 ``` python
from fastai.collab import *
from fastai.tabular.all import *
path = untar_data(URLs.ML_100k)

ratings = pd.read_csv(path/'u.data', delimiter='\t', 
                                        header=None,
                                         names='user','movie','rating','timestamp'])


```

Load Data

There are some rows and columns with empty values and the goal would be for the model to learn how to fill in these values.

Crosstab Representation

What does the term **latent factors** refer to ? Latent factors are those factors which are important in order to make recommendation predictions, but these factors are not directly given to the model, they are learned during training. That's why they are called **latent**. 

First step for is to randomly initialize the parameters. These parameters would be the set of latent factors for each user and movie. The number of latent factors can be explicitly chosen.

Second step is to make predictions using our latent factors. 

Third step is to calculate loss. 

Then the optimization starts in order to minimize the loss. 

Learning the Latent Factors (collaborative filtering)

Latent Factors with Crosstab

```python
class DotProductBias(Module):
  def __init__(self, n_users, n_movies, n_factors, y_range=(0,5.5)):
    self.user_factors = Embedding(n_users, n_factors)
    self.user_bias = Embedding(n_users, 1)
    self.movie_factors = Embedding(n_movies, n_factors)
    self.movie_bias = Embedding(n_movies, 1)
    self.y_range = y_range
  def forward(self, x):
    users = self.user_factors(x[:,0])
    movies = self.movie_factors(x[:,1])
    res = (users * movies).sum(dim=1, keepdim=True)
    res += self.user_bias(x[:,0]) + self.movie_bias(x[:,1])
    return sigmoid_range(res, *self.y_range)

model = DotProductBias(n_users, n_movies, 50)
learn = Learner(dls, model, loss_func=MSELossFlat())
learn.fit_one_cycle(5, 5e-3)

```

Code for Collaborative Filtering From Scratch

Movielens dataset contains millions of movie ratings data, namely, these are the combination of movie and user IDs and numerical rating. This dataset can be used to practice for recommendation problems. 

San Diego State University

This methodology is frequently used in recommendation problems. The examples  include deciding which stories to show on social media feed, which movies to suggest to user and many more.  In simple terms **collaborative filtering** finds what particular user liked and tries to find users with similar preferences and based on this information it would recommend to the current user the items that these other users liked. 

Collaborative Filtering

https://www.amazon.com/Deep-Learning-Coders-fastai-PyTorch/dp/1492045527

Reference for Deep Learning for Coders with Fastai and PyTorch: AI Applications Without a PhD 1st Edition


MovieLens Data for Collaborative Filtering

**Bootstrapping problem** is one of the major weaknesses of collaborative filtering. It means that the model / system cannot make any recommendations or draw any inferences for users or items about which it has not yet gathered sufficient information. It’s also called the cold start problem. There are several different approaches to solve this issue.  For instance, we can come up with an average embedding for a user or movie. Another option can be to select a particular user/movie to represent the average user/movie. Additionally, we can define several questions that could help initialize the embedding vectors for new users and movies.

Bootstrapping Problem in Collaborative Filtering

In collaborative filtering models, bias terms compensate for the baseline tendencies of specific users or items. Item bias accounts for items that systematically receive exceptionally high or low ratings across the board. User bias accounts for users who consistently give higher or lower ratings than the average user, adjusting for these systematic deviations.

Learn Before

Related

Learn After