Collaborative Recommender System for Music using Pytorch. Combine Matrix Factorization and Neural Networks for improved performance. Python sample code included.

1. Music Entertainment System
Collaborative Recommender
System for Music
Valentin Nagacevschi

2. What to listen next …..

3. Music Entertainment System
Why Recommender Systems?
• Information overload too many choices
• Help users find items of their interest
• Help item providers deliver items to right users
• Help platforms build user engagement

4. Music Entertainment System
What is a Recommender System?
• Most successful and widespread application of ML in business.
• Many users interact with many items: predict items for users
• Applied Movies, Books, Music, Retail, etc.

5. The Goal of Recommender System
Relevance Novelty
Serendipity Diversity

6. Music Entertainment System
Domains
• Media
News, videos, movies, music
• eCommerce
Product recommendation
• Jobs
Personalised job boards, newsletters with best matching jobs
• Travel & Real Estate
Events, Places, Hotels, Restaurants, Flights, Car Rentals
• Education
Personalised education - materials, courses, specialisations, skills

7. Music Entertainment System
Types of Recommender Systems
• Content-based recommendation systems
• Item bases / User based
• Need information for items or users to calculate similarities
• Collaborative recommendation system
• People like
• things similar to other things they like
• things that are liked by other people with similar taste

8. Collaborative Filtering
Memory based approach
Model based approach
Find similar users based on cosine
similarity or Pearson correlation and
use weighted average of ratings
Use machine learning to find user
ratings of unrated items using Matrix
Factorization and Neural Networks

10. Music Entertainment System
Matrix Factorization

11. Music Entertainment System
Ratings vs. Interactions
• Ratings
• Normally 1 - 5
• Unreliable and biased
• Interactions
• Normally 0 - 1
• Cannot capture dislikes

12. Music Entertainment System
Music Interactions Dataset
user_id track_id gt30 lt30 rating
0 133575735 15717314 1 0
1 133575735 29494564 3 1
2 133575735 31531850 1 0
3 133575735 37472673 2 0
4 133575735 42984237 0 1

13. Music Entertainment System
Prepare Music Data
• No ratings, but better than interactions
• Labels standard: 30 seconds threshold
• Derived ratings:
3 + (gt30 - lt30) if (gt30 - lt30) >= 0
2 + (gt30 - lt30) if (gt30 - lt30) < 0

14. Rating - Before and After

15. Music Entertainment System
Why PyTorch ?
• Dynamic approach to Graph Computation
• Increased developer productivity
• Easier to learn and simpler to code
• Easy to debug
• Simplicity and transparency

16. Music Entertainment System
Matrix Factorization Model
import torch.nn as nn
import torch.optim as optim
class MatrixFactorization(nn.Module):
def __init__(self, n_users, n_items, n_factors=20):
super().__init__()
self.user_factors = nn.Embedding(n_users, n_factors, sparse=True)
self.item_factors = nn.Embedding(n_items, n_factors, sparse=True)
self.user_biases = nn.Embedding(n_users, 1, sparse=True)
self.item_biases = nn.Embedding(n_items, 1, sparse=True)
def forward(self, user, item):
dot = (self.user_factors(user) * self.item_factors(item)).sum(1)
bias = self.user_biases(user) + self.item_biases(item)
return dot + bias

17. Music Entertainment System
Model and Data Preparation
model = MatrixFactorization(1000, 1000)
loss_func = nn.MSELoss()
optimizer = optim.SGD(model.parameters(), lr=1e-6)
# shuffle training data
rows, cols = ratings.nonzero()
p = np.random.permutation(len(rows))
rows, cols = rows[p], cols[p]

18. Music Entertainment System
Train the Model
for row, col in zip(*(rows, cols)):
# Turn data into variables
rating = Variable(torch.FloatTensor([ratings[row, col]]))
row = Variable(torch.LongTensor([np.long(row)]))
col = Variable(torch.LongTensor([np.long(col)]))
# Predict and calculate loss
prediction = model(row, col)
loss = loss_func(prediction, rating)
# Backpropagate
loss.backward()
# Update the parameters
optimizer.step()

