Systèmes de
Recommandation
Zero → Hero

import numpy as np
import pandas as pd
from sklearn.metrics import mean_squared_error, mean_absolute_error

# ─── Création d'une matrice utilisateur-item sparse ───────────────
data = {
    'user':   ['Alice', 'Alice', 'Bob',   'Bob',   'Carol', 'Carol'],
    'item':   ['Lion',  'Inter', 'Inter', 'Spider','Lion',  'Intou'],
    'rating': [5,       4,       5,       4,       3,       5      ]
}
df = pd.DataFrame(data)

# ─── Pivot : matrice R (users × items) ───────────────────────────
R = df.pivot(index='user', columns='item', values='rating')
print("Matrice Utilisateur-Item :")
print(R)
print(f"\nSparsité : {R.isna().sum().sum() / R.size * 100:.1f}%")

# ─── Calcul des métriques ─────────────────────────────────────────
def compute_metrics(y_true, y_pred):
    """Calcule RMSE et MAE."""
    rmse = np.sqrt(mean_squared_error(y_true, y_pred))
    mae  = mean_absolute_error(y_true, y_pred)
    return {'RMSE': round(rmse, 4), 'MAE': round(mae, 4)}

# Exemple
y_true = [5, 4, 3, 2, 5]
y_pred = [4.5, 3.8, 3.2, 2.5, 4.7]
metrics = compute_metrics(y_true, y_pred)
print(f"\nRMSE : {metrics['RMSE']} | MAE : {metrics['MAE']}")

# ─── Precision@K et Recall@K ─────────────────────────────────────
def precision_recall_at_k(recommended, relevant, k):
    """
    recommended : liste ordonnée des items recommandés
    relevant    : set des items réellement pertinents
    k           : nombre de recommandations à évaluer
    """
    top_k   = recommended[:k]
    hits    = len(set(top_k) & set(relevant))
    precision = hits / k
    recall    = hits / len(relevant) if relevant else 0
    return precision, recall

recommended = ['Spider-Man', 'Interstellar', 'Get Out', 'Lion']
relevant     = {'Interstellar', 'Get Out'}
p, r = precision_recall_at_k(recommended, relevant, k=3)
print(f"\nPrecision@3 : {p:.2f} | Recall@3 : {r:.2f}")

import numpy as np
import pandas as pd
from sklearn.metrics.pairwise import cosine_similarity
from scipy.stats import pearsonr

class UserBasedCF:
    """
    Filtrage Collaboratif basé Utilisateur.
    Utilise la corrélation de Pearson + biais utilisateur.
    """
    def __init__(self, n_neighbors=5):
        self.n_neighbors   = n_neighbors
        self.rating_matrix = None
        self.similarity    = None
        self.user_means    = None

    def fit(self, rating_matrix):
        """Entraîne le modèle sur la matrice de notes."""
        self.rating_matrix = rating_matrix.copy()
        self.user_means    = rating_matrix.mean(axis=1)

        # Centrer la matrice (soustraction de la moyenne par user)
        R_centered = rating_matrix.sub(self.user_means, axis=0).fillna(0)

        # Matrice de similarité utilisateurs (Pearson via cosinus centré)
        sim_matrix = cosine_similarity(R_centered)
        self.similarity = pd.DataFrame(
            sim_matrix,
            index=rating_matrix.index,
            columns=rating_matrix.index
        )
        print(f"✅ Modèle entraîné : {len(rating_matrix)} users, {rating_matrix.shape[1]} items")
        return self

    def get_neighbors(self, user, item=None):
        """Retourne les k voisins les plus similaires ayant noté l'item."""
        sims = self.similarity[user].drop(user).sort_values(ascending=False)

        if item is not None:
            # Garder seulement les voisins ayant noté l'item
            has_rated = self.rating_matrix[item].dropna().index
            sims      = sims[sims.index.isin(has_rated)]

        return sims.head(self.n_neighbors)

    def predict(self, user, item):
        """Prédit la note de l'utilisateur pour un item."""
        if item not in self.rating_matrix.columns:
            return self.user_means[user]  # fallback

        neighbors = self.get_neighbors(user, item)

        if len(neighbors) == 0:
            return self.user_means[user]

        numerator   = 0
        denominator = 0

        for neighbor, sim_score in neighbors.items():
            r_ni = self.rating_matrix.loc[neighbor, item]
            r_n_mean = self.user_means[neighbor]
            numerator   += sim_score * (r_ni - r_n_mean)
            denominator += abs(sim_score)

        pred = self.user_means[user] + (numerator / denominator if denominator > 0 else 0)
        return float(np.clip(pred, 1, 5))

    def recommend(self, user, n=5):
        """Retourne les n meilleures recommandations pour un utilisateur."""
        rated_items    = self.rating_matrix.loc[user].dropna().index
        unrated_items  = [i for i in self.rating_matrix.columns if i not in rated_items]

        predictions = {}
        for item in unrated_items:
            predictions[item] = self.predict(user, item)

        top_n = sorted(predictions.items(), key=lambda x: x[1], reverse=True)[:n]
        return top_n

