Creating MLP model to predict the ratings that a user will give to an unseen movie

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

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
    # 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 
#MSE Loss : imported from torch.nn 
# 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
        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()
            # are all the ratings 
            # ratings > 0
            if torch.sum( >0) > 0
                output = sae(input)
                # don't compute the gradients regarding the target
                # only deal with true ratings 
                # Loss Criterion 
                loss =criterion(output,target)
                # Average the error of the movies that don't have zero ratings
                # Direction of the backpropagation 
                # Intensity of the backpropagation 
    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?