tessl/pypi-fastai

fastai simplifies training fast and accurate neural nets using modern best practices

—

Pending

Overview

Eval results

Files

Collaborative Filtering

Name: tessl/pypi-fastai
Author: tessl

Recommendation system capabilities including specialized learners and models for collaborative filtering tasks, matrix factorization, and neural collaborative filtering approaches.

Capabilities

Collaborative Filtering Learner

Main entry point for creating recommendation system learners using collaborative filtering techniques.

def collab_learner(dls, n_factors=50, use_nn=False, emb_szs=None, layers=None, 
                   config=None, y_range=None, loss_func=None, **kwargs):
    """
    Create a collaborative filtering learner.
    
    Parameters:
    - dls: CollabDataLoaders with user-item interaction data
    - n_factors: Number of factors/embeddings for matrix factorization
    - use_nn: Use neural network instead of dot product
    - emb_szs: Custom embedding sizes for users and items
    - layers: Hidden layer sizes for neural collaborative filtering
    - config: Model configuration dictionary
    - y_range: Range of rating values
    - loss_func: Loss function (MSE for ratings, BCE for binary)
    - **kwargs: Additional learner arguments
    
    Returns:
    - Learner instance for collaborative filtering
    """

Collaborative Filtering Data Processing

Specialized data loaders for recommendation datasets with user-item interactions.

class CollabDataLoaders(DataLoaders):
    """DataLoaders for collaborative filtering datasets."""
    
    @classmethod
    def from_csv(cls, path, csv_name='ratings.csv', header='infer', delimiter=None,
                 user_name=None, item_name=None, rating_name=None, valid_pct=0.2, 
                 seed=None, **kwargs):
        """
        Create CollabDataLoaders from CSV file.
        
        Parameters:
        - path: Path to data directory
        - csv_name: Name of CSV file with ratings
        - header: CSV header handling
        - delimiter: CSV delimiter
        - user_name: Column name for user IDs (auto-detected if None)
        - item_name: Column name for item IDs (auto-detected if None)  
        - rating_name: Column name for ratings (auto-detected if None)
        - valid_pct: Validation split percentage
        - seed: Random seed for splitting
        
        Returns:
        - CollabDataLoaders instance
        """
    
    @classmethod
    def from_df(cls, ratings, valid_pct=0.2, user_name=None, item_name=None, 
                rating_name=None, seed=None, **kwargs):
        """
        Create from pandas DataFrame.
        
        Parameters:
        - ratings: DataFrame with user-item ratings
        - valid_pct: Validation percentage
        - user_name: User column name
        - item_name: Item column name
        - rating_name: Rating column name
        - seed: Random seed
        
        Returns:
        - CollabDataLoaders instance
        """

class CollabBlock(TransformBlock):
    """Transform block for collaborative filtering data."""
    
    def __init__(self): ...

Collaborative Filtering Models

Model architectures for different collaborative filtering approaches.

class EmbeddingDotBias(nn.Module):
    """
    Matrix factorization model with bias terms.
    Standard approach using dot product of user and item embeddings with biases.
    """
    
    def __init__(self, n_users, n_items, n_factors, y_range=(0, 5.5)):
        """
        Initialize embedding dot bias model.
        
        Parameters:
        - n_users: Number of unique users
        - n_items: Number of unique items
        - n_factors: Number of embedding factors
        - y_range: Range of rating values
        """
    
    def forward(self, users, items):
        """
        Forward pass computing predictions.
        
        Parameters:
        - users: User ID tensor
        - items: Item ID tensor
        
        Returns:
        - Predicted ratings tensor
        """

class EmbeddingNN(nn.Module):
    """
    Neural collaborative filtering model.
    Uses neural network on concatenated user and item embeddings.
    """
    
    def __init__(self, n_users, n_items, n_factors, layers, y_range=(0, 5.5), 
                 use_bn=True, emb_drop=0.0, lin_drop=0.0):
        """
        Initialize neural collaborative filtering model.
        
        Parameters:
        - n_users: Number of unique users
        - n_items: Number of unique items  
        - n_factors: Number of embedding factors
        - layers: List of hidden layer sizes
        - y_range: Range of rating values
        - use_bn: Use batch normalization
        - emb_drop: Embedding dropout probability
        - lin_drop: Linear layer dropout probability
        """
    
    def forward(self, users, items):
        """Forward pass through neural network."""