# ─── Exemple d'utilisation ───────────────────────────────────────
data = {
    'Alice': {'Item1':5, 'Item2':3, 'Item3':4, 'Item4':None, 'Item5':1},
    'Bob':   {'Item1':4, 'Item2':None, 'Item3':4, 'Item4':1, 'Item5':1},
    'Carol': {'Item1':None, 'Item2':2, 'Item3':None, 'Item4':4, 'Item5':5},
    'Dave':  {'Item1':1, 'Item2':1, 'Item3':None, 'Item4':5, 'Item5':4},
    'Eve':   {'Item1':3, 'Item2':3, 'Item3':5, 'Item4':None, 'Item5':None},
}

R = pd.DataFrame(data).T

model = UserBasedCF(n_neighbors=3)
model.fit(R)

# Prédiction
pred = model.predict('Alice', 'Item4')
print(f"\n🔮 Prédiction Alice → Item4 : {pred:.2f}/5")

# Top recommandations
recs = model.recommend('Alice', n=3)
print("\n🎯 Top recommandations pour Alice :")
for item, score in recs:
    print(f"   {item} : {score:.2f}⭐")

from surprise import SVD, Dataset, Reader, accuracy
from surprise.model_selection import cross_validate, train_test_split
import pandas as pd

# ─── Chargement des données ───────────────────────────────────────
# pip install scikit-surprise
reader = Reader(rating_scale=(1, 5))
data   = Dataset.load_builtin('ml-100k')  # MovieLens 100K

# ─── Split train/test ─────────────────────────────────────────────
trainset, testset = train_test_split(data, test_size=0.2, random_state=42)

# ─── Modèle SVD ──────────────────────────────────────────────────
algo = SVD(
    n_factors=50,       # nombre de facteurs latents
    n_epochs=20,        # itérations de descente de gradient
    lr_all=0.005,       # learning rate
    reg_all=0.02,       # régularisation L2
    biased=True,        # inclure les biais user/item
    random_state=42
)

# ─── Entraînement ────────────────────────────────────────────────
algo.fit(trainset)

# ─── Évaluation ──────────────────────────────────────────────────
predictions = algo.test(testset)
print(f"RMSE : {accuracy.rmse(predictions, verbose=False):.4f}")
print(f"MAE  : {accuracy.mae(predictions,  verbose=False):.4f}")

# ─── Cross-validation 5-fold ─────────────────────────────────────
results = cross_validate(
    SVD(), data,
    measures=['RMSE', 'MAE'],
    cv=5, verbose=True
)

# ─── Prédiction pour un utilisateur ──────────────────────────────
uid    = "196"   # user ID (string pour Surprise)
iid    = "302"   # item ID
pred   = algo.predict(uid, iid)
print(f"\n🔮 Prédiction User {uid} → Item {iid} : {pred.est:.2f}/5")

# ─── Top-N recommandations ────────────────────────────────────────
from collections import defaultdict

def get_top_n(predictions, n=10):
    """Construit le Top-N pour chaque utilisateur."""
    top_n = defaultdict(list)
    for uid, iid, true_r, est, _ in predictions:
        top_n[uid].append((iid, est))
    for uid, user_ratings in top_n.items():
        user_ratings.sort(key=lambda x: x[1], reverse=True)
        top_n[uid] = user_ratings[:n]
    return top_n

top_n = get_top_n(predictions, n=5)
print(f"\n🎯 Top-5 pour User 196 :")
for item, score in top_n["196"]:
    print(f"   Item {item} : {score:.2f}⭐")

import pandas as pd
import numpy as np
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.metrics.pairwise import cosine_similarity

