RAPPORT CODING WEEK

Project 3: Movie recommender system using model-based collaborative filtering

( Matrix factorization )

RÉALISÉ PAR : ENCADRÉ PAR :

GROUPE 4 Mme Sanae FILALI

OUAHCHI FIRDAWS
OUAZZANI CHAHDI Nada
MAAROUFI Ilias
ACHBANI Ismail
TOURE Nagnan Abraham Karim
ABOUELAZ Youssef

2023-2024
 TABLE DES MATIÈRES

TABLE DES MATIÈRES:

I. Contextualisation....................................................................................................4
1. Systèmes de recommandation ...........................................................................4
1.1. Filtration collaborative ..............................................................................4
1.2. Filtration basée sur le contenu ...................................................................5
1.3. Système de recommandation hybride.........................................................5
2. Machine Learning (apprentissage automatique) et ses approches.........................6
2.1. Apprentissage supervisé.............................................................................6
2.1.1.Classification......................................................................................6
2.1.2. Régression..........................................................................................7
2.2. Apprentissage non supervisé......................................................................7
2.2.1. Clustering...........................................................................................7
2.2.2. Réduction de dimensionnalité..............................................................8
2.3. Apprentissage par renforcement.................................................................8
3. Relation entre les systèmes de recommandation et l'apprentissage automatique....9
4. Factorisation matricielle....................................................................................9
5. Enoncé du problème ........................................................................................10

II. Aspect théorique de la factorisation matricielle.......................................................11

1. Aspect mathématique de la factorisation matricielle............................................11
2. Différents types de factorisation matricielle........................................................11
2.1. ALS (Alternating Least Squares) .............................................................11
2.2. SVD (Singular Value Decomposition) ......................................................14
2.3. NMF (Non-Negative Matrix Factorization)...............................................15

III. Analyse Exploratoire des Données (EDA) et visualisation des données.....................16

1. Qu'est-ce que l'Analyse Exploratoire des Données (EDA) ? ...................................16
2. Qu'elles sont les techniques les plus utilisées d'EDA ? ..........................................16
3. Visualisation du Dataset ....................................................................................17

IV. Construction du modèle et évaluation...................................................................19

1. Ensembles d'entraînement et de test...................................................................19
2. Métriques de validation du modèle......................................................................21
2.1. RMSE (Root Mean Square Error) ...............................................................21
2.2. Precision ................................................................................................21
2.3. Recall .....................................................................................................22
2.4. F1-Score .................................................................................................22

V. Explication du Code.............................................................................................23
1. Les bibliothèques utilisées.................................................................................23
2. Division 80/20 (ALS) ..........................................................................................25
2.1. Gestion des données................................................................................25
2.2. Implémentation des métriques.................................................................25
2.3. Implémentation de l’algorithme de l’ALS...................................................26
2.4. Implémentation des outputs.....................................................................27
2.5. Résultats obtenus.....................................................................................27

Rapport - Coding week

2
 TABLE DES MATIÈRES

3. K-Cross méthode 1 (ALS)......................................................................................28

3.1. Gestion des données.........................................................................28
3.2. Implémentation des métriques..........................................................29
3.3. Implémentation de l’algorithme de l’ALS............................................29
3.4. Implémentation des outputs..............................................................30
3.5. Résultats obtenus.............................................................................30
4. K-Cross méthode 2 (ALS).................................................................................32
4.1. Gestion des données.........................................................................32
4.2. Implémentation des métriques..........................................................32
4.3. Implémentation de l’algorithme de l’ALS............................................32
4.4. Implémentation des outputs..............................................................33
4.5. Résultats obtenus.............................................................................33
5. K-Cross méthode 2 (SVD).................................................................................35
5.1. Gestion des données..........................................................................35
5.2. Implémentation des métriques...........................................................35
5.3. Implémentation de l’algorithme de la SVD..........................................36
5.4. Implémentation des outputs..............................................................36
5.5. Résultats obtenus..............................................................................36
6. NMF (Bonus)..................................................................................................37
6.1. Implémentation de l’algorithme de l’NMF...........................................37
6.2. Résultats obtenus..............................................................................38

VI. Analyse des résultats et comparaison.........................................................................40

1. Analyse des résultats..............................................................................................40
1.1. Division 80/20 (ALS)................................................................................40
1.2. K-Cross méthode 1 (ALS).........................................................................41
1.3. K-Cross méthode 2 (ALS).........................................................................41
1.4. K-Cross méthode 2 (SVD)........................................................................41
2. Comparaison entre les résultats..............................................................................42

VII. Centrale Flix (Bonus)................................................................................................44

1. Introduction et objectif..........................................................................................44
2. Description de l'Application....................................................................................44
3. Fonctionnement de l'Application............................................................................45
4. Conclusion et perspectives d'amélioration...............................................................47

VIII. Conclusion et futures perspectives...........................................................................48

1. Conclusion............................................................................................................48
2. Futures perspectives..............................................................................................48

IX. Références bibliographiques.......................................................................................50

Rapport - Coding week 3

 CONTEXTUALISATION

I. CONTEXTUALISATION
Dans un monde où la quantité de contenu disponible explose chaque jour, les systèmes de
recommandation jouent un rôle crucial en aidant les utilisateurs à découvrir des produits, des
services ou des contenus qui correspondent à leurs intérêts et à leurs préférences. L'un des
types les plus populaires de systèmes de recommandation est celui des systèmes de
recommandation de films. Ces systèmes exploitent les avancées de l'intelligence artificielle, en
particulier du machine Learning, pour prédire les préférences des utilisateurs et leur suggérer
des films pertinents.
L’intelligence artificielle est l’ensemble des théories et de techniques mises en œuvre en vue
de réaliser des machines capables de simuler l’intelligence humaine.

1. Systèmes de recommandation
Les systèmes de recommandation sont conçus pour identifier et proposer des produits,
services ou informations adaptés aux préférences individuelles des utilisateurs. Leur
fonctionnement repose sur trois approches principales :

1.1. Filtration collaborative : Ce système se base sur les ressemblances entre les
comportements et les préférences des individus pour leur proposer des produits qui leur
correspondent. Il prend en entrée les préférences des utilisateurs, dans notre contexte cela peut
être les films qui ont été mis en favoris. Il va alors rechercher dans la base de données les
utilisateurs qui ont mis les mêmes films en favoris et ainsi trouver des profils similaires à celui
de l’utilisateur auquel on souhaite faire des recommandations. Ces recommandations seront les
films favoris des utilisateurs qui ont un profil similaire.

Figure 1: Système de recommandation collaboratif

Avantages :
Démarrage facile.
Historique des interactions entre utilisateurs et items : plus cette historique est importante,
plus la recommandation sera pertinente, étant donné qu'elle nécessite uniquement cela.

Inconvénients :
Démarrage à froid pour les nouveaux utilisateurs ou les nouveaux items. C‘est-à-dire qu‘à
l'entrée d'un nouvel utilisateur dans le système, aucun score n'est attribué à aucun item, ce
qui rend les préférences de ce nouvel utilisateur inconnues.

Rapport - Coding week 4

 CONTEXTUALISATION

1.2. Filtration basée sur le contenu : Cette approche recommande des articles en analysant les
caractéristiques des produits eux-mêmes et en les comparant aux préférences ou au profil de
l'utilisateur. Par exemple, si un utilisateur aime des films de science-fiction avec certains
acteurs, le système recommandera d'autres films de science-fiction mettant en vedette ces
acteurs. Les techniques utilisées peuvent inclure l'analyse de texte pour les descriptions de
produits, l'extraction de caractéristiques pour les images, etc.

Figure 2: Système de recommandation basé sur le contenu

Avantages :
Efficacité dans la recommandation des items peu populaires à un utilisateur ayant des goûts
spécifiques.
Capacité de calculer la préférence d'un utilisateur pour un nouvel item, résolvant ainsi en
partie le problème de démarrage à froid.

Inconvénients :
Incapacité de produire des recommandations pour un nouvel utilisateur.
Le modèle produit est spécifique à l'utilisateur, ce qui peut renforcer ses goûts existants et
limiter sa découverte de nouveaux items.

1.3. Système de recommandation hybride : Les méthodes collaboratives et les méthodes

basées sur les contenus ont chacune leurs avantages et leurs inconvénients. Dans la pratique,
on implémente un système hybride de recommandation pour bénéficier des avantages de
chacune de ces techniques tout en mitigeant les inconvénients. Un système hybride permet en
fait d’exploiter à la fois les descriptions des items (ou contenu) et les ratings de la communauté
d’utilisateurs.

Figure 3: Système de recommandation hybride

Rapport - Coding week 5

 CONTEXTUALISATION

2. Machine Learning (apprentissage automatique) et ses approches

Le Machine Learning (ML) correspond à un ensemble d’algorithmes utilisables pour obtenir
une intelligence artificielle. Le ML est un domaine de l’IA qui consiste à implanter un
algorithme qui donne à une machine la capacité d’apprendre à réaliser des tâches. Le ML est le
moteur sous-jacent des systèmes de recommandation permettant de prédire les préférences
des utilisateurs avec un minimum d'intervention humaine.

2.1. Apprentissage supervisé (make predictions)

C’est un apprentissage à partir d’une base de données d’entrainement (Dataset) qui est
constituée d’un nombres de “n” exemples qui sont des paires d’entrées et de leurs sorties (xi,yi).
L'objectif est de prédire la sortie pour de nouvelles entrées. Pour ce faire, chaque exemple de
données est associé à un libellé ou à une catégorie connue, ce processus étant appelé
"labellisation". Par exemple, dans un problème de classification d'e-mails comme "spam" ou
"non-spam", chaque e-mail dans l'ensemble de données d'apprentissage serait labélisé comme
étant soit "spam" soit "non-spam". Le modèle est alors entraîné à reconnaître les
caractéristiques des e-mails associées à chaque catégorie afin de prédire correctement la
catégorie pour de nouveaux e-mails non labellisés.

