Блог

У меня есть эта модель с 2 встраиванием, которая содержит для пользователей и для предметов 2 веса для пользователей, предметов, и я просто умножаю встраивание(пользователя) на встраивание(предмет) для потерь, которые я использую MSE

 prox = nn.Threshold(0,0)
def l2_regularize(array):
    loss = torch.sum(array ** 2.0)
    return loss
htanh = torch.nn.Hardtanh(min_val=1, max_val=5)
class MF(torch.nn.Module):
    def __init__(self, n_users, n_items, n_factors=8, c_vector=1e-6, c_bias=1e-6): 
        super().__init__()
        self.n_users = n_users
        self.n_items = n_items
        self.c_bias = c_bias
        self.c_vector = c_vector
        self.user_factors = torch.nn.Embedding(n_users, n_factors, sparse=True) #u
        self.item_factors = torch.nn.Embedding(n_items, n_factors, sparse=True) #q
        self.bias_user = nn.Embedding(n_users, 1)
        self.bias_item = nn.Embedding(n_items, 1)
        self.bias = nn.Parameter(torch.ones(1))

    def __call__(self,df):
        user_id = df[:, 0]
        item_id = df[:, 1]
        vector_user = self.user_factors(user_id)
        vector_item = self.item_factors(item_id)
        bias_user = self.bias_user(user_id).squeeze()
        bias_item = self.bias_item(item_id).squeeze()
        
        biases = (self.bias   bias_user   bias_item)        
        ui_interaction = torch.sum(vector_user * vector_item, dim=-1)
        prediction = ui_interaction   biases
        
        return prox(prediction.squeeze()) #htanh(prediction.squeeze())?
         
    def loss(self, prediction, target):
        loss_mse = F.mse_loss(prediction, target.squeeze())
        
        prior_bias_user =  l2_regularize(self.bias_user.weight) * self.c_bias
        prior_bias_item = l2_regularize(self.bias_item.weight) * self.c_bias
        
        prior_user =  l2_regularize(self.user_factors.weight) * self.c_vector
        prior_item = l2_regularize(self.item_factors.weight) * self.c_vector
        total = loss_mse   prior_user   prior_item   prior_bias_user   prior_bias_item
        return total
 

И этот код для поезда

 model = MF(n_users, n_items)
optimizer = torch.optim.SGD(model.parameters(),lr=1e-2)
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
hist_loss=[]
epochs= 1

model.train()
for epoch in range(epochs):
    for batch in tqdm(train_dataloader):        
        for uid,mid,target in batch:         
            
            optimizer.zero_grad()

            rating = torch.FloatTensor([target]).to(device)     
            uid = torch.LongTensor([int(uid)]).to(device)
            mid = torch.LongTensor([int(mid)]).to(device)
            model = model.to(device)
            prediction = model(torch.tensor([[uid,mid]]).to(device))
    
            loss = model.loss(prediction,rating)
            loss.backward()
            
            optimizer.step()                      
            hist_loss.append(loss)
 

Я использую набор данных MovieLens, но модель не обучается. На наборе проверки я вижу прогноз 20, когда цели = {1,5}. Что не так в моем коде?