# ─── Dataset de films ─────────────────────────────────────────────
movies = pd.DataFrame({
    'title': [
        'The Matrix', 'Inception', 'Interstellar',
        'The Avengers', 'Iron Man', 'Titanic',
        'Toy Story', 'Finding Nemo'
    ],
    'genres': [
        'action sci-fi thriller',
        'sci-fi thriller mystery',
        'sci-fi drama adventure',
        'action superhero adventure',
        'action superhero comedy',
        'romance drama history',
        'animation comedy adventure family',
        'animation adventure family comedy'
    ],
    'description': [
        'computer hacker discovers reality is a simulation artificial intelligence',
        'thief enters dreams steal secrets subconscious',
        'astronauts travel wormhole save humanity black hole time',
        'superheroes team unite fight alien invasion earth',
        'billionaire genius builds powered armor suit hero',
        'epic romance tragedy ocean ship iceberg',
        'cowboy toy adventures new space ranger friend',
        'clownfish ocean adventure find son reef'
    ]
})

# ─── Feature Engineering : combinaison genres + description ───────
movies['features'] = movies['genres'] + ' ' + movies['description']

# ─── Vectorisation TF-IDF ─────────────────────────────────────────
tfidf = TfidfVectorizer(
    max_features=500,
    stop_words='english',
    ngram_range=(1, 2)  # unigrammes + bigrammes
)
tfidf_matrix = tfidf.fit_transform(movies['features'])
print(f"Matrice TF-IDF : {tfidf_matrix.shape}")

# ─── Matrice de similarité cosinus entre films ────────────────────
cosine_sim = cosine_similarity(tfidf_matrix)
print(f"Matrice similarité : {cosine_sim.shape}")

# ─── Fonction de recommandation ───────────────────────────────────
def content_based_recommend(title, n=3):
    """Recommande n films similaires à 'title'."""
    idx       = movies[movies['title'] == title].index[0]
    sim_scores= list(enumerate(cosine_sim[idx]))
    sim_scores= sorted(sim_scores, key=lambda x: x[1], reverse=True)[1:n+1]

    print(f"\n🎬 Films similaires à '{title}' :")
    for i, score in sim_scores:
        print(f"   {movies['title'].iloc[i]:<20} (similarité: {score:.3f})")

content_based_recommend('The Matrix')
content_based_recommend('Toy Story')

# ─── Profil utilisateur ───────────────────────────────────────────
def build_user_profile(liked_movies, weights=None):
    """
    Construit un vecteur profil utilisateur comme
    moyenne pondérée des vecteurs TF-IDF des films aimés.
    """
    indices = [movies[movies['title'] == m].index[0] for m in liked_movies]
    vectors = tfidf_matrix[indices].toarray()

    if weights:
        weights = np.array(weights)[:, np.newaxis]
        profile = (vectors * weights).sum(axis=0) / weights.sum()
    else:
        profile = vectors.mean(axis=0)

    return profile

def recommend_from_profile(user_profile, seen_movies, n=3):
    """Recommande à partir du profil utilisateur."""
    sims    = cosine_similarity([user_profile], tfidf_matrix.toarray())[0]
    results = pd.Series(sims, index=movies['title'])
    results = results.drop(seen_movies, errors='ignore')
    print("\n👤 Recommandations personnalisées :")
    print(results.nlargest(n).to_string())

# Exemple
liked   = ['The Matrix', 'Inception']
weights = [5, 4]   # notes de l'utilisateur
profile = build_user_profile(liked, weights)
recommend_from_profile(profile, seen_movies=liked)

