17_Vocabulary_and_Matching.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "kernelspec": {
      "display_name": "Python 3",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.6.9"
    },
    "colab": {
      "name": "06_Vocabulary_and_Matching.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "toc_visible": true
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "j581rMA_UX95",
        "colab_type": "text"
      },
      "source": [
        "# Vocabulary and Matching\n",
        "So far we've seen how a body of text is divided into tokens, and how individual tokens are parsed and tagged with parts of speech, dependencies and lemmas.\n",
        "\n",
        "In this section we will identify and label specific phrases that match patterns we can define ourselves. "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "98ZF9yj1UX96",
        "colab_type": "text"
      },
      "source": [
        "## Rule-based Matching\n",
        "spaCy offers a rule-matching tool called `Matcher` that allows you to build a library of token patterns, then match those patterns against a Doc object to return a list of found matches. You can match on any part of the token including text and annotations, and you can add multiple patterns to the same matcher."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "we5xa7JTUX9-",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Perform standard imports\n",
        "import spacy\n",
        "nlp = spacy.load('en_core_web_sm')"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8_f7hedZUX-E",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Import the Matcher library\n",
        "from spacy.matcher import Matcher\n",
        "matcher = Matcher(nlp.vocab)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oqw7SLMOUX-I",
        "colab_type": "text"
      },
      "source": [
        "<font color=green>Here `matcher` is an object that pairs to the current `Vocab` object. We can add and remove specific named matchers to `matcher` as needed.</font>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "p87LnVqsUX-J",
        "colab_type": "text"
      },
      "source": [
        "### Creating patterns\n",
        "In literature, the phrase 'solar power' might appear as one word or two, with or without a hyphen. In this section we'll develop a matcher named 'SolarPower' that finds all three:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "EZiWwexnUX-K",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "pattern1=[{'LOWER': 'solarpower'}]\n",
        "pattern2 = [{'LOWER': 'solar'},{'Lower':'power'}]\n",
        "pattern3=[{'LOWER': 'solar'},{'Lower':'power'}, {'IS_PUNCT':True}]\n",
        "\n",
        "matcher.add('Solarpower', None, pattern1,pattern2,pattern3)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2SH0yWAxUX-R",
        "colab_type": "text"
      },
      "source": [
        "Let's break this down:\n",
        "* `pattern1` looks for a single token whose lowercase text reads 'solarpower'\n",
        "* `pattern2` looks for two adjacent tokens that read 'solar' and 'power' in that order\n",
        "* `pattern3` looks for three adjacent tokens, with a middle token that can be any punctuation.<font color=green>*</font>\n",
        "\n",
        "<font color=green>\\* Remember that single spaces are not tokenized, so they don't count as punctuation.</font>\n",
        "<br>Once we define our patterns, we pass them into `matcher` with the name 'SolarPower', and set *callbacks* to `None` (more on callbacks later)."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CI69pbIJUX-S",
        "colab_type": "text"
      },
      "source": [
        "### Applying the matcher to a Doc object"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KH797-fvUX-T",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "doc = nlp(u'The Solar Power industry continues to grow as demand \\\n",
        "for solarpower increases. Solar-power cars are gaining popularity.')\n",
        "\n",
        "  "
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4AvOXuMWUX-X",
        "colab_type": "code",
        "outputId": "2ee91fba-bfd5-4738-adfb-fe5ab402b555",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "print(matcher(doc))\n",
        "found_matches= matcher(doc)"
      ],
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[(6544436658971563323, 1, 3), (6544436658971563323, 10, 11)]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "n6kGzmp9UX-b",
        "colab_type": "text"
      },
      "source": [
        "`matcher` returns a list of tuples. Each tuple contains an ID for the match, with start & end tokens that map to the span `doc[start:end]`"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5iJklP7OUX-e",
        "colab_type": "code",
        "outputId": "4a373ac8-5370-4914-936f-2b8c078a1026",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 50
        }
      },
      "source": [
        "for match_id, start, end in found_matches:\n",
        "  string_id=nlp.vocab.strings[match_id]\n",
        "  span=doc[start:end]\n",
        "  print(match_id, string_id, start, end, span.text)"
      ],
      "execution_count": 18,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "6544436658971563323 Solarpower 1 3 Solar Power\n",
            "6544436658971563323 Solarpower 10 11 solarpower\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GkDHOtbJUX-k",
        "colab_type": "text"
      },
      "source": [
        "The `match_id` is simply the hash value of the `string_ID` 'SolarPower'"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NMkn3teeUX-l",
        "colab_type": "text"
      },
      "source": [
        "### Setting pattern options and quantifiers\n",
        "You can make token rules optional by passing an `'OP':'*'` argument. This lets us streamline our patterns list:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Xf2wy6NYUX-m",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Redefine the patterns:\n",
        "\n",
        "# Remove the old patterns to avoid duplication:\n",
        "\n",
        "# Add the new set of patterns to the 'SolarPower' matcher:"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NeuIJWUuUX-q",
        "colab_type": "code",
        "outputId": "37b476e3-d003-432d-c0bf-98249c8123b4",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[(8656102463236116519, 1, 3), (8656102463236116519, 10, 11), (8656102463236116519, 13, 16)]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-MkM1IzuUX-v",
        "colab_type": "text"
      },
      "source": [
        "This found both two-word patterns, with and without the hyphen!\n",
        "\n",
        "The following quantifiers can be passed to the `'OP'` key:\n",
        "<table><tr><th>OP</th><th>Description</th></tr>\n",
        "\n",
        "<tr ><td><span >\\!</span></td><td>Negate the pattern, by requiring it to match exactly 0 times</td></tr>\n",
        "<tr ><td><span >?</span></td><td>Make the pattern optional, by allowing it to match 0 or 1 times</td></tr>\n",
        "<tr ><td><span >\\+</span></td><td>Require the pattern to match 1 or more times</td></tr>\n",
        "<tr ><td><span >\\*</span></td><td>Allow the pattern to match zero or more times</td></tr>\n",
        "</table>\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HOwPPP4kUX-x",
        "colab_type": "text"
      },
      "source": [
        "### Be careful with lemmas!\n",
        "If we wanted to match on both 'solar power' and 'solar powered', it might be tempting to look for the *lemma* of 'powered' and expect it to be 'power'. This is not always the case! The lemma of the *adjective* 'powered' is still 'powered':"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "18lKwEauUX-x",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "pattern1 = [{'LOWER': 'solarpower'}]\n",
        "pattern2 = [{'LOWER': 'solar'}, {'IS_PUNCT': True, 'OP':'*'}, {'LEMMA': 'power'}] # CHANGE THIS PATTERN\n",
        "\n",
        "# Remove the old patterns to avoid duplication:\n",
        "matcher.remove('Solarpower')\n",
        "# Add the new set of patterns to the 'SolarPower' matcher:\n",
        "matcher.add('SolarPower', None, pattern1,pattern2,pattern3)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lGsf97xhUX-0",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "doc2 = nlp(u'Solar-powered energy runs solar-powered cars.')"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GtOv1hp8UX-2",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "found_matches=matcher(doc)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PyeaiUP1UX-6",
        "colab_type": "text"
      },
      "source": [
        "<font color=green>The matcher found the first occurrence because the lemmatizer treated 'Solar-powered' as a verb, but not the second as it considered it an adjective.<br>For this case it may be better to set explicit token patterns.</font>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "25rTqp43UX-7",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Redefine the patterns\n",
        "\n",
        "# Remove the old patterns to avoid duplication:\n",
        "\n",
        "# Add the new set of patterns to the 'SolarPower' matcher:"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Ntj4MPmeUX-_",
        "colab_type": "code",
        "outputId": "14fdb066-bd46-4020-ee6a-8787cf15ecc5",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "found_matches = matcher(doc2)\n",
        "print(found_matches)"
      ],
      "execution_count": 22,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[(8656102463236116519, 0, 3), (8656102463236116519, 5, 8)]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9LkUTClVUX_D",
        "colab_type": "text"
      },
      "source": [
        "## Other token attributes\n",
        "Besides lemmas, there are a variety of token attributes we can use to determine matching rules:\n",
        "<table><tr><th>Attribute</th><th>Description</th></tr>\n",
        "\n",
        "<tr ><td><span >`ORTH`</span></td><td>The exact verbatim text of a token</td></tr>\n",
        "<tr ><td><span >`LOWER`</span></td><td>The lowercase form of the token text</td></tr>\n",
        "<tr ><td><span >`LENGTH`</span></td><td>The length of the token text</td></tr>\n",
        "<tr ><td><span >`IS_ALPHA`, `IS_ASCII`, `IS_DIGIT`</span></td><td>Token text consists of alphanumeric characters, ASCII characters, digits</td></tr>\n",
        "<tr ><td><span >`IS_LOWER`, `IS_UPPER`, `IS_TITLE`</span></td><td>Token text is in lowercase, uppercase, titlecase</td></tr>\n",
        "<tr ><td><span >`IS_PUNCT`, `IS_SPACE`, `IS_STOP`</span></td><td>Token is punctuation, whitespace, stop word</td></tr>\n",
        "<tr ><td><span >`LIKE_NUM`, `LIKE_URL`, `LIKE_EMAIL`</span></td><td>Token text resembles a number, URL, email</td></tr>\n",
        "<tr ><td><span >`POS`, `TAG`, `DEP`, `LEMMA`, `SHAPE`</span></td><td>The token's simple and extended part-of-speech tag, dependency label, lemma, shape</td></tr>\n",
        "<tr ><td><span >`ENT_TYPE`</span></td><td>The token's entity label</td></tr>\n",
        "\n",
        "</table>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-gbt1l9fUX_E",
        "colab_type": "text"
      },
      "source": [
        "### Token wildcard\n",
        "You can pass an empty dictionary `{}` as a wildcard to represent **any token**. For example, you might want to retrieve hashtags without knowing what might follow the `#` character:\n",
        ">`[{'ORTH': '#'}, {}]`"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KChALQlFUX_F",
        "colab_type": "text"
      },
      "source": [
        "___\n",
        "## PhraseMatcher\n",
        "In the above section we used token patterns to perform rule-based matching. An alternative - and often more efficient - method is to match on terminology lists. In this case we use PhraseMatcher to create a Doc object from a list of phrases, and pass that into `matcher` instead."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "y44pg0NNUX_G",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Perform standard imports, reset nlp\n",
        "import spacy\n",
        "nlp = spacy.load('en_core_web_sm')"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "es7sO7nXUX_J",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Import the PhraseMatcher library\n",
        "from spacy.matcher import PhraseMatcher\n",
        "matcher = PhraseMatcher(nlp.vocab)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pgvBRbtkUX_O",
        "colab_type": "text"
      },
      "source": [
        "For this exercise we're going to import a Wikipedia article on *Reaganomics*<br>\n",
        "Source: https://en.wikipedia.org/wiki/Reaganomics"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "skjrJtifUX_S",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# If you are using google colab, upload the text file using the left panel -> Files tab and then execute this cell\n",
        "with open('reaganomics.txt', encoding='utf-8', errors='ignore') as f:\n",
        "    doc3 = nlp(f.read())\n",
        "\n",
        "doc3    "
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2WnyPM5RUX_a",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# First, create a list of match phrases:\n",
        "pharse_list=['voodoo economics', 'supply-side economics', 'Trickle-down Economics']\n",
        "# Next, convert each phrase to a Doc object:\n",
        "pharse_patterns=[nlp(text) for text in pharse_list]\n",
        "# Pass each Doc object into matcher (note the use of the asterisk!):\n",
        "matcher.add('VoodooEconomics',None, *pharse_patterns)\n",
        "# Build a list of matches:\n",
        "matches=matcher(doc3)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OzVbLxLZUX_g",
        "colab_type": "code",
        "outputId": "a79b1f00-de23-484e-af39-f5e92ec56e16",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 101
        }
      },
      "source": [
        "# (match_id, start, end)\n",
        "matches"
      ],
      "execution_count": 42,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[(3473369816841043438, 41, 45),\n",
              " (3473369816841043438, 49, 53),\n",
              " (3473369816841043438, 54, 56),\n",
              " (3473369816841043438, 673, 677),\n",
              " (3473369816841043438, 2984, 2988)]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 42
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fxKRO4c6UX_k",
        "colab_type": "text"
      },
      "source": [
        "<font color=green>The first four matches are where these terms are used in the definition of Reaganomics:</font>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2Hu1wt0DUX_l",
        "colab_type": "code",
        "outputId": "562a3a30-2c95-47ed-de7a-13f5d8d113e1",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 373
        }
      },
      "source": [
        "doc3[:685]"
      ],
      "execution_count": 50,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "REAGANOMICS\n",
              "https://en.wikipedia.org/wiki/Reaganomics\n",
              "\n",
              "Reaganomics (a portmanteau of [Ronald] Reagan and economics attributed to Paul Harvey)[1] refers to the economic policies promoted by U.S. President Ronald Reagan during the 1980s. These policies are commonly associated with supply-side economics, referred to as trickle-down economics or voodoo economics by political opponents, and free-market economics by political advocates.\n",
              "\n",
              "The four pillars of Reagan's economic policy were to reduce the growth of government spending, reduce the federal income tax and capital gains tax, reduce government regulation, and tighten the money supply in order to reduce inflation.[2]\n",
              "\n",
              "The results of Reaganomics are still debated. Supporters point to the end of stagflation, stronger GDP growth, and an entrepreneur revolution in the decades that followed.[3][4] Critics point to the widening income gap, an atmosphere of greed, and the national debt tripling in eight years which ultimately reversed the post-World War II trend of a shrinking national debt as percentage of GDP.[5][6]\n",
              "\n",
              "HISTORICAL CONTEXT\n",
              "\n",
              "Prior to the Reagan administration, the United States economy experienced a decade of high unemployment and persistently high inflation (known as stagflation). Attacks on Keynesian economic orthodoxy as well as empirical economic models such as the Phillips Curve grew. Political pressure favored stimulus resulting in an expansion of the money supply. President Richard Nixon's wage and price controls were phased out.[7] The federal oil reserves were created to ease any future short term shocks. President Jimmy Carter had begun phasing out price controls on petroleum while he created the Department of Energy. Much of the credit for the resolution of the stagflation is given to two causes: a three-year contraction of the money supply by the Federal Reserve Board under Paul Volcker, initiated in the last year of Carter's presidency, and long-term easing of supply and pricing in oil during the 1980s oil glut.[citation needed]\n",
              "\n",
              "In stating that his intention was to lower taxes, Reagan's approach was a departure from his immediate predecessors. Reagan enacted lower marginal tax rates as well as simplified income tax codes and continued deregulation. During Reagan's eight year presidency, the annual deficits averaged 4.0% of GDP, compared to a 2.2% average during the preceding eight years.[8] The real (inflation adjusted) average rate of growth in federal spending fell from 4% under Jimmy Carter to 2.5% under Ronald Reagan.[9][10] GDP per employed person increased at an average 1.5% rate during the Reagan administration, compared to an average 0.6% during the preceding eight years.[11] Private sector productivity growth, measured as real output per hour of all persons, increased at an average rate of 1.9% during Reagan's eight years, compared to an average 1.3% during the preceding eight years.[12] Federal net outlays as a percent of GDP averaged 21.4% under Reagan, compared to 19.1% during the preceding eight years.[13]\n",
              "\n",
              "During the Nixon and Ford Administrations, before Reagan's election, a combined supply and demand side policy was considered unconventional by the moderate wing of the Republican Party. While running against Reagan for the Presidential nomination in 1980, George H. W. Bush had derided Reaganomics as \"voodoo economics\".[14] Similarly, in 1976, Gerald Ford had severely criticized Reagan's proposal to turn back a large part of the Federal budget to the states.\n",
              "\n",
              "JUSTIFICATIONS\n",
              "\n",
              "In his 1980 campaign speeches, Reagan presented his economic proposals as a return to the free enterprise principles, free market economy that had been in favor before the Great Depression and FDR's New Deal policies. At the same time he attracted a following from the supply-side economics movement, which formed in opposition to Keynesian"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 50
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ALODVyM5UX_n",
        "colab_type": "text"
      },
      "source": [
        "## Viewing Matches\n",
        "There are a few ways to fetch the text surrounding a match. The simplest is to grab a slice of tokens from the doc that is wider than the match:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NUxzCDr6UX_o",
        "colab_type": "code",
        "outputId": "c6464a64-0416-4052-9538-af25e432baae",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "doc3[665:685]  # Note that the fifth match starts at doc3[673]"
      ],
      "execution_count": 45,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "same time he attracted a following from the supply-side economics movement, which formed in opposition to Keynesian"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 45
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1em3ezFVUX_s",
        "colab_type": "code",
        "outputId": "88947c9b-66e8-4e78-b006-f484b090cdca",
        "colab": {}
      },
      "source": [
        "doc3[2975:2995]  # The sixth match starts at doc3[2985]"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "against institutions.[66] His policies became widely known as \"trickle-down economics\", due to the significant"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 21
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "X2wdP4y_UX_u",
        "colab_type": "text"
      },
      "source": [
        "Another way is to first apply the `sentencizer` to the Doc, then iterate through the sentences to the match point:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0GlrI4moUX_u",
        "colab_type": "code",
        "outputId": "b5d5538f-0dc2-4733-8d77-04e88518ac1e",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "# Build a list of sentences\n",
        "sents= [sent for sent in doc3.sents]\n",
        "# In the next section we'll see that sentences contain start and end token values:\n",
        "print(sents[0].start, sents[0].end)"
      ],
      "execution_count": 47,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "0 35\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_ewJxfJ-UX_z",
        "colab_type": "code",
        "outputId": "7d92c1b2-2f3b-4128-a4a4-bbf90641c821",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 121
        }
      },
      "source": [
        "# Iterate over the sentence list until the sentence end value exceeds a match start value:\n",
        "for sent in sents:\n",
        "  if matches[4][1]< sent.end:\n",
        "    print(sent)\n",
        "    break"
      ],
      "execution_count": 52,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "His policies became widely known as \"trickle-down economics\", due to the significant cuts in the upper tax brackets, as that extra money for the wealthy could trickle along to low-income groups.[67]\n",
            "\n",
            "Federal income tax and payroll tax levels\n",
            "\n",
            "During the Reagan administration, fiscal year federal receipts grew from $599 billion to $991 billion (an increase of 65%) while fiscal year federal outlays grew from $678 billion to $1144 billion (an increase of 69%).[68][69]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EQK0GMBEUX_1",
        "colab_type": "text"
      },
      "source": [
        "For additional information visit https://spacy.io/usage/linguistic-features#section-rule-based-matching\n",
        "## Next Up: NLP Basics Assessment"
      ]
    }
  ]
}