Tag_Prediction_on_Stack_Overflow_Posts.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Tag Prediction on Stack Overflow Posts",
      "provenance": [],
      "collapsed_sections": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5ynYgUuLWI5E"
      },
      "source": [
        "\n",
        "Text preprocessing"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CJaBsxYpWJbm",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "d79b8fec-1823-4abf-e284-57aa642e8655"
      },
      "source": [
        "import nltk\n",
        "nltk.download('stopwords')\n",
        "from nltk.corpus import stopwords"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[nltk_data] Downloading package stopwords to /root/nltk_data...\n",
            "[nltk_data]   Package stopwords is already up-to-date!\n"
          ],
          "name": "stderr"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FGuHNuP1WWDa"
      },
      "source": [
        "from ast import literal_eval\n",
        "import pandas as pd\n",
        "import numpy as np\n",
        "\n",
        "def read_data(filename):\n",
        "    data = pd.read_csv(filename, sep='\\t')\n",
        "    data['tags'] = data['tags'].apply(literal_eval)\n",
        "    return data\n",
        "\n",
        "train = read_data('data/train.tsv')\n",
        "validation = read_data('data/validation.tsv')\n",
        "test = pd.read_csv('data/test.tsv', sep='\\t')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "oyGOPcLgWpC7",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 206
        },
        "outputId": "5fbc09a7-ae69-4a6a-b147-a214a72141d3"
      },
      "source": [
        "train.head()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/html": [
              "<div>\n",
              "<style scoped>\n",
              "    .dataframe tbody tr th:only-of-type {\n",
              "        vertical-align: middle;\n",
              "    }\n",
              "\n",
              "    .dataframe tbody tr th {\n",
              "        vertical-align: top;\n",
              "    }\n",
              "\n",
              "    .dataframe thead th {\n",
              "        text-align: right;\n",
              "    }\n",
              "</style>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>title</th>\n",
              "      <th>tags</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>How to draw a stacked dotplot in R?</td>\n",
              "      <td>[r]</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>mysql select all records where a datetime fiel...</td>\n",
              "      <td>[php, mysql]</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>How to terminate windows phone 8.1 app</td>\n",
              "      <td>[c#]</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>3</th>\n",
              "      <td>get current time in a specific country via jquery</td>\n",
              "      <td>[javascript, jquery]</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>4</th>\n",
              "      <td>Configuring Tomcat to Use SSL</td>\n",
              "      <td>[java]</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>"
            ],
            "text/plain": [
              "                                               title                  tags\n",
              "0                How to draw a stacked dotplot in R?                   [r]\n",
              "1  mysql select all records where a datetime fiel...          [php, mysql]\n",
              "2             How to terminate windows phone 8.1 app                  [c#]\n",
              "3  get current time in a specific country via jquery  [javascript, jquery]\n",
              "4                      Configuring Tomcat to Use SSL                [java]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 5
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DS42glFNWqKW"
      },
      "source": [
        "X_train, y_train = train['title'].values, train['tags'].values\n",
        "X_val, y_val = validation['title'].values, validation['tags'].values\n",
        "X_test = test['title'].values"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "w-RapVgxW2SC"
      },
      "source": [
        "import re\n",
        "REPLACE_BY_SPACE_RE = re.compile('[/(){}\\[\\]\\|@,;]')\n",
        "BAD_SYMBOLS_RE = re.compile('[^0-9a-z #+_]')\n",
        "STOPWORDS = set(stopwords.words('english'))\n",
        "\n",
        "def text_prepare(text):\n",
        "    \"\"\"\n",
        "        text: a string\n",
        "        \n",
        "        return: modified initial string\n",
        "    \"\"\"\n",
        "    text = text.lower()\n",
        "    text = re.sub(REPLACE_BY_SPACE_RE,\" \",text)\n",
        "    text = re.sub(BAD_SYMBOLS_RE,\"\",text)\n",
        "    text = text.split();\n",
        "    return ' '.join([i for i in text if i not in STOPWORDS])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CwCYIZ4QYw_-",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "8e2f9b83-0d22-4815-a6a8-932d88e0f353"
      },
      "source": [
        "def test_text_prepare():\n",
        "    examples = [\"SQL Server - any equivalent of Excel's CHOOSE function?\",\n",
        "                \"How to free c++ memory vector<int> * arr?\"]\n",
        "    answers = [\"sql server equivalent excels choose function\", \n",
        "               \"free c++ memory vectorint arr\"]\n",
        "    for ex, ans in zip(examples, answers):\n",
        "        if text_prepare(ex) != ans:\n",
        "            return \"Wrong answer for the case: '%s'\" % ex\n",
        "    return 'Basic tests are passed.'\n",
        "print(test_text_prepare())    "
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Basic tests are passed.\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9I9UhVwQY3fn",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "7ad57c50-4071-4dcf-f20f-d38f2b369406"
      },
      "source": [
        "prepared_questions = []\n",
        "for line in open('data/text_prepare_tests.tsv', encoding='utf-8'):\n",
        "    line = text_prepare(line.strip())\n",
        "    prepared_questions.append(line)\n",
        "text_prepare_results = '\\n'.join(prepared_questions)\n",
        "\n",
        "grader.submit_tag('TextPrepare', text_prepare_results)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Current answer for task TextPrepare is:\n",
            " sqlite php readonly\n",
            "creating multiple textboxes dynamically\n",
            "self one prefer javascript\n",
            "save php date...\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "uNnIu5MhZavp",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "19fa2786-04b7-448d-9c78-56323653f061"
      },
      "source": [
        "X_train[:3]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array(['How to draw a stacked dotplot in R?',\n",
              "       'mysql select all records where a datetime field is less than a specified value',\n",
              "       'How to terminate windows phone 8.1 app'], dtype=object)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 10
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AZAp-S9jZbIU"
      },
      "source": [
        "# Dictionary of all tags from train corpus with their counts.\n",
        "from collections import defaultdict\n",
        "tags_counts = defaultdict(int)\n",
        "# Dictionary of all words from train corpus with their counts.\n",
        "words_counts = defaultdict(int)\n",
        "\n",
        "for tags in y_train:\n",
        "    for tag in tags:\n",
        "        tags_counts[tag]+=1\n",
        "\n",
        "for text in X_train:\n",
        "    for word in text.split():\n",
        "        words_counts[word]+=1"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SvEX7x71aAX2",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "6905b873-abfc-4ee9-9630-8f1f7b39c24c"
      },
      "source": [
        "most_common_tags = sorted(tags_counts.items(), key=lambda x: x[1], reverse=True)[:3]\n",
        "most_common_words = sorted(words_counts.items(), key=lambda x: x[1], reverse=True)[:3]\n",
        "\n",
        "grader.submit_tag('WordsTagsCount', '%s\\n%s' % (','.join(tag for tag, _ in most_common_tags), \n",
        "                                                ','.join(word for word, _ in most_common_words)))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Current answer for task WordsTagsCount is:\n",
            " javascript,c#,java\n",
            "to,in,a...\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "J5m9E3M8aEo6"
      },
      "source": [
        "Transforming text to a vector"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HG2pAA7taB6u"
      },
      "source": [
        "DICT_SIZE = 5000\n",
        "INDEX_TO_WORDS =sorted(words_counts.keys(), key = lambda x: words_counts[x], reverse = True)[:DICT_SIZE]\n",
        "WORDS_TO_INDEX = {word: i for i, word in enumerate(INDEX_TO_WORDS)}\n",
        "ALL_WORDS = WORDS_TO_INDEX.keys()\n",
        "\n",
        "def my_bag_of_words(text, words_to_index, dict_size):\n",
        "    result_vector = np.zeros(dict_size)\n",
        "    for word in text.split():\n",
        "        if word in words_to_index:\n",
        "            result_vector[words_to_index[word]]+=1\n",
        "    return result_vector"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "oru84n_Eaxgx"
      },
      "source": [
        "def test_my_bag_of_words():\n",
        "    words_to_index = {'hi': 0, 'you': 1, 'me': 2, 'are': 3}\n",
        "    examples = ['hi how are you']\n",
        "    answers = [[1, 1, 0, 1]]\n",
        "    for ex, ans in zip(examples, answers):\n",
        "        if (my_bag_of_words(ex, words_to_index, 4) != ans).any():\n",
        "            return \"Wrong answer for the case: '%s'\" % ex\n",
        "    return 'Basic tests are passed.'"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pICMVtfMa_Tr",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "0e73dbb9-e2d8-423d-8451-a349125827ef"
      },
      "source": [
        "print(test_my_bag_of_words())"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Basic tests are passed.\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "St6_eTIhdR97",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "a077084c-19ef-46a3-8001-3ab3578b75f2"
      },
      "source": [
        "from scipy import sparse as sp_sparse\n",
        "X_train_mybag = sp_sparse.vstack([sp_sparse.csr_matrix(my_bag_of_words(text, WORDS_TO_INDEX, DICT_SIZE)) for text in X_train])\n",
        "X_val_mybag = sp_sparse.vstack([sp_sparse.csr_matrix(my_bag_of_words(text, WORDS_TO_INDEX, DICT_SIZE)) for text in X_val])\n",
        "X_test_mybag = sp_sparse.vstack([sp_sparse.csr_matrix(my_bag_of_words(text, WORDS_TO_INDEX, DICT_SIZE)) for text in X_test])\n",
        "print('X_train shape ', X_train_mybag.shape)\n",
        "print('X_val shape ', X_val_mybag.shape)\n",
        "print('X_test shape ', X_test_mybag.shape)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "X_train shape  (100000, 5000)\n",
            "X_val shape  (30000, 5000)\n",
            "X_test shape  (20000, 5000)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "oe1OQsjAdikF",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "b80f44cb-7525-41f9-f002-76cb071dca69"
      },
      "source": [
        "row = X_train_mybag[10].toarray()[0]\n",
        "non_zero_elements_count =(row >0).sum()\n",
        "\n",
        "grader.submit_tag('BagOfWords', str(non_zero_elements_count))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Current answer for task BagOfWords is:\n",
            " 9...\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WDkSrDYNdzhV"
      },
      "source": [
        "from sklearn.feature_extraction.text import TfidfVectorizer\n",
        "def tfidf_features(X_train, X_val, X_test):\n",
        "    \"\"\"\n",
        "        X_train, X_val, X_test — samples        \n",
        "        return TF-IDF vectorized representation of each sample and vocabulary\n",
        "    \"\"\"\n",
        "    # Create TF-IDF vectorizer with a proper parameters choice\n",
        "    # Fit the vectorizer on the train set\n",
        "    # Transform the train, test, and val sets and return the result\n",
        "    \n",
        "    tfidf_vectorizer = TfidfVectorizer(min_df=5,max_df =0.9, ngram_range =(1,2),token_pattern ='(\\S+)')\n",
        "    \n",
        "    X_train =tfidf_vectorizer.fit_transform(X_train)\n",
        "    X_val = tfidf_vectorizer.transform(X_val)\n",
        "    X_test = tfidf_vectorizer.transform(X_test)\n",
        "    \n",
        "    return X_train, X_val, X_test, tfidf_vectorizer.vocabulary_"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "IVwZB8Ksd3Bn"
      },
      "source": [
        "X_train_tfidf, X_val_tfidf, X_test_tfidf, tfidf_vocab = tfidf_features(X_train, X_val, X_test)\n",
        "tfidf_reversed_vocab = {i:word for word,i in tfidf_vocab.items()}"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "leOKa2_veUsf",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "4c5be3e9-7509-433d-b828-285dca1268b2"
      },
      "source": [
        "tfidf_vocab['c++']"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "4600"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 20
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7dLreQnnedjg",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 36
        },
        "outputId": "1789fec9-cee0-44b7-900d-3f654a7fbe66"
      },
      "source": [
        "tfidf_reversed_vocab[4600]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'c++'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 21
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "f-LbqkThei6F"
      },
      "source": [
        "from sklearn.preprocessing import MultiLabelBinarizer\n",
        "mlb = MultiLabelBinarizer(classes=sorted(tags_counts.keys()))\n",
        "y_train = mlb.fit_transform(y_train)\n",
        "y_val = mlb.fit_transform(y_val)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cG8V2H9ifGdr"
      },
      "source": [
        "from sklearn.multiclass import OneVsRestClassifier\n",
        "from sklearn.linear_model import LogisticRegression, RidgeClassifier\n",
        "def train_classifier(X_train, y_train):trained classifier\n",
        "    \"\"\"\n",
        "    # Create and fit LogisticRegression wraped into OneVsRestClassifier.    \n",
        "    clf = OneVsRestClassifier(RidgeClassifier(normalize =True))\n",
        "    clf.fit(X_train,y_train)\n",
        "    return clf"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LT9dDfvMftre"
      },
      "source": [
        "classifier_mybag = train_classifier(X_train_mybag, y_train)\n",
        "classifier_tfidf = train_classifier(X_train_tfidf, y_train)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "UsxVLqFkfzHs"
      },
      "source": [
        "y_val_predicted_labels_mybag = classifier_mybag.predict(X_val_mybag)\n",
        "y_val_predicted_scores_mybag = classifier_mybag.decision_function(X_val_mybag)\n",
        "\n",
        "y_val_predicted_labels_tfidf = classifier_tfidf.predict(X_val_tfidf)\n",
        "y_val_predicted_scores_tfidf = classifier_tfidf.decision_function(X_val_tfidf)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6BiplPcqgBl4",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "84eda67c-d8eb-4649-a40d-e5a2cbd2225b"
      },
      "source": [
        "y_val_pred_inversed = mlb.inverse_transform(y_val_predicted_labels_tfidf)\n",
        "y_val_inversed = mlb.inverse_transform(y_val)\n",
        "for i in range(3):\n",
        "    print('Title:\\t{}\\nTrue labels:\\t{}\\nPredicted labels:\\t{}\\n\\n'.format(\n",
        "        X_val[i],\n",
        "        ','.join(y_val_inversed[i]),\n",
        "        ','.join(y_val_pred_inversed[i])\n",
        "    ))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Title:\tWhy odbc_exec always fail?\n",
            "True labels:\tphp,sql\n",
            "Predicted labels:\t\n",
            "\n",
            "\n",
            "Title:\tAccess a base classes variable from within a child class\n",
            "True labels:\tjavascript\n",
            "Predicted labels:\t\n",
            "\n",
            "\n",
            "Title:\tContent-Type \"application/json\" not required in rails\n",
            "True labels:\truby,ruby-on-rails\n",
            "Predicted labels:\truby-on-rails\n",
            "\n",
            "\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9BOcbJ4FgS7m"
      },
      "source": [
        "from sklearn.metrics import accuracy_score\n",
        "from sklearn.metrics import f1_score\n",
        "from sklearn.metrics import roc_auc_score \n",
        "from sklearn.metrics import average_precision_score\n",
        "from sklearn.metrics import recall_score\n",
        "\n",
        "def print_evaluation_scores(y_val, predicted):\n",
        "    print(accuracy_score(y_val,predicted))\n",
        "    print(f1_score(y_val,predicted,average = 'weighted'))\n",
        "    print(average_precision_score(y_val,predicted))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4aabOL9QgY3X",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "cf7b7189-55f4-4691-9461-41e093162e30"
      },
      "source": [
        "print('Bag-of-words')\n",
        "print_evaluation_scores(y_val, y_val_predicted_labels_mybag)\n",
        "print('Tfidf')\n",
        "print_evaluation_scores(y_val, y_val_predicted_labels_tfidf)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Bag-of-words\n",
            "0.15913333333333332\n",
            "0.35094245868701784\n",
            "0.10319669169287037\n",
            "Tfidf\n",
            "0.23706666666666668\n",
            "0.4819196928016005\n",
            "0.20358877147781837\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vPKl9etQgZzo",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 295
        },
        "outputId": "e5f62036-eadc-4c9f-d15c-aba2e9874c56"
      },
      "source": [
        "from metrics import roc_auc\n",
        "%matplotlib inline\n",
        "n_classes = len(tags_counts)\n",
        "roc_auc(y_val, y_val_predicted_scores_mybag, n_classes)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WvQXI3hlggfJ",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 295
        },
        "outputId": "00123765-2788-49d0-9e27-d7fa2ac81469"
      },
      "source": [
        "n_classes = len(tags_counts)\n",
        "roc_auc(y_val, y_val_predicted_scores_tfidf, n_classes)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rS9iSIPhg-FW",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "7360a38f-fed3-4506-98c4-e4f28e188b63"
      },
      "source": [
        "test_predictions = classifier_tfidf.predict(X_test_tfidf)\n",
        "test_pred_inversed = mlb.inverse_transform(test_predictions)\n",
        "\n",
        "test_predictions_for_submission = '\\n'.join('%i\\t%s' % (i, ','.join(row)) for i, row in enumerate(test_pred_inversed))\n",
        "grader.submit_tag('MultilabelClassification', test_predictions_for_submission)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Current answer for task MultilabelClassification is:\n",
            " 0\tmysql,php\n",
            "1\tjavascript\n",
            "2\t\n",
            "3\tjavascript,jquery\n",
            "4\tandroid\n",
            "5\tphp,xml\n",
            "6\tjson\n",
            "7\tjava,swing\n",
            "8\tpython\n",
            "9\t\n",
            "...\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KmV1DbQ6g-yP"
      },
      "source": [
        "def print_words_for_tag(classifier, tag, tags_classes, index_to_words, all_words):\n",
        "    print('Tag:\\t{}'.format(tag))\n",
        "    # Extract an estimator from the classifier for the given tag.\n",
        "    # Extract feature coefficients from the estimator.\n",
        "    est = classifier.estimators_[tags_classes.index(tag)]\n",
        "    top_positive_words = [index_to_words[index] for index in est.coef_.argsort().tolist()[0][-5:]]# top-5 words sorted by the coefficiens.\n",
        "    top_negative_words = [index_to_words[index] for index in est.coef_.argsort().tolist()[0][:5]]# bottom-5 words  sorted by the coefficients.\n",
        "    print('Top positive words:\\t{}'.format(', '.join(top_positive_words)))\n",
        "    print('Top negative words:\\t{}\\n'.format(', '.join(top_negative_words)))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ijF1vk2thJ9h",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "534ec3cf-9e03-4f47-ea2f-e6f6f9a6b6b2"
      },
      "source": [
        "print_words_for_tag(classifier_tfidf, 'c', mlb.classes, tfidf_reversed_vocab, ALL_WORDS)\n",
        "print_words_for_tag(classifier_tfidf, 'c++', mlb.classes, tfidf_reversed_vocab, ALL_WORDS)\n",
        "print_words_for_tag(classifier_tfidf, 'linux', mlb.classes, tfidf_reversed_vocab, ALL_WORDS)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Tag:\tc\n",
            "Top positive words:\t(c, in c, in c?, c, (c)\n",
            "Top negative words:\tobjective, objective c:, fault on, objective c, to unsigned\n",
            "\n",
            "Tag:\tc++\n",
            "Top positive words:\tc++?, qwidget, compiler?, (c++), c++\n",
            "Top negative words:\tobject file:, file: no, void pointer, opencv python, access memory\n",
            "\n",
            "Tag:\tlinux\n",
            "Top positive words:\tlinux:, linux, for linux, (linux), linux)\n",
            "Top negative words:\ta bash, 3 for, develop a, compiling with, a unix\n",
            "\n"
          ],
          "name": "stdout"
        }
      ]
    }
  ]
}