class HybridRecommender:
    """
    Système hybride combinant CF et CB.
    - Weighted : somme pondérée des scores
    - Switching : CF si assez de données, CB sinon (cold start)
    """
    def __init__(self, cf_model, cb_model, alpha=0.7, min_ratings=5):
        self.cf          = cf_model
        self.cb          = cb_model
        self.alpha       = alpha       # poids CF
        self.min_ratings = min_ratings # seuil cold start

    def _count_ratings(self, user):
        return self.cf.rating_matrix.loc[user].notna().sum()

    def recommend_weighted(self, user, n=5):
        """Hybrid pondéré : α × CF + (1-α) × CB"""
        cf_recs = dict(self.cf.recommend(user, n=n*2))
        cb_recs = dict(self.cb.get_scores(user, n=n*2))

        all_items = set(cf_recs) | set(cb_recs)
        scores    = {}
        for item in all_items:
            s_cf = cf_recs.get(item, 0)
            s_cb = cb_recs.get(item, 0)
            scores[item] = self.alpha * s_cf + (1 - self.alpha) * s_cb

        return sorted(scores.items(), key=lambda x: x[1], reverse=True)[:n]

    def recommend_switching(self, user, n=5):
        """Switching : CF si assez de notes, sinon CB (cold start)."""
        n_rated = self._count_ratings(user)

        if n_rated >= self.min_ratings:
            print(f"   → Mode CF ({n_rated} notes)")
            return self.cf.recommend(user, n=n)
        else:
            print(f"   → Mode CB (cold start, {n_rated} notes)")
            return self.cb.recommend_for_cold_start(user, n=n)

    def recommend_cascade(self, user, n=5, first_n=50):
        """
        Cascade : CF filtre → Top-first_n → CB re-rank → Top-n final.
        """
        # Étape 1 : CF génère des candidats
        candidates = dict(self.cf.recommend(user, n=first_n))

        # Étape 2 : CB re-rank les candidats
        cb_scores = self.cb.score_items(user, list(candidates.keys()))
        final     = sorted(cb_scores.items(), key=lambda x: x[1], reverse=True)[:n]
        return final

import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import Dataset, DataLoader
import numpy as np
import pandas as pd

