Task1-2-IUF-Test10.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Imports:\n",
    "\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "from math import log"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Declaration and initialization of a Pandas DataFrame to contain ratings provided by 200 existing \n",
    "# users (rows) for 1000 available movies (columns). \n",
    "\n",
    "user_movie_matrix = pd.DataFrame(index=range(1, 201), columns=range(1, 1001))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Populating the above Pandas DataFrame, a row at a time (ratings for movies watched by a user)\n",
    "# by parsing 'train.txt'.\n",
    "\n",
    "with open(\"../train.txt\", \"r\") as train_file_handle:\n",
    "    for row, user in enumerate(train_file_handle):\n",
    "        user_movie_matrix.loc[row+1] = user.split()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "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>1</th>\n",
       "      <th>2</th>\n",
       "      <th>3</th>\n",
       "      <th>4</th>\n",
       "      <th>5</th>\n",
       "      <th>6</th>\n",
       "      <th>7</th>\n",
       "      <th>8</th>\n",
       "      <th>9</th>\n",
       "      <th>10</th>\n",
       "      <th>...</th>\n",
       "      <th>991</th>\n",
       "      <th>992</th>\n",
       "      <th>993</th>\n",
       "      <th>994</th>\n",
       "      <th>995</th>\n",
       "      <th>996</th>\n",
       "      <th>997</th>\n",
       "      <th>998</th>\n",
       "      <th>999</th>\n",
       "      <th>1000</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>5</td>\n",
       "      <td>3</td>\n",
       "      <td>0</td>\n",
       "      <td>3</td>\n",
       "      <td>3</td>\n",
       "      <td>5</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>5</td>\n",
       "      <td>3</td>\n",
       "      <td>...</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>4</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>2</td>\n",
       "      <td>...</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>...</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>...</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>4</td>\n",
       "      <td>3</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>...</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>196</th>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>5</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>...</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>197</th>\n",
       "      <td>0</td>\n",
       "      <td>3</td>\n",
       "      <td>0</td>\n",
       "      <td>3</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>...</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>198</th>\n",
       "      <td>4</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>3</td>\n",
       "      <td>0</td>\n",
       "      <td>2</td>\n",
       "      <td>4</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>...</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>199</th>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>4</td>\n",
       "      <td>0</td>\n",
       "      <td>5</td>\n",
       "      <td>0</td>\n",
       "      <td>...</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>200</th>\n",
       "      <td>5</td>\n",
       "      <td>4</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>4</td>\n",
       "      <td>4</td>\n",
       "      <td>4</td>\n",
       "      <td>0</td>\n",
       "      <td>...</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>200 rows × 1000 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "    1    2    3    4    5    6    7    8    9    10    ... 991  992  993   \\\n",
       "1      5    3    0    3    3    5    0    1    5    3  ...    0    0    0   \n",
       "2      4    0    0    0    0    0    0    0    0    2  ...    0    0    0   \n",
       "3      0    0    0    0    0    0    0    0    0    0  ...    0    0    0   \n",
       "4      0    0    0    0    0    0    0    0    0    0  ...    0    0    0   \n",
       "5      4    3    0    0    0    0    0    0    0    0  ...    0    0    0   \n",
       "..   ...  ...  ...  ...  ...  ...  ...  ...  ...  ...  ...  ...  ...  ...   \n",
       "196    0    0    0    0    0    0    0    5    0    0  ...    0    0    0   \n",
       "197    0    3    0    3    0    0    0    0    0    0  ...    0    0    0   \n",
       "198    4    0    0    3    0    2    4    0    0    0  ...    0    0    0   \n",
       "199    1    0    0    0    0    0    4    0    5    0  ...    0    0    0   \n",
       "200    5    4    0    0    0    0    4    4    4    0  ...    0    0    0   \n",
       "\n",
       "    994  995  996  997  998  999  1000  \n",
       "1      0    0    0    0    0    0    0  \n",
       "2      0    0    0    0    0    0    0  \n",
       "3      0    0    0    0    0    0    0  \n",
       "4      0    0    0    0    0    0    0  \n",
       "5      0    0    0    0    0    0    0  \n",
       "..   ...  ...  ...  ...  ...  ...  ...  \n",
       "196    0    0    0    0    0    0    0  \n",
       "197    0    0    0    0    0    0    0  \n",
       "198    0    0    0    0    0    0    0  \n",
       "199    0    0    0    0    0    0    0  \n",
       "200    0    0    0    0    0    0    0  \n",
       "\n",
       "[200 rows x 1000 columns]"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Displaying the Pandas DataFrame as assigned above.\n",
    "\n",
    "user_movie_matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Conversion of 'user_movie_matrix' from a Pandas DataFrame to a Numpy Array.\n",
    "\n",
    "user_movie_matrix = user_movie_matrix.to_numpy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Changing the data type of each element in the above Numpy Array, from a string to an integer.\n",
    "\n",
    "user_movie_matrix = user_movie_matrix.astype(\"uint8\", copy=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[5, 3, 0, ..., 0, 0, 0],\n",
       "       [4, 0, 0, ..., 0, 0, 0],\n",
       "       [0, 0, 0, ..., 0, 0, 0],\n",
       "       ...,\n",
       "       [4, 0, 0, ..., 0, 0, 0],\n",
       "       [1, 0, 0, ..., 0, 0, 0],\n",
       "       [5, 4, 0, ..., 0, 0, 0]], dtype=uint8)"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Displaying the final version of user_movie_matrix as a Numpy Array.\n",
    "\n",
    "user_movie_matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Declaration and initialization of a Numpy Array to hold the averages of (observed) ratings of \n",
    "# existing users.\n",
    "\n",
    "train_average_ratings = np.zeros(shape=(200,))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Populating the above Numpy Array:\n",
    "\n",
    "for train_count, train_user in enumerate(user_movie_matrix):\n",
    "    nonzero_rating_indices = np.nonzero(train_user)\n",
    "    train_average_ratings[train_count] = np.mean(train_user[nonzero_rating_indices])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Declaration and initialization of a Numpy Array to hold inverse (existing) user frequency values for \n",
    "# each movie.\n",
    "\n",
    "inverse_user_frequency = np.zeros(shape=(1000,))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Populating the above Numpy Array:\n",
    "\n",
    "for movie_count, movie in enumerate(user_movie_matrix.T):\n",
    "    nonzero_rating_indices = np.nonzero(movie)\n",
    "    inverse_user_frequency[movie_count] = log(200/len(nonzero_rating_indices))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Declaration and initialization of a Numpy Array to contain ratings on movies by existing users, as a \n",
    "# product of the original ratings and inverse (existing) user frequencies.\n",
    "\n",
    "weighted_user_movie_matrix = np.zeros(shape=(200, 1000))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Populating the above Numpy Array:\n",
    "\n",
    "for movie_count in range(1000):\n",
    "    weighted_user_movie_matrix[:, movie_count] = user_movie_matrix[:, movie_count] * inverse_user_frequency[movie_count]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Declaration and initialization of a Numpy Array to hold the averages of weighted (observed) ratings \n",
    "# of existing users.\n",
    "\n",
    "weighted_train_average_ratings = np.zeros(shape=(200,))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Populating the above Numpy Array:\n",
    "\n",
    "for train_count, train_user in enumerate(weighted_user_movie_matrix):\n",
    "    nonzero_rating_indices = np.nonzero(train_user)\n",
    "    weighted_train_average_ratings[train_count] = np.mean(train_user[nonzero_rating_indices])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Declaration and initialization of a list to contain movies which have not been rated by any existing \n",
    "# user:\n",
    "\n",
    "train_unrated_movies = []\n",
    "\n",
    "for train_count, movie in enumerate(user_movie_matrix.T):\n",
    "    if not any(movie):\n",
    "        train_unrated_movies.append(train_count)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Declaration and initialization of two dictionaries corresponding to 'test5.txt':\n",
    "\n",
    "# one to contain ratings for movies watched by each active user,\n",
    "\n",
    "test5_observed_ratings = {}\n",
    "\n",
    "# and the other, to contain target movie(s) for which rating prediction(s) is/are to be made, \n",
    "# respective to each active user.\n",
    "\n",
    "test5_required_predictions = {}\n",
    "\n",
    "for test5_count in range(100):\n",
    "    test5_observed_ratings[test5_count] = []\n",
    "    test5_required_predictions[test5_count] = []"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Parsing 'test10.txt' for subsequent assignments of the above dictionaries.\n",
    "\n",
    "with open(\"../test10.txt\", \"r\") as test5_file_handle:\n",
    "    for line in test5_file_handle:\n",
    "        user_movie_rating = [int(value) for value in line.split()]\n",
    "        if user_movie_rating[2] != 0:\n",
    "            test5_observed_ratings[user_movie_rating[0]-301].append((user_movie_rating[1]-1, \n",
    "                                                                     user_movie_rating[2]))\n",
    "        else:\n",
    "            test5_required_predictions[user_movie_rating[0]-301].append(user_movie_rating[1]-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Declaration and initialization of a Numpy Array to hold the averages of (observed) ratings of \n",
    "# active users.\n",
    "\n",
    "test5_average_ratings = np.zeros(shape=(100,))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Populating the above Numpy Array:\n",
    "\n",
    "for test5_count, test5_user in enumerate(test5_observed_ratings.values()):\n",
    "    test5_user_ratings = []\n",
    "    for movie, rating in test5_user:\n",
    "        test5_user_ratings.append(rating)\n",
    "    test5_average_ratings[test5_count] = np.mean(np.array(test5_user_ratings))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Declaration and initialization of a dictionary to contain weighted ratings for movies watched by \n",
    "# each active user.\n",
    "\n",
    "weighted_test5_observed_ratings = {}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Populating the above dictionary:\n",
    "\n",
    "for test5_count, test5_user in enumerate(test5_observed_ratings.values()):\n",
    "    movies_and_weighted_ratings = []\n",
    "    for movie, rating in test5_user:\n",
    "        movies_and_weighted_ratings.append((movie, rating * inverse_user_frequency[movie]))\n",
    "    weighted_test5_observed_ratings[test5_count] = movies_and_weighted_ratings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Declaration and initialization of a Numpy Array to hold the we-ghtedaverages of (observed) ratings \n",
    "# of active users.\n",
    "\n",
    "weighted_test5_average_ratings = np.zeros(shape=(100,))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Populating the above Numpy Array:\n",
    "\n",
    "for test5_count, test5_user in enumerate(weighted_test5_observed_ratings.values()):\n",
    "    test5_user_ratings = []\n",
    "    for movie, rating in test5_user:\n",
    "        test5_user_ratings.append(rating)\n",
    "    weighted_test5_average_ratings[test5_count] = np.mean(np.array(test5_user_ratings))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Declaration and initialization of a list to contain active users who have rated each movie with the\n",
    "# same value.\n",
    "\n",
    "test5_users_with_same_ratings = []"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Populating the above list:\n",
    "\n",
    "for test5_count in range(100):\n",
    "    observed_movies_ratings = test5_observed_ratings[test5_count]\n",
    "    different_ratings = []\n",
    "    for movie, rating in observed_movies_ratings:\n",
    "        if rating not in different_ratings:\n",
    "            different_ratings.append(rating)\n",
    "    if len(different_ratings) == 1:\n",
    "        test5_users_with_same_ratings.append(test5_count)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Defining a function to compute the similarity between two arbitrary users (represented as vectors),\n",
    "# based on their movie ratings. \n",
    "\n",
    "def cosine_similarity(vector_1, vector_2):\n",
    "    return np.dot(vector_1, vector_2)/(np.linalg.norm(vector_1)*np.linalg.norm(vector_2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Initialization of a file handler to operate on a text file in which to store results (i.e., predicted\n",
    "# ratings for target movie(s) corresponding to each active user).\n",
    "\n",
    "result5_file_handle = open(\"Task1-2-IUF-Test10Result.txt\", \"a\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# COLLABORATIVE FILTERING ALGORITHM: ~V2~\n",
    "\n",
    "# Iteration through each active user:\n",
    "for test5_count in range(100):\n",
    "    available_ratings = weighted_test5_observed_ratings[test5_count]\n",
    "    target_movies = test5_required_predictions[test5_count]\n",
    "    # Iteration through each target movie:\n",
    "    for movie in target_movies:\n",
    "        # If the target movie has not been rated by any existing user, its rating by the \n",
    "        # corresponding active user is approximated to be equal to the average value in the rating\n",
    "        # scale (in this particular model, the average rating equates to 3, for a rating scale from\n",
    "        # 1 to 5, with unit increments).\n",
    "        if movie in train_unrated_movies:\n",
    "            result5_file_handle.write(f\"{test5_count + 301} {movie + 1} 3\\n\")\n",
    "        # The following code block gets executed if the target movie has been rated by at least one\n",
    "        # existing user.\n",
    "        else:\n",
    "            # Declaring and initializing a Numpy Array to store similarity values between an arbitrary \n",
    "            # active user and existing users, corresponding to a target movie:\n",
    "            test5_similarity = np.zeros(shape=(200,))\n",
    "            # Iteration through each existing user:\n",
    "            for train_count in range(200):\n",
    "                # The arbitrary existing user is only to be considered further, if said user has rated \n",
    "                # the target movie under consideration:\n",
    "                if user_movie_matrix[train_count][movie] != 0:\n",
    "                    # Declaration and initialization of two lists (required to have the same length):\n",
    "                    # one, to hold ratings by an arbitrary active user,\n",
    "                    common_dimensions_test5 = []\n",
    "                    # and the other, to hold ratings by an arbitrary existing user,\n",
    "                    common_dimensions_train = []\n",
    "                    # corresponding to movies watched by the arbitrary active user.\n",
    "                    # Iteration through movies watched by an arbitrary active user, to populate\n",
    "                    # above lists.\n",
    "                    for count, observed_movie in enumerate(available_ratings):\n",
    "                        # Population of the above lists can only proceed, if an arbitrary existing user\n",
    "                        # has rated the movie which has been rated by the arbitrary active user:\n",
    "                        if user_movie_matrix[train_count][observed_movie[0]] != 0:\n",
    "                            if test5_count not in test5_users_with_same_ratings:\n",
    "                                common_dimensions_test5.append(observed_movie[1] - weighted_test5_average_ratings[test5_count])\n",
    "                                common_dimensions_train.append(weighted_user_movie_matrix[train_count][observed_movie[0]] - weighted_train_average_ratings[train_count])\n",
    "                            else:\n",
    "                                common_dimensions_test5.append(test5_observed_ratings[test5_count][count][1])\n",
    "                                common_dimensions_train.append(user_movie_matrix[train_count][observed_movie[0]])\n",
    "                    # Calculation of the similarity between an arbitrary active user and an arbitrary\n",
    "                    # existing user can only proceed, if there exist two or more movies for which \n",
    "                    # ratings are available across both users (otherwise, Cosine Similarity, and \n",
    "                    # Pearson Corelation cannot accurately account for the actual similarity between \n",
    "                    # both users):\n",
    "                    if len(common_dimensions_train) > 1:\n",
    "                        # The condition statements below account for the Pearson Corelation algorithm.\n",
    "                        # The following code block gets executed, if an arbitrary active user has \n",
    "                        # provided varying ratings (corresponding to rated movies):\n",
    "                        if test5_count not in test5_users_with_same_ratings:\n",
    "                            # The following code block gets executed, if an arbitrary active user and \n",
    "                            # an arbitrary existing user have provided varying ratings (corresponding \n",
    "                            # to rated movies):\n",
    "                            if any(common_dimensions_test5) and any(common_dimensions_train):\n",
    "                                # Calculation of the similarity between an arbitrary active user and \n",
    "                                # an arbitrary existing user utilizes Pearson Corelation as the metric:\n",
    "                                test5_similarity[train_count] = cosine_similarity(np.array(common_dimensions_test5), np.array(common_dimensions_train))\n",
    "                        # The following code block gets executed, if as arbitrary active user has \n",
    "                        # provided same ratings (corresponding to rated movies):\n",
    "                        else:\n",
    "                            # Calculation of the similarity between an arbitrary active user and an \n",
    "                            # arbitrary existing user utilizes Cosine Similarity as the metric (since \n",
    "                            # common_dimensions_test5 consists entirely of zeros):\n",
    "                            test5_similarity[train_count] = cosine_similarity(np.array(common_dimensions_test5), np.array(common_dimensions_train))\n",
    "            # Each value in the above Numpy Array is directly proportional to the similarity between an \n",
    "            # arbitrary active user and the corresponding existing user.\n",
    "            # If there exists at least one non-zero similarity value, we proceed to determine existing \n",
    "            # users who closely resemble an arbitrary active user, with regards to the ratings of \n",
    "            # observed movies.\n",
    "            if any(test5_similarity):\n",
    "                # Sorting the above Numpy Array in a decreasing order to arrive at five existing users \n",
    "                # (neighbors) who closely resemble an arbitrary active user, with regards to the ratings \n",
    "                # of observed movies:\n",
    "                test5_top5_neighbors = np.argpartition(np.absolute(test5_similarity), -100)[-100:]\n",
    "                # Prediction of the rating for a target movie corresponding to an arbitrary active user \n",
    "                # is computed as a weighted average of the ratings of the neighbours.\n",
    "                # The numerator represents the sum of products of weight ,i.e., the similarity value \n",
    "                # (between an arbitrary active user and a neighbor), and rating, of the neighbor \n",
    "                # corresponding to an arbitrary active user's target movie:\n",
    "                numerator = 0\n",
    "                # The denominator represents the sum of similarity value(s) between each neighbor and  \n",
    "                # an arbitrary active user, corresponding to the target movie:\n",
    "                denominator = 0\n",
    "                # The following code block calculates predicted rating (in accordance to the Pearson \n",
    "                # Corelation algorithm), only if an arbitrary active user has provided varying ratings \n",
    "                # (corresponding to rated movies):\n",
    "                if test5_count not in test5_users_with_same_ratings:\n",
    "                    # Iteration through each neighbor:\n",
    "                    for top5 in test5_top5_neighbors:\n",
    "                        numerator += test5_similarity[top5] * (user_movie_matrix[top5][movie] - train_average_ratings[top5])\n",
    "                        denominator += abs(test5_similarity[top5])\n",
    "                    predicted_rating = test5_average_ratings[test5_count] + (numerator/denominator)\n",
    "                    if round(predicted_rating) not in range(1,6):\n",
    "                        if predicted_rating < 1:\n",
    "                            predicted_rating = 1\n",
    "                        else:\n",
    "                            predicted_rating = 5\n",
    "                # The following code block calculates predicted rating (in accordance to the Cosine \n",
    "                # Similarity algorithm), only if an arbitrary active user has provided same ratings \n",
    "                # (corresponding to rated movies):\n",
    "                else:\n",
    "                    # Iteration through each neighbor:\n",
    "                    for top5 in test5_top5_neighbors:\n",
    "                        numerator += test5_similarity[top5] * user_movie_matrix[top5][movie]\n",
    "                        denominator += test5_similarity[top5]\n",
    "                    predicted_rating = numerator/denominator\n",
    "                result5_file_handle.write(f\"{test5_count + 301} {movie + 1} {str(round(predicted_rating))[0]}\\n\")\n",
    "            # The following code block gets executed if similarity values between an arbitrary active \n",
    "            # user and all existing users are all equal to zero; thus implying the absence of \n",
    "            # neighbors corresponding to the arbitrary active user.\n",
    "            else:\n",
    "                # Declaration and initialization of a list to hold ratings for the target movie \n",
    "                # (corresponding to an arbitrary active user) provided by existing users:\n",
    "                nonzero_ratings = []\n",
    "                # Iteration through each existing user to obtain the corresponding rating for the \n",
    "                # target movie, only if it has been watched by said existing user:\n",
    "                for train_movie_rating in user_movie_matrix[:, movie]:\n",
    "                    if train_movie_rating != 0:\n",
    "                        nonzero_ratings.append(train_movie_rating)\n",
    "                # The predicted rating for the target movie corresponding to an arbitrary user is \n",
    "                # approximated to be equal to be mean of ratings contained in the above list.\n",
    "                result5_file_handle.write(f\"{test5_count + 301} {movie + 1} {str(round(np.mean(np.array(nonzero_ratings))))[0]}\\n\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Closing the text file after having written all outputs:\n",
    "\n",
    "result5_file_handle.close()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "hubpy3.7-tf2.3",
   "language": "python",
   "name": "hubpy3.7-tf2.3"
  },
  "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.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}