19. Music Entertainment System
SpotLight Library
dataset = get_music_dataset(variant=‘100K')
train, test = random_train_test_split(dataset)
model = ExplicitFactorizationModel(
loss=‘regression', # loss function
embedding_dim=40, # latent dimensionality
n_iter=12, # number of epochs of training
batch_size=1024, # minibatch size
l2=1e-9, # strength of L2 regularization
learning_rate=0.1)
model.fit(train)
train_rmse = rmse_score(model, train) # 0.907
test_rmse = rmse_score(model, test) # 0.946
Maciej Kula

20. Music Entertainment System
Neural Collaborative Filtering
Layer 1
Layer 2
Layer x
0 0 0 0 0 0 ……
Item Latent Vector
0 0 0 0 0 0 ……
User Latent Vector
Y
^
ui Yui
Training TargetOutput Layer
Neural CF Layers
Embeddings Layers
Input Layers
Dr. Xiangnan He - 2017

21. Music Entertainment System
Layer 1
Layer 2
Layer x
0 0 0 0 0 0 ……0 0 0 0 0 0 ……
Y
^
ui Yui
Training
MF User Vector MLP User Vector MF Item Vector MLP Item Vector
MF Layer
NeuMF Layer
Concatenation
Dot Product
Concatenation
Dr. Xiangnan He - 2017

22. Music Entertainment System
def __init__(self, config):
super(NeuMF, self).__init__()
self.dim_mf = config[‘dim_mf']
self.dim_mlp = config[‘dim_mlp']
#mf part
self.user_mf = nn.Embedding(num_embeddings=self.num_users, embedding_dim=self.dim_mf)
self.item_mf = nn.Embedding(num_embeddings=self.num_items, embedding_dim=self.dim_mf)
#mlp part
self.user_mlp = nn.Embedding(num_embeddings=self.num_users, embedding_dim=self.dim_mlp)
self.item_mlp = nn.Embedding(num_embeddings=self.num_items, embedding_dim=self.dim_mlp)
self.fc_layers = nn.ModuleList()
for (in_size, out_size) in enumerate(zip(config['layers'][:-1], config['layers'][1:])):
self.fc_layers.append(nn.Linear(in_size, out_size))
self.logist = nn.Linear(in_features=config['layers'][-1] + self.dim_mf, out_features=1)
self.sigmoid = nn.Sigmoid()

23. Music Entertainment System
def forward(self, user, item):
user_embedding_mlp = self.embedding_user_mlp(user)
item_embedding_mlp = self.embedding_item_mlp(item)
user_embedding_mf = self.embedding_user_mf(user)
item_embedding_mf = self.embedding_item_mf(item)
#### mf part
mf_vector =torch.mul(user_embedding_mf, item_embedding_mf)
#### mlp part
mlp_vector = torch.cat([user_embedding_mlp, item_embedding_mlp], dim=-1)
for idx, _ in enumerate(range(len(self.fc_layers))):
mlp_vector = self.fc_layers[idx](mlp_vector)
mlp_vector = nn.ReLU()(mlp_vector)
vector = torch.cat([mlp_vector, mf_vector], dim=-1)
logits = self.logist(vector)
output = self.sigmoid(logits)
return output

24. Music Entertainment System
Next Steps
• Group Collaborative Recommender System
• Collaborative Recommender for Playlists
• Add meta content into mix, such as genre, artist, album, year
• Consider audio features: Tempo, Time signature, Mode, Key,
Loudness, Danceability, Energy, Timbre, Beat, Mel spectrogram.

25. Music Entertainment System
Takeaways
• Collaborative Recommender - perfect for user/item interactions
(explicit or implicit)
• Matrix Factorization models performs good in most of the cases
• MF - a particular case for Neural Collaborative Filtering
• Combine pre-trained MF and NCF for even better performance
• PyTorch is the best choice for both research and production

26. Thank you !
linkedin.com/in/vnagacevschi/