아마존.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "1c6bb1e4-ad27-46bb-b39b-4fc3ae822280",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Using backend: pytorch\n"
     ]
    }
   ],
   "source": [
    "\"\"\"RottenMovie dataset\"\"\"\n",
    "import numpy as np\n",
    "import os\n",
    "import re\n",
    "import pandas as pd\n",
    "import scipy.sparse as sp\n",
    "import torch as th\n",
    "\n",
    "import dgl\n",
    "from dgl.data.utils import download, extract_archive, get_download_dir\n",
    "from utils import to_etype_name\n",
    "import pandas as pd\n",
    "import os\n",
    "import datetime\n",
    "import numpy as np\n",
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "18ec84be-2f6a-408e-ae50-296e8af9ca64",
   "metadata": {},
   "outputs": [],
   "source": [
    "import easydict\n",
    "\n",
    "args = easydict.EasyDict({ \n",
    "    \"data_name\":                      \"rotten\", \n",
    "    \"use_one_hot_fea\":                True,\n",
    "    \"gpu\":                            0,\n",
    "    \"seed\":                           123,\n",
    "    \"data_test_ratio\":                0.1,\n",
    "    \"data_valid_ratio\":               0.1,\n",
    "    \"model_activation\":               'leaky',\n",
    "    \"gcn_dropout\":                    0.5,\n",
    "    \"gcn_agg_norm_symm\":              True,\n",
    "    \"gcn_agg_units\":                  32,\n",
    "    \"gcn_agg_accum\":                  'sum',\n",
    "    \"gcn_out_units\":                  32, # 64, 128\n",
    "    \"gen_r_num_basis_func\":           2,\n",
    "    \"train_max_epoch\":                300,\n",
    "    \"train_log_interval\":             5,\n",
    "    \"train_valid_interval\":           5,\n",
    "    \"train_optimizer\":                'adam',\n",
    "    \"train_grad_clip\":                1.0,\n",
    "    \"train_lr\":                       0.01,\n",
    "    \"train_min_lr\":                   0.0008,\n",
    "    \"train_lr_decay_factor\":          0.5,\n",
    "    \"train_decay_patience\":           25,\n",
    "    \"train_early_stopping_patience\":  50,\n",
    "    \"share_param\":                    False,\n",
    "    \"mix_cpu_gpu\":                    False,\n",
    "    \"minibatch_size\":                 40000,\n",
    "    \"num_workers_per_gpu\":            8,\n",
    "    \"device\":                         0,\n",
    "    \"save_dir\":                       './save/',\n",
    "    \"save_id\":                        1,\n",
    "    \"train_max_iter\":                 1000\n",
    "})\n",
    "\n",
    "np.random.seed(args.seed)\n",
    "th.manual_seed(args.seed)\n",
    "\n",
    "if th.cuda.is_available():\n",
    "    th.cuda.manual_seed_all(args.seed)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "5048ca0c-62d1-4352-b2b5-e3223404c308",
   "metadata": {},
   "outputs": [],
   "source": [
    "train_data='./data/amazon_trainset.csv'\n",
    "test_data='./data/amazon_testset.csv'\n",
    "movie_data = './data/amazon_movie_info.csv'\n",
    "user_data = './data/amazon_user_info.csv'\n",
    "\n",
    "emotion=False\n",
    "sentiment=False\n",
    "\n",
    "name='rotten'\n",
    "device='cpu'\n",
    "mix_cpu_gpu=False\n",
    "use_one_hot_fea=False\n",
    "symm=True\n",
    "valid_ratio=0.1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "87f8e0f5-6b03-46df-ae96-a8825ae6f256",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "......1: 데이터 로드\n"
     ]
    }
   ],
   "source": [
    "print('......1: 데이터 로드')\n",
    "all_train_rating_info = pd.read_csv(train_data, encoding='utf-8')\n",
    "test_rating_info = pd.read_csv(test_data, encoding='utf-8')\n",
    "\n",
    "#######\n",
    "all_train_rating_info['sentiment'] = all_train_rating_info['sentiment'] + 11 #rating 과 구분하기위해 11 더해줌 : 11 - 15\n",
    "test_rating_info['sentiment'] = test_rating_info['sentiment'] + 11 #rating 과 구분하기위해 11 더해줌 : 11 - 15\n",
    "\n",
    "all_train_rating_info['emotion'] = all_train_rating_info['emotion'] + 16 # 16~21\n",
    "test_rating_info['emotion'] = test_rating_info['emotion'] + 16 # 16~21\n",
    "\n",
    "all_rating_info = pd.concat([all_train_rating_info, test_rating_info], ignore_index=True)\n",
    "\n",
    "user_info = pd.read_csv(user_data, encoding='utf-8')\n",
    "movie_info = pd.read_csv(movie_data, encoding='utf-8')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "7e8e77cf-c275-4ffa-846a-049c7f61d30d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "......4: User/Movie를 Global id에 매핑\n",
      "Total user number = 3659, movie number = 33898\n"
     ]
    }
   ],
   "source": [
    "print('......4: User/Movie를 Global id에 매핑')\n",
    "# Map user/movie to the global id\n",
    "global_user_id_map = {ele: i for i, ele in enumerate(user_info['user_id'])}\n",
    "global_movie_id_map = {ele: i for i, ele in enumerate(movie_info['movie_id'])}\n",
    "print('Total user number = {}, movie number = {}'.format(len(global_user_id_map),\n",
    "                                                         len(global_movie_id_map)))\n",
    "_num_user = len(global_user_id_map)\n",
    "_num_movie = len(global_movie_id_map)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "99215101-9d7f-4074-95ea-62fbbc9f336b",
   "metadata": {},
   "outputs": [],
   "source": [
    "rating_info = all_train_rating_info"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "17c14381-e6d8-4991-9716-1347d6ef684a",
   "metadata": {},
   "outputs": [
    {
     "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>user_id</th>\n",
       "      <th>movie_id</th>\n",
       "      <th>review</th>\n",
       "      <th>rating</th>\n",
       "      <th>review_date</th>\n",
       "      <th>review_all</th>\n",
       "      <th>helpful</th>\n",
       "      <th>sentiment</th>\n",
       "      <th>emotion</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>104555</td>\n",
       "      <td>30037</td>\n",
       "      <td>They did it again!</td>\n",
       "      <td>5.0</td>\n",
       "      <td>08 12, 2013</td>\n",
       "      <td>That '70s Show hit a few bumps with this seaso...</td>\n",
       "      <td>[0, 0]</td>\n",
       "      <td>13</td>\n",
       "      <td>16</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>80035</td>\n",
       "      <td>13314</td>\n",
       "      <td>Nice Touchy-Feely Flick</td>\n",
       "      <td>4.0</td>\n",
       "      <td>08 12, 2013</td>\n",
       "      <td>It is 1987.  Jack Campbell (Nicholas Cage)is a...</td>\n",
       "      <td>[1, 1]</td>\n",
       "      <td>14</td>\n",
       "      <td>18</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>73255</td>\n",
       "      <td>47748</td>\n",
       "      <td>\"Advertising and Morality\"</td>\n",
       "      <td>4.0</td>\n",
       "      <td>08 12, 2013</td>\n",
       "      <td>This subtitled film gives a very good feel for...</td>\n",
       "      <td>[0, 1]</td>\n",
       "      <td>13</td>\n",
       "      <td>18</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>65251</td>\n",
       "      <td>3302</td>\n",
       "      <td>One of Monroe's best</td>\n",
       "      <td>5.0</td>\n",
       "      <td>08 12, 2013</td>\n",
       "      <td>I always thought Marilyn Monroe was a very und...</td>\n",
       "      <td>[2, 2]</td>\n",
       "      <td>15</td>\n",
       "      <td>18</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>39753</td>\n",
       "      <td>40862</td>\n",
       "      <td>A Bleak And Effective Look At Life Within A Ju...</td>\n",
       "      <td>4.0</td>\n",
       "      <td>08 12, 2013</td>\n",
       "      <td>Through the years, there have been countless p...</td>\n",
       "      <td>[0, 0]</td>\n",
       "      <td>13</td>\n",
       "      <td>18</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   user_id  movie_id                                             review  \\\n",
       "0   104555     30037                                 They did it again!   \n",
       "1    80035     13314                            Nice Touchy-Feely Flick   \n",
       "2    73255     47748                         \"Advertising and Morality\"   \n",
       "3    65251      3302                               One of Monroe's best   \n",
       "4    39753     40862  A Bleak And Effective Look At Life Within A Ju...   \n",
       "\n",
       "   rating  review_date                                         review_all  \\\n",
       "0     5.0  08 12, 2013  That '70s Show hit a few bumps with this seaso...   \n",
       "1     4.0  08 12, 2013  It is 1987.  Jack Campbell (Nicholas Cage)is a...   \n",
       "2     4.0  08 12, 2013  This subtitled film gives a very good feel for...   \n",
       "3     5.0  08 12, 2013  I always thought Marilyn Monroe was a very und...   \n",
       "4     4.0  08 12, 2013  Through the years, there have been countless p...   \n",
       "\n",
       "  helpful  sentiment  emotion  \n",
       "0  [0, 0]         13       16  \n",
       "1  [1, 1]         14       18  \n",
       "2  [0, 1]         13       18  \n",
       "3  [2, 2]         15       18  \n",
       "4  [0, 0]         13       18  "
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rating_info.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "e2befb7b-5619-4f5e-833f-c274f3aed473",
   "metadata": {},
   "outputs": [],
   "source": [
    "rating_pairs = (np.array([global_user_id_map[ele] for ele in rating_info[\"user_id\"]],\n",
    "                         dtype=np.int64),\n",
    "                np.array([global_movie_id_map[ele] for ele in rating_info[\"movie_id\"]],\n",
    "                         dtype=np.int64))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "0fc81e93-e5cd-49dd-a919-170ece2d3977",
   "metadata": {},
   "outputs": [],
   "source": [
    "rating_values = rating_info[\"rating\"].values.astype(np.float32)\n",
    "sentiment_values = rating_info[\"sentiment\"].values.astype(np.int16) \n",
    "emotion_values = rating_info[\"emotion\"].values.astype(np.int16)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7802e977-026f-44ca-88d5-dd56c5ff53b5",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "49d87f20-244c-4168-b862-107edd25f64b",
   "metadata": {},
   "outputs": [],
   "source": [
    "#movie data processing\n",
    "movie_df = pd.read_csv(movie_data, encoding='utf-8')\n",
    "movie_df.reset_index(inplace=True)\n",
    "movie_df.rename(columns = {\"index\": \"movie_id\"}, inplace=True)\n",
    "\n",
    "movie_df = movie_df[['movie_id','movie_title','original_release_date', 'genres']]\n",
    "movie_df['original_release_date']= pd.to_datetime(movie_df['original_release_date']) \n",
    "movie_df['year'] = movie_df['original_release_date'].dt.strftime('%Y')\n",
    "mean_val = pd.to_numeric(movie_df['year']).mean()\n",
    "\n",
    "movie_df = movie_df.fillna({'original_release_date':movie_df.original_release_date.mean()})\n",
    "movie_df = movie_df.fillna({'year':mean_val})\n",
    "movie_df = movie_df.fillna({'genres' : 'unknown'})\n",
    "\n",
    "self.movie_info = movie_df\n",
    "self.movie_genre_dummies = movie_df['genres'].str.get_dummies(sep=',')\n",
    "self.movie_info = pd.concat([movie_df, self.movie_genre_dummies], axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6a9bc4c5-375a-4a65-84fb-1c9d2ce97aac",
   "metadata": {},
   "outputs": [],
   "source": [
    "print('......3: Train/Valid 분리')       \n",
    "num_valid = int(np.ceil(self.all_train_rating_info.shape[0] * valid_ratio))\n",
    "shuffled_idx = np.random.permutation(self.all_train_rating_info.shape[0])\n",
    "self.train_idx = shuffled_idx[num_valid: ]\n",
    "self.valid_idx = shuffled_idx[ :num_valid]\n",
    "self.train_rating_info = self.all_train_rating_info.iloc[self.train_idx]\n",
    "self.valid_rating_info = self.all_train_rating_info.iloc[self.valid_idx]\n",
    "\n",
    "\n",
    "print(\"All rating pairs : {}\".format(self.all_rating_info.shape[0]))\n",
    "print(\"\\tAll train rating pairs : {}\".format(self.all_train_rating_info.shape[0]))\n",
    "print(\"\\t\\tTrain rating pairs : {}\".format(self.train_rating_info.shape[0]))\n",
    "print(\"\\t\\tValid rating pairs : {}\".format(self.valid_rating_info.shape[0]))\n",
    "print(\"\\tTest rating pairs  : {}\".format(self.test_rating_info.shape[0]))\n",
    "\n",
    "\n",
    "print('......4: User/Movie를 Global id에 매핑')\n",
    "# Map user/movie to the global id\n",
    "self.global_user_id_map = {ele: i for i, ele in enumerate(self.user_info['user_id'])}\n",
    "self.global_movie_id_map = {ele: i for i, ele in enumerate(self.movie_info['movie_id'])}\n",
    "print('Total user number = {}, movie number = {}'.format(len(self.global_user_id_map),\n",
    "                                                         len(self.global_movie_id_map)))\n",
    "self._num_user = len(self.global_user_id_map)\n",
    "self._num_movie = len(self.global_movie_id_map)\n",
    "\n",
    "\n",
    "print('......5: features 생성')\n",
    "### Generate features\n",
    "\n",
    "self.user_feature = None\n",
    "self.movie_feature = None\n",
    "\n",
    "# load feature\n",
    "if use_one_hot_fea == False:\n",
    "    self.user_feature = th.FloatTensor(self._process_user_fea())\n",
    "    self.movie_feature = th.FloatTensor(self._process_movie_fea())\n",
    "\n",
    "    # if mix_cpu_gpu, we put features in CPU\n",
    "    if mix_cpu_gpu == False:\n",
    "        self.user_feature = self.user_feature.to(self._device)\n",
    "        self.movie_feature = self.movie_feature.to(self._device)\n",
    "\n",
    "if self.user_feature is None:\n",
    "    self.user_feature_shape = (self.num_user, self.num_user)\n",
    "    self.movie_feature_shape = (self.num_movie, self.num_movie)\n",
    "else:\n",
    "    self.user_feature_shape = self.user_feature.shape\n",
    "    self.movie_feature_shape = self.movie_feature.shape\n",
    "\n",
    "info_line = \"Feature dim: \"\n",
    "info_line += \"\\nuser: {}\".format(self.user_feature_shape)\n",
    "info_line += \"\\nmovie: {}\".format(self.movie_feature_shape)\n",
    "print(info_line)\n",
    "\n",
    "\n",
    "print('......6: Graph Encoder/Decoder 생성')\n",
    "\n",
    "self.emotion_rating_values = list(set(self.all_rating_info[\"emotion\"].values))\n",
    "self.sentiment_rating_values = list(set(self.all_rating_info[\"sentiment\"].values))\n",
    "self.possible_rating_values = list(set(self.all_rating_info[\"rating\"].values))\n",
    "\n",
    "\n",
    "self.rating_values = self.possible_rating_values \n",
    "if self.sentiment == True:\n",
    "    self.rating_values += self.sentiment_rating_values\n",
    "if self.emotion == True:\n",
    "    self.rating_values += self.emotion_rating_values\n",
    "\n",
    "print(\"rating_values : \", self.rating_values)\n",
    "all_rating_pairs, all_rating_values, all_sentiment_values, all_emotion_values = self._generate_pair_value(self.all_rating_info)\n",
    "all_train_rating_pairs, all_train_rating_values, all_train_sentiment_values, all_train_emotion_values = self._generate_pair_value(self.all_train_rating_info)\n",
    "train_rating_pairs, train_rating_values, train_sentiment_values, train_emotion_values = self._generate_pair_value(self.train_rating_info)\n",
    "valid_rating_pairs, valid_rating_values, valid_sentiment_values, valid_emotion_values = self._generate_pair_value(self.valid_rating_info)\n",
    "test_rating_pairs, test_rating_values, test_sentiment_values, test_emotion_values = self._generate_pair_value(self.test_rating_info)\n",
    "\n",
    "# self.train_s_graph, self.train_e_graph = self._generate_sub_graph(train_rating_pairs, train_sentiment_values, train_emotion_values)\n",
    "self.train_rating_pairs = train_rating_pairs\n",
    "self.train_enc_graph = self._generate_enc_graph(train_rating_pairs, train_rating_values, train_sentiment_values, train_emotion_values, add_support=True)\n",
    "self.train_dec_graph = self._generate_dec_graph(train_rating_pairs)\n",
    "self.train_labels = self._make_labels(train_rating_values)\n",
    "self.train_truths = th.FloatTensor(train_rating_values).to(device)\n",
    "\n",
    "# self.valid_s_graph, self.valid_e_graph = self.train_s_graph, self.train_e_graph\n",
    "self.valid_enc_graph = self._generate_enc_graph(all_train_rating_pairs, train_rating_values, train_sentiment_values, train_emotion_values, add_support=True)\n",
    "self.valid_dec_graph = self._generate_dec_graph(valid_rating_pairs)\n",
    "self.valid_labels = self._make_labels(valid_rating_values)\n",
    "self.valid_truths = th.FloatTensor(valid_rating_values).to(device)\n",
    "\n",
    "\n",
    "test_pairs =(np.concatenate((train_rating_pairs[0], test_rating_pairs[0]), axis=0), np.concatenate((train_rating_pairs[1], test_rating_pairs[1]), axis=0))\n",
    "self.test_enc_graph = self._generate_enc_graph(test_pairs, train_rating_values, train_sentiment_values, train_emotion_values, add_support=True)\n",
    "self.test_dec_graph = self._generate_dec_graph(test_rating_pairs)\n",
    "self.test_labels = self._make_labels(test_rating_values)\n",
    "self.test_truths = th.FloatTensor(test_rating_values).to(device)\n",
    "\n",
    "\n",
    "print('......7: Graph 결과 출력')\n",
    "print(\"Train enc graph: \\t#user:{}\\t#movie:{}\\t#pairs:{}\".format(\n",
    "    self.train_enc_graph.number_of_nodes('user'), self.train_enc_graph.number_of_nodes('movie'),\n",
    "    self._npairs(self.train_enc_graph)))\n",
    "print(\"Train dec graph: \\t#user:{}\\t#movie:{}\\t#pairs:{}\".format(\n",
    "    self.train_dec_graph.number_of_nodes('user'), self.train_dec_graph.number_of_nodes('movie'),\n",
    "    self.train_dec_graph.number_of_edges()))\n",
    "print(\"Valid enc graph: \\t#user:{}\\t#movie:{}\\t#pairs:{}\".format(\n",
    "    self.valid_enc_graph.number_of_nodes('user'), self.valid_enc_graph.number_of_nodes('movie'),\n",
    "    self._npairs(self.valid_enc_graph)))\n",
    "print(\"Valid dec graph: \\t#user:{}\\t#movie:{}\\t#pairs:{}\".format(\n",
    "    self.valid_dec_graph.number_of_nodes('user'), self.valid_dec_graph.number_of_nodes('movie'),\n",
    "    self.valid_dec_graph.number_of_edges()))\n",
    "print(\"Test enc graph: \\t#user:{}\\t#movie:{}\\t#pairs:{}\".format(\n",
    "    self.test_enc_graph.number_of_nodes('user'), self.test_enc_graph.number_of_nodes('movie'),\n",
    "    self._npairs(self.test_enc_graph)))\n",
    "print(\"Test dec graph: \\t#user:{}\\t#movie:{}\\t#pairs:{}\".format(\n",
    "    self.test_dec_graph.number_of_nodes('user'), self.test_dec_graph.number_of_nodes('movie'),\n",
    "    self.test_dec_graph.number_of_edges()))\n",
    "\n",
    "\n",
    "\n",
    "def _make_labels(self, ratings):\n",
    "labels = th.LongTensor(np.searchsorted([i*0.5 for i in range(1,11)], ratings)).to(self._device)\n",
    "return labels\n",
    "\n",
    "def _npairs(self, graph):\n",
    "rst = 0\n",
    "for r in self.possible_rating_values:\n",
    "    r = to_etype_name(r)\n",
    "    rst += graph.number_of_edges(str(r))\n",
    "return rst\n",
    "\n",
    "def _generate_pair_value(self, rating_info):\n",
    "rating_pairs = (np.array([self.global_user_id_map[ele] for ele in rating_info[\"user_id\"]],\n",
    "                         dtype=np.int64),\n",
    "                np.array([self.global_movie_id_map[ele] for ele in rating_info[\"movie_id\"]],\n",
    "                         dtype=np.int64))\n",
    "rating_values = rating_info[\"rating\"].values.astype(np.float32)\n",
    "sentiment_values = rating_info[\"sentiment\"].values.astype(np.int16) \n",
    "emotion_values = rating_info[\"emotion\"].values.astype(np.int16)\n",
    "return rating_pairs, rating_values, sentiment_values, emotion_values\n",
    "\n",
    "def _generate_enc_graph(self, rating_pairs, rating_values, sentiment_values, emotion_values, add_support=False):\n",
    "\n",
    "data_dict = dict()\n",
    "num_nodes_dict = {'user': self._num_user, 'movie': self._num_movie}\n",
    "rating_row, rating_col = rating_pairs\n",
    "\n",
    "for rating in self.possible_rating_values:\n",
    "    ridx = np.where(rating_values == rating)\n",
    "    rrow = rating_row[ridx]\n",
    "    rcol = rating_col[ridx]\n",
    "    rating = to_etype_name(rating)\n",
    "    data_dict.update({\n",
    "        ('user', str(rating), 'movie'): (rrow, rcol),\n",
    "        ('movie', 'rev-%s' % str(rating), 'user'): (rcol, rrow)\n",
    "    })\n",
    "\n",
    "if self.sentiment == True: \n",
    "    for rating in self.sentiment_rating_values:\n",
    "        ridx = np.where(sentiment_values == rating)\n",
    "        rrow = rating_row[ridx]\n",
    "        rcol = rating_col[ridx]\n",
    "        rating = to_etype_name(rating)\n",
    "        data_dict.update({\n",
    "            ('user', str(rating), 'movie'): (rrow, rcol),\n",
    "            ('movie', 'rev-%s' % str(rating), 'user'): (rcol, rrow)\n",
    "        })\n",
    "\n",
    "if self.emotion == True:\n",
    "    for rating in self.emotion_rating_values:\n",
    "        ridx = np.where(emotion_values == rating)\n",
    "        rrow = rating_row[ridx]\n",
    "        rcol = rating_col[ridx]\n",
    "        rating = to_etype_name(rating)\n",
    "        data_dict.update({\n",
    "            ('user', str(rating), 'movie'): (rrow, rcol),\n",
    "            ('movie', 'rev-%s' % str(rating), 'user'): (rcol, rrow)\n",
    "        })\n",
    "\n",
    "graph = dgl.heterograph(data_dict, num_nodes_dict=num_nodes_dict)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "033ffc2a-361d-44e8-aadf-702c775fbc1b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# sanity check\n",
    "# assert len(rating_pairs[0]) == sum([graph.number_of_edges(et) for et in graph.etypes]) // 2\n",
    "\n",
    "if add_support:\n",
    "    def _calc_norm(x):\n",
    "        x = x.numpy().astype('float32')\n",
    "        x[x == 0.] = np.inf\n",
    "        x = th.FloatTensor(1. / np.sqrt(x))\n",
    "        return x.unsqueeze(1)\n",
    "    user_ci = []\n",
    "    user_cj = []\n",
    "    movie_ci = []\n",
    "    movie_cj = []\n",
    "    for r in self.possible_rating_values:\n",
    "        r = to_etype_name(r)\n",
    "        user_ci.append(graph['rev-%s' % r].in_degrees())\n",
    "        movie_ci.append(graph[r].in_degrees())\n",
    "        if self._symm:\n",
    "            user_cj.append(graph[r].out_degrees())\n",
    "            movie_cj.append(graph['rev-%s' % r].out_degrees())\n",
    "        else:\n",
    "            user_cj.append(th.zeros((self.num_user,)))\n",
    "            movie_cj.append(th.zeros((self.num_movie,)))\n",
    "    user_ci = _calc_norm(sum(user_ci))\n",
    "    movie_ci = _calc_norm(sum(movie_ci))\n",
    "    if self._symm:\n",
    "        user_cj = _calc_norm(sum(user_cj))\n",
    "        movie_cj = _calc_norm(sum(movie_cj))\n",
    "    else:\n",
    "        user_cj = th.ones(self.num_user,)\n",
    "        movie_cj = th.ones(self.num_movie,)\n",
    "    graph.nodes['user'].data.update({'ci' : user_ci, 'cj' : user_cj})\n",
    "    graph.nodes['movie'].data.update({'ci' : movie_ci, 'cj' : movie_cj})\n",
    "\n",
    "return graph\n",
    "\n",
    "def _generate_dec_graph(self, rating_pairs):\n",
    "ones = np.ones_like(rating_pairs[0])\n",
    "user_movie_ratings_coo = sp.coo_matrix(\n",
    "    (ones, rating_pairs),\n",
    "    shape=(self.num_user, self.num_movie), dtype=np.float32)\n",
    "g = dgl.bipartite_from_scipy(user_movie_ratings_coo, utype='_U', etype='_E', vtype='_V')\n",
    "return dgl.heterograph({('user', 'rate', 'movie'): g.edges()}, \n",
    "                       num_nodes_dict={'user': self.num_user, 'movie': self.num_movie})\n",
    "\n",
    "@property\n",
    "def num_links(self):\n",
    "return self.possible_rating_values.size\n",
    "\n",
    "@property\n",
    "def num_user(self):\n",
    "return self._num_user\n",
    "\n",
    "@property\n",
    "def num_movie(self):\n",
    "return self._num_movie\n",
    "\n",
    "def _process_user_fea(self):\n",
    "top_critic = (self.user_info['top_critic'] == False).values.astype(np.float32)\n",
    "all_publisher_name = set(self.user_info['publisher_name'])\n",
    "publisher_map = {ele: i for i, ele in enumerate(all_publisher_name)}\n",
    "publisher_one_hot = np.zeros(shape=(self.user_info.shape[0], len(all_publisher_name)),\n",
    "                          dtype=np.float32)\n",
    "publisher_one_hot[np.arange(self.user_info.shape[0]),\n",
    "               np.array([publisher_map[ele] for ele in self.user_info['publisher_name']])] = 1\n",
    "user_features = np.concatenate([top_critic.reshape((self.user_info.shape[0], 1)),\n",
    "                                publisher_one_hot], axis=1)\n",
    "\n",
    "return user_features\n",
    "\n",
    "\n",
    "def _process_movie_fea(self):\n",
    "import torchtext\n",
    "TEXT = torchtext.legacy.data.Field(tokenize='spacy', tokenizer_language='en_core_web_sm')\n",
    "embedding = torchtext.vocab.GloVe(name='840B', dim=300)\n",
    "\n",
    "title_embedding = np.zeros(shape=(self.movie_info.shape[0], 300), dtype=np.float32)\n",
    "release_years = np.zeros(shape=(self.movie_info.shape[0], 1), dtype=np.float32)\n",
    "\n",
    "for idx, row in self.movie_info.iterrows():\n",
    "    title_context = row['movie_title']\n",
    "    year = row['year']\n",
    "\n",
    "    # We use average of glove\n",
    "    title_embedding[idx, :] = embedding.get_vecs_by_tokens(TEXT.tokenize(title_context)).numpy().mean(axis=0)\n",
    "    release_years[idx] = float(year)   \n",
    "\n",
    "movie_features = np.concatenate((title_embedding,\n",
    "                         (release_years - 1950.0) / 100.0,\n",
    "                         self.movie_genre_dummies),axis=1) \n",
    "return movie_features\n",
    "\n",
    "\n",
    "def _generate_sub_graph(self, rating_pairs, sentiment_values, emotion_values):\n",
    "\n",
    "num_nodes_dict = {'user': self._num_user, 'movie': self._num_movie}\n",
    "rating_row, rating_col = rating_pairs\n",
    "\n",
    "data_dict = dict()\n",
    "for rating in self.sentiment_rating_values:\n",
    "    ridx = np.where(sentiment_values == rating)\n",
    "    rrow = rating_row[ridx]\n",
    "    rcol = rating_col[ridx]\n",
    "    rating = to_etype_name(rating)\n",
    "    data_dict.update({\n",
    "        ('user', str(rating), 'movie'): (rrow, rcol),\n",
    "        ('movie', 'rev-%s' % str(rating), 'user'): (rcol, rrow)\n",
    "    })\n",
    "\n",
    "s_graph = dgl.heterograph(data_dict, num_nodes_dict=num_nodes_dict)\n",
    "\n",
    "data_dict = dict()\n",
    "for rating in self.emotion_rating_values:\n",
    "    ridx = np.where(emotion_values == rating)\n",
    "    rrow = rating_row[ridx]\n",
    "    rcol = rating_col[ridx]\n",
    "    rating = to_etype_name(rating)\n",
    "    data_dict.update({\n",
    "        ('user', str(rating), 'movie'): (rrow, rcol),\n",
    "        ('movie', 'rev-%s' % str(rating), 'user'): (rcol, rrow)\n",
    "    })\n",
    "\n",
    "e_graph = dgl.heterograph(data_dict, num_nodes_dict=num_nodes_dict)\n",
    "\n",
    "return s_graph, e_graph"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c7eaa159-698b-4728-898e-4e839cfa2e2d",
   "metadata": {},
   "outputs": [],
   "source": [
    "if __name__ == '__main__':\n",
    "    RottenMovie(train_data='./data/trainset.csv',\n",
    "                test_data='./data/testset.csv',\n",
    "                feature_data='./'\n",
    "    )"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}