Zeker! Hier is een stapsgewijze gids voor het bouwen van een aanbevelingssysteem met PyTorch voor jouw sparsammaatrix (gebruikers × items): --- ### 1. Gegevensvoorbewerking **Stap 1: Data laden en inspecteren** - Laad je data in bijvoorbeeld een pandas DataFrame. - Bekijk de structuur: gebruikers-ID's, item-ID's en eventueel ratings. **Stap 2: Encoderings- en normalisatietechnieken** - Zet gebruikers en items om in numerieke indices (bijv. via `LabelEncoder`) als dat nog niet is gedaan. - Normaliseer ratings indien nodig (bijvoorbeeld min-max scaling) voor stabiliteit. **Stap 3: Sparse matrix maken** - Gebruik `scipy.sparse` om een sparse matrix te maken: bijvoorbeeld `csr_matrix`. **Voorbeeld:** ```python import pandas as pd from sklearn.preprocessing import LabelEncoder from scipy import sparse # Data inladen df = pd.read_csv('jouw_data.csv') # columns: user_id, item_id, rating # Encoderen user_encoder = LabelEncoder() item_encoder = LabelEncoder() df['user_idx'] = user_encoder.fit_transform(df['user_id']) df['item_idx'] = item_encoder.fit_transform(df['item_id']) # Sparse matrix maken n_users = df['user_idx'].nunique() n_items = df['item_idx'].nunique() ratings_matrix = sparse.csr_matrix( (df['rating'], (df['user_idx'], df['item_idx'])) ) ``` --- ### 2. Modelarchitectuur kiezen **Opties:** - **Collaboratief filteren (matrix factorisatie):** Leer gebruikers- en item-embeddings. - **Inhoudsgebaseerd:** Gebruik itemkenmerken (indien beschikbaar). - **Hybride aanpak:** Combineer beiden. Voor jouw sparsammaatrix is matrix factorisatie met embeddings een goede start. --- ### 3. Model bouwen in PyTorch **Stap 1: Embedding lagen** - Gebruikers- en item-embeddings. **Stap 2: Forward-pass** - Vermenigvuldig embeddings (dot product) en voorspel ratings. **Voorbeeldcode:** ```python import torch import torch.nn as nn class MatrixFactorization(nn.Module): def __init__(self, num_users, num_items, embedding_dim): super().__init__() self.user_embedding = nn.Embedding(num_users, embedding_dim) self.item_embedding = nn.Embedding(num_items, embedding_dim) def forward(self, user_idxs, item_idxs): user_embeds = self.user_embedding(user_idxs) item_embeds = self.item_embedding(item_idxs) pred = (user_embeds * item_embeds).sum(1) return pred ``` --- ### 4. Trainingsstrategieën **Stap 1: Loss-functie** - Bijvoorbeeld MSELoss voor ratings. **Stap 2: Data loader maken** - Laad batches van (user_idx, item_idx, rating). **Stap 3: Training loop** - Idealiter met optimalisatie zoals Adam. - Gebruik reguliere technieken zoals dropout of L2-regulatie indien nodig. **Voorbeeld:** ```python import torch.optim as optim model = MatrixFactorization(n_users, n_items, embedding_dim=50) criterion = nn.MSELoss() optimizer = optim.Adam(model.parameters(), lr=0.01) # Voorbeeld trainingsloop for epoch in range(10): for user_idx, item_idx, rating in dataloader: optimizer.zero_grad() pred = model(user_idx, item_idx) loss = criterion(pred, rating) loss.backward() optimizer.step() print(f"Epoch {epoch+1}, Loss: {loss.item()}") ``` --- ### 5. Aanvullende technieken - **Negatieve sampling:** Voor het trainen met implicit feedback. - **Early stopping:** Om overfitting te voorkomen. - **Hyperparameter tuning:** Via grid search of Bayesian optimization. - **Evaluatie:** Gebruik metrics zoals RMSE, MAE, of ranking-metrics (MAP, NDCG). --- ### Samenvatting - **Voorbewerking:** Encoderen, sparse matrix maken. - **Model:** Embedding-gebaseerd matrix factorisatie in PyTorch. - **Training:** MSE-loss, batchgewijs, optimalisatie. - **Uitbreidingen:** Negatieve sampling, regularisatie, evaluatie. Wil je dat ik specifieke voorbeeldcode voor een volledige werkende implementatie of evaluatie toevoeg?

