# 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: <br> # # `X_grad[i, :] = np.dot(np.dot(X[i, :], Theta_temp.T) - Y_temp, Theta_temp)` # # <br><br> # 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. # </div> # # [Click here to go back to the function `cofiCostFunc` to update it](#cofiCostFunc). # # <font color="red"> Do not forget to re-execute the cell containg the function `cofiCostFunc` so that it is updated with your implementation of the gradient computation.</font> # In[5]: # Check gradients by running checkcostFunction utils.checkCostFunction(cofiCostFunc) # <a id="section5"></a> # #### 2.2.3 Regularized cost function # # The cost function for collaborative filtering with regularization is given by # # $$ 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) $$ # # 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. # # [Click here to go back to the function `cofiCostFunc` to update it](#cofiCostFunc) # <font color="red"> Do not forget to re-execute the cell containing the function `cofiCostFunc` so that it is updated with your implementation of regularized cost function.</font> # In[6]:
num_users = 4 num_movies = 5 num_features = 3 X = X[:num_movies, :num_features] Theta = Theta[:num_users, :num_features] Y = Y[:num_movies, 0:num_users] R = R[:num_movies, 0:num_users] # Evaluate cost function J, _ = cofiCostFunc(np.concatenate([X.ravel(), Theta.ravel()]), Y, R, num_users, num_movies, num_features, 1.5) print('Cost at loaded parameters: %.2f \n(this value should be about 31.34)' % J) utils.checkCostFunction(cofiCostFunc, 1.5) ##### passed # Before we will train the collaborative filtering model, we will first # add ratings that correspond to a new user that we just observed. This # part of the code will also allow you to put in your own ratings for the # movies in our dataset! movieList = utils.loadMovieList() n_m = len(movieList) # Initialize my ratings my_ratings = np.zeros(n_m) # Check the file movie_idx.txt for id of each movie in our dataset # For example, Toy Story (1995) has ID 1, so to rate it "4", you can set # Note that the index here is ID-1, since we start index from 0. my_ratings[0] = 4