Figure 4: Principe de fonctionnement de l’apprentissage supervisé .

Si la sortie est un ensemble de groupements, on parle de classification et si la sortie contient

des réels, on parle de régression. Ce sont les deux branches de ce type d’apprentissage .

2.1.1. Classification (Group similar data points together) : Consiste à prédire la classe ou la
catégorie d'un exemple. Exemples: Classification des e-mails en spam ou en non spam,
reconnaissance faciale pour la classification des personnes, etc.

Figure 5: Principe de fonctionnement de la classification.

Rapport - Coding week

6
 CONTEXTUALISATION

2.1.2. Régression (To Make continuous predictions) : Consiste à prédire une valeur continue
pour un exemple donné. Exemples: Prédiction du prix des maisons en fonction de leurs
caractéristiques, estimation du temps de livraison en fonction de la distance, etc.

Figure 6: Principe de fonctionnement de la régression.

Avantages :
Fournir des prédictions précises pour de nouvelles données.
Possibilité d’utilisation pour des tâches variées, telles que la classification, la régression et la
prédiction.

Inconvénients :
Dépendance forte de la qualité et de la quantité des données étiquetées disponibles.
Possibilité d’être sujet à des problèmes de surapprentissage si le modèle est trop complexe
ou si les données d'entraînement sont bruitées.

2.2. Apprentissage non supervisé

Les modèles explorent les données pour trouver des regroupements cachés sans utiliser de
sorties connues. En fait, le terme "non labellisé" fait référence à des données d'entrée qui ne
sont pas accompagnées de libellés ou de catégories connues. Dans les systèmes de
recommandation, cela peut aider à identifier des groupes d'utilisateurs ou d'items similaires
sans connaître leurs préférences spécifiques. Il existe:

2.2.1. Clustering : Consiste à regrouper des exemples similaires en ensembles ou en clusters,

notamment en utilisant des techniques telles que l'algorithme K-Means qui partitionne les
données en k clusters. Exemples: Segmentation de la clientèle pour le marketing ciblé, clustering
des utilisateurs basé sur leurs comportements d'achat.

Figure 7: Principe de fonctionnement du clustering.

Rapport - Coding week

7
 CONTEXTUALISATION

2.2.2. Réduction de dimensionnalité : Consiste à réduire le nombre de variables ou de

caractéristiques dans les données. Exemple: Réduction de dimensionnalité pour la visualisation
de données.

Figure 8: Principe de fonctionnement de réduction de dimensionnalité.

Avantages :
Peut révéler des structures complexes dans les données qui ne seraient pas apparentes
autrement.
N'exige pas de données étiquetées, ce qui le rend plus flexible pour l'analyse exploratoire
des données

Inconvénients :
Les résultats peuvent être difficiles à interpréter, en particulier pour des ensembles de
données complexes.
Peut être sensible à l'initialisation et aux paramètres de l'algorithme.

2.3. Apprentissage par renforcement

L'apprentissage par renforcement est une approche de l'intelligence artificielle qui met
l'accent sur l'apprentissage du système à travers ses interactions avec l'environnement. Avec
l'apprentissage par renforcement, le système adapte ses paramètres en fonction des réactions
reçues de l'environnement, qui fournit ensuite un retour d'information sur les décisions prises .
Par exemple, un système qui modélise un joueur d'échecs qui utilise le résultat des étapes
précédentes pour améliorer ses performances, est un système qui apprend avec le
renforcement.

Avantages :
Peut s'adapter à des environnements changeants et incertains.
Peut prendre en compte les récompenses différées pour optimiser les décisions à long
terme.

Inconvénients :
Peut être difficile à entraîner et à configurer, nécessitant souvent des expériences itératives
et des mécanismes de régularisation.
Peut être sensible à la conception de la fonction de récompense, qui doit être
soigneusement définie pour refléter les objectifs souhaités.

Rapport - Coding week

8
 CONTEXTUALISATION

3. Relation entre les systèmes de recommandation et l'apprentissage automatique

Le principe du système de recommandation est de faire correspondre à l’utilisateur des items
ou des contenus en se basant sur ses interactions précédentes avec le système et en tenant
compte de ses préférences. Le but est notamment d’accroître la satisfaction de l’utilisateur en
personnalisant son expérience sur le site.
Les systèmes de recommandation utilisent souvent des techniques d'apprentissage
automatique pour analyser les préférences des utilisateurs et générer des recommandations
personnalisées. L'apprentissage automatique permet aux systèmes de comprendre les schémas
complexes dans les données utilisateur, tels que les tendances de consommation et les
préférences cachées, afin de fournir des suggestions précises. Ces techniques incluent :

Filtrage collaboratif :
1. Filtrage collaboratif utilisateur-utilisateur.
2. Filtrage collaboratif item-item.
3. Factorisation de matrices.

Filtrage par contenu :

1. Analyse du texte.
2. Représentations vectorielles.
3. Systèmes de recommandation basés sur le contenu.

4. Factorisation matricielle
La factorisation matricielle est une technique utilisée dans les systèmes de recommandation,
en particulier dans le filtrage collaboratif. L'idée principale est de décomposer une grande
matrice (souvent une matrice utilisateur-item indiquant les préférences ou les évaluations des
utilisateurs) en deux matrices de dimension inférieure de telle manière que le produit de ces
deux matrices approche la matrice originale. Cela permet d'identifier des structures latentes
dans les données, souvent interprétées comme des facteurs ou des caractéristiques cachés
influençant les préférences des utilisateurs.

Figure 9: Principe de fonctionnement de la factorisation matricielle.

Rapport - Coding week

9
 CONTEXTUALISATION

Il existe différents types de factorisation de matrice, parmi lesquels on peut citer :

ALS (Alternating Least Squares) : Une approche itérative qui combine la mise à jour des
facteurs utilisateurs et des facteurs items afin de réduire l'erreur quadratique moyenne entre les
prévisions et les observations.

SVD (Singular Value Decomposition) : Une méthode classique de décomposition matricielle

qui décompose la matrice utilisateur-item en trois matrices de facteurs : une matrice de facteurs
utilisateur, une matrice de valeurs singulières et une matrice de facteurs item.

NMF (Non-Negative Matrix Factorization) : Une méthode qui décompose la matrice

utilisateur-item en deux matrices de facteurs non négatifs, permettant ainsi une interprétation
plus intuitive des résultats et pouvant être utilisée lorsque les données sont positives et non
normalisées.

5. Enoncé du problème

Dans le cadre de notre projet, nous avons pour objectif de mettre au point un système de
recommandation de films en exploitant la méthode du filtrage collaboratif basé sur la
factorisation matricielle, en utilisant le dataset MovieLens.

Cette initiative vise principalement à développer un modèle d'apprentissage machine capable

de prédire avec précision les préférences des utilisateurs pour des films qu'ils n'ont pas encore
visionnés, en s'appuyant sur les évaluations historiques et les similarités entre les goûts des
utilisateurs.

L'enjeu est double : d'une part, améliorer l'expérience des utilisateurs en leur proposant des
films qui correspondent véritablement à leurs goûts et préférences, et d'autre part, relever les
défis techniques associés à la gestion et l'analyse de grandes quantités de données, la mise en
œuvre de méthodes de factorisation matricielle avancées et l'évaluation rigoureuse de la
performance des modèles développés.

En complément de ces objectifs, le projet prévoit la création d'une interface web conviviale
permettant aux utilisateurs de visualiser les recommandations générées par le système,
facilitant ainsi leur accès à un contenu personnalisé et améliorant leur engagement.

Ce système de recommandation vise à révolutionner la manière dont les utilisateurs

découvrent les films, en transformant l'expérience de navigation au sein de catalogues
volumineux en un parcours personnalisé et enrichissant, basé sur une compréhension
approfondie de leurs préférences et comportements cinématographiques.

Rapport - Coding week

10
 ASPECT THÉORIQUE DE LA FACTORISATION MATRICIELLE

II. ASPECT THÉORIQUE DE LA FACTORISATION MATRICIELLE

1. Aspect mathématique de la factorisation matricielle

Soit R une matrice de dimensions m × n , où m est le nombre d'utilisateurs et n le nombre

d'items (films, par exemple). La matrice R contient les évaluations données par les utilisateurs
aux items, et beaucoup d'entrées de R sont inconnues (non évaluées).

L'objectif de la factorisation matricielle est de trouver deux matrices de faible rang: P de

dimension m × k et Q de dimension k × n, telles que le produit PQT (où QT: la matrice
transposée de Q) soit une bonne approximation de R. Ici, k est le nombre de facteurs latents et
est beaucoup plus petit que m et n.

Les entrées de P et Q sont ajustées de manière à minimiser l'erreur entre R et PQT, souvent
mesurée par l'erreur quadratique moyenne (RMSE) sur l'ensemble des évaluations connues. La
fonction de coût L(P,Q) peut être exprimée comme suit :

où κ est l'ensemble des indices ( i , j ) pour lesquels l'évaluation rij est connue, pi est la i-ème
ligne de P, qj​est la j-ème colonne de Q, et λ est un terme de régularisation qui aide à éviter le
sur-ajustement en pénalisant les valeurs trop grandes dans P et Q. Pour minimiser la fonction
de coût L(P,Q), les algorithmes ALS, SVD et NMF sont utilisés.

2. Différents types de factorisation matricielle

2.1. ALS (Alternating Least Squares)
L'ALS minimise la fonction de coût L(P,Q) en alternant entre la tenue fixe de P, pour optimiser
Q et la tenue fixe de Q pour optimiser P. Concrètement, cela se fait comme suit :

1. Initialisation : Commencer avec des valeurs initiales pour P et Q, souvent choisies

