From 9e3a54aaa265f1cfa47314eff3bc7e679ddde458 Mon Sep 17 00:00:00 2001 From: fuqiongying <3047530642@qq.com> Date: Sat, 30 Mar 2024 23:31:32 +0800 Subject: [PATCH 1/6] nlp improve --- open-machine-learning-jupyter-book/_toc.yml | 7 +- ...beginner-guide-to-text-preprocessing.ipynb | 613 ++++++++++ .../nlp/news-topic-classification-tasks.ipynb | 505 ++++++++ .../deep-learning/{ => nlp}/nlp.ipynb | 130 +- .../nlp/text-preprocessing.ipynb | 510 ++++++++ .../nlp/text-representation.ipynb | 1071 +++++++++++++++++ 6 files changed, 2718 insertions(+), 118 deletions(-) create mode 100644 open-machine-learning-jupyter-book/assignments/deep-learning/nlp/beginner-guide-to-text-preprocessing.ipynb create mode 100644 open-machine-learning-jupyter-book/assignments/deep-learning/nlp/news-topic-classification-tasks.ipynb rename open-machine-learning-jupyter-book/deep-learning/{ => nlp}/nlp.ipynb (87%) create mode 100644 open-machine-learning-jupyter-book/deep-learning/nlp/text-preprocessing.ipynb create mode 100644 open-machine-learning-jupyter-book/deep-learning/nlp/text-representation.ipynb diff --git a/open-machine-learning-jupyter-book/_toc.yml b/open-machine-learning-jupyter-book/_toc.yml index 6a4456061..a09d32cd1 100644 --- a/open-machine-learning-jupyter-book/_toc.yml +++ b/open-machine-learning-jupyter-book/_toc.yml @@ -106,7 +106,10 @@ parts: - file: deep-learning/object-detection.ipynb - file: deep-learning/image-classification.ipynb - file: deep-learning/image-segmentation.ipynb - - file: deep-learning/nlp.ipynb + - file: deep-learning/nlp/nlp.ipynb + sections: + - file: deep-learning/nlp/text-preprocessing.ipynb + - file: deep-learning/nlp/text-representation.ipynb - file: deep-learning/gan.ipynb - file: deep-learning/difussion-model.ipynb - file: deep-learning/dqn.ipynb @@ -232,6 +235,8 @@ parts: - file: assignments/deep-learning/object-detection/car-object-detection - file: assignments/deep-learning/overview/basic-classification-classify-images-of-clothing - file: assignments/deep-learning/nlp/getting-start-nlp-with-classification-task + - file: assignments/deep-learning/nlp/beginner-guide-to-text-preprocessing + - file: assignments/deep-learning/nlp/news-topic-classification-tasks - file: slides/introduction sections: - file: slides/python-programming/python-programming-introduction diff --git a/open-machine-learning-jupyter-book/assignments/deep-learning/nlp/beginner-guide-to-text-preprocessing.ipynb b/open-machine-learning-jupyter-book/assignments/deep-learning/nlp/beginner-guide-to-text-preprocessing.ipynb new file mode 100644 index 000000000..308414b0f --- /dev/null +++ b/open-machine-learning-jupyter-book/assignments/deep-learning/nlp/beginner-guide-to-text-preprocessing.ipynb @@ -0,0 +1,613 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Beginner’s Guide to Text Pre-Processing" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Natural Language Processing is a subdomain under Artificial Intelligence which deals with processing natural language data like text and speech. We can also term NLP as the “Art of extracting information from texts”. Recently there has been a lot of activity in this field and amazing research coming out every day! But, the revolutionary research was the “Transformer” which opened up avenues to build massive Deep Learning models which can come very close to human-level tasks like Summarization and Question Answering. Then came the GPTs and BERTs which were massive models consisting of billions of computation parameters trained on very huge datasets and can be fine-tuned to a variety of NLP tasks and problem statements.\n", + "\n", + "Deep down, the roots of building a robust NLP model, Text Processing, plays a very important role. This might not be very evident in the recent models like BERT and GPT, but it is one of the most elementary processes in Natural Language Processing. All NLP researchers and enthusiasts will have done Text Processing more times than not while attempting to solve problems in this domain. For a beginner, Text Processing is a fundamental concept to be nailed before setting sights on solving advanced problems. This brings to a question - Why Text Processing?" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Why Text Pre-processing?" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Text Pre-processing is important because language models are quite complex and there might be unnecessary data in the text corpus which might add to an ambiguity factor in the dataset, make it more computationally intensive and also impact the accuracy to a pretty considerable extent. \n", + "\n", + "Text Pre-processing is important because language models are quite complex, largely due to grammar rules. Unnecessary data in non-processed datasets will only add to ambiguity, increase computation requirements, and impact the accuracy of the model to a considerable extent.\n", + "\n", + "Moreover, we have to get the text transformed into vectors/numbers which can be ingested by machines or computers. This process is called Encoding Technique and we have many techniques like CountVectorizer, Tf-Idf Vectorizer, Bag of Words, Word2Vec, GLoVe, etc. Popularly this process is also known as Text Representation. This comes after the Text Pre-Processing. We shall look into these techniques in the next article 🙂\n", + "\n", + "Coming back to Text Pre-processing, let us look into a few popular Text Pre-processing methods in NLP." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Downloading Packages" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We will use the most popular library in processing textual data - NLTK (Natural Language Toolkit). On top of downloading and loading the base NLTK library we have to download a few additional files for our Pre-Processing techniques. The code is shown below:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "!pip install nltk\n", + "\n", + "import nltk\n", + "nltk.download('punkt')\n", + "nltk.download('wordnet')\n", + "nltk.download('stopwords')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Note: All code examples can be executed on Colab exactly the way it is shown in the articles.\n", + "\n", + "Once that is done, we can start doing different pre-processing activities, a few of which are listed below. At the end, we will bundle all of these pre-processing techniques into a function, making it very easy to use and even add that into a sequence with other pre-processing techniques." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Removing Accented Characters" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This will be our first pre-processing technique, which involves removing unaccented characters like é, â etc. These characters won’t be adding any meaning if included in the sentence. We can use the library - unicodedata to replace the unaccented characters with normal characters." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'cafe'" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import unicodedata\n", + "\n", + "def remove_accented_chars(text):\n", + " text = unicodedata.normalize('NFKD', text).encode('ascii', 'ignore').decode('utf-8', 'ignore')\n", + " \n", + " return text\n", + "\n", + "remove_accented_chars('résumé')\n", + "# Result - 'resume'\n", + "\n", + "remove_accented_chars('café')\n", + "# Result - 'cafe'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Removing Special & Non-Alphanumeric Characters" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Next step is to take care of special symbols, numbers and non-alphanumeric characters like #, @, $ etc. We can remove these characters easily using regular expressions." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'ElonMusk is revolutionizing the Space industry especially the aspect of Reusable rockets'" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import re\n", + "\n", + "def remove_special_characters(text):\n", + " pattern = r'[^a-zA-Z\\s]'\n", + " n_pattern = r'[^a-zA-Z0-9\\s]'\n", + " # Removing everything apart from alphanumerical chars\n", + " text = re.sub(pattern, '', text)\n", + " # Removing numbers\n", + " text = re.sub(n_pattern, '', text)\n", + " return text\n", + "\n", + "remove_special_characters('The brown fox is quick and the blue dog is lazy!')\n", + "# Result - The brown fox is quick and the blue dog is lazy\n", + "\n", + "remove_special_characters('@ElonMusk is revolutionizing the Space industry, especially the aspect of Reusable rockets!!!')\n", + "# Result - ElonMusk is revolutionizing the Space industry especially the aspect of Reusable rockets" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Note: Removing numbers may or may not be feasible based on the scenario of the problem statement. Therefore, removing numbers is solely based on the dataset and the problem statement." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Converting to Lowercase" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This is an important and compulsory step in Pre-processing text. If we consider the words “Banana” and “banana”, both convey the same meaning, but are represented differently and are treated as unique words by the encoder (which converts text to vectors). To combat this, we can simply convert the entire corpus to lower case to make sure every word or token (in NLP jargon) is in the same configuration which makes it easier to process and represent it in an effective manner.\n", + "\n", + "We can achieve this by simply using the lower() method on the string and further use strip() method to remove any white spaces too." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'hi there, how are you?'" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "def to_lower(text):\n", + " return text.lower().strip()\n", + "\n", + "to_lower('Hi there, How are you?')\n", + "# Result - hi there, how are you?" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Removing Punctuation" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Punctuation is an added weight to the corpus, but is very important in conveying the semantic meaning of the sentence. However, we can go ahead and remove them as one of the pre-processing techniques. Advanced encoding techniques like Word Embeddings (covered in a later post) can model the corpus without any punctuation." + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'We were though we had rushed to get there late for the film Thank you I said'" + ] + }, + "execution_count": 26, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import string\n", + "\n", + "def remove_p(text):\n", + "\n", + " text = text.translate(str.maketrans('', '', string.punctuation))\n", + " text = re.sub('[''\"\"…]', '', text)\n", + " text = re.sub('\\n', '', text)\n", + "\n", + " return text\n", + "\n", + "remove_p('We were , though we had rushed to get there, late for the film. ''Thank you'', I said')\n", + "# Result - We were though we had rushed to get there late for the film. Thank you I said" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Note: Punctuation were not removed in the more advanced GPTs & BERTs as the models were powerful enough to process and model sentences as it is without any pre-processing." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Tokenization" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This is a very small step which converts a sentence into tokens or words. If the input is a string (sentence) the output will be the list of words/tokens in that sentence. The official definition of a token is - ”A sequence of characters which are grouped together as a useful semantic term for analyzing”. To put it in simple words, they are nothing but the smallest meaningful entities of a sentence. Here, we use NLTK’s function word_tokenize(). Tokenization is important to apply the next steps  -  Stopword Removal, Stemming and Lemmatization." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['She', 'sells', 'sea', 'shells', 'on', 'the', 'sea', 'shore']" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import nltk\n", + "\n", + "def tokenization(text):\n", + " tokens = nltk.word_tokenize(text)\n", + " return tokens\n", + "\n", + "tokenization('She sells sea shells on the sea shore')\n", + "# Result - ['She','sells','sea','shells','on','the','sea','shore']" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "There is an alternative for nltk.word_tokenize i.e. tensorflow’s text_to_word_sequence which gives the same output as NLTK’s word_tokenize" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['she', 'sells', 'sea', 'shells', 'on', 'the', 'sea', 'shore']" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from tensorflow.keras.preprocessing.text import text_to_word_sequence\n", + "\n", + "text_to_word_sequence('She sells sea shells on the sea shore')\n", + "#Result - ['She','sells','sea','shells','on','the','sea','shore']" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Stopword Removal" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Stopwords are the words which are most common like I, am, there, where etc. They usually don’t help in certain NLP tasks and are best removed to save computation and time. Common methodology in earlier times was to remove the stopwords. However, in the age of GPT and BERT, we don’t usually remove the stopwords." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['brown', 'fox', 'quick', 'blue', 'dog', 'lazy']" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from nltk.corpus import stopwords\n", + "\n", + "STOPWORDS = stopwords.words('english')\n", + "def remove_stopwords(tokens):\n", + "\n", + " filtered_tokens = [token for token in tokens if token not in STOPWORDS]\n", + " return filtered_tokens\n", + "\n", + "remove_stopwords(['the', 'brown', 'fox', 'is', 'quick', 'and', 'the', 'blue', 'dog', 'is', 'lazy'])\n", + "#Result - ['brown', 'fox', 'quick', 'blue', 'dog', 'lazy']\n", + "\n", + "# We can also print all the stopwords present in NLTK configuration by print(stopwords.words('english'))\n", + "\n", + "# Also we have an option to modify the set of stopwords for our custom scenario by the following methods stopwords.remove() and stopwords.add()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Note: You can try out both approaches for creating the corpus — Removing Stopwords and Retaining the Stopwords. We can see different end results based on whether stopwords were removed or retained." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Stemming" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Stemming is a process of reducing a given token/word to its root form. For ex: The words - likely, likes, liked, liking are reduced to its root form i.e. like. Stemming uses a crude heuristic process that chops off the ends of words in the hope of correctly transforming words into its root form. So the words “trouble”, “troubled” and “troubles” might actually be converted to “troubl” instead of “trouble” because the ends were just chopped off!\n", + "\n", + "Stemming is an optional step and the best way to find out if it is effective or not is to experiment and observe the results before and after stemming. There are two types of Stemmer defined in NLTK - PorterStemmer & SnowballStemmer. The details are given here. In our examples, we will be using PorterStemmer." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['welcom', 'fairli', 'easili']" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from nltk.stem import PorterStemmer\n", + "\n", + "ps = PorterStemmer()\n", + "def stem(words):\n", + " stemmed_tokens = [ps.stem(word) for word in words]\n", + " return stemmed_tokens\n", + "\n", + "stem(['brown', 'fox', 'quick', 'blue', 'dog', 'lazy'])\n", + "# Result - ['brown', 'fox', 'quick', 'blue', 'dog', 'lazi']\n", + "\n", + "stem(['welcome', 'fairly', 'easily'])\n", + "# Result - ['welcom', 'fairli', 'easili']" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Lemmatization" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "A widely used step after lower-casing and the removal of stopwords is Lemmatization. It is similar to stemming but does not chop the ends of the words, instead it transforms to the actual root word based on a dictionary. This dictionary is called WordNet. Find more details on WordNet here. Since it has to look up a dictionary, it is slightly slower than Stemming. For example, the token “better” is transformed into “good” which retains the semantic meaning even after transformation which might not be the case in stemming (most of the times, the meaning of the stemmed word is not semantically grasped. Lazy becomes lazi after stemming!) NLTK Lemmatizer details here." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['welcome', 'fairly', 'better', 'goose', 'goose']" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from nltk.stem.wordnet import WordNetLemmatizer\n", + "\n", + "lemmatizer = WordNetLemmatizer()\n", + "def lemmatize(words):\n", + " lemmatized_tokens = [lemmatizer.lemmatize(word) for word in words]\n", + " return lemmatized_tokens\n", + "\n", + "lemmatize(['welcome', 'fairly', 'better', 'goose' , 'geese'])\n", + "# Result - ['welcome', 'fairly', 'good', 'goose' , 'goose']" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Putting it all together" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now that we have defined functions for all Pre-processing steps, let us call them and observe the results. We can also create a pipe of function calls in a specific order for processing. This is also termed as the Pre-processing pipeline." + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'brown fox quick blue dog lazy'" + ] + }, + "execution_count": 35, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "sentence = 'The brown fox is quick and the blue dog is lazy!'\n", + "\n", + "# REMOVING ACCENTED CHARACTERS\n", + "remove_accented_chars(sentence)\n", + "# Result - The brown fox is quick and the blue dog is lazy!\n", + "\n", + "# REMOVING SPECIAL CHARACTERS\n", + "remove_special_characters(sentence)\n", + "# Result - The brown fox is quick and the blue dog is lazy\n", + "\n", + "# CONVERTING TO LOWER CASE\n", + "# Pipeline involving removal of spl chars and then lower casing\n", + "to_lower(remove_special_characters(sentence))\n", + "# Result - the brown fox is quick and the blue dog is lazy\n", + "\n", + "# REMOVING PUNCTUATION\n", + "remove_p(to_lower(remove_special_characters(sentence)))\n", + "# Result - the brown fox is quick and the blue dog is lazy\n", + "\n", + "# TOKENIZATION\n", + "text_tokens = tokenization(remove_p(to_lower(remove_special_characters(sentence))))\n", + "# Result - ['the', 'brown', 'fox', 'is', 'quick', 'and', 'the', 'blue', 'dog', 'is', 'lazy']\n", + "\n", + "# REMOVAL OF STOPWORDS\n", + "filtered_tokens = remove_stopwords(text_tokens)\n", + "# Result - ['brown', 'fox', 'quick', 'blue', 'dog', 'lazy']\n", + "\n", + "# STEMMING\n", + "stem(filtered_tokens)\n", + "# Result - ['brown', 'fox', 'quick', 'blue', 'dog', 'lazi']\n", + "\n", + "# LEMMATIZATION\n", + "lemmatize(filtered_tokens)\n", + "# Result - ['brown', 'fox', 'quick', 'blue', 'dog', 'lazy']\n", + "\n", + "# REFACTORING THE CORPUS\n", + "def refactor(words):\n", + " return ' '.join(words)\n", + "refactor(lemmatize(filtered_tokens))\n", + "# Result - 'brown fox quick blue dog lazy'\n", + "# ONE PIPELINE FOR ALL STEPS\n", + "refactor(lemmatize(remove_stopwords(tokenization(remove_p(to_lower(remove_special_characters('The brown fox is quick and the blue dog is lazy!')))))))\n", + "# Result - 'brown fox quick blue dog lazy'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Feel free to experiment stemming, lemmatization, stopword removal aspects in the pipeline. Given here is the code containing all the functions in a single python file." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Conclusion" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We have covered a few of the most popular Text Pre-processing steps in NLP in this post. There are a few more advanced concepts like Bi-gram, Tri-gram filtering, correcting spelling mistakes, expanding abbreviations etc. Feel free to explore these methods also. One more thing to note which has surfaced in recent years is “Pre-processing can hamper the performance of Deep NLP models!” as stated here. BERT and GPT also don’t employ rigorous pre-processing steps, which might induce a thought  - ”Was learning these techniques a waste of time?” Definitely not! These techniques are building blocks in NLP and are to be known for any beginner starting out in NLP. \n", + "\n", + "Try these techniques on your custom data and observe how Pre-processing techniques can help in building a very good text corpus which can later be employed for training Deep Learning Models for NLP tasks. In our next post, we will move to the next step of representing the corpus as a vector, commonly known as Text Encoding." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Acknowledgements\n", + "\n", + "Thanks to [Pranav Raikote](https://twitter.com/A6Singularity) for creating [NLP Tutorials – Part 1: Beginner’s Guide to Text Pre-Processing](https://appliedsingularity.com/2021/12/28/nlp-tutorials-part-1-beginners-guide-to-text-pre-processing/). It inspires the majority of the content in this chapter." + ] + } + ], + "metadata": { + "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.9.13" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/open-machine-learning-jupyter-book/assignments/deep-learning/nlp/news-topic-classification-tasks.ipynb b/open-machine-learning-jupyter-book/assignments/deep-learning/nlp/news-topic-classification-tasks.ipynb new file mode 100644 index 000000000..955d7dc98 --- /dev/null +++ b/open-machine-learning-jupyter-book/assignments/deep-learning/nlp/news-topic-classification-tasks.ipynb @@ -0,0 +1,505 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# News topic classification tasks" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## packages" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import torch\n", + "import torchtext\n", + "import os\n", + "from keras.preprocessing.text import Tokenizer\n", + "from keras_preprocessing import sequence\n", + "import string\n", + "import re\n", + "import numpy as np\n", + "import torch.nn as nn\n", + "import torch.nn.functional as F\n", + "from torch.utils.data.dataset import random_split\n", + "import time\n", + "from torch.utils.data import DataLoader" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Download the data" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We're going to use torchtext.datasets.AG_NEWS,there are four types of news inside." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "load_data_path = \"../data\"\n", + " \n", + "if not os.path.isdir(load_data_path):\n", + " os.mkdir(load_data_path)\n", + " \n", + "train_dataset, test_dataset = torchtext.datasets.AG_NEWS(\n", + " root='../data/', split=('train', 'test'))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can have a look about the data." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "print(list(train_dataset)[:3])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Basic information of the data:**" + ] + }, + { + "attachments": { + "image.png": { + "image/png": "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" + } + }, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "![image.png](attachment:image.png)" + ] + }, + { + "attachments": { + "image.png": { + "image/png": "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" + } + }, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "![image.png](attachment:image.png)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The training set has 120,000 samples, and the label has four values: 1, 2, 3, and 4. The distribution of various types of labels in the training set and test set is relatively uniform." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Work with datasets" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Function: \n", + "1. Replace with space (i.e., split the words on both sides of it into two words), convert all letters to lowercase. \n", + "2. Convert the label to [0,3]. \n", + "3. Sentence length interception" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**The length of the sentences in the sample was analyzed: more than 90% of the sentences were not more than 50 in length, so 50 words were subsequently intercepted.**" + ] + }, + { + "attachments": { + "image-2.png": { + "image/png": "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" + }, + "image-3.png": { + "image/png": "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" + }, + "image.png": { + "image/png": "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" + } + }, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "![image.png](attachment:image.png)![image-2.png](attachment:image-2.png)![image-3.png](attachment:image-3.png)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "punct = str.maketrans('','',string.punctuation)\n", + "def process_datasets_by_Tokenizer(train_dataset, test_dataset, seq_len=200):\n", + " \"\"\"\n", + " Parameter:\n", + " Tran Dattaset: Training sample list Lister (Tapoel (Inter, Ster))\n", + " Return:\n", + " Tran Dattaset: Training set list Lister Petter (Tapul (Turner, Inter))\n", + " \"\"\"\n", + " tokenizer = Tokenizer()\n", + " train_dataset_texts, train_dataset_labels = [], []\n", + " test_dataset_texts, test_dataset_labels = [], []\n", + " \n", + " for label, text in train_dataset:\n", + " # In the previous print, you can see that there is \"\\\\\" , which is replaced with a space, and all of them are lowercase letters\n", + " train_dataset_texts.append(text.replace('\\\\',' ').translate(punct).lower())\n", + " train_dataset_labels.append(label - 1) # Mapping Labels to [0,3]\n", + " \n", + " for label, text in test_dataset:\n", + " test_dataset_texts.append(text.replace('\\\\',' ').translate(punct).lower())\n", + " test_dataset_labels.append(label - 1)\n", + " \n", + " # Here's the trick and put the training set of tests together to build a vocabulary list, so that there are no unlogged words\n", + " all_dataset_texts = train_dataset_texts + test_dataset_texts\n", + " all_dataset_labels = train_dataset_labels + test_dataset_labels\n", + " tokenizer.fit_on_texts(all_dataset_texts)\n", + " \n", + " #train_dataset_seqs is a list in which each element is a list that transforms a sentence from a literal representation into an index representation in a vocabulary\n", + " train_dataset_seqs = tokenizer.texts_to_sequences(train_dataset_texts)\n", + " test_datase_seqs = tokenizer.texts_to_sequences(test_dataset_texts)\n", + " #print(type(train_dataset_seqs), type(train_dataset_seqs[0])) # \n", + " #print(train_dataset_seqs)\n", + " \n", + " # Intercept the first seq_len, and make up 0 after the shortage\n", + " # train_dataset_seqs is a tensor，size:(Number of samples, seq_len)\n", + " train_dataset_seqs = torch.tensor(sequence.pad_sequences(\n", + " train_dataset_seqs, seq_len, padding='post'), dtype=torch.int32)\n", + " test_datase_seqs = torch.tensor(sequence.pad_sequences(\n", + " test_datase_seqs, seq_len, padding='post'), dtype=torch.int32)\n", + " #print(type(train_dataset_seqs), type(train_dataset_seqs[0])) # \n", + " #print(train_dataset_seqs)\n", + " \n", + " train_dataset = list(zip(train_dataset_seqs, train_dataset_labels))\n", + " test_dataset = list(zip(test_datase_seqs, test_dataset_labels))\n", + " \n", + " vocab_size = len(tokenizer.index_word.keys())\n", + " num_class = len(set(all_dataset_labels))\n", + " return train_dataset, test_dataset, vocab_size, num_class\n", + " \n", + " \n", + "embed_dim = 16 # There are about 90,000 words, and the embedding dimension here is 16\n", + "batch_size = 64\n", + "seq_len = 50 # A sentence length of 50 can cover more than 90% of the sample\n", + " \n", + "train_dataset, test_dataset, vocab_size, num_class = process_datasets_by_Tokenizer(\n", + " train_dataset, test_dataset, seq_len=seq_len)\n", + " \n", + "print(train_dataset[:2])\n", + "print(\"vocab_size = {}, num_class = {}\".format(vocab_size, num_class))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "With the 4 print statements commented out open, let's test the code:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "train = [(1, 'The moon is light'),\n", + " (2, 'This is the last rose of summer')]\n", + "test = train[:]\n", + "train, test, sz, cls = process_datasets_by_Tokenizer(train, test, seq_len=5)\n", + "train, test, sz, cls" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Build a model" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The structure of the model is simple: embedding layer + average pooling layer + fully connected layer" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "class TextSentiment(nn.Module):\n", + " \"\"\"Text classification model\"\"\"\n", + " def __init__(self, vocab_size, embed_dim, num_class, seq_len):\n", + " \"\"\"\n", + " description: Initialization function of the class\n", + " :param vocab_size: The total number of distinct words contained in the entire corpus\n", + " :param embed_dim: Specifies the dimension in which the word is embedded\n", + " :param num_class: The total number of categories for the text classification\n", + " \"\"\" \n", + " super(TextSentiment, self).__init__()\n", + " \n", + " self.seq_len = seq_len\n", + " self.embed_dim = embed_dim\n", + " \n", + " # Instantiating the embedding layer, \n", + " #sparse=True means that only part of the weights are updated each time the gradient is solved for that layer.\n", + " self.embedding = nn.Embedding(vocab_size, embed_dim, sparse=True)\n", + " # Instantiate the linear layer, the parameters are embed_dim and num_class.\n", + " self.fc = nn.Linear(embed_dim, num_class)\n", + " # Initialize weights for each layer\n", + " self.init_weights()\n", + " \n", + " def init_weights(self):\n", + " \"\"\"Initialize the weight function\"\"\"\n", + " # Specifies the number of value ranges for the initial weight\n", + " initrange = 0.5\n", + " # The weight parameters of each layer are initialized to a uniform distribution\n", + " self.embedding.weight.data.uniform_(-initrange, initrange)\n", + " self.fc.weight.data.uniform_(-initrange, initrange)\n", + " # The bias is initialized to 0\n", + " self.fc.bias.data.zero_()\n", + " \n", + " def forward(self, text):\n", + " \"\"\"\n", + " :param text: The result of the text numeric mapping\n", + " :return: A tensor of the same size as the number of categories, which is used to determine the category of the text\n", + " \"\"\"\n", + " # [batch_size, seq_len, embed_dim]\n", + " embedded = self.embedding(text) \n", + " # [batch_size, embed_dim, seq_len]，\n", + " # Later, the dimension where the sentence is located is pooling, so put the dimension where the sentence is located at the end\n", + " embedded = embedded.transpose(2, 1) # The dimension of the sentence changes from the second dimension to the third dimension\n", + " # [batch_size, embed_dim, 1] \n", + " embedded = F.avg_pool1d(embedded, kernel_size=self.seq_len)\n", + " # [embed_dim, batch_size] \n", + " embedded = embedded.squeeze(-1)\n", + " # [batch_size, embed_dim]\n", + " # I saw that torch.nn.CrossEntropyLoss() comes with softmax, so I don't have softmax here\n", + " return self.fc(embedded)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Training" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### generate_batch" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "generate_batch: Construct the data in a batch and pass it in as a parameter of the DataLoader function" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def generate_batch(batch):\n", + " \"\"\"[summary]\n", + " Args:\n", + " batch ([type]): [description] A batch_size-sized list of sample tensors and tuples of corresponding labels\n", + " [(sample1, label1), (sample2, label2), ..., (samplen, labeln)]\n", + " :return Sample tensors and labels are in their respective list forms(Tensor)\n", + " \"\"\"\n", + " text = [entry[0].reshape(1, -1) for entry in batch]\n", + "# print(text)\n", + " label = torch.tensor([entry[1] for entry in batch])\n", + " text = torch.cat(text, dim=0)\n", + " \n", + " return torch.tensor(text), torch.tensor(label)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's test the effect of this paragraph:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "batch = [(torch.tensor([3, 23, 2, 8]), 1), (torch.tensor([3, 45, 21, 6]), 0)]\n", + "res = generate_batch(batch)\n", + "print(res, res[0].size())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Training & Validation Functions" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", + "def run(data, batch_size, model, criterion, \n", + " mode='train', optimizer=None, scheduler=None):\n", + " total_loss, total_acc = 0., 0.\n", + " \n", + " shuffle = False\n", + " if mode == 'train':\n", + " shuffle = True\n", + " data = DataLoader(data, batch_size=batch_size, shuffle=shuffle,\n", + " collate_fn=generate_batch)\n", + " \n", + " for i, (text, label) in enumerate(data):\n", + "# text = text.to(device) # gpu version\n", + "# label = label.to(device)\n", + " sz = text.size(0)\n", + " if mode == 'train':\n", + " optimizer.zero_grad()\n", + " output = model(text)\n", + " loss = criterion(output, label)\n", + " # Cumulative batch average, referring to the reservoir sampling algorithm\n", + " total_loss = i / (i + 1) * total_loss + loss.item() / sz / (i + 1)\n", + " loss.backward()\n", + " optimizer.step()\n", + "# predict = F.softmax(output, dim=-1)\n", + " correct_cnt = (output.argmax(1) == label).sum().item()\n", + " total_acc = i / (i + 1) * total_acc + correct_cnt / sz / (i + 1)\n", + " else:\n", + " with torch.no_grad():\n", + " output = model(text)\n", + " loss = criterion(output, label)\n", + " total_loss = i / (i + 1) * total_loss + loss.item() / sz / (i + 1)\n", + "# predict = F.softmax(output, dim=-1)\n", + " correct_cnt = (output.argmax(1) == label).sum().item()\n", + " total_acc = i / (i + 1) * total_acc + correct_cnt / sz / (i + 1)\n", + " \n", + "# if i % 10 == 0:\n", + "# print(\"i: {}, loss: {}\".format(i, total_loss))\n", + " \n", + " # Adjust the optimizer learning rate\n", + " if (scheduler):\n", + " scheduler.step()\n", + "# print(total_loss, total_acc, total_loss / count, total_acc / count, count)\n", + " return total_loss , total_acc" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Main process" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "model = TextSentiment(vocab_size + 1, embed_dim, num_class, seq_len)\n", + "# model = TextSentiment(vocab_size + 1, embed_dim, num_class, seq_len).to(device) # gpu version\n", + " \n", + "criterion = torch.nn.CrossEntropyLoss() # Comes with softmax\n", + "optimizer = torch.optim.SGD(model.parameters(), lr=0.1)\n", + "scheduler = torch.optim.lr_scheduler.StepLR(optimizer, 1, gamma=0.99)\n", + " \n", + "train_len = int(len(train_dataset) * 0.95)\n", + "sub_train_, sub_valid_ = random_split(train_dataset, \n", + " [train_len, len(train_dataset) - train_len])\n", + "n_epochs = 10\n", + "for epoch in range(n_epochs):\n", + " start_time = time.time()\n", + " train_loss, train_acc = run(sub_train_, batch_size, model, criterion, \n", + " mode='train', optimizer=optimizer, scheduler=scheduler)\n", + " \n", + " valid_loss, valid_acc = run(sub_train_, batch_size, model, criterion, mode='validation')\n", + " \n", + " secs = int(time.time() - start_time)\n", + " mins = secs / 60\n", + " secs = secs % 60\n", + " \n", + " print(\"Epoch: %d\" % (epoch + 1),\n", + " \" | time in %d minutes, %d seconds\" % (mins, secs))\n", + " print(\n", + " f\"\\tLoss: {train_loss:.4f}(train)\\t|\\tAcc: {train_acc * 100:.1f}%(train)\"\n", + " )\n", + " print(\n", + " f\"\\tLoss: {valid_loss:.4f}(valid)\\t|\\tAcc: {valid_acc * 100:.1f}%(valid)\"\n", + " )" + ] + } + ], + "metadata": { + "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.9.13" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/open-machine-learning-jupyter-book/deep-learning/nlp.ipynb b/open-machine-learning-jupyter-book/deep-learning/nlp/nlp.ipynb similarity index 87% rename from open-machine-learning-jupyter-book/deep-learning/nlp.ipynb rename to open-machine-learning-jupyter-book/deep-learning/nlp/nlp.ipynb index efcff10fd..5b578475f 100644 --- a/open-machine-learning-jupyter-book/deep-learning/nlp.ipynb +++ b/open-machine-learning-jupyter-book/deep-learning/nlp/nlp.ipynb @@ -46,7 +46,7 @@ "tags": [] }, "source": [ - "# Natural Language Processing Overview" + "# Natural Language Processing" ] }, { @@ -87,30 +87,12 @@ "NLP involves enabling machines to understand, interpret, and produce human language in a way that is both valuable and meaningful. OpenAI, known for developing advanced language models like ChatGPT, highlights the importance of NLP in creating intelligent systems that can understand, respond to, and generate text, making technology more user-friendly and accessible" ] }, - { - "cell_type": "markdown", - "id": "7d322ec8-6408-42b6-a8ea-71c5d5884de9", - "metadata": { - "tags": [] - }, - "source": [ - "## How Does NLP Work?" - ] - }, - { - "cell_type": "markdown", - "id": "d4f0be94-661e-4c6b-a6d7-632f95a5a9ca", - "metadata": {}, - "source": [ - "Let’s take a look at some of the mechanisms at work behind natural language processing." - ] - }, { "cell_type": "markdown", "id": "dd2ee092-520b-4064-b14d-183661e6a049", "metadata": {}, "source": [ - "### Components of NLP" + "## Components of NLP" ] }, { @@ -177,102 +159,6 @@ "Understanding these components is crucial for anyone delving into NLP, as they form the backbone of how NLP models interpret and generate human langua" ] }, - { - "cell_type": "markdown", - "id": "222b00a6-f1ba-4b63-a8e5-1dbca48b77fe", - "metadata": {}, - "source": [ - "### NLP techniques and methods" - ] - }, - { - "cell_type": "markdown", - "id": "948b9247-e6d1-4ee1-bf99-1aa419ac8700", - "metadata": {}, - "source": [ - "To analyze and understand human language, NLP employs a variety of techniques and methods. Here are some fundamental techniques used in NLP:" - ] - }, - { - "cell_type": "markdown", - "id": "9591bff3-247e-45be-a300-a7c4c941597c", - "metadata": {}, - "source": [ - "- Tokenization: This is the process of breaking text into words, phrases, symbols, or other meaningful elements, known as tokens." - ] - }, - { - "cell_type": "markdown", - "id": "b17ee05d-7891-4726-bd9c-7dd881bad64c", - "metadata": {}, - "source": [ - "

