Hello all,

I’m trying to execute a modified version of matrix factorization via deep learning. The goal is to find a matrix of shape [9724x300] where the rows are items and there are (arbitrarily) 300 features. The function would be optimized when the dot product of vector_i and vector_j are really, really close to the value in the interaction matrix, Xij.

Xij has dimensions [9724x9724] where the value in cell [0,1] is the number of users who liked both items i and j. Ergo, when optimized, Vi*VjT should be really close to the number of users who liked both items i and j.

I’ve modified this code from a tutorial. The key difference is that in this resource, the author has a user-to-item matrix, not an item-to-item matrix.

I’m stuck trying to index vectors i and j in tensor self.vectors. It appears the datatype did not match what was expected, despite making i and j into LongTensors.

Any feedback would be appreciated!

```
import torch
from torch.autograd import Variable
class MatrixFactorization(torch.nn.Module):
def __init__(self, n_items=len(movie_ids), n_factors=300):
super().__init__()
self.vectors = nn.Embedding(n_items, n_factors,sparse=True)
def forward(self, i,j):
return (self.vectors([i])*torch.transpose(self.vectors([j]))).sum(1)
def predict(self, i, j):
return self.forward(i, j)
model = MatrixFactorization(n_items= len(movie_ids),n_factors=300)
loss_fn = nn.MSELoss()
optimizer = torch.optim.SGD(model.parameters(), lr=0.01)
for i in range(len(movie_ids)):
for j in range(len(movie_ids)):
# get user, item and rating data
rating = Variable(torch.FloatTensor([Xij[i, j]]))
# predict
i = Variable(torch.LongTensor([int(i)]))
j = Variable(torch.LongTensor([int(j)]))
prediction = model(i, j)
loss = loss_fn(prediction, rating)
# backpropagate
loss.backward()
# update weights
optimizer.step()
```

And the error I receive:

```
TypeError: embedding(): argument 'indices' (position 2) must be Tensor, not list
```