aléatoirement.
2. Fixer P et optimiser Q : Pour chaque item j, minimiser L(P,Q) par rapport à qj​en tenant P
constant. Cela conduit à un problème de moindres carrés linéaires qui peut être résolu
analytiquement :

où rj​est la colonne j de R et I est la matrice identité de dimension k.

3. Fixer Q et optimiser P : De manière similaire, pour chaque utilisateur i, minimiser L(P,Q)

par rapport à pi​en tenant Q constant :

où ri est la ligne i de R.

Rapport - Coding week

11
 ASPECT THÉORIQUE DE LA FACTORISATION MATRICIELLE

4. Répéter : Alterner entre les étapes 2 et 3 jusqu'à convergence, c'est-à-dire jusqu'à ce que la
réduction de la fonction de coût L(P,Q) entre deux itérations successives soit inférieure à un
seuil prédéfini.

Algorithme fonction als_factorization (Alternating Least Squares)

La fonction als_factorization
1. Initialise aléatoirement les facteurs de la matrice utilisateurs P et la matrice items Q avec
des valeurs entre 0 et 3. P a une dimension de num_factors × num_users, tandis que Q a
une dimension de num_factors × num_items.
2. Initialise la première ligne de Q avec les moyennes des notations: La première ligne de Q
est initialisée avec les moyennes des notations pour chaque item. Cela est fait en calculant
la moyenne des notations non nulles pour chaque item dans la matrice R et en l'assignant à
la première ligne de Q.
3. Identifie la matrice identité pour la régularisation: Une matrice identité de taille
num_factors × num_factors est créée pour la régularisation. Cette matrice sera utilisée
plus tard dans le processus de régularisation.

Cette partie de la fonction als_factorization correspond à la boucle d'entraînement de

l'algorithme ALS, qui parcourt chaque utilisateur et calcule le nombre d'items qu'il a notés.
Si un utilisateur n'a noté aucun item, le nombre est ajusté à 1 pour éviter une division par zéro
lors des mises à jour des facteurs utilisateur.

Rapport - Coding week

12
 ASPECT THÉORIQUE DE LA FACTORISATION MATRICIELLE

1. On extrait les indices des items notés par l'utilisateur i à partir du vecteur indicateur Ii.
2. On extrait les caractéristiques latentes des items notés par l'utilisateur i à partir de la
matrice Q.
3. On extrait les notations de l'utilisateur i pour les items notés à partir de la matrice R.
4. Résolution du système linéaire : On résout un système linéaire pour obtenir les
caractéristiques latentes de l'utilisateur i. Cela implique la construction d'une matrice Ai et
d'un vecteur Vi, puis l'utilisation de la fonction de résolution de système linéaire pour
trouver les facteurs utilisateur P.

Cette partie du code parcourt tous les items pour calculer le nombre d'utilisateurs ayant noté
chaque item. Si aucun utilisateur n'a noté aucun item particulier, le nombre est ajusté à 1 pour
éviter une division par zéro lors des mises à jour des facteurs item.

Cette partie du code met à jour les facteurs item en résolvant un système linéaire basé sur
les caractéristiques latentes des utilisateurs qui ont noté chaque item et leurs notations
respectives.

Rapport - Coding week

13
 ASPECT THÉORIQUE DE LA FACTORISATION MATRICIELLE

2.2. SVD (Singular Value Decomposition)

Tout comme l’ALS, la SVD vise à décomposer une matrice R (les évaluations des utilisateurs
sur des films) en composantes plus simples, facilitant ainsi la découverte de structures latentes
dans les données. Pour la SVD, la décomposition s'écrit :

U représente les vecteurs propres de RRT (RT: la transposée de R) et contient des

informations sur les utilisateurs.
Σ est une matrice diagonale contenant les valeurs singulières de R qui quantifient
l'importance de chaque caractéristique latente. (Les valeurs singulières sont les valeurs
propres de la matrice RRT).
VT (la transposée de V) contient des informations sur les films.
L'application de SVD dans le cadre des systèmes de recommandation se fait en approximant
R par une version réduite, , où seules les k plus grandes valeurs singulières (et
leurs vecteurs correspondants) sont conservées. Cette approximation de rang inférieur capture
les tendances principales des données tout en réduisant le bruit et les détails superflus.

Tandis que l'ALS optimise alternativement les matrices de facteurs latents P et Q en

minimisant une fonction de coût, la SVD décompose directement la matrice R en composantes
singulières, sans nécessiter d'itérations alternées.

Algorithme SVD (Singular Value Decomposition)

Ce code utilise la bibliothèque existante Surprise pour construire et entraîner un modèle SVD
pour la recommandation de films.
On commence par instancier un objet de modèle SVD en utilisant la classe SVD fournie par la
bibliothèque Surprise. Cette classe prend plusieurs paramètres :
n_factors : Le nombre de facteurs latents à utiliser dans la décomposition. Cela détermine
la dimensionnalité des espaces de facteurs utilisateur et item.
n_epochs : Le nombre d'epochs (itérations) à utiliser lors de l'apprentissage du modèle. Plus
le nombre d'epochs est élevé, plus le modèle aura la possibilité d'apprendre à partir des
données.
reg_all : Le terme de régularisation à appliquer à tous les paramètres du modèle. Cela
permet de contrôler le sur-ajustement en ajoutant une pénalité pour des valeurs de
paramètres trop grandes.
Ensuite, on entraîne le modèle en appelant la méthode fit() sur l'objet de modèle SVD. On lui
fournit les données d'entraînement sous forme d'un ensemble de données de formation
construit à partir des données d'entraînement initiales à l'aide de la méthode
build_full_trainset() de l'objet train_data. Cette méthode crée un ensemble de données
d'entraînement complet à partir des données fournies, ce qui est nécessaire pour que le modèle
puisse être entraîné correctement.

Rapport - Coding week 14

 ASPECT THÉORIQUE DE LA FACTORISATION MATRICIELLE

2.3. NMF (Non-negative Matrix Factorization)

Contrairement à SVD et ALS, NMF impose une contrainte de non-négativité sur les matrices
qu'elle décompose, ce qui rend l'interprétation des composants beaucoup plus intuitive,
notamment dans des contextes où les données ne peuvent pas être négatives (comme des notes,
des fréquences, etc.).

Mathématiquement, la NMF consiste à factoriser une matrice de données V (de dimensions

m×n) en deux matrices non-négatives W (de dimensions m×k) et H (de dimensions k×n), où k
est le nombre de facteurs ou de composantes souhaitées. Plus précisément, l'objectif est
d'approximer la matrice V par le produit WH.

Dans ce code, nous avons utilisé la classe NMF de la bibliothèque scikit-learn pour effectuer la
factorisation de la matrice. Nous initialisons le modèle avec le nombre de facteurs souhaités
(n_components) et le nombre maximal d'itérations (max_iter). Ensuite, nous adaptons le
modèle aux données de notation (R) à l'aide de la méthode fit_transform(), qui renvoie les
matrices W et H correspondant aux facteurs utilisateur et item respectivement.

Rapport - Coding week 15

 ANALYSE EXPLORATOIRE DES DONNÉES ET VISUALISATION DES DONNÉES

III. ANALYSE EXPLORATOIRE DES DONNÉES (EDA) ET

VISUALISATION DES DONNÉES
[Link]'est-ce que l'Analyse Exploratoire des Données (EDA) ?

L'Analyse Exploratoire des Données (EDA) permet aux analystes de comprendre les données,
de formuler des hypothèses et de déterminer quelles stratégies de modélisation ou de calcul
utiliser. C’est une étape cruciale avant la modélisation dans tout projet de science des données,
où un certain nombre de techniques sont utilisées pour mieux comprendre l'ensemble de
données utilisé, ceci est accompli en faisant :

Extraire des variables importantes et laisser des variables inutiles

Identifier les valeurs aberrantes, les valeurs manquantes ou les erreurs humaines
Comprendre la (les) relation (s), ou l'absence de, entre les variables
Maximiser les connaissances sur un ensemble de données et minimiser les erreurs
potentielles pouvant survenir plus tard dans le processus

2. Qu'elles sont les techniques les plus utilisées d'EDA ?

Analyse Univariable non-graphique : Cette forme d'analyse est la plus simple, se concentrant
sur une seule variable sans tenir compte des causes ou des relations avec d'autres variables. Son
but principal est de décrire les données pour identifier des tendances ou des modèles internes.
Par exemple, calculer la moyenne, la médiane, le mode, la variance, et l'écart type.

Analyse Univariable graphique : Les méthodes non-graphiques ne fournissent pas une image
complète des données, donc les méthodes graphiques sont nécessaires pour une meilleure
visualisation.
Diagrammes en tige-et-feuille : Ils montrent toutes les valeurs des données et la forme de la
distribution.
Histogrammes : Un type de graphique à barres où chaque barre représente la fréquence
(nombre) ou proportion (nombre/total) de cas pour une plage de valeurs.
Boîtes à moustaches (Box plots) : Elles représentent graphiquement un résumé en cinq
nombres : minimum, premier quartile, médiane, troisième quartile et maximum.

Analyse Multivariée non-graphique : Lorsque les données proviennent de plus d'une variable,
on parle de données multivariées. Ces techniques d'EDA montrent les relations entre deux ou
plusieurs variables à travers des tableaux croisés ou des statistiques.

Analyse Multivariée graphique : Les données multivariées utilisent des graphiques pour
afficher les relations entre deux ou plus ensembles de données.
Graphiques à barres groupées : Chaque groupe représente un niveau d'une des variables, et
chaque barre au sein d'un groupe représente les niveaux de l'autre variable.
Graphiques multivariés : Représentation graphique des relations entre plusieurs facteurs et
une réponse.
Graphiques à bulles (Bubble charts) : Une visualisation qui affiche plusieurs cercles (bulles)
dans un tracé bidimensionnel.
Cartes de chaleur (Heat maps) : Représentation graphique des données où les valeurs sont
représentées par des couleurs.

