examples/RNMFk/RNMFk.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "os.environ[\"OMP_NUM_THREADS\"] = \"1\" # export OMP_NUM_THREADS=1\n",
    "os.environ[\"OPENBLAS_NUM_THREADS\"] = \"1\" # export OPENBLAS_NUM_THREADS=1\n",
    "os.environ[\"MKL_NUM_THREADS\"] = \"1\" # export MKL_NUM_THREADS=1\n",
    "os.environ[\"VECLIB_MAXIMUM_THREADS\"] = \"1\" # export VECLIB_MAXIMUM_THREADS=1\n",
    "os.environ[\"NUMEXPR_NUM_THREADS\"] = \"1\" # export NUMEXPR_NUM_THREADS=1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Load Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['ml-latest-small/',\n",
       " 'ml-latest-small/links.csv',\n",
       " 'ml-latest-small/tags.csv',\n",
       " 'ml-latest-small/ratings.csv',\n",
       " 'ml-latest-small/README.txt',\n",
       " 'ml-latest-small/movies.csv']"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from io import BytesIO\n",
    "from zipfile import ZipFile\n",
    "from urllib.request import urlopen\n",
    "\n",
    "r = urlopen(\"https://files.grouplens.org/datasets/movielens/ml-latest-small.zip\")\n",
    "zipfile = ZipFile(BytesIO(r.read()))\n",
    "\n",
    "#print the content of zipfile\n",
    "zipfile.namelist()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "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>userId</th>\n",
       "      <th>movieId</th>\n",
       "      <th>rating</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>4.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1</td>\n",
       "      <td>3</td>\n",
       "      <td>4.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>1</td>\n",
       "      <td>6</td>\n",
       "      <td>4.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>1</td>\n",
       "      <td>47</td>\n",
       "      <td>5.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>1</td>\n",
       "      <td>50</td>\n",
       "      <td>5.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   userId  movieId  rating\n",
       "0       1        1     4.0\n",
       "1       1        3     4.0\n",
       "2       1        6     4.0\n",
       "3       1       47     5.0\n",
       "4       1       50     5.0"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import pandas as pd\n",
    "import os \n",
    "\n",
    "ratings_df = pd.read_csv(zipfile.open(os.path.join(\"ml-latest-small\", \"ratings.csv\")), usecols=[\"userId\", \"movieId\", \"rating\"])\n",
    "ratings_df.head()"
   ]
  },
  {
   "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>movieId</th>\n",
       "      <th>title</th>\n",
       "      <th>genres</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>Toy Story (1995)</td>\n",
       "      <td>Adventure|Animation|Children|Comedy|Fantasy</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2</td>\n",
       "      <td>Jumanji (1995)</td>\n",
       "      <td>Adventure|Children|Fantasy</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>3</td>\n",
       "      <td>Grumpier Old Men (1995)</td>\n",
       "      <td>Comedy|Romance</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>4</td>\n",
       "      <td>Waiting to Exhale (1995)</td>\n",
       "      <td>Comedy|Drama|Romance</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>5</td>\n",
       "      <td>Father of the Bride Part II (1995)</td>\n",
       "      <td>Comedy</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   movieId                               title  \\\n",
       "0        1                    Toy Story (1995)   \n",
       "1        2                      Jumanji (1995)   \n",
       "2        3             Grumpier Old Men (1995)   \n",
       "3        4            Waiting to Exhale (1995)   \n",
       "4        5  Father of the Bride Part II (1995)   \n",
       "\n",
       "                                        genres  \n",
       "0  Adventure|Animation|Children|Comedy|Fantasy  \n",
       "1                   Adventure|Children|Fantasy  \n",
       "2                               Comedy|Romance  \n",
       "3                         Comedy|Drama|Romance  \n",
       "4                                       Comedy  "
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "movies_df = pd.read_csv(zipfile.open(os.path.join(\"ml-latest-small\", \"movies.csv\")))\n",
    "movies_df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "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>movieId</th>\n",
       "      <th>title</th>\n",
       "      <th>genres</th>\n",
       "      <th>userId</th>\n",
       "      <th>rating</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>Toy Story (1995)</td>\n",
       "      <td>Adventure|Animation|Children|Comedy|Fantasy</td>\n",
       "      <td>1.0</td>\n",
       "      <td>4.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1</td>\n",
       "      <td>Toy Story (1995)</td>\n",
       "      <td>Adventure|Animation|Children|Comedy|Fantasy</td>\n",
       "      <td>5.0</td>\n",
       "      <td>4.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>1</td>\n",
       "      <td>Toy Story (1995)</td>\n",
       "      <td>Adventure|Animation|Children|Comedy|Fantasy</td>\n",
       "      <td>7.0</td>\n",
       "      <td>4.5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>1</td>\n",
       "      <td>Toy Story (1995)</td>\n",
       "      <td>Adventure|Animation|Children|Comedy|Fantasy</td>\n",
       "      <td>15.0</td>\n",
       "      <td>2.5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>1</td>\n",
       "      <td>Toy Story (1995)</td>\n",
       "      <td>Adventure|Animation|Children|Comedy|Fantasy</td>\n",
       "      <td>17.0</td>\n",
       "      <td>4.5</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   movieId             title                                       genres  \\\n",
       "0        1  Toy Story (1995)  Adventure|Animation|Children|Comedy|Fantasy   \n",
       "1        1  Toy Story (1995)  Adventure|Animation|Children|Comedy|Fantasy   \n",
       "2        1  Toy Story (1995)  Adventure|Animation|Children|Comedy|Fantasy   \n",
       "3        1  Toy Story (1995)  Adventure|Animation|Children|Comedy|Fantasy   \n",
       "4        1  Toy Story (1995)  Adventure|Animation|Children|Comedy|Fantasy   \n",
       "\n",
       "   userId  rating  \n",
       "0     1.0     4.0  \n",
       "1     5.0     4.0  \n",
       "2     7.0     4.5  \n",
       "3    15.0     2.5  \n",
       "4    17.0     4.5  "
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df = movies_df.merge(ratings_df, how=\"left\", on=\"movieId\")\n",
    "df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'pandas.core.frame.DataFrame'>\n",
      "RangeIndex: 100854 entries, 0 to 100853\n",
      "Data columns (total 5 columns):\n",
      " #   Column   Non-Null Count   Dtype  \n",
      "---  ------   --------------   -----  \n",
      " 0   movieId  100854 non-null  int64  \n",
      " 1   title    100854 non-null  object \n",
      " 2   genres   100854 non-null  object \n",
      " 3   userId   100836 non-null  float64\n",
      " 4   rating   100836 non-null  float64\n",
      "dtypes: float64(2), int64(1), object(2)\n",
      "memory usage: 3.8+ MB\n"
     ]
    }
   ],
   "source": [
    "df.info()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "df.dropna(inplace=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "num_samples = len(df)\n",
    "df = df.sample(num_samples, random_state=42)\n",
    "df.reset_index(drop=True, inplace=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "count    100836.000000\n",
       "mean          3.501557\n",
       "std           1.042529\n",
       "min           0.500000\n",
       "25%           3.000000\n",
       "50%           3.500000\n",
       "75%           4.000000\n",
       "max           5.000000\n",
       "Name: rating, dtype: float64"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.rating.describe()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "# Prepare Dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'pandas.core.frame.DataFrame'>\n",
      "Index: 100556 entries, 0 to 100835\n",
      "Data columns (total 5 columns):\n",
      " #   Column   Non-Null Count   Dtype  \n",
      "---  ------   --------------   -----  \n",
      " 0   movieId  100556 non-null  int64  \n",
      " 1   title    100556 non-null  object \n",
      " 2   genres   100556 non-null  object \n",
      " 3   userId   100556 non-null  float64\n",
      " 4   rating   100556 non-null  float64\n",
      "dtypes: float64(2), int64(1), object(2)\n",
      "memory usage: 4.6+ MB\n"
     ]
    }
   ],
   "source": [
    "# drop users that has less than min_num_ratings ratings\n",
    "min_num_ratings = 20\n",
    "df = df[df.groupby('userId').userId.transform('count')>min_num_ratings].copy()\n",
    "df.info()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "from math import ceil\n",
    "\n",
    "df[\"rating\"] = df.rating.replace(0.5, 1)\n",
    "ratings = df.rating\n",
    "ratins_round = []\n",
    "\n",
    "for r in ratings:\n",
    "    ratins_round.append(round(r))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "df[\"rating\"] = ratins_round"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjkAAAGdCAYAAADwjmIIAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAtuElEQVR4nO3df3DU9Z3H8VcS8oMAG0QlgeOH6aFA5EckKWFtrYghW8w4cmIPPQZTRHpmEseQHhy5o/xsD48qP1qi8YoQ79QR6IzeSSjJGgROEwQCuYYojFpavJNNHAUCQTZr8r0/OrtlCQnZkCW7H5+PmR3Y7/e9n/28v59dfPnd7yYRlmVZAgAAMExkb08AAAAgGAg5AADASIQcAABgJEIOAAAwEiEHAAAYiZADAACMRMgBAABGIuQAAAAj9entCfSmtrY2ff755xowYIAiIiJ6ezoAAKALLMvS+fPnNXToUEVGdny+5lsdcj7//HMNHz68t6cBAAC64bPPPtOwYcM63B9QyFmxYoVWrlzpt2306NE6fvy4JOnSpUv66U9/qjfeeENut1sOh0MvvPCCEhMTffWnTp1Sbm6u3n33XfXv3185OTlas2aN+vT5y1T27t2rwsJC1dfXa/jw4Vq6dKl+/OMf+z1vcXGxfvnLX8rlcmnixIn69a9/rcmTJwfSjgYMGCDpzwfJZrMF9NjOeDweVVRUKCsrS9HR0T02bigxvUf6C3+m90h/4c/0HoPZX1NTk4YPH+7773hHAj6Tc+edd+qdd975ywCXhZOFCxeqrKxMO3bsUEJCgvLz8/Xwww/r/ffflyS1trYqOztbSUlJqqqq0unTp/X4448rOjpa//Iv/yJJOnnypLKzs/XUU0/ptddeU2VlpZ588kkNGTJEDodDkrRt2zYVFhaqpKREGRkZ2rBhgxwOh06cOKHBgwd3uRfvR1Q2m63HQ058fLxsNpuRL1zJ/B7pL/yZ3iP9hT/Te7wR/V3rUpOALzzu06ePkpKSfLdbbrlFknTu3Dm9/PLLWrdunaZNm6a0tDRt3bpVVVVVOnDggCSpoqJCH374oV599VWlpqZqxowZWr16tYqLi9XS0iJJKikpUXJysp5//nmNHTtW+fn5euSRR7R+/XrfHNatW6cFCxZo3rx5SklJUUlJieLj47Vly5ZA2wEAAIYK+EzOxx9/rKFDhyouLk52u11r1qzRiBEjVFNTI4/Ho8zMTF/tmDFjNGLECFVXV2vKlCmqrq7W+PHj/T6+cjgcys3NVX19ve666y5VV1f7jeGtKSgokCS1tLSopqZGRUVFvv2RkZHKzMxUdXV1p3N3u91yu92++01NTZL+nDY9Hk+gh6JD3rF6csxQY3qP9Bf+TO+R/sKf6T0Gs7+ujhlQyMnIyFBpaalGjx6t06dPa+XKlbrnnnt07NgxuVwuxcTEaODAgX6PSUxMlMvlkiS5XC6/gOPd793XWU1TU5O+/vprnTlzRq2trVet8V4b1JE1a9a0u6ZI+vMZpvj4+GsfgAA5nc4eHzPUmN4j/YU/03ukv/Bneo/B6O/ixYtdqgso5MyYMcP39wkTJigjI0MjR47U9u3b1bdv38Bm2AuKiopUWFjou++9cCkrK6vHr8lxOp2aPn26kZ+zSub3SH/hz/Qe6S/8md5jMPvzfhJzLdf1FfKBAwfqjjvu0CeffKLp06erpaVFZ8+e9Tub09DQoKSkJElSUlKSDh486DdGQ0ODb5/3T++2y2tsNpv69u2rqKgoRUVFXbXGO0ZHYmNjFRsb2257dHR0UF5gwRo3lJjeI/2FP9N7pL/wZ3qPweivq+Nd1088vnDhgj799FMNGTJEaWlpio6OVmVlpW//iRMndOrUKdntdkmS3W5XXV2dGhsbfTVOp1M2m00pKSm+msvH8NZ4x4iJiVFaWppfTVtbmyorK301AAAAAYWcf/iHf9C+ffv0xz/+UVVVVfqbv/kbRUVF6bHHHlNCQoLmz5+vwsJCvfvuu6qpqdG8efNkt9s1ZcoUSVJWVpZSUlI0d+5c/c///I/Ky8u1dOlS5eXl+c6wPPXUU/rDH/6gxYsX6/jx43rhhRe0fft2LVy40DePwsJC/eY3v9Err7yijz76SLm5uWpubta8efN68NAAAIBwFtDHVf/7v/+rxx57TF9++aVuvfVWff/739eBAwd06623SpLWr1+vyMhIzZo1y++HAXpFRUVp586dys3Nld1uV79+/ZSTk6NVq1b5apKTk1VWVqaFCxdq48aNGjZsmDZv3uz7GTmSNHv2bH3xxRdatmyZXC6XUlNTtXv37nYXIwMAgG+vgELOG2+80en+uLg4FRcXq7i4uMOakSNHateuXZ2OM3XqVB09erTTmvz8fOXn53daAwAAvr34LeQAAMBIhBwAAGAkQg4AADASIQcAABiJkAMAAIx0XT/xGACA25aU9fiYsVGW1k6Wxq0ol7s1osfH/+Oz2T0+JkIPZ3IAAICRCDkAAMBIhBwAAGAkQg4AADASIQcAABiJkAMAAIxEyAEAAEYi5AAAACMRcgAAgJEIOQAAwEiEHAAAYCRCDgAAMBIhBwAAGImQAwAAjETIAQAARiLkAAAAIxFyAACAkQg5AADASIQcAABgJEIOAAAwEiEHAAAYiZADAACMRMgBAABGIuQAAAAjEXIAAICRCDkAAMBIhBwAAGAkQg4AADASIQcAABiJkAMAAIxEyAEAAEYi5AAAACMRcgAAgJEIOQAAwEiEHAAAYCRCDgAAMBIhBwAAGImQAwAAjETIAQAARiLkAAAAIxFyAACAkQg5AADASIQcAABgJEIOAAAwEiEHAAAYiZADAACMRMgBAABGIuQAAAAjEXIAAICRCDkAAMBIhBwAAGAkQg4AADASIQcAABiJkAMAAIxEyAEAAEYi5AAAACNdV8h59tlnFRERoYKCAt+2S5cuKS8vTzfffLP69++vWbNmqaGhwe9xp06dUnZ2tuLj4zV48GAtWrRI33zzjV/N3r17NWnSJMXGxmrUqFEqLS1t9/zFxcW67bbbFBcXp4yMDB08ePB62gEAAAbpdsg5dOiQXnrpJU2YMMFv+8KFC/X2229rx44d2rdvnz7//HM9/PDDvv2tra3Kzs5WS0uLqqqq9Morr6i0tFTLli3z1Zw8eVLZ2dm67777VFtbq4KCAj355JMqLy/31Wzbtk2FhYVavny5jhw5ookTJ8rhcKixsbG7LQEAAIN0K+RcuHBBc+bM0W9+8xvddNNNvu3nzp3Tyy+/rHXr1mnatGlKS0vT1q1bVVVVpQMHDkiSKioq9OGHH+rVV19VamqqZsyYodWrV6u4uFgtLS2SpJKSEiUnJ+v555/X2LFjlZ+fr0ceeUTr16/3Pde6deu0YMECzZs3TykpKSopKVF8fLy2bNlyPccDAAAYok93HpSXl6fs7GxlZmbq5z//uW97TU2NPB6PMjMzfdvGjBmjESNGqLq6WlOmTFF1dbXGjx+vxMREX43D4VBubq7q6+t11113qbq62m8Mb433Y7GWlhbV1NSoqKjItz8yMlKZmZmqrq7ucN5ut1tut9t3v6mpSZLk8Xjk8Xi6cyiuyjtWT44Zakzvkf7Cn+k9hlJ/sVFWz48Zafn92dNC4biF0hoGQzD76+qYAYecN954Q0eOHNGhQ4fa7XO5XIqJidHAgQP9ticmJsrlcvlqLg843v3efZ3VNDU16euvv9aZM2fU2tp61Zrjx493OPc1a9Zo5cqV7bZXVFQoPj6+w8d1l9Pp7PExQ43pPdJf+DO9x1Dob+3k4I29Or0tKOPu2rUrKON2RyisYTAFo7+LFy92qS6gkPPZZ5/pmWeekdPpVFxcXLcm1puKiopUWFjou9/U1KThw4crKytLNputx57H4/HI6XRq+vTpio6O7rFxQ4npPdJf+DO9x1Dqb9yK8msXBSg20tLq9Db97HCk3G0RPT7+sRWOHh8zUKG0hsEQzP68n8RcS0Ahp6amRo2NjZo0aZJvW2trq/bv369NmzapvLxcLS0tOnv2rN/ZnIaGBiUlJUmSkpKS2n0Lyvvtq8trrvxGVkNDg2w2m/r27auoqChFRUVdtcY7xtXExsYqNja23fbo6OigvMCCNW4oMb1H+gt/pvcYCv25W3s+hPjGbosIyvi9fcwuFwprGEzB6K+r4wV04fH999+vuro61dbW+m7p6emaM2eO7+/R0dGqrKz0PebEiRM6deqU7Ha7JMlut6uurs7vW1BOp1M2m00pKSm+msvH8NZ4x4iJiVFaWppfTVtbmyorK301AADg2y2gMzkDBgzQuHHj/Lb169dPN998s2/7/PnzVVhYqEGDBslms+npp5+W3W7XlClTJElZWVlKSUnR3LlztXbtWrlcLi1dulR5eXm+syxPPfWUNm3apMWLF+uJJ57Qnj17tH37dpWVlfmet7CwUDk5OUpPT9fkyZO1YcMGNTc3a968edd1QAAAgBm69e2qzqxfv16RkZGaNWuW3G63HA6HXnjhBd/+qKgo7dy5U7m5ubLb7erXr59ycnK0atUqX01ycrLKysq0cOFCbdy4UcOGDdPmzZvlcPzlM9TZs2friy++0LJly+RyuZSamqrdu3e3uxgZAAB8O113yNm7d6/f/bi4OBUXF6u4uLjDx4wcOfKaV7ZPnTpVR48e7bQmPz9f+fn5XZ4rAAD49uB3VwEAACMRcgAAgJEIOQAAwEiEHAAAYCRCDgAAMBIhBwAAGImQAwAAjETIAQAARiLkAAAAIxFyAACAkQg5AADASIQcAABgJEIOAAAwEiEHAAAYiZADAACMRMgBAABGIuQAAAAjEXIAAICRCDkAAMBIhBwAAGAkQg4AADASIQcAABiJkAMAAIxEyAEAAEYi5AAAACMRcgAAgJEIOQAAwEiEHAAAYCRCDgAAMBIhBwAAGImQAwAAjETIAQAARiLkAAAAIxFyAACAkQg5AADASIQcAABgJEIOAAAwEiEHAAAYiZADAACMRMgBAABGIuQAAAAjEXIAAICRCDkAAMBIhBwAAGAkQg4AADASIQcAABiJkAMAAIxEyAEAAEYi5AAAACMRcgAAgJEIOQAAwEiEHAAAYCRCDgAAMBIhBwAAGImQAwAAjETIAQAARiLkAAAAIxFyAACAkQg5AADASIQcAABgJEIOAAAwEiEHAAAYKaCQ8+KLL2rChAmy2Wyy2Wyy2+363e9+59t/6dIl5eXl6eabb1b//v01a9YsNTQ0+I1x6tQpZWdnKz4+XoMHD9aiRYv0zTff+NXs3btXkyZNUmxsrEaNGqXS0tJ2cykuLtZtt92muLg4ZWRk6ODBg4G0AgAADBdQyBk2bJieffZZ1dTU6PDhw5o2bZoeeugh1dfXS5IWLlyot99+Wzt27NC+ffv0+eef6+GHH/Y9vrW1VdnZ2WppaVFVVZVeeeUVlZaWatmyZb6akydPKjs7W/fdd59qa2tVUFCgJ598UuXl5b6abdu2qbCwUMuXL9eRI0c0ceJEORwONTY2Xu/xAAAAhggo5Dz44IN64IEHdPvtt+uOO+7QL37xC/Xv318HDhzQuXPn9PLLL2vdunWaNm2a0tLStHXrVlVVVenAgQOSpIqKCn344Yd69dVXlZqaqhkzZmj16tUqLi5WS0uLJKmkpETJycl6/vnnNXbsWOXn5+uRRx7R+vXrffNYt26dFixYoHnz5iklJUUlJSWKj4/Xli1bevDQAACAcNanuw9sbW3Vjh071NzcLLvdrpqaGnk8HmVmZvpqxowZoxEjRqi6ulpTpkxRdXW1xo8fr8TERF+Nw+FQbm6u6uvrddddd6m6utpvDG9NQUGBJKmlpUU1NTUqKiry7Y+MjFRmZqaqq6s7nbPb7Zbb7fbdb2pqkiR5PB55PJ7uHop2vGP15JihxvQe6S/8md5jKPUXG2X1/JiRlt+fPS0UjlsorWEwBLO/ro4ZcMipq6uT3W7XpUuX1L9/f7355ptKSUlRbW2tYmJiNHDgQL/6xMREuVwuSZLL5fILON793n2d1TQ1Nenrr7/WmTNn1NraetWa48ePdzr3NWvWaOXKle22V1RUKD4+/trNB8jpdPb4mKHG9B7pL/yZ3mMo9Ld2cvDGXp3eFpRxd+3aFZRxuyMU1jCYgtHfxYsXu1QXcMgZPXq0amtrde7cOf32t79VTk6O9u3bF/AEe0NRUZEKCwt995uamjR8+HBlZWXJZrP12PN4PB45nU5Nnz5d0dHRPTZuKDG9R/oLf6b3GEr9jVtRfu2iAMVGWlqd3qafHY6Uuy2ix8c/tsLR42MGKpTWMBiC2Z/3k5hrCTjkxMTEaNSoUZKktLQ0HTp0SBs3btTs2bPV0tKis2fP+p3NaWhoUFJSkiQpKSmp3begvN++urzmym9kNTQ0yGazqW/fvoqKilJUVNRVa7xjdCQ2NlaxsbHttkdHRwflBRascUOJ6T3SX/gzvcdQ6M/d2vMhxDd2W0RQxu/tY3a5UFjDYApGf10d77p/Tk5bW5vcbrfS0tIUHR2tyspK374TJ07o1KlTstvtkiS73a66ujq/b0E5nU7ZbDalpKT4ai4fw1vjHSMmJkZpaWl+NW1tbaqsrPTVAAAABHQmp6ioSDNmzNCIESN0/vx5vf7669q7d6/Ky8uVkJCg+fPnq7CwUIMGDZLNZtPTTz8tu92uKVOmSJKysrKUkpKiuXPnau3atXK5XFq6dKny8vJ8Z1ieeuopbdq0SYsXL9YTTzyhPXv2aPv27SorK/PNo7CwUDk5OUpPT9fkyZO1YcMGNTc3a968eT14aAAAQDgLKOQ0Njbq8ccf1+nTp5WQkKAJEyaovLxc06dPlyStX79ekZGRmjVrltxutxwOh1544QXf46OiorRz507l5ubKbrerX79+ysnJ0apVq3w1ycnJKisr08KFC7Vx40YNGzZMmzdvlsPxl89PZ8+erS+++ELLli2Ty+VSamqqdu/e3e5iZAAA8O0VUMh5+eWXO90fFxen4uJiFRcXd1gzcuTIa17VPnXqVB09erTTmvz8fOXn53daAwAAvr343VUAAMBIhBwAAGAkQg4AADASIQcAABiJkAMAAIxEyAEAAEYi5AAAACMRcgAAgJEIOQAAwEiEHAAAYCRCDgAAMBIhBwAAGImQAwAAjETIAQAARiLkAAAAIxFyAACAkQg5AADASIQcAABgJEIOAAAwEiEHAAAYiZADAACMRMgBAABGIuQAAAAjEXIAAICRCDkAAMBIhBwAAGAkQg4AADASIQcAABiJkAMAAIxEyAEAAEYi5AAAACMRcgAAgJEIOQAAwEiEHAAAYCRCDgAAMBIhBwAAGImQAwAAjETIAQAARiLkAAAAIxFyAACAkQg5AADASIQcAABgJEIOAAAwEiEHAAAYiZADAACMRMgBAABGIuQAAAAjEXIAAICRCDkAAMBIhBwAAGAkQg4AADASIQcAABiJkAMAAIxEyAEAAEYi5AAAACMRcgAAgJEIOQAAwEiEHAAAYCRCDgAAMBIhBwAAGImQAwAAjETIAQAARgoo5KxZs0bf/e53NWDAAA0ePFgzZ87UiRMn/GouXbqkvLw83Xzzzerfv79mzZqlhoYGv5pTp04pOztb8fHxGjx4sBYtWqRvvvnGr2bv3r2aNGmSYmNjNWrUKJWWlrabT3FxsW677TbFxcUpIyNDBw8eDKQdAABgsIBCzr59+5SXl6cDBw7I6XTK4/EoKytLzc3NvpqFCxfq7bff1o4dO7Rv3z59/vnnevjhh337W1tblZ2drZaWFlVVVemVV15RaWmpli1b5qs5efKksrOzdd9996m2tlYFBQV68sknVV5e7qvZtm2bCgsLtXz5ch05ckQTJ06Uw+FQY2Pj9RwPAABgiD6BFO/evdvvfmlpqQYPHqyamhr94Ac/0Llz5/Tyyy/r9ddf17Rp0yRJW7du1dixY3XgwAFNmTJFFRUV+vDDD/XOO+8oMTFRqampWr16tf7xH/9RK1asUExMjEpKSpScnKznn39ekjR27Fi99957Wr9+vRwOhyRp3bp1WrBggebNmydJKikpUVlZmbZs2aIlS5Zc94EBAADhLaCQc6Vz585JkgYNGiRJqqmpkcfjUWZmpq9mzJgxGjFihKqrqzVlyhRVV1dr/PjxSkxM9NU4HA7l5uaqvr5ed911l6qrq/3G8NYUFBRIklpaWlRTU6OioiLf/sjISGVmZqq6urrD+brdbrndbt/9pqYmSZLH45HH4+nmUWjPO1ZPjhlqTO+R/sKf6T2GUn+xUVbPjxlp+f3Z00LhuIXSGgZDMPvr6pjdDjltbW0qKCjQ9773PY0bN06S5HK5FBMTo4EDB/rVJiYmyuVy+WouDzje/d59ndU0NTXp66+/1pkzZ9Ta2nrVmuPHj3c45zVr1mjlypXttldUVCg+Pr4LXQfG6XT2+JihxvQe6S/8md5jKPS3dnLwxl6d3haUcXft2hWUcbsjFNYwmILR38WLF7tU1+2Qk5eXp2PHjum9997r7hA3XFFRkQoLC333m5qaNHz4cGVlZclms/XY83g8HjmdTk2fPl3R0dE9Nm4oMb1H+gt/3h5/djhS7raI3p5Olx1b4ehSXSit4bgV5dcuClBspKXV6W1BW7+uHudgCqU1DIZg9uf9JOZauhVy8vPztXPnTu3fv1/Dhg3zbU9KSlJLS4vOnj3rdzanoaFBSUlJvporvwXl/fbV5TVXfiOroaFBNptNffv2VVRUlKKioq5a4x3jamJjYxUbG9tue3R0dFBeYMEaN5SY3iP9hT93W4TcreETcgJdj1BYw2Ae32CtX28fs8uFwhoGUzD66+p4AX27yrIs5efn680339SePXuUnJzstz8tLU3R0dGqrKz0bTtx4oROnTolu90uSbLb7aqrq/P7FpTT6ZTNZlNKSoqv5vIxvDXeMWJiYpSWluZX09bWpsrKSl8NAAD4dgvoTE5eXp5ef/11/ed//qcGDBjgu4YmISFBffv2VUJCgubPn6/CwkINGjRINptNTz/9tOx2u6ZMmSJJysrKUkpKiubOnau1a9fK5XJp6dKlysvL851leeqpp7Rp0yYtXrxYTzzxhPbs2aPt27errKzMN5fCwkLl5OQoPT1dkydP1oYNG9Tc3Oz7thUAAPh2CyjkvPjii5KkqVOn+m3funWrfvzjH0uS1q9fr8jISM2aNUtut1sOh0MvvPCCrzYqKko7d+5Ubm6u7Ha7+vXrp5ycHK1atcpXk5ycrLKyMi1cuFAbN27UsGHDtHnzZt/XxyVp9uzZ+uKLL7Rs2TK5XC6lpqZq9+7d7S5GBgAA304BhRzLuvZX+eLi4lRcXKzi4uIOa0aOHHnNK9unTp2qo0ePdlqTn5+v/Pz8a84JAAB8+/C7qwAAgJEIOQAAwEiEHAAAYCRCDgAAMBIhBwAAGImQAwAAjETIAQAARiLkAAAAIxFyAACAkQg5AADASIQcAABgJEIOAAAwEiEHAAAYiZADAACMRMgBAABGIuQAAAAjEXIAAICRCDkAAMBIhBwAAGAkQg4AADASIQcAABiJkAMAAIxEyAEAAEYi5AAAACMRcgAAgJEIOQAAwEiEHAAAYCRCDgAAMBIhBwAAGImQAwAAjNSntycAXI/blpQFZdzYKEtrJ0vjVpTL3RrRo2P/8dnsHh0PAHB1nMkBAABGIuQAAAAjEXIAAICRCDkAAMBIhBwAAGAkQg4AADASIQcAABiJkAMAAIxEyAEAAEYi5AAAACMRcgAAgJEIOQAAwEj8gk4AAMJAsH4hcbB4f9Fxb+JMDgAAMBIhBwAAGImQAwAAjETIAQAARiLkAAAAIxFyAACAkQg5AADASIQcAABgJEIOAAAwEiEHAAAYiZADAACMRMgBAABGIuQAAAAjEXIAAICRCDkAAMBIhBwAAGAkQg4AADBSwCFn//79evDBBzV06FBFRETorbfe8ttvWZaWLVumIUOGqG/fvsrMzNTHH3/sV/PVV19pzpw5stlsGjhwoObPn68LFy741fz+97/XPffco7i4OA0fPlxr165tN5cdO3ZozJgxiouL0/jx47Vr165A2wEAAIYKOOQ0Nzdr4sSJKi4uvur+tWvX6le/+pVKSkr0wQcfqF+/fnI4HLp06ZKvZs6cOaqvr5fT6dTOnTu1f/9+/eQnP/Htb2pqUlZWlkaOHKmamhr98pe/1IoVK/Rv//Zvvpqqqio99thjmj9/vo4ePaqZM2dq5syZOnbsWKAtAQAAA/UJ9AEzZszQjBkzrrrPsixt2LBBS5cu1UMPPSRJ+vd//3clJibqrbfe0qOPPqqPPvpIu3fv1qFDh5Seni5J+vWvf60HHnhAzz33nIYOHarXXntNLS0t2rJli2JiYnTnnXeqtrZW69at84WhjRs36oc//KEWLVokSVq9erWcTqc2bdqkkpKSbh0MAABgjh69JufkyZNyuVzKzMz0bUtISFBGRoaqq6slSdXV1Ro4cKAv4EhSZmamIiMj9cEHH/hqfvCDHygmJsZX43A4dOLECZ05c8ZXc/nzeGu8zwMAAL7dAj6T0xmXyyVJSkxM9NuemJjo2+dyuTR48GD/SfTpo0GDBvnVJCcntxvDu++mm26Sy+Xq9Hmuxu12y+12++43NTVJkjwejzweT5f7vBbvWD05ZqgJlR5jo6zgjBtp+f3Zk3r7mF0+h1CYS7B4ewvGGgZTV9cklNYwGO/DYL4HpdA4boGuYbD+vQsW79oF41h3dcweDTmhbs2aNVq5cmW77RUVFYqPj+/x53M6nT0+Zqjp7R7XTg7u+KvT23p8zFC6QL631+9GCMYaBlOgr49QWMNgvg+DtX7h+D4M9r93wRKM1+jFixe7VNejIScpKUmS1NDQoCFDhvi2NzQ0KDU11VfT2Njo97hvvvlGX331le/xSUlJamho8Kvx3r9WjXf/1RQVFamwsNB3v6mpScOHD1dWVpZsNlsgrXbK4/HI6XRq+vTpio6O7rFxQ0mo9DhuRXlQxo2NtLQ6vU0/Oxwpd1tEj459bIWjR8frjlBZv2Dy9hiMNQymrr4+QmkNg/E+DOZ7UArP92Gw/r0LFu8aBuM16v0k5lp6NOQkJycrKSlJlZWVvlDT1NSkDz74QLm5uZIku92us2fPqqamRmlpaZKkPXv2qK2tTRkZGb6af/7nf5bH4/EdGKfTqdGjR+umm27y1VRWVqqgoMD3/E6nU3a7vcP5xcbGKjY2tt326OjooPwjEaxxQ0lv9+huDe5/vNxtET3+HKH0mujt9bsRgrGGwRToeoTCGgbz+AZr/Xr7mF2uq2sYTq/jywXjNdrV8QK+8PjChQuqra1VbW2tpD9fbFxbW6tTp04pIiJCBQUF+vnPf67/+q//Ul1dnR5//HENHTpUM2fOlCSNHTtWP/zhD7VgwQIdPHhQ77//vvLz8/Xoo49q6NChkqS/+7u/U0xMjObPn6/6+npt27ZNGzdu9DsL88wzz2j37t16/vnndfz4ca1YsUKHDx9Wfn5+oC0BAAADBXwm5/Dhw7rvvvt8973BIycnR6WlpVq8eLGam5v1k5/8RGfPntX3v/997d69W3Fxcb7HvPbaa8rPz9f999+vyMhIzZo1S7/61a98+xMSElRRUaG8vDylpaXplltu0bJly/x+ls7dd9+t119/XUuXLtU//dM/6fbbb9dbb72lcePGdetAAAAAswQccqZOnSrL6vgK74iICK1atUqrVq3qsGbQoEF6/fXXO32eCRMm6L//+787rfnRj36kH/3oR51PGAAAfCvxu6sAAICRCDkAAMBIhBwAAGAkQg4AADASIQcAABiJkAMAAIxEyAEAAEYi5AAAACMRcgAAgJEIOQAAwEiEHAAAYCRCDgAAMBIhBwAAGImQAwAAjETIAQAARiLkAAAAIxFyAACAkQg5AADASIQcAABgJEIOAAAwEiEHAAAYiZADAACMRMgBAABGIuQAAAAjEXIAAICRCDkAAMBIhBwAAGAkQg4AADASIQcAABiJkAMAAIxEyAEAAEYi5AAAACMRcgAAgJEIOQAAwEiEHAAAYCRCDgAAMFKf3p6AycatKJe7NaK3p9Flf3w2u7enAABAj+FMDgAAMBIhBwAAGImQAwAAjETIAQAARiLkAAAAIxFyAACAkQg5AADASIQcAABgJEIOAAAwEiEHAAAYiZADAACMRMgBAABGIuQAAAAjEXIAAICRCDkAAMBIhBwAAGAkQg4AADASIQcAABiJkAMAAIxEyAEAAEYi5AAAACMRcgAAgJEIOQAAwEiEHAAAYCRCDgAAMFLYh5zi4mLddtttiouLU0ZGhg4ePNjbUwIAACEgrEPOtm3bVFhYqOXLl+vIkSOaOHGiHA6HGhsbe3tqAACgl4V1yFm3bp0WLFigefPmKSUlRSUlJYqPj9eWLVt6e2oAAKCX9entCXRXS0uLampqVFRU5NsWGRmpzMxMVVdXX/Uxbrdbbrfbd//cuXOSpK+++koej6fH5ubxeHTx4kX18USqtS2ix8YNti+//LLLtd4ev/zyS0VHRwdxVp3r801zcMZts3TxYltQ1jCQ4xwsobJ+wWT6+zCU1jAY78Ngvgel8HwfBuvfu2DxrmEwXqPnz5+XJFmW1XmhFab+7//+z5JkVVVV+W1ftGiRNXny5Ks+Zvny5ZYkbty4cePGjZsBt88++6zTrBC2Z3K6o6ioSIWFhb77bW1t+uqrr3TzzTcrIqLn/k+hqalJw4cP12effSabzdZj44YS03ukv/Bneo/0F/5M7zGY/VmWpfPnz2vo0KGd1oVtyLnlllsUFRWlhoYGv+0NDQ1KSkq66mNiY2MVGxvrt23gwIHBmqJsNpuRL9zLmd4j/YU/03ukv/Bneo/B6i8hIeGaNWF74XFMTIzS0tJUWVnp29bW1qbKykrZ7fZenBkAAAgFYXsmR5IKCwuVk5Oj9PR0TZ48WRs2bFBzc7PmzZvX21MDAAC9LKxDzuzZs/XFF19o2bJlcrlcSk1N1e7du5WYmNir84qNjdXy5cvbfTRmEtN7pL/wZ3qP9Bf+TO8xFPqLsKxrff8KAAAg/ITtNTkAAACdIeQAAAAjEXIAAICRCDkAAMBIhJxu2L9/vx588EENHTpUEREReuutt675mL1792rSpEmKjY3VqFGjVFpaGvR5dleg/e3du1cRERHtbi6X68ZMOEBr1qzRd7/7XQ0YMECDBw/WzJkzdeLEiWs+bseOHRozZozi4uI0fvx47dq16wbMNnDd6a+0tLTd+sXFxd2gGQfuxRdf1IQJE3w/ZMxut+t3v/tdp48Jl/WTAu8v3NbvSs8++6wiIiJUUFDQaV04reHlutJfuK3hihUr2s13zJgxnT6mN9aPkNMNzc3NmjhxooqLi7tUf/LkSWVnZ+u+++5TbW2tCgoK9OSTT6q8vDzIM+2eQPvzOnHihE6fPu27DR48OEgzvD779u1TXl6eDhw4IKfTKY/Ho6ysLDU3d/zL76qqqvTYY49p/vz5Onr0qGbOnKmZM2fq2LFjN3DmXdOd/qQ//1TSy9fvT3/60w2aceCGDRumZ599VjU1NTp8+LCmTZumhx56SPX19VetD6f1kwLvTwqv9bvcoUOH9NJLL2nChAmd1oXbGnp1tT8p/Nbwzjvv9Jvve++912Ftr61fz/y6zG8vSdabb77Zac3ixYutO++802/b7NmzLYfDEcSZ9Yyu9Pfuu+9akqwzZ87ckDn1tMbGRkuStW/fvg5r/vZv/9bKzs7225aRkWH9/d//fbCnd9260t/WrVuthISEGzepILjpppuszZs3X3VfOK+fV2f9hev6nT9/3rr99tstp9Np3XvvvdYzzzzTYW04rmEg/YXbGi5fvtyaOHFil+t7a/04k3MDVFdXKzMz02+bw+FQdXV1L80oOFJTUzVkyBBNnz5d77//fm9Pp8vOnTsnSRo0aFCHNeG8hl3pT5IuXLigkSNHavjw4dc8axBKWltb9cYbb6i5ubnDX+kSzuvXlf6k8Fy/vLw8ZWdnt1ubqwnHNQykPyn81vDjjz/W0KFD9Z3vfEdz5szRqVOnOqztrfUL6594HC5cLle7n8KcmJiopqYmff311+rbt28vzaxnDBkyRCUlJUpPT5fb7dbmzZs1depUffDBB5o0aVJvT69TbW1tKigo0Pe+9z2NGzeuw7qO1jBUrzvy6mp/o0eP1pYtWzRhwgSdO3dOzz33nO6++27V19dr2LBhN3DGXVdXVye73a5Lly6pf//+evPNN5WSknLV2nBcv0D6C8f1e+ONN3TkyBEdOnSoS/XhtoaB9hdua5iRkaHS0lKNHj1ap0+f1sqVK3XPPffo2LFjGjBgQLv63lo/Qg6u2+jRozV69Gjf/bvvvluffvqp1q9fr//4j//oxZldW15eno4dO9bpZ8nhrKv92e12v7MEd999t8aOHauXXnpJq1evDvY0u2X06NGqra3VuXPn9Nvf/lY5OTnat29fh0Eg3ATSX7it32effaZnnnlGTqczpC+u7a7u9Bduazhjxgzf3ydMmKCMjAyNHDlS27dv1/z583txZv4IOTdAUlKSGhoa/LY1NDTIZrOF/VmcjkyePDnkg0N+fr527typ/fv3X/P/lDpaw6SkpGBO8boE0t+VoqOjddddd+mTTz4J0uyuX0xMjEaNGiVJSktL06FDh7Rx40a99NJL7WrDcf0C6e9Kob5+NTU1amxs9DvT29raqv3792vTpk1yu92Kiorye0w4rWF3+rtSqK/hlQYOHKg77rijw/n21vpxTc4NYLfbVVlZ6bfN6XR2+vl6uKutrdWQIUN6expXZVmW8vPz9eabb2rPnj1KTk6+5mPCaQ2709+VWltbVVdXF7JreDVtbW1yu91X3RdO69eRzvq7Uqiv3/3336+6ujrV1tb6bunp6ZozZ45qa2uvGgDCaQ2709+VQn0Nr3ThwgV9+umnHc6319YvqJc1G+r8+fPW0aNHraNHj1qSrHXr1llHjx61/vSnP1mWZVlLliyx5s6d66v/wx/+YMXHx1uLFi2yPvroI6u4uNiKioqydu/e3VstdCrQ/tavX2+99dZb1scff2zV1dVZzzzzjBUZGWm98847vdVCp3Jzc62EhARr79691unTp323ixcv+mrmzp1rLVmyxHf//ffft/r06WM999xz1kcffWQtX77cio6Oturq6nqjhU51p7+VK1da5eXl1qeffmrV1NRYjz76qBUXF2fV19f3RgvXtGTJEmvfvn3WyZMnrd///vfWkiVLrIiICKuiosKyrPBeP8sKvL9wW7+rufLbR+G+hle6Vn/htoY//elPrb1791onT5603n//fSszM9O65ZZbrMbGRsuyQmf9CDnd4P3K9JW3nJwcy7IsKycnx7r33nvbPSY1NdWKiYmxvvOd71hbt2694fPuqkD7+9d//Vfrr//6r624uDhr0KBB1tSpU609e/b0zuS74Gq9SfJbk3vvvdfXr9f27dutO+64w4qJibHuvPNOq6ys7MZOvIu6019BQYE1YsQIKyYmxkpMTLQeeOAB68iRIzd+8l30xBNPWCNHjrRiYmKsW2+91br//vt9AcCywnv9LCvw/sJt/a7myhAQ7mt4pWv1F25rOHv2bGvIkCFWTEyM9Vd/9VfW7NmzrU8++cS3P1TWL8KyLCu454oAAABuPK7JAQAARiLkAAAAIxFyAACAkQg5AADASIQcAABgJEIOAAAwEiEHAAAYiZADAACMRMgBAABGIuQAAAAjEXIAAICRCDkAAMBI/w/FylJJgWrDMgAAAABJRU5ErkJggg==",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "plt.figure(dpi=100)\n",
    "df.rating.hist()\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "596"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "unique_users = df.userId.unique().tolist()\n",
    "len(unique_users)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "596"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "unique_users_map = {}\n",
    "\n",
    "for idx, mm in enumerate(df.userId.unique()):\n",
    "    unique_users_map[int(mm)] = idx\n",
    "len(unique_users_map)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9724"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "movie_ids_map = {}\n",
    "\n",
    "for idx, mm in enumerate(df.movieId.unique()):\n",
    "    movie_ids_map[mm] = idx\n",
    "len(movie_ids_map)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Prepare Train Matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import random\n",
    "random.seed(42)\n",
    "np.random.seed(42)\n",
    "\n",
    "X = np.zeros((len(unique_users), len(movie_ids_map)))\n",
    "\n",
    "KNOWN_MASK = np.zeros(X.shape) * False\n",
    "for row in df.itertuples():\n",
    "    \n",
    "    # given we have matrix, add in the actual ratings to the matrix\n",
    "    x = unique_users_map[int(row.userId)]\n",
    "    y = movie_ids_map[row.movieId]\n",
    "    X[x, y] = row.rating\n",
    "    \n",
    "    # save the coordinates (row, column) of the ratings.\n",
    "    KNOWN_MASK[x,y] = True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Num. Test: 10056 \n",
      " Num. Known: 100556\n",
      "Num. Known: 90500\n"
     ]
    }
   ],
   "source": [
    "from math import ceil\n",
    "import scipy.sparse as ss\n",
    "\n",
    "X_train = X.copy()\n",
    "test_size = 0.1\n",
    "\n",
    "num_known = len(np.argwhere(KNOWN_MASK))\n",
    "num_test = ceil(num_known * test_size)\n",
    "print(\n",
    "    \"Num. Test:\", num_test, \"\\n\",\n",
    "    \"Num. Known:\", len(np.argwhere(KNOWN_MASK)))\n",
    "\n",
    "removed_cords = random.sample(list(enumerate(np.argwhere(KNOWN_MASK))), num_test)\n",
    "for idx, (x, y)  in removed_cords:\n",
    "    X_train[x, y] = 0\n",
    "    KNOWN_MASK[x,y] = False\n",
    "\n",
    "print(\"Num. Known:\", len(np.argwhere(KNOWN_MASK)))\n",
    "assert len(np.argwhere(KNOWN_MASK)) == num_known - num_test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train = X_train.astype(\"float32\")\n",
    "X = X.astype(\"float32\")\n",
    "X_train_ss = ss.csr_matrix(X_train)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# RNMFk"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/maksim/miniconda3/envs/TELF/lib/python3.11/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
      "  from .autonotebook import tqdm as notebook_tqdm\n",
      "/home/maksim/repositories/telf_internal/TELF/factorization/NMFk.py:824: UserWarning: predict_k_method is defaulted to WH_sill!\n",
      "  warnings.warn(\"predict_k_method is defaulted to WH_sill!\")\n",
      "/home/maksim/repositories/telf_internal/TELF/factorization/NMFk.py:842: UserWarning: calculate_error is True! Error calculation can make the runtime longer and take up more memory space!\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "n_perturbs: 2\n",
      "perturb_type: uniform\n",
      "n_iters: 100\n",
      "epsilon: 0.015\n",
      "init: nnsvd\n",
      "save_path: ../../results\n",
      "save_output: True\n",
      "use_gpu: True\n",
      "verbose: True\n",
      "nmf_verbose: False\n",
      "perturb_verbose: False\n",
      "transpose: False\n",
      "collect_output: True\n",
      "sill_thresh: 0.7\n",
      "predict_k: True\n",
      "predict_k_method: WH_sill\n",
      "n_jobs: 4\n",
      "n_nodes: 1\n",
      "nmf: <function nmf at 0x767b044839c0>\n",
      "nmf_method: nmf_recommender\n",
      "nmf_obj_params: {'lr_bu': 1e-05, 'lr_bi': 1e-05, 'MASK': array([[1., 1., 1., ..., 0., 0., 0.],\n",
      "       [1., 1., 1., ..., 0., 0., 0.],\n",
      "       [1., 1., 0., ..., 0., 0., 0.],\n",
      "       ...,\n",
      "       [0., 0., 0., ..., 0., 0., 0.],\n",
      "       [0., 0., 0., ..., 0., 0., 0.],\n",
      "       [0., 0., 0., ..., 0., 0., 0.]])}\n",
      "clustering_obj_params: {}\n",
      "pruned: True\n",
      "calculate_error: True\n",
      "consensus_mat: False\n",
      "use_consensus_stopping: 0\n",
      "mask: None\n",
      "calculate_pac: False\n",
      "simple_plot: True\n",
      "get_plot_data: False\n",
      "perturb_multiprocessing: False\n",
      "k_search_method: linear\n",
      "H_sill_thresh: None\n",
      "factor_thresholding: None\n",
      "factor_thresholding_H_regression: None\n",
      "factor_thresholding_obj_params: {}\n",
      "factor_thresholding_H_regression_obj_params: {}\n",
      "clustering_method: kmeans\n",
      "device: [0]\n",
      "lock: <unlocked _thread.lock object at 0x767b0ae4e100>\n",
      "K_search_settings: {'lock': <unlocked _thread.lock object at 0x767b0aece780>, 'k_search_method': 'linear', 'sill_thresh': 0.7, 'H_sill_thresh': None, 'k_min': -1, 'k_max': inf}\n",
      "total_exec_seconds: 0\n",
      "experiment_name: \n",
      "thresholding_function: None\n",
      "nmf_params: {'niter': 100, 'use_gpu': True, 'nmf_verbose': False, 'lr_bu': 1e-05, 'lr_bi': 1e-05, 'MASK': array([[1., 1., 1., ..., 0., 0., 0.],\n",
      "       [1., 1., 1., ..., 0., 0., 0.],\n",
      "       [1., 1., 0., ..., 0., 0., 0.],\n",
      "       ...,\n",
      "       [0., 0., 0., ..., 0., 0., 0.],\n",
      "       [0., 0., 0., ..., 0., 0., 0.],\n",
      "       [0., 0., 0., ..., 0., 0., 0.]])}\n"
     ]
    }
   ],
   "source": [
    "from TELF.factorization import NMFk\n",
    "from TELF.factorization import RNMFk_predict\n",
    "\n",
    "params = {\n",
    "    \"n_perturbs\":2,\n",
    "    \"n_iters\":100,\n",
    "    \"epsilon\":0.015,\n",
    "    \"n_jobs\":4,\n",
    "    \"init\":\"nnsvd\", \n",
    "    \"use_gpu\":True,\n",
    "    \"save_path\":os.path.join(\"..\", \"..\", \"results\"), \n",
    "    \"save_output\":True,\n",
    "    \"collect_output\":True,\n",
    "    \"predict_k\":True,\n",
    "    \"predict_k_method\":\"sill\",\n",
    "    \"verbose\":True,\n",
    "    \"nmf_verbose\":False,\n",
    "    \"transpose\":False,\n",
    "    \"sill_thresh\":0.7,\n",
    "    \"pruned\":True,\n",
    "    'nmf_method':'nmf_recommender', # nmf_fro_mu, nmf_recommender\n",
    "    \"calculate_error\":True,\n",
    "    \"predict_k\":True,\n",
    "    \"use_consensus_stopping\":0,\n",
    "    \"calculate_pac\":False,\n",
    "    \"perturb_type\":\"uniform\",\n",
    "    \"nmf_obj_params\":{\n",
    "        \"lr_bu\":0.00001, \n",
    "        \"lr_bi\":0.00001,\n",
    "        \"MASK\":KNOWN_MASK\n",
    "    },\n",
    "    \"perturb_multiprocessing\":False,\n",
    "    \"perturb_verbose\":False\n",
    "}\n",
    "Ks = range(1,11,1)\n",
    "name = \"RNMFk_Example\"\n",
    "note = \"This is an example run of NMFk\"\n",
    "\n",
    "model = NMFk(**params)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  0%|          | 0/10 [00:00<?, ?it/s]/home/maksim/miniconda3/envs/TELF/lib/python3.11/site-packages/numpy/_core/fromnumeric.py:3596: RuntimeWarning: Mean of empty slice.\n",
      "  return _methods._mean(a, axis=axis, dtype=dtype,\n",
      "/home/maksim/miniconda3/envs/TELF/lib/python3.11/site-packages/numpy/_core/_methods.py:138: RuntimeWarning: invalid value encountered in scalar divide\n",
      "  ret = ret.dtype.type(ret / rcount)\n",
      "100%|██████████| 10/10 [00:06<00:00,  1.53it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 9.25 s, sys: 4.44 s, total: 13.7 s\n",
      "Wall time: 7.12 s\n"
     ]
    }
   ],
   "source": [
    "%time results = model.fit(X_train_ss, Ks, name, note)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_keys(['time', 'k_predict', 'W', 'H', 'other_results'])"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "results.keys()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "results[\"k_predict\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Define Prediction Helper"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "W = results[\"W\"]\n",
    "H = results[\"H\"]\n",
    "global_mean = results[\"other_results\"][\"global_mean\"]\n",
    "bi = results[\"other_results\"][\"bi\"]\n",
    "bu = results[\"other_results\"][\"bu\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_preds_test = []\n",
    "y_trues_test = []\n",
    "for idx, (u, i) in removed_cords:\n",
    "    y_preds_test.append(RNMFk_predict(W, H, global_mean, bu, bi, u, i))\n",
    "    y_trues_test.append(X[u, i])\n",
    "    \n",
    "y_preds_test = np.array(y_preds_test)\n",
    "y_trues_test = np.array(y_trues_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "rows, columns = np.argwhere(KNOWN_MASK)[:,0], np.argwhere(KNOWN_MASK)[:,1]\n",
    "\n",
    "y_preds_train = []\n",
    "y_trues_train = []\n",
    "\n",
    "for u, i in zip(rows, columns):\n",
    "    y_preds_train.append(RNMFk_predict(W, H, global_mean, bu, bi, u, i))\n",
    "    y_trues_train.append(X_train_ss[u, i])\n",
    "    \n",
    "y_preds_train = np.array(y_preds_train)\n",
    "y_trues_train = np.array(y_trues_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "NMF reconstruction error: 0.1879058\n",
      "NMF train error: 0.92384833\n",
      "NMF test error: 0.94747734\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/maksim/miniconda3/envs/TELF/lib/python3.11/site-packages/sklearn/metrics/_regression.py:492: FutureWarning: 'squared' is deprecated in version 1.4 and will be removed in 1.6. To calculate the root mean squared error, use the function'root_mean_squared_error'.\n",
      "  warnings.warn(\n",
      "/home/maksim/miniconda3/envs/TELF/lib/python3.11/site-packages/sklearn/metrics/_regression.py:492: FutureWarning: 'squared' is deprecated in version 1.4 and will be removed in 1.6. To calculate the root mean squared error, use the function'root_mean_squared_error'.\n",
      "  warnings.warn(\n",
      "/home/maksim/miniconda3/envs/TELF/lib/python3.11/site-packages/sklearn/metrics/_regression.py:492: FutureWarning: 'squared' is deprecated in version 1.4 and will be removed in 1.6. To calculate the root mean squared error, use the function'root_mean_squared_error'.\n",
      "  warnings.warn(\n"
     ]
    }
   ],
   "source": [
    "from sklearn.metrics import mean_squared_error\n",
    "\n",
    "reconstruct = mean_squared_error(W@H, X_train, squared=True)\n",
    "mse_train = mean_squared_error(y_preds_train, y_trues_train, squared=True)\n",
    "mse_test = mean_squared_error(y_preds_test, y_trues_test, squared=True)\n",
    "\n",
    "print(\"NMF reconstruction error:\", reconstruct)\n",
    "print(\"NMF train error:\", mse_train)\n",
    "print(\"NMF test error:\", mse_test)"
   ]
  },
  {
   "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.11.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}