Corrigés & Projet
Tous les exercices résolus

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

class ItemBasedCF:
    def __init__(self, k=3):
        self.k = k

    def fit(self, R):
        """R : DataFrame (users × items) avec NaN pour les manquants."""
        self.R          = R.copy()
        self.user_means = R.mean(axis=1)
        self.item_means = R.mean(axis=0)
        # Centrage par item (réduit le biais de popularité)
        Rc = R.subtract(self.item_means, axis=1).fillna(0)
        sim = cosine_similarity(Rc.T)          # similarité entre items = colonnes
        np.fill_diagonal(sim, 0)
        self.item_sim = pd.DataFrame(sim, index=R.columns, columns=R.columns)
        return self

    def predict(self, user, item):
        notes = self.R.loc[user].dropna().drop(item, errors='ignore')
        if notes.empty: return float(self.item_means.get(item, 3.0))
        sims = self.item_sim.loc[item, notes.index].nlargest(self.k)
        sims = sims[sims > 0]
        if sims.empty: return float(self.user_means.get(user, 3.0))
        pred = (sims * notes.loc[sims.index]).sum() / sims.abs().sum()
        return float(np.clip(pred, 1, 5))

    def recommend(self, user, n=5):
        rated   = self.R.loc[user].dropna().index
        unrated = [i for i in self.R.columns if i not in rated]
        preds   = {i: self.predict(user, i) for i in unrated}
        return sorted(preds.items(), key=lambda x: x[1], reverse=True)[:n]

data = {
    'Alice': {'Action A':5,'Action B':4,'Drama C':2,'Drama D':1,'SciFi E':None},
    'Bob':   {'Action A':4,'Action B':None,'Drama C':3,'Drama D':2,'SciFi E':5},
    'Carol': {'Action A':2,'Action B':1,'Drama C':5,'Drama D':4,'SciFi E':None},
    'Dave':  {'Action A':None,'Action B':5,'Drama C':None,'Drama D':3,'SciFi E':4},
}
R = pd.DataFrame(data).T
model = ItemBasedCF(k=2).fit(R)
print("Alice → SciFi E :", round(model.predict('Alice', 'SciFi E'), 2))
for u in R.index:
    print(u, "→", [(i, round(s,2)) for i,s in model.recommend(u, 2)])

import numpy  as np
import pandas as pd
from sklearn.preprocessing    import StandardScaler
from sklearn.metrics.pairwise import cosine_similarity

class MusicRecommender:
    FEATURES = ['tempo','energy','danceability','acousticness','valence']

    def fit(self, songs):
        self.songs = songs.reset_index(drop=True)
        self.X = StandardScaler().fit_transform(self.songs[self.FEATURES])
        self.sim = cosine_similarity(self.X)
        np.fill_diagonal(self.sim, 0)
        return self

    def similar(self, title, n=3):
        idx = self.songs.index[self.songs['title'] == title][0]
        top = np.argsort(self.sim[idx])[::-1][:n]
        out = self.songs.iloc[top][['title','artist']].copy()
        out['sim'] = self.sim[idx][top].round(3)
        return out.reset_index(drop=True)

    def for_user(self, liked, ratings, n=4):
        idx     = [self.songs.index[self.songs['title']==t][0] for t in liked]
        w       = np.array(ratings, dtype=float)[:, None]
        profile = (self.X[idx] * w).sum(0) / w.sum()
        scores  = cosine_similarity([profile], self.X)[0]
        scores[idx] = -1                              # masquer déjà aimés
        top = np.argsort(scores)[::-1][:n]
        out = self.songs.iloc[top][['title','artist']].copy()
        out['score'] = scores[top].round(3)
        return out.reset_index(drop=True)

songs = pd.DataFrame({
    'title': ['Blinding Lights','Levitating','Bohemian Rhapsody','Someone Like You','Uptown Funk'],
    'artist':['The Weeknd','Dua Lipa','Queen','Adele','Bruno Mars'],
    'tempo':[171,103,72,68,115], 'energy':[0.80,0.70,0.40,0.25,0.89],
    'danceability':[0.89,0.80,0.40,0.30,0.92], 'acousticness':[0.02,0.04,0.55,0.90,0.03],
    'valence':[0.62,0.91,0.35,0.12,0.97],
})
rec = MusicRecommender().fit(songs)
print(rec.similar('Blinding Lights', 2))
print(rec.for_user(['Uptown Funk','Blinding Lights'], [5,4], 2))

import numpy as np

class HybridRecommender:
    """Combine un modèle CF et un modèle Content-Based."""
    def __init__(self, cf, cb, alpha=0.6, min_ratings=5):
        self.cf, self.cb = cf, cb
        self.alpha, self.min_ratings = alpha, min_ratings

    def weighted(self, u, i):
        return self.alpha * self.cf.predict(u, i) + (1 - self.alpha) * self.cb.predict(u, i)

    def switching(self, u, i):
        n = self.cf.n_ratings(u)
        return self.cf.predict(u, i) if n >= self.min_ratings else self.cb.predict(u, i)

def eval_cold_start(hybrid, R, n_held=3, seed=99):
    """Masque des notes pour simuler des utilisateurs peu actifs."""
    np.random.seed(seed)
    ew, es = [], []
    for u in R.index:
        notes = R.loc[u].dropna()
        if len(notes) < n_held + 2: continue
        hidden = notes.sample(len(notes) - n_held).index
        for i in hidden:
            t = R.loc[u, i]
            ew.append((t - hybrid.weighted(u, i))**2)
            es.append((t - hybrid.switching(u, i))**2)
    return np.sqrt(np.mean(ew)), np.sqrt(np.mean(es))

# Balayage de α pour trouver le meilleur compromis
for a in [0.0, 0.2, 0.4, 0.6, 0.8, 1.0]:
    h = HybridRecommender(cf, cb, alpha=a)
    rw, rs = eval_cold_start(h, R_full)
    print(f"α={a:.1f} | Weighted RMSE={rw:.3f} | Switching RMSE={rs:.3f}")