Rapport - Coding week 16

 ANALYSE EXPLORATOIRE DES DONNÉES (EDA) ET VISUALISATION DES DONNÉES

3. Visualisation du DataSet
Utilisateurs

Figure 1: Répartition des sexes des utilisateurs

Figure 2 : Répartition des occupations des utilisateurs

Figure 3: Distribution des âges des utilisateurs

Rapport - Coding week 17

 ANALYSE EXPLORATOIRE DES DONNÉES (EDA) ET VISUALISATION DES DONNÉES

Films

Figure 4: Pourcentage des évaluations par note

Figure 5: Pourcentage de films par genre

Figure 6: Top 20 des films les plus évalués

NB : Un fichier [Link] regroupant tous les codes de cette partie est déposé en complément avec le rapport.

Rapport - Coding week 18

 CONSTRUCTION DU MODÈLE ET ÉVALUATION

IV. CONSTRUCTION DU MODÈLE ET ÉVALUATION

1. Ensembles d'entraînement et de test

Afin d’évaluer les performances d'un modèle d'apprentissage automatique, on divise la base de
données en ensembles d'entraînement et de test, et cela s’avère important pour plusieurs
raisons :

Évaluation des performances : La division des données permet de tester le modèle sur des
données qu'il n'a pas vues pendant l'entraînement, ce qui donne une estimation plus précise
de sa capacité à généraliser sur de nouvelles données.

Prévention du sur-ajustement : En réservant une partie des données pour le test, nous
nous assurons que le modèle n'apprend pas simplement par cœur les données
d'entraînement, mais qu'il est capable de généraliser à de nouvelles données.

Le sur-ajustement se produit lorsque le modèle s'adapte trop précisément aux données

d'entraînement spécifiques, ce qui compromet sa capacité à généraliser à de nouvelles données.
En réservant une partie des données pour le test, nous pouvons donc évaluer si le modèle
généralise efficacement ou s'il est trop adapté aux données d'entraînement. Cela permet de
garantir que le modèle produit des prédictions précises dans des situations réelles.

Réduction de la variance : La division des données permet de réduire la variance des

performances du modèle en évaluant sa performance sur plusieurs ensembles de test
différents.

Il existe différentes façons de diviser les données:

Division 80/20 : Dans cette approche, 80% des données sont utilisées pour l'entraînement et
20% pour le test.

Division 75/25 : Similaire à la division 80/20, mais avec une répartition légèrement
différente où 75% des données sont utilisées pour l'entraînement et 25% pour le test.

K-Fold Cross-Validation : Cette méthode divise les données en K sous-ensembles, appelés

"folds", où K-1 folds sont utilisés pour l'entraînement et 1 fold est utilisé pour le test. Cette
opération est répétée K fois, en utilisant chaque fold comme ensemble de test une fois.

Leave-One-Out Cross-Validation (LOOCV) : Dans cette méthode, un seul échantillon est

maintenu comme ensemble de test à chaque itération, tandis que tous les autres
échantillons sont utilisés pour l'entraînement.

Nested Cross-Validation : l'ensemble de données est divisé en k folds, puis pour chaque
fold, un processus de validation croisée est appliqué à nouveau pour diviser ce fold en deux
parties distinctes : une pour l'entraînement et une pour le test.

Rapport - Coding week 19

 CONSTRUCTION DU MODÈLE ET ÉVALUATION

Comparaison entre les différentes méthodes de division de données

Avantages de la division 80/20 ou division 75/25

Utilisation plus importante des données d'entraînement.

Ensemble de test légèrement plus large.

Inconvénients de la division 80/20 ou division 75/25

Moins de données pour l'évaluation.

Sensibilité à la répartition des données.

Avantages de la validation croisée

K-Fold Cross-Validation :
Permet une meilleure utilisation des données en effectuant K itérations où chaque
échantillon est utilisé une fois comme ensemble de test.
Fournit une estimation plus robuste des performances du modèle.
Leave-One-Out Cross-Validation (LOOCV) :
Utilise toutes les données disponibles pour l'entraînement à l'exception d'une seule
observation, ce qui peut conduire à une meilleure estimation des performances du modèle.
Nested Cross-Validation :
Permet une évaluation plus fiable de la performance du modèle.
Réduit le risque de sur-ajustement.

Inconvénients de la validation croisée

K-Fold Cross-Validation :
Peut être plus coûteux en termes de temps de calcul, surtout avec de grands ensembles de
données et des valeurs élevées de K.
Leave-One-Out Cross-Validation (LOOCV) :
Peut être coûteux en termes de temps de calcul, en particulier avec de grandes quantités de
données.
Nested Cross-Validation :
Augmente considérablement le temps de calcul en raison de la répétition de la validation
croisée à chaque Fold.

Chacune de ces méthodes a ses avantages et ses inconvénients, le choix de la méthode dépend
souvent de la taille de l'ensemble de données, de sa distribution, et des exigences spécifiques du
problème.

Rapport - Coding week 20

 CONSTRUCTION DU MODÈLE ET ÉVALUATION

2. Métriques de validation du modèle

2.1. RMSE (Root Mean Square Error)

L'erreur quadratique moyenne de la racine (RMSE) calcule la valeur moyenne de toutes les
différences au carré entre les notes réelles et prédites, puis procède au calcul de la racine
carrée sur le résultat. Ainsi, de grandes erreurs peuvent avoir un impact significatif sur la note
RMSE, ce qui rend la métrique RMSE plus précieuse lorsque des erreurs significatives sont
indésirables. Les notes réelles et les notes prédites ont une erreur quadratique moyenne de :

- d i : est la note réelle.

- ˆd i : est la note prévue.
- n : est le nombre de notes.

Algorithme de calcul de la métrique RMSE

2.2. Precision

Lorsqu'on cherche à prédire si un utilisateur est intéressé ou non par un item, quatre
possibilités sont offertes par la matrice de confusion.

La précision correspond au pourcentage ou au nombre des items suggérés et s'avérant

véritablement pertinentes pour l'utilisateur. Par exemple, si l'on considère une liste des Top-N
recommandations, la précision correspond à la proportion d'items véritablement consommés,
appréciés ou achetés par l'utilisateur courant. Elle est calculée en utilisant la formule suivante:

Rapport - Coding week 21

 CONSTRUCTION DU MODÈLE ET ÉVALUATION

2.3. Recall

Le rappel mesure le nombre de recommandations pertinentes émises au regard du nombre

total de recommandations pertinentes. Concrètement, on énumère le nombre d'items dont la
mesure associée est non nulle et se retrouvant parmi les items suggérés, il est calculé par la
formule ci-dessous :

Si la précision est faible, l'utilisateur sera insatisfait, car il devra perdre du temps à lire des
items qui ne l'intéressent pas.
Si le rappel est faible, l'utilisateur n'aura pas accès à un item qu'il souhaiterait avoir.

2.4. F1-Score

Le F1-score est une alternative métrique d'évaluation en apprentissage automatique qui

évalue les compétences prédictives d'un modèle en détaillant sa performance par classe plutôt
qu'une performance globale comme le fait l'exactitude. Le score F1 combine deux métriques
concurrentes - la précision et le rappel du modèle, ce qui explique son utilisation répandue. Il
est calculé par la formule ci-dessous :

Rapport - Coding week 22

 EXPLICATION DU CODE

V. EXPLICATION DU CODE
1. Les bibliothèques utilisées
Bibliothèque Pandas

La bibliothèque pandas offre des structures de données flexibles et performantes, notamment

les DataFrames, qui permettent de stocker et de manipuler des données tabulaires de manière
intuitive. Dans notre code, nous utilisons pandas pour plusieurs tâches clés.
D'abord, nous l'utilisons pour lire les données à partir d'un fichier CSV à l'aide de la fonction
pd.read_csv()qui nous permet de charger les données de notre fichier '[Link]' et de les stocker
dans un DataFrame pandas avec des noms de colonnes spécifiques.
Ensuite, nous utilisons les fonctionnalités de pandas pour effectuer des opérations de
prétraitement sur les données, telles que la division des données en ensembles d'entraînement
et de test à l'aide de train_test_split(), la création de matrices de notation à partir des données,
et la manipulation des DataFrames pour extraire les évaluations réelles et les prédictions pour
un utilisateur spécifique.
Bibliothèque NumPy

La bibliothèque NumPy offre des structures de données efficaces pour les calculs numériques
et algébriques. Dans notre code, NumPy est utilisé pour plusieurs aspects clés.
D'abord, nous l’utilisons pour créer des matrices [Link]() et les manipuler, comme les
matrices de notation (R et T) et les matrices d'index (I et I2). Ces matrices sont des tableaux
NumPy qui représentent respectivement les évaluations des utilisateurs sur les articles et les
indices indiquant la présence de ces évaluations.
Ensuite, dans le processus de factorisation de matrices, nous utilisons les fonctionnalités de
NumPy pour des calculs algébriques, tels que la résolution de systèmes d'équations linéaires à
l'aide de [Link]() qui met à jour les matrices de facteurs latents (P et Q) lors de
l'entraînement du modèle.
De plus, NumPy est utilisé pour effectuer des calculs matriciels qui sont au cœur de
l'algorithme de factorisation de matrices. [Link](): produit matriciel, [Link](): racine carrée,
[Link](): somme éléments, [Link](): crée tableau , [Link](): moyenne éléments,
[Link](): nombres aléatoires, [Link](): matrice identité.
Bibliothèque scikit-learn (sklearn.model_selection)

La bibliothèque sklearn.model_selection de scikit-learn est une composante essentielle pour

