\n",
"**Implementation Note**: We strongly encourage you to use a vectorized implementation to compute $J$, since it will later by called many times by `scipy`'s optimization package. As usual, it might be easiest to first write a non-vectorized implementation (to make sure you have the right answer), and the modify it to become a vectorized implementation (checking that the vectorization steps do not change your algorithm’s output). To come up with a vectorized implementation, the following tip might be helpful: You can use the $R$ matrix to set selected entries to 0. For example, `R * M` will do an element-wise multiplication between `M`\n",
"and `R`; since `R` only has elements with values either 0 or 1, this has the effect of setting the elements of M to 0 only when the corresponding value in R is 0. Hence, `np.sum( R * M)` is the sum of all the elements of `M` for which the corresponding element in `R` equals 1.\n",
"
\n",
"\n",
"\u001b[0;34m\u001b[0m\n\u001b[1;32m 14\u001b[0m R \u001b[38;5;241m=\u001b[39m R[:num_movies, \u001b[38;5;241m0\u001b[39m:num_users]\n\u001b[1;32m 16\u001b[0m \u001b[38;5;66;03m# Evaluate cost function\u001b[39;00m\n\u001b[0;32m---> 17\u001b[0m J, _ \u001b[38;5;241m=\u001b[39m \u001b[43mcofiCostFunc\u001b[49m\u001b[43m(\u001b[49m\u001b[43mnp\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mconcatenate\u001b[49m\u001b[43m(\u001b[49m\u001b[43m[\u001b[49m\u001b[43mX\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mravel\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mTheta\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mravel\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[43m]\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 18\u001b[0m \u001b[43m \u001b[49m\u001b[43mY\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mR\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mnum_users\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mnum_movies\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mnum_features\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 20\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mCost at loaded parameters: \u001b[39m\u001b[38;5;132;01m%.2f\u001b[39;00m\u001b[38;5;124m \u001b[39m\u001b[38;5;130;01m\\n\u001b[39;00m\u001b[38;5;124m(this value should be about 22.22)\u001b[39m\u001b[38;5;124m'\u001b[39m \u001b[38;5;241m%\u001b[39m J)\n",
"Input \u001b[0;32mIn [65]\u001b[0m, in \u001b[0;36mcofiCostFunc\u001b[0;34m(params, Y, R, num_users, num_movies, num_features, lambda_)\u001b[0m\n\u001b[1;32m 73\u001b[0m Theta_grad \u001b[38;5;241m=\u001b[39m np\u001b[38;5;241m.\u001b[39mzeros(Theta\u001b[38;5;241m.\u001b[39mshape)\n\u001b[1;32m 75\u001b[0m \u001b[38;5;66;03m# ====================== YOUR CODE HERE ======================\u001b[39;00m\n\u001b[1;32m 76\u001b[0m \n\u001b[1;32m 77\u001b[0m \u001b[38;5;66;03m# Y: Rating, num_movies x num_users\u001b[39;00m\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 87\u001b[0m \u001b[38;5;66;03m# J += (Theta[j].T@X[i] - Y[i, j])**2\u001b[39;00m\n\u001b[1;32m 88\u001b[0m \u001b[38;5;66;03m# J /= 2\u001b[39;00m\n\u001b[0;32m---> 90\u001b[0m ratings \u001b[38;5;241m=\u001b[39m \u001b[43mX\u001b[49m\u001b[38;5;129;43m@Theta\u001b[39;49m\n\u001b[1;32m 91\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m i \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mrange\u001b[39m(num_movies):\n\u001b[1;32m 92\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m j \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mrange\u001b[39m(num_users):\n",
"\u001b[0;31mValueError\u001b[0m: matmul: Input operand 1 has a mismatch in its core dimension 0, with gufunc signature (n?,k),(k,m?)->(n?,m?) (size 4 is different from 3)"
]
}
],
"source": [
"# Load pre-trained weights (X, Theta, num_users, num_movies, num_features)\n",
"data = loadmat(os.path.join('Data', 'ex8_movieParams.mat'))\n",
"X, Theta, num_users, num_movies, num_features = data['X'],\\\n",
" data['Theta'], data['num_users'], data['num_movies'], data['num_features']\n",
"\n",
"# Reduce the data set size so that this runs faster\n",
"num_users = 4\n",
"num_movies = 5\n",
"num_features = 3\n",
"\n",
"X = X[:num_movies, :num_features]\n",
"Theta = Theta[:num_users, :num_features]\n",
"Y = Y[:num_movies, 0:num_users]\n",
"R = R[:num_movies, 0:num_users]\n",
"\n",
"# Evaluate cost function\n",
"J, _ = cofiCostFunc(np.concatenate([X.ravel(), Theta.ravel()]),\n",
" Y, R, num_users, num_movies, num_features)\n",
" \n",
"print('Cost at loaded parameters: %.2f \\n(this value should be about 22.22)' % J)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"*You should now submit your solutions.*"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"grader[3] = cofiCostFunc\n",
"grader.grade()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"\n",
"#### 2.2.2 Collaborative filtering gradient\n",
"\n",
"Now you should implement the gradient (without regularization). Specifically, you should complete the code in `cofiCostFunc` to return the variables `X_grad` and `Theta_grad`. Note that `X_grad` should be a matrix of the same size as `X` and similarly, `Theta_grad` is a matrix of the same size as\n",
"`Theta`. The gradients of the cost function is given by:\n",
"\n",
"$$ \\frac{\\partial J}{\\partial x_k^{(i)}} = \\sum_{j:r(i,j)=1} \\left( \\left(\\theta^{(j)}\\right)^T x^{(i)} - y^{(i,j)} \\right) \\theta_k^{(j)} $$\n",
"\n",
"$$ \\frac{\\partial J}{\\partial \\theta_k^{(j)}} = \\sum_{i:r(i,j)=1} \\left( \\left(\\theta^{(j)}\\right)^T x^{(i)}- y^{(i,j)} \\right) x_k^{(i)} $$\n",
"\n",
"Note that the function returns the gradient for both sets of variables by unrolling them into a single vector. After you have completed the code to compute the gradients, the next cell run a gradient check\n",
"(available in `utils.checkCostFunction`) to numerically check the implementation of your gradients (this is similar to the numerical check that you used in the neural networks exercise. If your implementation is correct, you should find that the analytical and numerical gradients match up closely.\n",
"\n",
"\n",
"**Implementation Note:** You can get full credit for this assignment without using a vectorized implementation, but your code will run much more slowly (a small number of hours), and so we recommend that you try to vectorize your implementation. To get started, you can implement the gradient with a for-loop over movies\n",
"(for computing $\\frac{\\partial J}{\\partial x^{(i)}_k}$) and a for-loop over users (for computing $\\frac{\\partial J}{\\theta_k^{(j)}}$). When you first implement the gradient, you might start with an unvectorized version, by implementing another inner for-loop that computes each element in the summation. After you have completed the gradient computation this way, you should try to vectorize your implementation (vectorize the inner for-loops), so that you are left with only two for-loops (one for looping over movies to compute $\\frac{\\partial J}{\\partial x_k^{(i)}}$ for each movie, and one for looping over users to compute $\\frac{\\partial J}{\\partial \\theta_k^{(j)}}$ for each user).\n",
"
\n",
"\n",
"\n",
"**Implementation Tip:** To perform the vectorization, you might find this helpful: You should come up with a way to compute all the derivatives associated with $x_1^{(i)} , x_2^{(i)}, \\dots , x_n^{(i)}$ (i.e., the derivative terms associated with the feature vector $x^{(i)}$) at the same time. Let us define the derivatives for the feature vector of the $i^{th}$ movie as:\n",
"\n",
"$$ \\left(X_{\\text{grad}} \\left(i, :\\right)\\right)^T = \n",
"\\begin{bmatrix}\n",
"\\frac{\\partial J}{\\partial x_1^{(i)}} \\\\\n",
"\\frac{\\partial J}{\\partial x_2^{(i)}} \\\\\n",
"\\vdots \\\\\n",
"\\frac{\\partial J}{\\partial x_n^{(i)}}\n",
"\\end{bmatrix} = \\quad\n",
"\\sum_{j:r(i,j)=1} \\left( \\left( \\theta^{(j)} \\right)^T x^{(i)} - y^{(i,j)} \\right) \\theta^{(j)}\n",
"$$\n",
"\n",
"To vectorize the above expression, you can start by indexing into `Theta` and `Y` to select only the elements of interests (that is, those with `r[i, j] = 1`). Intuitively, when you consider the features for the $i^{th}$ movie, you only need to be concerned about the users who had given ratings to the movie, and this allows you to remove all the other users from `Theta` and `Y`.
\n",
"\n",
"\n",
"Concretely, you can set `idx = np.where(R[i, :] == 1)[0]` to be a list of all the users that have rated movie $i$. This will allow you to create the temporary matrices `Theta_temp = Theta[idx, :]` and `Y_temp = Y[i, idx]` that index into `Theta` and `Y` to give you only the set of users which have rated the $i^{th}$ movie. This will allow you to write the derivatives as:
\n",
"\n",
"`X_grad[i, :] = np.dot(np.dot(X[i, :], Theta_temp.T) - Y_temp, Theta_temp)`\n",
"\n",
"
\n",
"Note that the vectorized computation above returns a row-vector instead. After you have vectorized the computations of the derivatives with respect to $x^{(i)}$, you should use a similar method to vectorize the derivatives with respect to $θ^{(j)}$ as well.\n",
"
\n",
"\n",
"[Click here to go back to the function `cofiCostFunc` to update it](#cofiCostFunc). \n",
"\n",
" Do not forget to re-execute the cell containg the function `cofiCostFunc` so that it is updated with your implementation of the gradient computation."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# Check gradients by running checkcostFunction\n",
"utils.checkCostFunction(cofiCostFunc)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"*You should now submit your solutions*"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"grader[4] = cofiCostFunc\n",
"grader.grade()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"\n",
"#### 2.2.3 Regularized cost function\n",
"\n",
"The cost function for collaborative filtering with regularization is given by\n",
"\n",
"$$ J(x^{(1)}, \\dots, x^{(n_m)}, \\theta^{(1)}, \\dots, \\theta^{(n_u)}) = \\frac{1}{2} \\sum_{(i,j):r(i,j)=1} \\left( \\left( \\theta^{(j)} \\right)^T x^{(i)} - y^{(i,j)} \\right)^2 + \\left( \\frac{\\lambda}{2} \\sum_{j=1}^{n_u} \\sum_{k=1}^{n} \\left( \\theta_k^{(j)} \\right)^2 \\right) + \\left( \\frac{\\lambda}{2} \\sum_{i=1}^{n_m} \\sum_{k=1}^n \\left(x_k^{(i)} \\right)^2 \\right) $$\n",
"\n",
"You should now add regularization to your original computations of the cost function, $J$. After you are done, the next cell will run your regularized cost function, and you should expect to see a cost of about 31.34.\n",
"\n",
"[Click here to go back to the function `cofiCostFunc` to update it](#cofiCostFunc)\n",
" Do not forget to re-execute the cell containing the function `cofiCostFunc` so that it is updated with your implementation of regularized cost function."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# Evaluate cost function\n",
"J, _ = cofiCostFunc(np.concatenate([X.ravel(), Theta.ravel()]),\n",
" Y, R, num_users, num_movies, num_features, 1.5)\n",
" \n",
"print('Cost at loaded parameters (lambda = 1.5): %.2f' % J)\n",
"print(' (this value should be about 31.34)')"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"*You should now submit your solutions.*"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"grader[5] = cofiCostFunc\n",
"grader.grade()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"\n",
"#### 2.2.4 Regularized gradient\n",
"\n",
"Now that you have implemented the regularized cost function, you should proceed to implement regularization for the gradient. You should add to your implementation in `cofiCostFunc` to return the regularized gradient\n",
"by adding the contributions from the regularization terms. Note that the gradients for the regularized cost function is given by:\n",
"\n",
"$$ \\frac{\\partial J}{\\partial x_k^{(i)}} = \\sum_{j:r(i,j)=1} \\left( \\left(\\theta^{(j)}\\right)^T x^{(i)} - y^{(i,j)} \\right) \\theta_k^{(j)} + \\lambda x_k^{(i)} $$\n",
"\n",
"$$ \\frac{\\partial J}{\\partial \\theta_k^{(j)}} = \\sum_{i:r(i,j)=1} \\left( \\left(\\theta^{(j)}\\right)^T x^{(i)}- y^{(i,j)} \\right) x_k^{(i)} + \\lambda \\theta_k^{(j)} $$\n",
"\n",
"This means that you just need to add $\\lambda x^{(i)}$ to the `X_grad[i,:]` variable described earlier, and add $\\lambda \\theta^{(j)}$ to the `Theta_grad[j, :]` variable described earlier.\n",
"\n",
"[Click here to go back to the function `cofiCostFunc` to update it](#cofiCostFunc)\n",
" Do not forget to re-execute the cell containing the function `cofiCostFunc` so that it is updated with your implementation of the gradient for the regularized cost function.\n",
"\n",
"After you have completed the code to compute the gradients, the following cell will run another gradient check (`utils.checkCostFunction`) to numerically check the implementation of your gradients."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# Check gradients by running checkCostFunction\n",
"utils.checkCostFunction(cofiCostFunc, 1.5)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"*You should now submit your solutions.*"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"grader[6] = cofiCostFunc\n",
"grader.grade()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 2.3 Learning movie recommendations \n",
"\n",
"After you have finished implementing the collaborative filtering cost function and gradient, you can now start training your algorithm to make movie recommendations for yourself. In the next cell, you can enter your own movie preferences, so that later when the algorithm runs, you can get your own movie recommendations! We have filled out some values according to our own preferences, but you should change this according to your own tastes. The list of all movies and their number in the dataset can be found listed in the file `Data/movie_idx.txt`."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# Before we will train the collaborative filtering model, we will first\n",
"# add ratings that correspond to a new user that we just observed. This\n",
"# part of the code will also allow you to put in your own ratings for the\n",
"# movies in our dataset!\n",
"movieList = utils.loadMovieList()\n",
"n_m = len(movieList)\n",
"\n",
"# Initialize my ratings\n",
"my_ratings = np.zeros(n_m)\n",
"\n",
"# Check the file movie_idx.txt for id of each movie in our dataset\n",
"# For example, Toy Story (1995) has ID 1, so to rate it \"4\", you can set\n",
"# Note that the index here is ID-1, since we start index from 0.\n",
"my_ratings[0] = 4\n",
"\n",
"# Or suppose did not enjoy Silence of the Lambs (1991), you can set\n",
"my_ratings[97] = 2\n",
"\n",
"# We have selected a few movies we liked / did not like and the ratings we\n",
"# gave are as follows:\n",
"my_ratings[6] = 3\n",
"my_ratings[11]= 5\n",
"my_ratings[53] = 4\n",
"my_ratings[63] = 5\n",
"my_ratings[65] = 3\n",
"my_ratings[68] = 5\n",
"my_ratings[182] = 4\n",
"my_ratings[225] = 5\n",
"my_ratings[354] = 5\n",
"\n",
"print('New user ratings:')\n",
"print('-----------------')\n",
"for i in range(len(my_ratings)):\n",
" if my_ratings[i] > 0:\n",
" print('Rated %d stars: %s' % (my_ratings[i], movieList[i]))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### 2.3.1 Recommendations\n",
"\n",
"After the additional ratings have been added to the dataset, the script\n",
"will proceed to train the collaborative filtering model. This will learn the\n",
"parameters X and Theta. To predict the rating of movie i for user j, you need to compute (θ (j) ) T x (i) . The next part of the script computes the ratings for\n",
"all the movies and users and displays the movies that it recommends (Figure\n",
"4), according to ratings that were entered earlier in the script. Note that\n",
"you might obtain a different set of the predictions due to different random\n",
"initializations."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# Now, you will train the collaborative filtering model on a movie rating \n",
"# dataset of 1682 movies and 943 users\n",
"\n",
"# Load data\n",
"data = loadmat(os.path.join('Data', 'ex8_movies.mat'))\n",
"Y, R = data['Y'], data['R']\n",
"\n",
"# Y is a 1682x943 matrix, containing ratings (1-5) of 1682 movies by \n",
"# 943 users\n",
"\n",
"# R is a 1682x943 matrix, where R(i,j) = 1 if and only if user j gave a\n",
"# rating to movie i\n",
"\n",
"# Add our own ratings to the data matrix\n",
"Y = np.hstack([my_ratings[:, None], Y])\n",
"R = np.hstack([(my_ratings > 0)[:, None], R])\n",
"\n",
"# Normalize Ratings\n",
"Ynorm, Ymean = utils.normalizeRatings(Y, R)\n",
"\n",
"# Useful Values\n",
"num_movies, num_users = Y.shape\n",
"num_features = 10\n",
"\n",
"# Set Initial Parameters (Theta, X)\n",
"X = np.random.randn(num_movies, num_features)\n",
"Theta = np.random.randn(num_users, num_features)\n",
"\n",
"initial_parameters = np.concatenate([X.ravel(), Theta.ravel()])\n",
"\n",
"# Set options for scipy.optimize.minimize\n",
"options = {'maxiter': 100}\n",
"\n",
"# Set Regularization\n",
"lambda_ = 10\n",
"res = optimize.minimize(lambda x: cofiCostFunc(x, Ynorm, R, num_users,\n",
" num_movies, num_features, lambda_),\n",
" initial_parameters,\n",
" method='TNC',\n",
" jac=True,\n",
" options=options)\n",
"theta = res.x\n",
"\n",
"# Unfold the returned theta back into U and W\n",
"X = theta[:num_movies*num_features].reshape(num_movies, num_features)\n",
"Theta = theta[num_movies*num_features:].reshape(num_users, num_features)\n",
"\n",
"print('Recommender system learning completed.')"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"After training the model, you can now make recommendations by computing the predictions matrix."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"p = np.dot(X, Theta.T)\n",
"my_predictions = p[:, 0] + Ymean\n",
"\n",
"movieList = utils.loadMovieList()\n",
"\n",
"ix = np.argsort(my_predictions)[::-1]\n",
"\n",
"print('Top recommendations for you:')\n",
"print('----------------------------')\n",
"for i in range(10):\n",
" j = ix[i]\n",
" print('Predicting rating %.1f for movie %s' % (my_predictions[j], movieList[j]))\n",
"\n",
"print('\\nOriginal ratings provided:')\n",
"print('--------------------------')\n",
"for i in range(len(my_ratings)):\n",
" if my_ratings[i] > 0:\n",
" print('Rated %d for %s' % (my_ratings[i], movieList[i]))"
]
}
],
"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.9.5"
}
},
"nbformat": 4,
"nbformat_minor": 4
}