🎬 第25课：电影推荐项目

🎯 学习目标

🗂️ 课程定位

📖 核心理论

电影推荐是推荐系统最经典的应用场景。从Netflix Prize到MovieLens，电影推荐一直是推荐系统研究的重要基准。本课综合运用协同过滤、矩阵分解、内容推荐和混合方法构建完整的电影推荐系统。

📐 数学公式

💻 代码实现

import numpy as np
from collections import defaultdict
np.random.seed(42)
print("="*60+"\n电影推荐项目\n"+"="*60)
n_users=50;n_movies=30;n_genres=6
genres=["动作","喜剧","剧情","科幻","恐怖","爱情"]
# 电影特征
movie_genre=np.random.random((n_movies,n_genres))>0.6
movie_genre=movie_genre.astype(float)
movie_year=np.random.randint(1990,2024,n_movies)
movie_quality=np.random.random(n_movies)*2+3  # 3-5分
print(f"用户:{n_users} 电影:{n_movies} 类型:{n_genres}")
# 用户偏好
user_pref=np.random.random((n_users,n_genres))*2
user_year_pref=np.random.randint(1990,2024,n_users)
# 生成评分
ratings={}
for u in range(n_users):
    n_watched=np.random.randint(5,15)
    genre_score=user_pref[u]@movie_genre.T
    genre_score=genre_score/genre_score.max()
    year_sim=1-abs(movie_year-user_year_pref[u])/34
    quality_bias=movie_quality-3
    score=genre_score*0.4+year_sim*0.2+quality_bias*0.2+np.random.random(n_movies)*0.2
    top_movies=np.argsort(-score)[:n_watched]
    for m in top_movies:
        rating=int(np.clip(round(score[m]+1),1,5))
        ratings[(u,m)]=rating
print(f"评分数:{len(ratings)} 密度:{len(ratings)/(n_users*n_movies):.4f}")
# 协同过滤
print("\n--- 协同过滤 ---")
uv=defaultdict(dict);iv=defaultdict(dict)
for(u,m),r in ratings.items():uv[u][m]=r;iv[m][u]=r
def cosine_sim(a,b):
    ck=set(a.keys())&set(b.keys())
    if not ck:return 0
    va=np.array([a[k]for k in ck]);vb=np.array([b[k]for k in ck])
    return np.dot(va,vb)/(np.linalg.norm(va)*np.linalg.norm(vb)+1e-10)
target=0;K=5
sims={u:cosine_sim(uv.get(target,{}),uv.get(u,{}))for u in range(n_users)if u!=target}
top_k=sorted(sims.items(),key=lambda x:-x[1])[:K]
pred_cf={}
for m in range(n_movies):
    if m in uv.get(target,{}):continue
    num=den=0
    for u,sim in top_k:
        if m in uv.get(u,{}):num+=sim*uv[u][m];den+=abs(sim)
    if den>0:pred_cf[m]=num/den
cf_rec=sorted(pred_cf.items(),key=lambda x:-x[1])[:5]
print(f"CF推荐:{[(f'电影{m}',f'{s:.2f}')for m,s in cf_rec]}")
# 矩阵分解
print("\n--- 矩阵分解 ---")
K_mf=8
P=np.random.randn(n_users,K_mf)*0.01;Q=np.random.randn(n_movies,K_mf)*0.01
obs=list(ratings.keys())
for ep in range(100):
    for u,m in obs:
        r=ratings[(u,m)];pred=P[u]@Q[m];err=r-pred
        P[u]+=0.005*(err*Q[m]-0.02*P[u]);Q[m]+=0.005*(err*P[u]-0.02*Q[m])
    if(ep+1)%25==0:
        rmse=np.sqrt(np.mean([(P[u]@Q[m]-ratings[(u,m)])**2for u,m in obs]))
        print(f"  Epoch{ep+1}:RMSE={rmse:.4f}")
pred_mf=P[target]@Q.T
mf_rec=sorted([(m,pred_mf[m])for m in range(n_movies)if m not in uv.get(target,{})],key=lambda x:-x[1])[:5]
print(f"MF推荐:{[(f'电影{m}',f'{s:.2f}')for m,s in mf_rec]}")
# 内容推荐
print("\n--- 内容推荐 ---")
user_genre_profile=np.zeros(n_genres)
for m,r in uv.get(target,{}).items():user_genre_profile+=movie_genre[m]*r
if user_genre_profile.sum()>0:user_genre_profile/=user_genre_profile.sum()
content_scores=movie_genre@user_genre_profile+movie_quality*0.1
content_rec=sorted([(m,content_scores[m])for m in range(n_movies)if m not in uv.get(target,{})],key=lambda x:-x[1])[:5]
print(f"内容推荐:{[(f'电影{m}',f'{s:.2f}')for m,s in content_rec]}")
# 混合推荐
print("\n--- 混合推荐 ---")
all_scores={}
for m in range(n_movies):
    if m in uv.get(target,{}):continue
    s=0
    if m in pred_cf:s+=0.3*pred_cf[m]/5
    s+=0.4*sigmoid(P[target]@Q[m])/5
    s+=0.3*content_scores[m]
    all_scores[m]=s
def sigmoid(x):return 1/(1+np.exp(-x))
hybrid_rec=sorted(all_scores.items(),key=lambda x:-x[1])[:5]
print(f"混合推荐:{[(f'电影{m}',f'{s:.2f}')for m,s in hybrid_rec]}")
# 电影分析
print("\n电影类型分析:")
for g in range(n_genres):
    g_movies=np.where(movie_genre[:,g]>0)[0]
    avg_rating=np.mean([ratings.get((u,m),0)for u in range(n_users)for m in g_movies])/max(1,len(g_movies))
    print(f"  {genres[g]}:电影数={len(g_movies)} 平均评分={avg_rating:.2f}")

🔴 运行结果

✅ 验证通过

🔍 代码解读

💡 关键洞察

📝 本章小结

🧪 练习

📚 延伸阅读

💼 面试考点

🏭 工业案例