HW6_NB.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Наивный Байес и спам\n",
    "__Суммарное количество баллов: 10__\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import re\n",
    "import copy\n",
    "from collections import Counter, defaultdict\n",
    "\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.feature_extraction.text import CountVectorizer\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib\n",
    "import spacy\n",
    "from nltk.stem.snowball import SnowballStemmer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def read_dataset(filename):\n",
    "    file = open(filename, encoding=\"utf-8\")\n",
    "    x = []\n",
    "    y = []\n",
    "    for line in file:\n",
    "        cl, sms = re.split(\"^(ham|spam)[\\t\\s]+(.*)$\", line)[1:3]\n",
    "        x.append(sms)\n",
    "        y.append(cl)\n",
    "    return np.array(x, dtype=np.str), np.array(y, dtype=np.str)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_precision_recall_accuracy(y_pred, y_true):\n",
    "    classes = np.unique(list(y_pred) + list(y_true))\n",
    "    true_positive = dict((c, 0) for c in classes)\n",
    "    true_negative = dict((c, 0) for c in classes)\n",
    "    false_positive = dict((c, 0) for c in classes)\n",
    "    false_negative = dict((c, 0) for c in classes)\n",
    "    for c_pred, c_true in zip(y_pred, y_true):\n",
    "        for c in classes:\n",
    "            if c_true == c:\n",
    "                if c_pred == c_true:\n",
    "                    true_positive[c] = true_positive.get(c, 0) + 1\n",
    "                else:\n",
    "                    false_negative[c] = false_negative.get(c, 0) + 1\n",
    "            else:\n",
    "                if c_pred == c:\n",
    "                    false_positive[c] = false_positive.get(c, 0) + 1\n",
    "                else:\n",
    "                    true_negative[c] = true_negative.get(c, 0) + 1\n",
    "    precision = dict((c, true_positive[c] / (true_positive[c] + false_positive[c]) \\\n",
    "                                            if true_positive[c] + false_positive[c] else 0) for c in classes)\n",
    "    recall = dict((c, true_positive[c] / (true_positive[c] + false_negative[c]) \\\n",
    "                                            if true_positive[c] + false_negative[c] else 0) for c in classes)\n",
    "    accuracy = sum([true_positive[c] for c in classes]) / len(y_pred)\n",
    "    return precision, recall, accuracy\n",
    "\n",
    "def plot_precision_recall(X_train, y_train, X_test, y_test, bow_method, voc_sizes=range(4, 200, 5)):\n",
    "    classes = np.unique(list(y_train) + list(y_test))\n",
    "    precisions = dict([(c, []) for c in classes])\n",
    "    recalls = dict([(c, []) for c in classes])\n",
    "    accuracies = []\n",
    "    for v in voc_sizes:\n",
    "        bow = bow_method(X_train, voc_limit=v)\n",
    "        X_train_transformed = bow.transform(X_train, )\n",
    "        X_test_transformed = bow.transform(X_test, )\n",
    "        classifier = NaiveBayes(0.001)\n",
    "        classifier.fit(X_train_transformed, y_train)\n",
    "        y_pred = classifier.predict(X_test_transformed)\n",
    "        precision, recall, acc = get_precision_recall_accuracy(y_pred, y_test)\n",
    "        for c in classes:\n",
    "            precisions[c].append(precision[c])\n",
    "            recalls[c].append(recall[c])\n",
    "        accuracies.append(acc)\n",
    "    def plot(x, ys, ylabel, legend=True):        \n",
    "        plt.figure(figsize = (12, 3))\n",
    "        plt.xlabel(\"Vocabulary size\")\n",
    "        plt.ylabel(ylabel)\n",
    "        plt.xlim(x[0], x[-1])\n",
    "        plt.ylim(np.min(list(ys.values()))-0.01, np.max(list(ys.values()))+0.01)\n",
    "        for c in ys.keys():\n",
    "            plt.plot(x, ys[c], label=\"Class \" + str(c))\n",
    "        if legend:\n",
    "            plt.legend()\n",
    "        plt.tight_layout()\n",
    "        plt.show()\n",
    "    \n",
    "    plot(voc_sizes, recalls, \"Recall\")\n",
    "    plot(voc_sizes, precisions, \"Precision\")\n",
    "    plot(voc_sizes, {\"\":accuracies}, \"Accuracy\", legend=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "X, y = read_dataset(\"hw6_data/spam\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.random.seed(28)\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, train_size=0.9)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Задание 1 (3.5 балла)\n",
    "Реализуйте классификацию методом Байеса в предположении независимости компонент `x`. При реализации следует считать, что значения каждой компоненты дискретны, а `p(x|y)` имеет мультиномиальное распределение.\n",
    "\n",
    "#### Методы\n",
    "`fit(X, y)` - оценивает параметры распределения `p(x|y)` для каждого `y`. \n",
    "\n",
    "`log_proba(X)` - для каждого элемента набора `X` считает логарифм вероятности отнести его к каждому классу. По теореме Байеса: `p(y|x) = p(y)p(x|y)/p(x)`. Соответственно, после логарифмирования: `log p(y|x) = log p(y) + log p(x|y) - log p(x)`. Поскольку `log p(x)` является независящей от класса `y` константой, это слагаемое никак не влияет на решение задачи максимизации. Поэтому его можно просто убрать для простоты."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "class NaiveBayes:\n",
    "    def __init__(self, alpha):\n",
    "        self.alpha = alpha # Параметр аддитивной регуляризации\n",
    "    \n",
    "    def fit(self, X, y):\n",
    "        self.classes = np.unique(y)\n",
    "        self.n_classes = n_classes = len(self.classes)\n",
    "        self.n_features = n_features = X.shape[1]\n",
    "        \n",
    "        # prior class probabilites\n",
    "        self.prior_cl = np.zeros(n_classes)\n",
    "        for i, label in enumerate(self.classes):\n",
    "            self.prior_cl[i] = np.mean(y == label)\n",
    "        \n",
    "        # conditional probabilities - apply Laplace smoothing\n",
    "        self.cond_prob = np.zeros(shape=(n_features, n_classes))\n",
    "        for fi in range(n_features):  # feature index\n",
    "            total_count =  np.sum(X[:, fi])\n",
    "            for ci, label in enumerate(self.classes):  # class index\n",
    "                class_count = np.sum(X[y == label][:, fi])\n",
    "                self.cond_prob[fi, ci] = (class_count + self.alpha) \\\n",
    "                                       / (total_count + n_features * self.alpha ) # * n_features)\n",
    "        \n",
    "    def predict(self, X):\n",
    "        return np.array([self.classes[i] for i in np.argmax(self.log_proba(X), axis=1)])\n",
    "    \n",
    "    def log_proba(self, X):\n",
    "        res = np.zeros(shape=(X.shape[0], self.n_classes))\n",
    "        \n",
    "        for i, xi in enumerate(X):\n",
    "            for ci in range(self.n_classes):\n",
    "                res[i, ci] = np.log(self.prior_cl[ci])\n",
    "                for fi in range(self.n_features):\n",
    "                    res[i, ci] += xi[fi] * np.log(self.cond_prob[fi, ci]) \n",
    "        return res"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Задание 2 (3.5 балла)\n",
    "Теперь реализуем метод bag of words. Задача состоит в том, чтобы посчитать количество вхождений каждого слова в предложение.\n",
    "\n",
    "#### Методы\n",
    "`__init__(X, voc_limit)` - инициализирует BoW, составляя словарь, который будет использоваться для векторизации предложений. Размер словаря должен быть не больше `voc_limit`, в него должны входить самые часто встречающиеся в выборке слова.\n",
    "\n",
    "`transform(X)` - векторизует сообщения из набора."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "class BoW:\n",
    "    def __init__(self, X, voc_limit=1000, ignore_case=True):\n",
    "        c = Counter()\n",
    "        for xi in X:\n",
    "            if ignore_case:\n",
    "                xi = xi.lower()  \n",
    "            xi = self.skip_punctuation(xi)\n",
    "            c.update(xi)\n",
    "        c.pop('')\n",
    "        self.voc = [item[0] for item in c.most_common(voc_limit)]\n",
    "        self.voc_limit = voc_limit\n",
    "        self.ignore_case=ignore_case\n",
    "        \n",
    "        self.vec = CountVectorizer(max_features=voc_limit, max_df=1.0, min_df=0.0)\n",
    "        self.vec.fit(X)\n",
    "        \n",
    "    def transform(self, X, ):\n",
    "        res = np.zeros(shape=(X.shape[0], self.voc_limit))\n",
    "        for i, xi in enumerate(X):\n",
    "            if self.ignore_case:\n",
    "                xi = xi.lower()\n",
    "            xi = self.skip_punctuation(xi)\n",
    "            c = Counter(xi)\n",
    "            for j, word in enumerate(self.voc):\n",
    "                res[i, j] = c[word]\n",
    "        \n",
    "        return res\n",
    "        \n",
    "    def skip_punctuation(self, sentence):\n",
    "        return list((''.join(filter(lambda x: all(ch.isalpha() or ch.isdigit() for ch in x), \n",
    "                                    word)) for word in sentence.split() if word != ''))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "bow = BoW(X_train, voc_limit=500)\n",
    "X_train_bow = bow.transform(X_train)\n",
    "X_test_bow = bow.transform(X_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "({'ham': 0.9449715370018975, 'spam': 1.0},\n",
       " {'ham': 1.0, 'spam': 0.5166666666666667},\n",
       " 0.9480286738351255)"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "clf = NaiveBayes(0.001)\n",
    "clf.fit(X_train_bow, y_train)\n",
    "get_precision_recall_accuracy(clf.predict(X_test_bow), y_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x216 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x216 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x216 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_precision_recall(X_train, y_train, X_test, y_test, BoW)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Задание 3 (3 балла)\n",
    "Теперь добавим в BoW стемминг. Для этого нам понадобится класс SnowballStemmer из пакета `nltk`\n",
    "\n",
    "#### Методы\n",
    "`__init__(X, voc_limit)` - инициализирует BoW, составляя словарь, который будет использоваться для векторизации предложений. Размер словаря должен быть не больше `voc_limit`, в него должны входить самые часто встречающиеся в выборке слова.\n",
    "\n",
    "`transform(X)` - векторизует сообщения из набора."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "class BowStem:\n",
    "    def __init__(self, X, voc_limit=1000, ignore_case=True):\n",
    "        self.stemmer = SnowballStemmer('english')\n",
    "        c = Counter()\n",
    "        for xi in X:\n",
    "            if ignore_case:\n",
    "                xi = xi.lower()  \n",
    "            xi = [self.stemmer.stem(w) for w in self.skip_punctuation(xi)]\n",
    "            c.update(xi)\n",
    "        c.pop('')\n",
    "        self.voc = [item[0] for item in c.most_common(voc_limit)]\n",
    "        self.voc_limit = voc_limit\n",
    "        self.ignore_case=ignore_case\n",
    "        \n",
    "    def transform(self, X, use_sklearn=False):\n",
    "        res = np.zeros(shape=(X.shape[0], self.voc_limit))\n",
    "        for i, xi in enumerate(X):\n",
    "            if self.ignore_case:\n",
    "                xi = xi.lower()\n",
    "            xi = [self.stemmer.stem(w) for w in self.skip_punctuation(xi)]\n",
    "            \n",
    "            c = Counter(xi)\n",
    "            for j, word in enumerate(self.voc):\n",
    "                res[i, j] = c[word]\n",
    "        \n",
    "        return res\n",
    "        \n",
    "    def skip_punctuation(self, sentence):\n",
    "        return list((''.join(filter(lambda x: all(ch.isalpha() or ch.isdigit() for ch in x), \n",
    "                                    word)) for word in sentence.split() if word != ''))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "bows = BowStem(X_train, voc_limit=500)\n",
    "X_train_bows = bows.transform(X_train)\n",
    "X_test_bows = bows.transform(X_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "({'ham': 0.9485714285714286, 'spam': 1.0},\n",
       " {'ham': 1.0, 'spam': 0.55},\n",
       " 0.9516129032258065)"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "predictor = NaiveBayes(0.001)\n",
    "predictor.fit(X_train_bows, y_train)\n",
    "get_precision_recall_accuracy(predictor.predict(X_test_bows), y_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x216 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x216 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x216 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_precision_recall(X_train, y_train, X_test, y_test, BowStem)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.5"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": false,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}