08_mnb_topfilter.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import pickle\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "from sklearn.feature_extraction.text import TfidfTransformer, TfidfVectorizer\n",
    "from sklearn.naive_bayes import MultinomialNB\n",
    "from sklearn.metrics import classification_report\n",
    "from sklearn.metrics.pairwise import cosine_similarity\n",
    "\n",
    "\n",
    "path = './learning_data/'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Load Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open(path+'X_test_raw.pkl','rb') as f:\n",
    "    X_test_raw = pickle.load(f)\n",
    "with open(path+'y_test.pkl','rb') as f:\n",
    "    y_test = pickle.load(f)\n",
    "with open(path+'y_train.pkl','rb') as f:\n",
    "    y_train = pickle.load(f)\n",
    "with open(path+'topics.pkl','rb') as f:\n",
    "    topics = pickle.load(f)\n",
    "\n",
    "test_samples_count = y_test.shape[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Load MNB Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open(path+'tfidf_vectorizer_mnb.pkl','rb') as f:\n",
    "    tfidf_vectorizer_mnb = pickle.load(f)\n",
    "with open(path+'tfidf_transformer_mnb.pkl','rb') as f:\n",
    "    tfidf_transformer_mnb = pickle.load(f)\n",
    "with open(path+'mnb_clf.pkl','rb') as f:\n",
    "    mnb_clf = pickle.load(f)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Helper function to get the top-k results for n samples in an n*m matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_top_k(values, k):\n",
    "    results = np.zeros_like(values)\n",
    "    for i in range(values.shape[0]):\n",
    "        indexes = values[i,:].argsort()[-k:][::-1]\n",
    "        results[i,indexes] = 1.0\n",
    "    return results"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Helper function to get the recommendations and their scores in a dict format"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_topic_names(recoms, k, topics=topics):\n",
    "    indices = list(np.where(recoms > 0)[0])\n",
    "    result = sorted([(topics[x],recoms[x]) for x in indices], key=lambda e: e[1], reverse=True)\n",
    "    if len(result)<k:\n",
    "        result = result + [('no-more-recoms',0)]*(k-len(result))\n",
    "    return result\n",
    "\n",
    "def vectorized_get_topic_names(recoms_array, k, topics=topics):\n",
    "    results = np.apply_along_axis(get_topic_names, 1, recoms_array, k)\n",
    "    return results"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Set K"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "k_ml = 3\n",
    "k_topfilter = 2\n",
    "k_similarity = 25\n",
    "k_saved_files = '5_3_2'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Results from MNB (Top-k)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_test_mnb = tfidf_transformer_mnb.transform(tfidf_vectorizer_mnb.transform(X_test_raw.readme_processed.values))\n",
    "mnb_predictions = mnb_clf.predict_proba(X_test_mnb)\n",
    "mnb_top_k = get_top_k(mnb_predictions, k_ml)\n",
    "\n",
    "mnb_results = mnb_predictions * mnb_top_k\n",
    "mnb_recoms = vectorized_get_topic_names(mnb_results, k_ml)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Similarity (Top-k^2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "sims_values = cosine_similarity(mnb_top_k, y_train)\n",
    "sims_top_k2 = get_top_k(sims_values, k_similarity)\n",
    "sims_filtered = sims_top_k2 * sims_values"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Make Recommendations (Top-k)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "topfilter_ratings = np.matmul(sims_filtered, y_train)/sims_filtered.sum(axis=1)[:,None]\n",
    "topfilter_ratings[np.where(mnb_results>0)] = 0\n",
    "topfilter_top_k = get_top_k(topfilter_ratings, k_topfilter)\n",
    "\n",
    "topfilter_results = topfilter_ratings * topfilter_top_k\n",
    "topfilter_recoms = vectorized_get_topic_names(topfilter_results, k_topfilter)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Report on Failures"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Topfilter failed to make 2 recommendations for 34.7% of the 29050 test repositoried.\n",
      "\n",
      "Topfilter made NO recommendations for 21.98% of the 29050 test repositoried.\n"
     ]
    }
   ],
   "source": [
    "failed_k = []\n",
    "failed_0 = []\n",
    "\n",
    "for i in range(topfilter_ratings.shape[0]):\n",
    "    if len(np.where(topfilter_ratings[i,:]>0)[0])<k_topfilter:\n",
    "        failed_k.append(i)\n",
    "    if len(np.where(topfilter_ratings[i,:]>0)[0])==0:\n",
    "        failed_0.append(i)\n",
    "\n",
    "print(f'\\nTopfilter failed to make {k_topfilter} recommendations for {np.round(len(failed_k)*100/test_samples_count, 2)}% of the {test_samples_count} test repositoried.')\n",
    "print(f'\\nTopfilter made NO recommendations for {np.round(len(failed_0)*100/test_samples_count, 2)}% of the {test_samples_count} test repositoried.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Save Results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "try:\n",
    "    os.makedirs('./results/')\n",
    "except:\n",
    "    pass\n",
    "\n",
    "with open(f'./results/mnb_topfilter_top{k_saved_files}_test_results_ml_based.pkl','wb') as f:\n",
    "    pickle.dump(mnb_recoms, f)\n",
    "with open(f'./results/mnb_topfilter_top{k_saved_files}_test_results_sim_based.pkl','wb') as f:\n",
    "    pickle.dump(topfilter_recoms, f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}