la validation croisée, la sélection de modèles et la division de données pour l'entraînement et
les tests dans le contexte de l'apprentissage automatique. Dans notre code, nous l'importons
pour utiliser la fonction train_test_split() qui permet de diviser nos données en ensembles
d'entraînement et de test pour évaluer la performance de notre modèle de filtrage collaboratif,
en vérifiant la capacité de généralisation du modèle sur des données qu'il n'a pas encore vues.
On a aussi utilisé la fonction KFold, une autre fonctionnalité de cette bibliothèque, pour la
validation croisée, optimisant l'évaluation de la performance et la généralisation du modèle.
Cette méthode divise les données en k segments égaux, entraînant et évaluant le modèle k fois.
Chaque segment sert une fois comme ensemble de test, tandis que les autres composent
l'ensemble d'entraînement.

Rapport - Coding week 23

 EXPLICATION DU CODE

Bibliothèque [Link]

[Link] est une bibliothèque de visualisation en Python utilisée pour créer des
graphiques et des visualisations de données.
Nous utilisons la fonction [Link]() de [Link] pour tracer les courbes d'erreur.
Dans ce contexte, nous traçons à la fois l'erreur RMSE sur l'ensemble d'entraînement et
l'ensemble de test par rapport au nombre d'époques. Ces courbes nous permettent de visualiser
la performance de notre modèle pendant l'entraînement et de détecter tout signe de
surapprentissage (overfitting) ou de sous-apprentissage (underfitting).
En utilisant d'autres fonctions de [Link] telles que [Link](), [Link](),
[Link]() et [Link](), nous ajoutons des titres et des légendes à notre graphique pour le
rendre plus informatif et compréhensible.

Bibliothèque surprise

La bibliothèque Surprise est spécialisée dans les systèmes de recommandation. Nous utilisons
ses classes Dataset et Reader pour charger et préparer les données de recommandation.
Dataset convertit les données de sources variées en un format compatible avec les algorithmes
de Surprise, tandis que Reader spécifie les bornes de notation (1 à 5, par exemple).
La fonction cross_validate permet une validation croisée à k-fold, évaluant les modèles sur
différentes métriques comme le RMSE. L'algorithme SVD, accessible via la classe SVD, est
central pour nos modèles de recommandation, permettant de configurer des paramètres tels
que le nombre de facteurs latents. Ces importations facilitent le chargement des données, la
validation croisée, et l'entraînement des modèles, exploitant les fonctions spécifiques à la
recommandation de Surprise.

Bibliothèque flask

Flask est un framework Python pour développer des applications web rapidement. Il gère la
création de l'application, la présentation de pages HTML, l'envoi de fichiers et d'autres
interactions HTTP. Nous définissons des routes pour gérer l'authentification, le
téléchargement/suppression de fichiers et la génération de recommandations.
La fonction login() authentifie les utilisateurs, et une fois connectés, Flask utilise leur ID pour
proposer des recommandations personnalisées via la fonction
matrix_factorization_recommendations, qui applique une factorisation de matrices aux
données utilisateurs-articles. Les recommandations générées sont affichées sur le web grâce à
render_template, offrant ainsi une expérience utilisateur sur mesure. Flask facilite donc
l'intégration du modèle de recommandation avec l'interface utilisateur, enrichissant
l'expérience par des suggestions ciblées.

Bibliothèque Pickle

La bibliothèque pickle est utilisée pour sauvegarder et charger les matrices P et Q, générées
aléatoirement, dans un fichier "NMF_matrices.pkl" via `[Link]()` et `[Link]()`,
respectivement. Cette technique de sérialisation permet de stocker efficacement ces objets
Python, évitant ainsi de les recalculer, ce qui est avantageux dans les scénarios où la génération
des données est coûteuse en temps ou en ressources.

Rapport - Coding week 24

 EXPLICATION DU CODE

2. Division 80/20 (ALS)

2.1. Gestion des données

Dans cette section, nous avons commencé par la lecture des données à partir d'un fichier et
les avons transformées en un format utilisable pour l'entraînement et les tests. Les données ont
été lues à l'aide de la bibliothèque Pandas et stockées dans un DataFrame. Ensuite, nous avons
divisé ces données en ensembles d'entraînement et de test à l'aide de la fonction
train_test_split de la bibliothèque sklearn.model_selection (80% pour l'entraînement et 20%
pour le test).

Pour préparer les données pour l'algorithme de factorisation de matrices, nous avons rempli
notre matrice utilisateur-film avec des 0 dans les parties où les données sur les évaluations des
films étaient manquantes. Cette étape est cruciale car elle permet de garantir que notre modèle
puisse traiter efficacement les données incomplètes et fournir des prédictions appropriées pour
les évaluations manquantes. Enfin, nous avons converti ces ensembles en matrices pour les
utiliser dans l'algorithme de factorisation de matrices.
2.2. Implémentation des métriques
Nous avons défini les métriques d'évaluation pour évaluer les performances de notre modèle
de recommandation. Ces métriques comprennent la racine carrée de l'erreur quadratique
moyenne (RMSE), la précision, le rappel et le score F1.

Rapport - Coding week 25

 EXPLICATION DU CODE

2.3. Implémentation de l’algorithme de l’ALS

Le code fourni initialise les paramètres du modèle pour la factorisation de la matrice de
notation utilisateur-élément R. Au début, il définit λ pour la régularisation et k pour le nombre
de facteurs latents, ce qui permet de contrôler la complexité du modèle et d'éviter le
surapprentissage. Par la suite, les dimensions de R (m lignes et n colonnes) sont extraites afin
de préparer l'algorithme pour la décomposition de la matrice. En utilisant l'algorithme
Alternating Least Squares (ALS) de manière itérative, les matrices P et Q sont apprises en
alternance, résolvant ainsi des problèmes de moindres carrés. Il convient de noter que la
régularisation est appliquée lors de la mise à jour des matrices, ce qui contribue à améliorer la
généralisation du modèle en contrôlant les termes de grande magnitude dans P et Q. Le nombre
d'itérations, contrôlé par n_epochs, détermine la durée de l'apprentissage du modèle. Enfin, les
erreurs sont calculées tout au long du processus d'apprentissage pour évaluer les performances
du modèle.

Rapport - Coding week 26

 EXPLICATION DU CODE

2.4. Implémentation des outputs

Nous avons calculé les erreurs d'entraînement et de test ainsi que les métriques de
performance à chaque époque d'entraînement. Ces résultats ont été stockés dans des listes pour
une analyse ultérieure.

2.5. Résultats obtenus

Nous avons présenté les résultats obtenus après l'entraînement du modèle. Cela inclut
l'affichage des erreurs RMSE d'entraînement et de test, ainsi que la précision, le rappel et le
score F1 d'entraînement. Nous allons explorer les détails de ces résultats dans la partie VI.

Vous trouverez ci-dessous une représentation de nos métriques pour la phase d'entraînement
ainsi que pour la phase de test en fonction du nombre d'époques.
Le temps d'exécution du code est de 8 secondes .

Figure 1: Performances des métriques en fonction des epochs

Rapport - Coding week 27

 EXPLICATION DU CODE

Ci-dessus, vous trouverez la comparaison entre la moyenne de chaque métrique dans le même
histogramme.

Figure 2: Histogramme de l’erreur en fonction des différentes métriques

Et finalement, voici les prédictions de notation pour un utilisateur, basées uniquement sur ses 5
meilleurs films.

3. K-Cross méthode 1 (ALS)

3.1. Gestion des données
Dans cette partie, nous nous occupons de la manipulation des données nécessaires pour
entraîner et tester notre modèle de filtrage collaboratif. D'abord, nous lisons les données à
partir d'un fichier CSV contenant les évaluations des utilisateurs pour les articles. Ces données
sont stockées dans un DataFrame Pandas pour une manipulation plus facile. Ensuite, nous
divisons ces données en ensembles d'entraînement et de test à l'aide de la fonction
train_test_split de scikit-learn. Cette division est cruciale pour évaluer les performances du
modèle sur des données non vues pendant l'entraînement. Enfin, nous convertissons ces
données en matrices, où chaque ligne représente un utilisateur et chaque colonne représente
un article, avec les valeurs de notation correspondantes.

Rapport - Coding week 28

 EXPLICATION DU CODE

3.2. Implémentation des métriques

Dans cette partie, nous définissons les métriques de performance que nous utiliserons pour
évaluer la qualité des prédictions de notre modèle. Nous utilisons la racine de l'erreur
quadratique moyenne (RMSE), qui mesure la différence entre les évaluations réelles et les
prédictions du modèle. En outre, nous calculons la précision, le rappel et le score F1 pour
évaluer la capacité du modèle à recommander les bons articles aux utilisateurs.

3.3. Implémentation de l’algorithme de l’ALS

Cette section concerne la validation croisée K-fold, une technique importante pour évaluer
les performances d'un modèle de manière robuste. Nous divisons les données en K folds.
Ensuite, nous entraînons et testons le modèle K fois, chaque fois en utilisant un fold différent
comme ensemble de test et les autres folds comme ensemble d'entraînement. Cela nous permet
d'obtenir une estimation plus fiable des performances du modèle, car il est testé sur différentes
combinaisons de données d'entraînement et de test.

Rapport - Coding week 29

 EXPLICATION DU CODE

3.4. Implémentation des outputs

Dans cette partie, nous nous concentrons sur la gestion des résultats produits par notre
modèle. D'abord, nous suivons les erreurs d'entraînement et de test ainsi que les métriques de
performance telles que la précision, le rappel et le score F1. Ces informations sont essentielles
pour comprendre comment notre modèle se comporte pendant l'entraînement et l'évaluation.

Ensuite, nous générons des recommandations personnalisées pour les utilisateurs en

identifiant les articles qu'ils n'ont pas encore évalués et en leur attribuant des notes prédictives.
Ces recommandations sont basées sur les préférences d'autres utilisateurs similaires .

3.5. Résultats obtenus

Dans cette section, nous présentons les résultats de notre évaluation du modèle, ce qui inclut
les métriques de performance moyennes telles que la précision moyenne, le RMSE moyen, le
rappel moyen et le score F1 moyen. Ces résultats nous donnent une idée de l'efficacité globale
de notre modèle pour recommander des articles aux utilisateurs.

