MainApp.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "from urllib.request import urlopen\n",
    "from urllib import parse\n",
    "from bs4 import BeautifulSoup\n",
    "from Models.DataCollector import DataCollector\n",
    "from Models.UserInspector import UserInspector\n",
    "from champion_graph import ChampionGraph\n",
    "import torch.nn.functional as F\n",
    "import json\n",
    "import operator\n",
    "\n",
    "import torch\n",
    "from Models.Models import AutoEncoder, Predictor\n",
    "from utils import champ_id_remap, global_win_rate, get_original_champ_id\n",
    "\n",
    "with open('./metadata/name_to_key.json', 'r') as fp:\n",
    "    name_to_key = json.load(fp)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ChampionRecommender():\n",
    "    def __init__(self):\n",
    "        self.user_inspector = UserInspector()\n",
    "\n",
    "        self.user_encoder = AutoEncoder(143, 12)\n",
    "        self.user_encoder.load_state_dict(torch.load('./trained_model/user_encoder_augmented.pth'))\n",
    "\n",
    "        self.item_encoder = AutoEncoder(143, 8)\n",
    "        self.item_encoder.load_state_dict(torch.load('./trained_model/item_encoder2.pth'))\n",
    "\n",
    "        self.predictor = Predictor(user_len=12, item_len=8, hidden_unit=10).eval()\n",
    "        self.predictor.load_state_dict(torch.load('./trained_model/predictor_last_m.pth'))\n",
    "        \n",
    "        self.remapped_champ_id = champ_id_remap()\n",
    "        self.global_win_rate = global_win_rate() \n",
    "        \n",
    "        with open('./datasets/item_vectors_tf_idf.json', 'r') as fp:\n",
    "            self.item_vectors = json.load(fp)        \n",
    "        \n",
    "        with open('./metadata/user_idf_table.json', 'r') as fp:\n",
    "            self.idf_table = json.load(fp)\n",
    "\n",
    "    def recommender(self, userName):\n",
    "        #try:\n",
    "        user_data = self.user_inspector.user_history_collector(userName)\n",
    "        win_rate_dict, played_champion_key = self.winrate_predictior(user_data)\n",
    "        champ_sim_dict = self.champion_mapper(userName)\n",
    "        \n",
    "        recommendation = dict()\n",
    "        \n",
    "        for key in champ_sim_dict.keys():\n",
    "            recommendation[key] = 0.001*win_rate_dict[key] + champ_sim_dict[key]\n",
    "            \n",
    "\n",
    "        return recommendation, played_champion_key\n",
    "        #except:\n",
    "        #    print(\"not a valid user. please check.\")\n",
    "        \n",
    "    def champion_mapper(self, userName):\n",
    "        champion_graph = ChampionGraph(userName)\n",
    "        champion_distance = champion_graph.get_champion_distance()\n",
    "        champ_sim_dict = dict()\n",
    "        sorted_result = sorted(champion_distance.items(), key=operator.itemgetter(1), reverse=False)\n",
    "        for item in sorted_result:\n",
    "            champ_sim_dict[item[0]] = round(1/item[1], 4)\n",
    "        return champ_sim_dict\n",
    "    \n",
    "\n",
    "    def winrate_predictior(self, user_data):\n",
    "        user_winrate = self._tensor_item(user_data['win_rate'])\n",
    "        user_vec = self._user_vector_generator(user_data)\n",
    "        played_champions = [i for i, e in enumerate(user_vec) if e != 0]\n",
    "        \n",
    "        played_champion_key = [get_original_champ_id(self.remapped_champ_id, int(i)) for i in played_champions]\n",
    "        \n",
    "        user_vec = torch.Tensor(user_vec)\n",
    "        user_vec = self.user_encoder.encoder(user_vec)\n",
    "        \n",
    "        win_rate_dict = dict()\n",
    "        \n",
    "        for key, item in self.item_vectors.items():\n",
    "            if int(key) not in played_champions:\n",
    "                global_win = self._tensor_item(self.global_win_rate[int(key)])\n",
    "                item_vec = torch.Tensor([item])\n",
    "                item_vec = self.item_encoder.encoder(item_vec)\n",
    "                #item_vec = torch.Tensor([0,0,0,0,0,0,0,0])\n",
    "                #user_vec = torch.Tensor([0,0,0,0,0,0,0,0,0,0,0,0])\n",
    "                item_vec = item_vec.squeeze()\n",
    "                \n",
    "                user_vec = F.normalize(user_vec, dim=0)\n",
    "                item_vec = F.normalize(item_vec, dim=0)\n",
    "                \n",
    "                prediction = self.predictor(user_vec, item_vec, user_winrate, global_win)\n",
    "                win_rate_dict[key] = prediction.item() - global_win.item()\n",
    "        \n",
    "        win_rate_dict = self._dict_origin_mapper(win_rate_dict)\n",
    "        sorted_result = sorted(win_rate_dict.items(), key=operator.itemgetter(1), reverse=True)\n",
    "        win_rate_dict = dict()\n",
    "        \n",
    "        for item in sorted_result:\n",
    "            win_rate_dict[item[0]] = item[1]\n",
    "            \n",
    "        return win_rate_dict, played_champion_key\n",
    "    \n",
    "    \n",
    "    def system_tester(self, userName):\n",
    "        allchamp = self.user_inspector.user_allchamp_collector(userName)\n",
    "        recommendation, played_keys = self.recommender(userName)\n",
    "        \n",
    "        type1_1 = []\n",
    "        type1_2 = []\n",
    "        all_win = []\n",
    "        \n",
    "        for i, (key, item) in enumerate(recommendation.items()):\n",
    "            if key in allchamp.keys():\n",
    "                type1_1.append(i)\n",
    "                type1_2.append(allchamp[key][1])\n",
    "                all_win.append(allchamp[key][1])\n",
    "        \n",
    "        reco = []\n",
    "        type2 = []\n",
    "        for i in range(5):\n",
    "            key = list(recommendation.keys())[i]\n",
    "            if key in allchamp.keys():\n",
    "                reco.append(allchamp[key][1])\n",
    "                \n",
    "        if len(reco) != 0 and len(all_win) != 0:\n",
    "            type2.append(sum(reco)/len(reco) - sum(all_win)/len(all_win))\n",
    "        \n",
    "        return [type1_1, type1_2], type2\n",
    "        \n",
    "    \n",
    "    def _dict_origin_mapper(self, recommend_dict):\n",
    "        original_recommend_dict = dict()\n",
    "        for remapped_id, score in recommend_dict.items():\n",
    "            original_id = get_original_champ_id(self.remapped_champ_id, int(remapped_id))\n",
    "            original_name = self.user_inspector.key_to_id[str(original_id)]\n",
    "            original_recommend_dict[original_name] = recommend_dict[remapped_id]\n",
    "        return original_recommend_dict\n",
    "\n",
    "            \n",
    "    def _user_vector_generator(self, user_data):\n",
    "        user_win_rate = user_data['win_rate']\n",
    "        play_count_vector = [0 for x in range(143)]\n",
    "\n",
    "        for champ_history in user_data['champion_history']:\n",
    "            original_champ_id = champ_history['champion_key']\n",
    "            champ_idx = self.remapped_champ_id[original_champ_id]\n",
    "\n",
    "            max_play_count = self._get_max_play_count(user_data)\n",
    "            measured_score = (champ_history['play_count'] / max_play_count) * self.idf_table[str(champ_idx)]\n",
    "            play_count_vector[champ_idx] = measured_score\n",
    "        \n",
    "        return play_count_vector\n",
    "\n",
    "    \n",
    "    def _get_max_play_count(self, user_data):\n",
    "        \"\"\"\n",
    "        Get count of maximally played champion for user_name\n",
    "        \"\"\"\n",
    "        max_play_count = 0\n",
    "\n",
    "        for champ_history in user_data['champion_history']:\n",
    "            champ_play_count = champ_history['play_count']\n",
    "            if max_play_count < champ_play_count:\n",
    "                max_play_count = champ_play_count\n",
    "\n",
    "        return max_play_count\n",
    "\n",
    "    \n",
    "    def _tensor_item(self, item):\n",
    "        return torch.Tensor([item])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "test = ChampionRecommender()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open('./data_batch/userlist1.json', 'r') as fp:\n",
    "    userlist = json.load(fp)\n",
    "\n",
    "type1_1 = []\n",
    "type1_2 = []\n",
    "type2 = []\n",
    "    \n",
    "for i, key in enumerate(userlist['user_name']):\n",
    "    try:\n",
    "        if i < 1000:\n",
    "            type1_elem, type2_elem = test.system_tester(key)\n",
    "            type1_1 += type1_elem[0]\n",
    "            type1_2 += type1_elem[1]\n",
    "            type2 += type2_elem\n",
    "\n",
    "    except:\n",
    "        pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "plt.scatter(type1_1, type1_2, alpha=0.4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sum(type2)/len(type2)"
   ]
  }
 ],
 "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.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}