{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "## Lexicon Mining for Semiotic Squares: Exploding Binary Classification\n", "## Jason S. Kessler @jasonkessler\n", "## Talk at Data Day Texas, 2018 #ddtx\n", "\n", "Refer to the presentation [SlideShare](https://www.slideshare.net/JasonKessler/lexicon-mining-for-semiotic-squares-exploding-binary-classification-86789220) for background on this project, and an in-depth explanation of semiotic squares.\n", "\n", "The Github repository for talk is at [https://github.com/JasonKessler/SemioticSquaresTalk](https://github.com/JasonKessler/SemioticSquaresTalk).\n", "\n", "Visualizations were made using [Scattertext](https://github.com/JasonKessler/scattertext).\n", "\n", "Please cite as: \n", "Jason S. Kessler. Scattertext: a Browser-Based Tool for Visualizing how Corpora Differ. ACL System Demonstrations. 2017.\n" ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [ { "data": { "text/html": [ "" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "import pandas as pd\n", "import numpy as np\n", "import scattertext as st\n", "import seaborn as sns\n", "from scipy.stats import rankdata\n", "from IPython.display import IFrame\n", "from IPython.core.display import display, HTML\n", "display(HTML(\"\"))\n", "import matplotlib.pyplot as plt\n", "%matplotlib inline " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### The data\n", " \n", "Dataset consists of reviews of movies and plot descriptions. Plot descriptions are guaranteed to be from a movie which was reviewed. \n", "\n", "Data set is from http://www.cs.cornell.edu/people/pabo/movie-review-data/\n", "\n", "References:\n", "* Bo Pang, Lillian Lee, and Shivakumar Vaithyanathan, Thumbs up? Sentiment Classification using Machine Learning Techniques, Proceedings of EMNLP 2002.\n", "\n", "* Bo Pang and Lillian Lee, A Sentimental Education: Sentiment Analysis Using Subjectivity Summarization Based on Minimum Cuts, Proceedings of ACL 2004." ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Positive 2455\n", "Negative 2411\n", "Plot 156\n", "Name: category_name, dtype: int64\n" ] }, { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
textmovie_namecategory_name
0A senior at an elite college (Katie Holmes), a...abandonPlot
1Will Lightman is a hip Londoner who one day re...about_a_boyPlot
2Warren Schmidt (Nicholson) is forced to deal w...about_schmidtPlot
3An account of screenwriter Charlie Kaufman's (...adaptationPlot
4Ali G unwittingly becomes a pawn in the evil C...ali_g_indahousePlot
\n", "
" ], "text/plain": [ " text movie_name \\\n", "0 A senior at an elite college (Katie Holmes), a... abandon \n", "1 Will Lightman is a hip Londoner who one day re... about_a_boy \n", "2 Warren Schmidt (Nicholson) is forced to deal w... about_schmidt \n", "3 An account of screenwriter Charlie Kaufman's (... adaptation \n", "4 Ali G unwittingly becomes a pawn in the evil C... ali_g_indahouse \n", "\n", " category_name \n", "0 Plot \n", "1 Plot \n", "2 Plot \n", "3 Plot \n", "4 Plot " ] }, "execution_count": 2, "metadata": {}, "output_type": "execute_result" } ], "source": [ "rdf = st.SampleCorpora.RottenTomatoes.get_data()\n", "rdf['category_name'] = rdf['category'].apply(lambda x: {'plot': 'Plot', 'rotten': 'Negative', 'fresh': 'Positive'}[x])\n", "print(rdf.category_name.value_counts())\n", "rdf[['text', 'movie_name', 'category_name']].head()" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [], "source": [ "corpus = (st.CorpusFromPandas(rdf, \n", " category_col='category_name', \n", " text_col='text',\n", " nlp = st.whitespace_nlp_with_sentences)\n", " .build())\n", "corpus.get_term_freq_df().to_csv('term_freqs.csv')\n", "unigram_corpus = corpus.get_unigram_corpus()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Let's visualize the corpus using Scattertext\n", "\n", "The x-axis indicates the rank of a word or bigram in the set of positive reviews, and the y-axis negative reviews.\n", "\n", "Ranks are determined using \"dense\" ranking, meaning the most frequent terms, regardless of ties, are given rank 1, the next most frequent terms, regardless of ties, are given rank 2, etc.\n", "\n", "It appears that terms more associated with a class are a further distance from the diagonal line between the lower-left and upper-right corners. Terms are colored according to this distance. We'll return to this in a bit.\n", "\n", "Scattertext selectively labels points in such a way as to prevent labels from overlapping other elements of the graph. Mouse-over points and term labels for a preview, and click for a key-word in context view.\n", "\n", "References:\n", "* Jason S. Kessler. Scattertext: a Browser-Based Tool for Visualizing how Corpora Differ. ACL System Demonstrations. 2017." ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "data": { "text/html": [ "\n", " \n", " " ], "text/plain": [ "" ] }, "execution_count": 4, "metadata": {}, "output_type": "execute_result" } ], "source": [ "html = st.produce_scattertext_explorer(\n", " corpus,\n", " category='Positive',\n", " not_categories=['Negative'],\n", " sort_by_dist=False,\n", " metadata=rdf['movie_name'],\n", " term_scorer=st.RankDifference(),\n", " transform=st.Scalers.percentile_dense\n", ")\n", "file_name = 'rotten_fresh_stdense.html'\n", "open(file_name, 'wb').write(html.encode('utf-8'))\n", "IFrame(src=file_name, width = 1300, height=700)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### We view can see more terms through breaking ties in ranking alphabetically.\n", "Lower frequency terms are more prominent in this view, and more terms can be labeled." ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "data": { "text/html": [ "\n", " \n", " " ], "text/plain": [ "" ] }, "execution_count": 5, "metadata": {}, "output_type": "execute_result" } ], "source": [ "html = st.produce_scattertext_explorer(\n", " corpus,\n", " category='Positive',\n", " not_categories=['Negative'],\n", " sort_by_dist=False,\n", " metadata=rdf['movie_name'],\n", " term_scorer=st.RankDifference(),\n", ")\n", "file_name = 'rotten_fresh_st.html'\n", "open(file_name, 'wb').write(html.encode('utf-8'))\n", "IFrame(src=file_name, width = 1300, height=700)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Examining term-category association\n", "We'll roughly follow the explanation given in Monroe et. al (2008), culminating in a version of their Log-Odds-Ratio with an Informed Dirichlet Prior score. \n", "\n", "### Naive approach 1\n", "### Frequency difference (not recommended)\n", "$$\\mbox{freqdiff}(\\mbox{term}) := \\frac{\\#(\\mbox{term}\\in\\mbox{category}_a)}{\\#(\\mbox{category}_a)} - \\frac{\\#(\\mbox{term}\\in\\mbox{category}_b)}{\\#(\\mbox{category}_b)}$$\n", "Disporportionately favors very frequent words.\n", "\n", "References\n", "* Burt L. Monroe, Michael P. Colaresi, and Kevin M. Quinn. 2008. Fightin’ words: Lexical feature selection and evaluation for identifying the content of political conflict. Political Analysis.\n" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "data": { "text/html": [ "\n", " \n", " " ], "text/plain": [ "" ] }, "execution_count": 6, "metadata": {}, "output_type": "execute_result" } ], "source": [ "class FrequencyDifference:\n", " def get_scores(self, a, b): \n", " return a/np.sum(a) - b/np.sum(b)\n", " def get_name(self): \n", " return 'Frequency Difference'\n", " \n", "html = st.produce_fightin_words_explorer(\n", " corpus,\n", " category='Positive',\n", " not_categories=['Negative'],\n", " term_scorer=FrequencyDifference(),\n", " metadata = rdf['movie_name'],\n", " grey_threshold=0,\n", " #y_axis_values=[-.002,0,.002,.004]\n", ")\n", "file_name = 'rotten_fresh_diff.html'\n", "open(file_name, 'wb').write(html.encode('utf-8'))\n", "IFrame(src=file_name, width = 1300, height=700)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Naive approach 2\n", "### tf.idf difference (not recommended)\n", "$$ \\mbox{Term Frquency}(\\mbox{term}, \\mbox{category}) = \\#(\\mbox{term}\\in\\mbox{category}) $$\n", "\n", "$$ \\mbox{Inverse Document Frquency}(\\mbox{term}) = \\log \\frac{\\mbox{# of categories}}{\\mbox{# of categories containing term}} $$\n", "\n", "$$ \\mbox{tf.idf}(\\mbox{term}, \\mbox{category}) = \\mbox{Term Frquency}(\\mbox{term}, \\mbox{category}) \\times \\mbox{Inverse Document Frquency}(\\mbox{term}) $$\n", "\n", "$$ \\mbox{tf.idf-difference}(\\mbox{term}, \\mbox{category}) = \\mbox{tf.idf}(\\mbox{term}, \\mbox{category}_a) - \\mbox{tf.idf}(\\mbox{term}, \\mbox{category}_b) $$\n", "\n", "Tf.idf ignores terms used in each category. Since we only consider three categories (positive, negative and plot descriptions), a large number of terms have zero (log 1) scores. The problem is Tf.idf doesn't weight how often a term is used in another category. This causes eccentric, brittle, low-frequency terms to be favored.\n", "\n", "This formulation does take into account data from a background corpus." ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/Users/kesslej/anaconda3/lib/python3.5/site-packages/scattertext-0.0.2.17-py3.5.egg/scattertext/TermDocMatrixFilter.py:43: RuntimeWarning: invalid value encountered in log\n", " bigram_prob[bigram] / np.product([unigram_prob[word] for word in bigram.split(' ')])\n" ] }, { "data": { "text/html": [ "\n", " \n", " " ], "text/plain": [ "" ] }, "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], "source": [ "class TFIDF:\n", " def __init__(self, corpus):\n", " self.tdf = corpus.get_term_freq_df()\n", " def get_scores(self, a, b): \n", " n_docs = self.tdf.shape[1]\n", " n_docs_with_term = (self.tdf > 0).astype(float).sum(axis=1)\n", " idf = np.log(n_docs/n_docs_with_term)/np.log(2)\n", " return a * idf - b * idf\n", " def get_name(self): \n", " return 'tf.idf difference'\n", " \n", "html = st.produce_fightin_words_explorer(\n", " corpus,\n", " category='Positive',\n", " not_categories=['Negative'],\n", " term_scorer=TFIDF(corpus),\n", " metadata = rdf['movie_name'],\n", " grey_threshold=0\n", ")\n", "file_name = 'rotten_fresh_tfidf.html'\n", "open(file_name, 'wb').write(html.encode('utf-8'))\n", "IFrame(src=file_name, width = 1300, height=700)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Naive approach 3\n", "### Log-odds-ratio w/ smoothing (not recommended)\n", "\n", "$$ \\newcommand\\ddfrac[2]{\\frac{\\displaystyle #1}{\\displaystyle #2}}$$\n", "$$ \\mbox{Odds}(\\mbox{term}_i, \\mbox{category}) = \\frac{\\#(\\mbox{term}_i\\in\\mbox{category}_a)}{\\sum_{\\mbox{term}` \\neq \\mbox{term}} \\#(\\mbox{term}'\\in\\mbox{category})} = \\frac{y_{ai}}{n_{a} - y_{ai}} $$\n", "Note: this can be a very small number.\n", "\n", "The odds ratio is the ratio of the odds of a term being used in one category vs. another.\n", "$$ \\mbox{Odds-Ratio}(\\mbox{term}_i, \\mbox{category}_a, \\mbox{category}_b) = \\ddfrac{y_{ai}\\mathbin{/}(n_{a} - y_{ai})}{y_{bi}\\mathbin{/}(n_{b} - y_{bi})} $$\n", "\n", "Given the likelihood these quantities are very small, the Log-Odds-Ratio is often used.\n", "\n", "$$ \\mbox{Log-Odds-Ratio}(\\mbox{term}_i, \\mbox{category}_a, \\mbox{category}_b) = \\log \\frac{y_{ai}}{n_{a} - y_{ai}} - \\log \\frac{y_{bi}}{n_{b} - y_{bi}} $$\n", "\n", "If term does not appear in $\\mbox{category}_b$ (i.e., $ y_{bi} = 0 $), the odd of term_i in category_b will be 0 resulting the odds-ratio to be undefined. We circumvent this issue by adding a pseudo-count to each term, assuming it occurs at least $\\alpha$ times. \n", "\n", "$$ \\mbox{Smoothed Log-Odds-Ratio}(\\mbox{term}_i, \\mbox{category}_a, \\mbox{category}_b) = \\log \\frac{y_{ai} + \\alpha}{n_{a} + \\alpha \\cdot |y| - y_{ai} - \\alpha} - \\log \\frac{y_{bi} + \\alpha}{n_{b} + \\alpha \\cdot |y| - y_{bi} - \\alpha} $$\n", "\n", "This has a slightly better profile than tf.idf, but still favors very low-frequency terms that are unique to a category.\n", "\n", "We can see that terms used exclusively in one category or another clump form extremely high or low-scoring clumps. These terms occur infrequently. Intuitively, we'd like to score things highly if they have a lot of evidence behind them AND they tend to be used much more in one category vs. another." ] }, { "cell_type": "code", "execution_count": 8, "metadata": { "scrolled": false }, "outputs": [ { "data": { "text/html": [ "\n", " \n", " " ], "text/plain": [ "" ] }, "execution_count": 8, "metadata": {}, "output_type": "execute_result" } ], "source": [ "class LogOddsRatioSmoothed:\n", " def __init__(self, alpha):\n", " self.alpha = alpha\n", " def get_scores(self, a, b): \n", " return (np.log((a + self.alpha)/(np.sum(a) + self.alpha * len(a) - a - self.alpha)) \n", " - np.log((b + self.alpha)/(np.sum(b) + self.alpha * len(b) - b - self.alpha)))\n", " def get_name(self): \n", " return 'Smoothed Log-Odds-Ratio'\n", " \n", "html = st.produce_fightin_words_explorer(\n", " corpus,\n", " category='Positive',\n", " not_category_name='Negative',\n", " not_categories=['Negative'],\n", " term_scorer=LogOddsRatioSmoothed(0.00000001),\n", " metadata = rdf['movie_name'],\n", " grey_threshold=0,\n", " y_axis_values=[-20, -10, 0, 10, 20]\n", ")\n", "file_name = 'rotten_fresh_lorsmooth.html'\n", "open(file_name, 'wb').write(html.encode('utf-8'))\n", "IFrame(src=file_name, width = 1300, height=700)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Accounting for variance\n", "How can we account for the certainty of the estimates? Less frequent terms will have higher variances.\n", "\n", "The standard error of the log-odds-ratio is:\n", "\n", "$$ \\mbox{SE-Smoothed Log-Odds-Ratio}(\\mbox{term}_i, \\mbox{category}_a, \\mbox{category}_b) = \\frac{1}{y_{ai} + \\alpha} + \\frac{1}{n_{a} + \\alpha \\cdot |y| - y_{ai} - \\alpha} + \\frac{1}{y_{bi} + \\alpha}+ \\frac{1}{n_{b} + \\alpha \\cdot |y| - y_{bi} - \\alpha} $$\n", "\n", "The plot below shows how terms used infrequently and especially those which only appear in one class have a very high variance." ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "data": { "text/html": [ "\n", " \n", " " ], "text/plain": [ "" ] }, "execution_count": 9, "metadata": {}, "output_type": "execute_result" } ], "source": [ "class SELogOddsRatioSmoothed:\n", " def __init__(self, alpha):\n", " self.alpha = alpha\n", " def get_scores(self, a, b): \n", " a += self.alpha\n", " b += self.alpha\n", " return 1./a + 1./(np.sum(a) - a) + 1./b + 1./(np.sum(b) - b)\n", " def get_name(self): \n", " return 'SE Smoothed Log-Odds-Ratio'\n", " \n", "html = st.produce_fightin_words_explorer(\n", " corpus,\n", " category='Positive',\n", " not_category_name='Negative',\n", " not_categories=['Negative'],\n", " term_scorer=SELogOddsRatioSmoothed(0.00000001),\n", " metadata = rdf['movie_name'],\n", " grey_threshold=0\n", ")\n", "file_name = 'rotten_fresh_lorsmoothse.html'\n", "open(file_name, 'wb').write(html.encode('utf-8'))\n", "IFrame(src=file_name, width = 1300, height=700)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Smoothed Log-Odds-Ratio Z-Score\n", "### Preferred in certain cases\n", "\n", "Finding the Z-Scores of log-odds-ratios allows us to gracefully account for variance.\n", "\n", "$$ \\mbox{LOR Smoothed Z-Score}(\\mbox{term}_i, \\mbox{category}_a, \\mbox{category}_b) = \\frac{\\mbox{LOR Smoothed}}{\\sqrt{\\mbox{SE LOR Smoothed}}} $$\n", "\n", "The chart below, given a smoothing $\\alpha$ of 0.01, dampens the score of infrequent words and allows for frequently words to rank highly. However, the words \"and\" and \"of\" appear to be over-weighted. \n", "\n", "Eccentric words like \"winning\" are down-weighted but still significant." ] }, { "cell_type": "code", "execution_count": 21, "metadata": {}, "outputs": [ { "data": { "text/html": [ "\n", " \n", " " ], "text/plain": [ "" ] }, "execution_count": 21, "metadata": {}, "output_type": "execute_result" } ], "source": [ "class LogOddsRatioSmoothedZScorePrior:\n", " def __init__(self, prior):\n", " self.prior = prior\n", " def get_scores(self, a, b): \n", " a += self.prior\n", " b += self.prior\n", " lor = (np.log(a/(np.sum(a) - a)) - np.log(b/(np.sum(b) - b)))\n", " lorstd = 1./a + 1./(np.sum(a) - a) + 1./b + 1./(np.sum(b) - b)\n", " return lor/np.sqrt(lorstd)\n", " \n", " def get_name(self): \n", " return 'Smoothed Log-Odds-Ratio w/ Prior Z-Score'\n", "html = st.produce_fightin_words_explorer(\n", " corpus,\n", " category='Positive',\n", " not_category_name='Negative',\n", " not_categories=['Negative'],\n", " term_scorer=LogOddsRatioSmoothedZScorePrior(0.01),\n", " metadata = rdf['movie_name'],\n", " grey_threshold = 1.96\n", ")\n", "file_name = 'rotten_fresh_lorudp.html'\n", "open(file_name, 'wb').write(html.encode('utf-8'))\n", "IFrame(src=file_name, width = 1300, height=700)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Log-Odds-Ratio with Informative Dirichlet Prior Z-Score\n", "### Prefered, currently very popular in NLP and CSS literature, flaws exist\n", "### Note: this formulation is modified slightly from Monroe et al. 2008.\n", "\n", "We know, intuitively, words which which are used very frequently require much more evidence to be significantly associated with a class than less frequent words. For example, words like \"best\" and \"entertaining\" in the above example should be scored lower than \"and\" and \"of\". \n", "\n", "The approach developed by Monroe et. al is to more aggressively smooth terms based on their frequency in a background corpus.\n", "\n", "The downside is of this approach is that obtaining a background corpus may be difficult. Lists of background term frequencies, especially for 2+grams, can be very large and unwieldy. Moreover, term frequency lists can become outdated very quickly, especially wrt to politics, pop culture, and technology.\n", "\n", "We construct two vectors of background term counts for each category, $\\alpha_a$ and $\\alpha_b$. The priors are based on a background set of word frequencies, referred to as $y_{c}$ These are ideally in the same domain as the documents being studied, although could come from a general list of word frequencies. The background counts are normalized to the size of their respective categories. The hyperparameter $\\sigma$ scales the background counts to a multiple of their category size. In other words, as $\\sigma$ increases, the regularization increases, and the odds ratio tends more toward zero.\n", "\n", "The $\\sigma$ I've found most useful is 10, which I include in Scattertext.\n", "\n", "$$ \\alpha_a = \\sigma \\cdot n_a \\cdot \\frac{y_{ci}}{n_c} $$\n", "\n", "$$ \\alpha_b = \\sigma \\cdot n_b \\cdot \\frac{y_{ci}}{n_c} $$\n", "\n", "The $\\alpha$s can then be used analogously to find the Z-Score of the LOR.\n", "\n", "$$ \\mbox{LOR}(\\mbox{term}_i, \\mbox{category}_a, \\mbox{category}_b) = \\log \\frac{y_{ai} + \\alpha_a}{n_{a} + \\alpha_a \\cdot |y| - y_{ai} - \\alpha_a} - \\log \\frac{y_{bi} + \\alpha_b}{n_{b} + \\alpha_b \\cdot |y| - y_{bi} - \\alpha_b} $$\n", "\n", "$$ \\mbox{LOR-SE}(\\mbox{term}_i, \\mbox{category}_a, \\mbox{category}_b) = \\frac{1}{y_{ai} + \\alpha_a} + \\frac{1}{n_{a} + \\alpha_a \\cdot |y| - y_{ai} - \\alpha_a} + \\frac{1}{y_{bi} + \\alpha_b}+ \\frac{1}{n_{b} + \\alpha_b \\cdot |y| - y_{bi} - \\alpha_b} $$\n", "\n", "In the following example, we use the plot description as a background corpus." ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [ { "data": { "text/html": [ "\n", " \n", " " ], "text/plain": [ "" ] }, "execution_count": 11, "metadata": {}, "output_type": "execute_result" } ], "source": [ "priors = (st.PriorFactory(unigram_corpus, \n", " category='Positive', \n", " not_categories=['Negative'],\n", " starting_count=0.01)\n", " .use_neutral_categories()\n", " .get_priors())\n", "class LogOddsRatioSmoothedZScorePrior:\n", " def __init__(self, prior, prior_scale):\n", " self.prior = prior\n", " self.prior_scale = prior_scale\n", " def get_scores(self, a, b): \n", " ap = a + self.prior * self.prior_scale*sum(a)/sum(self.prior.values)\n", " bp = b + self.prior * self.prior_scale*sum(b)/sum(self.prior.values)\n", " lor = (np.log(ap/(np.sum(ap) - ap)) - np.log(bp/(np.sum(bp) - bp)))\n", " lorstd = 1./ap + 1./(np.sum(ap) - ap) + 1./bp + 1./(np.sum(bp) - bp)\n", " return lor/np.sqrt(lorstd)\n", " \n", " def get_name(self): \n", " return 'Log-Odds-Ratio w/ Informative Prior Z-Score'\n", "html = st.produce_fightin_words_explorer(\n", " unigram_corpus,\n", " category='Positive',\n", " not_category_name='Negative',\n", " not_categories=['Negative'],\n", " term_scorer=LogOddsRatioSmoothedZScorePrior(priors, 10),\n", " # Equivalent of \n", " # term_scorer=st.LogOddsRatioInformativeDirichletPrior(priors, 10), \n", " metadata = rdf['movie_name']\n", ")\n", "file_name = 'rotten_fresh_loridp.html'\n", "open(file_name, 'wb').write(html.encode('utf-8'))\n", "IFrame(src=file_name, width = 1300, height=700)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Effect of $\\sigma$\n", "In the plot below, we can see how a changing $\\sigma$ alters the z-scores of low and high-frequency terms which are associated the Positive category.\n", "\n", "A high $\\sigma$ causes the infrequent word \"winning\", which only occurs in Positive documents, to dominate more frequent, associated terms. A very low $\\sigma$ causes rankings to revert to Smoothed LOR Z-Score." ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Text(0,0.5,'Z-Score')" ] }, "execution_count": 12, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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\n", "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "term_freqs = unigram_corpus.get_term_freq_df()\n", "data = []\n", "for sigma in np.linspace(0.01, 30, 40):\n", " scores = LogOddsRatioSmoothedZScorePrior(priors, sigma).get_scores(term_freqs['Positive freq'], term_freqs['Negative freq'])\n", " for term in ['and', 'best', 'winning', 'of']:\n", " data.append({'term': term, 'score': scores[term], 'sigma': sigma})\n", "ax = (pd.DataFrame(data)\n", " .pivot(index='sigma', columns='term', values='score')\n", " .plot(figsize=(15, 8), fontsize=20))\n", "ax.legend(prop={'size': 20})\n", "ax.set_xlabel('$\\sigma$', size= 20)\n", "ax.set_ylabel('Z-Score', size= 20)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Dense rank differences\n", "### Prefered, but may under-score extremely frequent and infrequent terms\n", "\n", "Let $\\rho_\\mbox{category}$ be the dense rank function for a given category.\n", "\n", "Let $d_\\mbox{category}$ be the number of distinct term frequencies in a category\n", "\n", "This metric takes the difference of the normalized category-specific dense ranks of term frequencies. \n", "\n", "Define the rank-difference score as the difference in \n", "$$\\mbox{Rank-Difference} = \\frac{\\rho_{a}(y_a)}{d_a} - \\frac{\\rho_{b}(y_b)}{d_b}$$\n", "\n", "We can see that the words which occur fairly frequently are favored. Frequent and very infrequent words are heavily regularized.\n", "\n", "No background frequencies are required!" ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [ { "data": { "text/html": [ "\n", " \n", " " ], "text/plain": [ "" ] }, "execution_count": 13, "metadata": {}, "output_type": "execute_result" } ], "source": [ "class RankDifference:\n", " def get_scores(self, a, b): \n", " return rankdata(a,'dense')/np.max(rankdata(a,'dense')) - rankdata(b,'dense')/np.max(rankdata(b,'dense'))\n", " def get_name(self): \n", " return 'Rank Difference'\n", " \n", "html = st.produce_fightin_words_explorer(\n", " corpus,\n", " category='Positive',\n", " not_category_name='Negative',\n", " not_categories=['Negative'],\n", " term_scorer=RankDifference(),\n", " metadata = rdf['movie_name'],\n", " grey_threshold=0\n", ")\n", "file_name = 'rotten_fresh_rankdiff.html'\n", "open(file_name, 'wb').write(html.encode('utf-8'))\n", "IFrame(src=file_name, width = 1300, height=700)" ] }, { "cell_type": "code", "execution_count": 34, "metadata": {}, "outputs": [], "source": [ "tdf = unigram_corpus.get_term_freq_df()\n", "tdf['score'] = st.RankDifference().get_scores(tdf['Positive freq'], tdf['Negative freq'])\n", "tdf['cnt'] = tdf['Positive freq'] + tdf['Negative freq']\n", "tdf = tdf[tdf['cnt'] > 0]\n", "tdf['logcnt'] = np.log(tdf['cnt'])/np.log(2)\n", "tdf.reset_index().to_csv('term_freqs.csv', index=False)" ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [ { "data": { "text/html": [ "\n", " \n", " " ], "text/plain": [ "" ] }, "execution_count": 14, "metadata": {}, "output_type": "execute_result" } ], "source": [ "rdf['domain'] = rdf.category_name.apply(lambda x: 'Plot' if x == 'Plot' else 'Review')\n", "plotcorpus = (st.CorpusFromPandas(rdf, \n", " category_col='domain', \n", " text_col='text',\n", " nlp = st.whitespace_nlp_with_sentences)\n", " .build())\n", "html = st.produce_fightin_words_explorer(\n", " plotcorpus,\n", " category='Review',\n", " not_category_name='Plot',\n", " term_scorer=RankDifference(),\n", " metadata = rdf['movie_name'],\n", " grey_threshold=0\n", ")\n", "file_name = 'plot_rankdiff.html'\n", "open(file_name, 'wb').write(html.encode('utf-8'))\n", "IFrame(src=file_name, width = 1300, height=700)" ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [], "source": [ "phrase_corpus = (st.CorpusFromPandas(rdf, \n", " category_col='category_name', \n", " text_col='text',\n", " nlp = st.whitespace_nlp_with_sentences, \n", " feats_from_spacy_doc = st.PhraseMachinePhrases())\n", " .build())" ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [], "source": [ "tdf = phrase_corpus.get_term_freq_df()" ] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [], "source": [ "priors = (st.PriorFactory(phrase_corpus, \n", " category='Positive', \n", " not_categories=['Negative'],\n", " starting_count=0.01)\n", " .use_neutral_categories()\n", " .get_priors())" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### And the semiotic square using SE-LOR/Background" ] }, { "cell_type": "code", "execution_count": 18, "metadata": { "scrolled": false }, "outputs": [ { "data": { "text/html": [ "\n", " \n", " " ], "text/plain": [ "" ] }, "execution_count": 18, "metadata": {}, "output_type": "execute_result" } ], "source": [ "semiotic_square = st.SemioticSquare(\n", " phrase_corpus,\n", " category_a='Positive',\n", " category_b='Negative',\n", " neutral_categories=['Plot'],\n", " scorer=st.LogOddsRatioInformativeDirichletPrior(priors, 10),\n", ")\n", "\n", "html = st.produce_semiotic_square_explorer(semiotic_square,\n", " category_name='Positive',\n", " not_category_name='Negative',\n", " x_label='Positive-Negative',\n", " y_label='Review-Plot',\n", " neutral_category_name='Plot Description',\n", " metadata=rdf['movie_name'])\n", "\n", "fn = 'semiotic_square_loridp.html'\n", "open(fn, 'wb').write(html.encode('utf-8'))\n", "IFrame(src=fn, width = 1600, height=900)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### The Semiotic Square using RankDiff" ] }, { "cell_type": "code", "execution_count": 20, "metadata": {}, "outputs": [ { "data": { "text/html": [ "\n", " \n", " " ], "text/plain": [ "" ] }, "execution_count": 20, "metadata": {}, "output_type": "execute_result" } ], "source": [ "semiotic_square = st.SemioticSquare(\n", " phrase_corpus,\n", " category_a='Positive',\n", " category_b='Negative',\n", " neutral_categories=['Plot'],\n", " scorer=st.RankDifference(),\n", ")\n", "\n", "html = st.produce_semiotic_square_explorer(semiotic_square,\n", " category_name='Positive',\n", " not_category_name='Negative',\n", " x_label='Positive-Negative',\n", " y_label='Review-Plot',\n", " neutral_category_name='Plot Description',\n", " metadata=rdf['movie_name'])\n", "\n", "fn = 'semiotic_square_rankdiff.html'\n", "open(fn, 'wb').write(html.encode('utf-8'))\n", "IFrame(src=fn, width = 1600, height=900)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] } ], "metadata": { "anaconda-cloud": { "attach-environment": true, "environment": "Root", "summary": "Class Association Scores with Scattertext" }, "kernelspec": { "display_name": "Python [Root]", "language": "python", "name": "Python [Root]" }, "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.5.2" } }, "nbformat": 4, "nbformat_minor": 2 }