Image: Tokenization in NLP
" - ] - }, - { - "cell_type": "markdown", - "id": "2476764b-2b93-41f9-932a-578941752c51", - "metadata": {}, - "source": [ - "- Parsing: Parsing involves analyzing the grammatical structure of a sentence to extract meaning." - ] - }, - { - "cell_type": "markdown", - "id": "73a80730-782c-47e7-824b-55e18f9769e2", - "metadata": {}, - "source": [ - "- Lemmatization: This technique reduces words to their base or root form, allowing for the grouping of different forms of the same word." - ] - }, - { - "cell_type": "markdown", - "id": "f8d9dcd0-e581-490e-a1ab-b6b9e4440869", - "metadata": {}, - "source": [ - "

Image: Lemmatization in NLP
" - ] - }, - { - "cell_type": "markdown", - "id": "223836f4-cb48-4746-b1f0-18e726d86935", - "metadata": {}, - "source": [ - "- Named Entity Recognition (NER): NER is used to identify entities such as persons, organizations, locations, and other named items in the text." - ] - }, - { - "cell_type": "markdown", - "id": "ef91cea7-c99a-4955-a319-deeeb471583d", - "metadata": {}, - "source": [ - "

Image: NER in NLP
" - ] - }, - { - "cell_type": "markdown", - "id": "af0f5555-bb7a-44a1-9316-829eca456515", - "metadata": {}, - "source": [ - "- Sentiment analysis: This method is used to gain an understanding of the sentiment or emotion conveyed in a piece of text." - ] - }, - { - "cell_type": "markdown", - "id": "c26a4926-3a0d-4384-a547-0cd9eea3ff05", - "metadata": {}, - "source": [ - "

