{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Natural Language Processing with Python\n",
    "\n",
    "Feng Li\n",
    "\n",
    "School of Statistics and Mathematics\n",
    "\n",
    "Central University of Finance and Economics\n",
    "\n",
    "[feng.li@cufe.edu.cn](mailto:feng.li@cufe.edu.cn)\n",
    "\n",
    "[https://feng.li/python](https://feng.li/python)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Concepts in text processing (文本处理基本概念)\n",
    "\n",
    "## Corpora (语料库)\n",
    "\n",
    "Corpus is a large collection of texts. It is a body of written or spoken material upon which a linguistic analysis is based. A corpus provides grammarians, lexicographers, and other interested parties with better discriptions of a language. Computer-procesable corpora allow linguists to adopt the principle of total accountability, retrieving all the occurrences of a particular word or structure for inspection or randomly selcted samples. Corpus analysis provide lexical information, morphosyntactic information, semantic information and pragmatic information."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "\n",
    "## Tokens\n",
    "\n",
    "A token is the technical name for a sequence of characters, that we want to treat as a group. The vocabulary of a text is just the set of tokens that it uses, since in a set, all duplicates are collapsed together. In Python we can obtain the vocabulary items with the command: `set()`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Stopwords （停词）\n",
    "\n",
    "\n",
    "Stopwords are common words that generally do not contribute to the meaning of a sentence,\n",
    "at least for the purposes of information retrieval and natural language processing. These are\n",
    "words such as the and a. Most search engines will filter out stopwords from search queries\n",
    "and documents in order to save space in their index."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "\n",
    "## Stemming （词根检索）\n",
    "\n",
    "Stemming is a technique to remove affixes from a word, ending up with the stem. For\n",
    "example, the stem of cooking is cook , and a good stemming algorithm knows that the ing\n",
    "suffix can be removed. Stemming is most commonly used by search engines for indexing\n",
    "words. Instead of storing all forms of a word, a search engine can store only the stems, greatly\n",
    "reducing the size of index while increasing retrieval accuracy."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Frequency Counts （频数统计）\n",
    "\n",
    "Frequency Counts the number of hits. Frequency counts require finding all the occurences of a particular feature in the corpus. So it is implicit in concordancing. Software is used for this purpose. Frequency counts can be explained statistically. \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "\n",
    "## Word Segmenter （分词）\n",
    "\n",
    "Word segmentation is the problem of dividing a string of written language into its component words.\n",
    "\n",
    "In English and many other languages using some form of the Latin alphabet, the space is a good approximation of a word divider (word delimiter). (Some examples where the space character alone may not be sufficient include contractions like can't for can not.)\n",
    "\n",
    "However the equivalent to this character is not found in all written scripts, and without it word segmentation is a difficult problem. Languages which do not have a trivial word segmentation process include Chinese, Japanese, where sentences but not words are delimited, Thai and Lao, where phrases and sentences but not words are delimited, and Vietnamese, where syllables but not words are delimited."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Part-Of-Speech Tagger （词性标注工具）\n",
    "\n",
    "In corpus linguistics, part-of-speech tagging (POS tagging or POST), also called grammatical tagging or word-category disambiguation, is the process of marking up a word in a text (corpus) as corresponding to a particular part of speech, based on both its definition, as well as its context—i.e. relationship with adjacent and related words in a phrase, sentence, or paragraph. A simplified form of this is commonly taught to school-age children, in the identification of words as nouns, verbs, adjectives, adverbs, etc.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Named Entity Recognizer（命名实体识别工具）\n",
    "\n",
    "Named-entity recognition (NER) (also known as entity identification, entity chunking and entity extraction) is a subtask of information extraction that seeks to locate and classify elements in text into pre-defined categories such as the names of persons, organizations, locations, expressions of times, quantities, monetary values, percentages."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Natural Language Processing tools （自然语言处理工具）\n",
    "\n",
    "- Natural Language Toolkit\n",
    "\n",
    "    **NLTK** is a leading platform for building Python programs to work with human language data. It provides easy-to-use interfaces to over 50 corpora and lexical resources such as WordNet, along with a suite of text processing libraries for classification, tokenization, stemming, tagging, parsing, and semantic reasoning, wrappers for industrial-strength NLP libraries, and an active discussion forum.\n",
    "    \n",
    "    Natural Language Processing with Python provides a practical introduction to programming for language processing. Written by the creators of NLTK, it guides the reader through the fundamentals of writing Python programs, working with corpora, categorizing text, analyzing linguistic structure, and more. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "- Stanford Word Segmenter\n",
    "\n",
    "    Tokenization of raw text is a standard pre-processing step for many NLP tasks. For English, tokenization usually involves punctuation splitting and separation of some affixes like possessives. Other languages require more extensive token pre-processing, which is usually called segmentation.\n",
    "\n",
    "    The Stanford Word Segmenter currently supports Arabic and Chinese. The provided segmentation schemes have been found to work well for a variety of applications. \n",
    "    \n",
    "- NLP toolkits for Chinese\n",
    "\n",
    "    - [Toolkit for Chinese natural language processing](https://github.com/xpqiu/fnlp/)\n",
    "    \n",
    "    - [The ICT Natural Language Processing Research Group](http://nlp.ict.ac.cn/english/)\n",
    "    \n",
    "    - [Jieba Chinse Word Segmenter](https://github.com/fxsjy/jieba)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Tokenizing Text （标记文本）"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "\n",
    "- Before you use the NLTK library, please use the NLTK Downloader to obtain the resource.  The NLTK data will be downloaded in to the following director depending your OS.\n",
    "  \n",
    "  \n",
    "   ```\n",
    "   $HOME/nltk_data\n",
    "   /usr/share/nltk_data\n",
    "   /usr/local/share/nltk_data\n",
    "   /usr/lib/nltk_data\n",
    "   /usr/local/lib/nltk_data\n",
    "   /usr/nltk_data\n",
    "   /usr/lib/nltk_data\n",
    "   ```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[nltk_data] Downloading package punkt to /home/fli/nltk_data...\n",
      "[nltk_data]   Unzipping tokenizers/punkt.zip.\n",
      "[nltk_data] Downloading package stopwords to /home/fli/nltk_data...\n",
      "[nltk_data]   Unzipping corpora/stopwords.zip.\n",
      "[nltk_data] Downloading package treebank to /home/fli/nltk_data...\n",
      "[nltk_data]   Unzipping corpora/treebank.zip.\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import nltk\n",
    "nltk.download('punkt')\n",
    "nltk.download('stopwords')\n",
    "nltk.download('treebank')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Tokenizing text into sentences （断句）\n",
    "\n",
    "The `sent_tokenize()` function uses an instance of `PunktSentenceTokenizer` from the\n",
    "`nltk.tokenize.punkt` module. This instance has already been trained and works well for many European languages. So it knows what punctuation and characters mark the end of a sentence and the beginning of a new sentence."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "para = \"Python is a widely used general-purpose, high-level programming language. \\\n",
    "        Its design philosophy emphasizes code readability, and its syntax allows programmers \\\n",
    "        to express concepts in fewer lines of code than would be possible in languages such as \\\n",
    "        C++ or Java. The language provides constructs intended to enable clear programs \\\n",
    "        on both a small and large scale.\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Python is a widely used general-purpose, high-level programming language.',\n",
       " 'Its design philosophy emphasizes code readability, and its syntax allows programmers         to express concepts in fewer lines of code than would be possible in languages such as         C++ or Java.',\n",
       " 'The language provides constructs intended to enable clear programs         on both a small and large scale.']"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from nltk.tokenize import sent_tokenize\n",
    "sent_tokenize(para)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Tokenizing sentences into words （分词）"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Hello', 'World', '.']"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from nltk.tokenize import word_tokenize\n",
    "word_tokenize('Hello World.')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Python', 'is', 'a', 'widely', 'used', 'general-purpose', ',', 'high-level', 'programming', 'language', '.', 'Its', 'design', 'philosophy', 'emphasizes', 'code', 'readability', ',', 'and', 'its', 'syntax', 'allows', 'programmers', 'to', 'express', 'concepts', 'in', 'fewer', 'lines', 'of', 'code', 'than', 'would', 'be', 'possible', 'in', 'languages', 'such', 'as', 'C++', 'or', 'Java', '.', 'The', 'language', 'provides', 'constructs', 'intended', 'to', 'enable', 'clear', 'programs', 'on', 'both', 'a', 'small', 'and', 'large', 'scale', '.']\n"
     ]
    }
   ],
   "source": [
    "tok = word_tokenize(para)\n",
    "print(tok)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Tokenizing sentences using regular expressions （使用正则表达式分词）"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[\"Can't\", 'is', 'a', 'contraction']"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from nltk.tokenize import RegexpTokenizer\n",
    "tokenizer = RegexpTokenizer(\"[\\w']+\")\n",
    "tokenizer.tokenize(\"Can't is a contraction.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Filtering stopwords in a tokenized sentence （过滤停词）"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'at', 'be', 'yours', 'own', 'if', 'we', 'that', 'll', 'again', 'had', 'you', 'aren', 'their', 'in', 't', \"couldn't\", 'ain', 'an', 'which', 'from', \"mustn't\", 'can', \"mightn't\", 'i', 'more', 'yourselves', 'as', 'should', 'weren', 'the', 'but', 'very', 'until', 'just', 'with', 'wouldn', 'too', 'below', 'she', 'further', 'will', 'now', 'why', \"aren't\", 'than', 'do', 'have', 'to', \"don't\", \"hasn't\", \"you're\", 'this', 'did', \"won't\", 'won', 'and', 'him', 'am', 'other', 'it', 'hers', 've', 'wasn', 'off', 'they', 'above', 'them', \"haven't\", 'before', 'where', 'there', 'being', 'nor', 'our', 'who', 'been', 'by', 'some', 'has', 'only', 'on', 'd', 'through', 'm', 'is', 'didn', 'ourselves', 'theirs', 'does', 'about', 'needn', 'those', 'between', \"that'll\", 'or', 'under', 'no', 'shan', \"wasn't\", \"you'll\", 'not', \"hadn't\", 'both', 'himself', \"shouldn't\", 'out', 'mustn', 'hadn', 'during', 'don', 'while', 'same', 'so', 'whom', 'then', 'few', 'shouldn', 'for', 'of', 'hasn', 'such', 'how', 'are', 'doing', 'after', 'its', \"needn't\", 'most', 're', 'isn', \"shan't\", \"weren't\", 'up', \"isn't\", 'his', 'haven', 'down', 'itself', \"you've\", \"should've\", 'her', \"didn't\", 'my', 'because', 'themselves', 'all', \"doesn't\", 'having', 'here', 's', 'myself', \"wouldn't\", \"you'd\", \"it's\", 'once', 'herself', 'each', 'mightn', 'ours', 'over', 'into', 'when', 'your', 'was', 'these', 'o', 'were', 'a', 'me', 'he', \"she's\", 'any', 'doesn', 'what', 'against', 'y', 'couldn', 'ma', 'yourself'}\n"
     ]
    }
   ],
   "source": [
    "from nltk.corpus import stopwords\n",
    "english_stops = set(stopwords.words('english'))\n",
    "print(english_stops)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "words = [\"Can't\", 'is', 'a', 'contraction']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[\"Can't\", 'contraction']"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[word for word in words if word not in english_stops]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Replacing and Correcting Words （替换和纠正）"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Stemming （词干提取）\n",
    "\n",
    "One of the most common stemming algorithms is the **Porter stemming algorithm** by Martin\n",
    "Porter. It is designed to remove and replace well-known suffixes of English words"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'cook'"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from nltk.stem import PorterStemmer\n",
    "stemmer = PorterStemmer()\n",
    "stemmer.stem('cooking')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Removing repeating characters （删除重复字符）\n",
    "\n",
    "In everyday language, people are often not strictly grammatical. They will write things such as\n",
    "I looooooove it in order to emphasize the word love . However, computers don't know\n",
    "that \"looooooove\" is a variation of \"love\" unless they are told. This recipe presents a method\n",
    "to remove these annoying repeating characters in order to end up with a proper English word."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "import re\n",
    "from nltk.corpus import wordnet\n",
    "\n",
    "replacement_patterns = [\n",
    "    (r'won\\'t', 'will not'),\n",
    "    (r'can\\'t', 'cannot'),\n",
    "    (r'i\\'m', 'i am'),\n",
    "    (r'ain\\'t', 'is not'),\n",
    "    (r'(\\w+)\\'ll', '\\g<1> will'),\n",
    "    (r'(\\w+)n\\'t', '\\g<1> not'),\n",
    "    (r'(\\w+)\\'ve', '\\g<1> have'),\n",
    "    (r'(\\w+)\\'s', '\\g<1> is'),\n",
    "    (r'(\\w+)\\'re', '\\g<1> are'),\n",
    "    (r'(\\w+)\\'d', '\\g<1> would')\n",
    "]\n",
    "\n",
    "class RegexpReplacer(object):\n",
    "    \n",
    "    def __init__(self, patterns=replacement_patterns):\n",
    "        self.patterns = [(re.compile(regex), repl) for (regex, repl) in\n",
    "                         patterns]\n",
    "        \n",
    "    def replace(self, text):\n",
    "        s = text\n",
    "        for (pattern, repl) in self.patterns:\n",
    "            (s, count) = re.subn(pattern, repl, s)\n",
    "        return s\n",
    "    \n",
    "class RepeatReplacer(object):\n",
    "    \n",
    "    def __init__(self):\n",
    "        self.repeat_regexp = re.compile(r'(\\w*)(\\w)\\2(\\w*)')\n",
    "        self.repl = r'\\1\\2\\3'\n",
    "        \n",
    "    def replace(self, word):\n",
    "        if wordnet.synsets(word):\n",
    "            return word\n",
    "        repl_word = self.repeat_regexp.sub(self.repl, word)\n",
    "        if repl_word != word:\n",
    "            return self.replace(repl_word)\n",
    "        else:\n",
    "            return repl_word"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Spelling correction （拼写纠正）"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Replacing synonyms （同义词替换）\n",
    "\n",
    "It is often useful to reduce the vocabulary of a text by replacing words with common\n",
    "synonyms. By compressing the vocabulary without losing meaning, you can save memory\n",
    "in cases such as frequency analysis and text indexing. Vocabulary reduction\n",
    "can also increase the occurrence of significant collocations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Part-of-speech Tagging （词性标注工具）\n",
    "\n",
    "## Training a unigram part-of-speech tagger\n",
    "\n",
    "A unigram generally refers to a single token. Therefore, a unigram tagger only uses a single\n",
    "word as its context for determining the part-of-speech tag."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Pierre',\n",
       " 'Vinken',\n",
       " ',',\n",
       " '61',\n",
       " 'years',\n",
       " 'old',\n",
       " ',',\n",
       " 'will',\n",
       " 'join',\n",
       " 'the',\n",
       " 'board',\n",
       " 'as',\n",
       " 'a',\n",
       " 'nonexecutive',\n",
       " 'director',\n",
       " 'Nov.',\n",
       " '29',\n",
       " '.']"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from nltk.tag import UnigramTagger\n",
    "from nltk.corpus import treebank\n",
    "train_sents = treebank.tagged_sents()[:3000]\n",
    "tagger = UnigramTagger(train_sents)\n",
    "treebank.sents()[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('Pierre', 'NNP'),\n",
       " ('Vinken', 'NNP'),\n",
       " (',', ','),\n",
       " ('61', 'CD'),\n",
       " ('years', 'NNS'),\n",
       " ('old', 'JJ'),\n",
       " (',', ','),\n",
       " ('will', 'MD'),\n",
       " ('join', 'VB'),\n",
       " ('the', 'DT'),\n",
       " ('board', 'NN'),\n",
       " ('as', 'IN'),\n",
       " ('a', 'DT'),\n",
       " ('nonexecutive', 'JJ'),\n",
       " ('director', 'NN'),\n",
       " ('Nov.', 'NNP'),\n",
       " ('29', 'CD'),\n",
       " ('.', '.')]"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tagger.tag(treebank.sents()[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Word Clouds\n",
    "\n",
    "One approach to visualizing words and counts is word clouds, which artistically lay out the words with sizes proportional to their counts.\n",
    "\n",
    "Generally, though, data scientists don’t think much of word clouds, in large part\n",
    "because the placement of the words doesn’t mean anything other than “here’s some\n",
    "space where I was able to fit a word.”\n",
    "\n",
    "If you ever are forced to create a word cloud, think about whether you can make the\n",
    "axes convey something. For example, imagine that, for each of some collection of data\n",
    "science–related buzzwords, you have two numbers between 0 and 100—the first rep‐\n",
    "resenting how frequently it appears in job postings, the second how frequently it\n",
    "appears on resumes:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt \n",
    "\n",
    "\n",
    "def plot_resumes(plt):\n",
    "    data = [ (\"big data\", 100, 15), (\"Hadoop\", 95, 25), (\"Python\", 75, 50),\n",
    "         (\"R\", 50, 40), (\"machine learning\", 80, 20), (\"statistics\", 20, 60),\n",
    "         (\"data science\", 60, 70), (\"analytics\", 90, 3),\n",
    "         (\"team player\", 85, 85), (\"dynamic\", 2, 90), (\"synergies\", 70, 0),\n",
    "         (\"actionable insights\", 40, 30), (\"think out of the box\", 45, 10),\n",
    "         (\"self-starter\", 30, 50), (\"customer focus\", 65, 15),\n",
    "         (\"thought leadership\", 35, 35)]\n",
    "\n",
    "    def text_size(total):\n",
    "        \"\"\"equals 8 if total is 0, 28 if total is 200\"\"\"\n",
    "        return 8 + total / 200 * 20\n",
    "\n",
    "    for word, job_popularity, resume_popularity in data:\n",
    "        plt.text(job_popularity, resume_popularity, word,\n",
    "                 ha='center', va='center',\n",
    "                 size=text_size(job_popularity + resume_popularity))\n",
    "    plt.xlabel(\"Popularity on Job Postings\")\n",
    "    plt.ylabel(\"Popularity on Resumes\")\n",
    "    plt.axis([0, 100, 0, 100])\n",
    "    plt.show()\n",
    "    \n",
    "\n",
    "plot_resumes(plt)  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Text Classification （文本分类）\n",
    "\n",
    "All are statistics!"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.10.9"
  },
  "rise": {
   "auto_select": "first",
   "autolaunch": false,
   "enable_chalkboard": true,
   "start_slideshow_at": "selected",
   "theme": "black"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": false,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}