Author: [Yury Kashnitsky](https://yorko.github.io). Translated and edited by [Christina Butsko](https://www.linkedin.com/in/christinabutsko/), [Nerses Bagiyan](https://www.linkedin.com/in/nersesbagiyan/), [Yulia Klimushina](https://www.linkedin.com/in/yuliya-klimushina-7168a9139), and [Yuanyuan Pao](https://www.linkedin.com/in/yuanyuanpao/). This material is subject to the terms and conditions of the [Creative Commons CC BY-NC-SA 4.0](https://creativecommons.org/licenses/by-nc-sa/4.0/) license. Free use is permitted for any non-commercial purpose. ## Article outline 1. [Analysis of IMDB movie reviews](#analysis-of-imdb-movie-reviews) 2. [A Simple Word Count](#a-simple-word-count) 3. [The XOR Problem](#the-xor-problem) 4. [Useful resources](#useful-resources) ## 1. Analysis of IMDB movie reviews Now for a little practice! We want to solve the problem of binary classification of IMDB movie reviews. We have a training set with marked reviews, 12500 reviews marked as good, another 12500 bad. Here, it's not easy to get started with machine learning right away because we don't have the matrix $X$; we need to prepare it. We will use a simple approach: bag of words model. Features of the review will be represented by indicators of the presence of each word from the whole corpus in this review. The corpus is the set of all user reviews. The idea is illustrated by a picture ```{figure} /_static/img/topic4_bag_of_words.svg ``` ```{code-cell} ipython3 import os import numpy as np import matplotlib.pyplot as plt #sharper plots %config InlineBackend.figure_format = 'retina' from sklearn.datasets import load_files from sklearn.feature_extraction.text import CountVectorizer from sklearn.linear_model import LogisticRegression ``` **To get started, we automatically download the dataset from [here](http://ai.stanford.edu/~amaas/data/sentiment/aclImdb_v1.tar.gz) and unarchive it along with the rest of datasets in the data folder. The dataset is briefly described [here](http://ai.stanford.edu/~amaas/data/sentiment/). There are 12.5k of good and bad reviews in the test and training sets.** ```{code-cell} ipython3 import tarfile from io import BytesIO import requests url = "http://ai.stanford.edu/~amaas/data/sentiment/aclImdb_v1.tar.gz" def load_imdb_dataset(extract_path, overwrite=False): # check if existed already if ( os.path.isfile(os.path.join(extract_path, "aclImdb", "README")) and not overwrite ): print("IMDB dataset is already in place.") return print("Downloading the dataset from: ", url) response = requests.get(url) tar = tarfile.open(mode="r:gz", fileobj=BytesIO(response.content)) data = tar.extractall(extract_path) ``` ```{code-cell} ipython3 # for Jupyter-book, we copy data from GitHub, locally, to save Internet traffic, # you can specify the data/ folder from the root of your cloned # https://github.com/Yorko/mlcourse.ai repo, to save Internet traffic DATA_PATH = "../../_static/data/" load_imdb_dataset(extract_path=DATA_PATH) ``` ```{code-cell} ipython3 # change if you have it in alternative location PATH_TO_IMDB = DATA_PATH + "aclImdb" reviews_train = load_files( os.path.join(PATH_TO_IMDB, "train"), categories=["pos", "neg"] ) text_train, y_train = reviews_train.data, reviews_train.target reviews_test = load_files(os.path.join(PATH_TO_IMDB, "test"), categories=["pos", "neg"]) text_test, y_test = reviews_test.data, reviews_test.target ``` ```{code-cell} ipython3 print("Number of documents in training data: %d" % len(text_train)) print(np.bincount(y_train)) print("Number of documents in test data: %d" % len(text_test)) print(np.bincount(y_test)) ``` **Here are a few examples of the reviews.** ```{code-cell} ipython3 print(text_train[1]) ``` ```{code-cell} ipython3 y_train[1] # bad review ``` ```{code-cell} ipython3 text_train[2] ``` ```{code-cell} ipython3 y_train[2] # good review ``` ```{code-cell} ipython3 # import pickle # with open('../../data/imdb_text_train.pkl', 'wb') as f: # pickle.dump(text_train, f) # with open('../../data/imdb_text_test.pkl', 'wb') as f: # pickle.dump(text_test, f) # with open('../../data/imdb_target_train.pkl', 'wb') as f: # pickle.dump(y_train, f) # with open('../../data/imdb_target_test.pkl', 'wb') as f: # pickle.dump(y_test, f) ``` ## 2. A Simple Word Count **First, we will create a dictionary of all the words using CountVectorizer** ```{code-cell} ipython3 cv = CountVectorizer() cv.fit(text_train) len(cv.vocabulary_) ``` **If you look at the examples of "words" (let's call them tokens), you can see that we have omitted many of the important steps in text processing (automatic text processing can itself be a completely separate series of articles).** ```{code-cell} ipython3 print(cv.get_feature_names()[:50]) print(cv.get_feature_names()[50000:50050]) ``` **Secondly, we are encoding the sentences from the training set texts with the indices of incoming words. We'll use the sparse format.** ```{code-cell} ipython3 X_train = cv.transform(text_train) X_train ``` **Let's see how our transformation worked** ```{code-cell} ipython3 print(text_train[19726]) ``` ```{code-cell} ipython3 X_train[19726].nonzero()[1] ``` ```{code-cell} ipython3 X_train[19726].nonzero() ``` **Third, we will apply the same operations to the test set** ```{code-cell} ipython3 X_test = cv.transform(text_test) ``` **The next step is to train Logistic Regression.** ```{code-cell} ipython3 %%time logit = LogisticRegression(solver="lbfgs", n_jobs=-1, random_state=7) logit.fit(X_train, y_train) ``` **Let's look at accuracy on the both the training and the test sets.** ```{code-cell} ipython3 round(logit.score(X_train, y_train), 3), round(logit.score(X_test, y_test), 3), ``` **The coefficients of the model can be beautifully displayed.** ```{code-cell} ipython3 def visualize_coefficients(classifier, feature_names, n_top_features=25): # get coefficients with large absolute values coef = classifier.coef_.ravel() positive_coefficients = np.argsort(coef)[-n_top_features:] negative_coefficients = np.argsort(coef)[:n_top_features] interesting_coefficients = np.hstack([negative_coefficients, positive_coefficients]) # plot them plt.figure(figsize=(15, 5)) colors = ["red" if c < 0 else "blue" for c in coef[interesting_coefficients]] plt.bar(np.arange(2 * n_top_features), coef[interesting_coefficients], color=colors) feature_names = np.array(feature_names) plt.xticks( np.arange(1, 1 + 2 * n_top_features), feature_names[interesting_coefficients], rotation=60, ha="right", ); ``` ```{code-cell} ipython3 def plot_grid_scores(grid, param_name): plt.plot( grid.param_grid[param_name], grid.cv_results_["mean_train_score"], color="green", label="train", ) plt.plot( grid.param_grid[param_name], grid.cv_results_["mean_test_score"], color="red", label="test", ) plt.legend(); ``` ```{code-cell} ipython3 visualize_coefficients(logit, cv.get_feature_names()); ``` **To make our model better, we can optimize the regularization coefficient for the `Logistic Regression`. We'll use `sklearn.pipeline` because `CountVectorizer` should only be applied to the training data (so as to not "peek" into the test set and not count word frequencies there). In this case, `pipeline` determines the correct sequence of actions: apply `CountVectorizer`, then train `Logistic Regression`.** ```{code-cell} ipython3 %%time from sklearn.pipeline import make_pipeline text_pipe_logit = make_pipeline( CountVectorizer(), # for some reason n_jobs > 1 won't work # with GridSearchCV's n_jobs > 1 LogisticRegression(solver="lbfgs", n_jobs=1, random_state=7), ) text_pipe_logit.fit(text_train, y_train) print(text_pipe_logit.score(text_test, y_test)) ``` ```{code-cell} ipython3 %%time from sklearn.model_selection import GridSearchCV param_grid_logit = {"logisticregression__C": np.logspace(-5, 0, 6)} grid_logit = GridSearchCV( text_pipe_logit, param_grid_logit, return_train_score=True, cv=3, n_jobs=-1 ) grid_logit.fit(text_train, y_train) ``` **Let's print best $C$ and cv-score using this hyperparameter:** ```{code-cell} ipython3 grid_logit.best_params_, grid_logit.best_score_ ``` ```{code-cell} ipython3 plot_grid_scores(grid_logit, "logisticregression__C") ``` For the validation set: ```{code-cell} ipython3 grid_logit.score(text_test, y_test) ``` **Now let's do the same with random forest. We see that, with logistic regression, we achieve better accuracy with less effort.** ```{code-cell} ipython3 from sklearn.ensemble import RandomForestClassifier ``` ```{code-cell} ipython3 forest = RandomForestClassifier(n_estimators=200, n_jobs=-1, random_state=17) ``` ```{code-cell} ipython3 %%time forest.fit(X_train, y_train) ``` ```{code-cell} ipython3 round(forest.score(X_test, y_test), 3) ``` ## 3. The XOR Problem Let's now consider an example where linear models are worse. Linear classification methods still define a very simple separating surface - a hyperplane. The most famous toy example of where classes cannot be divided by a hyperplane (or line) with no errors is "the XOR problem". XOR is the "exclusive OR", a Boolean function with the following truth table: ```{figure} /_static/img/topic4_XOR_table.gif ``` XOR is the name given to a simple binary classification problem in which the classes are presented as diagonally extended intersecting point clouds. ```{code-cell} ipython3 # creating dataset rng = np.random.RandomState(0) X = rng.randn(200, 2) y = np.logical_xor(X[:, 0] > 0, X[:, 1] > 0) ``` ```{code-cell} ipython3 plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm.Paired); ``` Obviously, one cannot draw a single straight line to separate one class from another without errors. Therefore, logistic regression performs poorly with this task. ```{code-cell} ipython3 def plot_boundary(clf, X, y, plot_title): xx, yy = np.meshgrid(np.linspace(-3, 3, 50), np.linspace(-3, 3, 50)) clf.fit(X, y) # plot the decision function for each datapoint on the grid Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())).T)[:, 1] Z = Z.reshape(xx.shape) image = plt.imshow( Z, interpolation="nearest", extent=(xx.min(), xx.max(), yy.min(), yy.max()), aspect="auto", origin="lower", cmap=plt.cm.PuOr_r, ) contours = plt.contour(xx, yy, Z, levels=[0], linewidths=2, linetypes="--") plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm.Paired) plt.xticks(()) plt.yticks(()) plt.xlabel(r"$x_1$") plt.ylabel(r"$x_2$") plt.axis([-3, 3, -3, 3]) plt.colorbar(image) plt.title(plot_title, fontsize=12); ``` ```{code-cell} ipython3 plot_boundary( LogisticRegression(solver="lbfgs"), X, y, "Logistic Regression, XOR problem" ) ``` But if one were to give polynomial features as an input (here, up to 2 degrees), then the problem is solved. ```{code-cell} ipython3 from sklearn.pipeline import Pipeline from sklearn.preprocessing import PolynomialFeatures ``` ```{code-cell} ipython3 logit_pipe = Pipeline( [ ("poly", PolynomialFeatures(degree=2)), ("logit", LogisticRegression(solver="lbfgs")), ] ) ``` ```{code-cell} ipython3 plot_boundary(logit_pipe, X, y, "Logistic Regression + quadratic features. XOR problem") ``` Here, logistic regression has still produced a hyperplane but in a 6-dimensional feature space $1, x_1, x_2, x_1^2, x_1x_2$ and $x_2^2$. When we project to the original feature space, $x_1, x_2$, the boundary is nonlinear. In practice, polynomial features do help, but it is computationally inefficient to build them explicitly. SVM with the kernel trick works much faster. In this approach, only the distance between the objects (defined by the kernel function) in a high dimensional space is computed, and there is no need to produce a combinatorially large number of features. ## 4. Useful resources - Medium ["story"](https://medium.com/open-machine-learning-course/open-machine-learning-course-topic-4-linear-classification-and-regression-44a41b9b5220) based on this notebook - Main course [site](https://mlcourse.ai), [course repo](https://github.com/Yorko/mlcourse.ai), and YouTube [channel](https://www.youtube.com/watch?v=QKTuw4PNOsU&list=PLVlY_7IJCMJeRfZ68eVfEcu-UcN9BbwiX) - Course materials as a [Kaggle Dataset](https://www.kaggle.com/kashnitsky/mlcourse) - If you read Russian: an [article](https://habrahabr.ru/company/ods/blog/323890/) on Habr.com with ~ the same material. And a [lecture](https://youtu.be/oTXGQ-_oqvI) on YouTube - A nice and concise overview of linear models is given in the book ["Deep Learning"](http://www.deeplearningbook.org) (I. Goodfellow, Y. Bengio, and A. Courville). - Linear models are covered practically in every ML book. We recommend "Pattern Recognition and Machine Learning" (C. Bishop) and "Machine Learning: A Probabilistic Perspective" (K. Murphy). - If you prefer a thorough overview of linear model from a statistician's viewpoint, then look at "The elements of statistical learning" (T. Hastie, R. Tibshirani, and J. Friedman). - The book "Machine Learning in Action" (P. Harrington) will walk you through implementations of classic ML algorithms in pure Python. - [Scikit-learn](http://scikit-learn.org/stable/documentation.html) library. These guys work hard on writing really clear documentation. - Scipy 2017 [scikit-learn tutorial](https://github.com/amueller/scipy-2017-sklearn) by Alex Gramfort and Andreas Mueller. - One more [ML course](https://github.com/diefimov/MTH594_MachineLearning) with very good materials. - [Implementations](https://github.com/rushter/MLAlgorithms) of many ML algorithms. Search for linear regression and logistic regression.