Image: Sentiment analysis in NLP
" - ] - }, - { - "cell_type": "markdown", - "id": "514884a8-dd0b-4b85-bb66-fc33cdec524b", - "metadata": {}, - "source": [ - "Each of these techniques plays a vital role in enabling computers to process and understand human language, forming the building blocks of more advanced NLP applications." - ] - }, { "cell_type": "markdown", "id": "6926e7a2-cc7f-4459-9925-9fa78f73f471", @@ -786,7 +672,8 @@ }, "source": [ "## Your turn! 🚀\n", - "You can practice your nlp skills by following the assignment [getting start nlp with classification task](../assignments/deep-learning/nlp/getting-start-nlp-with-classification-task.ipynb)." + "\n", + "TBD." ] }, { @@ -798,6 +685,15 @@ "\n", "Thanks to [Matt Crabtree](https://www.datacamp.com/portfolio/mattcrabtree) and [Phil Culliton](https://www.kaggle.com/philculliton) for creating the open-source course [What is Natural Language Processing (NLP)?](https://www.datacamp.com/blog/what-is-natural-language-processing) and [NLP Getting Started Tutorial](https://www.kaggle.com/code/philculliton/nlp-getting-started-tutorial). It inspires the majority of the content in this chapter.\n" ] + }, + { + "cell_type": "markdown", + "id": "c3f25b14", + "metadata": {}, + "source": [ + "```{tableofcontents}\n", + "```" + ] } ], "metadata": { diff --git a/open-machine-learning-jupyter-book/deep-learning/nlp/text-preprocessing.ipynb b/open-machine-learning-jupyter-book/deep-learning/nlp/text-preprocessing.ipynb new file mode 100644 index 000000000..23da5d928 --- /dev/null +++ b/open-machine-learning-jupyter-book/deep-learning/nlp/text-preprocessing.ipynb @@ -0,0 +1,510 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "tags": [ + "hide-cell" + ] + }, + "outputs": [], + "source": [ + "# Install the necessary dependencies\n", + "\n", + "import os\n", + "import sys\n", + "!{sys.executable} -m pip install --quiet pandas scikit-learn numpy matplotlib jupyterlab_myst ipython nltk" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "tags": [ + "remove-cell" + ] + }, + "source": [ + "---\n", + "license:\n", + " code: MIT\n", + " content: CC-BY-4.0\n", + "github: https://github.com/ocademy-ai/machine-learning\n", + "venue: By Ocademy\n", + "open_access: true\n", + "bibliography:\n", + " - https://raw.githubusercontent.com/ocademy-ai/machine-learning/main/open-machine-learning-jupyter-book/references.bib\n", + "---" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Text Preprocessing\n", + "\n", + "Preprocessing in NLP is a means to get text data ready for further processing or analysis. Most of the time, preprocessing is a mix of cleaning and normalising techniques that make the text easier to use for the task at hand.\n", + "\n", + "A useful library for processing text in Python is the Natural Language Toolkit (NLTK). This chapter will go into 6 of the most commonly used pre-processing steps and provide code examples so you can start using the techniques immediately." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Common NLTK preprocessing steps" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Tokenization\n", + "\n", + "Splitting the text into individual words or subwords (tokens).\n", + "\n", + ":::{figure} https://static-1300131294.cos.ap-shanghai.myqcloud.com/images/deep-learning/NLP/tokenization.png\n", + "---\n", + "name: 'tokenization in nlp'\n", + "width: 90%\n", + "---\n", + "Tokenization in NLP\n", + ":::\n", + "\n", + "Here is how to implement tokenization in NLTK:" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Tokens: ['Natural', 'language', 'processing', 'is', 'a', 'field', 'of', 'artificial', 'intelligence', 'that', 'deals', 'with', 'the', 'interaction', 'between', 'computers', 'and', 'human', '(', 'natural', ')', 'language', '.']\n" + ] + } + ], + "source": [ + "import nltk\n", + "\n", + "# input text\n", + "text = \"Natural language processing is a field of artificial intelligence that deals with the interaction between computers and human (natural) language.\"\n", + "\n", + "# tokenize the text\n", + "tokens = nltk.word_tokenize(text)\n", + "\n", + "print(\"Tokens:\", tokens)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Remove stop words\n", + "\n", + "Removing common words that do not add significant meaning to the text, such as “a,” “an,” and “the.”\n", + "\n", + "To remove common stop words from a list of tokens using NLTK, you can use the **nltk.corpus.stopwords.words()** function to get a list of stopwords in a specific language and filter the tokens using this list. Here is an example of how to do this:" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Tokens without stopwords: ['Natural', 'language', 'processing', 'field', 'artificial', 'intelligence', 'deals', 'interaction', 'computers', 'human', '(', 'natural', ')', 'language', '.']\n" + ] + } + ], + "source": [ + "import nltk\n", + "\n", + "# input text\n", + "text = \"Natural language processing is a field of artificial intelligence that deals with the interaction between computers and human (natural) language.\"\n", + "\n", + "# tokenize the text\n", + "tokens = nltk.word_tokenize(text)\n", + "\n", + "# get list of stopwords in English\n", + "stopwords = nltk.corpus.stopwords.words(\"english\")\n", + "\n", + "# remove stopwords\n", + "filtered_tokens = [token for token in tokens if token.lower() not in stopwords]\n", + "\n", + "print(\"Tokens without stopwords:\", filtered_tokens)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Stemming\n", + "\n", + "Reducing words to their root form by removing suffixes and prefixes, such as converting “jumping” to “jump.” But it may produce non-existent words.\n", + "\n", + ":::{figure} https://static-1300131294.cos.ap-shanghai.myqcloud.com/images/deep-learning/NLP/stemming.png\n", + "---\n", + "name: 'stemming in nlp'\n", + "width: 90%\n", + "---\n", + "Stemming in NLP\n", + ":::\n", + "\n", + "To perform stemming on a list of tokens using NLTK, you can use the **nltk.stem.WordNetLemmatizer()** function to create a stemmer object and the method to stem each token. Here is an example of how to do this:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Stemmed tokens: ['natur', 'languag', 'process', 'is', 'a', 'field', 'of', 'artifici', 'intellig', 'that', 'deal', 'with', 'the', 'interact', 'between', 'comput', 'and', 'human', '(', 'natur', ')', 'languag', '.']\n" + ] + } + ], + "source": [ + "import nltk\n", + "\n", + "# input text\n", + "text = \"Natural language processing is a field of artificial intelligence that deals with the interaction between computers and human (natural) language.\"\n", + "\n", + "# tokenize the text\n", + "tokens = nltk.word_tokenize(text)\n", + "\n", + "# create stemmer object\n", + "stemmer = nltk.stem.PorterStemmer()\n", + "\n", + "# stem each token\n", + "stemmed_tokens = [stemmer.stem(token) for token in tokens]\n", + "\n", + "print(\"Stemmed tokens:\", stemmed_tokens)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Lemmatization\n", + "\n", + "Reducing words to their base form by considering the context in which they are used, such as “running” or “ran” becoming “run”. This technique is similar to stemming, but it is more accurate as it considers the context of the word.\n", + "\n", + ":::{figure} https://static-1300131294.cos.ap-shanghai.myqcloud.com/images/deep-learning/NLP/Lemmatization.png\n", + "---\n", + "name: 'lemmatization in nlp'\n", + "width: 90%\n", + "---\n", + "Lemmatization in NLP\n", + ":::\n", + "\n", + "To perform lemmatization on a list of tokens using NLTK, you can use the **nltk.stem.WordNetLemmatizer()** function to create a lemmatizer object and the **lemmatize()** method to lemmatize each token. Here is an example of how to do this:" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Lemmatized tokens: ['Natural', 'language', 'processing', 'is', 'a', 'field', 'of', 'artificial', 'intelligence', 'that', 'deal', 'with', 'the', 'interaction', 'between', 'computer', 'and', 'human', '(', 'natural', ')', 'language', '.']\n" + ] + } + ], + "source": [ + "import nltk\n", + "\n", + "# input text\n", + "text = \"Natural language processing is a field of artificial intelligence that deals with the interaction between computers and human (natural) language.\"\n", + "\n", + "# tokenize the text\n", + "tokens = nltk.word_tokenize(text)\n", + "\n", + "# create lemmatizer object\n", + "lemmatizer = nltk.stem.WordNetLemmatizer()\n", + "\n", + "# lemmatize each token\n", + "lemmatized_tokens = [lemmatizer.lemmatize(token) for token in tokens]\n", + "\n", + "print(\"Lemmatized tokens:\", lemmatized_tokens)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "tags": [] + }, + "source": [ + "### Part Of Speech Tagging\n", + "\n", + "Identifying the part of speech of each word in the text, such as noun, verb, or adjective.\n", + "\n", + ":::{figure} https://static-1300131294.cos.ap-shanghai.myqcloud.com/images/deep-learning/NLP/POS tag and description.png\n", + "---\n", + "name: 'POS tag and description in nlp'\n", + "width: 90%\n", + "---\n", + "POS tag and description\n", + ":::\n", + "\n", + "To perform part of speech (POS) tagging on a list of tokens using NLTK, you can use the **nltk.pos_tag()** function to tag the tokens with their corresponding POS tags. Here is an example of how to do this:" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Tagged tokens: [('Natural', 'JJ'), ('language', 'NN'), ('processing', 'NN'), ('is', 'VBZ'), ('a', 'DT'), ('field', 'NN'), ('of', 'IN'), ('artificial', 'JJ'), ('intelligence', 'NN'), ('that', 'IN'), ('deals', 'NNS'), ('with', 'IN'), ('the', 'DT'), ('interaction', 'NN'), ('between', 'IN'), ('computers', 'NNS'), ('and', 'CC'), ('human', 'JJ'), ('(', '('), ('natural', 'JJ'), (')', ')'), ('language', 'NN'), ('.', '.')]\n" + ] + } + ], + "source": [ + "import nltk\n", + "\n", + "# input text\n", + "text = \"Natural language processing is a field of artificial intelligence that deals with the interaction between computers and human (natural) language.\"\n", + "\n", + "# tokenize the text\n", + "tokens = nltk.word_tokenize(text)\n", + "\n", + "# tag the tokens with their POS tags\n", + "tagged_tokens = nltk.pos_tag(tokens)\n", + "\n", + "print(\"Tagged tokens:\", tagged_tokens)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Named Entity Recognition(NER)\n", + "\n", + "Extracting named entities from a text, like a person’s name.\n", + "\n", + ":::{figure} https://static-1300131294.cos.ap-shanghai.myqcloud.com/images/deep-learning/NLP/ner.gif\n", + "---\n", + "name: 'ner in nlp'\n", + "width: 90%\n", + "---\n", + "ner in NLP\n", + ":::\n", + "\n", + "To perform named entity recognition (NER) on a list of tokens using NLTK, you can use the **nltk.ne_chunk()** function to identify and label named entities in the tokens. Here is an example of how to do this:" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Named entities: (S\n", + " Natural/JJ\n", + " language/NN\n", + " processing/NN\n", + " is/VBZ\n", + " a/DT\n", + " field/NN\n", + " of/IN\n", + " artificial/JJ\n", + " intelligence/NN\n", + " that/IN\n", + " deals/NNS\n", + " with/IN\n", + " the/DT\n", + " interaction/NN\n", + " between/IN\n", + " computers/NNS\n", + " and/CC\n", + " human/JJ\n", + " (/(\n", + " natural/JJ\n", + " )/)\n", + " language/NN\n", + " ./.\n", + " (PERSON John/NNP Smith/NNP)\n", + " works/VBZ\n", + " at/IN\n", + " (ORGANIZATION Google/NNP)\n", + " in/IN\n", + " (GPE New/NNP York/NNP)\n", + " ./.)\n" + ] + } + ], + "source": [ + "import nltk\n", + "\n", + "# input text\n", + "text = \"Natural language processing is a field of artificial intelligence that deals with the interaction between computers and human (natural) language. John Smith works at Google in New York.\"\n", + "\n", + "# tokenize the text\n", + "tokens = nltk.word_tokenize(text)\n", + "\n", + "# tag the tokens with their part of speech\n", + "tagged_tokens = nltk.pos_tag(tokens)\n", + "\n", + "# identify named entities\n", + "named_entities = nltk.ne_chunk(tagged_tokens)\n", + "\n", + "print(\"Named entities:\", named_entities)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## NLTK preprocessing pipeline example" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Preprocessing techniques can be applied independently or in combination, depending on the specific requirements of the task at hand.\n", + "\n", + "Here is an example of a typical NLP pipeline using the NLTK:\n", + "\n", + "1.Tokenization: First, we need to split the input text into individual words (tokens). This can be done using the **nltk.word_tokenize()** function.\n", + "\n", + "2.Part-of-speech tagging: Next, we can use the **nltk.pos_tag()** function to assign a part-of-speech (POS) tag to each token, which indicates its role in a sentence (e.g., noun, verb, adjective).\n", + "\n", + "3.Named entity recognition: Using the **nltk.ne_chunk()** function, we can identify named entities (e.g., person, organization, location) in the text.\n", + "\n", + "4.Lemmatization: We can use the **nltk.WordNetLemmatizer()** function to convert each token to its base form (lemma), which helps with the analysis of the text.\n", + "\n", + "5.Stopword removal: We can use the **nltk.corpus.stopwords.words()** function to remove common words (stopwords) that do not add significant meaning to the text, such as “the,” “a,” and “an.”\n", + "\n", + "6.Text classification: Finally, we can use the processed text to train a classifier using machine learning algorithms to perform tasks such as sentiment analysis or spam detection." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## NLTK preprocessing example code" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [], + "source": [ + "import nltk\n", + "\n", + "# input text\n", + "text = \"Natural language processing is a field of artificial intelligence that deals with the interaction between computers and human (natural) language.\"\n", + "\n", + "# tokenization\n", + "tokens = nltk.word_tokenize(text)\n", + "\n", + "# part-of-speech tagging\n", + "pos_tags = nltk.pos_tag(tokens)\n", + "\n", + "# named entity recognition\n", + "named_entities = nltk.ne_chunk(pos_tags)\n", + "\n", + "# lemmatization\n", + "lemmatizer = nltk.WordNetLemmatizer()\n", + "lemmas = [lemmatizer.lemmatize(token) for token in tokens]\n", + "\n", + "# stopword removal\n", + "stopwords = nltk.corpus.stopwords.words(\"english\")\n", + "filtered_tokens = [token for token in tokens if token not in stopwords]\n", + "\n", + "# text classification (example using a simple Naive Bayes classifier)\n", + "from nltk.classify import NaiveBayesClassifier" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Sentiment: neg\n" + ] + } + ], + "source": [ + "# training data (using a toy dataset for illustration purposes)\n", + "training_data = [(\"It was a great movie.\", \"pos\"), (\"I hated the book.\", \"neg\"), (\"The book was okay.\", \"pos\")]\n", + "\n", + "# extract features from the training data\n", + "def extract_features(text):\n", + " features = {}\n", + " for word in nltk.word_tokenize(text):\n", + " features[word] = True\n", + " return features\n", + "\n", + "# create a list of feature sets and labels\n", + "feature_sets = [(extract_features(text), label) for (text, label) in training_data]\n", + "\n", + "# train the classifier\n", + "classifier = NaiveBayesClassifier.train(feature_sets)\n", + "\n", + "# test the classifier on a new example\n", + "test_text = \"I really enjoyed the movie.\"\n", + "print(\"Sentiment:\", classifier.classify(extract_features(test_text)))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Your turn! 🚀\n", + "\n", + "Assignment - [Beginner Guide to Text Pre-Processing](../assignments/deep-learning/nlp/beginner-guide-to-text-preprocessing.ipynb)\n", + "\n", + "## Acknowledgments\n", + "\n", + "Thanks to [Neri Van Otten](https://spotintelligence.com/author/spotintelligence) for creating the open-source project [Top 14 Steps To Build A Complete NLTK Preprocessing Pipeline In Python](https://spotintelligence.com/2022/12/21/nltk-preprocessing-pipeline).It inspire the majority of the content in this chapter." + ] + } + ], + "metadata": { + "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.9.13" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/open-machine-learning-jupyter-book/deep-learning/nlp/text-representation.ipynb b/open-machine-learning-jupyter-book/deep-learning/nlp/text-representation.ipynb new file mode 100644 index 000000000..d959fbf1e --- /dev/null +++ b/open-machine-learning-jupyter-book/deep-learning/nlp/text-representation.ipynb @@ -0,0 +1,1071 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "id": "25fea2d2", + "metadata": { + "tags": [ + "hide-cell" + ] + }, + "outputs": [], + "source": [ + "# Install the necessary dependencies\n", + "\n", + "import os\n", + "import sys\n", + "!{sys.executable} -m pip install --quiet pandas scikit-learn numpy matplotlib jupyterlab_myst ipython gensim torch" + ] + }, + { + "cell_type": "markdown", + "id": "74660f15", + "metadata": { + "tags": [ + "hide-input" + ] + }, + "source": [ + "---\n", + "license:\n", + " code: MIT\n", + " content: CC-BY-4.0\n", + "github: https://github.com/ocademy-ai/machine-learning\n", + "venue: By Ocademy\n", + "open_access: true\n", + "bibliography:\n", + " - https://raw.githubusercontent.com/ocademy-ai/machine-learning/main/open-machine-learning-jupyter-book/references.bib\n", + "---" + ] + }, + { + "cell_type": "markdown", + "id": "3c79b007", + "metadata": {}, + "source": [ + "# Word embedding" + ] + }, + { + "cell_type": "markdown", + "id": "9ef3de21", + "metadata": {}, + "source": [ + "Word Embeddings are numeric representations of words in a lower-dimensional space, capturing semantic and syntactic information. Mainly including discrete representation methods and distribution representation methods" + ] + }, + { + "cell_type": "markdown", + "id": "31ac0f5a", + "metadata": {}, + "source": [ + "## Discrete representation" + ] + }, + { + "cell_type": "markdown", + "id": "5d1dc20e", + "metadata": {}, + "source": [ + "This method involves compiling a list of distinct terms and giving each one a unique integer value, or id. and after that, insert each word’s distinct id into the sentence. Every vocabulary word is handled as a feature in this instance. Thus, a large vocabulary will result in an extremely large feature size. Common discrete representation methods include:one-hot,Bag of Word (Bow) and Term frequency-inverse document frequency (TF-IDF)" + ] + }, + { + "cell_type": "markdown", + "id": "2cc04cbb", + "metadata": {}, + "source": [ + "### One-Hot" + ] + }, + { + "cell_type": "markdown", + "id": "2f1dc868", + "metadata": {}, + "source": [ + "One-hot encoding is a simple method for representing words in natural language processing (NLP). In this encoding scheme, each word in the vocabulary is represented as a unique vector, where the dimensionality of the vector is equal to the size of the vocabulary. The vector has all elements set to 0, except for the element corresponding to the index of the word in the vocabulary, which is set to 1." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "864709ef", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Vocabulary: {'mat', 'dog', 'tree', 'in', 'on', 'hat', 'the', 'bird', 'cat'}\n", + "Word to Index Mapping: {'mat': 0, 'dog': 1, 'tree': 2, 'in': 3, 'on': 4, 'hat': 5, 'the': 6, 'bird': 7, 'cat': 8}\n", + "One-Hot Encoded Matrix:\n", + "cat: [0, 0, 0, 0, 0, 0, 0, 0, 1]\n", + "in: [0, 0, 0, 1, 0, 0, 0, 0, 0]\n", + "the: [0, 0, 0, 0, 0, 0, 1, 0, 0]\n", + "hat: [0, 0, 0, 0, 0, 1, 0, 0, 0]\n", + "dog: [0, 1, 0, 0, 0, 0, 0, 0, 0]\n", + "on: [0, 0, 0, 0, 1, 0, 0, 0, 0]\n", + "the: [0, 0, 0, 0, 0, 0, 1, 0, 0]\n", + "mat: [1, 0, 0, 0, 0, 0, 0, 0, 0]\n", + "bird: [0, 0, 0, 0, 0, 0, 0, 1, 0]\n", + "in: [0, 0, 0, 1, 0, 0, 0, 0, 0]\n", + "the: [0, 0, 0, 0, 0, 0, 1, 0, 0]\n", + "tree: [0, 0, 1, 0, 0, 0, 0, 0, 0]\n" + ] + } + ], + "source": [ + "def one_hot_encode(text):\n", + "\twords = text.split()\n", + "\tvocabulary = set(words)\n", + "\tword_to_index = {word: i for i, word in enumerate(vocabulary)}\n", + "\tone_hot_encoded = []\n", + "\tfor word in words:\n", + "\t\tone_hot_vector = [0] * len(vocabulary)\n", + "\t\tone_hot_vector[word_to_index[word]] = 1\n", + "\t\tone_hot_encoded.append(one_hot_vector)\n", + "\n", + "\treturn one_hot_encoded, word_to_index, vocabulary\n", + "\n", + "# sample\n", + "example_text = \"cat in the hat dog on the mat bird in the tree\"\n", + "\n", + "one_hot_encoded, word_to_index, vocabulary = one_hot_encode(example_text)\n", + "\n", + "print(\"Vocabulary:\", vocabulary)\n", + "print(\"Word to Index Mapping:\", word_to_index)\n", + "print(\"One-Hot Encoded Matrix:\")\n", + "for word, encoding in zip(example_text.split(), one_hot_encoded):\n", + "\tprint(f\"{word}: {encoding}\")\n" + ] + }, + { + "cell_type": "markdown", + "id": "97ef1ca7", + "metadata": {}, + "source": [ + "### Bag of Word (Bow)" + ] + }, + { + "cell_type": "markdown", + "id": "bd4709a2", + "metadata": {}, + "source": [ + "Bag-of-Words (BoW) is a text representation technique that represents a document as an unordered set of words and their respective frequencies. It discards the word order and captures the frequency of each word in the document, creating a vector representation." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "9a2f8864", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Bag-of-Words Matrix:\n", + "[[0 1 1 1 0 0 1 0 1]\n", + " [0 2 0 1 0 1 1 0 1]\n", + " [1 0 0 1 1 0 1 1 1]\n", + " [0 1 1 1 0 0 1 0 1]]\n", + "Vocabulary (Feature Names): ['and' 'document' 'first' 'is' 'one' 'second' 'the' 'third' 'this']\n" + ] + } + ], + "source": [ + "from sklearn.feature_extraction.text import CountVectorizer\n", + "documents = [\"This is the first document.\",\n", + "\t\t\t\"This document is the second document.\",\n", + "\t\t\t\"And this is the third one.\",\n", + "\t\t\t\"Is this the first document?\"]\n", + "\n", + "vectorizer = CountVectorizer()\n", + "X = vectorizer.fit_transform(documents)\n", + "feature_names = vectorizer.get_feature_names_out()\n", + "\n", + "print(\"Bag-of-Words Matrix:\")\n", + "print(X.toarray())\n", + "print(\"Vocabulary (Feature Names):\", feature_names)\n" + ] + }, + { + "cell_type": "markdown", + "id": "6a18e45f", + "metadata": {}, + "source": [ + "### Term frequency-inverse document frequency (TF-IDF)" + ] + }, + { + "cell_type": "markdown", + "id": "d4d1e4d7", + "metadata": {}, + "source": [ + "Term Frequency-Inverse Document Frequency, commonly known as TF-IDF, is a numerical statistic that reflects the importance of a word in a document relative to a collection of documents (corpus). It is widely used in natural language processing and information retrieval to evaluate the significance of a term within a specific document in a larger corpus. TF-IDF consists of two components:" + ] + }, + { + "cell_type": "markdown", + "id": "3d63655c", + "metadata": {}, + "source": [ + "**·Term Frequency (TF)**: Term Frequency measures how often a term (word) appears in a document. It is calculated using the formula:" + ] + }, + { + "attachments": { + "image.png": { + "image/png": "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" + } + }, + "cell_type": "markdown", + "id": "880b6882", + "metadata": {}, + "source": [ + "![image.png](attachment:image.png)" + ] + }, + { + "cell_type": "markdown", + "id": "7570820c", + "metadata": {}, + "source": [ + "**·Inverse Document Frequency (IDF)**: Inverse Document Frequency measures the importance of a term across a collection of documents. It is calculated using the formula:" + ] + }, + { + "attachments": { + "image.png": { + "image/png": "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" + } + }, + "cell_type": "markdown", + "id": "c351af56", + "metadata": {}, + "source": [ + "![image.png](attachment:image.png)" + ] + }, + { + "cell_type": "markdown", + "id": "d95ef779", + "metadata": {}, + "source": [ + "The TF-IDF score for a term t in a document d is then given by multiplying the TF and IDF values:\n", + "\n", + "TF-IDF(t,d,D)=TF(t,d)×IDF(t,D) \n", + "\n", + "The higher the TF-IDF score for a term in a document, the more important that term is to that document within the context of the entire corpus. This weighting scheme helps in identifying and extracting relevant information from a large collection of documents, and it is commonly used in text mining, information retrieval, and document clustering.\n", + "\n", + "Let’s Implement Term Frequency-Inverse Document Frequency (TF-IDF) using python with the scikit-learn library. It begins by defining a set of sample documents. The TfidfVectorizer is employed to transform these documents into a TF-IDF matrix. The code then extracts and prints the TF-IDF values for each word in each document. This statistical measure helps assess the importance of words in a document relative to their frequency across a collection of documents, aiding in information retrieval and text analysis tasks." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "c645bb7a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Document 1:\n", + "dog: 0.30151134457776363\n", + "lazy: 0.30151134457776363\n", + "over: 0.30151134457776363\n", + "jumps: 0.30151134457776363\n", + "fox: 0.30151134457776363\n", + "brown: 0.30151134457776363\n", + "quick: 0.30151134457776363\n", + "the: 0.6030226891555273\n", + "\n", + "\n", + "Document 2:\n", + "step: 0.3535533905932738\n", + "single: 0.3535533905932738\n", + "with: 0.3535533905932738\n", + "begins: 0.3535533905932738\n", + "miles: 0.3535533905932738\n", + "thousand: 0.3535533905932738\n", + "of: 0.3535533905932738\n", + "journey: 0.3535533905932738\n", + "\n", + "\n" + ] + } + ], + "source": [ + "from sklearn.feature_extraction.text import TfidfVectorizer\n", + "\n", + "# Sample\n", + "documents = [\n", + "\t\"The quick brown fox jumps over the lazy dog.\",\n", + "\t\"A journey of a thousand miles begins with a single step.\",\n", + "]\n", + "\n", + "vectorizer = TfidfVectorizer() # Create the TF-IDF vectorizer\n", + "tfidf_matrix = vectorizer.fit_transform(documents)\n", + "feature_names = vectorizer.get_feature_names_out()\n", + "tfidf_values = {}\n", + "\n", + "for doc_index, doc in enumerate(documents):\n", + "\tfeature_index = tfidf_matrix[doc_index, :].nonzero()[1]\n", + "\ttfidf_doc_values = zip(feature_index, [tfidf_matrix[doc_index, x] for x in feature_index])\n", + "\ttfidf_values[doc_index] = {feature_names[i]: value for i, value in tfidf_doc_values}\n", + "#let's print\n", + "for doc_index, values in tfidf_values.items():\n", + "\tprint(f\"Document {doc_index + 1}:\")\n", + "\tfor word, tfidf_value in values.items():\n", + "\t\tprint(f\"{word}: {tfidf_value}\")\n", + "\tprint(\"\\n\")\n" + ] + }, + { + "cell_type": "markdown", + "id": "f02af2ee", + "metadata": {}, + "source": [ + "## Distributed representation" + ] + }, + { + "cell_type": "markdown", + "id": "dbf1c07c", + "metadata": {}, + "source": [ + "### Word2Vec" + ] + }, + { + "cell_type": "markdown", + "id": "67e6d642", + "metadata": {}, + "source": [ + "Word2Vec is a neural approach for generating word embeddings. It belongs to the family of neural word embedding techniques and specifically falls under the category of distributed representation models. It is a popular technique in natural language processing (NLP) that is used to represent words as continuous vector spaces. Developed by a team at Google, Word2Vec aims to capture the semantic relationships between words by mapping them to high-dimensional vectors. The underlying idea is that words with similar meanings should have similar vector representations. In Word2Vec every word is assigned a vector. We start with either a random vector or one-hot vector." + ] + }, + { + "cell_type": "markdown", + "id": "bf16b0de", + "metadata": {}, + "source": [ + "There are two neural embedding methods for Word2Vec, Continuous Bag of Words (CBOW) and Skip-gram." + ] + }, + { + "cell_type": "markdown", + "id": "a4ba4b22", + "metadata": {}, + "source": [ + "#### Continuous Bag of Words(CBOW)" + ] + }, + { + "cell_type": "markdown", + "id": "1e7d21ea", + "metadata": {}, + "source": [ + "Continuous Bag of Words (CBOW) is a type of neural network architecture used in the Word2Vec model. The primary objective of CBOW is to predict a target word based on its context, which consists of the surrounding words in a given window. Given a sequence of words in a context window, the model is trained to predict the target word at the center of the window.\n", + "\n", + "CBOW is a feedforward neural network with a single hidden layer. The input layer represents the context words, and the output layer represents the target word. The hidden layer contains the learned continuous vector representations (word embeddings) of the input words.\n", + "\n", + "The architecture is useful for learning distributed representations of words in a continuous vector space." + ] + }, + { + "cell_type": "markdown", + "id": "b1e22020", + "metadata": {}, + "source": [ + ":::{figure} https://static-1300131294.cos.ap-shanghai.myqcloud.com/images/deep-learning/NLP/cbow.png\n", + "---\n", + "name: 'continuous bag of words'\n", + "width: 90%\n", + "---\n", + "Continuous Bag of Words\n", + ":::" + ] + }, + { + "cell_type": "markdown", + "id": "612a2f35", + "metadata": {}, + "source": [ + "The hidden layer contains the continuous vector representations (word embeddings) of the input words.\n", + "\n", + "The weights between the input layer and the hidden layer are learned during training.\n", + "The dimensionality of the hidden layer represents the size of the word embeddings (the continuous vector space)." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "c51a75d9", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 1, Loss: 0\n", + "Epoch 2, Loss: 0\n", + "Epoch 3, Loss: 0\n", + "Epoch 4, Loss: 0\n", + "Epoch 5, Loss: 0\n", + "Epoch 6, Loss: 0\n", + "Epoch 7, Loss: 0\n", + "Epoch 8, Loss: 0\n", + "Epoch 9, Loss: 0\n", + "Epoch 10, Loss: 0\n", + "Epoch 11, Loss: 0\n", + "Epoch 12, Loss: 0\n", + "Epoch 13, Loss: 0\n", + "Epoch 14, Loss: 0\n", + "Epoch 15, Loss: 0\n", + "Epoch 16, Loss: 0\n", + "Epoch 17, Loss: 0\n", + "Epoch 18, Loss: 0\n", + "Epoch 19, Loss: 0\n", + "Epoch 20, Loss: 0\n", + "Epoch 21, Loss: 0\n", + "Epoch 22, Loss: 0\n", + "Epoch 23, Loss: 0\n", + "Epoch 24, Loss: 0\n", + "Epoch 25, Loss: 0\n", + "Epoch 26, Loss: 0\n", + "Epoch 27, Loss: 0\n", + "Epoch 28, Loss: 0\n", + "Epoch 29, Loss: 0\n", + "Epoch 30, Loss: 0\n", + "Epoch 31, Loss: 0\n", + "Epoch 32, Loss: 0\n", + "Epoch 33, Loss: 0\n", + "Epoch 34, Loss: 0\n", + "Epoch 35, Loss: 0\n", + "Epoch 36, Loss: 0\n", + "Epoch 37, Loss: 0\n", + "Epoch 38, Loss: 0\n", + "Epoch 39, Loss: 0\n", + "Epoch 40, Loss: 0\n", + "Epoch 41, Loss: 0\n", + "Epoch 42, Loss: 0\n", + "Epoch 43, Loss: 0\n", + "Epoch 44, Loss: 0\n", + "Epoch 45, Loss: 0\n", + "Epoch 46, Loss: 0\n", + "Epoch 47, Loss: 0\n", + "Epoch 48, Loss: 0\n", + "Epoch 49, Loss: 0\n", + "Epoch 50, Loss: 0\n", + "Epoch 51, Loss: 0\n", + "Epoch 52, Loss: 0\n", + "Epoch 53, Loss: 0\n", + "Epoch 54, Loss: 0\n", + "Epoch 55, Loss: 0\n", + "Epoch 56, Loss: 0\n", + "Epoch 57, Loss: 0\n", + "Epoch 58, Loss: 0\n", + "Epoch 59, Loss: 0\n", + "Epoch 60, Loss: 0\n", + "Epoch 61, Loss: 0\n", + "Epoch 62, Loss: 0\n", + "Epoch 63, Loss: 0\n", + "Epoch 64, Loss: 0\n", + "Epoch 65, Loss: 0\n", + "Epoch 66, Loss: 0\n", + "Epoch 67, Loss: 0\n", + "Epoch 68, Loss: 0\n", + "Epoch 69, Loss: 0\n", + "Epoch 70, Loss: 0\n", + "Epoch 71, Loss: 0\n", + "Epoch 72, Loss: 0\n", + "Epoch 73, Loss: 0\n", + "Epoch 74, Loss: 0\n", + "Epoch 75, Loss: 0\n", + "Epoch 76, Loss: 0\n", + "Epoch 77, Loss: 0\n", + "Epoch 78, Loss: 0\n", + "Epoch 79, Loss: 0\n", + "Epoch 80, Loss: 0\n", + "Epoch 81, Loss: 0\n", + "Epoch 82, Loss: 0\n", + "Epoch 83, Loss: 0\n", + "Epoch 84, Loss: 0\n", + "Epoch 85, Loss: 0\n", + "Epoch 86, Loss: 0\n", + "Epoch 87, Loss: 0\n", + "Epoch 88, Loss: 0\n", + "Epoch 89, Loss: 0\n", + "Epoch 90, Loss: 0\n", + "Epoch 91, Loss: 0\n", + "Epoch 92, Loss: 0\n", + "Epoch 93, Loss: 0\n", + "Epoch 94, Loss: 0\n", + "Epoch 95, Loss: 0\n", + "Epoch 96, Loss: 0\n", + "Epoch 97, Loss: 0\n", + "Epoch 98, Loss: 0\n", + "Epoch 99, Loss: 0\n", + "Epoch 100, Loss: 0\n", + "Embedding for 'embeddings': [[-1.0344244 0.07897425 0.03608504 -0.556515 0.14206451 -1.833232\n", + " 0.7083351 0.66258 0.57552516 1.7009653 ]]\n" + ] + } + ], + "source": [ + "import torch\n", + "import torch.nn as nn\n", + "import torch.optim as optim\n", + "\n", + "# Define CBOW model\n", + "class CBOWModel(nn.Module):\n", + "\tdef __init__(self, vocab_size, embed_size):\n", + "\t\tsuper(CBOWModel, self).__init__()\n", + "\t\tself.embeddings = nn.Embedding(vocab_size, embed_size)\n", + "\t\tself.linear = nn.Linear(embed_size, vocab_size)\n", + "\n", + "\tdef forward(self, context):\n", + "\t\tcontext_embeds = self.embeddings(context).sum(dim=1)\n", + "\t\toutput = self.linear(context_embeds)\n", + "\t\treturn output\n", + "\n", + "# Sample data\n", + "context_size = 2\n", + "raw_text = \"word embeddings are awesome\"\n", + "tokens = raw_text.split()\n", + "vocab = set(tokens)\n", + "word_to_index = {word: i for i, word in enumerate(vocab)}\n", + "data = []\n", + "for i in range(2, len(tokens) - 2):\n", + "\tcontext = [word_to_index[word] for word in tokens[i - 2:i] + tokens[i + 1:i + 3]]\n", + "\ttarget = word_to_index[tokens[i]]\n", + "\tdata.append((torch.tensor(context), torch.tensor(target)))\n", + "\n", + "# Hyperparameters\n", + "vocab_size = len(vocab)\n", + "embed_size = 10\n", + "learning_rate = 0.01\n", + "epochs = 100\n", + "\n", + "# Initialize CBOW model\n", + "cbow_model = CBOWModel(vocab_size, embed_size)\n", + "criterion = nn.CrossEntropyLoss()\n", + "optimizer = optim.SGD(cbow_model.parameters(), lr=learning_rate)\n", + "\n", + "# Training loop\n", + "for epoch in range(epochs):\n", + "\ttotal_loss = 0\n", + "\tfor context, target in data:\n", + "\t\toptimizer.zero_grad()\n", + "\t\toutput = cbow_model(context)\n", + "\t\tloss = criterion(output.unsqueeze(0), target.unsqueeze(0))\n", + "\t\tloss.backward()\n", + "\t\toptimizer.step()\n", + "\t\ttotal_loss += loss.item()\n", + "\tprint(f\"Epoch {epoch + 1}, Loss: {total_loss}\")\n", + "\n", + "# Example usage: Get embedding for a specific word\n", + "word_to_lookup = \"embeddings\"\n", + "word_index = word_to_index[word_to_lookup]\n", + "embedding = cbow_model.embeddings(torch.tensor([word_index]))\n", + "print(f\"Embedding for '{word_to_lookup}': {embedding.detach().numpy()}\")\n" + ] + }, + { + "cell_type": "markdown", + "id": "f057334a", + "metadata": {}, + "source": [ + "#### Skip-Gram" + ] + }, + { + "cell_type": "markdown", + "id": "f38b64f9", + "metadata": {}, + "source": [ + "The Skip-Gram model learns distributed representations of words in a continuous vector space. The main objective of Skip-Gram is to predict context words (words surrounding a target word) given a target word. This is the opposite of the Continuous Bag of Words (CBOW) model, where the objective is to predict the target word based on its context. It is shown that this method produces more meaningful embeddings." + ] + }, + { + "cell_type": "markdown", + "id": "efa00238", + "metadata": {}, + "source": [ + ":::{figure} https://static-1300131294.cos.ap-shanghai.myqcloud.com/images/deep-learning/NLP/skipgram.png\n", + "---\n", + "name: 'skip gram'\n", + "width: 90%\n", + "---\n", + "Skip Gram\n", + ":::" + ] + }, + { + "cell_type": "markdown", + "id": "977b2fa3", + "metadata": {}, + "source": [ + "After applying the above neural embedding methods we get trained vectors of each word after many iterations through the corpus. These trained vectors preserve syntactical or semantic information and are converted to lower dimensions. The vectors with similar meaning or semantic information are placed close to each other in space.\n", + "\n", + "Let’s understand with a basic example. The python code contains, parameter that controls the dimensionality of the word vectors, and you can adjust other parameters such as based on your specific needs.vector_sizewindow" + ] + }, + { + "cell_type": "markdown", + "id": "87dc4e0e", + "metadata": {}, + "source": [ + ">Note: Word2Vec models can perform better with larger datasets. \n", + ">If you have a large corpus, you might achieve more meaningful word embeddings.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "bbe003fd", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Requirement already satisfied: gensim in d:\\anaconda\\lib\\site-packages (4.3.0)\n", + "Requirement already satisfied: FuzzyTM>=0.4.0 in d:\\anaconda\\lib\\site-packages (from gensim) (2.0.5)\n", + "Requirement already satisfied: numpy>=1.18.5 in d:\\anaconda\\lib\\site-packages (from gensim) (1.23.5)\n", + "Requirement already satisfied: scipy>=1.7.0 in d:\\anaconda\\lib\\site-packages (from gensim) (1.10.0)\n", + "Requirement already satisfied: smart-open>=1.8.1 in d:\\anaconda\\lib\\site-packages (from gensim) (5.2.1)\n", + "Requirement already satisfied: pyfume in d:\\anaconda\\lib\\site-packages (from FuzzyTM>=0.4.0->gensim) (0.2.25)\n", + "Requirement already satisfied: pandas in d:\\anaconda\\lib\\site-packages (from FuzzyTM>=0.4.0->gensim) (1.5.3)\n", + "Requirement already satisfied: python-dateutil>=2.8.1 in d:\\anaconda\\lib\\site-packages (from pandas->FuzzyTM>=0.4.0->gensim) (2.8.2)\n", + "Requirement already satisfied: pytz>=2020.1 in d:\\anaconda\\lib\\site-packages (from pandas->FuzzyTM>=0.4.0->gensim) (2022.7)\n", + "Requirement already satisfied: fst-pso in d:\\anaconda\\lib\\site-packages (from pyfume->FuzzyTM>=0.4.0->gensim) (1.8.1)\n", + "Requirement already satisfied: simpful in d:\\anaconda\\lib\\site-packages (from pyfume->FuzzyTM>=0.4.0->gensim) (2.11.0)\n", + "Requirement already satisfied: six>=1.5 in d:\\anaconda\\lib\\site-packages (from python-dateutil>=2.8.1->pandas->FuzzyTM>=0.4.0->gensim) (1.16.0)\n", + "Requirement already satisfied: miniful in d:\\anaconda\\lib\\site-packages (from fst-pso->pyfume->FuzzyTM>=0.4.0->gensim) (0.0.6)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[nltk_data] Downloading package punkt to\n", + "[nltk_data] C:\\Users\\zhongmeiqi\\AppData\\Roaming\\nltk_data...\n", + "[nltk_data] Package punkt is already up-to-date!\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Vector representation of 'word': [-9.5800208e-03 8.9437785e-03 4.1664648e-03 9.2367809e-03\n", + " 6.6457358e-03 2.9233587e-03 9.8055992e-03 -4.4231843e-03\n", + " -6.8048164e-03 4.2256550e-03 3.7299085e-03 -5.6668529e-03\n", + " 9.7035142e-03 -3.5551414e-03 9.5499391e-03 8.3657773e-04\n", + " -6.3355025e-03 -1.9741615e-03 -7.3781307e-03 -2.9811086e-03\n", + " 1.0425397e-03 9.4814906e-03 9.3598543e-03 -6.5986011e-03\n", + " 3.4773252e-03 2.2767992e-03 -2.4910474e-03 -9.2290826e-03\n", + " 1.0267317e-03 -8.1645092e-03 6.3240929e-03 -5.8001447e-03\n", + " 5.5353874e-03 9.8330071e-03 -1.5987856e-04 4.5296676e-03\n", + " -1.8086446e-03 7.3613892e-03 3.9419360e-03 -9.0095028e-03\n", + " -2.3953868e-03 3.6261671e-03 -1.0080514e-04 -1.2024897e-03\n", + " -1.0558038e-03 -1.6681013e-03 6.0541567e-04 4.1633579e-03\n", + " -4.2531900e-03 -3.8336846e-03 -5.0755290e-05 2.6549282e-04\n", + " -1.7014991e-04 -4.7843382e-03 4.3120929e-03 -2.1710952e-03\n", + " 2.1056964e-03 6.6702347e-04 5.9686624e-03 -6.8418151e-03\n", + " -6.8183104e-03 -4.4762432e-03 9.4359247e-03 -1.5930856e-03\n", + " -9.4291316e-03 -5.4270827e-04 -4.4478951e-03 5.9980620e-03\n", + " -9.5831212e-03 2.8602476e-03 -9.2544509e-03 1.2484600e-03\n", + " 6.0004774e-03 7.4001122e-03 -7.6209377e-03 -6.0561695e-03\n", + " -6.8399287e-03 -7.9184016e-03 -9.4984965e-03 -2.1255787e-03\n", + " -8.3757477e-04 -7.2564054e-03 6.7876028e-03 1.1183097e-03\n", + " 5.8291717e-03 1.4714618e-03 7.9081533e-04 -7.3718326e-03\n", + " -2.1769912e-03 4.3199472e-03 -5.0856168e-03 1.1304744e-03\n", + " 2.8835384e-03 -1.5386029e-03 9.9318363e-03 8.3507905e-03\n", + " 2.4184163e-03 7.1170190e-03 5.8888551e-03 -5.5787875e-03]\n" + ] + } + ], + "source": [ + "!pip install gensim\n", + "from gensim.models import Word2Vec\n", + "from nltk.tokenize import word_tokenize\n", + "import nltk\n", + "nltk.download('punkt') # Download the tokenizer models if not already downloaded\n", + "\n", + "sample = \"Word embeddings are dense vector representations of words.\"\n", + "tokenized_corpus = word_tokenize(sample.lower()) # Lowercasing for consistency\n", + "\n", + "skipgram_model = Word2Vec(sentences=[tokenized_corpus],\n", + "\t\t\t\t\t\tvector_size=100, # Dimensionality of the word vectors\n", + "\t\t\t\t\t\twindow=5,\t\t # Maximum distance between the current and predicted word within a sentence\n", + "\t\t\t\t\t\tsg=1,\t\t\t # Skip-Gram model (1 for Skip-Gram, 0 for CBOW)\n", + "\t\t\t\t\t\tmin_count=1,\t # Ignores all words with a total frequency lower than this\n", + "\t\t\t\t\t\tworkers=4)\t # Number of CPU cores to use for training the model\n", + "\n", + "# Training\n", + "skipgram_model.train([tokenized_corpus], total_examples=1, epochs=10)\n", + "skipgram_model.save(\"skipgram_model.model\")\n", + "loaded_model = Word2Vec.load(\"skipgram_model.model\")\n", + "vector_representation = loaded_model.wv['word']\n", + "print(\"Vector representation of 'word':\", vector_representation)\n" + ] + }, + { + "cell_type": "markdown", + "id": "42cda55f", + "metadata": {}, + "source": [ + "In practice, the choice between CBOW and Skip-gram often depends on the specific characteristics of the data and the task at hand. CBOW might be preferred when training resources are limited, and capturing syntactic information is important. Skip-gram, on the other hand, might be chosen when semantic relationships and the representation of rare words are crucial." + ] + }, + { + "cell_type": "markdown", + "id": "4ea1f37d", + "metadata": {}, + "source": [ + "## Pretrained Word-Embedding" + ] + }, + { + "cell_type": "markdown", + "id": "59ead5c0", + "metadata": {}, + "source": [ + "Pre-trained word embeddings are representations of words that are learned from large corpora and are made available for reuse in various natural language processing (NLP) tasks. These embeddings capture semantic relationships between words, allowing the model to understand similarities and relationships between different words in a meaningful way." + ] + }, + { + "cell_type": "markdown", + "id": "2c887969", + "metadata": {}, + "source": [ + "### GloVe" + ] + }, + { + "cell_type": "markdown", + "id": "0b8a6505", + "metadata": {}, + "source": [ + "GloVe is trained on global word co-occurrence statistics. It leverages the global context to create word embeddings that reflect the overall meaning of words based on their co-occurrence probabilities. this method, we take the corpus and iterate through it and get the co-occurrence of each word with other words in the corpus. We get a co-occurrence matrix through this. The words which occur next to each other get a value of 1, if they are one word apart then 1/2, if two words apart then 1/3 and so on.\n", + "\n", + "Let us take an example to understand how the matrix is created. We have a small corpus:" + ] + }, + { + "cell_type": "markdown", + "id": "ef94e71e", + "metadata": {}, + "source": [ + ">Corpus:\n", + ">\n", + ">It is a nice evening.\n", + ">\n", + ">Good Evening!\n", + ">\n", + ">Is it a nice evening?" + ] + }, + { + "cell_type": "markdown", + "id": "394c071b", + "metadata": {}, + "source": [ + "| |it|is|a|nice|evening|good|\n", + "|----------|----------|----------|----------|----------|----------|----------|\n", + "|it|0|\n", + "|is|1+1|0|\n", + "|a|1/2+1|1+1/2|0|\n", + "|nice|1/3+1/2|1/2+1/3|1+1|0|\n", + "|evening|1/4+1/3|1/3+1/4|1/2+1/2|1+1|0|\n", + "|good|0|0|0|0|1|0|\n" + ] + }, + { + "cell_type": "markdown", + "id": "4bd03226", + "metadata": {}, + "source": [ + "The upper half of the matrix will be a reflection of the lower half. We can consider a window frame as well to calculate the co-occurrences by shifting the frame till the end of the corpus. This helps gather information about the context in which the word is used.\n", + "\n", + "Initially, the vectors for each word is assigned randomly. Then we take two pairs of vectors and see how close they are to each other in space. If they occur together more often or have a higher value in the co-occurrence matrix and are far apart in space then they are brought close to each other. If they are close to each other but are rarely or not frequently used together then they are moved further apart in space.\n", + "\n", + "After many iterations of the above process, we’ll get a vector space representation that approximates the information from the co-occurrence matrix. The performance of GloVe is better than Word2Vec in terms of both semantic and syntactic capturing." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ae3737fa", + "metadata": {}, + "outputs": [], + "source": [ + "from gensim.models import KeyedVectors\n", + "from gensim.downloader import load\n", + "\n", + "glove_model = load('glove-wiki-gigaword-50')\n", + "word_pairs = [('learn', 'learning'), ('india', 'indian'), ('fame', 'famous')]\n", + "\n", + "# Compute similarity for each pair of words\n", + "for pair in word_pairs:\n", + "\tsimilarity = glove_model.similarity(pair[0], pair[1])\n", + "\tprint(f\"Similarity between '{pair[0]}' and '{pair[1]}' using GloVe: {similarity:.3f}\")\n" + ] + }, + { + "cell_type": "markdown", + "id": "28c55b60", + "metadata": {}, + "source": [ + "Output:\n", + "\n", + ">Similarity between 'learn' and 'learning' using GloVe: 0.802\n", + ">\n", + ">Similarity between 'india' and 'indian' using GloVe: 0.865\n", + ">\n", + ">Similarity between 'fame' and 'famous' using GloVe: 0.589" + ] + }, + { + "cell_type": "markdown", + "id": "e2847def", + "metadata": {}, + "source": [ + "### Fasttext" + ] + }, + { + "cell_type": "markdown", + "id": "dfec4ddf", + "metadata": {}, + "source": [ + "Developed by Facebook, FastText extends Word2Vec by representing words as bags of character n-grams. This approach is particularly useful for handling out-of-vocabulary words and capturing morphological variations." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "eebd305d", + "metadata": {}, + "outputs": [], + "source": [ + "import gensim.downloader as api\n", + "fasttext_model = api.load(\"fasttext-wiki-news-subwords-300\") ## Load the pre-trained fastText model\n", + "# Define word pairs to compute similarity for\n", + "word_pairs = [('learn', 'learning'), ('india', 'indian'), ('fame', 'famous')]\n", + "\n", + "# Compute similarity for each pair of words\n", + "for pair in word_pairs:\n", + "\tsimilarity = fasttext_model.similarity(pair[0], pair[1])\n", + "\tprint(f\"Similarity between '{pair[0]}' and '{pair[1]}' using FastText: {similarity:.3f}\")\n" + ] + }, + { + "cell_type": "markdown", + "id": "157465a1", + "metadata": {}, + "source": [ + "Output:\n", + "\n", + ">Similarity between 'learn' and 'learning' using Word2Vec: 0.642\n", + ">\n", + ">Similarity between 'india' and 'indian' using Word2Vec: 0.708\n", + ">\n", + ">Similarity between 'fame' and 'famous' using Word2Vec: 0.519" + ] + }, + { + "cell_type": "markdown", + "id": "81b1af62", + "metadata": {}, + "source": [ + "### BERT (Bidirectional Encoder Representations from Transformers)" + ] + }, + { + "cell_type": "markdown", + "id": "5c151177", + "metadata": {}, + "source": [ + "BERT is a transformer-based model that learns contextualized embeddings for words. It considers the entire context of a word by considering both left and right contexts, resulting in embeddings that capture rich contextual information." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "332b65ea", + "metadata": {}, + "outputs": [], + "source": [ + "from transformers import BertTokenizer, BertModel\n", + "import torch\n", + "\n", + "# Load pre-trained BERT model and tokenizer\n", + "model_name = 'bert-base-uncased'\n", + "tokenizer = BertTokenizer.from_pretrained(model_name)\n", + "model = BertModel.from_pretrained(model_name)\n", + "\n", + "word_pairs = [('learn', 'learning'), ('india', 'indian'), ('fame', 'famous')]\n", + "\n", + "# Compute similarity for each pair of words\n", + "for pair in word_pairs:\n", + "\ttokens = tokenizer(pair, return_tensors='pt')\n", + "\twith torch.no_grad():\n", + "\t\toutputs = model(**tokens)\n", + "\t\n", + "\t# Extract embeddings for the [CLS] token\n", + "\tcls_embedding = outputs.last_hidden_state[:, 0, :]\n", + "\n", + "\tsimilarity = torch.nn.functional.cosine_similarity(cls_embedding[0], cls_embedding[1], dim=0)\n", + "\t\n", + "\tprint(f\"Similarity between '{pair[0]}' and '{pair[1]}' using BERT: {similarity:.3f}\")\n" + ] + }, + { + "cell_type": "markdown", + "id": "a58c5b0d", + "metadata": {}, + "source": [ + "Output:\n", + "\n", + ">Similarity between 'learn' and 'learning' using BERT: 0.930\n", + ">\n", + ">Similarity between 'india' and 'indian' using BERT: 0.957\n", + ">\n", + ">Similarity between 'fame' and 'famous' using BERT: 0.956" + ] + }, + { + "cell_type": "markdown", + "id": "66f947fb", + "metadata": {}, + "source": [ + "## Considerations for Deploying Word Embedding Models" + ] + }, + { + "cell_type": "markdown", + "id": "6a613911", + "metadata": {}, + "source": [ + "+ You need to use the exact same pipeline during deploying your model as were used to create the training data for the word embedding. If you use a different tokenizer or different method of handling white space, punctuation etc. you might end up with incompatible inputs." + ] + }, + { + "cell_type": "markdown", + "id": "5fa07fb4", + "metadata": {}, + "source": [ + "+ Words in your input that doesn’t have a pre-trained vector. Such words are known as Out of Vocabulary Word(oov). What you can do is replace those words with “UNK” which means unknown and then handle them separately." + ] + }, + { + "cell_type": "markdown", + "id": "6a10d779", + "metadata": {}, + "source": [ + "+ Dimension mis-match: Vectors can be of many lengths. If you train a model with vectors of length say 400 and then try to apply vectors of length 1000 at inference time, you will run into errors. So make sure to use the same dimensions throughout." + ] + }, + { + "cell_type": "markdown", + "id": "d15dc1cd", + "metadata": {}, + "source": [ + "## Advantages and Disadvantage of Word Embeddings" + ] + }, + { + "cell_type": "markdown", + "id": "bfef3ca2", + "metadata": {}, + "source": [ + "### Advantages" + ] + }, + { + "cell_type": "markdown", + "id": "e3250120", + "metadata": {}, + "source": [ + "+ It is much faster to train than hand build models like WordNet (which uses graph embeddings).\n", + "+ Almost all modern NLP applications start with an embedding layer.\n", + "+ It Stores an approximation of meaning." + ] + }, + { + "cell_type": "markdown", + "id": "9c43e912", + "metadata": {}, + "source": [ + "### Disadvantages" + ] + }, + { + "cell_type": "markdown", + "id": "e57b362a", + "metadata": {}, + "source": [ + "+ It can be memory intensive.\n", + "+ It is corpus dependent. Any underlying bias will have an effect on your model.\n", + "+ It cannot distinguish between homophones. Eg: brake/break, cell/sell, weather/whether etc." + ] + }, + { + "cell_type": "markdown", + "id": "f18cb460", + "metadata": {}, + "source": [ + "## Conclusion" + ] + }, + { + "cell_type": "markdown", + "id": "88044847", + "metadata": {}, + "source": [ + "In conclusion, word embedding techniques such as TF-IDF, Word2Vec, and GloVe play a crucial role in natural language processing by representing words in a lower-dimensional space, capturing semantic and syntactic information." + ] + }, + { + "cell_type": "markdown", + "id": "13556362", + "metadata": {}, + "source": [ + "## Your turn! 🚀\n", + "\n", + "Assignment - [News topic classification tasks](../assignments/deep-learning/nlp/news-topic-classification-tasks.ipynb)\n", + "\n", + "## Acknowledgments\n", + "\n", + "Thanks to [GeeksforGeeks](https://auth.geeksforgeeks.org/user/shristikotaiah/articles?utm_source=geeksforgeeks&utm_medium=article_author&utm_campaign=auth_user) for creating the open-source project [Word Embeddings in NLP](https://www.geeksforgeeks.org/word-embeddings-in-nlp).It inspire the majority of the content in this chapter." + ] + } + ], + "metadata": { + "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.9.13" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From 9311ac5d8150fdf204112ff66732b7f36aa835ab Mon Sep 17 00:00:00 2001 From: fuqiongying <3047530642@qq.com> Date: Sun, 31 Mar 2024 08:10:30 +0800 Subject: [PATCH 2/6] update link of assignment --- .../nlp/news-topic-classification-tasks.ipynb | 49 ------------------- .../nlp/text-preprocessing.ipynb | 2 +- .../nlp/text-representation.ipynb | 2 +- 3 files changed, 2 insertions(+), 51 deletions(-) diff --git a/open-machine-learning-jupyter-book/assignments/deep-learning/nlp/news-topic-classification-tasks.ipynb b/open-machine-learning-jupyter-book/assignments/deep-learning/nlp/news-topic-classification-tasks.ipynb index 955d7dc98..b7f50f462 100644 --- a/open-machine-learning-jupyter-book/assignments/deep-learning/nlp/news-topic-classification-tasks.ipynb +++ b/open-machine-learning-jupyter-book/assignments/deep-learning/nlp/news-topic-classification-tasks.ipynb @@ -80,37 +80,6 @@ "print(list(train_dataset)[:3])" ] }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "**Basic information of the data:**" - ] - }, - { - "attachments": { - "image.png": { - "image/png": "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" - } - }, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "![image.png](attachment:image.png)" - ] - }, - { - "attachments": { - "image.png": { - "image/png": "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" - } - }, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "![image.png](attachment:image.png)" - ] - }, { "cell_type": "markdown", "metadata": {}, @@ -142,24 +111,6 @@ "**The length of the sentences in the sample was analyzed: more than 90% of the sentences were not more than 50 in length, so 50 words were subsequently intercepted.**" ] }, - { - "attachments": { - "image-2.png": { - "image/png": "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" - }, - "image-3.png": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAbcAAAFhCAIAAAB8knOOAAAgAElEQVR4Aeyca1gU15rv68N5zif4oOfR0Xn2wOyMDJPH6dNnT6Yf4vY4W494mR0dE49mj0azJWzAcIh7R2O8xFZponYwtkjwEqNcFPEWsxU0AqKCtCAJclEQ5CoCEZsGbLqLO1XH8Z28s3ZVd9GI0NC8/QFXrbVqrff9rbf+tdaqKjmRfkSACBABIuCYAOe4iEqIABEgAkRAJJWkICACRIAIKBEglVSiQ2VEgAgQAVJJigEiQASIgBIBUkklOlRGBIgAESCVpBggAkSACCgRIJVUokNlRIAIEAFSSYoBIkAEiIASAVJJJTpURgSIABEglaQYIAJEgAgoESCVVKLjNmVGo5HjOLVaXV5ePqBTOp2O47iQkJCOjo4BK8srDKov+elO5pjN5gULFhiNRifry6uNjJ3yfl8up6OjIyQkJDEx8eVOH7GzysvL1Wo1x3FDGZpBWSshMxwGkEoOakTGauVBKcLoV8lXciUMiolrBx5uCRzHkUpKBkJO5pXEhqQXUkkJEPc8HJQijBOVHEMjLdeCUWv8cIiUgrNyMsNhAKmkwhC4T5FcJTGYuBc/dn2NKllYWAirJ/ksBpY5cK5keSXvKzExEWvKmxosZUlrsI2ANn/99dfQF0y7FNyU2ImHhYWFISEh0MiCBQvMZrOTFkoMk8z7FIihkUajERxht0fAMBYgLGZfukF0hzVY7ilaMqghY33Bjhw1xVbGOvJ9ISwKCQmpr69fsGABmGSXjJNtom3OJEglnaE05uugBMC+JEYSe+2hUGJQsqUcx+l0OgCBN3C2AoqCpC/2UsT6WPklyEoaZFUS24dMZTcldsovOWhNLh92bZZYBeeim8rE7NqJQik3zGg0DqVBsF8+yihPEv0FX3D07bqPmeiLXSmXNIWVIR//KlsC1RITE+2ScdSmk+OIjrAJUkmWhtumJYoAVwjGPVzhGJp4/WAFzIHQh0MMOzgdD9m+8HqTNIWVX444Xgn4iAAtRGESRREysWuJm6ydoijiJSe/W2Avjqwd0E1lYugOYkHNBXdQE9G7ITaIzkKDaACwUgblCALkY1MATbkprOzIcYmdyBmnt3Iy8jaxkQHH0ZFrpJKOyLhVPgQK6iD6hkGGMxcUFwxcURSxWmJiIpuGdjAHopDtSx7W2PVQEnglYNxLVEPSOFrIusnayaoktinvRdIsHiq7ib2jxmEO9IUdyStADta3e8gOkJMNAi68H4D90Dj6gncXzEHz0HF5An0xGo14oqOmsDK2LPFUPqySUyT1RVGUVGDhYC9ys5VzSCWV+bhJqUQRMLZwjcPKh+QSEkWRDXeMQvZcXASh3KAiQ9dYmRXfl4aLNqCiyW1mLw/snXVTwkRyyF5v2IuCwQpuorWsGSwxrIAd4QDBhS05xPov3aBdXOAd9iVvHMVOgQPa5mhbAJqFptjKkt7BcbmdaJ5dMnZHTXKKgvGOikglHZFxq3xWAlDycKtRsiyShyaeotPpMLLlVxEELtsXQsQlJJyFsxisMKgE2oCyomCzIzcldkoO7V5vAxpp10201hExrIDuSC5sySHWf+kG5bjQNexL3jipJFKihBsSYCUALwO8Ju2qJDvpw1PsrrglvNi+JEU405Q8FpdXU85BmUAX5Jc92ox1JG5K7JQcvpxKotnQGriJlsBdBOtgQu6O5BTlQ2wHEwM2CLjYIdbpdHDrYu+I2KDzCbbrAZtiK0MXEk/lduIpNJd0flCoplMEWAnAQISpAR7iGhlCE6dguFMpqYDXGNs46iBUxsZxGiKJcqesl1XCRlABFVTSkZsKZkOH8l5khvxnxoBuSq52SdfyjrBBR1owxAbBAPkzEBBKye1Ebp4jDvJbi3JT8pYljkvsRNmVW453oAHbVDDeURGtuB2Rcat8yWWJOsiuqiQiyBZBWq50bB0slfQF1wlbk+M4VNiXo4zXEu4zylUSxV3SNbopsVNyKL/glU1VdhMvXdYYJIalKProIFz8rDrA/BRPebkGHcEBA7B3tnEnN0nQMGeaklRmt5LtOs5x3Pz58+EdXrsVjEbjgG0qj6PdUlJJu1jcLVMiAexVJ3lTF6+fkJAQ598qxzu5ZC4JHDFw4apz8npTHgNWlfBlbEnLym5KmEgOB6uSbH27brLG4FRIwseRSiJVaNmuQLBDgMAVGhRFkWWINw/Ezt5KUdCx1FFC3jVGFBjPNiWvjALNuoOW6HQ6eQUYOCTjZJuO7LebTyppFwtlEgEiMBoJyFVyBKwklRwByNQFESACL0MAZ7s4tZRP+V+m3UGeQyo5SGBUffwRkCyWYXHH/sVr2O3Z4OKXdR/T7Gr6laDA5TN2AQnJ1sor6UuhEVJJBThURAT+gwCpJMbBCKsk+zwHhfKVazF65yhBKumIDOUTASJABP6DAKkkxQERIAJEQIkAqaQSHSojAkSACJBKUgwQASJABJQIkEoq0aEyIkAEiACpJMUAESACRECJAKmkEh0qIwJEgAiQSlIMEAEiQASUCJBKKtGhMiJABIgAqSTFABEgAkRAicDAKokfBlGCCBABIuCuBBRkcmCV5OlHBIgAEXB3AqSS7j7C5B8RIAJDI0AqOTR+dDYRIALuToBU0t1HmPwjAkRgaARIJYfGj84mAkTA3QmQSrr7CJN/RIAIDI0AqeTQ+NHZRIAIuDsBUkl3H2HyjwgQgaERIJUcGj86mwgQAXcnQCrp7iNM/hEBIjA0AqSSQ+NHZxMBIuDuBEgl3X2EyT8iQASGRsDNVbK+vt7f3z8jI2NolP7r7NTU1EWLFtXX1/9XFs/X1dVt3rzZx8eH4ziNRhMXF9fa2ooVzGbz3r17fXx8PDw8Fi9efPPmTZvNNgKl2AUkXGXGUPqVuDA+DynkXu1VY7FY4uPjNRoNx3GzZ88+f/681WpVDi13VsmioiKVSsVx3CtRSZvNlpGRoVKp/P39WZWsra1dtGjRG2+8cfTo0StXrmzevNnDwyMiIsJisfA839raum7dOh8fH71ef+HChXfffdfLywvtGb5SyagPX0fD17LEhXF4SCH3yq8am80WGRk5YcKEbdu2Xbx4ce3atZMmTYqPj1eOLlJJZT7/WdrU1KTX6ydMmMBxnEQlDx06pFKpCgoKoKrNZouJifH19c3Pz+d5Pisry8vLKzk5GUpNJlNAQMCqVatMJtOwlkq8cpUZQ+lX4sJ4O6SQG46rprS0VKPRxMTEwHrOYrFs3759zpw51dXVCgE27Cqp1Wrxf50LDAw0m82sNRkZGViqUqmKioqwFE5kT4mNjeU4DqvBuSqVKjc3NzAwENpBCYPKjhrHXpxMaLVaDw+PTZs2HThwALuAqeLGjRs/+OCD5uZmbCo3N/eXv/wlTBj1ev28efMeP36MpefOnUMXhq8Uu4PE8HU0fC1LXBhvhxRyw3HVsFcfRJTRaGSXd3bDbBhV0mw2o3ihWrESwwooVoiNjQVDnVRJPBET0MWrVUmDwXD58mWr1RobG8u6YJdpUlLSlClTjEZjS0tLcHAwK/Q8z+fl5U2bNi0tLW34SiVWDV9Hw9eyxIVxeEghx86oXslVw/N8eHi45PqtqqqaNWvWN998oxBjw6iSqFMwq8JpI+ig5JDneZBFnGc5r5IoQyi70OOr3ZcEiAOqJGxTwpoa7hNbt25lH9eAVbGxscNXKhnv4eto+FqWuDCeDynkeJ5/JVcNiMyaNWvYlR884NVqtQoxNlwqCdcPx3HYveRxs1wEoQLHcSCj8gp2V9zswxmJLEoOFSg4X6Qcsg0NDQEBARqNBrYpnz59+t577yEB6AXHe/hKJe4MX0fD17LEhfF8SCHHquRQQq69vX3jxo04qYKgGl0qyQa6XEN5npdkOqmSOPdElKibI6ySlZWVS5cu1Wg0RqMRnB2+qZZyyyxqBDvyU1plI5VLJS6M50MFlaSQg8DAmceAQaXVakf1XJINdHCGnWnixYyZY0sl8/PzZ8yYMXfu3OLiYvR0+LbtlFtGAyChXHl0lkpcGM+HjlSSQg6jwsldy1G3L4k6iPNbyMHlp1wEX27FPRrmkjdu3FCpVCtWrKirq8ORg4TdR8DTp08vLCzkeX74SkeJGUNxUOLCuD20q5IUcpIn4E5eU+eYN0wgooxG45QpU9LS0hQCbLj2JXmelzy9wfUvCOWAT28cnY6yiG8C4ftD2MVIPr0pKCjQaDTBwcHwCqSEdRa9L/myr4tKSI7bQ7lKUsi99DvIo+59SZxO4js67NuO+FCbLcUtRZ7nUUYlFZxXSZycSvodyvUmCVn48mTSpEnr1q2L+MsfLL3NZvPatWu9vLzYrwhSU1PBhuErBd/ZibxLzBiKg0MZJnc6l0IOvlh7JVdNe3v7rl27PDw8Nm/ejN/exMXFsW+hyINnGOeS0BmsrEHpJG8qSaQQ5Q+tZIVSq9XafcbNniWZS7LzWVZ/sf2XSEhCtqys7M0335ToOBzCfJbneZPJFBkZ6eg77mEqlaikq8wYYr8vMUDudwqFnPw77qFcNa2trXFxcfQdt/tdKeQRESACLiMw7HNJl3lGHRMBIkAEXgUBUslXQZHaIAJEwH0JkEq679iSZ0SACLwKAqSSr4IitUEEiID7EiCVdN+xJc+IABF4FQRIJV8FRWqDCBAB9yVAKum+Y0ueEQEi8CoIkEq+CorUBhEgAu5LgFTSfceWPCMCROBVECCVfBUUqQ0iQATclwCppPuOLXlGBIjAqyBAKvkqKFIbRIAIuC8BUkn3HVvyjAgQgVdBYEgqqXAyFREBIkAE3J4A5/YekoNEgAgQgaEQIJUcCj06lwgQAfcnQCrp/mNMHhIBIjAUAqSSQ6FH5xIBIuD+BEgl3X+MyUMiQASGQoBUcij06FwiQATcnwCppPuPMXlIBIjAUAiQSg6FHp1LBIiA+xMglXT/MSYPiQARGAoBUsmh0KNziQARcH8CpJLuP8bkIREgAkMhQCo5FHojca7JZNJqtb6+vhzH+fn5JSUldXV1Oer4zJkz3F/+FixYYDaboX5HR8eBAwd8fX09PT3ffvvt3NxcQRCwKVeVogGUGDECLS0tu3bt8vb29vT0XL58+d27d9lIaGlp+eyzz7y9vTmOmzt37rVr1/r7+x3Z1tvbe+HChblz53Ic5+vrGxUVZbPZ5JVbW1uXL1+u0+nYImUzBgzmw4cPq1Qqu0Z2dHQolLI2OJMmlXSGksvqNDU1LVmyRKPRxMfHZ2RkaLVaT09PvV7f29tr1yadTjdz5syIiAj9z7/Dhw9brVZRFLu6ujZs2ODr62swGC5fvrxixQpvb2+j0QjtuKrUrheUOawEbDZbaGioWq2OjY3FSMjMzIROQc4gTtLT08PCwiZPnnz69Gm7JvX29ur1+okTJ4aHh2dkZBgMBm9v7w0bNkhu5FCN4zhWJZXNEEVRIZihQW9vb4PBgEaeOnUKtF651K4jypmkksp8XFx67NgxtVr94MEDsEMQhKNHj77++uslJSVyy3ie/8Mf/rBjxw52XoDV8vLyvL2909LSIMdmswUFBa1Zswbu/K4qRfMoMWIELl26NHXq1KysLOjRYrG8//77oaGhnZ2doijm5uZOnjwZ46Srq2vdunXLli179uyZ3MKSkhKVSoXyJIrihQsX5PF5/fp1tVo9ffp0ViWVzVAO5vz8/KlTpyYmJoJJvb29W7dufeutt1pbW0VRVC6VezFgzqtRSZ1Ox3FcSEhIYWGhWq2GNR/MU6CI4zh26SeKYkdHR0hICK4OcVIDFpeXl2M70HJHRwcUGY1GjuPUanVhYSG2IGl8QLfHRIWurq6tW7cGBwfzPI8GFxYWvvbaaxJcUGoymfz9/TF08BRIGAyGhQsXNjc3Y/6lS5fUanV5ebkoiq4qRWMoMWIEoqOj33//fVS97u7ujz/+OCQkBC4xo9Ho4+NTXFyM9uh0OkfXl8FgWL16dXt7O1aWJx48ePCb3/wmJSUlJCSEVUllM5SD+eLFi//2b//26NEj7M5gMKCRyqV4ivOJV6mSKHmQUKvV8+fPZzNxJMxm84IFC9gijuPw8pZIJFTDc0ElJefKVdh5BGOr5oULF6ZOnZqfny83u6ys7Fe/+tXp06cDAgI8PT3ZTczOzs7Q0FBkCOcWFxf7+PhkZWW5qlTuAuWMMAGbzXby5EkfHx9cUzc2Ns6fPz8oKOj5hnh/f39ubq6fn19kZGRfX5/ENpjo6HS6e/fuvf/++5KQg8qwrNbr9RaLRaKSbGtyMxSCmT1RFMXu7u6rV6+q1Wq7RiqXSppydPiKVRKUDoUMpyowo0SxlxwmJiayMgeleNuBUmwKG8drHqerdmdYjjwfi/mwTYnLZIkL6enpHMfBJiZs1uAmJgS0ZDEOd6PExERXlUrsp8MRJoAXTkxMDLvT3djY+Lvf/Q4nIgcOHJDsM4Kdra2tb7311q9+9SuNRmMwGDIyMj755BNPT09UK0EQoqKili9f3traipIq99GuGQrBzLYA4sBx3ObNm+VPjZRL2XaU069SJVEEcaqISofL5PLycizFySPmSGQO82GJDWtDVEmsjHNPzFH2eYyWtrS0BAUF+fn54TalxJHTp0/Pnj0bS/v7+48cOTJ16tS8vDyr1fr73/8ehwNORJV0VanEfjocSQI9PT23bt1KT0/ftGkT3k1FUWxqalq+fDl7r506deqJEyfkc0m4PKdOnXr9+nWwvL+/32Aw4L5kZmYmBqQjlXRkhkIws5Tu3LmTkZGxZ88eb2/v0NBQiVAql7LtKKdfpUri5A7VDXWQVUkUNbxZYQLq4+mYL1dJnFqKoogNurFKNjQ0LF++3M/Pz+5a29EYA5kjR464arao3K8jsyl/JAnAI0G4mwqCsG/fPvZOLAjCyZMnvb29CwsLJVbBdSp5sFNWVqZSqc6cOdPQ0ODv748PdhypJLbJmoGZbAKDmc3EdFpamqen54ULFzCHTSiXsjXtpkedSgJN0EeY+9hdcY8rlSwpKZk5c+b8+fMrKirsjiJmdnd3Y1oURdgC1+l0rtp5VO6XNZXSLiQA0paYmNje3r569eotW7awM8dHjx79+te/xhkP2gmVcW4E+aBliS9+7CyHTcubgnPRDDh0FMxoAJvAUGczMa1citUcJVygkjhVtAsLS3FiOM5VMicnR61Wr1692mQyORpFfGdA8sARns+cOXPG0VNslUpVVlbmwlIFj6hoOAh0dnZu2rTpT3/6E7vViHEyKJXs6+vbsmWL5MUJaCo9Pf3Ro0c3mV9aWtrbb78dFBR08+bNR48eKZsBUyWFYN6/fz9sdyKixsbG2bNn7969WxRF5VI8xfmEC1QS3hdlH9ew63FUSZhI4iFOHtnK4Kcbr7gfPHjg5+cn33CxO8DHjh3z9vbG14N7e3sjIiL8/PxqampEUXTVG5HK/dp1hDKHlQBsHeK7PvAONmwmwopb8oruyZMnYT0utyojI2Py5Mm4rJaEHFtfvuJWMEMUReVgvnTpkqenJ77UKQjCqVOnJk+enJGRIYqicilrlZNp16gk6ho7D8dnC/jMiy0dhyoJ38NMnjx5w4YNP39K85//wtIbbiG45IEn4L6+vkeOHElPT//www89PT0xgjs6OsLCwuBzBfkXF64qdTJMqdorJMB+0CX/cOXx48e//e1vNRrNoUOHMjIywsPDJ06ciJ97SUIOXvSBb2/S09M/+eQTVjRZm+UqqWyGcjBDv/CBkNxI5VLWKifTrlFJXCGiDrKrb3ZrMiQkpL6+Hl6uhDrjZy4J+0GIiE3AdoQkZGEjEr7AhS+1MzMz2e9wbDZbVFSUo++4XVXqZKRStVdIwGQysXFy48YN9kttLIVPpL/99ltcnstDDr6Y9vPzg8rJyclsU2izXCXl4erIDOVglhspiiIGs91StMrJxKtRSSc7o2pEgAgQgTFHgFRyzA0ZGUwEiMCIEiCVHFHc1BkRIAJjjgCp5JgbMjKYCBCBESVAKjmiuKkzIkAExhwBUskxN2RkMBEgAiNKgFRyRHFTZ0SACIw5AqSSY27IyGAiQARGlACp5Ijips6IABEYcwRIJcfckJHBRIAIjCgBUskRxU2dEQEiMOYIkEqOuSEjg4kAERhRAqSSI4qbOiMCRGDMESCVHHNDRgYTASIwogQGVkmefkSACBABdyegoLukku4++OQfESACThAglXQCElUhAkRgHBMglRzHg0+uEwEi4AQBUkknIFEVIkAExjEBUslxPPjkOhEgAk4QIJV0AhJVIQJEYBwTIJUcx4NPrhMBIuAEAVJJJyBRFSJABMYxAVLJcTz45DoRIAJOECCVdAISVSECRGAcEyCVHMeDT64TASLgBIGxrZL19fX+/v4ZGRmOPC0qKlKpVBzHKdRxdO7Yyi8oKFi4cGFRUZEzZitUTk1NXbRoUX19PdtOQ0PDp59+6uXlxXHc7NmzL1++bLVasYLZbN67d6+Pj4+Hh8fixYtv3rxps9mwtKGhYefOnV5eXh4eHkuXLr19+zZb+vDhw48++sjLy2vChAmrV6++c+cOW4qNUGLkCdiNBOWxlhhpsViSkpJmz57NcZyPj09kZKTJZMI6ykGF1RobG5cuXarVajGH53nloMKaduPcZDJFRkaq1Wq7VuG5bGIMq6QzCuhMHRbHGE0XFhbOnTtXpVI5o5KOKttstoyMDJVK5e/vz6okhKmPj49er09JSVm7du2kSZPi4+OBVWtr67p166D0woUL7777rpeXF96TTCZTcHCwSqU6cuQIlqampsK59+7dmzFjBtvytGnTsHSMjoUbmO0oEpTHWuK4xWKJiIiYMGHCtm3brly5otfrvby81q1b19rayvO8clBhU9AIx3GsSioHFZ5rN87hXAi51NRUsCo4OJiVb2wBE6SSiGJMJsxm8/Hjx318fDiOG1AlFSo3NTXp9foJEyZwHCdRyZs3b06aNCk5ORkAtba2hoaGvvPOO0+ePOF5Pisry8vLC0tNJlNAQMCqVasg7M6dOzdlypS0tDQ4t6mpaeXKlcHBwS0tLTabbc+ePSqVqqCgAErhkvi3f/u3xsbGMTkYbmG0QiQoj7XE+/z8/OnTp8fFxeHiICkpydfXNz8/n+d55aDCpr7//nuVSvX666+zKqkQVHCiQpxfuXLFy8vr+++/xy6Sk5MnTZp05coVzJEnRrtKxsbGcswvNjYWfJDko0CYzebAwEA4IzAwMDc3171X3MDh/fffP336NEKQDzMLzW5lrVbr4eGxadOmAwcOSFQyIyNj2rRpeXl52KxWq8U6er1+3rx5jx8/xtJz586hJV9++eXKlStBT3meb2tr++ijjwIDA80vfoGBgR999FFbWxuem5eX5+vre/PmTcyhxAgTUIgE5bGW2KnX61esWPH06VNJPhwqBxXUKSgomDVr1rfffhsYGMiqpEJQwYkKF8W+ffvmzZtXV1eHVlVUVMycOROFBfPZxKhWSYkUgvaBP5IiuCxhm5IR1f9K4hqQdd4N0mfOnImLi2ttbYXFsvKKW6GywWCA3cbY2FhUQOBTVVU1d+7cgICAuro6q9V68+ZNjUaza9eu9vb2lpaW4OBgUD2EmZeXN23aNJw/Yr7JZDp+/Pi0adNgtQ73s08++aS9vR3rwLnKIYuVKTEcBBxFwqDGGgZXq9X+8MMPK1eu9PDw0Gg0EKhgs0JQQQVYGkdERDQ1NUlUkvVaElRQpBDn7LmQzsrKmjJlyrlz5+RFmDN6VRJnhXgb0Wq17HpQvueI0gmayIqmu6okDqQzKulMZblK8jxfVVW1bNkyvOfs3bsXdpdgjLZu3YqrKp7nYVwkSgdjx3GcwWCwWCw8z7e3t2/evHnGjBn37t0Dw2w2W0xMDMdxknPRbEqMJAFJJDg/1rDtuHDhQrVa/cYbb+j1+itXrvzxj3/08PCAmyt44SioeJ632WyRkZFLly5tbGxEwZX7Lg8qSZ0BLwrQ4jlz5lRXV0vOZQ/HgEo6umwkKomqyk5tMjIy4NomlWRHXSF6JNcGz/O1tbVLly594403jh49Ck9vpkyZcuzYsfb29qdPn7733nt4G4Mu5Cr57Nmz9PT0lJSU9evXe3h4REREgFAWFBRoNBq25UWLFqlUKlJJdrBclZZEgpNjDdbCBGXKlCm4A2i1WvV6Pe5LKgQVz/OpqamzZs2CDWtHKukoqFhcCnHO87zZbP7ss8+8vLwGfGA4elWS53nUOFA6yUrQkUqyF62kDkvQzdLKASFxVqGy5NqAZywajQafsdhstuPHj3t5eeXm5g5qfgFzhJiYmClTpmRlZYFJDx48CAgImDBhArwpUlxcPGvWLFJJyXi55FASCYMaa1BJfMQH9hcWFk6fPj0hIUE5qCorK+fMmYOPfRypJDKBJQgbVFikEOdPnz798MMPvby8/vznP7MrITyXTYxqlQRDcR0NWolTRYkCAk3JSwOSOqznbpZWCAi5pwqVJdfG06dPV6xYIdk9LCsre/PNN2NjYwe1VwVmwKXiSAdhXzIlJUVuM+WMMAFJJAxqrCFs8FIFy+FijI2NVQ4qyfWO+zyO1pQ8zzsKKkdxXllZuXTpUpVKdePGDWeojgGVRDdwagnLZ4kCokqyYyM5BZtyv4SjgLDrqUJlybWhHNA8z9t97jl9+vTCwsKWlpb169eHhYXBJiZYAjqYkJDA8/y+ffuWLVuGT8B5no+NjcXn43Ytp8wRIyCJBOWxlljV3t7+ySefSF5+wFugclA9vwenMr/k5OTFixcHBASkpqaWlZUNGFSsJXbjvLi4eO6LX3FxMVtZIT16VRKfveAKGmURZiJ4iHuOeBeCCtjCePj2xm5AOBp4hcqSa0P+ViOsuHGBk6X4viRsReFbRPBGJG5OpaSkYDuwAbpo0aLQ0FBWVR25QPnDTUASCQO+Gyux58qVK5MmTcKFs8Vi2b59u0ajKS0tHTCo2KbkK27loGLPlS9MaogAACAASURBVMd5bW3tohe/2tpatqZyevSqJMws2Pm2ZHeSFcFx+yYQjq48ICC8JJu5UF9eGduRXxsPHz5csGDBG2+8ERUVdeXKlW3btk2YMAGfwJjN5rVr13p5een1evnXNRCU7PMZ9sqBDzDeeOONhISExMREf39/dgMUTaKESwjII0F5rOF6xJUcPD6Gb29SUlL++Mc/skOvHFSsv3KVVA4q9lxJnMOjc47jAgMDI/7yp/yK7qhWSXytBLUSxwBY4OQRZ4u47oZ3hgATlrIE3SwtCQh4hBcYGDh0leR5vq6ujv2O+9SpU+x0Dz6MdfQdN54LX3lfvXqV/Qb8+fu9GzdunPDiFxAQ8ODBAzcbl7HrjlwleZ5XGGuJSkIEHjhwQKPRwOf/58+flwy9QlAhN7lKsgFpN6jwXMlF8eTJk3feeQfFhE042iiHpka7SqLDlCACRIAIuIQAqaRLsFOnRIAIjBkCpJJjZqjIUCJABFxCgFTSJdipUyJABMYMAVLJMTNUZCgRIAIuIUAq6RLs1CkRIAJjhgCp5JgZKjKUCBABlxAglXQJduqUCBCBMUOAVHLMDBUZSgSIgEsIkEq6BDt1SgSIwJghQCo5ZoaKDCUCRMAlBEglXYKdOiUCRGDMECCVHDNDRYYSASLgEgKkki7BTp0SASIwZggMSSUVTqYiIkAEiIDbE+Dc3kNykAgQASIwFAKkkkOhR+cSASLg/gRIJd1/jMlDIkAEhkKAVHIo9OhcIkAE3J8AqaT7jzF5SASIwFAIkEoOhR6dSwSIgPsTIJV0/zEmD4kAERgKAVLJodCjc4kAEXB/AqSS7j/G5CERIAJDIUAqORR6dC4RIALuT4BU0v3HmDwkAkRgKATGgEoajUaO49RqdXl5+VBcHevnZmZmLlmyxGw2KzjS0dFx4MABX19fT0/Pt99+Ozc3VxAErD86S9E8SowSAo8fP/7444+9vb0nTpwYEBBQVFTERpHESFcFVW9v7+nTp/38/DiOmzt3bnJycn9/P9qmXIrVnEyQSjoJypXVBEEwGo1qtXrBggUKKtnV1bVhwwZfX1+DwXD58uUVK1Z4e3sbjUYwfXSWuhIr9W2PQGVl5cyZMyGK0tPTw8LCfHx8MjMz7dUVXRVUgiBERUVNnDgxPDz86tWrYWFhkydPPn36NBipXGrXEeXMMaCSyg64fanFYjEYDBMnTuQ4Tlkl8/LyvL2909LSgInNZgsKClqzZo3NZhNFcXSWuv3wjS0HBUHYt2+fWq1+8OABWN7b26vX6995553W1la5L64KqpqaGj8/v6NHj8Ikt7e3NyIiwt/f/6effhJFUblU7sWAOS5QSZ1Ox3FcSEhIYWGhWq3mXvxgygNFEjmQrLjxsLCwMCQkBE5Xlo8BKYzmCjqdztPTc9u2bYcPH1Z202AwLFy4sLm5Gd25dOkS7lSMzlI0lRKjgUBHR0dISMjHH3/c3d2N9hQXF7/++uu5ubmYgwlXBRUb2GBMfn4+rpyUS9F45xMuU0lQN/yrVqvnz5+PhyCjHR0doiiiLMK+JByyNSGtrCDOExltNWNiYq5du9bf35+YmKjgY2dnZ2hoaEhICEADL4qLi318fLKyskZn6WhDTfaASm7ZsqWvrw9pQBQlJiZiDiRcFVSiKO7evVtyLTQ2Ns6ePTshIWHAUokXzhy6UiWBO6oeznpgRokUHKkkKgLOQHEPzhnPx1wdZZWE+N6xYwe70V5eXq5WqxMTE0dn6ZgbArc3uK+vT6vVzpw5s7KyEpwVBOHo0aMcx8lV0lVBJYqiTqf7wx/+wPM8jojZbF6wYIFOpxuwFE9xPuEylUQRBPc4jgMPHU0eUUNRVVETQQs4jsMc5/0fQzWVVdJqtf7+979HhuAXquToLB1D8MePqQ8ePPDz89NoNPHx8fD0ZsmSJXCvlUBwVVD19fVt3boVJ0lgFaqkcqnEBScPXaaS6CSqJN6s7E4eJSqJh6IokkqKouiqG/tQ+nUyRqnaCBOora0NCgqaOHGir69vVFRURUXF7Nmz8fJEY4Yy9EM5d8DZovJME+13PkEq6TwrF9dUnku6apNoKP26GCh17xwB2JdMT0+XVB/K0A/l3AF3HpV3LSVeOHNIKukMpVFRR1klRVG0+8BRpVKVlZWN2tJRQZaMYAh89dVXv/vd7549e4Z5iYmJ7NIN810YVHafYk+dOjUrK0sUReVS1n4n06SSToJyfbUBVdJVL68NpV/XYyUL/pJAenr61KlT8/LyILupqWnJkiXr1q3r6ur6y4r/cTSUoR/KucpvRCqXyr0YMIdUckBEo6WCXCVhSxd3eDs6OsLCwry9vdlvb/CridFZOlrgkh0/E2htbV2+fLlGozlz5sz58+cXLFjg5+eHL5mPkpDr6+uLjIz09PTUarX47c2pU6fgBQ/l0p8dHcS/pJKDgOXaqgOqpCiKNpstKirK0Xfco7PUtVSpdzkBk8m0devWiS9+QUFBtbW1WEeiki4Mua6urqSkJEffcSuXojtOJlygkk5aRtWIABEgAqOBAKnkaBgFsoEIEIHRS4BUcvSODVlGBIjAaCBAKjkaRoFsIAJEYPQSIJUcvWNDlhEBIjAaCJBKjoZRIBuIABEYvQRIJUfv2JBlRIAIjAYCpJKjYRTIBiJABEYvAVLJ0Ts2ZBkRIAKjgQCp5GgYBbKBCBCB0UuAVHL0jg1ZRgSIwGggQCo5GkaBbCACRGD0EiCVHL1jQ5YRASIwGgiQSo6GUSAbiAARGL0EBlZJnn5EgAgQAXcnoCDSpJLuPvjkHxEgAk4QIJV0AhJVIQJEYBwTIJUcx4NPrhMBIuAEAVJJJyBRFSJABMYxAVLJcTz45DoRIAJOECCVdAISVSECRGAcEyCVHMeDT64TASLgBAFSSScgURUiQATGMQFSyXE8+OQ6ESACThAglXQCElUhAkRgHBMglRzHg0+uEwEi4ASBUaGS9fX1/v7+3M8/rVbLWp6RkfFzyX/+q1KpioqKeJ43m82BgYGQGxsby56l1WqxGpvvlunU1NRFixbV19fb9Y6lJCGJ0BISEiRF/v7+2KDZbN67d6+Pj4+Hh8fixYtv3rxps9mwr+ErxS4oMWIEGhoadu7c6eXl5eHhsXTp0tu3b7NjXVdXt3nzZh8fH47jNBpNXFxca2urI9uGLzCUW7ZYLPHx8RqNhuO42bNnnz9/3mq1opHKpViNTbheJYuKilQqleQSDQwMNJvNYGhsbKykFOUPpRDqZGRkwCnQpkRtWbfdJm2z2TIyMlQqFStqEu/a2tri4uIimJ9Op5s7d66XlxcS02q1M2bM2L59O9Y6cODA06dPeZ5vbW1dt26dj4+PXq+/cOHCu+++y544fKUSL+hwBAiYTKbg4GCVSnXkyBEc69TUVOi6trZ20aJFb7zxxtGjR69cubJ582YPD4+IiAiLxSK3bfgCQ7llm80WGRk5YcKEbdu2Xbx4ce3atZMmTYqPjwcLlUvlXkCO61VSq9VyHIcXOc4c4QLGeRDOetATKIIT4Sysg+qJld0y0dTUpNfrJ0yYwAJ0xtOCgoJf/epXcXFxME1obm5es2bN1q1b2VkDtpOVleXl5ZWcnAw5JpMpICBg1apVJpOJ5/nhK0UDKDFiBM6dOzdlypS0tDTosampaeXKlcHBwS0tLTzPHzp0SKVSFRQUQKnNZouJifH19c3Pz5dbOHyBodxyaWmpRqOJiYmBYLZYLNu3b58zZ051dTXP88qlci8gx8UqiWttnPdhDkgeHuKsBz1xpJJFLyan2CDWd7+EVqv18PDYtGnTgQMH8DYzoJsQ+gEBASBzPM/X1dXNmTMH7zGSFvR6/bx58x4/foz5586dw+n88JVid5QYMQJffvnlypUrnzx5Aj22tbV99NFHsLB7vrLeuHHjBx980NzcjPbk5ub+8pe/lF+bPM8PX2Aot8wGJ9hpNBpx9aNcin5JEi5WSYk1PM+DxnEcBxctHuKim5U/nDOyK27MlDfuZjkGg+Hy5ctWqzU2NtZ5lYyNjfXy8srOzkYahYWFarU6Pj5+9erVHh4e7H5TS0tLcHAwuwHC83xeXt60adPS0tKGrxRto4SrCJhMpuPHj0+bNg2Xq3JLkpKSpkyZYjQaJUXDFxjKLfM8Hx4eLrkWqqqqZs2a9c033wxYKvECD0edSsICHKcquABHleQ4Di9aXI+jqsLck1VSdNWNE86rZHV19Zw5czZu3MjuJaWkpHAcB/tNKSkpa9euxf0mICxZjMOtKzY2dvhK3XiwxoRrcBlyHGcwGNhQYY2HbUrce2GLhi8wlFvmeV6r1a5Zs4ad8LKaoFzKusCmR5dK4tigzEEOyiI+ybE7yed5PjY2FhWW9dO9086rZFJSkmQiyfN8fHz8rFmzcL/JarVGR0dPmTIlKyvr6dOn7733Hg4HYESVHL5S9x6vUe7ds2fP0tPTU1JS1q9fj/dLic0NDQ0BAQEajQbDhq0wfIGh3HJ7e/vGjRtRLsAkVEnlUtZ+SXoUqSRKpMRJ1mK4k3AcJ7luWRwKp7NNuVPaSZU0mUyrXvxwR9IRBNDB6Oho5Vv38JU6MozyR5IAPJ+B+yXbb2Vl5dKlSzUajXytDdWGLzCUW3bzuaQzEsm+IGlXJdndSZx1SjYp2MF2m7STKpmfn+/r62v3KU1bWxtLA57naLVa5W2g4StljaG0CwkUFhZOnz6djZn8/PwZM2bMnTu3uLjYkWHDFxjKLQ+486i8a+nInVExl3RSIpVVEubVMJGEqZBWq2UzHSFwg3wnVTIhIUG+HQE35xUrVsDbkUADns8kJCQ4elg5ffr0wsLCYS11g3EZWy60tLSsX78+LCyMfVGcjQSe52/cuKFSqVasWFFXV6fsnd0n0SMQNueYFzDAQqPRiK83KZc68sj1KonPZ+QrZbiA2cc1MEOUX+qwI8lxHOxX4qQSWnD76aQzKmmz2bZu3frOO+/gex4YE4cOHfLy8sKXh+EVM41GU1paOqxvRGYpvomJ5lFixAjo9XpfX9+8vDzo0WKxRERE4BuRBQUFGo0mODh4wB0bF4aN8huRyqWOOLtYJVEH2UfYkIZJPmooW0G+3JbMGUklJUB4nodXxz/66CPJ4prneXhY6ePjEx0dnZKSEhQU5OHhge+cm83mtWvXenl5sd/eoKQOX6mjkKX84SPAfl0DbztMmjQJIgG+eJk0adK6devwAy1IwNJbEnLDFxjKLbe3t+/atcvDw2Pz5s347Q0Gs3KpI7AuVklYGrMKiGncCpHUwXzWJRBTfPBNK25JyPI8DznyGwxgrKur+/TTT+Hr3cWLF6emprLf4ZhMpsjISEffcQ9fKTvElB4ZApJIuHr1KnwEXVZW9uabb+LlySbgupOH3PAFhnLLra2tcXFxjr7jVi61C9nFKmnXpsFmwoRUsmAfV09vBkuM6hMBIuA8AXdQSee9pZpEgAgQgcESIJUcLDGqTwSIwPgiQCo5vsabvCUCRGCwBEglB0uM6hMBIjC+CJBKjq/xJm+JABEYLAFSycESo/pEgAiMLwKkkuNrvMlbIkAEBkuAVHKwxKg+ESAC44sAqeT4Gm/ylggQgcESIJUcLDGqTwSIwPgiQCo5vsabvCUCRGCwBEglB0uM6hMBIjC+CJBKjq/xJm+JABEYLIEhqaTCyVREBIgAEXB7Apzbe0gOEgEiQASGQoBUcij06FwiQATcnwCppPuPMXlIBIjAUAiQSg6FHp1LBIiA+xMglXT/MSYPiQARGAoBUsmh0KNziQARcH8CpJLuP8bkIREgAkMhQCo5FHp0LhEgAu5PgFTS/ceYPCQCRGAoBEglh0KPziUCRMD9CZBKuv8Yk4dEgAgMhcDIqaTRaOT+8qdWq8vLy9F6nU6H5UajEfM7OjpCQkKgKDExEfNFUdTpdJJG2FL3SJtMJq1W6+vry3Gcn59fUlJSV1eXI9fOnDmDDCGxYMECs9kM9Ts6Og4cOODr6+vp6fn222/n5uYKgoBNuaoUDaDEiBFoaWnZtWuXt7e3p6fn8uXL7969y0ZCS0vLZ5995u3tzXHc3Llzr1271t/f78g2V4VNb2/v6dOn/fz8wMjk5GTWSOVSR744yh85lUxMTJRcwChwrA5iHRRKlEJoAfPLy8vVarVOp3PkmxvkNzU1LVmyRKPRxMfHZ2RkaLVaT09PvV7f29tr1zudTjdz5syIiAj9z7/Dhw9brVZRFLu6ujZs2ODr62swGC5fvrxixQpvb2+E6apSu15Q5rASsNlsoaGharU6NjYWIyEzMxM6bW1tXb58OcRJenp6WFjY5MmTT58+bdckV4WNIAhRUVETJ04MDw+/evWqxEjlUruOKGeOkEqiDkomg2AcTDNRNGFSCZMgOBHSUA1bQPVU9nBMlx47dkytVj948AC8EATh6NGjr7/+eklJidwvnuf/8Ic/7Nixg50XYLW8vDxvb++0tDTIsdlsQUFBa9assdlsoii6qhTNo8SIEbh06dLUqVOzsrKgR4vF8v7774eGhnZ2doqimJubO3nyZIyTrq6udevWLVu27NmzZ3ILXRU2NTU1fn5+R48ehVDv7e2NiIjw9/f/6aefRFFULpV7MWDOCKmk2WxesGABx3E4eWEtA1kMCQnp6OgQRREmiSCajlRyPEwku7q6tm7dGhwczPM84iosLHzttdfsYjSZTP7+/ngXwVMgYTAYFi5c2NzcjPmXLl3CO5OrStEYSowYgejo6Pfffx9Vr7u7++OPP8arz2g0+vj4FBcXoz06nY7dt8F8URRdFTZs6II9+fn5uDZSLmXtdzI9QioJooaraY7jcKWM00zMkUgqzhnZFTdmOumn21S7cOHC1KlT8/Pz5R6VlZX96le/On36dEBAgKenJ7uJ2dnZGRoailcCnFtcXOzj45OVleWqUrkLlDPCBGw228mTJ318fHBN3djYOH/+/KCgoOcb4v39/bm5uX5+fpGRkX19fRLbXBg2u3fvlgh3Y2Pj7NmzExISRFFULpV44czhCKmk/NENx3Fw0SqoJEyLsALHcZADMoqq6oyf7lEHtilxmSxxKj09neM42MSEHSXcxASGksU43LoSExNdVSqxnw5HmAA+L42JiWF3uhsbG3/3u9/hnObAgQN2Hxi6MGx0Ot0f/vAHdo3FaoJy6UtAHiGVlKyp8UmO0WhEEUTVw7mko8VjYmIiLhVfwucxekpLS0tQUJCfnx9uU0ocOX369OzZs7G0v7//yJEjU6dOzcvLs1qtv//975EwnIgq6apSif10OJIEenp6bt26lZ6evmnTJrybiqLY1NS0fPly9l47derUEydOyOeSrgqbvr6+rVu3ShZGqJLKpS9HeIRUUmIcq4xsGqopqySUShhJ2ne/w4aGhuXLl/v5+dldazvyF3TwyJEjrrrtK/fryGzKH0kC8EgQ7qaCIOzbt4+9EwuCcPLkSW9v78LCQolVyoM7fKXwCqAbziXt8oXdSaDJ7lSiStp9RsHuTuKcVLJJIelurB+WlJTMnDlz/vz5FRUVyr50d3ezFeB5jk6nc9UWknK/rKmUdiGBsrIylUqVmJjY3t6+evXqLVu2sDPHR48e/frXv5Yv7JQHd/hKB9x5HKv7kpIIkCijZD0OMyC7a2p2IgnVdDodmynpyA0Oc3Jy1Gr16tWrTSaTgjuAdPXq1e3t7VgNns+cOXPG0eNIlUpVVlbmwlI0lRIjQ6Czs3PTpk1/+tOf2K1GjJNBqaQLw8buU2x8vUm59CU4j8SKGzURl8kwB0QdVHhfUuKSfCKJO5tuOZ188OCBn59faGgovNUooSE5PHbsmLe3N74eDC+R+fn51dTUuPCNSOVX6iQu0OEIEDAYDK+//jq+69Pb26vX6+ElXFhxS17RPXnyJKzH5bYpD+7wlSq/EalcKvdiwJyRUElRFO0+48aHCSij+FjN7puVkjkjKiac7n4qCR82TJ48ecOGDT9/SvOf/8LSWwIEnoD7+voeOXIkPT39ww8/9PT0PHXqFLx529HRERYW5u3tzX57g5LqqtIBA5QqvHIC7Add+HUNxsnjx49/+9vfajSaQ4cOZWRkhIeHT5w4ET/3koScq8Kmr68vMjLS09NTq9XitzfognLpS/AcIZXEd8VRB+XbHPhegl2JRKnFzUq3X3HDfhASYxMAQRKyoiiaTCb4Ahe+1M7MzGS/w7HZbFFRUY6+43ZV6UtELZ0yRAKSOLlx4wb7ETSWwifS3377LS7P5SHnqrDp6upKSkpy9B23culg6Y2cSg7WMkl9mDDimh1Kx8nTGwkKOiQCRGAkCYwZlRxJKNQXESACRAAJkEoiCkoQASJABOwQIJW0A4WyiAARIAJIgFQSUVCCCBABImCHAKmkHSiURQSIABFAAqSSiIISRIAIEAE7BEgl7UChLCJABIgAEiCVRBSUIAJEgAjYIUAqaQcKZREBIkAEkACpJKKgBBEgAkTADgFSSTtQKIsIEAEigARIJREFJYgAESACdgiQStqBQllEgAgQASQwsEry9CMCRIAIuDsB1ER5glTS3Qef/CMCRMAJAnJxxBxSSSf4URUiQATcnQBqojxBKunug0/+EQEi4AQBuThiDqmkE/yoChEgAu5OADVRniCVdPfBJ/+IABFwgoBcHDGHVNIJflSFCBABdyeAmihPkEq6++CTf0SACDhBQC6OmEMq6QQ/qkIEiIC7E0BNlCdIJd198Mk/IkAEnCAgF0fMIZV0gh9VIQJEwN0JoCbKE6SS7j745B8RIAJOEJCLI+aMhErW19f7+/tz9n6xsbFgf0ZGhqRcpVIVFRXxPG82mwMDA6EU68NZWq0WqznBYUxWaWho2Llzp5eXl4eHx9KlS2/fvm2z2Rx5UldXt3nzZh8fH47jNBpNXFxca2srVk5ISJBA9vf3r6+vhwpms3nv3r0+Pj4eHh6LFy++efMm29HwlaJ5lBh5Ao2NjUuXLtVqtXa7Vi6FU4YvMJRbtlgs8fHxGo2G47jZs2efP3/earWiF8qlWI1NoCbKE6NFJWNjYyUXMMofSiHUycjIAN+KiopUKpWjAWb9H7tpk8kUHBysUqmOHDly4cKFd99918vLKzU11a5HtbW1ixYteuONN44ePXrlypXNmzd7eHhERERYLBaor9VqZ8yYsX379oiffwcOHHj69CnP862trevWrfPx8dHr9dgRoh6+UruOUObIELBYLBERERzH2b2IlEvBwuELDOWWbTZbZGTkhAkTtm3bdvHixbVr106aNCk+Ph6sUi51xFYujpgzEiopN0ur1XIchxMZnC1Kpoo4kYSaMN/EOqie8vbdJufcuXNTpkxJS0sDj5qamlauXBkcHNzS0iL38dChQyqVqqCgAIpsNltMTIyvr29+fj7P883NzWvWrNm6dSs7Q8RGsrKyvLy8kpOTIcdkMgUEBKxatcpkMvE8P3ylaAAlRp7A999/r1KpXn/9dbsqqVwK1g5fYCi3XFpaqtFoYmJiIJgtFsv27dvnzJlTXV3N87xyqSPOqInyhAtUEhfXOFXBJTnmoCcgoHKVLBoHE0me57/88suVK1c+efIEgLS1tX300UeBgYFmsxkRQeL5ynrjxo0ffPBBc3MzFuXm5v7yl78EqnV1dXPmzMF7DNaBhF6vnzdv3uPHjzH/3LlzOJ0fvlLsjhIjTKCgoGDWrFnffvttYGCgXCWVS9HU4QsM5ZbZ4ARjjEajl5cXhLpyKRovScjFEXNGWiVRENmBAcljV9xsKc4Z2RU3ZkpcdeNDk8l0/PjxadOm4cpiQGeTkpKmTJliNBp5ni8sLFSr1fHx8atXr/bw8GB3LVtaWoKDgyXim5eXN23atLS0tOErHdB+qjBMBGAnJyIioqmpSa6SyqVo0vAFhnLLPM+Hh4fjShTsqaqqmjVr1jfffDNgKdovSaAmyhMjrZKgdDhJAUNxdskKJV60uB7nOA6mQiC1rJJKHHa/Q9ij4DjOYDDgPqOym7BNiavmlJQUjuNg1zIlJWXt2rW4awmEJYtxuHXFxsYOX6my/VQ6TARg227p0qWNjY0wuOylpFzKmjR8gaHcMs/zWq12zZo17LKJ1QTlUtYFNi0XR8wZUZUE5+W7xSABKIv4JEe+AAevYmNjJTrLeut+6WfPnqWnp6ekpKxfvx6lTdnNhoaGgIAAjUaD25Tx8fGzZs3CQ6vVGh0dPWXKlKysrKdPn7733nvspcLzPKrk8JUqu0Clw0QgNTUVI0GuksqlrEnDFxjKLbe3t2/cuBHlAkxClVQuZe2XpFET5YkRVUmcMzqSP7DbkZiyOCSMJA676yE8kAFpU/CxsrJy6dKlGo0G1tqOaoIORkdHK9+6h6/UkWGUP3wEKisr58yZExcXB889JCqpXCqxavgCQ7llN59LwiRRsqEgQY/PteVTTqjJ7k7irHPANuW9jNGcwsLC6dOnO3oIw/N8fn7+jBkz5s6dW1xcLPGxra2NzYHnOVqtVnkbaPhKWWMoPTIE8JJhd7cgHfviJ8/HUomFwxcYyi0PuPOovGsp8QIP5VNIzBm5uSTcHxxpH9qqrJIwr4aJJEyFtFotm8m2M9bTLS0t69evDwsLY98Mh4cqCQkJdr27ceOGSqVasWJFXV0dWwHgr1ixAt6OhCK2KbuPFKdPn15YWMjz/PCVskZSegQIlJWVpTK/5OTkxYsXBwQEpKamlr34MYWpklK5ecMXGMot232Kje/MKZfKvYAc1ER5YuRUErQMn8CgraieuIiG253dnUf5RDIjIwNacMvppF6v9/X1zcvLA1zwoi++AokMIVFQUKDRaIKDg+ElR0npoUOH2DfS4RUzjUZTWlo6rG9EZim+iSkxkg5HmABcO5ItabRBudSFYaP8RqRyKXonScjFEXNGTiVh6sdxnHxTEvcr2dm+fOQkc0ZUTDdWSfZzGngwPWnSJNxULTxhLwAAIABJREFUYoHAtwqTJk1at27dz1/W/Oe/sPSGpnx8fKKjo1NSUoKCgjw8PLAps9m8du1aLy8v9tsb/Mhn+EolkUqHI0xAWQflpWzIwbLPJWHT3t6+a9cuDw+PzZs347c3GMzKpY4IoybKEyOnkiCFdmeI+EQVVdLuvhu0gCLr9ituGM66urpPP/0UvuNevHjx1atX8XtVNmSfr6TefPNNBMgmkJikqdTUVPY7HJPJFBkZ6eg77uErdRS1lD8CBOQ6yHYqL2VDDmoOX2Aot9za2hoXF+foO27lUtZHTMvFEXNGTiXRmpdLwIDhqhwawa1ot1xuvxwoOosIEIGXIICaKE+MGZV8CbfpFCJABIiAkwTk4og5pJJOMqRqRIAIuDMB1ER5glTSnQeefCMCRMBJAnJxxBxSSScZUjUiQATcmQBqojxBKunOA0++EQEi4CQBuThiDqmkkwypGhEgAu5MADVRniCVdOeBJ9+IABFwkoBcHDGHVNJJhlSNCBABdyaAmihPkEq688CTb0SACDhJQC6OmEMq6SRDqkYEiIA7E0BNlCdIJd154Mk3IkAEnCQgF0fMIZV0kiFVIwJEwJ0JoCbKE6SS7jzw5BsRIAJOEpCLI+YMrJJYlRJEgAgQgXFIgFRyHA46uUwEiMAgCJBKDgIWVSUCRGAcEiCVHIeDTi4TASIwCAKkkoOARVWJABEYhwRIJcfhoJPLRIAIDIIAqeQgYFFVIkAExiEBUslxOOjkMhEgAoMgQCo5CFhUlQgQgXFIgFRyHA46uUwEiMAgCJBKDgIWVSUCRGAcEiCVHIeDPh5dFgRh5N0Wfv6NfNdD6dElrIZisORcoC7JHMohqeRQ6I3oua2trcuXL9fpdAq9dnR0HDhwwNfX19PT8+23387NzWUjfnSWKrjzCou6u7ufPXs22AaR3stdeIIgdHd33717t7e31/muf5bW//pXFEW0xPl2oGZmZuaSJUvMZjN74uPHjz/++GNvb++JEycGBAQUFRVB+x0dHWfPnt21axcn+yUmJrItYBqDavfu3fv374eQQ2uhNCwsbO7cuQMGZHFxMZ4oimJnZ+fZs2fffffd//N//s+nn3569+5dthT7lYe6IAgNDQ1RUVF+fn4cx82dOzc5Obm/vx9tHmyCVHKwxFxTv7e3V6/XcxynoJJdXV0bNmzw9fU1GAyXL19esWKFt7e30WgEi0dn6cjQFAShrKwsLi4O5ea/FOgvU3J7cnJyMjIyRFHs6emJj49/9OgR1ikvL3/w4AEeQoJtTxRFq9W6d+/erq4u9goHMyQ18fS2traqF7+amprW1taffvrp7t27oijyPP/sL3/t7e0Wi6W2thbOlfwVBMFoNKrV6gULFrAqWVlZOXPmTIiT9PT0sLAwHx+fzMxMURS7u7t//PHH7777bvny5Xq9ft++fQcOHFi2bNn/+l//686dO6zB4A4E1T/8wz8YDIbq6urdu3dPnjw5NzcXWFVUVHzyySe+vr6FhYWXLl367W9/qxyQZ86cqaura3vxM5vNmZmZSUlJeXl5paWlubm569evT0lJAR/ZYL5+/fqqVavYlgVBOH78uIeHR3h4+NWrV8PCwqZPn37hwgUJH+cPSSWdZ+XKmtevX1er1dOnT1dQyby8PJVKdf/+fbgIIVI//PBDm80mimJeXp63t3daWhrEd09PT05Ozvfff9/Z2SkIAlsKM6Dk5OSLFy92d3eLolhaWvraa6+lpaUBApvNtnPnTizFc6G0s7MzNjZ2zZo1kn7x3KCgICxFphIRwfxXkgCVPHnyJLTW19fX3d3d4+BnsVh6enpQEaqrqxsbG0VR7O3tvX//vs1mEwQBJiZnz57NysqSWCgIQm9vb9eLX3d3t8ViuXPnTmdnZ1dXV3d3t9VqBaTZ2dnf/vx7/Pjx1atXUezu3bu3b9++tLS0e/fuPXnyxGAwfP3116IoZmdn7969+wDzS09PLy4u3r9/v8QGURQtFovBYJg4cSLHcaxKCoKwb98+tVqN+g434Hfeeae1tRUip6ysDFm1trampqZWVVXZJZaXl/ev//qvT548AVyVlZU3btzIzc3t6uq6f/9+fX19cnLy1atXRVE8e/ZsamoqO/SSsLHZbNnZ2Z9//nl4ePiBAwfWr18/YcKEDz/8ENwtLi4ODw+fN2+eJKig3+bm5sDAQAyq54uGHTt2hIaGQlD19vbm5ORcvXr14cOHclDO5IyQSup0Oo7jQkJCCgsL1Wo1TOdhmgNFkrEURbG8vBxrwrkdHR2iKHZ0dISEhLD1jUYjNOhoUeAMiNFc58GDB7/5zW9SUlJCQkIUVDI2NvbGjRs8z1dUVFy/fj07O7uoqOj8+fOgmwaDYeHChVarVRAEs9mck5Nz+PDhffv2VVRUNDY2RkVFLVy4sLm5GQg/fPgwNTV1//79OTk5NTU1RUVF3333nclkQkpGo/HGjRuVlZU5OTmRkZF4LlTIzs5+7bXXysvLRVGEfqFlKL106dK8efNaWloEQWhqarp58+aZM2fOnz+fk5PT2NgI+djRSyfg+sHTKyoqLly4AJnZ2dm7du3as2fPl19+WVFRcerUqYiIiD0//3bt2lVeXl5VVRUREXH79u1Lly5FRERER0dXVFQcOnRoz549er3+4MGDgiDs2bOnqqoKu8DEnTt3Dh48ePjw4XPnzlVXV4eHhx86dOjwi9/BgwcBy6lTp7Kysp6++HV1dcXFxcEwiaJ47949mPbC/Sk8PPzp06egkpcuXcJeINHQ0GBXJXU6naen57Zt2w4fPsyqJFw+H3/8MYg1NHL//v1/+Zd/+fHHH+EQWVkslgULFvzzP/9zeHi4XVa//e1vZ82a9cMPPyCr9957b/r06SUlJYcOHXrrrbf+/u///ssvv0RWly5dUqvVjgLj0aNHn3zyyTfffCMPG0EQYmNj7QZVR0dHRUXFN998gy1XVVVptdqDBw8iq7a2tuXLl4eFhQ1q6wNPH1GVlOx1qNXq+fPns5khISEghRKJhDpYysqi2WxesGABK6Pom3skbDZbaGioXq+3WCwKKtnZ2ZmTk5OXl3fo0KHw8PCzZ89eu3YtLi7uypUraWlpT548eX5r3b59e19f3/OrcceOHYcPHz527NgvfvGLQ4cOlZaWxsTEBAYGAnyr1ZqYmLhly5a/+qu/+uyzz7755puQkJBr166VlJSgUFZVVV27di05ObmkpOT999/HoQHmRqPxr/7qr7Kysjo7O0NDQyWl5eXlzzcEHj58GB8fv2vXritXrpSWllZVVeXn5ycnJ//www/l5eUvsYcoGW5BENg5408//fT48ePu7u7m5uaenh6oDHUOHz58584dyel4mJ2dDZNoq9W6Z8+empoamHB1dnbeuXOnr68Pm7I7HbbZbPv375dcnIIgnDp1qrCwEHuxq5JdXV16vR7mYoNVyZiYmGvXrvX39ycmJspVcsuWLWi5KIrV1dUZGRmPHj2C6TWyOnnypJeXF6innJV8cLOzsw8fPvyP//iPOTk5ERERq1atCgkJ6erqQlbNzc0JCQkNDQ09PT3ywGhpafnTn/4UGRkpb1kQhHPnzv31X/+1PKgEQaipqfnxxx/VajVM7fPy8nbt2oXTYUEQ7t2797d/+7c7d+5E4INKjLRKwnQPZQ7lH2aUOJxwiPOmxMREjuOwsiiKUEGtVm/cuFFSNCj/R3llQRCioqKWL1/e2toKswBkIrG8u7u7qKgoIiLi888/r6+vh9Ly8vLw8PAff/zxzJkzISEhSUlJPM/HxMTArApuRYmJiXV1dbt27Xr33XfhOgeVPHfunFqtTkxM7OjoCA4OhqnEtWvXQEnr6uquX78eGhpaXV0dExPz6aefshqRk5PzN3/zN3BuSEjIjh072NJnz5599dVXz7dN4+LiYG4LpfC3qamppKQkKysL1lYSNwd1+FyGduzYsXv37vLy8hs3buzcuTMiImLnzp1PnjzBdqxW68GDB+1OCWHieePGjdu3b8O+ZGVlJVrV2toaHx9/4cKFzMzM8vLy77777uyLH7Tc09MD/0V2U1NTdna2zWbr6upqb2+H0wVBuHTpEq55RVGUqOS5c+cEQbhx48YXX3zR2dkJbWZnZzs/l0QHJSrZ19en1WpnzpxZWVkJdQRB+Oabb/7bf/tvS5cuZVlt2rTp7/7u79atW4cSL2EFAQmDi6wuXLjwf//v/7148WJJSclnn30GpcgqOTn5/Pnzu3btOnXqlL+/vyQw2traEhISUlJSenp6zp8/n5qayobNt99++9prr9kNqt7e3gcPHuzbt+/o0aOiKN65c2f//v3nzp0DB61W62effaZWqx1dO8jKUWJEVRJFECeAaDfoJquDYDHWlEghm89xnLuutTMzM2fPng2Xk7JK9vT05ObmLl68+NatWzjY5eXlCxcuTElJMRgMy5YtS0xMbGlpOXfuHDyCQJW0Wq3z589ftWoVBKVEJa1W6+9//3udTmc2m0tLS69cuSKKIqjk6tWrf/rpp6ysrA0bNmCnoiiiSuK5WArr/b/7u7/78MMP+/r6YI8PFp7t7e39/f1Wq7Wzs7OqqurixYt41ssl+l78YKPwxo0bp06dgtkl7CrChd3U1PTVV1/hnqCko46OjtTU1IqKipYXv2fPntlstoaGBkEQ6urqIiMji4uLHz9+XFNTs3fvXpgRQwsVFRV79uw5zvyKioouXrwI01JBEHJych4+fNj64tfR0YEqKQjC/fv3Y2Nj29vb09LS8vPz0aRXopKiKD548MDPz0+j0cTHx8PTmyVLlvzP//k/T5w4wbI6f/68l5dXXl4ePmuSsJIMLrD64Ycfvvjii6ysrObmZqPRGB4ezrL68ccfjx8/vmLFih9++OGdd97Byx98bGtr+/rrr48ePXr79u09e/Y8X7P/+POvvr4+KSkJVFLSL5xbXl5+6dKlzZs39/X1GY3GqKgoUMn+/v64uDi9Xj9v3jxJdwh2wMSIqiSuvFDjUN0kKokV2PW4RENxQorNDujt2KrQ0NDg7+9/6tQpEC9llezr60tOTv7Nb37T3t6OboIOHjx48NSpU++9996ePXtaW1vLy8thHoEqyU4K4LFsYmIiO5fE+eCjR4++/vrr7u5uVEmTyZSWlvbdd99VV1djv6iSkpbBkbS0tKlTp8bHx8MeaHR09N69e7///vuKioq7d+/CLlt7e/vhw4d5nsdLFETNyb9oCSSePXtWVFSUm5vL5oNAV1ZWHjx4kN02hTpgak5OzhdffHHh519WVlZ1dXV6enpHR0dubu7BgwdbW1sFQaivr4cHLNh+fX39zZs3JdZev3795s2bUCcpKSk2NvbSi99PP/10/Phx2JcElTx+/DjciuDxOpxy9+7d7OxsSZu4LwkGS0phQqrVai0WC1sEerdq1aqAgICoqKiKiorZs2fDxQisbt26tebFDye//f39ElaSwQVW0dHR3t7ef/zjHzMyMq5fvx4TE8PzPLKCHfAPPvhAci442NbW9sknn3zwwQeXL19+6623Vq9enZ6efu3Fr6Gh4fTp0+xcUqfTsR5VVVUtXLgwODjYbDb/8MMPhw4dSk5OFkXRaDQeOHCgqqpqxYoVBoMBwgmHycnEaFRJIAj6CPIvX3Hjolsyx3TS7TFRDbxm7xOYxrsLOgJPtH/961/Dihjyi4uLfXx82K2clpaW4uLi8vLyJy9+sCkp2QaCuWRiYqLk3K6urubm5vj4+JqaGtiXDA0NbW5u1uv12dnZFy9exFfSHO1LgjBptdpf/OIX9+7d6+/vP378eEJCQm9vryAIFoslOjoaZ1sHDx6sra3t7+83m80w53Lyb2NjY0FBAZIRRfHRo0dlZWWVlZXZ2dmYLwjC06dPYbHM83xlZSXaD3W6u7tPnjx57949uBrhArNYLA8fPrx9+/adO3cuX75cV1cHszPJiDQ0NPz5z38uZX5NTU0pKSmweBdF8fTp06yRkrkkqGRnZyfs0oI9Dx8+vHfvnon5tba2VlVV4dMbu6wePnx469Ytk8lklx6wgjgBRQZWJSUl//Iv/4JO2WWFYdPT04Osnr/CtGrVqqysrO7u7vz8/MzMzKysLGTV2Ni4YcOGbdu24blsuJrNZuf3Jbdu3drT04PvEjQ3N6enpzc2NnZ3d5eWlqanp9fV1XV3d7e3t7e0tFgslszMzOrqasnGNAaDcmI0qiROJPFdP7lKwjwIVcMtp5OPHj26yfzS0tLefvvtoKCgmzdvsm/twQD39PQkJSX94z/+IzstunTpkkqlKisrYx8aVldXJyYmXrx48fvvv4flZHNz86lTp/A5Najk3r17Jee2tbVZLJYTJ04UFhYajcbr169/8sknVqvVYDDExcUVFBTgQ9L09PRf/OIXkn7Bzo6OjtWrV7/++utNTU3PnwXt2LEDX+WzWq07duyATVVBECIjIx89etTd3R0REaHT6cKd+Ol0us8//3zXrl3wnBR67OvrS09Pv337dn5+vtFobGhogHxBEE6fPv3o0aPo6OgHDx6Ul5fD6hKnG0VFReXl5bW1tY2NjRaLBWTdYrHcvXv3+aOJqqqqwsJCWBFnZ2fjMxZovLa29uDBg4XMr6mp6erVq6iSZ86cgbcgobv4+HicS5aUlIBKgjbhU4js7Oy9e/cyi/jjWVlZ9+/fR5W0y2r58uW+vr5btmxBfosWLVKr1Z999hmySkxMVKvV9fX1yCo9PT0mJgbfc3LEymAwBAUFdXV1Iavs7Ozr16/DW9ylpaXnzp3bsmULsqqpqVm5cqXdp9hwM9u+ffupU6dEUTx69OiqVataWlpwsGJjY//2b/+WDarS0tIdO3aEh4dHRESsXLly2bJl9+/f37t378qVK//6r//6/v37J06cgNK1a9d6eHgEBgaGh4fv2LED3hmAlp35O6pVEiaSKJq44sbJZkhISHp6Omgl3veccXss1gGvHe2tdHd3Z2Rk/I//8T/YtxodvZ7W19dXVFS0cOHCefPmnTlzpqysrLCw8J/+6Z/wYW5CQsKSJUvwBTR4ta2goKC9vf3o0aNGo3Hv3r15eXk6nc5qtebl5b355pslJSWpqakdHR0wrfjf//t/w2JN8lrcs2fP5s2bt3r16q6urpqamujoaBgLQRCqq6vxgm9vbw8PD4d3Oa1Wa1dXV09PT68Tv56ens7OTliqgwDV1tampqbCjmp1dfWf//xnWJw+fPjQYDBYrdbo6Oj6+vqqqqoHDx6gVLW1tR07duz5m5I7duyAV5QiIiJ6enra2tr0ev3+/fv7+vpMJtPly5dFUTx+/Dg7MRRFsampCd53wUgTBOHmzZugO4IgFBcXNzU14SzVrkrCjkRSUhI8bhpwX1IQBDmrhISEefPmNTU1IbyrV69OmTLl9u3bwKq2tnbJkiXr1q3r6+tDVhs3bszMzDxz5owyq7y8vMDAwPz8fGC1devWDz/88Pbt29u3b+/p6amtrf3lL38ZEhICrL799luIOrhVSALDZrPdevFraGjo6uoymUwwN4TZIs/zz182krwviY93bDZbUFDQF1980dLSsnfv3oKCghkzZjx69OjEiRPw4VNERIS/v/9PP/0EIQFO4dAMmBiNKsmupnG2yK6scSnKvnGJGjqgz2O0glwl4f4B8+i+vr7S0lJ/f39vb2/22xtYYwqC0NHRERYWJinNzMy0Wq0lJSVlZWWbNm36xS9+cerUqUePHoWGhk6ZMgW+x4BrNSwsbN++fffv3w8KCnrrrbd+97vf1dXV7dmzx2q1QssbN27MyckxGAznz5/ft2/fli1bgDPb79WrV+/cufPv//7vsGf05MkT/JoCPhSBRZ8gCN9+++1333039JESBCE+Pv7evXvl5eXg2p49e549e8bz/O7du2/cuNHV1QUq2d/fD28jgSTl5ubevHkTxBq+e0GV3LNnj8Vigcxbt249f69ox44dbW1trLVpaWl79+5NTEysra1NSko6+uK3e/fu69evw4V65syZqKiob178qqurY2NjUaBxLgk1r169Cp/9DaiSrAGYljzjFkURPnXVaDTwmuqCBQv8/Pxqa2uRVUlJyezZs3fv3v35559LWO3du/c3v/nNH//4x4qKivz8/JqamrCwsClTpnz++ec1NTUqlWr+/PkNDQ3Aymw2z5gx42/+5m8MBsPDhw+jo6MTEhLWrFkDrNjAgE/Fzp49+/zS3vnit23btjfffHPChAn/+q//+t577124cOH//b//t3fvXvBLfq63t3dJScmzZ890Op3JZIKd7vXr13/11VdhYWGTJ0/G/X0k43xilKokzhbhRcj6+np4KTIxMRHX2jirwhy3XHfjWCqrpCiKNTU1sbGx+/btk3zH3dvb+8MPP8B7gs+/+vr7v/97+aevZrP5zJkz69atW7Zs2ZUrV0JCQo4dO8becnmer6qqio6O/u///b+/9dZbpaWlz549A5UURdFms8ELRnv27Dlx4kRWVhY8nAHjbTZbVFQUWBUXFwfvdYqi2NjYWFhY2NTU9Pwhe05Ozr179x4/ftze3n7lypV9+/Y9X4Cj7y+RgGna87XVjh07LBYLqKQgCMAhLi5u//793d3dqJKgepWVlTdv3sQ3rh2pJNpTU1Nz69atmJgYzIFEd3c3vAnU0dFhMBjq6urgEF7VFATh66+/LigogPldf3//iRMnQCVFUSwpKTl27Bg2mJ2dfeXKFbiLDP1NIGjWZDJt3bp14otfUFAQSCSyKi4uVqlUe/bskbMClQwJCWltbQVWra2tUVFR//7v/56SkvIP//APRUVFMO+DeXd4eDgM/bJlyzIzM8+ePfvVV1+ha2xgvPPOO2az+dKlS2lpaf0vfu3t7QaD4fl76R4eHteuXUtKSkpNTbV7Ln4hXl9fHx4eDvuV9fX1K1asoO+4kRgl/uN/Q2hqaiooKCguLpbgaGpq2rFjR01NTV9fX01NDc4Q2WpWq/XIkSPwBBb2JXGTDqt1dXUdPHgQv4a2WCyoklCnu7u7srKypqbm/v37CQkJeCKbEATh0aNHd+/ehfW40Wjct2/f/v37i4qKfvzxxy+++GLXrl1nz559JW+VC4Jw8uTJhIQEQRBAJUVR7Ovrg89pYP3FqqQoij/99NOXX36JM9z29vbTp0/L55LoUWtr64kTJ3JycjAHJoBwCN963rp1CxQf19e9vb0RERH4VoAgCAkJCaiSpaWlqJKCIFy9ejUlJeWlVZI1zFEaDHMJK9YkQRBgP4fNhLQgCOnp6bibJK8AOdevX4ctXRgFWHFjZeSPOU4mRmgu6aQ1VG0oBGw2GzwGxfeQBUHo6ek5fvz4V199BRPD6urq8vLyp0+fwiHEjSAIsBEObwhZrdbr169XVFRAqEHNnp6elJSUnTt3wlNdeCQtUUncjzMajY5UEt40Kigo+P/tnP1LKk0Ux//00ZRC0ZKsrKQiiNIKeoHbK4iSVrgl9GJpEdWibbStRq66is4+cg/PYZ51b1n3oQjO/nScnTnOfHS/Oy9nRozQhlZ/+k9sCw3C9Bhjd3d3qJLwsDkcDpQki0qapgn9bvD5+vo6Ozt7fX39+PgojrixwoqiZLNZ9AbEYrHY6urq2tra1taWLMtTU1NLS0tra2vr6+vz8/O1Wu3x8dHpdBqGgTUX5yWz2Sysb3DOdV13u91wHE4+n4cfBUuZpomRQGLiR+3vYmWpJ5wPgC8P8W4vKtlsNt1uN04Qc84tKgm44LUnOn/XJpV8F9FPypDP5yVJurm5KZfL1WpVUZTp6WmXyyXLMjSjXq/HYrHT01NYt9V1XdO0RCLhdDrn5uZAECuVSi6XKxQKmqY9Pz8rinJycjI6OupwONLpNPj5k0pyzm9vbxOJxBsqaZqmqqobGxuZTObp6alWq7Xbbc65YRi5XA6m/P4eOuxpgwVTVEnYQiNqTbdK4ldD99zhcJyfn19fX8NQrlwuDwwMQB7DMDweTzqdzmaznQ47FlQUpVAoFItFRVFg2NiZzy3+vlRVbbVai4uLlmcVVRL2boNKSpLkdrvHx8fh9I1MJhOJRH4J1/HxsbjGjRX4qPGNrLCqnPO9vT2v12uJx8IM278v/NhtxOPxYDCIOy9hJIGBBPACy2azoVCou+zbKaSSb/P5eXdzudzk5OTQ0FB/fz9jLBwOQ2wNtsQwjM3NzeHh4UAg4PF4GGM+ny+RSODfq3N0Cvvv5fV6I5EIxtCAq87QnjHWPXvY6Wwyxt5WSVCrTlhlKBQaHBz0+/0ul4sx9qfNglj5jxqwu05USYsHwzCCwaAFEeaRZTkSiZimqWlaPp9vt9uKosCUa7PZDIfDExMT7Xb7/Pz86urq6ekJXjNYHEbcg4ODGHrCOQfBhXOG4NG17FC8uLgAlby/v08mk7jrPJVKzczMnAiXLMtivCR+7+eMb2QFMU+MMXwNQxNwrGOaJkxZWpqGwOF0EvF35JxvbW3hZnlwlUwmo9Goxcm7H0kl30X0IzO8vLwoigJzf7YN4Jxrmvbw8PD3M4C2/ntP1HUdYifFEWjvxXvMmcvlbGPFYLIV+9pveFNVFbozsiyXSqWRkRG/3w8931arlUqljo+PIRZKdGIYRiAQAJWEjrbT6YSpYXhuTdNst9uwwREKXl5ewn5k0Q/s+1xZWbEk/i8jbovPr2QFEG5vb10u18LCAqoeVqler8Of2ePxYAA13IWyjUajs6uKMSZ2GyHD1dXVw8MDnpDXaDQikcju7i4679EglewRFGX7wQQ455Ik2XZvS6WSx+OBk37ebmG5XI5Go4eHh0dHR319fWNjY3AgI5TinCcSiUAggKGakF4qlQYGBorFYrVa7exMZ4yJT2mlUjk4OFhYWHA6nRhBDV3s7spA4I4lXZIkDDK13Prcxy9mBROOjLHl5WU8VkOsuaZpPp8PxhmWgYuu6/v7+53n8Z8CAAABCUlEQVQAA8ZY92IjzF0EAgH/vxf4OT09Ff33YpNK9kKJ8vx4ApIkieeAYHt0XU+n05ZoR7xra8ABHzgQFvN0P+e6rmcyGXi8j46OLEsTjUYDDhYSDyWKx+M7OzuiW7DPzs7EbJBYKBTEtaPuUp9I+WJWlUpFnCm2VLjZbN7c3Kiq2t3NNE3TMIzt7W1YUbQUhI+wJVEVLls/tmUxkVQSUZBBBIgAEbAhQCppA4WSiAARIAJIgFQSUZBBBIgAEbAhQCppA4WSiAARIAJIgFQSUZBBBIgAEbAhQCppA4WSiAARIAJIgFQSUZBBBIgAEbAhQCppA4WSiAARIAJIgFQSUZBBBIgAEbAh8A9frgfdYpIoaQAAAABJRU5ErkJggg==" - }, - "image.png": { - "image/png": "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" - } - }, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "![image.png](attachment:image.png)![image-2.png](attachment:image-2.png)![image-3.png](attachment:image-3.png)" - ] - }, { "cell_type": "code", "execution_count": null, diff --git a/open-machine-learning-jupyter-book/deep-learning/nlp/text-preprocessing.ipynb b/open-machine-learning-jupyter-book/deep-learning/nlp/text-preprocessing.ipynb index 23da5d928..9adec6a7d 100644 --- a/open-machine-learning-jupyter-book/deep-learning/nlp/text-preprocessing.ipynb +++ b/open-machine-learning-jupyter-book/deep-learning/nlp/text-preprocessing.ipynb @@ -478,7 +478,7 @@ "source": [ "## Your turn! 🚀\n", "\n", - "Assignment - [Beginner Guide to Text Pre-Processing](../assignments/deep-learning/nlp/beginner-guide-to-text-preprocessing.ipynb)\n", + "Assignment - [Beginner Guide to Text Pre-Processing](../../assignments/deep-learning/nlp/beginner-guide-to-text-preprocessing.ipynb)\n", "\n", "## Acknowledgments\n", "\n", diff --git a/open-machine-learning-jupyter-book/deep-learning/nlp/text-representation.ipynb b/open-machine-learning-jupyter-book/deep-learning/nlp/text-representation.ipynb index d959fbf1e..41558a1e9 100644 --- a/open-machine-learning-jupyter-book/deep-learning/nlp/text-representation.ipynb +++ b/open-machine-learning-jupyter-book/deep-learning/nlp/text-representation.ipynb @@ -1039,7 +1039,7 @@ "source": [ "## Your turn! 🚀\n", "\n", - "Assignment - [News topic classification tasks](../assignments/deep-learning/nlp/news-topic-classification-tasks.ipynb)\n", + "Assignment - [News topic classification tasks](../../assignments/deep-learning/nlp/news-topic-classification-tasks.ipynb)\n", "\n", "## Acknowledgments\n", "\n", From 9ed64ec1d86915c165ca0ceb5f641948cef814e6 Mon Sep 17 00:00:00 2001 From: fuqiongying <3047530642@qq.com> Date: Sun, 31 Mar 2024 08:32:24 +0800 Subject: [PATCH 3/6] fix --- .../deep-learning/nlp/nlp.ipynb | 8 ++++---- .../deep-learning/nlp/text-representation.ipynb | 4 ++-- 2 files changed, 6 insertions(+), 6 deletions(-) diff --git a/open-machine-learning-jupyter-book/deep-learning/nlp/nlp.ipynb b/open-machine-learning-jupyter-book/deep-learning/nlp/nlp.ipynb index 5b578475f..41943ef09 100644 --- a/open-machine-learning-jupyter-book/deep-learning/nlp/nlp.ipynb +++ b/open-machine-learning-jupyter-book/deep-learning/nlp/nlp.ipynb @@ -108,7 +108,7 @@ "id": "fd0b8220-7d49-4c84-9338-d01d5555d664", "metadata": {}, "source": [ - "#### Syntax\n", + "### Syntax\n", "- Definition: Syntax pertains to the arrangement of words and phrases to create well-structured sentences in a language.\n", "- Example: Consider the sentence \"The cat sat on the mat.\" Syntax involves analyzing the grammatical structure of this sentence, ensuring that it adheres to the grammatical rules of English, such as subject-verb agreement and proper word order." ] @@ -118,7 +118,7 @@ "id": "7364e95d-a57e-4b70-9f5f-37d22cd17984", "metadata": {}, "source": [ - "#### Semantics\n", + "### Semantics\n", "- Definition: Semantics is concerned with understanding the meaning of words and how they create meaning when combined in sentences.\n", "- Example: In the sentence \"The panda eats shoots and leaves,\" semantics helps distinguish whether the panda eats plants (shoots and leaves) or is involved in a violent act (shoots) and then departs (leaves), based on the meaning of the words and the context." ] @@ -136,7 +136,7 @@ "id": "82bbe334-dc25-46b8-a2b8-61dc28e266ad", "metadata": {}, "source": [ - "#### Pragmatics\n", + "### Pragmatics\n", "- Definition: Pragmatics deals with understanding language in various contexts, ensuring that the intended meaning is derived based on the situation, speaker’s intent, and shared knowledge.\n", "- Example: If someone says, \"Can you pass the salt?\" Pragmatics involves understanding that this is a request rather than a question about one's ability to pass the salt, interpreting the speaker’s intent based on the dining context." ] @@ -146,7 +146,7 @@ "id": "a0bb2293-2ea7-491e-80a1-aee4259d8c3f", "metadata": {}, "source": [ - "#### Discourse\n", + "### Discourse\n", "- Definition: Discourse focuses on the analysis and interpretation of language beyond the sentence level, considering how sentences relate to each other in texts and conversations.\n", "- Example: In a conversation where one person says, \"I’m freezing,\" and another responds, \"I’ll close the window,\" discourse involves understanding the coherence between the two statements, recognizing that the second statement is a response to the implied request in the first." ] diff --git a/open-machine-learning-jupyter-book/deep-learning/nlp/text-representation.ipynb b/open-machine-learning-jupyter-book/deep-learning/nlp/text-representation.ipynb index 41558a1e9..23797bb87 100644 --- a/open-machine-learning-jupyter-book/deep-learning/nlp/text-representation.ipynb +++ b/open-machine-learning-jupyter-book/deep-learning/nlp/text-representation.ipynb @@ -378,7 +378,7 @@ }, { "cell_type": "markdown", - "id": "b1e22020", + "id": "97e81f1f", "metadata": {}, "source": [ ":::{figure} https://static-1300131294.cos.ap-shanghai.myqcloud.com/images/deep-learning/NLP/cbow.png\n", @@ -593,7 +593,7 @@ }, { "cell_type": "markdown", - "id": "efa00238", + "id": "a3f31a42", "metadata": {}, "source": [ ":::{figure} https://static-1300131294.cos.ap-shanghai.myqcloud.com/images/deep-learning/NLP/skipgram.png\n", From 6c1297fee5a790042f656991cf9365c1cc007d6d Mon Sep 17 00:00:00 2001 From: fuqiongying <3047530642@qq.com> Date: Sun, 31 Mar 2024 09:13:16 +0800 Subject: [PATCH 4/6] fix --- .../nlp/text-representation.ipynb | 36 ++++--------------- 1 file changed, 7 insertions(+), 29 deletions(-) diff --git a/open-machine-learning-jupyter-book/deep-learning/nlp/text-representation.ipynb b/open-machine-learning-jupyter-book/deep-learning/nlp/text-representation.ipynb index 23797bb87..04baf427f 100644 --- a/open-machine-learning-jupyter-book/deep-learning/nlp/text-representation.ipynb +++ b/open-machine-learning-jupyter-book/deep-learning/nlp/text-representation.ipynb @@ -23,7 +23,7 @@ "id": "74660f15", "metadata": { "tags": [ - "hide-input" + "remove-cell" ] }, "source": [ @@ -212,20 +212,9 @@ "id": "3d63655c", "metadata": {}, "source": [ - "**·Term Frequency (TF)**: Term Frequency measures how often a term (word) appears in a document. It is calculated using the formula:" - ] - }, - { - "attachments": { - "image.png": { - "image/png": "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" - } - }, - "cell_type": "markdown", - "id": "880b6882", - "metadata": {}, - "source": [ - "![image.png](attachment:image.png)" + "**·Term Frequency (TF)**: Term Frequency measures how often a term (word) appears in a document. It is calculated using the formula:\n", + "\n", + "$TF(t,d)=\\frac{Total\\ number\\ of\\ times\\ term\\ t\\ appears\\ in\\ document\\ d}{Total\\ number\\ of\\ terms\\ in\\ document\\ d}$" ] }, { @@ -233,20 +222,9 @@ "id": "7570820c", "metadata": {}, "source": [ - "**·Inverse Document Frequency (IDF)**: Inverse Document Frequency measures the importance of a term across a collection of documents. It is calculated using the formula:" - ] - }, - { - "attachments": { - "image.png": { - "image/png": "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" - } - }, - "cell_type": "markdown", - "id": "c351af56", - "metadata": {}, - "source": [ - "![image.png](attachment:image.png)" + "**·Inverse Document Frequency (IDF)**: Inverse Document Frequency measures the importance of a term across a collection of documents. It is calculated using the formula:\n", + "\n", + "$IDF(t,D)=\\log{(\\frac{Total\\ documents}{Number\\ of\\ documents\\ containing\\ term\\ t})}$" ] }, { From 15867e144fd7f88d3ada3b0f91aab8767d11882a Mon Sep 17 00:00:00 2001 From: fuqiongying <3047530642@qq.com> Date: Thu, 4 Apr 2024 17:26:02 +0800 Subject: [PATCH 5/6] associate assignment --- open-machine-learning-jupyter-book/deep-learning/nlp/nlp.ipynb | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/open-machine-learning-jupyter-book/deep-learning/nlp/nlp.ipynb b/open-machine-learning-jupyter-book/deep-learning/nlp/nlp.ipynb index 41943ef09..8f424ef66 100644 --- a/open-machine-learning-jupyter-book/deep-learning/nlp/nlp.ipynb +++ b/open-machine-learning-jupyter-book/deep-learning/nlp/nlp.ipynb @@ -673,7 +673,7 @@ "source": [ "## Your turn! 🚀\n", "\n", - "TBD." + "You can practice your nlp skills by following the assignment [getting start nlp with classification task](../../assignments/deep-learning/nlp/getting-start-nlp-with-classification-task.ipynb)." ] }, { @@ -692,6 +692,7 @@ "metadata": {}, "source": [ "```{tableofcontents}\n", + "\n", "```" ] } From 0b1523b944a30fd998c20e2c251616dc040967aa Mon Sep 17 00:00:00 2001 From: fuqiongying <3047530642@qq.com> Date: Sat, 6 Apr 2024 21:30:29 +0800 Subject: [PATCH 6/6] update --- .../nlp/text-preprocessing.ipynb | 44 ++++++++++++------- 1 file changed, 28 insertions(+), 16 deletions(-) diff --git a/open-machine-learning-jupyter-book/deep-learning/nlp/text-preprocessing.ipynb b/open-machine-learning-jupyter-book/deep-learning/nlp/text-preprocessing.ipynb index 9adec6a7d..5ecdcc0c2 100644 --- a/open-machine-learning-jupyter-book/deep-learning/nlp/text-preprocessing.ipynb +++ b/open-machine-learning-jupyter-book/deep-learning/nlp/text-preprocessing.ipynb @@ -76,7 +76,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 2, "metadata": {}, "outputs": [ { @@ -112,7 +112,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, "metadata": {}, "outputs": [ { @@ -162,7 +162,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, "metadata": {}, "outputs": [ { @@ -212,7 +212,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 5, "metadata": {}, "outputs": [ { @@ -264,7 +264,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 6, "metadata": {}, "outputs": [ { @@ -311,7 +311,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 7, "metadata": {}, "outputs": [ { @@ -405,9 +405,16 @@ "## NLTK preprocessing example code" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "First, we preprocess the text, including tokenization, part-of-speech tagging, named entity recognition, lemmatization and stopword removal." + ] + }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -431,28 +438,34 @@ "\n", "# stopword removal\n", "stopwords = nltk.corpus.stopwords.words(\"english\")\n", - "filtered_tokens = [token for token in tokens if token not in stopwords]\n", - "\n", - "# text classification (example using a simple Naive Bayes classifier)\n", - "from nltk.classify import NaiveBayesClassifier" + "filtered_tokens = [token for token in tokens if token not in stopwords]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Then we do the text classification (example using a simple Naive Bayes classifier)." ] }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 15, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Sentiment: neg\n" + "Sentiment: pos\n" ] } ], "source": [ + "from nltk.classify import NaiveBayesClassifier\n", + "\n", "# training data (using a toy dataset for illustration purposes)\n", - "training_data = [(\"It was a great movie.\", \"pos\"), (\"I hated the book.\", \"neg\"), (\"The book was okay.\", \"pos\")]\n", + "training_data = [(\"I enjoy the book.\", \"pos\"),(\"I like this movie.\", \"pos\"),(\"It was a boring movie.\", \"neg\")]\n", "\n", "# extract features from the training data\n", "def extract_features(text):\n", @@ -463,12 +476,11 @@ "\n", "# create a list of feature sets and labels\n", "feature_sets = [(extract_features(text), label) for (text, label) in training_data]\n", - "\n", "# train the classifier\n", "classifier = NaiveBayesClassifier.train(feature_sets)\n", "\n", "# test the classifier on a new example\n", - "test_text = \"I really enjoyed the movie.\"\n", + "test_text = \"I enjoyed the movie.\"\n", "print(\"Sentiment:\", classifier.classify(extract_features(test_text)))" ] },