Système de recommandations - Analyse de notes de films
On modélise une plateforme où des utilisateurs notent des films. Les données sont représentées par un dictionnaire :
notes = {
"Amina": [("Inception", 5), ("Matrix", 4), ("Titanic", 3)],
"Youssef": [("Inception", 4), ("Avatar", 5)],
"Sara": [("Matrix", 5), ("Avatar", 4), ("Titanic", 2)],
"Hamza": []
}
Chaque tuple (film, note) représente une évaluation (note sur 5).
Écrire une fonction films_utilisateur(notes, nom) qui retourne la liste des films notés par nom.
Exemple
films_utilisateur(notes, "Amina")
["Inception", "Matrix", "Titanic"]
def films_utilisateur(notes, nom):
if nom not in notes:
return []
films = []
for film, note in notes[nom]:
films.append(film)
return films
Écrire une fonction note_moyenne_utilisateur(notes, nom) qui retourne la moyenne des notes de nom. (Si aucune note → retourner None)
Exemple
note_moyenne_utilisateur(notes, "Amina")
4.0
def note_moyenne_utilisateur(notes, nom):
if nom not in notes or not notes[nom]:
return None
total = 0
for film, note in notes[nom]:
total += note
return total / len(notes[nom])
Écrire ensemble_films(notes) qui retourne l'ensemble de tous les films notés.
def ensemble_films(notes):
films = set()
for utilisateur, evaluations in notes.items():
for film, note in evaluations:
films.add(film)
return films
Écrire notes_film(notes, film) qui retourne la liste des notes attribuées au film.
Exemple
notes_film(notes, "Matrix")
[4, 5]
def notes_film(notes, film):
notes_list = []
for utilisateur, evaluations in notes.items():
for f, note in evaluations:
if f == film:
notes_list.append(note)
return notes_list
Écrire moyenne_film(notes, film) qui retourne la moyenne des notes du film. (Si le film n'a aucune note → retourner None)
def moyenne_film(notes, film):
notes_list = notes_film(notes, film)
if not notes_list:
return None
return sum(notes_list) / len(notes_list)
Écrire meilleur_film(notes) qui retourne le film ayant la meilleure moyenne. (égalité → plus petit nom lexicographiquement)
def meilleur_film(notes):
max_moyenne = -1
meilleur = None
for film in ensemble_films(notes):
moy = moyenne_film(notes, film)
if moy is not None:
if moy > max_moyenne:
max_moyenne = moy
meilleur = film
elif moy == max_moyenne:
if meilleur is None or film < meilleur:
meilleur = film
return meilleur
Écrire utilisateurs_ayant_note(notes, film) qui retourne la liste triée des utilisateurs ayant noté film.
def utilisateurs_ayant_note(notes, film):
utilisateurs = []
for user, evaluations in notes.items():
for f, note in evaluations:
if f == film:
utilisateurs.append(user)
break
utilisateurs.sort()
return utilisateurs
Écrire matrice_utilisateur_film(notes) qui retourne un dictionnaire de dictionnaires tel que : $$\text{res}[u][f] = \text{note de } u \text{ pour } f$$ (si aucune note → absence de clé)
Exemple (partiel attendu)
{
"Amina": {"Inception": 5, "Matrix": 4, "Titanic": 3},
"Youssef": {"Inception": 4, "Avatar": 5},
"Sara": {"Matrix": 5, "Avatar": 4, "Titanic": 2},
"Hamza": {}
}
def matrice_utilisateur_film(notes):
matrice = {}
for user, evaluations in notes.items():
dico = {}
for film, note in evaluations:
dico[film] = note
matrice[user] = dico
return matrice
Écrire films_non_vus(notes, nom) qui retourne l'ensemble des films que nom n'a pas encore notés.
Exemple
films_non_vus(notes, "Youssef")
{"Matrix", "Titanic"}
def films_non_vus(notes, nom):
tous_les_films = ensemble_films(notes)
films_vus = set(films_utilisateur(notes, nom))
return tous_les_films - films_vus
Écrire recommandation(notes, nom) qui retourne le film non vu par nom ayant la meilleure moyenne globale. (Si aucun film → retourner None)
Exemple
recommandation(notes, "Youssef")
"Matrix"
Films non vus : Matrix, Titanic
Moyennes : Matrix = 4.5, Titanic = 2.5
def recommandation(notes, nom):
non_vus = films_non_vus(notes, nom)
if not non_vus:
return None
max_moyenne = -1
meilleur_film = None
for film in non_vus:
moy = moyenne_film(notes, film)
if moy is not None:
if moy > max_moyenne:
max_moyenne = moy
meilleur_film = film
elif moy == max_moyenne:
if meilleur_film is None or film < meilleur_film:
meilleur_film = film
return meilleur_film
Écrire utilisateur_plus_proche(notes, nom) qui retourne l'utilisateur ayant le plus de films en commun avec nom. (égalité → plus petit nom)
def utilisateur_plus_proche(notes, nom):
if nom not in notes:
return None
films_nom = set(films_utilisateur(notes, nom))
max_communs = -1
plus_proche = None
for user, evaluations in notes.items():
if user != nom:
films_user = set(films_utilisateur(notes, user))
communs = len(films_nom & films_user)
if communs > max_communs:
max_communs = communs
plus_proche = user
elif communs == max_communs:
if plus_proche is None or user < plus_proche:
plus_proche = user
return plus_proche
Écrire recommandation_collaborative(notes, nom) qui recommande un film aimé (note ≥ 4) par l'utilisateur le plus proche, mais non vu par nom.
def recommandation_collaborative(notes, nom):
# Trouver l'utilisateur le plus proche
proche = utilisateur_plus_proche(notes, nom)
if proche is None:
return None
# Films non vus par nom
non_vus = films_non_vus(notes, nom)
# Films aimés par l'utilisateur proche (note >= 4)
films_aimes = []
for film, note in notes[proche]:
if note >= 4:
films_aimes.append(film)
# Trouver un film aimé par proche et non vu par nom
for film in films_aimes:
if film in non_vus:
return film
return None
Discussion (0)
Soyez le premier à laisser un commentaire !
Laisser un commentaire
Votre commentaire sera visible après modération.