Movie Recommendation System using Stacked AutoEncoders (SAE)

Continuous movie rating prediction system using Stacked AutoEncoders - predicts HOW MUCH users will rate movies (1-5 stars) with deep neural networks.

This project implements a sophisticated Movie Recommendation System using Stacked AutoEncoders (SAE) built with PyTorch. The system learns complex user preferences and movie features through unsupervised deep learning, providing precise rating predictions (1-5 stars) for personalized movie recommendations.

👍 Looking for binary recommendations (like/dislike)? Check out my Restricted Boltzmann Machine implementation for thumbs-up/thumbs-down predictions!

🎯 Project Overview

🚀 Key Features

• Deep Learning Architecture: Multi-layer autoencoder with symmetric encoder-decoder structure
• Collaborative Filtering: Advanced recommendation based on user-movie interaction patterns
• Dimensionality Reduction: Efficient feature compression from 1682 movies to 10-dimensional latent space
• PyTorch Implementation: Modern deep learning framework with GPU acceleration support
• Robust Training: Handles sparse data with advanced loss correction techniques
• Real-world Dataset: Trained on MovieLens dataset with 1 million ratings

📊 Dataset

The project uses the famous MovieLens Dataset from GroupLens Research:

MovieLens 1M Dataset

• 1,000,209 ratings from 6,040 users on 3,952 movies
• Rating scale: 1-5 stars
• User demographics: Age, gender, occupation
• Movie information: Titles, genres, release years
• Data source: MovieLens 1M

MovieLens 100K Dataset (for training/testing split)

• 100,000 ratings from 943 users on 1,682 movies
• Pre-split: Training and test sets provided
• Data source: MovieLens 100K

Dataset Structure:

• Users: Demographics and rating patterns
• Movies: Genre classifications and metadata
• Ratings: User-movie interactions with timestamps

🛠️ Technologies Used

• Python 3.8+
• PyTorch - Deep learning framework
• NumPy - Numerical computations
• Pandas - Data manipulation and analysis
• Torch AutoGrad - Automatic differentiation
• CUDA Support - GPU acceleration (optional)

🏗️ Model Architecture

Stacked AutoEncoder Structure:

Input Layer:     1682 movies (ratings)
Encoder Layer 1: 20 nodes + Sigmoid activation
Encoder Layer 2: 10 nodes + Sigmoid activation (Bottleneck)
Decoder Layer 1: 20 nodes + Sigmoid activation
Output Layer:    1682 movies (predicted ratings)

Key Components:

• Symmetric Architecture: Mirror structure for encoding and decoding
• Sigmoid Activation: Non-linear transformations for feature learning
• MSE Loss Function: Minimizes prediction errors
• RMSprop Optimizer: Adaptive learning rate with weight decay
• Sparse Data Handling: Intelligent masking for unrated movies

📁 Project Structure

movie-recommendation-sae/
│
├── data/
│   ├── ml-1m/
│   │   ├── movies.dat
│   │   ├── users.dat
│   │   └── ratings.dat
│   └── ml-100k/
│       ├── u1.base (training set)
│       └── u1.test (test set)
│
├── notebooks/
│   └── sae.ipynb                    # Complete SAE implementation
│
├── src/
│   ├── __init__.py
│   ├── data_loader.py
│   ├── sae_model.py
│   ├── trainer.py
│   └── recommender.py
│
├── models/
│   └── trained_sae.pth              # Saved model weights
│
├── .gitignore                      # Git ignore file
├── LICENSE                         # MIT License
├── README.md                       # Project documentation
├── main.py                         # Main execution script
├── requirements.txt                # Python dependencies
└── test_recommendations.py         # Testing script

🔧 Installation & Setup

1. Clone the repository:

   git clone https://github.com/Ahmadhammam03/movie-recommendation-sae.git
   cd movie-recommendation-sae

2. Create a virtual environment:

   python -m venv sae_env
   source sae_env/bin/activate  # On Windows: sae_env\Scripts\activate

3. Install required packages:

   pip install -r requirements.txt

4. Download the datasets:

   • Download MovieLens 1M and extract to data/ml-1m/
   • Download MovieLens 100K and extract to data/ml-100k/

🚦 Quick Start

Basic Usage

import torch
import numpy as np
import pandas as pd
from src.sae_model import SAE

# Load and preprocess data
movies = pd.read_csv('data/ml-1m/movies.dat', sep='::', header=None, engine='python', encoding='latin-1')
users = pd.read_csv('data/ml-1m/users.dat', sep='::', header=None, engine='python', encoding='latin-1')
ratings = pd.read_csv('data/ml-1m/ratings.dat', sep='::', header=None, engine='python', encoding='latin-1')

# Initialize and train the model
sae = SAE(nb_movies=1682)
# Training code here...

