Creating MLP model to predict the ratings that a user will give to an unseen movie using PyTorch
For my project , i’m trying to predict the ratings that a user will give to an unseen movie, based on the ratings he gave to other movies. I’m using the movielens dataset.The Main folder, which is ml-100k contains informations about 100,000 movies.
Before processing the data, the main data (ratings data) contains user ID, movie ID, user rating from 0 to 5 and timestamps(not considered for this project).I then split the data into Training set(80%) and test data(20%) using sklearn Library.
To create the recommendation systems, the model ‘Stacked-Autoencoder’ is being used. I’m using PyTorch and the code is implemented on Google Colab. The project is based on this https://towardsdatascience.com/stacked-auto-encoder-as-a-recommendation-system-for-movie-rating-prediction-33842386338
I'm new to deep Learning and I want to compare this model(Stacked_Autoencoder) to another Deep Learning model. For Instance,I want to use Multilayer Perception(MLP). This is for research purposes. This is the code below for creating Stacked-Autoencoder model and training  the model.
### Part 1 : Archirecture of the AutoEncoder 

#nn.Module is a parent class 
# SAE is a child class of the parent class nn.Module
class SAE(nn.Module): 
# self is the object of the SAE class 

# Archirecture 
    def __init__(self, ): 
    # self can use alll the methods of the class nn.Module
        super(SAE,self).__init__()
    # Full connected layer  n°1, input and 20 neurons-nodes of the first layer
    # one neuron can be the genre of the movie
    
    # Encode step 
        self.fc1 = nn.Linear(nb_movies,20)
    # Full connected layer n°2 
        self.fc2 = nn.Linear(20,10)
    
    # Decode step 
    # Full connected layer n°3
        self.fc3 = nn.Linear(10,20) 
    # Full connected layer n°4
        self.fc4 = nn.Linear(20,nb_movies) 
    # Sigmoid activation function 
        self.activation = nn.Sigmoid()

# Action : activation of the neurons
def forward(self, x) : 
        x = self.activation(self.fc1(x))
        x = self.activation(self.fc2(x))
        x = self.activation(self.fc3(x))
        # dont's use the activation function 
        # use the linear function only 
        x = self.fc4(x)
        # x is th evector of predicted ratings
        return x 

# Create the AutoEncoder object 
sae=SAE()
#MSE Loss : imported from torch.nn 
criterion=nn.MSELoss() 
# RMSProp optimizer (update the weights) imported from torch.optim 
#sea.parameters() are weights and bias adjusted during the training
optimizer=optim.RMSProp(sae.parameters(),lr=0.01, weight_decay=0.5)

### Part 2 : Training of the SAE 
# number of epochs 
nb_epochs = 200 
# Epoch forloop 
for epoch in range(1, nb_epoch+1): 
        # at the beginning the loss is at zero
        s=0.
        train_loss = 0 

        #Users forloop 
        for id_user in range(nb_users)
            # add one dimension to make a two dimension vector.
            # create a new dimension and put it the first position .unsqueeze[0]
            input = Variable(training_set[id_user].unsqueeze[0])
            
            # clone the input to obtain the target  
            target= input.clone()
            
            # target.data are all the ratings 
            # ratings &gt; 0
            if torch.sum(target.data &gt;0) &gt; 0
                output = sae(input)
                # don't compute the gradients regarding the target
                target.require_grad=False 
                # only deal with true ratings 
                output[target==0]=0
                
                # Loss Criterion 
                loss =criterion(output,target)
                
                # Average the error of the movies that don't have zero ratings
                mean_corrector=nb_movies/float(torch.sum(target.data&gt;0)+1e-10)
                
                # Direction of the backpropagation 
                loss.backward()
                train_loss+=np.sqrt(loss.data[0]*mean_corrector)
                s+=1.
                
                # Intensity of the backpropagation 
                optimizer.step()
        
    print('epoch:' +str (epoch)+'loss:' +str(train_loss/s)

)
If I want to train using the MLP model. How can I implement this class model?
Also, What other deep learning model(Beside MLP) that I can use to compare with Stacked-Autoencoder?
Thanks.

An MLP is not suited for recommendations. If you want to go this route, you will need to create an embedding for your userid and another for your itemid and then add linear layers on top of the embeddings. Your target will be to predict the rating for a userid-itemid pair.
I suggest you take a look at variational autoencoders (VAE). They give state-of-the-art results in recommender systems. They will also give a fair comparaison with your stacked-autoencoder. Here's the research paper applying VAE for collaborative filtering : https://arxiv.org/pdf/1802.05814.pdf