# ─── Architecture NCF ─────────────────────────────────────────────
class NCF(nn.Module):
    """
    Neural Collaborative Filtering.
    Combine GMF (Generalized Matrix Factorization)
    et MLP dans un modèle unifié.
    """
    def __init__(self, n_users, n_items, emb_dim=32, layers=[64, 32, 16]):
        super().__init__()

        # ── GMF : embeddings ─────────────────────────────
        self.gmf_user = nn.Embedding(n_users, emb_dim)
        self.gmf_item = nn.Embedding(n_items, emb_dim)

        # ── MLP : embeddings ─────────────────────────────
        self.mlp_user = nn.Embedding(n_users, layers[0] // 2)
        self.mlp_item = nn.Embedding(n_items, layers[0] // 2)

        # ── MLP : couches cachées ─────────────────────────
        mlp_modules = []
        in_size = layers[0]
        for out_size in layers[1:]:
            mlp_modules += [
                nn.Linear(in_size, out_size),
                nn.BatchNorm1d(out_size),
                nn.ReLU(),
                nn.Dropout(0.2)
            ]
            in_size = out_size
        self.mlp_layers = nn.Sequential(*mlp_modules)

        # ── Couche de prédiction finale ───────────────────
        self.predict_layer = nn.Linear(emb_dim + layers[-1], 1)
        self.sigmoid = nn.Sigmoid()

        # Initialisation des poids
        self._init_weights()

    def _init_weights(self):
        for module in self.modules():
            if isinstance(module, nn.Embedding):
                nn.init.normal_(module.weight, std=0.01)
            elif isinstance(module, nn.Linear):
                nn.init.xavier_uniform_(module.weight)

    def forward(self, user_ids, item_ids):
        # ── GMF ──────────────────────────────────────────
        gmf_u = self.gmf_user(user_ids)
        gmf_i = self.gmf_item(item_ids)
        gmf_out = gmf_u * gmf_i  # element-wise product

        # ── MLP ──────────────────────────────────────────
        mlp_u   = self.mlp_user(user_ids)
        mlp_i   = self.mlp_item(item_ids)
        mlp_in  = torch.cat([mlp_u, mlp_i], dim=-1)
        mlp_out = self.mlp_layers(mlp_in)

        # ── Fusion GMF + MLP ─────────────────────────────
        fused = torch.cat([gmf_out, mlp_out], dim=-1)
        logit = self.predict_layer(fused)
        return self.sigmoid(logit).squeeze()

# ─── Dataset ─────────────────────────────────────────────────────
class InteractionDataset(Dataset):
    def __init__(self, users, items, labels):
        self.users  = torch.LongTensor(users)
        self.items  = torch.LongTensor(items)
        self.labels = torch.FloatTensor(labels)

    def __len__(self):
        return len(self.users)

    def __getitem__(self, idx):
        return self.users[idx], self.items[idx], self.labels[idx]

# ─── Entraînement ────────────────────────────────────────────────
def train_ncf(model, train_loader, n_epochs=10, lr=0.001):
    device    = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
    model     = model.to(device)
    optimizer = optim.Adam(model.parameters(), lr=lr, weight_decay=1e-5)
    criterion = nn.BCELoss()
    scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=5, gamma=0.5)

    loss_history = []

    for epoch in range(n_epochs):
        model.train()
        total_loss = 0

        for users, items, labels in train_loader:
            users, items, labels = users.to(device), items.to(device), labels.to(device)
            optimizer.zero_grad()
            preds = model.forward(users, items)
            loss  = criterion(preds, labels)
            loss.backward()
            optimizer.step()
            total_loss += loss.item()

        avg_loss = total_loss / len(train_loader)
        loss_history.append(avg_loss)
        scheduler.step()

        if (epoch + 1) % 2 == 0:
            print(f"Epoch [{epoch+1:3d}/{n_epochs}] Loss: {avg_loss:.4f}")

    return model, loss_history

# ─── Exemple rapide ──────────────────────────────────────────────
N_USERS, N_ITEMS = 100, 200
n_samples = 5000

users  = np.random.randint(0, N_USERS, n_samples)
items  = np.random.randint(0, N_ITEMS, n_samples)
labels = np.random.randint(0, 2, n_samples).astype(float)

dataset    = InteractionDataset(users, items, labels)
dataloader = DataLoader(dataset, batch_size=256, shuffle=True)

model = NCF(N_USERS, N_ITEMS, emb_dim=16, layers=[32, 16, 8])
model, history = train_ncf(model, dataloader, n_epochs=10)
print("\n✅ NCF entraîné avec succès !")
print(f"Paramètres : {sum(p.numel() for p in model.parameters()):,}")

class RecAutoEncoder(nn.Module):
    """
    AutoEncoder pour la complétion de matrices.
    Prend en entrée la ligne d'un utilisateur (notes partielles)
    et reconstruit la ligne complète.
    """
    def __init__(self, n_items, hidden_dims=[512, 256, 128], dropout=0.5):
        super().__init__()

        # ── Encodeur ─────────────────────────────────────
        encoder_layers = []
        in_dim = n_items
        for h_dim in hidden_dims:
            encoder_layers += [
                nn.Linear(in_dim, h_dim),
                nn.SELU(),
                nn.Dropout(dropout)
            ]
            in_dim = h_dim
        self.encoder = nn.Sequential(*encoder_layers)

        # ── Décodeur (symétrique) ─────────────────────────
        decoder_layers = []
        for h_dim in hidden_dims[-2::-1]:
            decoder_layers += [
                nn.Linear(in_dim, h_dim),
                nn.SELU(),
                nn.Dropout(dropout)
            ]
            in_dim = h_dim
        decoder_layers.append(nn.Linear(in_dim, n_items))
        self.decoder = nn.Sequential(*decoder_layers)

    def forward(self, x):
        z = self.encoder(x)
        r = self.decoder(z)
        return r

# ─── Loss masquée (ignore NaN) ────────────────────────────────────
def masked_mse_loss(pred, target, mask):
    """MSE calculée uniquement sur les notes observées."""
    loss = ((pred - target) ** 2) * mask
    return loss.sum() / mask.sum()

# ─── Entraînement AE ─────────────────────────────────────────────
def train_autoencoder(R_matrix, epochs=30, lr=0.001, batch_size=64):
    n_users, n_items = R_matrix.shape
    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')

    # Préparer les tenseurs
    R_tensor    = torch.FloatTensor(np.nan_to_num(R_matrix, nan=0)).to(device)
    mask_tensor = torch.FloatTensor(~np.isnan(R_matrix)).to(device)

    model     = RecAutoEncoder(n_items).to(device)
    optimizer = optim.Adam(model.parameters(), lr=lr)

    for epoch in range(epochs):
        model.train()
        perm    = torch.randperm(n_users)
        ep_loss = 0

        for i in range(0, n_users, batch_size):
            idx   = perm[i:i + batch_size]
            x     = R_tensor[idx]
            m     = mask_tensor[idx]
            optimizer.zero_grad()
            pred  = model(x)
            loss  = masked_mse_loss(pred, x, m)
            loss.backward()
            optimizer.step()
            ep_loss += loss.item()

        if (epoch + 1) % 5 == 0:
            print(f"Epoch {epoch+1:3d} | Loss: {ep_loss:.4f}")

    return model

# Usage
R = np.array([
    [5, 3, np.nan, 1, np.nan],
    [4, np.nan, 4, 1, 2],
    [np.nan, 2, 3, np.nan, 5],
], dtype=float)

ae_model = train_autoencoder(R, epochs=20)
print("✅ AutoEncoder entraîné !")

# ================================================================
# CINEAI RECOMMENDER — Architecture complète
# Structure du projet :
#
# cineai/
# ├── data/
# │   ├── raw/                 # MovieLens dataset
# │   └── processed/           # Features engineerées
# ├── models/
# │   ├── base.py              # Interface abstraite
# │   ├── collaborative.py     # SVD + User/Item CF
# │   ├── content.py           # TF-IDF + Embeddings
# │   ├── neural.py            # NCF + AutoEncoder
# │   └── hybrid.py            # Ensemble
# ├── api/
# │   ├── app.py               # Flask application
# │   └── routes.py            # Endpoints REST
# ├── evaluation/
# │   ├── metrics.py           # RMSE, MAE, P@K, NDCG
# │   └── experiment.py        # MLflow tracking
# └── config.py                # Hyperparamètres
# ================================================================

# ─── base.py : Interface abstraite ───────────────────────────────
from abc import ABC, abstractmethod
from typing import List, Dict, Tuple, Optional
import numpy as np

class BaseRecommender(ABC):
    """Interface commune pour tous les modèles."""

    @abstractmethod
    def fit(self, train_data): pass

    @abstractmethod
    def recommend(self, user_id: int, n: int = 10) -> List[Tuple[int, float]]: pass

    @abstractmethod
    def predict(self, user_id: int, item_id: int) -> float: pass

    def explain(self, user_id: int, item_id: int) -> Dict:
        """Explication de la recommandation (optionnel)."""
        return {"reason": "Based on your preferences"}


# ─── api/app.py : API Flask ───────────────────────────────────────
from flask import Flask, jsonify, request
from functools import wraps
import time

app = Flask(__name__)

# Décorateur de timing
def timer(f):
    @wraps(f)
    def wrapper(*args, **kwargs):
        start    = time.time()
        result   = f(*args, **kwargs)
        elapsed  = round((time.time() - start) * 1000, 2)
        if isinstance(result, tuple):
            resp, code = result
            resp.json['response_time_ms'] = elapsed
            return resp, code
        return result
    return wrapper

@app.route('/api/v1/recommend', methods=['GET'])
def get_recommendations():
    """
    GET /api/v1/recommend?user_id=123&n=10&strategy=hybrid
    """
    user_id  = request.args.get('user_id', type=int)
    n        = request.args.get('n', default=10, type=int)
    strategy = request.args.get('strategy', default='hybrid')

    if not user_id:
        return jsonify({'error': 'user_id required'}), 400

    # Sélection du modèle
    model_map = {
        'collaborative': cf_model,
        'content':       cb_model,
        'neural':        ncf_model,
        'hybrid':        hybrid_model
    }
    model = model_map.get(strategy, hybrid_model)

    try:
        recs = model.recommend(user_id, n=n)
        return jsonify({
            'user_id':   user_id,
            'strategy':  strategy,
            'items':     [
                {'item_id': item, 'score': round(score, 4),
                 'explain': model.explain(user_id, item)}
                for item, score in recs
            ]
        })
    except Exception as e:
        return jsonify({'error': str(e)}), 500


@app.route('/api/v1/similar', methods=['GET'])
def get_similar():
    """GET /api/v1/similar?item_id=42&n=5"""
    item_id = request.args.get('item_id', type=int)
    n       = request.args.get('n', default=5, type=int)
    similar = cb_model.get_similar_items(item_id, n=n)
    return jsonify({'item_id': item_id, 'similar': similar})


@app.route('/health')
def health():
    return jsonify({'status': 'ok', 'models_loaded': True})


# ─── MLflow Tracking ─────────────────────────────────────────────
import mlflow
import mlflow.sklearn

def run_experiment(model, params, train_data, test_data, exp_name='CineAI'):
    mlflow.set_experiment(exp_name)

    with mlflow.start_run():
        # Log hyperparamètres
        mlflow.log_params(params)

        # Entraînement
        model.fit(train_data)

        # Évaluation
        metrics = evaluate_model(model, test_data)
        mlflow.log_metrics(metrics)

        # Sauvegarde
        mlflow.sklearn.log_model(model, "recommender")

        print(f"✅ Run logged | RMSE: {metrics['rmse']:.4f} | P@10: {metrics['precision_at_10']:.4f}")
        return metrics

if __name__ == '__main__':
    app.run(debug=True, host='0.0.0.0', port=5000)