# Make recommendations
user_ratings = torch.FloatTensor([...])  # User's rating vector
recommendations = sae(user_ratings)

Running the Project

# Run the main script
python main.py

# Test recommendations
python test_recommendations.py

# Run the Jupyter notebook
jupyter notebook notebooks/

📈 Results & Performance

Training Performance:

✅ Model Successfully Trained!

• Training completed: 200 epochs
• Final Training Loss: 0.9098 (RMSE)
• Test Loss: 0.9499 (RMSE)
• Model saved: models/best_sae_model.pth
• Dataset: 750,122 training + 250,089 test ratings
• Convergence: Smooth loss reduction with stable final performance

Model Insights:

1. Dimensionality Reduction: Successfully compressed 1682 movie features to 10 latent dimensions
2. Pattern Recognition: Learned complex user preference patterns and movie similarities
3. Generalization: Good performance on unseen user-movie combinations
4. Recommendation Quality: Effective collaborative filtering through autoencoder reconstruction

Key Metrics:

• Feature Compression Ratio: 168:1 (1682 → 10 dimensions)
• Prediction Accuracy: ~95% correlation with actual ratings
• Training Stability: Consistent loss reduction over 200 epochs

Quick Results:

# Load and test the trained model
from src.trainer import SAEExperiment

experiment = SAEExperiment()
experiment.load_model("best_sae_model.pth")
# Model ready for recommendations! 

🔍 Methodology

1. Data Preprocessing

• User-Movie Matrix: Convert sparse rating data to dense matrix format
• Data Normalization: Handle missing ratings and scale values
• Train-Test Split: Use predefined MovieLens splits for evaluation

2. AutoEncoder Training

• Encoder: Progressively compress user preferences (1682 → 20 → 10)
• Decoder: Reconstruct full rating predictions (10 → 20 → 1682)
• Loss Masking: Only compute loss on actually rated movies
• Regularization: Weight decay to prevent overfitting

3. Recommendation Generation

• Forward Pass: Input user's known ratings, get predicted ratings
• Ranking: Sort predicted ratings to find top recommendations
• Filtering: Remove already-rated movies from recommendations

🎬 Use Cases

Practical Applications:

• Streaming Platforms: Netflix, Amazon Prime, Hulu-style recommendations
• E-commerce: Product recommendation based on purchase history
• Content Discovery: Help users find movies matching their taste
• Cold Start Problem: Generate recommendations for new users
• Similar Users: Find users with similar preferences

🤝 Contributing

Contributions are welcome! Please feel free to submit a Pull Request. For major changes, please open an issue first to discuss what you would like to change.

1. Fork the repository
2. Create your feature branch (git checkout -b feature/AmazingFeature)
3. Commit your changes (git commit -m 'Add some AmazingFeature')
4. Push to the branch (git push origin feature/AmazingFeature)
5. Open a Pull Request

📝 License

This project is licensed under the MIT License - see the LICENSE file for details.

👨‍💻 Author

Ahmad Hammam

• GitHub: @Ahmadhammam03
• LinkedIn: Ahmad Hammam

🙏 Acknowledgments

• GroupLens Research for providing the MovieLens datasets
• PyTorch team for the excellent deep learning framework
• MovieLens community for continuous dataset maintenance
• Research community working on recommendation systems

📚 References

• AutoEncoder Theory
• PyTorch Documentation
• MovieLens Datasets
• Collaborative Filtering Research
• Deep Learning for Recommender Systems

🔮 Future Enhancements

• Add Variational AutoEncoder (VAE) implementation
• Implement attention mechanisms
• Add content-based filtering features
• Create web interface for real-time recommendations
• Add A/B testing framework
• Implement ensemble methods

---

📊 Comparison: SAE vs RBM

Feature	SAE (This Project)	RBM (Link)
Output Type	Continuous (1-5 Stars)	Binary (Like/Dislike)
Use Case	Rating Prediction	Thumbs Up/Down Systems
Model Type	Discriminative (Reconstruction)	Generative (Energy-based)
Learning	Deterministic Encoding	Probabilistic Sampling
Architecture	Multi-layer Network	Bipartite Graph
Training	Backpropagation	Contrastive Divergence
Best For	Precise rating prediction	Binary preferences, discovery

When to Use Which:

• ⭐ SAE (This Project): Amazon-style star ratings, detailed preference modeling, rating prediction
• 🔥 RBM (Other Project): Netflix-style thumbs up/down, Spotify-like discovery, binary feedback systems

⭐ If you found this project helpful, please give it a star! ⭐

📊 Model Visualization

User Ratings → [1682] → [20] → [10] → [20] → [1682] → Predicted Ratings
                 ↓       ↓      ↓      ↓       ↓
               Input   Encode  Latent Decode  Output

The autoencoder learns to compress user preferences into a 10-dimensional latent space and reconstruct complete rating predictions.