Rapport - Coding week 30

 EXPLICATION DU CODE

Voici les résultats des métriques pour chaque epoch ainsi que leur moyenne pour toutes les
époques.
Le temps d'exécution du code est de 29 secondes.

Ci-dessus, vous trouverez la comparaison entre la moyenne de chaque métrique dans le même
histogramme.

Figure 3: Histogramme de l’erreur en fonction des différentes métriques de la méthode K-Cross 1 (ALS)

Finalement, voici les prédictions de notation pour l'utilisateur 17, basées uniquement sur ses 15
meilleurs films.

Ci-dessous, une comparaison entre son Actual Rating et le

Predicted Rating pour 5 films.

Rapport - Coding week 31

 EXPLICATION DU CODE

4. K-Cross méthode 2 (ALS)

4.1. Gestion des données

Dans cette section, nous gérons les données nécessaires à notre modèle de recommandation
collaborative. D'abord, nous utilisons une fonction load_data(filepath) pour charger les
données à partir d'un fichier CSV spécifié par filepath. Ensuite, nous transformons les données
en une matrice d'utilité, où les utilisateurs sont représentés par les lignes et les articles par
les colonnes. Cette matrice est essentielle pour entraîner notre modèle de recommandation.

4.2. Implémentation des métriques

Dans cette partie, nous définissons les métriques de performance que nous utiliserons pour
évaluer la qualité des prédictions de notre modèle .

4.3. Implémentation de l’algorithme de l’ALS

Dans l'implémentation de l'algorithme de "K-Cross 2", la méthode de validation croisée

utilisée diffère de celle de "K-Cross 1" observée dans le code précédent. Dans cette approche,
les données sont divisées en ensembles distincts (u1 à u5), où chaque ensemble est utilisé
séparément comme ensemble de test tandis que les autres sont utilisés comme ensembles
d'entraînement.

Rapport - Coding week 32

 EXPLICATION DU CODE

4.4. Implémentation des outputs

Dans cette section, nous présentons les résultats obtenus de l'évaluation du modèle. Nous
effectuons une comparaison entre les évaluations réelles et prédites pour un utilisateur
spécifique afin de donner une illustration concrète de la performance de notre modèle. Cette
comparaison nous aide à comprendre comment notre modèle se comporte dans la pratique
pour les recommandations individuelles.

4.5. Résultats obtenus

Dans cette section, nous affichons les résultats obtenus de l'évaluation du modèle. Nous
présentons les métriques de performance moyennes sur l'ensemble des Folds de validation
croisée.

Rapport - Coding week 33

 EXPLICATION DU CODE

Dans cette dernière partie, nous affichons les résultats obtenus après l'exécution de
l'algorithme. Voici donc les résultats des différentes métriques pour chaque Fold ainsi que leur
moyenne
Avec un temps d'exécution de 24 secondes pour ce code.

Voici une comparaison entre les ratings réelles et les predicted ratings pour l’utilisateur 11.

Finalement, voici la comparaison entre la moyenne de chaque métrique dans le même

histogramme.

Figure 4: Histogramme de la moyenne de l’erreur de différentes métriques de la méthode

K-Cross 2(ALS)

Rapport - Coding week 34

 EXPLICATION DU CODE

5. K-Cross méthode 2 (SVD)

5.1. Gestion des données
Dans cette section, nous gérons le chargement et la préparation des données avant de les
utiliser pour entraîner et évaluer notre modèle.

5.2. Implémentation des métriques

Dans cette partie, nous définissons les métriques qui seront utilisées pour évaluer les
performances de notre modèle.

5.3. Implémentation de l’algorithme de la SVD

Cette section couvre l'implémentation de l'algorithme de factorisation matricielle SVD. Nous
utilisons la bibliothèque Surprise pour cela. Dans cette partie, nous définissons les paramètres
du modèle, comme le nombre de facteurs latents, le nombre d'itérations, et le terme de
régularisation. Ensuite, nous entraînons le modèle sur les données d'entraînement et générons
des prédictions sur les données de test.

Rapport - Coding week 35

 EXPLICATION DU CODE

5.4. Implémentation des outputs

Cette section prend en considération le code pour afficher les résultats obtenus, tels que
les scores RMSE moyens, la précision moyenne, le rappel moyen et le score F1 moyen sur
toutes les Folds de la validation croisée.

5.5. Résultats obtenus

Dans cette dernière partie, nous affichons les résultats obtenus après l'exécution de
l'algorithme. Voici donc les résultats des différentes métriques pour chaque Fold ainsi que leur
moyenne
Avec un temps d'exécution de 4 secondes pour ce code.

Finalement, voici la comparaison entre la moyenne de chaque métrique dans le même

histogramme.

Figure 5: Histogramme de la moyenne de l’erreur de différentes métriques de la

méthode K-Cross 2(SVD)

Rapport - Coding week 36

 EXPLICATION DU CODE

6. NMF (Bonus)
6.1. Implémentation de l’algorithme de l’NMF

Cette première partie du code définit une fonction nommée compute_metrics qui calcule la
précision, le rappel et le score F1 à partir des données de notation des films, des matrices P et
Q issues de la factorisation de matrice, ainsi qu'un seuil optionnel.

Ces étapes préparent les données et sauvegardent les matrices P et Q pour une utilisation
ultérieure dans l'entraînement du modèle NMF (Non-negative Matrix Factorization).
La méthode [Link]() est utilisée pour sauvegarder chaque matrice, avec
pickle.HIGHEST_PROTOCOL spécifié comme protocole de sérialisation pour garantir une
compatibilité maximale.

Rapport - Coding week 37

 EXPLICATION DU CODE

Cette partie du code concerne l'entraînement du modèle NMF et la collecte des erreurs et
métriques pour chaque époque. On commence par Initialiser les listes d'erreurs et de
métriques, on ajoute une boucle d'entraînement sur les époques et une sur les utilisateurs.
Ensuite, on calcule l'erreur et on met à jour les matrices P et Q.

6.2. Résultats obtenus

Nous constatons que les résultats de l'entraînement du modèle semblent montrer une
amélioration progressive des performances au fil des époques.
Pour un temps d'exécution de 31 secondes pour ce code.

Rapport - Coding week 38

 EXPLICATION DU CODE

Précision (Precision) :
On observe une augmentation générale de la précision au fil des époques, avec une moyenne
de précision sur toutes les époques de 0.7939. Cela indique que le modèle devient plus sélectif
dans ses recommandations et présente moins de faux positifs.

Rappel (Recall) :
Bien que le rappel augmente également au fil des époques, il semble augmenter à un rythme
plus lent que la précision, suggérant ainsi que le modèle pourrait manquer certaines
recommandations pertinentes.

Score F1 (F1-Score) :
Une augmentation du score F1 indique généralement une amélioration globale de la
performance du modèle, avec une moyenne du score F1 sur toutes les époques de 0.6716 .

Erreur d'entraînement (Train Error) :

L'erreur d'entraînement diminue progressivement au fil des époques, ce qui indique que le
modèle s'ajuste progressivement aux données d'entraînement et minimise l'erreur entre les
prédictions et les vraies valeurs.

Par la fonction plot_histogram_avg_errors, on obtient l’histogramme ci-dessous. On peut

comparer visuellement les valeurs moyennes des différentes métriques et évaluer la
performance relative du modèle sur chaque métrique. Par exemple, si la barre pour la précision
est plus élevée que les autres, cela indique que le modèle obtient généralement de bons
résultats en termes de précision par rapport aux autres métriques. De même, une barre plus
basse pour une métrique comme le RMSE suggère de meilleures performances en termes de
précision de prédiction des évaluations.

Figure 6: Histogramme de la moyenne de l’erreur de différentes métriques de la

méthode NMF

Rapport - Coding week 39

 ANALYSE DES RÉSULTATS ET COMPARAISON

VI. Analyse des résultats et comparaison

1. Analyse des résultats
1.1. Division 80/20 (ALS)

La variation du pourcentage de trainning et de test

Dans cette nouvelle configuration, nous utilisons un ratio de 75 % pour l'ensemble
d'entraînement et de 25 % pour l'ensemble de test. L'objectif est de comparer les performances
de notre algorithme en analysant les métriques du modèle.

En comparant les résultats entre une division de données de 80/20 et 75/25 pour l'entraînement
et les tests, plusieurs observations peuvent être faites.

D'abord, en passant d'une division de 80/20 à 75/25, nous observons une légère diminution du
RMSE (Root Mean Squared Error) de 0,75 à 0,74. Cela suggère que le modèle a légèrement
amélioré sa capacité à prédire les notes des utilisateurs sur l'ensemble de test lorsque plus de
données sont utilisées pour l'entraînement.

Cependant, les mesures de précision et de rappel diminuent également légèrement, passant de

0,3 à 0,25 pour la précision et de 0,23 à 0,21 pour le rappel. Cette diminution indique que le
modèle peut avoir une capacité réduite à recommander avec précision des éléments aux
utilisateurs et à capturer tous les éléments pertinents pour eux.

La variation de nombre des epochs

En augmentant le nombre d'epochs, le modèle a plus d'itérations pour ajuster ses paramètres
afin de mieux correspondre aux données d'entraînement, ce qui peut conduire à des
recommandations plus précises. Cependant, cette amélioration de la précision s'accompagne
souvent d'une augmentation du temps d'exécution du code.

La variation des hyperparamètres

En augmentant la valeur du paramètre "k" à 40 dans le modèle de factorisation de moindres
carrés alternés (ALS), nous augmentons la dimension de l'espace latent. Cela permet au modèle
de capturer des relations plus complexes entre les utilisateurs et les éléments, ce qui peut
potentiellement améliorer les performances de recommandation en capturant des nuances plus
fines dans les préférences des utilisateurs. Cependant, cette augmentation de la
dimensionnalité augmente également le temps d'exécution du code.