class CollabTensorBias(TensorBase):
    """Tensor class for collaborative filtering with bias terms."""
    
    def show(self, ctx=None, **kwargs): ...

Collaborative Filtering Utilities

Utility functions for working with recommendation data and evaluation.

def get_collab_learner(dls, n_factors=50, use_nn=False, **kwargs):
    """Create collaborative filtering learner (alias for collab_learner)."""

def collab_config(**kwargs):
    """Get default configuration for collaborative filtering models."""

def split_collab_data(df, valid_pct=0.2, seed=None, user_name=None, 
                      item_name=None, rating_name=None):
    """
    Split collaborative filtering data maintaining user/item coverage.
    
    Parameters:
    - df: DataFrame with ratings data
    - valid_pct: Validation percentage
    - seed: Random seed
    - user_name: User column name
    - item_name: Item column name
    - rating_name: Rating column name
    
    Returns:
    - (train_df, valid_df)
    """

def collab_bias(n_factors=50, y_range=None):
    """Create embedding dot bias model."""

def collab_nn(n_factors=50, layers=None, y_range=None, **kwargs):
    """Create neural collaborative filtering model."""

Recommendation Metrics

Specialized metrics for evaluating recommendation systems.

def mean_reciprocal_rank(pred, targ, k=None):
    """
    Mean Reciprocal Rank metric for ranking evaluation.
    
    Parameters:
    - pred: Predicted rankings
    - targ: Target rankings  
    - k: Top-k cutoff
    
    Returns:
    - MRR score
    """

def ndcg(pred, targ, k=None):
    """
    Normalized Discounted Cumulative Gain.
    
    Parameters:
    - pred: Predicted rankings
    - targ: Target rankings
    - k: Top-k cutoff
    
    Returns:
    - NDCG score
    """

def precision_at_k(pred, targ, k=10):
    """Precision at K metric."""

def recall_at_k(pred, targ, k=10):  
    """Recall at K metric."""

def hit_rate_at_k(pred, targ, k=10):
    """Hit rate at K metric."""

Advanced Collaborative Filtering

Advanced techniques for improving recommendation quality.

class DeepFactorizationMachine(nn.Module):
    """Deep Factorization Machine for collaborative filtering."""
    
    def __init__(self, field_dims, embed_dim, mlp_dims, dropout): ...

class NeuralMatrixFactorization(nn.Module):
    """Neural Matrix Factorization combining MF and MLP."""
    
    def __init__(self, n_users, n_items, n_factors, layers): ...

def create_loaders_collab(df, valid_pct=0.2, seed=None, **kwargs):
    """Create data loaders for collaborative filtering with advanced options."""

def bias_learner(dls, n_factors=50, **kwargs):
    """Create learner with bias-only model (no user/item factors)."""

class CollabLine:
    """Single interaction representation for collaborative filtering."""
    
    def __init__(self, cats, classes, names): ...
    def show(self): ...

Cold Start and Content-Based Extensions

Approaches for handling new users/items and incorporating content features.

class HybridModel(nn.Module):
    """
    Hybrid model combining collaborative and content-based filtering.
    Handles cold start problem by incorporating item/user features.
    """
    
    def __init__(self, n_users, n_items, n_factors, content_features=None, 
                 layers=None): ...

def content_based_features(items_df, feature_cols=None):
    """
    Extract content-based features from item metadata.
    
    Parameters:
    - items_df: DataFrame with item information
    - feature_cols: Columns to use as features
    
    Returns:
    - Feature matrix for items
    """

def popularity_baseline(train_df, user_col='user', item_col='item', 
                       rating_col='rating'):
    """
    Create popularity-based baseline recommendations.
    
    Parameters:
    - train_df: Training data
    - user_col: User column name
    - item_col: Item column name  
    - rating_col: Rating column name
    
    Returns:
    - Popularity scores for items
    """

Install with Tessl CLI