Zeker, ik help je graag met het bouwen van een aanbevelingssysteem in PyTorch. Hier is een stapsgewijze handleiding: ## 1. Gegevensvoorbewerking ```python import torch import numpy as np from scipy.sparse import csr_matrix from sklearn.model_selection import train_test_split import pandas as pd def prepare_data(sparse_matrix): """Converteer sparse matrix naar PyTorch tensors""" # Converteer naar COO-formaat voor eenvoudige verwerking coo_matrix = sparse_matrix.tocoo() # Haal gebruikers, items en ratings users = torch.tensor(coo_matrix.row, dtype=torch.long) items = torch.tensor(coo_matrix.col, dtype=torch.long) ratings = torch.tensor(coo_matrix.data, dtype=torch.float) return users, items, ratings def split_data(users, items, ratings, test_size=0.2): """Split data in train en test sets""" return train_test_split( users, items, ratings, test_size=test_size, random_state=42 ) ``` ## 2. Modelarchitectuur - Matrix Factorisatie ```python import torch.nn as nn import torch.nn.functional as F class MatrixFactorization(nn.Module): def __init__(self, num_users, num_items, embedding_dim=50): super(MatrixFactorization, self).__init__() self.user_embeddings = nn.Embedding(num_users, embedding_dim) self.item_embeddings = nn.Embedding(num_items, embedding_dim) # Initialisatie nn.init.normal_(self.user_embeddings.weight, std=0.01) nn.init.normal_(self.item_embeddings.weight, std=0.01) def forward(self, user_ids, item_ids): user_emb = self.user_embeddings(user_ids) item_emb = self.item_embeddings(item_ids) # Dot product + bias return (user_emb * item_emb).sum(dim=1) class NeuralMatrixFactorization(nn.Module): """Geavanceerd model met neurale netwerken""" def __init__(self, num_users, num_items, embedding_dim=50, hidden_dims=[64, 32]): super(NeuralMatrixFactorization, self).__init__() self.user_embeddings = nn.Embedding(num_users, embedding_dim) self.item_embeddings = nn.Embedding(num_items, embedding_dim) # MLP voor interacties layers = [] input_dim = embedding_dim * 2 for hidden_dim in hidden_dims: layers.extend([ nn.Linear(input_dim, hidden_dim), nn.ReLU(), nn.Dropout(0.2) ]) input_dim = hidden_dim layers.append(nn.Linear(input_dim, 1)) self.mlp = nn.Sequential(*layers) def forward(self, user_ids, item_ids): user_emb = self.user_embeddings(user_ids) item_emb = self.item_embeddings(item_ids) # Concateneer embeddings interaction = torch.cat([user_emb, item_emb], dim=1) return self.mlp(interaction).squeeze() ``` ## 3. DataLoader en Training Setup ```python from torch.utils.data import Dataset, DataLoader class RecommendationDataset(Dataset): def __init__(self, users, items, ratings): self.users = users self.items = items self.ratings = ratings def __len__(self): return len(self.users) def __getitem__(self, idx): return self.users[idx], self.items[idx], self.ratings[idx] def create_dataloaders(users_train, items_train, ratings_train, users_test, items_test, ratings_test, batch_size=512): train_dataset = RecommendationDataset(users_train, items_train, ratings_train) test_dataset = RecommendationDataset(users_test, items_test, ratings_test) train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True) test_loader = DataLoader(test_dataset, batch_size=batch_size, shuffle=False) return train_loader, test_loader ``` ## 4. Training Strategie ```python def train_model(model, train_loader, test_loader, num_epochs=50, learning_rate=0.001): device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') model = model.to(device) optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate, weight_decay=1e-5) criterion = nn.MSELoss() train_losses = [] test_losses = [] for epoch in range(num_epochs): # Training model.train() total_train_loss = 0 for batch_users, batch_items, batch_ratings in train_loader: batch_users = batch_users.to(device) batch_items = batch_items.to(device) batch_ratings = batch_ratings.to(device) optimizer.zero_grad() predictions = model(batch_users, batch_items) loss = criterion(predictions, batch_ratings) loss.backward() optimizer.step() total_train_loss += loss.item() # Validatie model.eval() total_test_loss = 0 with torch.no_grad(): for batch_users, batch_items, batch_ratings in test_loader: batch_users = batch_users.to(device) batch_items = batch_items.to(device) batch_ratings = batch_ratings.to(device) predictions = model(batch_users, batch_items) loss = criterion(predictions, batch_ratings) total_test_loss += loss.item() avg_train_loss = total_train_loss / len(train_loader) avg_test_loss = total_test_loss / len(test_loader) train_losses.append(avg_train_loss) test_losses.append(avg_test_loss) if (epoch + 1) % 10 == 0: print(f'Epoch {epoch+1}/{num_epochs}, Train Loss: {avg_train_loss:.4f}, Test Loss: {avg_test_loss:.4f}') return train_losses, test_losses ``` ## 5. Evaluatie en Gebruik ```python def evaluate_model(model, test_loader): model.eval() device = next(model.parameters()).device predictions = [] actuals = [] with torch.no_grad(): for batch_users, batch_items, batch_ratings in test_loader: batch_users = batch_users.to(device) batch_items = batch_items.to(device) batch_predictions = model(batch_users, batch_items) predictions.extend(batch_predictions.cpu().numpy()) actuals.extend(batch_ratings.numpy()) from sklearn.metrics import mean_squared_error, mean_absolute_error mse = mean_squared_error(actuals, predictions) mae = mean_absolute_error(actuals, predictions) print(f'MSE: {mse:.4f}, MAE: {mae:.4f}') return mse, mae def get_recommendations(model, user_id, num_items, all_item_ids, k=10): """Genereer aanbevelingen voor een specifieke gebruiker""" device = next(model.parameters()).device model.eval() with torch.no_grad(): user_tensor = torch.tensor([user_id] * len(all_item_ids), dtype=torch.long).to(device) items_tensor = torch.tensor(all_item_ids, dtype=torch.long).to(device) scores = model(user_tensor, items_tensor) top_scores, top_indices = torch.topk(scores, k=k) return top_indices.cpu().numpy(), top_scores.cpu().numpy() ``` ## 6. Volledige Pipeline ```python def main(sparse_matrix): # Stap 1: Data voorbereiden users, items, ratings = prepare_data(sparse_matrix) num_users = sparse_matrix.shape[0] num_items = sparse_matrix.shape[1] # Stap 2: Data splitsen users_train, users_test, items_train, items_test, ratings_train, ratings_test = \ split_data(users, items, ratings) # Stap 3: DataLoaders maken train_loader, test_loader = create_dataloaders( users_train, items_train, ratings_train, users_test, items_test, ratings_test ) # Stap 4: Model initialiseren model = NeuralMatrixFactorization(num_users, num_items, embedding_dim=50) # Stap 5: Trainen train_losses, test_losses = train_model( model, train_loader, test_loader, num_epochs=50, learning_rate=0.001 ) # Stap 6: Evalueren mse, mae = evaluate_model(model, test_loader) return model, train_losses, test_losses # Voorbeeld gebruik: # model, train_loss, test_loss = main(jouw_sparse_matrix) ``` ## Aanvullende Tips: 1. **Hyperparameter tuning**: Experimenteer met embedding dimensies (20-200) 2. **Regularisatie**: Gebruik dropout en weight decay tegen overfitting 3. **Batch normalisatie**: Voor betere training stabiliteit 4. **Learning rate scheduling**: Reduceer learning rate tijdens training 5. **Vroege stop**: Stop training wanneer validatieloss stopt met verbeteren Deze implementatie biedt een solide basis voor collaboratief filteren. Voor inhoudsgebaseerde aanbevelingen zou je item features moeten toevoegen aan de embeddings.