En ajustant le paramètre λ dans le modèle ALS, nous contrôlons la force de régularisation

appliquée aux paramètres du modèle pour éviter le sur-ajustement. En augmentant λ, nous
intensifions la pénalisation, encourageant le modèle à maintenir des valeurs de paramètres
plus petites. Cela peut améliorer les performances du modèle en évitant le sur-ajustement aux
données d'entraînement. Après des essais, nous avons déterminé que la valeur optimale de λ
pour notre cas est de 0,1.

Rapport - Coding week 40

 ANALYSE DES RÉSULTATS ET COMPARAISON

1.2. K-Cross méthode 1 (ALS)

Augmentation du nombre des Folds
Augmenter le nombre de Folds dans la validation croisée peut améliorer la précision de
l'estimation des paramètres du modèle, ce qui est bénéfique lorsque les données
d'entraînement sont limitées. Par exemple, pour l'ALS, en passant de 80/20 à 10 Folds, la
précision est passée de 0,3 à 0,54. Cependant, cela entraîne généralement un temps d'exécution
plus long, comme observé avec des temps de 40s pour 7 Folds et de 62s pour 10 Folds. Chaque
itération de la validation croisée nécessite plus de temps car le modèle est entraîné et évalué sur
un plus grand nombre de sous-ensembles de données.

1.3. K-Cross méthode 2 (ALS)

La prédéfinition des Folds
Dans le cas où les données sont préalablement divisées en 5 Folds selon des critères définis,
cela peut refléter une distribution plus représentative des données réelles ou être basé sur des
caractéristiques spécifiques des données, ce qui peut conduire à une meilleure généralisation
du modèle. Ainsi, lors de l'évaluation du modèle de recommandation utilisant la factorisation
de matrices avec la méthode ALS, une division basée sur des critères pertinents peut aboutir à
une meilleure précision, comme il est indiqué dans l’histogramme ci-dessous le résultat de
précision est de 0,73. Il serait intéressant d'explorer quels sont ces critères spécifiques utilisés
pour la division en 5 Folds. Ces critères pourraient inclure des facteurs tels que la similarité
entre les utilisateurs ou les items, la densité des données, ou d'autres caractéristiques
pertinentes du jeu de données. Comprendre ces critères pourrait permettre une meilleure
interprétation des résultats et une adaptation plus précise du modèle à la structure des données.

Figure7: Histogramme de la moyenne de l’erreur de différentes métriques de la méthode

K-Cross 2(ALS)

1.4. K-Cross méthode 2 (SVD)

La variation de nombre des epochs
En augmentant le nombre d'epochs, le modèle a plus d'itérations pour ajuster ses paramètres
afin de mieux correspondre aux données d'entraînement, ce qui peut conduire à des
recommandations plus précises. Cependant, cette amélioration de la précision s'accompagne
souvent d'une augmentation du temps d'exécution du code. Par exemple pour 35 epochs, la
précision est devenue de 0,72 alors que le temps d’exécution est de 12s .

Rapport - Coding week 41

 ANALYSE DES RÉSULTATS ET COMPARAISON

Augmentation du nombre des folds

Augmenter le nombre de Folds dans la validation croisée peut conduire à une meilleure
estimation des paramètres du modèle, ce qui est avantageux lorsque les données
d'entraînement sont limitées. Par exemple, pour la méthode SVD, en augmentant le nombre de
Folds de 5 à 10, la précision est devenue 0,73. Cependant, cela entraîne généralement une
augmentation du temps d'exécution, comme observé avec des durées de 15 secondes pour 7
Folds et de 21 secondes pour 10 Folds. Chaque itération de la validation croisée nécessite
davantage de temps, car le modèle est entraîné et évalué sur un plus grand nombre de sous-
ensembles de données.

2. Comparaison entre les résultats

Comparaison entre différentes méthodes:

K-Cross 1(ALS), K-Cross 2(ALS), K-Cross 2(SVD), division 80/20(ALS), NMF

En analysant les performances des différentes méthodes sur notre base de données, plusieurs
observations émergent. La méthode ALS avec la validation croisée K-Cross 2 présente la
meilleure précision, atteignant 0.73, ce qui en fait un choix attrayant pour une précision
élevée. NMF montre également des performances prometteuses avec une progression des
métriques au fil des époques et un temps d'exécution relativement court de 31 secondes.
Cependant, la méthode ALS avec K-Cross 1 affiche une précision encore plus élevée, bien que
cela soit accompagné d'un temps d'exécution plus long avec l'augmentation du nombre de
Folds. La division 80/20 avec ALS montre une légère amélioration du RMSE, mais une
diminution de la précision et du rappel. Enfin, la méthode SVD avec K-Cross 2 présente
également une précision de 0.73, mais avec un temps d'exécution de 21 secondes pour 10
Folds.

Ainsi, le choix de la méthode dépendrait des exigences spécifiques du projet, avec ALS K-Cross
2 étant privilégié pour une précision maximale, tandis que NMF peut être préférable si un
temps d'exécution plus court est nécessaire tout en maintenant des performances raisonnables.

En conclusion, chaque méthode présente des avantages et des inconvénients, mais il semble
que la méthode ALS avec la validation croisée (K-Cross 2) soit la plus appropriée pour notre
base de données , elle offre ainsi les meilleures performances en termes de précision, bien
que cela puisse varier en fonction des critères de division spécifiques utilisés.

Rapport - Coding week 42

 ANALYSE DES RÉSULTATS ET COMPARAISON

Comparaison entre différentes méthodes : ALS, SVD, NMF

Pour comparer les résultats obtenus avec les modèles ALS, SVD et NMF, nous examinons
plusieurs métriques, notamment le RMSE, la précision, le rappel et le score F1, ainsi que le
temps d'exécution de chaque modèle.

Pour le modèle ALS, nous obtenons un RMSE moyen de 0.9357, une précision moyenne de
0.7237, un rappel moyen de 0.4130 et un score F1 moyen de 0.5259, avec un temps d'exécution
de 24 secondes. En comparaison, le modèle SVD affiche un RMSE moyen de 0.9452, une
précision moyenne de 0.7171, un rappel moyen de 0.9462 et un score F1 moyen de 0.8158, avec
un temps d'exécution de 4 secondes. Enfin, le modèle NMF présente une moyenne d'erreur
d'entraînement sur toutes les époques de 0.8492, une moyenne de précision de 0.7957, une
moyenne de rappel de 0.5915 et une moyenne de score F1 de 0.6719, avec un temps d'exécution
de 31 secondes.

Figure 1: Average Errors ALS

Figure 2: Average Errors SVD Figure 3: Average Errors NMF

En analysant ces résultats, il est clair que le modèle ALS se distingue comme le meilleur choix
en termes de performances et de temps d'exécution. En effet, il affiche le RMSE le plus bas et
des scores de précision et de F1 compétitifs, tout en maintenant un temps d'exécution
relativement court par rapport au modèle NMF. Ainsi, pour notre application, le modèle ALS
semble être la meilleure option, offrant un équilibre optimal entre précision et efficacité en
temps réel.

Rapport - Coding week 43

 CENTRALE FLIX (BONUS)

VII. Centrale Flix (Bonus)

1. Introduction et objectif

L'application Centrale Flix a été développée dans le but de fournir un service de

recommandation de films personnalisé aux utilisateurs. L’objectif principal de cette application
est de proposer des suggestions de films en fonction des préférences et des historiques de
visualisation des utilisateurs. En offrant une expérience utilisateur intuitive et conviviale,
Centrale Flix vise à simplifier la découverte de nouveaux contenus cinématographiques tout en
améliorant la satisfaction des utilisateurs.

2. Description de l'Application

Centrale Flix est une application web composée de deux pages principales :
Page d'identification : Cette page permet aux utilisateurs de s'identifier en fournissant
leur identifiant et leur mot de passe. Une fois authentifiés, les utilisateurs peuvent
accéder à la page de recommandations des films.

Page principale : Sur cette page, les utilisateurs peuvent découvrir une sélection de
films recommandés spécialement pour eux, basée sur divers critères de
personnalisation. Voici les fonctionnalités disponibles sur cette page :

Affichage des films recommandés : La liste des films recommandés est présentée dans un
tableau clair et organisé.
Exploration des films : Les utilisateurs peuvent explorer la liste des films recommandés
en faisant défiler le tableau. Chaque film est identifié par son numéro et son titre,
permettant aux utilisateurs de rapidement repérer les films qui les intéressent.
Consultation des détails : Pour chaque film recommandé, les utilisateurs peuvent
consulter des informations détaillées telles que l'identifiant du film et son estimation des
notes.
Interactions utilisateur : En plus de découvrir les films recommandés, les utilisateurs
peuvent interagir avec un Chatbot intégré, entraîné par IBM Watson Assistant. Ce Chatbot
peut répondre à diverses questions courantes sur les films et sur l'application Centrale
Flix.

NB : Dans notre cas simplifié, pour tester le code source de Centrale Flix (le bonus), entrez un
identifiant entre 1 et 10 et le mot de passe : "test".

Rapport - Coding week 44

 CENTRALE FLIX (BONUS)

3. Fonctionnement de l'Application
Organisation du dossier
Le dossier de l'application Centrale Flix se compose de trois
principaux éléments organisés de manière structurée. Le dossier
principal comprend deux sous-dossiers distincts, à savoir "Static"
et "Templates". Le dossier "Static" héberge les fichiers CSS,
essentiels à la mise en forme et au style des pages web de
l'application, tandis que le dossier "Templates" contient les
fichiers HTML définissant la structure et le contenu des pages
d'identification ("[Link]") et de recommandations de films
("[Link]"). En outre, le fichier principal de
l'application, "[Link]", est situé dans le répertoire principal. Il
contient le code essentiel pour gérer les interactions avec
l'application, y compris l'authentification des utilisateurs, la
récupération des recommandations de films et la gestion des
déconnexions. Cette organisation claire et structurée facilite la
gestion et la maintenance de l'application Centrale Flix, en
garantissant une séparation efficace entre la logique de
l'application, la présentation visuelle et les fichiers statiques.

