L7StudiesNotesc.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 5,
  "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.6.13"
    },
    "colab": {
      "name": "L7StudiesNotesb.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "machine_shape": "hm"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0dea6114"
      },
      "source": [
        "# Lesson 7\n",
        "\n",
        "# Matrix Factorization for Recommendations\n",
        "\n",
        "## Questions still opened\n",
        "\n",
        "## How to know that our recommendation is a good one?\n",
        "\n",
        "#### Training and Testing Data For Recommendations\n",
        "\n",
        "**prior** to implement our recommendation $\\rightarrow$ look for a metric of our interest\n",
        "\n",
        "metric x time\n",
        "\n",
        "#### In Udacity text:\n",
        "\n",
        "\"In the last lesson, you were making recommendations by providing a list of popular items, or a list of items that the user hadn't observed but that someone with similar tastes had observed. However, understanding if these recommendations are good in practice means that you have to deploy these recommendations to users and see how it impacts your metrics (sales, higher engagement, clicks, conversions, etc.).\n",
        "\n",
        "You may not want your recommendations to go live to understand how well they work. In these cases, you will want to split your data into training and testing portions. In these cases, you can train your recommendation engine on a subset of the data, then you can test how well your recommendation engine performs on a test set of data before deploying your model to the world.\n",
        "\n",
        "However, the cases you saw in the last lesson, where just a list of recommendations was provided, don't actually lend themselves very well to training and testing methods of evaluation. In the next upcoming pages, you will be introduced to matrix factorization, which actually does work quite well for these situations.\"\n",
        "\n",
        "### Why to use SVD?\n",
        "\n",
        "#### Singular Value Decomposition\n",
        "\n",
        "Simon Funk $\\rightarrow$ FunkSVD\n",
        "\n",
        "\n",
        "#### In Udacity text:\n",
        "\n",
        "\"Singular Value Decomposition - If we let AA be our user-item matrix, we can write the decomposition of that matrix in the following way:\"\n",
        "\n",
        "$A = U \\Sigma V^T$\n",
        "\n",
        "Is a **Matrix Factorization** + **no** missing values (positive or negative)\n",
        "\n",
        "\n",
        "$U$ $\\rightarrow$ User ($n$) $\\times$ Latent Factor ($k$) $\\leftarrow$ how users are sensible to latent factors\n",
        "\n",
        "$V^T$ $\\rightarrow$ Latent Factor ($k$) $\\times$ Movie ($m$) $\\leftarrow$ how movies can provide some latent factors\n",
        "\n",
        "$\\Sigma$ is a $k \\times k$ largest to smallest diagonal matrix $\\leftarrow$ how much each latent factor weights to predict the rating (some were dropped down, as we restrict the size of $k$)\n",
        "\n",
        "#### In Udacity text:\n",
        "\n",
        "\"In the next part of this lesson, you will first get exposure to Singular Value Decomposition, or SVD. We will soon see why this technique falls short for many recommendation problems. However, understanding traditional SVD approaches to matrix factorization is useful as a start to a number of matrix factorization techniques that are possible in practice.\n",
        "\n",
        "In order to implement SVD for many recommendation engines, we will need to use a slightly modified approach known as FunkSVD. This approach proved to work incredibly well during the Netflix competition, and therefore, it is one of the most popular recommendation approaches in use today.\"\n",
        "\n",
        "\n",
        "#### Latent Factors\n",
        "\n",
        "is **not** a feature observed in your data (a movie is about robot-love, or kinky-sadism) $\\rightarrow$ there is a trigger between user-movie\n",
        "\n",
        "#### In Udacity text:\n",
        "\n",
        "\"When performing SVD, we create a matrix of users by items (or customers by movies in our specific example), with user ratings for each item scattered throughout the matrix. An example is shown in the image below.\n",
        "\n",
        "![latent factors](graphs\\latent.png)\n",
        "\n",
        "You can see that this matrix doesn't have any specific information about the users or items. Rather, it just holds the ratings that each user gave to each item. Using SVD on this matrix, we can find latent features related to the movies and customers. This is amazing because the dataset doesn't contain any information about the customers or movies!\""
      ],
      "id": "0dea6114"
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "e33b2e84"
      },
      "source": [
        "---\n",
        "\n",
        "## How to use Machine Learning to make recommendations?\n",
        "\n",
        "split data in Train (**fit**) x Test (**evaluate**)\n",
        "\n",
        "#### Validating Your Recommendations\n",
        "\n",
        "old data $\\rightarrow$ fit\n",
        "\n",
        "new data $\\rightarrow$ evaluate\n",
        "\n",
        "**SVD** techniques can provide a **rating** for every user x item pair (you predicted an **8** and it was an **8**)\n",
        "\n",
        "Metrics lie **MSE** (Mean Squared Error) or **MAE** (Mean Absolute Error)\n",
        "\n",
        "#### Online Testing\n",
        "\n",
        "#### In Udacity text:\n",
        "\"For online methods of testing a recommender's performance, many of the methods you saw in the previous lesson work very well - you can deploy your recommendations and just watch your metrics carefully. It is common in practice to set up online recommendations to have an \"old\" version of recommended items, which is compared to a new page that uses a new recommendation strategy.\n",
        "\n",
        "All ideas associated with A/B testing that you learned in the earlier lessons are critical to watching your metrics in online learning, and ultimately, choosing a recommendation strategy that works best for your products and customers.\"\n",
        "\n",
        "#### Offline Testing\n",
        "\n",
        "#### In Udacity text:\n",
        "\"In many cases, a company might not let you simply deploy your recommendations out into the real world any time you feel like it. Testing out your recommendations in a training-testing environment prior to deploying them is called offline testing.\n",
        "\n",
        "The recommendation methods you built in the previous lesson actually don't work very well for offline testing. In offline testing, it is ideal to not just obtain a list of recommendations for each individual, because we ultimately don't know if a user doesn't use an item because they don't like it, or because they just haven't used it yet (but would like it). Rather, it would be great if we have an idea of how much each user would like each item using a predicted rating. Then we can compare this predicted rating to the actual rating any individual gives to an item in the future.\n",
        "\n",
        "In the previous video, you saw an example of a user to whom we gave a list of movies that they still hadn't seen. Therefore, we couldn't tell how well we were doing with our recommendations. Techniques related to matrix factorization lend themselves nicely to solving this problem.\"\n",
        "\n",
        "#### User Groups\n",
        "\n",
        "#### In Udacity text:\n",
        "\"The final (possible) method of validating your recommendations is by having user groups give feedback on items you would recommend for them. Obtaining good user groups that are representative of your customers can be a challenge on its own. This is especially true when you have a lot of products and a very large consumer base.\""
      ],
      "id": "e33b2e84"
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6b20b0c5"
      },
      "source": [
        "---\n",
        "\n",
        "## How to make recommendations to individuals that are new in the platform?\n",
        "\n",
        "the **Cold Start Problem**"
      ],
      "id": "6b20b0c5"
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "220c06b6"
      },
      "source": [
        "---\n",
        "\n",
        "## Intro to SVD \n",
        "\n",
        "## First Notebook - L10 - Singular Value Decomposition"
      ],
      "id": "220c06b6"
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "e70ec1fd"
      },
      "source": [
        "### Singular Value Decomposition\n",
        "\n",
        "So far in this lesson, you have gained some exposure to Singular Value Decomposition.  In this notebook, you will get some hands on practice with this technique.\n",
        "\n",
        "Let's get started by reading in our libraries and setting up the data we will be using throughout this notebook\n",
        "\n",
        "`1.` Run the cell below to create the **user_movie_subset** dataframe.  This will be the dataframe you will be using for the first part of this notebook.\n",
        "\n",
        "**Note: Unstacking the matrix here could take ~10 mins to run.**"
      ],
      "id": "e70ec1fd"
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "yBEFLVErrYJP",
        "outputId": "871b19c3-9187-4b83-b49c-ceb2a8064cc8"
      },
      "source": [
        "from google.colab import drive\n",
        "drive.mount('/content/gdrive')"
      ],
      "id": "yBEFLVErrYJP",
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Mounted at /content/gdrive\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "enBw7M54upuj"
      },
      "source": [
        "#from pathlib import Path\n",
        "#patmy = Path('/content/gdrive/MyDrive/GoogleColab/DataScientistStudies3')"
      ],
      "id": "enBw7M54upuj",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "abqVP0HHruSY",
        "outputId": "069a2a78-c9dd-41ae-b16b-b4dc7c16c895"
      },
      "source": [
        "%ls /content/gdrive/MyDrive/GoogleColab/DataScientistStudies3"
      ],
      "id": "abqVP0HHruSY",
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\u001b[0m\u001b[01;34mdata\u001b[0m/                    L7StudiesNotesb.ipynb           svd_tests.py\n",
            "\u001b[01;34mgraphs\u001b[0m/                  LICENSE                         tests.py\n",
            "helper.py                \u001b[01;34moriginal_notebooks\u001b[0m/             udacourse3.py\n",
            "L2L3StudiesNotese.ipynb  README.md\n",
            "L5L6StudiesNotesm.ipynb  Recommendations_with_IBM.ipynb\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1uNeldmxsLQZ"
      },
      "source": [
        "!cp /content/gdrive/MyDrive/GoogleColab/DataScientistStudies3/svd_tests.py .\n",
        "!cp /content/gdrive/MyDrive/GoogleColab/DataScientistStudies3/udacourse3.py ."
      ],
      "id": "1uNeldmxsLQZ",
      "execution_count": 41,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yehMEVi5mYO-"
      },
      "source": [
        "#reloader for our functions library\n",
        "from importlib import reload \n",
        "import udacourse3\n",
        "\n",
        "udacourse3 = reload(udacourse3)"
      ],
      "id": "yehMEVi5mYO-",
      "execution_count": 42,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "77e9d0b4",
        "outputId": "e67e1241-b10e-485a-8511-9ec46f0bbbb9"
      },
      "source": [
        "import numpy as np\n",
        "import pandas as pd\n",
        "import matplotlib.pyplot as plt\n",
        "import seaborn as sns\n",
        "import pickle\n",
        "import svd_tests as t\n",
        "\n",
        "from time import time\n",
        "from scipy import sparse\n",
        "import udacourse3"
      ],
      "id": "77e9d0b4",
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/statsmodels/tools/_testing.py:19: FutureWarning: pandas.util.testing is deprecated. Use the functions in the public API at pandas.testing instead.\n",
            "  import pandas.util.testing as tm\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8f501f85"
      },
      "source": [
        "You need to reallocate the maximum pagination (at Advanced Options on Windows) to at least **16Gb** and restart your computer before running this!"
      ],
      "id": "8f501f85"
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ck7KqgUNwygW",
        "outputId": "fbc879b6-af9a-4459-9c67-390ca21eb328"
      },
      "source": [
        "%ls /content/gdrive/MyDrive/GoogleColab/DataScientistStudies3/data"
      ],
      "id": "ck7KqgUNwygW",
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "all_recs.p              movies.dat            statistical_significance_data.csv\n",
            "bootstrapping_data.csv  permutation_data.csv  train_data.csv\n",
            "ExperimentalDesign.txt  ratings.dat           user_matrix\n",
            "movie_matrix            reviews_clean.csv     validation_data.csv\n",
            "movies_clean.csv        signtest_data.csv\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "X0tOsKzpxZr4"
      },
      "source": [
        "!cp /content/gdrive/MyDrive/GoogleColab/DataScientistStudies3/data/movies_clean.csv .\n",
        "!cp /content/gdrive/MyDrive/GoogleColab/DataScientistStudies3/data/reviews_clean.csv ."
      ],
      "id": "X0tOsKzpxZr4",
      "execution_count": 6,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2c3798f5"
      },
      "source": [
        "# Read in the datasets\n",
        "movie = udacourse3.fn_read_data('movies_clean.csv', remove_noisy_cols=True)\n",
        "review = udacourse3.fn_read_data('reviews_clean.csv', remove_noisy_cols=True)"
      ],
      "id": "2c3798f5",
      "execution_count": 9,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "orvJZk0xDVED"
      },
      "source": [
        "---\n",
        "## For specific notebook"
      ],
      "id": "orvJZk0xDVED"
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "c43b4d18",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 159
        },
        "outputId": "686b3344-28e4-4550-dc3a-1c03dfc8bc0f"
      },
      "source": [
        "# Create user-by-item matrix\n",
        "begin=time()\n",
        "\n",
        "user_item = review[['user_id', 'movie_id', 'rating']]\n",
        "user_by_movie = user_item.groupby(['user_id', 'movie_id'])['rating'].max().unstack()\n",
        "\n",
        "user_movie_subset = user_by_movie[[73486, 75314, 68646, 99685]].dropna(axis=0)\n",
        "\n",
        "end=time()\n",
        "print('time spent:', end-begin)\n",
        "user_movie_subset.head(2)"
      ],
      "id": "c43b4d18",
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "time spent: -10.658522605895996\n"
          ]
        },
        {
          "output_type": "execute_result",
          "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>movie_id</th>\n",
              "      <th>73486</th>\n",
              "      <th>75314</th>\n",
              "      <th>68646</th>\n",
              "      <th>99685</th>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>user_id</th>\n",
              "      <th></th>\n",
              "      <th></th>\n",
              "      <th></th>\n",
              "      <th></th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>265</th>\n",
              "      <td>10.0</td>\n",
              "      <td>10.0</td>\n",
              "      <td>10.0</td>\n",
              "      <td>10.0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1023</th>\n",
              "      <td>10.0</td>\n",
              "      <td>4.0</td>\n",
              "      <td>9.0</td>\n",
              "      <td>10.0</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>"
            ],
            "text/plain": [
              "movie_id  73486  75314  68646  99685\n",
              "user_id                             \n",
              "265        10.0   10.0   10.0   10.0\n",
              "1023       10.0    4.0    9.0   10.0"
            ]
          },
          "metadata": {},
          "execution_count": 9
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "918327cc"
      },
      "source": [
        "`2.` Now that you have the **user_movie_subset** matrix, use this matrix to correctly match each key to the correct value in the dictionary below.  Use the cells below the dictionary as necessary."
      ],
      "id": "918327cc"
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "f15da25d",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "efa37bcb-b8f6-4367-ea5d-e9454d6a3ddc"
      },
      "source": [
        "# match each letter to the best statement in the dictionary below - each will be used at most once\n",
        "a = 20\n",
        "b = 68646\n",
        "c = 'The Godfather'\n",
        "d = 'Goodfellas'\n",
        "e = 265\n",
        "f = 30685\n",
        "g = 4\n",
        "\n",
        "sol_1_dict = {\n",
        "    'the number of users in the user_movie_subset': a,\n",
        "    'the number of movies in the user_movie_subset': g,\n",
        "    'the user_id with the highest average ratings given': e,\n",
        "    'the movie_id with the highest average ratings received': b,\n",
        "    'the name of the movie that received the highest average rating': c\n",
        "}\n",
        "\n",
        "#test dictionary here\n",
        "t.test1(sol_1_dict)"
      ],
      "id": "f15da25d",
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "That's right!  There are 20 users in the dataset, which is given by the number of rows. There are 4 movies in the dataset given by the number of columns.  You can find the movies or users with the highest average ratings by taking the mean of each row or column.  Using the movies table, you can find the movie names associated with each id.  This shows the top rated movie is The Godfather!\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "d97293fb",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "3f90fc04-b66d-4a57-85f9-e448059990ce"
      },
      "source": [
        "# Cell for work\n",
        "# user with the highest average rating\n",
        "print(user_movie_subset.mean(axis=1))\n",
        "\n",
        "# movie with highest average rating\n",
        "print(user_movie_subset.mean(axis=0))\n",
        "\n",
        "# list of movie names\n",
        "for movie_id in [73486, 75314,  68646, 99685]:\n",
        "    print(movie[movie['movie_id'] == movie_id]['movie'])\n",
        "    \n",
        "# users by movies\n",
        "user_movie_subset.shape"
      ],
      "id": "d97293fb",
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "user_id\n",
            "265      10.00\n",
            "1023      8.25\n",
            "1683      8.00\n",
            "6571      9.25\n",
            "11639     8.25\n",
            "13006     6.50\n",
            "14076     9.00\n",
            "14725     8.00\n",
            "23548     8.25\n",
            "24760     7.50\n",
            "28713     8.75\n",
            "30685     9.50\n",
            "34110     9.25\n",
            "34430     6.50\n",
            "35150     9.50\n",
            "43294     9.50\n",
            "46849     8.25\n",
            "50556     7.25\n",
            "51382     7.75\n",
            "51410     8.00\n",
            "dtype: float64\n",
            "movie_id\n",
            "73486    8.60\n",
            "75314    7.35\n",
            "68646    9.00\n",
            "99685    8.50\n",
            "dtype: float64\n",
            "4187    One Flew Over the Cuckoo's Nest (1975)\n",
            "Name: movie, dtype: object\n",
            "4361    Taxi Driver (1976)\n",
            "Name: movie, dtype: object\n",
            "3706    The Godfather (1972)\n",
            "Name: movie, dtype: object\n",
            "6917    Goodfellas (1990)\n",
            "Name: movie, dtype: object\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(20, 4)"
            ]
          },
          "metadata": {},
          "execution_count": 11
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cba59e0f"
      },
      "source": [
        "ow that you have a little more context about the matrix we will be performing Singular Value Decomposition on, we're going to do just that.  To get started, let's remind ourselves about the dimensions of each of the matrices we are going to get back.   Essentially, we are going to split the **user_movie_subset** matrix into three matrices:\n",
        "\n",
        "$$ U \\Sigma V^T $$\n",
        "\n",
        "\n",
        "`3.` Given what you learned about in the previous parts of this lesson, provide the dimensions for each of the matrices specified above using the dictionary below."
      ],
      "id": "cba59e0f"
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7aae1c5a",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "b10c7f89-3e26-4322-a330-31de5b3d2c7b"
      },
      "source": [
        "# match each letter in the dictionary below - a letter may appear more than once.\n",
        "a = 'a number that you can choose as the number of latent features to keep'\n",
        "b = 'the number of users'\n",
        "c = 'the number of movies'\n",
        "d = 'the sum of the number of users and movies'\n",
        "e = 'the product of the number of users and movies'\n",
        "\n",
        "sol_2_dict = {\n",
        "    'the number of rows in the U matrix': b, \n",
        "    'the number of columns in the U matrix': a, \n",
        "    'the number of rows in the V transpose matrix': a, \n",
        "    'the number of columns in the V transpose matrix': c\n",
        "}\n",
        "\n",
        "#test dictionary here\n",
        "t.test2(sol_2_dict)"
      ],
      "id": "7aae1c5a",
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "That's right!  We will now put this to use, so you can see how the dot product of these matrices come together to create our user item matrix.  The number of latent features will control the sigma matrix as well, and this will a square matrix that will at most be the minimum of the number of users and number of movies (in our case the minimum is the 4 movies).\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "96df1374"
      },
      "source": [
        "Now let's verify the above dimensions by performing SVD on our user-movie matrix.\n",
        "\n",
        "`4.` Below you can find the code used to perform SVD in numpy.  You can see more about this functionality in the [documentation here](https://docs.scipy.org/doc/numpy-1.13.0/reference/generated/numpy.linalg.svd.html).  What do you notice about the shapes of your matrices?  If you try to take the dot product of the three objects you get back, can you directly do this to get back the user-movie matrix?"
      ],
      "id": "96df1374"
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "60ca1b01",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "82620226-6d6a-455d-d3d4-8b9a3e26590a"
      },
      "source": [
        "u, s, vt = np.linalg.svd(user_movie_subset)\n",
        "s.shape, u.shape, vt.shape"
      ],
      "id": "60ca1b01",
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "((4,), (20, 20), (4, 4))"
            ]
          },
          "metadata": {},
          "execution_count": 13
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "c356074b",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "5f6ef66a-8bf6-4a4e-fdfb-d0eb4619fbbc"
      },
      "source": [
        "# Run this cell for our thoughts on the questions posted above\n",
        "t.question4thoughts()"
      ],
      "id": "c356074b",
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Looking at the dimensions of the three returned objects, we can see the following:\n",
            "\n",
            " 1. The u matrix is a square matrix with the number of rows and columns equaling the number of users. \n",
            "\n",
            " 2. The v transpose matrix is also a square matrix with the number of rows and columns equaling the number of items.\n",
            "\n",
            " 3. The sigma matrix is actually returned as just an array with 4 values, but should be a diagonal matrix.  Numpy has a diag method to help with this.  \n",
            "\n",
            " In order to set up the matrices in a way that they can be multiplied together, we have a few steps to perform: \n",
            "\n",
            " 1. Turn sigma into a square matrix with the number of latent features we would like to keep. \n",
            "\n",
            " 2. Change the columns of u and the rows of v transpose to match this number of dimensions. \n",
            "\n",
            " If we would like to exactly re-create the user-movie matrix, we could choose to keep all of the latent features.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "58efc79e"
      },
      "source": [
        "`5.` Use the thoughts from the above question to create u, s, and vt with four latent features.  When you have all three matrices created correctly, run the test below to show that the dot product of the three matrices creates the original user-movie matrix.  The matrices should have the following dimensions:\n",
        "\n",
        "$$ U_{n x k} $$\n",
        "\n",
        "$$\\Sigma_{k x k} $$\n",
        "\n",
        "$$V^T_{k x m} $$\n",
        "\n",
        "where:\n",
        "\n",
        "1. n is the number of users\n",
        "2. k is the number of latent features to keep (4 for this case)\n",
        "3. m is the number of movies"
      ],
      "id": "58efc79e"
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "430d3130"
      },
      "source": [
        "# Change the dimensions of u, s, and vt as necessary to use four latent features\n",
        "# update the shape of u and store in u_new\n",
        "u_new = u[:, :len(s)]\n",
        "\n",
        "# update the shape of s and store in s_new\n",
        "s_new = np.zeros((len(s), len(s)))\n",
        "s_new[:len(s), :len(s)] = np.diag(s) \n",
        "\n",
        "# Because we are using 4 latent features and there are only 4 movies, \n",
        "# vt and vt_new are the same\n",
        "vt_new = vt"
      ],
      "id": "430d3130",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6f645755",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "8fd449a7-607e-4315-925c-64382dcde34d"
      },
      "source": [
        "# Check your matrices against the solution\n",
        "assert u_new.shape == (20, 4),\\\n",
        "\"Oops!  The shape of the u matrix doesn't look right. It should be 20 by 4.\"\n",
        "assert s_new.shape == (4, 4),\\\n",
        "\"Oops!  The shape of the sigma matrix doesn't look right.  It should be 4 x 4.\"\n",
        "assert vt_new.shape == (4, 4),\\\n",
        "\"Oops! The shape of the v transpose matrix doesn't look right.  It should be 4 x 4.\"\n",
        "assert np.allclose(np.dot(np.dot(u_new, s_new), vt_new), user_movie_subset),\\\n",
        "\"Oops!  Something went wrong with the dot product.  Your result didn't reproduce the original movie_user matrix.\"\n",
        "print(\"That's right! The dimensions of u should be 20 x 4, and both v transpose and sigma should be 4 x 4\")\n",
        "print(\"The dot product of the three matrices how equals the original user-movie matrix!\")"
      ],
      "id": "6f645755",
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "That's right! The dimensions of u should be 20 x 4, and both v transpose and sigma should be 4 x 4\n",
            "The dot product of the three matrices how equals the original user-movie matrix!\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "d2c87ed9"
      },
      "source": [
        "It turns out that the sigma matrix can actually tell us how much of the original variability in the user-movie matrix is captured by each latent feature.  The total amount of variability to be explained is the sum of the squared diagonal elements.  The amount of variability explained by the first componenet is the square of the first value in the diagonal.  The amount of variability explained by the second componenet is the square of the second value in the diagonal.   \n",
        "\n",
        "`6.` Using the above information, can you determine the amount of variability in the original user-movie matrix that can be explained by only using the first two components? Use the cell below for your work, and then test your answer against the solution with the following cell."
      ],
      "id": "d2c87ed9"
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "35a1e139",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "398bbe90-c17b-49ad-f538-91d2ac3acfbb"
      },
      "source": [
        "total_var = np.sum(s**2)\n",
        "var_exp_comp1_and_comp2 = s[0]**2 + s[1]**2\n",
        "perc_exp = round(var_exp_comp1_and_comp2/total_var*100, 2)\n",
        "print(\"The total variance in the original matrix is {}.\".format(total_var))\n",
        "print(\"Ther percentage of variability captured by the first two components is {}%.\".format(perc_exp))"
      ],
      "id": "35a1e139",
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "The total variance in the original matrix is 5877.0.\n",
            "Ther percentage of variability captured by the first two components is 98.55%.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6091804f",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "c44fdebc-3756-41cc-eaef-ea69bfb3ac82"
      },
      "source": [
        "assert np.round(perc_exp, 2) == 98.55,\\\n",
        "\"Oops!  That doesn't look quite right.You should have total variability as the sum of all the squared elements in the sigma matrix.  Then just the sum of the squared first two elements is the amount explained by the first two latent features.  Try again.\"\n",
        "print(\"Yup!  That all looks good!\")"
      ],
      "id": "6091804f",
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Yup!  That all looks good!\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1b522a1a"
      },
      "source": [
        "`7.` Similar to in the previous question, change the shapes of your u, sigma, and v transpose matrices.  However, this time consider only using the first 2 components to reproduce the user-movie matrix instead of all 4. After you have your matrices set up, check your matrices against the solution by running the tests.  The matrices should have the following dimensions:\n",
        "\n",
        "$$ U_{n x k} $$\n",
        "\n",
        "$$\\Sigma_{k x k} $$\n",
        "\n",
        "$$V^T_{k x m} $$\n",
        "\n",
        "where:\n",
        "\n",
        "1. n is the number of users\n",
        "2. k is the number of latent features to keep (2 for this case)\n",
        "3. m is the number of movies"
      ],
      "id": "1b522a1a"
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8f3bf26c"
      },
      "source": [
        "# Change the dimensions of u, s, and vt as necessary to use four latent features\n",
        "# update the shape of u and store in u_new\n",
        "k = 2\n",
        "u_2 = u[:, :k]\n",
        "\n",
        "# update the shape of s and store in s_new\n",
        "s_2 = np.zeros((k, k))\n",
        "s_2[:k, :k] = np.diag(s[:k]) \n",
        "\n",
        "# Because we are using 2 latent features, we need to update vt this time\n",
        "vt_2 = vt[:k, :]"
      ],
      "id": "8f3bf26c",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "c58200ec",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "78ceaede-cbd8-42d4-ba16-d20029161e84"
      },
      "source": [
        "# Check that your matrices are the correct shapes\n",
        "assert u_2.shape == (20, 2),\\\n",
        "\"Oops!  The shape of the u matrix doesn't look right. It should be 20 by 2.\"\n",
        "assert s_2.shape == (2, 2),\\\n",
        "\"Oops!  The shape of the sigma matrix doesn't look right.  It should be 2 x 2.\"\n",
        "assert vt_2.shape == (2, 4),\\\n",
        "\"Oops! The shape of the v transpose matrix doesn't look right.  It should be 2 x 4.\"\n",
        "print(\"That's right! The dimensions of u should be 20 x 2, sigma should be 2 x 2, and v transpose should be 2 x 4\")\n",
        "print(\"The question is now that we don't have all of the latent features, how well can we really re-create\")\n",
        "print(\"the original user-movie matrix?\")"
      ],
      "id": "c58200ec",
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "That's right! The dimensions of u should be 20 x 2, sigma should be 2 x 2, and v transpose should be 2 x 4\n",
            "The question is now that we don't have all of the latent features, how well can we really re-create\n",
            "the original user-movie matrix?\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "d1deca2f"
      },
      "source": [
        "`8.` When using all 4 latent features, we saw that we could exactly reproduce the user-movie matrix.  Now that we only have 2 latent features, we might measure how well we are able to reproduce the original matrix by looking at the sum of squared errors from each rating produced by taking the dot product as compared to the actual rating.  Find the sum of squared error based on only the two latent features, and use the following cell to test against the solution. "
      ],
      "id": "d1deca2f"
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6f070204"
      },
      "source": [
        "# Compute the dot product\n",
        "pred_ratings = np.dot(np.dot(u_2, s_2), vt_2)\n",
        "\n",
        "# Compute the squared error for each predicted vs. actual rating\n",
        "sum_square_errs = np.sum(np.sum((user_movie_subset - pred_ratings)**2))"
      ],
      "id": "6f070204",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "c0381f70",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "a75d2dae-1669-4d36-8d13-803b5bbcd08b"
      },
      "source": [
        "# Check against the solution\n",
        "assert np.round(sum_square_errs, 2) == 85.34, \"Oops!  That doesn't look quite right.  You should return a single number for the whole matrix.\"\n",
        "print(\"That looks right!  Nice job!\")"
      ],
      "id": "c0381f70",
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "That looks right!  Nice job!\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ec4d017b"
      },
      "source": [
        "At this point, you may be thinking... why would we want to choose a k that doesn't just give us back the full user-movie matrix with all the original ratings.  This is a good question.  One reason might be for computational reasons - sure, you may want to reduce the dimensionality of the data you are keeping, but really this isn't the main reason we would want to perform reduce k to lesser than the minimum of the number of movies or users.\n",
        "\n",
        "Let's take a step back for a second.  In this example we just went through, your matrix was very clean.  That is, for every user-movie combination, we had a rating.  **There were no missing values.** But what we know from the previous lesson is that the user-movie matrix is full of missing values.  \n",
        "\n",
        "A matrix similar to the one we just performed SVD on:\n",
        "\n",
        "<img src=\"graphs/nice_ex.png\" width=\"400\" height=\"400\">\n",
        "\n",
        "The real world:\n",
        "\n",
        "<img src=\"graphs/real_ex.png\" width=\"400\" height=\"400\">\n",
        "\n",
        "\n",
        "Therefore, if we keep all k latent features it is likely that latent features with smaller values in the sigma matrix will explain variability that is probably due to noise and not signal. Furthermore, if we use these \"noisey\" latent features to assist in re-constructing the original user-movie matrix it will potentially (and likely) lead to worse ratings than if we only have latent features associated with signal.   \n",
        "\n",
        "`9.` Let's try introducing just a little of the real world into this example by performing SVD on a matrix with missing values.  Below I have added a new user to our matrix who hasn't rated all four of our movies.  Try performing SVD on the new matrix.  What happens?"
      ],
      "id": "ec4d017b"
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1a91cac9"
      },
      "source": [
        "A message will appear as:\n",
        "    \n",
        "`LinAlgError: SVD did not converge` "
      ],
      "id": "1a91cac9"
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "393f1832",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 231
        },
        "outputId": "62d1fbea-e7a5-472f-b6b2-1d3446c80ce3"
      },
      "source": [
        "# This line adds one nan value as the very first entry in our matrix\n",
        "user_movie_subset.iloc[0, 0] = np.nan\n",
        "\n",
        "# Try svd with this new matrix\n",
        "u, s, vt = np.linalg.svd(user_movie_subset)"
      ],
      "id": "393f1832",
      "execution_count": null,
      "outputs": [
        {
          "output_type": "error",
          "ename": "NameError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-2-5a75d7cf58da>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;31m# This line adds one nan value as the very first entry in our matrix\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0muser_movie_subset\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0miloc\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnan\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      3\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0;31m# Try svd with this new matrix\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[0mu\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0ms\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvt\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlinalg\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msvd\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0muser_movie_subset\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mNameError\u001b[0m: name 'np' is not defined"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "d20c7ecb"
      },
      "source": [
        "**Even with just one nan value we cannot perform SVD!  This is going to be a huge problem, because our real dataset has nan values everywhere!  This is where FunkSVD comes in to help.** "
      ],
      "id": "d20c7ecb"
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cf6e68c5"
      },
      "source": [
        "---\n",
        "\n",
        "## Intro to SVD \n",
        "\n",
        "## Second Notebook - L15 - Implementing FunkSVD\n",
        "\n",
        "#### Udacity notes:\n",
        "\n",
        "\"In this notebook we will take a look at writing our own function that performs FunkSVD, which will follow the steps you saw in the previous video.  If you find that you aren't ready to tackle this task on your own, feel free to skip to the following video where you can watch as I walk through the steps.\"\n",
        "\n",
        "To test our algorithm, we will run it on the subset of the data you worked with earlier.  Run the cell below to get started."
      ],
      "id": "cf6e68c5"
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "d0bab8c0",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "98f8283c-9ca4-42c5-ed18-5c12457ac726"
      },
      "source": [
        "begin=time()\n",
        "#Read in the datasets\n",
        "movie = udacourse3.fn_read_data('movies_clean.csv', remove_noisy_cols=True)\n",
        "review = udacourse3.fn_read_data('reviews_clean.csv', remove_noisy_cols=True)\n",
        "\n",
        "# Create user-by-item matrix\n",
        "user_items = review[['user_id', 'movie_id', 'rating', 'timestamp']]\n",
        "user_by_movie = user_items.groupby(['user_id', 'movie_id'])['rating'].max().unstack()\n",
        "\n",
        "# Create data subset\n",
        "user_movie_subset = user_by_movie[[73486, 75314,  68646, 99685]].dropna(axis=0)\n",
        "rating_mat = np.matrix(user_movie_subset)\n",
        "end=time()\n",
        "print('time spent:', end-begin)\n",
        "rating_mat"
      ],
      "id": "d0bab8c0",
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "time spent: 7.243285894393921\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "matrix([[10., 10., 10., 10.],\n",
              "        [10.,  4.,  9., 10.],\n",
              "        [ 8.,  9., 10.,  5.],\n",
              "        [ 9.,  8., 10., 10.],\n",
              "        [10.,  5.,  9.,  9.],\n",
              "        [ 6.,  4., 10.,  6.],\n",
              "        [ 9.,  8., 10.,  9.],\n",
              "        [10.,  5.,  9.,  8.],\n",
              "        [ 7.,  8., 10.,  8.],\n",
              "        [ 9.,  5.,  9.,  7.],\n",
              "        [ 9.,  8., 10.,  8.],\n",
              "        [ 9., 10., 10.,  9.],\n",
              "        [10.,  9., 10.,  8.],\n",
              "        [ 5.,  8.,  5.,  8.],\n",
              "        [10.,  8., 10., 10.],\n",
              "        [ 9.,  9., 10., 10.],\n",
              "        [ 9.,  8.,  8.,  8.],\n",
              "        [10.,  8.,  1., 10.],\n",
              "        [ 5.,  6., 10., 10.],\n",
              "        [ 8.,  7., 10.,  7.]])"
            ]
          },
          "metadata": {},
          "execution_count": 7
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "067b4efd"
      },
      "source": [
        "`1.` You will use the **user_movie_subset** matrix to show that your FunkSVD algorithm will converge.  In the below cell, use the comments and document string to assist you as you complete writing your own function to complete FunkSVD.  You may also want to try to complete the funtion on your own without the assistance of comments.  You may feel free to remove and add to the function in any way that gets you a working solution! \n",
        "\n",
        "**Notice:** There isn't a sigma matrix in this version of matrix factorization.\n",
        "\n",
        "function `fn_FunkSVD` created!"
      ],
      "id": "067b4efd"
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "a57f6dda"
      },
      "source": [
        "`2.` Try out your function on the **user_movie_subset** dataset.  First try 4 latent features, a learning rate of 0.005, and 10 iterations.  When you take the dot product of the resulting U and V matrices, how does the resulting **user_movie** matrix compare to the original subset of the data?"
      ],
      "id": "a57f6dda"
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "803480c9",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "eb3f3e6f-9e55-4e30-ce93-474cd107451f"
      },
      "source": [
        "user_mat, movie_mat = udacourse3.fn_FunkSVD(\n",
        "                        rating_mat=rating_mat, \n",
        "                        latent_feature=4, \n",
        "                        learning_rate=0.005, \n",
        "                        num_iter=10,\n",
        "                        verbose=True)"
      ],
      "id": "803480c9",
      "execution_count": 30,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "###function FunkSDV started\n",
            "number of users: 20\n",
            "number of movies: 4\n",
            "number of valid ratings: 79\n",
            "Optimizaiton Statistics\n",
            "Iteration Mean Squared Error\n",
            "  1       47.0336\n",
            "  2       17.4815\n",
            "  3       4.7291\n",
            "  4       2.9644\n",
            "  5       2.7946\n",
            "  6       2.7565\n",
            "  7       2.7358\n",
            "  8       2.7169\n",
            "  9       2.6965\n",
            " 10       2.6734\n",
            "elapsed time: 0.0255s (00:00:0.0255s)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "d85e0dd5",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "c440d759-ec92-44ef-ee87-33d98679019d"
      },
      "source": [
        "print(np.dot(user_mat, movie_mat))\n",
        "print(rating_mat)"
      ],
      "id": "d85e0dd5",
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[10.0479878   8.87246196 10.51732358 10.24397654]\n",
            " [ 8.68183717  7.20811603  8.87570913  9.08982966]\n",
            " [ 7.77219217  7.05385187  8.37242259  7.6440144 ]\n",
            " [ 9.7356348   8.16457729  9.81244213  9.75149872]\n",
            " [ 8.76186393  7.3328852   8.87044476  8.56329042]\n",
            " [ 6.79822539  6.04766005  7.28043482  6.80179909]\n",
            " [ 9.42381555  8.02439959  9.57946788  9.17939085]\n",
            " [ 8.30759651  7.24556641  8.68488894  8.0376918 ]\n",
            " [ 8.47763219  7.76453366  9.09194749  8.14287574]\n",
            " [ 7.77321148  6.75411772  8.03316793  7.61884992]\n",
            " [ 9.02212402  8.1016081   9.42371448  8.496327  ]\n",
            " [ 9.81172459  8.52194624 10.06310113  9.35853524]\n",
            " [ 9.01085556  8.34387918  9.89038147  9.09683842]\n",
            " [ 6.59833477  6.10551032  7.13312072  6.31222798]\n",
            " [ 9.7161677   8.59577647 10.16193844  9.75859022]\n",
            " [ 9.621073    8.12340597 10.01267351 10.2129507 ]\n",
            " [ 8.10032893  7.11842416  8.61735771  8.53973922]\n",
            " [ 7.25331981  5.84897872  7.23119329  7.41332491]\n",
            " [ 8.30740382  7.24432175  8.76667183  8.51245611]\n",
            " [ 8.07650583  7.17981551  8.57563113  8.06728965]]\n",
            "[[10. 10. 10. 10.]\n",
            " [10.  4.  9. 10.]\n",
            " [ 8.  9. 10.  5.]\n",
            " [ 9.  8. 10. 10.]\n",
            " [10.  5.  9.  9.]\n",
            " [ 6.  4. 10.  6.]\n",
            " [ 9.  8. 10.  9.]\n",
            " [10.  5.  9.  8.]\n",
            " [ 7.  8. 10.  8.]\n",
            " [ 9.  5.  9.  7.]\n",
            " [ 9.  8. 10.  8.]\n",
            " [ 9. 10. 10.  9.]\n",
            " [10.  9. 10.  8.]\n",
            " [ 5.  8.  5.  8.]\n",
            " [10.  8. 10. 10.]\n",
            " [ 9.  9. 10. 10.]\n",
            " [ 9.  8.  8.  8.]\n",
            " [10.  8.  1. 10.]\n",
            " [ 5.  6. 10. 10.]\n",
            " [ 8.  7. 10.  7.]]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1b3064ab"
      },
      "source": [
        "**The predicted ratings from the dot product are already starting to look a lot like the original data values even after only 10 iterations.  You can see some extreme low values that are not captured well yet.  The 5 in the second to last row in the first column is predicted as an 8, and the 4 in the second row and second column is predicted to be a 7.  Clearly the model is not done learning, but things are looking good.**"
      ],
      "id": "1b3064ab"
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "330be1f6"
      },
      "source": [
        "`3.` Let's try out the function again on the **user_movie_subset** dataset.  This time we will again use 4 latent features and a learning rate of 0.005.  However, let's bump up the number of iterations to 250.  When you take the dot product of the resulting U and V matrices, how does the resulting **user_movie** matrix compare to the original subset of the data?  What do you notice about your error at the end of the 250 iterations?"
      ],
      "id": "330be1f6"
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "47599f2a",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "02d1ff5b-5568-44c6-e144-c90cd6bb6e36"
      },
      "source": [
        "user_mat, movie_mat = udacourse3.fn_FunkSVD(\n",
        "                        rating_mat=rating_mat, \n",
        "                        latent_feature=4, \n",
        "                        learning_rate=0.005, \n",
        "                        num_iter=250,\n",
        "                        verbose=True)"
      ],
      "id": "47599f2a",
      "execution_count": 31,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "###function FunkSDV started\n",
            "number of users: 20\n",
            "number of movies: 4\n",
            "number of valid ratings: 79\n",
            "Optimizaiton Statistics\n",
            "Iteration Mean Squared Error\n",
            "  1       40.3210\n",
            "  2       13.0213\n",
            "  3       3.9047\n",
            "  4       2.8719\n",
            "  5       2.7253\n",
            "  6       2.6681\n",
            "  7       2.6281\n",
            "  8       2.5894\n",
            "  9       2.5477\n",
            " 10       2.5011\n",
            " 11       2.4485\n",
            " 12       2.3891\n",
            " 13       2.3222\n",
            " 14       2.2471\n",
            " 15       2.1635\n",
            " 16       2.0713\n",
            " 17       1.9710\n",
            " 18       1.8632\n",
            " 19       1.7495\n",
            " 20       1.6315\n",
            " 21       1.5115\n",
            " 22       1.3920\n",
            " 23       1.2755\n",
            " 24       1.1643\n",
            " 25       1.0600\n",
            " 26       0.9640\n",
            " 27       0.8767\n",
            " 28       0.7982\n",
            " 29       0.7279\n",
            " 30       0.6651\n",
            " 31       0.6089\n",
            " 32       0.5584\n",
            " 33       0.5125\n",
            " 34       0.4706\n",
            " 35       0.4320\n",
            " 36       0.3961\n",
            " 37       0.3626\n",
            " 38       0.3312\n",
            " 39       0.3017\n",
            " 40       0.2739\n",
            " 41       0.2478\n",
            " 42       0.2233\n",
            " 43       0.2004\n",
            " 44       0.1792\n",
            " 45       0.1595\n",
            " 46       0.1414\n",
            " 47       0.1249\n",
            " 48       0.1099\n",
            " 49       0.0963\n",
            " 50       0.0842\n",
            " 51       0.0734\n",
            " 52       0.0638\n",
            " 53       0.0554\n",
            " 54       0.0480\n",
            " 55       0.0415\n",
            " 56       0.0359\n",
            " 57       0.0310\n",
            " 58       0.0268\n",
            " 59       0.0231\n",
            " 60       0.0200\n",
            " 61       0.0173\n",
            " 62       0.0149\n",
            " 63       0.0129\n",
            " 64       0.0112\n",
            " 65       0.0097\n",
            " 66       0.0085\n",
            " 67       0.0073\n",
            " 68       0.0064\n",
            " 69       0.0056\n",
            " 70       0.0049\n",
            " 71       0.0042\n",
            " 72       0.0037\n",
            " 73       0.0032\n",
            " 74       0.0028\n",
            " 75       0.0025\n",
            " 76       0.0022\n",
            " 77       0.0019\n",
            " 78       0.0017\n",
            " 79       0.0015\n",
            " 80       0.0013\n",
            " 81       0.0011\n",
            " 82       0.0010\n",
            " 83       0.0009\n",
            " 84       0.0008\n",
            " 85       0.0007\n",
            " 86       0.0006\n",
            " 87       0.0005\n",
            " 88       0.0005\n",
            " 89       0.0004\n",
            " 90       0.0004\n",
            " 91       0.0003\n",
            " 92       0.0003\n",
            " 93       0.0002\n",
            " 94       0.0002\n",
            " 95       0.0002\n",
            " 96       0.0002\n",
            " 97       0.0002\n",
            " 98       0.0001\n",
            " 99       0.0001\n",
            "100       0.0001\n",
            "101       0.0001\n",
            "102       0.0001\n",
            "103       0.0001\n",
            "104       0.0001\n",
            "105       0.0001\n",
            "106       0.0000\n",
            "107       0.0000\n",
            "108       0.0000\n",
            "109       0.0000\n",
            "110       0.0000\n",
            "111       0.0000\n",
            "112       0.0000\n",
            "113       0.0000\n",
            "114       0.0000\n",
            "115       0.0000\n",
            "116       0.0000\n",
            "117       0.0000\n",
            "118       0.0000\n",
            "119       0.0000\n",
            "120       0.0000\n",
            "121       0.0000\n",
            "122       0.0000\n",
            "123       0.0000\n",
            "124       0.0000\n",
            "125       0.0000\n",
            "126       0.0000\n",
            "127       0.0000\n",
            "128       0.0000\n",
            "129       0.0000\n",
            "130       0.0000\n",
            "131       0.0000\n",
            "132       0.0000\n",
            "133       0.0000\n",
            "134       0.0000\n",
            "135       0.0000\n",
            "136       0.0000\n",
            "137       0.0000\n",
            "138       0.0000\n",
            "139       0.0000\n",
            "140       0.0000\n",
            "141       0.0000\n",
            "142       0.0000\n",
            "143       0.0000\n",
            "144       0.0000\n",
            "145       0.0000\n",
            "146       0.0000\n",
            "147       0.0000\n",
            "148       0.0000\n",
            "149       0.0000\n",
            "150       0.0000\n",
            "151       0.0000\n",
            "152       0.0000\n",
            "153       0.0000\n",
            "154       0.0000\n",
            "155       0.0000\n",
            "156       0.0000\n",
            "157       0.0000\n",
            "158       0.0000\n",
            "159       0.0000\n",
            "160       0.0000\n",
            "161       0.0000\n",
            "162       0.0000\n",
            "163       0.0000\n",
            "164       0.0000\n",
            "165       0.0000\n",
            "166       0.0000\n",
            "167       0.0000\n",
            "168       0.0000\n",
            "169       0.0000\n",
            "170       0.0000\n",
            "171       0.0000\n",
            "172       0.0000\n",
            "173       0.0000\n",
            "174       0.0000\n",
            "175       0.0000\n",
            "176       0.0000\n",
            "177       0.0000\n",
            "178       0.0000\n",
            "179       0.0000\n",
            "180       0.0000\n",
            "181       0.0000\n",
            "182       0.0000\n",
            "183       0.0000\n",
            "184       0.0000\n",
            "185       0.0000\n",
            "186       0.0000\n",
            "187       0.0000\n",
            "188       0.0000\n",
            "189       0.0000\n",
            "190       0.0000\n",
            "191       0.0000\n",
            "192       0.0000\n",
            "193       0.0000\n",
            "194       0.0000\n",
            "195       0.0000\n",
            "196       0.0000\n",
            "197       0.0000\n",
            "198       0.0000\n",
            "199       0.0000\n",
            "200       0.0000\n",
            "201       0.0000\n",
            "202       0.0000\n",
            "203       0.0000\n",
            "204       0.0000\n",
            "205       0.0000\n",
            "206       0.0000\n",
            "207       0.0000\n",
            "208       0.0000\n",
            "209       0.0000\n",
            "210       0.0000\n",
            "211       0.0000\n",
            "212       0.0000\n",
            "213       0.0000\n",
            "214       0.0000\n",
            "215       0.0000\n",
            "216       0.0000\n",
            "217       0.0000\n",
            "218       0.0000\n",
            "219       0.0000\n",
            "220       0.0000\n",
            "221       0.0000\n",
            "222       0.0000\n",
            "223       0.0000\n",
            "224       0.0000\n",
            "225       0.0000\n",
            "226       0.0000\n",
            "227       0.0000\n",
            "228       0.0000\n",
            "229       0.0000\n",
            "230       0.0000\n",
            "231       0.0000\n",
            "232       0.0000\n",
            "233       0.0000\n",
            "234       0.0000\n",
            "235       0.0000\n",
            "236       0.0000\n",
            "237       0.0000\n",
            "238       0.0000\n",
            "239       0.0000\n",
            "240       0.0000\n",
            "241       0.0000\n",
            "242       0.0000\n",
            "243       0.0000\n",
            "244       0.0000\n",
            "245       0.0000\n",
            "246       0.0000\n",
            "247       0.0000\n",
            "248       0.0000\n",
            "249       0.0000\n",
            "250       0.0000\n",
            "elapsed time: 0.5924s (00:00:0.5924s)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "12bd5801",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "eeba0912-90de-458f-f2ff-ec6ad7528cad"
      },
      "source": [
        "print(np.dot(user_mat, movie_mat))\n",
        "print(rating_mat)"
      ],
      "id": "12bd5801",
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[10.00000029 10.00000014 10.00000008  9.9999997 ]\n",
            " [ 9.9999991   3.99999936  8.99999968 10.00000112]\n",
            " [ 7.99999976  8.99999987  9.99999995  5.00000026]\n",
            " [ 8.99999863  7.99999916  9.99999959 10.0000016 ]\n",
            " [10.00000102  5.00000079  9.0000004   8.99999871]\n",
            " [ 5.99999828  3.99999876  9.99999942  6.00000216]\n",
            " [ 8.9999994   7.99999978  9.99999991  9.0000006 ]\n",
            " [10.00000115  5.00000084  9.00000043  7.9999986 ]\n",
            " [ 7.00000147  8.00000107 10.00000054  7.99999818]\n",
            " [ 9.00000162  5.00000101  9.0000005   6.99999811]\n",
            " [ 9.00000205  8.00000146 10.00000069  7.99999743]\n",
            " [ 9.00000041 10.00000036 10.00000012  8.99999937]\n",
            " [10.0000002   8.99999998  9.99999996  7.99999983]\n",
            " [ 5.00000148  8.00000094  5.00000044  7.99999823]\n",
            " [ 9.99999903  7.99999933  9.99999961 10.00000111]\n",
            " [ 8.99999784  8.9999984   9.9999992  10.00000268]\n",
            " [ 8.99999862  7.99999905  7.99999953  8.00000167]\n",
            " [ 9.99999997  7.99999998  1.         10.00000004]\n",
            " [ 5.00000082  6.00000056 10.00000029  9.99999902]\n",
            " [ 7.99999985  6.99999986  9.99999994  7.00000022]]\n",
            "[[10. 10. 10. 10.]\n",
            " [10.  4.  9. 10.]\n",
            " [ 8.  9. 10.  5.]\n",
            " [ 9.  8. 10. 10.]\n",
            " [10.  5.  9.  9.]\n",
            " [ 6.  4. 10.  6.]\n",
            " [ 9.  8. 10.  9.]\n",
            " [10.  5.  9.  8.]\n",
            " [ 7.  8. 10.  8.]\n",
            " [ 9.  5.  9.  7.]\n",
            " [ 9.  8. 10.  8.]\n",
            " [ 9. 10. 10.  9.]\n",
            " [10.  9. 10.  8.]\n",
            " [ 5.  8.  5.  8.]\n",
            " [10.  8. 10. 10.]\n",
            " [ 9.  9. 10. 10.]\n",
            " [ 9.  8.  8.  8.]\n",
            " [10.  8.  1. 10.]\n",
            " [ 5.  6. 10. 10.]\n",
            " [ 8.  7. 10.  7.]]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5d5cfaf4"
      },
      "source": [
        "**In this case, we were able to completely reconstruct the item-movie matrix to obtain an essentially 0 mean squared error. I obtained 0 MSE on iteration 165.**"
      ],
      "id": "5d5cfaf4"
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8e2551d1"
      },
      "source": [
        "The last time we placed an **np.nan** value into this matrix the entire svd algorithm in python broke.  Let's see if that is still the case using your FunkSVD function.  In the below cell, I have placed a nan into the first cell of your numpy array.  \n",
        "\n",
        "`4.` Use 4 latent features, a learning rate of 0.005, and 250 iterations.  Are you able to run your SVD without it breaking (something that was not true about the python built in)?  Do you get a prediction for the nan value?  What is your prediction for the missing value? Use the cells below to answer these questions."
      ],
      "id": "8e2551d1"
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "97d8855a",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "13537af3-dd34-4aac-ba41-abd03bc83d1a"
      },
      "source": [
        "rating_mat[0, 0] = np.nan\n",
        "rating_mat"
      ],
      "id": "97d8855a",
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "matrix([[nan, 10., 10., 10.],\n",
              "        [10.,  4.,  9., 10.],\n",
              "        [ 8.,  9., 10.,  5.],\n",
              "        [ 9.,  8., 10., 10.],\n",
              "        [10.,  5.,  9.,  9.],\n",
              "        [ 6.,  4., 10.,  6.],\n",
              "        [ 9.,  8., 10.,  9.],\n",
              "        [10.,  5.,  9.,  8.],\n",
              "        [ 7.,  8., 10.,  8.],\n",
              "        [ 9.,  5.,  9.,  7.],\n",
              "        [ 9.,  8., 10.,  8.],\n",
              "        [ 9., 10., 10.,  9.],\n",
              "        [10.,  9., 10.,  8.],\n",
              "        [ 5.,  8.,  5.,  8.],\n",
              "        [10.,  8., 10., 10.],\n",
              "        [ 9.,  9., 10., 10.],\n",
              "        [ 9.,  8.,  8.,  8.],\n",
              "        [10.,  8.,  1., 10.],\n",
              "        [ 5.,  6., 10., 10.],\n",
              "        [ 8.,  7., 10.,  7.]])"
            ]
          },
          "metadata": {},
          "execution_count": 13
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1733a283",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "a4ae9ddc-2aa6-4a4e-cf7c-81520483b1ab"
      },
      "source": [
        "# run SVD on the matrix with the missing value\n",
        "user_mat, movie_mat = udacourse3.fn_FunkSVD(\n",
        "                        rating_mat=rating_mat, \n",
        "                        latent_feature=4, \n",
        "                        learning_rate=0.005, \n",
        "                        num_iter=250,\n",
        "                        verbose=True)"
      ],
      "id": "1733a283",
      "execution_count": 32,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "###function FunkSDV started\n",
            "number of users: 20\n",
            "number of movies: 4\n",
            "number of valid ratings: 79\n",
            "Optimizaiton Statistics\n",
            "Iteration Mean Squared Error\n",
            "  1       46.4930\n",
            "  2       17.5340\n",
            "  3       4.7729\n",
            "  4       2.9580\n",
            "  5       2.7496\n",
            "  6       2.6836\n",
            "  7       2.6420\n",
            "  8       2.6052\n",
            "  9       2.5674\n",
            " 10       2.5263\n",
            " 11       2.4807\n",
            " 12       2.4296\n",
            " 13       2.3722\n",
            " 14       2.3078\n",
            " 15       2.2358\n",
            " 16       2.1556\n",
            " 17       2.0669\n",
            " 18       1.9697\n",
            " 19       1.8641\n",
            " 20       1.7507\n",
            " 21       1.6306\n",
            " 22       1.5053\n",
            " 23       1.3766\n",
            " 24       1.2467\n",
            " 25       1.1183\n",
            " 26       0.9938\n",
            " 27       0.8756\n",
            " 28       0.7655\n",
            " 29       0.6650\n",
            " 30       0.5749\n",
            " 31       0.4954\n",
            " 32       0.4262\n",
            " 33       0.3664\n",
            " 34       0.3152\n",
            " 35       0.2715\n",
            " 36       0.2342\n",
            " 37       0.2024\n",
            " 38       0.1751\n",
            " 39       0.1518\n",
            " 40       0.1317\n",
            " 41       0.1144\n",
            " 42       0.0994\n",
            " 43       0.0864\n",
            " 44       0.0752\n",
            " 45       0.0654\n",
            " 46       0.0569\n",
            " 47       0.0496\n",
            " 48       0.0432\n",
            " 49       0.0377\n",
            " 50       0.0328\n",
            " 51       0.0287\n",
            " 52       0.0250\n",
            " 53       0.0219\n",
            " 54       0.0191\n",
            " 55       0.0168\n",
            " 56       0.0147\n",
            " 57       0.0129\n",
            " 58       0.0113\n",
            " 59       0.0100\n",
            " 60       0.0088\n",
            " 61       0.0077\n",
            " 62       0.0068\n",
            " 63       0.0060\n",
            " 64       0.0053\n",
            " 65       0.0047\n",
            " 66       0.0041\n",
            " 67       0.0037\n",
            " 68       0.0032\n",
            " 69       0.0029\n",
            " 70       0.0025\n",
            " 71       0.0023\n",
            " 72       0.0020\n",
            " 73       0.0018\n",
            " 74       0.0016\n",
            " 75       0.0014\n",
            " 76       0.0012\n",
            " 77       0.0011\n",
            " 78       0.0010\n",
            " 79       0.0009\n",
            " 80       0.0008\n",
            " 81       0.0007\n",
            " 82       0.0006\n",
            " 83       0.0005\n",
            " 84       0.0005\n",
            " 85       0.0004\n",
            " 86       0.0004\n",
            " 87       0.0003\n",
            " 88       0.0003\n",
            " 89       0.0003\n",
            " 90       0.0002\n",
            " 91       0.0002\n",
            " 92       0.0002\n",
            " 93       0.0002\n",
            " 94       0.0002\n",
            " 95       0.0001\n",
            " 96       0.0001\n",
            " 97       0.0001\n",
            " 98       0.0001\n",
            " 99       0.0001\n",
            "100       0.0001\n",
            "101       0.0001\n",
            "102       0.0001\n",
            "103       0.0001\n",
            "104       0.0000\n",
            "105       0.0000\n",
            "106       0.0000\n",
            "107       0.0000\n",
            "108       0.0000\n",
            "109       0.0000\n",
            "110       0.0000\n",
            "111       0.0000\n",
            "112       0.0000\n",
            "113       0.0000\n",
            "114       0.0000\n",
            "115       0.0000\n",
            "116       0.0000\n",
            "117       0.0000\n",
            "118       0.0000\n",
            "119       0.0000\n",
            "120       0.0000\n",
            "121       0.0000\n",
            "122       0.0000\n",
            "123       0.0000\n",
            "124       0.0000\n",
            "125       0.0000\n",
            "126       0.0000\n",
            "127       0.0000\n",
            "128       0.0000\n",
            "129       0.0000\n",
            "130       0.0000\n",
            "131       0.0000\n",
            "132       0.0000\n",
            "133       0.0000\n",
            "134       0.0000\n",
            "135       0.0000\n",
            "136       0.0000\n",
            "137       0.0000\n",
            "138       0.0000\n",
            "139       0.0000\n",
            "140       0.0000\n",
            "141       0.0000\n",
            "142       0.0000\n",
            "143       0.0000\n",
            "144       0.0000\n",
            "145       0.0000\n",
            "146       0.0000\n",
            "147       0.0000\n",
            "148       0.0000\n",
            "149       0.0000\n",
            "150       0.0000\n",
            "151       0.0000\n",
            "152       0.0000\n",
            "153       0.0000\n",
            "154       0.0000\n",
            "155       0.0000\n",
            "156       0.0000\n",
            "157       0.0000\n",
            "158       0.0000\n",
            "159       0.0000\n",
            "160       0.0000\n",
            "161       0.0000\n",
            "162       0.0000\n",
            "163       0.0000\n",
            "164       0.0000\n",
            "165       0.0000\n",
            "166       0.0000\n",
            "167       0.0000\n",
            "168       0.0000\n",
            "169       0.0000\n",
            "170       0.0000\n",
            "171       0.0000\n",
            "172       0.0000\n",
            "173       0.0000\n",
            "174       0.0000\n",
            "175       0.0000\n",
            "176       0.0000\n",
            "177       0.0000\n",
            "178       0.0000\n",
            "179       0.0000\n",
            "180       0.0000\n",
            "181       0.0000\n",
            "182       0.0000\n",
            "183       0.0000\n",
            "184       0.0000\n",
            "185       0.0000\n",
            "186       0.0000\n",
            "187       0.0000\n",
            "188       0.0000\n",
            "189       0.0000\n",
            "190       0.0000\n",
            "191       0.0000\n",
            "192       0.0000\n",
            "193       0.0000\n",
            "194       0.0000\n",
            "195       0.0000\n",
            "196       0.0000\n",
            "197       0.0000\n",
            "198       0.0000\n",
            "199       0.0000\n",
            "200       0.0000\n",
            "201       0.0000\n",
            "202       0.0000\n",
            "203       0.0000\n",
            "204       0.0000\n",
            "205       0.0000\n",
            "206       0.0000\n",
            "207       0.0000\n",
            "208       0.0000\n",
            "209       0.0000\n",
            "210       0.0000\n",
            "211       0.0000\n",
            "212       0.0000\n",
            "213       0.0000\n",
            "214       0.0000\n",
            "215       0.0000\n",
            "216       0.0000\n",
            "217       0.0000\n",
            "218       0.0000\n",
            "219       0.0000\n",
            "220       0.0000\n",
            "221       0.0000\n",
            "222       0.0000\n",
            "223       0.0000\n",
            "224       0.0000\n",
            "225       0.0000\n",
            "226       0.0000\n",
            "227       0.0000\n",
            "228       0.0000\n",
            "229       0.0000\n",
            "230       0.0000\n",
            "231       0.0000\n",
            "232       0.0000\n",
            "233       0.0000\n",
            "234       0.0000\n",
            "235       0.0000\n",
            "236       0.0000\n",
            "237       0.0000\n",
            "238       0.0000\n",
            "239       0.0000\n",
            "240       0.0000\n",
            "241       0.0000\n",
            "242       0.0000\n",
            "243       0.0000\n",
            "244       0.0000\n",
            "245       0.0000\n",
            "246       0.0000\n",
            "247       0.0000\n",
            "248       0.0000\n",
            "249       0.0000\n",
            "250       0.0000\n",
            "elapsed time: 0.5695s (00:00:0.5695s)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "55dbe5f5",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "2e61692a-24e4-48c2-f031-64bd868c92a3"
      },
      "source": [
        "preds = np.dot(user_mat, movie_mat)\n",
        "print(\"The predicted value for the missing rating is {}:\".format(preds[0,0]))\n",
        "print()\n",
        "print(\"The actual value for the missing rating is {}:\".format(rating_mat[0,0]))\n",
        "print()\n",
        "assert np.isnan(preds[0,0]) == False\n",
        "print(\"That's right! You just predicted a rating for a user-movie pair that was never rated!\")\n",
        "print(\"But if you look in the original matrix, this was actually a value of 10. Not bad!\")"
      ],
      "id": "55dbe5f5",
      "execution_count": 33,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "The predicted value for the missing rating is 10.5865223103412:\n",
            "\n",
            "The actual value for the missing rating is nan:\n",
            "\n",
            "That's right! You just predicted a rating for a user-movie pair that was never rated!\n",
            "But if you look in the original matrix, this was actually a value of 10. Not bad!\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "61220b4e"
      },
      "source": [
        "Now let's extend this to a more realistic example. Unfortunately, running this function on your entire user-movie matrix is still not something you likely want to do on your local machine.  However, we can see how well this example extends to 1000 users.  In the above portion, you were using a very small subset of data with no missing values.\n",
        "\n",
        "`5.` Given the size of this matrix, this will take quite a bit of time.  Consider the following hyperparameters: 4 latent features, 0.005 learning rate, and 20 iterations.  Grab a snack, take a walk, and this should be done running in a bit."
      ],
      "id": "61220b4e"
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "V405ge1LUn04",
        "outputId": "3cd02e63-fa13-40ef-cb39-673a4cf58220"
      },
      "source": [
        "#https://stackoverflow.com/questions/27779677/how-to-format-elapsed-time-from-seconds-to-hours-minutes-seconds-and-milliseco\n",
        "#begin=time()\n",
        "#a = 0\n",
        "#for i in range (0,2000000000):\n",
        "#    a =+ 1\n",
        "#spend=time()-begin\n",
        "\n",
        "#hour, remain = divmod(spend, 3600)\n",
        "#minute, second = divmod(remain, 60)\n",
        "#print(spend)\n",
        "#print(\"{:0>2}:{:0>2}:{:05.2f}\".format(int(hour),int(minute),second))"
      ],
      "id": "V405ge1LUn04",
      "execution_count": 23,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "114.95333433151245\n",
            "00:01:54.95\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "983e2236",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "93e2101b-98d1-48da-8aa0-9ae416f7beb2"
      },
      "source": [
        "#begin=time()\n",
        "# Setting up a matrix of the first 1000 users with movie ratings\n",
        "first_1000_user = np.matrix(user_by_movie.head(1000))\n",
        "\n",
        "# perform funkSVD on the matrix of the top 1000 users\n",
        "user_mat, movie_mat = udacourse3.fn_FunkSVD(\n",
        "                          rating_mat=first_1000_user, \n",
        "                          latent_feature=4, \n",
        "                          learning_rate=0.005, \n",
        "                          num_iter=20,\n",
        "                          verbose=True)\n",
        "#spend_time=time()-begin\n",
        "#hour, remain = divmod(spend, 3600)\n",
        "#minute, second = divmod(remain, 60)\n",
        "#print(\"{:0>2}:{:0>2}:{:05.2f}\".format(int(hour),int(minute),second))"
      ],
      "id": "983e2236",
      "execution_count": 35,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "###function FunkSDV started\n",
            "number of users: 1000\n",
            "number of movies: 31245\n",
            "number of valid ratings: 10852\n",
            "Optimizaiton Statistics\n",
            "Iteration Mean Squared Error\n",
            "  1       23.6762\n",
            "  2       10.8570\n",
            "  3       7.4245\n",
            "  4       5.7222\n",
            "  5       4.6490\n",
            "  6       3.8982\n",
            "  7       3.3401\n",
            "  8       2.9080\n",
            "  9       2.5636\n",
            " 10       2.2832\n",
            " 11       2.0513\n",
            " 12       1.8574\n",
            " 13       1.6938\n",
            " 14       1.5548\n",
            " 15       1.4361\n",
            " 16       1.3343\n",
            " 17       1.2466\n",
            " 18       1.1709\n",
            " 19       1.1051\n",
            " 20       1.0477\n",
            "elapsed time: 735.7977s (00:12:15.7977s)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "aea3af80"
      },
      "source": [
        "`6.` Now that you have a set of predictions for each user-movie pair.  Let's answer a few questions about your results. Provide the correct values to each of the variables below, and check your solutions using the tests below."
      ],
      "id": "aea3af80"
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "248e24a8",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "c12ae40b-ce7c-4a87-88e2-7e97394f0f4b"
      },
      "source": [
        "# How many actual ratings exist in first_1000_users\n",
        "num_rating = np.count_nonzero(~np.isnan(first_1000_user))\n",
        "print(\"The number of actual ratings in the first_1000_users is {}.\".format(num_rating))\n",
        "print()\n",
        "\n",
        "# How many ratings did we make for user-movie pairs that didn't have ratings\n",
        "rating_for_missing = first_1000_user.shape[0]*first_1000_user.shape[1] - num_rating\n",
        "print(\"The number of ratings made for user-movie pairs that didn't have ratings is {}\".format(rating_for_missing))"
      ],
      "id": "248e24a8",
      "execution_count": 24,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "The number of actual ratings in the first_1000_users is 10852.\n",
            "\n",
            "The number of ratings made for user-movie pairs that didn't have ratings is 31234148\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9eddaa36",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "e1840135-39f1-4b9c-bd96-cf0295de3b0c"
      },
      "source": [
        "# Test your results against the solution\n",
        "assert num_rating == 10852, \"Oops!  The number of actual ratings doesn't quite look right.\"\n",
        "assert rating_for_missing == 31234148,\\\n",
        "  \"Oops!  The number of movie-user pairs that you made ratings for that didn't actually have ratings doesn't look right.\"\n",
        "\n",
        "# Make sure you made predictions on all the missing user-movie pairs\n",
        "pred = np.dot(user_mat, movie_mat)\n",
        "assert np.isnan(pred).sum() == 0\n",
        "print(\"Nice job!  Looks like you have predictions made for all the missing user-movie pairs!\")\n",
        "print(\"But I still have one question... How good are they?\")"
      ],
      "id": "9eddaa36",
      "execution_count": 53,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Nice job!  Looks like you have predictions made for all the missing user-movie pairs!\n",
            "But I still have one question... How good are they?\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "a3fdea61"
      },
      "source": [
        "---\n",
        "\n",
        "## Metrics on prediction \n",
        "\n",
        "## Third Notebook - L18 - How Are We Doing?\n",
        "\n",
        "#### Udacity notes:\n",
        "\n",
        "\"In the last notebook, you created a working version of SVD for situations even when there are tons of missing values.  This is awesome!  The question now is how well does this solution work?\n",
        "\n",
        "In this notebook, we are going to simulate exactly what we would do in the real world to tune our recommender.\"\n",
        "\n",
        "Run the cell below to read in the data and get started."
      ],
      "id": "a3fdea61"
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "c7a9f4f7"
      },
      "source": [
        "#Read in the datasets\n",
        "movie = udacourse3.fn_read_data('movies_clean.csv', remove_noisy_cols=True)\n",
        "review = udacourse3.fn_read_data('reviews_clean.csv', remove_noisy_cols=True)"
      ],
      "id": "c7a9f4f7",
      "execution_count": 36,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9f4d2b73"
      },
      "source": [
        "1. Using the **reviews** dataframe, perform the following tasks to create a training and validation set of data we can use to test the performance of your SVD algorithm using **off-line** validation techniques.\n",
        "\n",
        " * Order the reviews dataframe from earliest to most recent \n",
        " * Pull the first 10000 reviews from  the dataset\n",
        " * Make the first 8000/10000 reviews the training data \n",
        " * Make the last 2000/10000 the test data\n",
        " * Return the training and test datasets\n",
        "\n",
        " function `fn_create_train_test` created!"
      ],
      "id": "9f4d2b73"
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "06d64606",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "76020424-8688-4b48-bfa8-259112ba5df6"
      },
      "source": [
        "# Use our function to create training and test datasets\n",
        "train_df, val_df = udacourse3.fn_create_train_test(\n",
        "                       review=review, \n",
        "                       order_by='date', \n",
        "                       train_size=8000, \n",
        "                       test_size=2000,\n",
        "                       verbose=True)"
      ],
      "id": "06d64606",
      "execution_count": 54,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "###function create_train_test started\n",
            "elapsed time: 1.4341s\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "06ee875a",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "a6786a93-d5c9-4323-b419-da36e93953cb"
      },
      "source": [
        "# Make sure the dataframes we are using are the right shape\n",
        "assert train_df.shape[0] == 8000,\\\n",
        "\"The number of rows doesn't look right in the training dataset.\"\n",
        "assert val_df.shape[0] == 2000,\\\n",
        "\"The number of rows doesn't look right in the validation dataset\"\n",
        "assert str(train_df.tail(1)['date']).split()[1] == '2013-03-15',\\\n",
        "\"The last date in the training dataset doesn't look like what we expected.\"\n",
        "assert str(val_df.tail(1)['date']).split()[1] == '2013-03-18',\\\n",
        "\"The last date in the validation dataset doesn't look like what we expected.\"\n",
        "print(\"Nice job!  Looks like you have written a function that provides training and validation dataframes\")\n",
        "print(\"for you to use in the next steps\")"
      ],
      "id": "06ee875a",
      "execution_count": 55,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Nice job!  Looks like you have written a function that provides training and validation dataframes\n",
            "for you to use in the next steps\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "84bf92f5"
      },
      "source": [
        "In the real world, we might have all of the data up to this final date in the training data.  Then we want to see how well we are doing for each of the new ratings, which show up in the test data.\n",
        "\n",
        "Below is a working example of the function created in the previous example you can use (or you can replace with your own).\n",
        "\n",
        "`2.`  Fit the function to the training data with the following hyperparameters: 15 latent features, a learning rate of 0.005, and 250 iterations. This will take some time to run, so you may choose fewer latent features, a higher learning rate, or fewer iteratios if you want to speed up the process.  \n",
        "\n",
        "**Note:** Again, this might be a good time to take a phone call, go for a walk, or just take a little break.\n",
        "\n",
        "`fn_funk_SVD` already exist!"
      ],
      "id": "84bf92f5"
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5c11c00c",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 191
        },
        "outputId": "dbaf28c3-dc23-4f39-a590-307ff9a1897b"
      },
      "source": [
        "# Create user-by-item matrix - nothing to do here\n",
        "train_user_item = train_df[['user_id', 'movie_id', 'rating', 'timestamp']]\n",
        "train_data_df = train_user_item.groupby(['user_id', 'movie_id'])['rating'].max().unstack()\n",
        "train_data_np = np.array(train_data_df)\n",
        "train_data_df.head(2)"
      ],
      "id": "5c11c00c",
      "execution_count": 62,
      "outputs": [
        {
          "output_type": "execute_result",
          "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>movie_id</th>\n",
              "      <th>2844</th>\n",
              "      <th>8133</th>\n",
              "      <th>13427</th>\n",
              "      <th>14142</th>\n",
              "      <th>14538</th>\n",
              "      <th>14872</th>\n",
              "      <th>15163</th>\n",
              "      <th>15324</th>\n",
              "      <th>15400</th>\n",
              "      <th>17925</th>\n",
              "      <th>18773</th>\n",
              "      <th>19729</th>\n",
              "      <th>19760</th>\n",
              "      <th>20530</th>\n",
              "      <th>20629</th>\n",
              "      <th>20902</th>\n",
              "      <th>21746</th>\n",
              "      <th>21884</th>\n",
              "      <th>22958</th>\n",
              "      <th>23876</th>\n",
              "      <th>23969</th>\n",
              "      <th>25456</th>\n",
              "      <th>25586</th>\n",
              "      <th>25878</th>\n",
              "      <th>26752</th>\n",
              "      <th>27698</th>\n",
              "      <th>27977</th>\n",
              "      <th>29583</th>\n",
              "      <th>29892</th>\n",
              "      <th>31235</th>\n",
              "      <th>31381</th>\n",
              "      <th>31385</th>\n",
              "      <th>31742</th>\n",
              "      <th>32138</th>\n",
              "      <th>32194</th>\n",
              "      <th>32553</th>\n",
              "      <th>32976</th>\n",
              "      <th>33870</th>\n",
              "      <th>34522</th>\n",
              "      <th>34583</th>\n",
              "      <th>...</th>\n",
              "      <th>2368749</th>\n",
              "      <th>2377938</th>\n",
              "      <th>2387433</th>\n",
              "      <th>2387820</th>\n",
              "      <th>2388725</th>\n",
              "      <th>2390253</th>\n",
              "      <th>2391514</th>\n",
              "      <th>2396701</th>\n",
              "      <th>2400272</th>\n",
              "      <th>2400283</th>\n",
              "      <th>2401621</th>\n",
              "      <th>2401846</th>\n",
              "      <th>2402705</th>\n",
              "      <th>2415464</th>\n",
              "      <th>2429640</th>\n",
              "      <th>2458314</th>\n",
              "      <th>2459022</th>\n",
              "      <th>2467480</th>\n",
              "      <th>2483516</th>\n",
              "      <th>2551516</th>\n",
              "      <th>2563548</th>\n",
              "      <th>2576522</th>\n",
              "      <th>2589132</th>\n",
              "      <th>2592910</th>\n",
              "      <th>2608224</th>\n",
              "      <th>2608732</th>\n",
              "      <th>2611484</th>\n",
              "      <th>2611502</th>\n",
              "      <th>2611508</th>\n",
              "      <th>2611516</th>\n",
              "      <th>2625030</th>\n",
              "      <th>2635622</th>\n",
              "      <th>2638984</th>\n",
              "      <th>2645104</th>\n",
              "      <th>2645164</th>\n",
              "      <th>2646378</th>\n",
              "      <th>2649128</th>\n",
              "      <th>2735466</th>\n",
              "      <th>2748368</th>\n",
              "      <th>2750600</th>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>user_id</th>\n",
              "      <th></th>\n",
              "      <th></th>\n",
              "      <th></th>\n",
              "      <th></th>\n",
              "      <th></th>\n",
              "      <th></th>\n",
              "      <th></th>\n",
              "      <th></th>\n",
              "      <th></th>\n",
              "      <th></th>\n",
              "      <th></th>\n",
              "      <th></th>\n",
              "      <th></th>\n",
              "      <th></th>\n",
              "      <th></th>\n",
              "      <th></th>\n",
              "      <th></th>\n",
              "      <th></th>\n",
              "      <th></th>\n",
              "      <th></th>\n",
              "      <th></th>\n",
              "      <th></th>\n",
              "      <th></th>\n",
              "      <th></th>\n",
              "      <th></th>\n",
              "      <th></th>\n",
              "      <th></th>\n",
              "      <th></th>\n",
              "      <th></th>\n",
              "      <th></th>\n",
              "      <th></th>\n",
              "      <th></th>\n",
              "      <th></th>\n",
              "      <th></th>\n",
              "      <th></th>\n",
              "      <th></th>\n",
              "      <th></th>\n",
              "      <th></th>\n",
              "      <th></th>\n",
              "      <th></th>\n",
              "      <th></th>\n",
              "      <th></th>\n",
              "      <th></th>\n",
              "      <th></th>\n",
              "      <th></th>\n",
              "      <th></th>\n",
              "      <th></th>\n",
              "      <th></th>\n",
              "      <th></th>\n",
              "      <th></th>\n",
              "      <th></th>\n",
              "      <th></th>\n",
              "      <th></th>\n",
              "      <th></th>\n",
              "      <th></th>\n",
              "      <th></th>\n",
              "      <th></th>\n",
              "      <th></th>\n",
              "      <th></th>\n",
              "      <th></th>\n",
              "      <th></th>\n",
              "      <th></th>\n",
              "      <th></th>\n",
              "      <th></th>\n",
              "      <th></th>\n",
              "      <th></th>\n",
              "      <th></th>\n",
              "      <th></th>\n",
              "      <th></th>\n",
              "      <th></th>\n",
              "      <th></th>\n",
              "      <th></th>\n",
              "      <th></th>\n",
              "      <th></th>\n",
              "      <th></th>\n",
              "      <th></th>\n",
              "      <th></th>\n",
              "      <th></th>\n",
              "      <th></th>\n",
              "      <th></th>\n",
              "      <th></th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>8</th>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>...</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>46</th>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>...</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "      <td>NaN</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "<p>2 rows × 2679 columns</p>\n",
              "</div>"
            ],
            "text/plain": [
              "movie_id  2844     8133     13427    ...  2735466  2748368  2750600\n",
              "user_id                              ...                           \n",
              "8             NaN      NaN      NaN  ...      NaN      NaN      NaN\n",
              "46            NaN      NaN      NaN  ...      NaN      NaN      NaN\n",
              "\n",
              "[2 rows x 2679 columns]"
            ]
          },
          "metadata": {},
          "execution_count": 62
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "GPvCTdCLghED",
        "outputId": "024b5a32-3a7e-4641-aa7a-f1a69dcafe16"
      },
      "source": [
        "# Fit FunkSVD with the specified hyper parameters to the training data\n",
        "user_mat, movie_mat = udacourse3.fn_FunkSVD(\n",
        "                          rating_mat=train_data_np, \n",
        "                          latent_feature=15, \n",
        "                          learning_rate=0.005, \n",
        "                          num_iter=250,\n",
        "                          verbose=True)"
      ],
      "id": "GPvCTdCLghED",
      "execution_count": 63,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "###function FunkSDV started\n",
            "number of users: 3278\n",
            "number of movies: 2679\n",
            "number of valid ratings: 8000\n",
            "Optimizaiton Statistics\n",
            "Iteration Mean Squared Error\n",
            "  1       10.5448\n",
            "  2       5.8821\n",
            "  3       4.1158\n",
            "  4       3.0849\n",
            "  5       2.4057\n",
            "  6       1.9249\n",
            "  7       1.5685\n",
            "  8       1.2957\n",
            "  9       1.0819\n",
            " 10       0.9114\n",
            " 11       0.7735\n",
            " 12       0.6609\n",
            " 13       0.5680\n",
            " 14       0.4908\n",
            " 15       0.4262\n",
            " 16       0.3718\n",
            " 17       0.3256\n",
            " 18       0.2862\n",
            " 19       0.2524\n",
            " 20       0.2232\n",
            " 21       0.1980\n",
            " 22       0.1761\n",
            " 23       0.1569\n",
            " 24       0.1402\n",
            " 25       0.1255\n",
            " 26       0.1125\n",
            " 27       0.1011\n",
            " 28       0.0910\n",
            " 29       0.0821\n",
            " 30       0.0741\n",
            " 31       0.0670\n",
            " 32       0.0607\n",
            " 33       0.0551\n",
            " 34       0.0500\n",
            " 35       0.0455\n",
            " 36       0.0414\n",
            " 37       0.0378\n",
            " 38       0.0345\n",
            " 39       0.0315\n",
            " 40       0.0288\n",
            " 41       0.0264\n",
            " 42       0.0242\n",
            " 43       0.0222\n",
            " 44       0.0203\n",
            " 45       0.0187\n",
            " 46       0.0172\n",
            " 47       0.0158\n",
            " 48       0.0146\n",
            " 49       0.0135\n",
            " 50       0.0124\n",
            " 51       0.0115\n",
            " 52       0.0106\n",
            " 53       0.0098\n",
            " 54       0.0091\n",
            " 55       0.0084\n",
            " 56       0.0078\n",
            " 57       0.0072\n",
            " 58       0.0067\n",
            " 59       0.0062\n",
            " 60       0.0058\n",
            " 61       0.0054\n",
            " 62       0.0050\n",
            " 63       0.0047\n",
            " 64       0.0044\n",
            " 65       0.0041\n",
            " 66       0.0038\n",
            " 67       0.0035\n",
            " 68       0.0033\n",
            " 69       0.0031\n",
            " 70       0.0029\n",
            " 71       0.0027\n",
            " 72       0.0025\n",
            " 73       0.0024\n",
            " 74       0.0022\n",
            " 75       0.0021\n",
            " 76       0.0019\n",
            " 77       0.0018\n",
            " 78       0.0017\n",
            " 79       0.0016\n",
            " 80       0.0015\n",
            " 81       0.0014\n",
            " 82       0.0013\n",
            " 83       0.0013\n",
            " 84       0.0012\n",
            " 85       0.0011\n",
            " 86       0.0010\n",
            " 87       0.0010\n",
            " 88       0.0009\n",
            " 89       0.0009\n",
            " 90       0.0008\n",
            " 91       0.0008\n",
            " 92       0.0007\n",
            " 93       0.0007\n",
            " 94       0.0007\n",
            " 95       0.0006\n",
            " 96       0.0006\n",
            " 97       0.0005\n",
            " 98       0.0005\n",
            " 99       0.0005\n",
            "100       0.0005\n",
            "101       0.0004\n",
            "102       0.0004\n",
            "103       0.0004\n",
            "104       0.0004\n",
            "105       0.0003\n",
            "106       0.0003\n",
            "107       0.0003\n",
            "108       0.0003\n",
            "109       0.0003\n",
            "110       0.0003\n",
            "111       0.0003\n",
            "112       0.0002\n",
            "113       0.0002\n",
            "114       0.0002\n",
            "115       0.0002\n",
            "116       0.0002\n",
            "117       0.0002\n",
            "118       0.0002\n",
            "119       0.0002\n",
            "120       0.0002\n",
            "121       0.0001\n",
            "122       0.0001\n",
            "123       0.0001\n",
            "124       0.0001\n",
            "125       0.0001\n",
            "126       0.0001\n",
            "127       0.0001\n",
            "128       0.0001\n",
            "129       0.0001\n",
            "130       0.0001\n",
            "131       0.0001\n",
            "132       0.0001\n",
            "133       0.0001\n",
            "134       0.0001\n",
            "135       0.0001\n",
            "136       0.0001\n",
            "137       0.0001\n",
            "138       0.0001\n",
            "139       0.0001\n",
            "140       0.0001\n",
            "141       0.0001\n",
            "142       0.0001\n",
            "143       0.0000\n",
            "144       0.0000\n",
            "145       0.0000\n",
            "146       0.0000\n",
            "147       0.0000\n",
            "148       0.0000\n",
            "149       0.0000\n",
            "150       0.0000\n",
            "151       0.0000\n",
            "152       0.0000\n",
            "153       0.0000\n",
            "154       0.0000\n",
            "155       0.0000\n",
            "156       0.0000\n",
            "157       0.0000\n",
            "158       0.0000\n",
            "159       0.0000\n",
            "160       0.0000\n",
            "161       0.0000\n",
            "162       0.0000\n",
            "163       0.0000\n",
            "164       0.0000\n",
            "165       0.0000\n",
            "166       0.0000\n",
            "167       0.0000\n",
            "168       0.0000\n",
            "169       0.0000\n",
            "170       0.0000\n",
            "171       0.0000\n",
            "172       0.0000\n",
            "173       0.0000\n",
            "174       0.0000\n",
            "175       0.0000\n",
            "176       0.0000\n",
            "177       0.0000\n",
            "178       0.0000\n",
            "179       0.0000\n",
            "180       0.0000\n",
            "181       0.0000\n",
            "182       0.0000\n",
            "183       0.0000\n",
            "184       0.0000\n",
            "185       0.0000\n",
            "186       0.0000\n",
            "187       0.0000\n",
            "188       0.0000\n",
            "189       0.0000\n",
            "190       0.0000\n",
            "191       0.0000\n",
            "192       0.0000\n",
            "193       0.0000\n",
            "194       0.0000\n",
            "195       0.0000\n",
            "196       0.0000\n",
            "197       0.0000\n",
            "198       0.0000\n",
            "199       0.0000\n",
            "200       0.0000\n",
            "201       0.0000\n",
            "202       0.0000\n",
            "203       0.0000\n",
            "204       0.0000\n",
            "205       0.0000\n",
            "206       0.0000\n",
            "207       0.0000\n",
            "208       0.0000\n",
            "209       0.0000\n",
            "210       0.0000\n",
            "211       0.0000\n",
            "212       0.0000\n",
            "213       0.0000\n",
            "214       0.0000\n",
            "215       0.0000\n",
            "216       0.0000\n",
            "217       0.0000\n",
            "218       0.0000\n",
            "219       0.0000\n",
            "220       0.0000\n",
            "221       0.0000\n",
            "222       0.0000\n",
            "223       0.0000\n",
            "224       0.0000\n",
            "225       0.0000\n",
            "226       0.0000\n",
            "227       0.0000\n",
            "228       0.0000\n",
            "229       0.0000\n",
            "230       0.0000\n",
            "231       0.0000\n",
            "232       0.0000\n",
            "233       0.0000\n",
            "234       0.0000\n",
            "235       0.0000\n",
            "236       0.0000\n",
            "237       0.0000\n",
            "238       0.0000\n",
            "239       0.0000\n",
            "240       0.0000\n",
            "241       0.0000\n",
            "242       0.0000\n",
            "243       0.0000\n",
            "244       0.0000\n",
            "245       0.0000\n",
            "246       0.0000\n",
            "247       0.0000\n",
            "248       0.0000\n",
            "249       0.0000\n",
            "250       0.0000\n",
            "elapsed time: 1188.5007s (00:19:48.5007s)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2e6286ac"
      },
      "source": [
        "Now that you have created the **user_mat** and **movie_mat**, we can use this to make predictions for how users would rate movies, by just computing the dot product of the row associated with a user and the column associated with the movie.\n",
        "\n",
        "`3.` Use the comments in the function below to complete the **predict_rating** function.\n",
        "\n",
        "function `predict_rating` created!"
      ],
      "id": "2e6286ac"
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8c290b2d",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "84addcda-625f-4f29-c77a-9f4678003ba5"
      },
      "source": [
        "# Test your function with the first user-movie in the user-movie matrix (notice this is a nan)\n",
        "pred_val = udacourse3.fn_predict_rating(\n",
        "               df_train=train_data_df, \n",
        "               user_matrix=user_mat, \n",
        "               movie_matrix=movie_mat, \n",
        "               user_id=8,\n",
        "               movie_id=2844,\n",
        "               verbose=True)\n",
        "pred_val"
      ],
      "id": "8c290b2d",
      "execution_count": 66,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "###function movies watched started\n",
            "elapsed time: 0.0002s\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "8.24594955251834"
            ]
          },
          "metadata": {},
          "execution_count": 66
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2f91a589"
      },
      "source": [
        "It is great that you now have a way to make predictions. However it might be nice to get a little phrase back about the user, movie, and rating.\n",
        "\n",
        "`4.` Use the comments in the function below to complete the **predict_rating** function.  \n",
        "\n",
        "**Note:** The movie name doesn't come back in a great format, so you can see in the solution I messed around with it a bit just to make it a little nicer.\n",
        "\n",
        "function `fn_print_prediction_summary` created!"
      ],
      "id": "2f91a589"
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "21e6d3be",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "4ebad032-3763-4ea6-be52-912355b981cc"
      },
      "source": [
        "# Test your function the the results of the previous function\n",
        "udacourse3.fn_print_prediction_summary(\n",
        "               df_movie=movie,\n",
        "               user_id=8, \n",
        "               movie_id=2844, \n",
        "               prediction=pred_val,\n",
        "               verbose=True)"
      ],
      "id": "21e6d3be",
      "execution_count": 70,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "###function movies watched started\n",
            "For user 8 we predict a 8.25 rating for the movie  Fantômas - À l'ombre de la guillotine (1913).\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {},
          "execution_count": 70
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "e55e4447"
      },
      "source": [
        "Now that we have the ability to make predictions, let's see how well our predictions do on the test ratings we already have.  This will give an indication of how well have captured the latent features, and our ability to use the latent features to make predictions in the future!\n",
        "\n",
        "`5.` For each of the user-movie rating in the **val_df** dataset, compare the actual rating given to the prediction you would make.  How do your predictions do?  Do you run into any problems?  If yes, what is the problem?  Use the document strings and comments below to assist as you work through these questions.\n",
        "\n",
        "function `fn_validation_comparison` created!"
      ],
      "id": "e55e4447"
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GG4wBhaLpQ0g"
      },
      "source": [
        "!cp /content/gdrive/MyDrive/GoogleColab/DataScientistStudies3/udacourse3.py .\n",
        "#reloader for our functions library\n",
        "from importlib import reload \n",
        "import udacourse3\n",
        "\n",
        "udacourse3 = reload(udacourse3)"
      ],
      "id": "GG4wBhaLpQ0g",
      "execution_count": 91,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "80d14fec",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "c88a76c7-33b7-4561-b1ae-1151675e24a3"
      },
      "source": [
        "# Perform the predicted vs. actual for the first 6 rows.  How does it look?\n",
        "udacourse3.fn_validation_comparison(\n",
        "    df_train=train_data_df,\n",
        "    user_matrix=user_mat,\n",
        "    movie_matrix=movie_mat,\n",
        "    val_df=val_df, \n",
        "    num_pred=6,\n",
        "    verbose=True)"
      ],
      "id": "80d14fec",
      "execution_count": 92,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "###function validation comparison started\n",
            "Our rating actual: 8 → for user 49056 on movie 1598822\n",
            "         predited: 7\n",
            "Our rating actual: 9 → for user 49056 on movie 289879\n",
            "         predited: 9\n",
            "Our rating actual: 9 → for user 49056 on movie 1563738\n",
            "         predited: 7\n",
            "Our rating actual: 4 → for user 49056 on movie 1458175\n",
            "         predited: 7\n",
            "Our rating actual: 8 → for user 28599 on movie 103639\n",
            "         predited: 8\n",
            "Our rating actual: 4 → for user 50593 on movie 1560985\n",
            "         predited: 4\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {},
          "execution_count": 92
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "764db75c",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "be6436af-22d7-44fd-c1d6-dae50ccf791c"
      },
      "source": [
        "# Perform the predicted vs. actual for the first 7 rows.  What happened?\n",
        "udacourse3.fn_validation_comparison(\n",
        "    df_train=train_data_df,\n",
        "    user_matrix=user_mat,\n",
        "    movie_matrix=movie_mat,\n",
        "    val_df=val_df, \n",
        "    num_pred=7,\n",
        "    verbose=True)"
      ],
      "id": "764db75c",
      "execution_count": 93,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "###function validation comparison started\n",
            "Our rating actual: 8 → for user 49056 on movie 1598822\n",
            "         predited: 7\n",
            "Our rating actual: 9 → for user 49056 on movie 289879\n",
            "         predited: 9\n",
            "Our rating actual: 9 → for user 49056 on movie 1563738\n",
            "         predited: 7\n",
            "Our rating actual: 4 → for user 49056 on movie 1458175\n",
            "         predited: 7\n",
            "Our rating actual: 8 → for user 28599 on movie 103639\n",
            "         predited: 8\n",
            "Our rating actual: 4 → for user 50593 on movie 1560985\n",
            "         predited: 4\n",
            "cannot predict for this movie\n",
            "system halted\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "False"
            ]
          },
          "metadata": {},
          "execution_count": 93
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "d63fe2c8"
      },
      "source": [
        "**The 7th movie is a movie that has no ratings.  Therefore, we are not able to make a prediction for this user-movie pair.**"
      ],
      "id": "d63fe2c8"
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4e224389"
      },
      "source": [
        "---\n",
        "\n",
        "## Users with no Data\n",
        "\n",
        "## Forth Notebook - L20 - Cold Start Problem\n",
        "\n",
        "#### in Udacity notes\n",
        "\n",
        "\"In the previous notebook, you learned about the **Cold Start Problem** first hand. In cases where you are introduced to a new user or new movie, collaborative flitering is not helpful as a technique to make predictions.\n",
        "\n",
        "Instead, you will need to use one of the techniques from the previous lesson like content based recommendations for new items or rank based recommendations for new users.\"\n",
        "\n",
        "As a final step to completing out our recommendation system, we will build in these edge cases. Run the cell below to get started.\n",
        "\n",
        "### Matrix Factorization - Collaborative Filtering Where Possible\n",
        "\n",
        "Notice the following information is available by running the below cell:\n",
        "\n",
        "`1.` **reviews** - a dataframe of reviews\n",
        "\n",
        "`2.` **movies** - a dataframe of movies\n",
        "\n",
        "`3.` **create_train_test** - a function for creating the training and validation datasets\n",
        "\n",
        "`4.` **predict_rating** - a function that takes a user and movie and gives a prediction using FunkSVD\n",
        "\n",
        "`5.` **train_df** and **val_df** - the training and test datasets used in the previous notebook\n",
        "\n",
        "`6.` **user_mat** and **movie_mat** - the u and v matrices from FunkSVD\n",
        "\n",
        "`7.` **train_data_df** - a user-movie matrix with ratings where available.  FunkSVD was performed on this matrix"
      ],
      "id": "4e224389"
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8e09a5c7"
      },
      "source": [
        "#Read in the datasets\n",
        "movie = udacourse3.fn_read_data('data/movies_clean.csv', remove_noisy_cols=True)\n",
        "review = udacourse3.fn_read_data('data/reviews_clean.csv', remove_noisy_cols=True)"
      ],
      "id": "8e09a5c7",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ddXg4y4bfgqZ"
      },
      "source": [
        "#copy picke files\n",
        "!cp /content/gdrive/MyDrive/GoogleColab/DataScientistStudies3/user_matrix .\n",
        "!cp /content/gdrive/MyDrive/GoogleColab/DataScientistStudies3/movie_matrix ."
      ],
      "id": "ddXg4y4bfgqZ",
      "execution_count": 96,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "dbfc2c2e",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "302781f6-4b8a-43c2-a1a6-3de9c56ab8c3"
      },
      "source": [
        "# Use our function to create training and test datasets\n",
        "train_df, val_df = udacourse3.fn_create_train_test(\n",
        "                       review=review, \n",
        "                       order_by='date', \n",
        "                       train_size=8000, \n",
        "                       test_size=2000,\n",
        "                       verbose=True)\n",
        "\n",
        "# Create user-by-item matrix - this will keep track of order of users and movies in u and v\n",
        "train_user_item = train_df[['user_id', 'movie_id', 'rating', 'timestamp']]\n",
        "train_data_df = train_user_item.groupby(['user_id', 'movie_id'])['rating'].max().unstack()\n",
        "train_data_np = np.array(train_data_df)\n",
        "\n",
        "# Read in user and movie matrices\n",
        "user_file = open(\"user_matrix\", 'rb')\n",
        "user_mat = pickle.load(user_file)\n",
        "user_file.close()\n",
        "\n",
        "movie_file = open(\"movie_matrix\", 'rb')\n",
        "movie_mat = pickle.load(movie_file)\n",
        "movie_file.close()"
      ],
      "id": "dbfc2c2e",
      "execution_count": 97,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "###function create_train_test started\n",
            "elapsed time: 1.3890s\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dfb4af38"
      },
      "source": [
        "### Validating Predictions\n",
        "\n",
        "Unfortunately, you weren't able to make predictions on every user-movie combination in the test set, as some of these users or movies were new.  \n",
        "\n",
        "However, you can validate your predictions for the user-movie pairs that do exist in the user_mat and movie_mat matrices.  \n",
        "\n",
        "`1.` Complete the function below to see how far off we were on average across all of the predicted ratings."
      ],
      "id": "dfb4af38"
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fbf66083"
      },
      "source": [
        "#########1#########2#########3#########4#########5#########6#########7#########8\n",
        "def fn_validation_comparison(df_train, \n",
        "                             user_matrix, \n",
        "                             movie_matrix,\n",
        "                             val_df,\n",
        "                             num_pred=0,\n",
        "                             relatory=True,\n",
        "                             verbose=False):\n",
        "    val_user = np.array(val_df['user_id'])\n",
        "    val_movie = np.array(val_df['movie_id'])\n",
        "    val_rating = np.array(val_df['rating'])\n",
        "\n",
        "    if relatory: #relatory only\n",
        "        if num_pred < 1:\n",
        "            if verbose:\n",
        "              print('no predictions asked')\n",
        "            return False\n",
        "        else:\n",
        "            for idx in range(num_pred): #call for our subfunction\n",
        "                #if verbose:\n",
        "                #    print('*calling predict rating subfunction')\n",
        "                pred = udacourse3.fn_predict_rating(\n",
        "                           df_train=df_train,\n",
        "                           user_matrix=user_matrix, \n",
        "                           movie_matrix=movie_matrix, \n",
        "                           user_id=val_user[idx],\n",
        "                           movie_id=val_movie[idx],\n",
        "                           verbose=False)\n",
        "                if not pred:\n",
        "                    if verbose:\n",
        "                        print('system halted')\n",
        "                    return False\n",
        "        \n",
        "                print('Our rating actual: {} → for user {} on movie {}'\\\n",
        "                      .format(val_rating[idx],\n",
        "                              val_user[idx], \n",
        "                              val_movie[idx]))\n",
        "                print('         predited: {}'.format(round(pred)))\n",
        "        return True\n",
        "\n",
        "    else: #full mode              \n",
        "        sse = 0\n",
        "        num_rated = 0\n",
        "        ls_pred, ls_act = [], []\n",
        "        actual_v_pred = np.zeros((10,10))\n",
        "        for idx in range(len(val_user)):\n",
        "            try:\n",
        "                pred = udacourse3.fn_predict_rating(\n",
        "                           df_train=df_train,\n",
        "                           user_matrix=user_matrix, \n",
        "                           movie_matrix=movie_matrix, \n",
        "                           user_id=val_user[idx], \n",
        "                           movie_id=val_movie[idx],\n",
        "                           verbose=False)\n",
        "                sse += (val_rating[idx] - pred)**2\n",
        "                num_rated += 1\n",
        "                ls_pred.append(pred)\n",
        "                ls_act.append(val_rating[idx])\n",
        "                actual_v_pred[11 - int(val_rating[idx] - 1), \n",
        "                              int(round(pred) - 1)] += 1\n",
        "        \n",
        "            except:\n",
        "                continue \n",
        "    \n",
        "        rmse = np.sqrt(sse / num_rated)\n",
        "        perc_rated = num_rated / len(val_user)\n",
        "    \n",
        "        output = rmse, perc_rated, actual_v_pred, ls_pred, ls_act\n",
        "    \n",
        "        end = time()\n",
        "        if verbose:\n",
        "            print('elapsed time: {}s'.format(end-begin))\n",
        "\n",
        "        return output"
      ],
      "id": "fbf66083",
      "execution_count": 103,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "43477706",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "outputId": "0988e898-3549-4011-8bd9-5f6c2b0f381d"
      },
      "source": [
        "# How well did we do?\n",
        "rmse, perc_rated, actual_v_pred, preds, acts = fn_validation_comparison(\n",
        "                                                   df_train=train_data_df, \n",
        "                                                   user_matrix=user_mat, \n",
        "                                                   movie_matrix=movie_mat,\n",
        "                                                   val_df=val_df,\n",
        "                                                   num_pred=0,\n",
        "                                                   relatory=False,\n",
        "                                                   verbose=True)\n",
        "print(rmse, perc_rated)\n",
        "sns.heatmap(actual_v_pred);\n",
        "plt.xticks(np.arange(10), np.arange(1,11));\n",
        "plt.yticks(np.arange(10), np.arange(1,11));\n",
        "plt.xlabel(\"Predicted Values\");\n",
        "plt.ylabel(\"Actual Values\");\n",
        "plt.title(\"Actual vs. Predicted Values\");"
      ],
      "id": "43477706",
      "execution_count": 104,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "cannot predict for this movie\n",
            "elapsed time: 34611.04255056381s\n",
            "4.04637277816206 0.6335\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 2 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8bca7067"
      },
      "source": [
        "plt.figure(figsize=(8,8))\n",
        "plt.hist(acts, normed=True, alpha=.5, label='actual');\n",
        "plt.hist(preds, normed=True, alpha=.5, label='predicted');\n",
        "plt.legend(loc=2, prop={'size': 15});\n",
        "plt.xlabel('Rating');\n",
        "plt.title('Predicted vs. Actual Rating');"
      ],
      "id": "8bca7067",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "b4c96b58"
      },
      "source": [
        "`2.` We didn't do so bad on making those predictions!  But, how many user-movie pairs were we unable to make predictions for?  Use the cell below to answer this question."
      ],
      "id": "b4c96b58"
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5bbda61f"
      },
      "source": [
        "# From the above, this can be calculated as follows:\n",
        "print(\"Number not rated {}\".format(int(len(val_df['rating'])*(1-perc_rated))))\n",
        "print(\"Number rated {}.\".format(int(len(val_df['rating'])*perc_rated)))"
      ],
      "id": "5bbda61f",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "27214ed2"
      },
      "source": [
        "### Content Based For New Movies\n",
        "\n",
        "If all of the above went well, you will notice we still have work to do!  We need to bring in a few things we picked up from the last lesson to use for those new users and movies.  Below is the code used to make the content based recommendations, which found movies that were similar to one another.  This was from **5_Content_Based_Recommendations** in the previous lesson.\n",
        "\n",
        "The below function **find_similar_movies** will provide similar movies to any movie based only on content.  \n",
        "\n",
        "Run the cell below to gain access to the content based similarity functions."
      ],
      "id": "27214ed2"
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "461373d7"
      },
      "source": [
        "# Subset so movie_content is only using the dummy variables for each genre and the 3 century based year dummy columns\n",
        "movie_content = np.array(movies.iloc[:,4:])\n",
        "\n",
        "# Take the dot product to obtain a movie x movie matrix of similarities\n",
        "dot_prod_movies = movie_content.dot(np.transpose(movie_content))"
      ],
      "id": "461373d7",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "d57a5d44"
      },
      "source": [
        "#########1#########2#########3#########4#########5#########6#########7#########8\n",
        "def fn_find_similar_movie(movie_id,\n",
        "                          verbose=False):\n",
        "    '''This function...\n",
        "    \n",
        "    Source: Udacity Data Science Course - Lesson 7  - Matrix Factorization for\n",
        "    Recommendations - Forth Notebook - Class 20 - Cold Start Problem w/ FunkSVD\n",
        "    \n",
        "    Inputs:\n",
        "      - movie_id (mandatory) - a movie_id\n",
        "      - verbose (optional) - if you want some verbosity in your function -\n",
        "        (Boolean, default=False)\n",
        "    Output:\n",
        "      - similar_movie - an array of the most similar movies by title\n",
        "    '''\n",
        "    if verbose:\n",
        "        print('###function movies watched started')\n",
        "    begin = time()\n",
        "\n",
        "    # find the row of each movie id\n",
        "    movie_idx = np.where(movies['movie_id'] == movie_id)[0][0]\n",
        "    \n",
        "    # find the most similar movie indices - to start I said they need to be the same for all content\n",
        "    similar_idxs = np.where(dot_prod_movies[movie_idx] == np.max(dot_prod_movies[movie_idx]))[0]\n",
        "    \n",
        "    # pull the movie titles based on the indices\n",
        "    similar_movies = np.array(movies.iloc[similar_idxs, ]['movie'])\n",
        "    \n",
        "    if verbose:\n",
        "        print('elapsed time: {}s'.format(end-begin))\n",
        "    \n",
        "    return similar_movies"
      ],
      "id": "d57a5d44",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5c63b733"
      },
      "source": [
        "#########1#########2#########3#########4#########5#########6#########7#########8\n",
        "def fn_get_movie_name(movie_id,\n",
        "                       verbose=False):\n",
        "    '''This function...\n",
        "    \n",
        "    Source: Udacity Data Science Course - Lesson 7  - Matrix Factorization for\n",
        "    Recommendations - Forth Notebook - Class 20 - Cold Start Problem w/ FunkSVD\n",
        "    \n",
        "    Inputs:\n",
        "      - movie_id (mandatory) - a list of movie ids\n",
        "      - verbose (optional) - if you want some verbosity in your function -\n",
        "        (Boolean, default=False)\n",
        "    Output:\n",
        "      - movies - a list of movie names associated with the movie_ids\n",
        "    '''\n",
        "    if verbose:\n",
        "        print('###function get movies names started')\n",
        "    begin = time()\n",
        "\n",
        "    movie_lst = list(movies[movies['movie_id'].isin(movie_ids)]['movie'])\n",
        "    \n",
        "    if verbose:\n",
        "        print('elapsed time: {}s'.format(end-begin))\n",
        "   \n",
        "    return movie_lst"
      ],
      "id": "5c63b733",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "d916c962"
      },
      "source": [
        "### Rank Based For New Users\n",
        "\n",
        "From the above two code cells, we have a way to make recommendations for movie-user pairs that have ratings in any part of our user-movie matrix.  We also have a way to make ratings for movies that have never received a rating using movie similarities.\n",
        "\n",
        "In this last part here, we need a way to make recommendations to new users.  For this, our functions from **2_Most_Popular_Recommendations** in Lesson 1 will come in handy.  Run the cell below to have these functions available.\n",
        "\n",
        "Run the cell below to gain access to the rank based functions."
      ],
      "id": "d916c962"
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5afe86fc"
      },
      "source": [
        "#########1#########2#########3#########4#########5#########6#########7#########8\n",
        "def fn_create_ranked_df(movie,\n",
        "                        review,\n",
        "                        verbose=False):\n",
        "    '''This function...\n",
        "    \n",
        "    Source: Udacity Data Science Course - Lesson 7  - Matrix Factorization for\n",
        "    Recommendations - Forth Notebook - Class 20 - Cold Start Problem w/ FunkSVD\n",
        "    \n",
        "    Inputs:\n",
        "      - movie (mandatory) - the movies dataframe\n",
        "      - review (mandatory) - the reviews dataframe\n",
        "      - verbose (optional) - if you want some verbosity in your function -\n",
        "        (Boolean, default=False)\n",
        "    Output:\n",
        "    ranked_movies - a dataframe with movies that are sorted by highest avg rating, more reviews, \n",
        "                    then time, and must have more than 4 ratings\n",
        "    '''\n",
        "    if verbose:\n",
        "        print('###function movies watched started')\n",
        "    begin = time()\n",
        "\n",
        "    # Pull the average ratings and number of ratings for each movie\n",
        "    movie_ratings = reviews.groupby('movie_id')['rating']\n",
        "    avg_ratings = movie_ratings.mean()\n",
        "    num_ratings = movie_ratings.count()\n",
        "    last_rating = pd.DataFrame(reviews.groupby('movie_id').max()['date'])\n",
        "    last_rating.columns = ['last_rating']\n",
        "\n",
        "    # Add Dates\n",
        "    rating_count_df = pd.DataFrame({'avg_rating': avg_ratings, 'num_ratings': num_ratings})\n",
        "    rating_count_df = rating_count_df.join(last_rating)\n",
        "\n",
        "    # merge with the movies dataset\n",
        "    movie_recs = movies.set_index('movie_id').join(rating_count_df)\n",
        "\n",
        "    # sort by top avg rating and number of ratings\n",
        "    ranked_movies = movie_recs.sort_values(['avg_rating', 'num_ratings', 'last_rating'], ascending=False)\n",
        "\n",
        "    # for edge cases - subset the movie list to those with only 5 or more reviews\n",
        "    ranked_movies = ranked_movies[ranked_movies['num_ratings'] > 4]\n",
        "        \n",
        "    if verbose:\n",
        "        print('elapsed time: {}s'.format(end-begin))\n",
        "            \n",
        "    return ranked_movies"
      ],
      "id": "5afe86fc",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "e644278f"
      },
      "source": [
        "#########1#########2#########3#########4#########5#########6#########7#########8\n",
        "def fn_popular_recommendation(user_id, \n",
        "                              num_top, \n",
        "                              ranked_movie,\n",
        "                              verbose=False):\n",
        "    '''This function...\n",
        "    \n",
        "    Source: Udacity Data Science Course - Lesson 7  - Matrix Factorization for\n",
        "    Recommendations - Forth Notebook - Class 20 - Cold Start Problem w/ FunkSVD\n",
        "    \n",
        "    Inputs:\n",
        "      - user_id (mandatory) - the user_id (str) of the individual you are \n",
        "        making recommendations for\n",
        "      - num_top (mandatory) - an integer of the number recommendations you want \n",
        "        back\n",
        "      - ranked_movie (mandatory) - a pandas dataframe of the already ranked \n",
        "        movies based on avg rating, count, and time\n",
        "      - verbose (optional) - if you want some verbosity in your function -\n",
        "        (Boolean, default=False)\n",
        "    Output:\n",
        "      - top_movie - a list of the n top recommended movies by movie title in order \n",
        "        best to worst\n",
        "    '''\n",
        "    if verbose:\n",
        "        print('###function popular recommendations started')\n",
        "    begin = time()\n",
        "\n",
        "    top_movie = list(ranked_movie['movie'][:n_top])\n",
        "    \n",
        "    if verbose:\n",
        "        print('elapsed time: {}s'.format(end-begin))\n",
        "\n",
        "    return top_movie"
      ],
      "id": "e644278f",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4cd1409a"
      },
      "source": [
        "### Now For Your Task\n",
        "\n",
        "The above cells set up everything we need to use to make predictions.  Your task is to write a function, which uses the above information as necessary to provide recommendations for every user in the **val_df** dataframe.  There isn't one right way to do this, but using a blend between the three could be your best bet.  \n",
        "\n",
        "You can see the blended approach I used in the video on the next page, but feel free to be creative with your solution!\n",
        "\n",
        "`3.` Use the function below along with the document strings to assist with completing the task for this notebook.  "
      ],
      "id": "4cd1409a"
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "d0e22912"
      },
      "source": [
        "#########1#########2#########3#########4#########5#########6#########7#########8\n",
        "def fn_make_recommendations(_id, \n",
        "                            _id_type='movie', \n",
        "                            train_data=train_data_df, \n",
        "                            train_df=train_df, \n",
        "                            movies=movies, \n",
        "                            rec_num=5, \n",
        "                            user_mat=user_mat,\n",
        "                            verbose=False):\n",
        "    '''This function...\n",
        "    \n",
        "    Source: Udacity Data Science Course - Lesson 7  - Matrix Factorization for\n",
        "    Recommendations - Forth Notebook - Class 20 - Cold Start Problem w/ FunkSVD\n",
        "    \n",
        "    Inputs:\n",
        "      - _id (mandatory) - either a user or movie id (int)\n",
        "      - _id_type (mandatory) - \"movie\" or \"user\" (str)\n",
        "      - train_data (mandatory)  - dataframe of data as user-movie matrix\n",
        "      - train_df (mandatory) - dataframe of training data reviews\n",
        "      - movies (mandatory) - movies df\n",
        "      - rec_num (optional) - number of recommendations to return (int)\n",
        "      - user_mat (optional) - the U matrix of matrix factorization\n",
        "      - movie_mat (optional) - the V matrix of matrix factorization\n",
        "      - verbose (optional) - if you want some verbosity in your function -\n",
        "        (Boolean, default=False)\n",
        "    Output:\n",
        "      - recs - (array) a list or numpy array of recommended movies like the \n",
        "        given movie, or recs for a user_id given\n",
        "    '''\n",
        "    if verbose:\n",
        "        print('###function movies watched started')\n",
        "    begin = time()\n",
        "\n",
        "    # if the user is available from the matrix factorization data, \n",
        "    # I will use this and rank movies based on the predicted values\n",
        "    # For use with user indexing\n",
        "    val_user = train_data_df.index\n",
        "    rec_id = fn_create_ranked_df(movie, \n",
        "                                 train_df,\n",
        "                                 verbose=verbose)\n",
        "    \n",
        "    if _id_type == 'user':\n",
        "        if _id in train_data.index:\n",
        "            # Get the index of which row the user is in for use in U matrix\n",
        "            idx = np.where(val_user == _id)[0][0]\n",
        "            \n",
        "            # take the dot product of that row and the V matrix\n",
        "            pred = np.dot(user_mat[idx,:],movie_mat)\n",
        "            \n",
        "            # pull the top movies according to the prediction\n",
        "            indice = preds.argsort()[-rec_num:][::-1] #indices\n",
        "            rec_id = train_data_df.columns[indices]\n",
        "            rec_name = fn_get_movie_name(rec_id,\n",
        "                                         verbose=verbose)         \n",
        "        else:\n",
        "            # if we don't have this user, give just top ratings back\n",
        "            rec_names = fn_popular_recommendation(_id, \n",
        "                                                  rec_num, \n",
        "                                                  ranked_movie,\n",
        "                                                  verbose=verbose)\n",
        "            \n",
        "    # Find similar movies if it is a movie that is passed\n",
        "    else:\n",
        "        rec_id = fn_find_similar_movie(_id,\n",
        "                                       verbose=verbose)\n",
        "        rec_name = get_movie_name(rec_id,\n",
        "                                  verbose=verbose)\n",
        "        \n",
        "    output = rec_id, rec_name\n",
        "    \n",
        "    end = time()\n",
        "    \n",
        "    if verbose:\n",
        "        print('elapsed time: {}s'.format(end-begin))\n",
        "    \n",
        "    return output"
      ],
      "id": "d0e22912",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ad7d1a3c"
      },
      "source": [
        "fn_make_recommendation(_id=48, \n",
        "                       _id_type='user'\n",
        "                       verbose=True)"
      ],
      "id": "ad7d1a3c",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7dacab52"
      },
      "source": [
        "len(set(val_df['user_id']))"
      ],
      "id": "7dacab52",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3b6458b0"
      },
      "source": [
        "# Make recommendations\n",
        "user_rec_dict_with_top = dict()\n",
        "for user_id in set(val_df['user_id']):\n",
        "    user_rec_dict_with_top[user_id] = fn_make_recommendation(_id=user_id, \n",
        "                                                             _id_type='user')[1]"
      ],
      "id": "3b6458b0",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0593a122"
      },
      "source": [
        "cnter = 0\n",
        "for user, rec in user_rec_dict_with_top.items():\n",
        "    if cnter < 12:\n",
        "        print(\"For user {}, our recommendations are: \\n {}\".format(user, rec))\n",
        "        cnter+=1\n",
        "    else:\n",
        "        break"
      ],
      "id": "0593a122",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "894d5a8d"
      },
      "source": [
        "**This recommendation style looks like it may do okay with accuracy, but it seems like a lot of the same movies are showing up.  When we think back to serendipity, novelty, and diversity as means of a good recommendation system, this set of recommendations still isn't great.  We might consider providing some content based recommendations from movies an individual has watched along with these recommendations to meet those categories of a good recommender.**"
      ],
      "id": "894d5a8d"
    }
  ]
}