Rapport - Coding week 45

 CENTRALE FLIX (BONUS)

Code Flask

Le code Flask est organisé de manière à gérer les routes et les fonctions de
l'application. La fonction login() gère l'authentification des utilisateurs à partir
de la page d'identification. Elle vérifie les identifiants saisis par l'utilisateur et
redirige vers la page de recommandations si les informations sont correctes.
Sinon, elle affiche un message d'erreur.

La fonction recommendations() récupère les recommandations spécifiques à

un utilisateur à partir des données prédéfinies. Si l'utilisateur existe dans la base
de données, elle affiche les recommandations sur la page des films
recommandés. Sinon, elle renvoie un message d'erreur.

La fonction logout() permet aux utilisateurs de se déconnecter de l'application

en redirigeant vers la page d'identification.

Principe de connexion et base de données simplifiée :

Lorsqu'un utilisateur accède à l'application, il est dirigé vers la page d'identification où il doit
saisir son identifiant et son mot de passe. Ces informations sont vérifiées côté serveur pour
garantir l'authenticité de l'utilisateur.

La base de données simplifiée utilisée dans notre application Centrale Flix consiste en un
ensemble de recommandations de films pour plusieurs utilisateurs, stockées sous forme de
dictionnaires Python. Chaque utilisateur est identifié par un numéro unique. Pour chaque
utilisateur, nous avons des données sur les films qui lui sont recommandés. Chaque ensemble
de recommandations comprend les identifiants des films, les titres des films correspondants et
les évaluations estimées de ces films pour cet utilisateur. Les données sont extraites du code
Python de recommandation de films basé sur la factorisation de matrices, en utilisant la
méthode de K-Cross 2 (ALS). Voici un extrait de ces données :

Rapport - Coding week 46

 CENTRALE FLIX (BONUS)

Bien que cette représentation des données soit efficace pour tester et démontrer
le fonctionnement de l'application, dans un scénario réel, nous aurions utilisé
une base de données SQL pour stocker ces informations de manière persistante
et organisée. Cela aurait permis une gestion plus flexible des données, une
évolutivité accrue et une meilleure intégration avec d'autres fonctionnalités de
l'application.

4. Conclusion et perspectives d'amélioration

Dans la perspective d'amélioration de notre application Centrale Flix, une implémentation

SQL pourrait grandement renforcer la robustesse et la flexibilité de notre système de
recommandation de films. En remplaçant notre base de données actuelle, qui est stockée sous
forme de dictionnaire dans notre code Flask, par une base de données SQL telle que SQLite,
nous pourrions bénéficier d'une gestion plus efficace des données, d'une meilleure évolutivité
et d'une intégration plus transparente avec d'autres outils et services.

De plus, pour enrichir l'expérience utilisateur, nous envisageons d'intégrer une fonctionnalité
de sign in plus interactive. Plutôt que de se limiter à une simple authentification, les utilisateurs
pourraient être invités à spécifier leurs préférences cinématographiques initiales lors de leur
inscription. Pour ce faire, nous pourrions mettre en œuvre des techniques de machine learning
telles que la méthode k-plus proches voisins (KNN) pour recommander des films basés sur les
goûts et les intérêts similaires des utilisateurs. Cette approche permettrait de personnaliser
davantage les recommandations et d'offrir une expérience utilisateur plus immersive et
engageante.

En somme, l'intégration d'une base de données SQL et l'amélioration de la fonction de sign in

avec des recommandations personnalisées représentent des pistes prometteuses pour le
développement futur de Centrale Flix. Ces évolutions pourraient non seulement améliorer la
performance et la pertinence de nos recommandations, mais aussi accroître la satisfaction et la
fidélité de nos utilisateurs. En continuant à explorer et à mettre en œuvre de telles
améliorations, nous sommes convaincus que Centrale Flix continuera à prospérer en tant
qu'outil de recommandation de films innovant et apprécié par les cinéphiles du monde entier.

Rapport - Coding week 47

 CONCLUSION ET FUTURS PERSPECTIVES

VIII. Conclusion et futures perspectives :

1. Conclusion
Dans cette étude, nous avons approfondi l'analyse des systèmes de filtrage collaboratif en
utilisant la méthode de factorisation de matrice. Nos résultats ont démontré l'efficacité de
l'algorithme Alternating Least Squares (ALS) dans la prédiction des préférences des utilisateurs,
notamment pour des ensembles de données volumineux. Nous avons souligné l'importance de
telles études pour mieux comprendre les jeux de données d'évaluation et les facteurs influant
sur les systèmes de recommandation, surtout dans le contexte des détaillants en ligne. Il est
crucial de tenir compte de considérations telles que la sensibilité au contexte, ce qui met en
évidence l'importance de tester plusieurs approches tout au long du développement du système
de recommandation.

Dans la pratique, l'algorithme ALS s'est avéré efficace pour traiter de vastes matrices
d'interactions utilisateur-élément, bien qu'il puisse rencontrer des défis avec des matrices très
creuses. En revanche, l'algorithme de factorisation de matrices non négatives (NMF) offre une
flexibilité appréciable pour gérer des données binaires et des matrices creuses, en plus de sa
capacité à traiter des données non négatives.

L'algorithme de décomposition en valeurs singulières (SVD), bien que plus complexe et

nécessitant plus de ressources computationnelles, est également largement utilisé dans les
systèmes de recommandation. Cependant, son temps de calcul plus long peut être un
inconvénient, surtout pour des ensembles de données de grande taille. Il est essentiel de
sélectionner judicieusement les hyperparamètres, tels que le nombre de dimensions latentes,
pour obtenir des performances optimales avec l'algorithme SVD. Des méthodes de validation
telles que la division 80/20 des données ou le k-cross validation peuvent être utilisées pour
ajuster ces hyperparamètres de manière robuste et éviter le surajustement ou le sous-
ajustement du modèle.

Concernant les performances, notre approche montre que l'ALS est généralement plus rapide
que le NMF ou le SVD pour les matrices de taille moyenne à grande, bien que le NMF puisse
surpasser l'ALS pour les matrices binaires et très creuses. Le choix de l'algorithme et de la
méthode de validation appropriés dépend donc des caractéristiques spécifiques des données et
des objectifs du système de recommandation.

En conclusion, cette étude met en lumière l'importance de choisir des algorithmes adaptés au
contexte et aux caractéristiques des données pour obtenir des systèmes de recommandation
performants. Elle offre des insights précieux pour le développement et l'optimisation des
systèmes de recommandation dans divers domaines d'application.

2. Futures perspectives
À l'heure actuelle, la factorisation de matrice reste un outil largement utilisé et efficace pour
la recommandation de contenu en ligne. Cependant, les services de renom tels que Netflix ou
TikTok vont bien au-delà de cette approche, en adoptant des algorithmes bien plus sophistiqués
et complexes. Ils combinent souvent plusieurs techniques d'intelligence artificielle pour fournir
des recommandations personnalisées à chaque utilisateur.

Rapport - Coding week 48

 CONCLUSION ET FUTURS PERSPECTIVES

Par exemple, Netflix exploite une gamme d'algorithmes reposant sur divers aspects tels que le
contenu visionné, les préférences des utilisateurs et les contextes de visionnage. Parmi ces
algorithmes, l'algorithme SVD (Décomposition en Valeurs Singulières) est largement utilisé, en
plus d'autres techniques telles que les réseaux de neurones, pour améliorer la précision des
recommandations.

De même, Instagram utilise une approche similaire en employant plusieurs algorithmes

d'intelligence artificielle pour personnaliser les flux de contenu de chaque utilisateur. Outre
l'analyse des vidéos visionnées par l'utilisateur pour proposer des recommandations similaires,
Instagram intègre également des algorithmes basés sur les interactions sociales et les
préférences des utilisateurs pour affiner ses recommandations.

Il est important de noter que ces plateformes continuent d'innover en développant de

nouvelles techniques d'IA pour affiner la précision et la personnalisation des
recommandations. Par exemple, Netflix a récemment dévoilé un nouvel algorithme de
recommandation baptisé "Dynamics Tiles", qui combine des méthodes d'apprentissage en
profondeur avec la factorisation de matrice pour offrir des recommandations encore plus
précises et personnalisées.

En somme, bien que la factorisation de matrice reste un élément central dans la

recommandation de contenu en ligne, les services de premier plan comme Netflix et Youtube
démontrent un engagement continu dans l'amélioration de l'expérience utilisateur en explorant
et en développant constamment de nouvelles techniques d'intelligence artificielle pour
perfectionner leurs recommandations personnalisées.

Rapport - Coding week 49

 RÉFÉRENCES BIBLIOGRAPHIQUES

IX. Références bibliographiques :

[1] [Link]
sequence=1&isAllowed=y#:~:text=Les%20syst%C3%A8mes%20de%20recommandations%20son
t,qui%20r%C3%A9pondent%20%C3%A0%20leurs%20exigences%20.

[2] [Link]

[3] [Link]

[4] [Link]

[5] [Link]

[6] [Link]

[7] Paolo Cremonesi, Roberto Turrin, and Fabio Airoldi, "Hybrid algorithms for recommending
new items," in Proceedings of the 2nd International Workshop on Information Heterogeneity
and Fusion in Recommender Systems, New York, 2011, pp. 33-40.

[8] G Takács, I Pilászy, B Németh, and Domonkos Tikk, "Investigation of Various Matrix
Factorization Methods for Large Recommender Systems," in IEEE International Conference on
Data Mining Workshops, Pisa, 2008., pp. 553-562

[9][Link]

Rapport - Coding week 50