Moteur de recommandation de films

Projet nº3 du Parcours de Data Scientist

F. Daniel07–2017

Table des matières1 Introduction 2

2 Nettoyage des données 22.1 Entrées dupliquées . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32.2 Nettoyage des mots clés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3

2.2.1 Regroupement par racines . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32.2.2 Regroupement des synonymes . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4

2.3 Examen des corrélations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52.4 Remplissage : gestion des valeurs manquantes . . . . . . . . . . . . . . . . . . . . . . . . 6

2.4.1 ’color’ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72.4.2 ’title_year’ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72.4.3 ’language’ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72.4.4 ’duration’ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72.4.5 ’gross’ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82.4.6 ’plot_keywords’ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82.4.7 ’num_critic_for_reviews’, ’num_user_for_reviews’ . . . . . . . . . . . 8

3 Exploration univariée 8

4 Moteur de recommandation 94.1 Similarité entre films . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94.2 Popularité des entrées . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104.3 Suites de films . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 114.4 Validation du moteur : exemple de recommandations . . . . . . . . . . . . . . . . . . . . 11

5 API 12

6 Conclusion 13

A Annexe : Arborescence et description des fonctions du moteur de recommandation 14

1

1 IntroductionL’objectif du projet est de réaliser un moteur de recommandation de films en se basant sur le contenu

d’une base de données mise à disposition via la plateforme Kaggle 1. Cette base de données comprend envi-ron 5000 ressources cinématographiques et les informations correspondants à ces entrées on été collectéesdans la base de donnée publique IMDb 2, qui recense principalement des films et séries TV.

Le moteur qui sera élaboré doit fonctionner suivant le schéma suivant : l’utilisateur fournira une réfé-rence de film qui lui a plu et en retour, le moteur établira un liste de 5 films susceptibles d’intéresser lespectateur en fonction du choix qu’il aura initialement fait. En pratique, les moteurs de recommandation defilms peuvent être élaborés en suivant trois grands axes :

– la popularité : choix basé uniquement sur la popularité – le plus simple et le plus impersonnel– le contenu : choix basé sur la description du contenu des ressources– un modèle collaboratif : choix basé sur une similarité de comportement entre utilisateurs

Dans le cas actuel, et compte–tenu du fait que la base de données ne concerne que des ressources cinéma-tographiques, le modèle collaboratif est exclu. Ainsi, le moteur qui je vais développer et qui sera décrit parla suite se basera à la fois sur le contenu et sur la popularité des ressources.

2 Nettoyage des donnéesLa base de données sur laquelle se base ce projet est fournie dans le fichier ’movie_metadata.csv’.

Cette base contient 5043 entrées regroupant à la fois des films et des séries TV 3. Ces différentes ressourcessont décrites suivant 28 variables qui peuvent être classées suivant 2 grandes catégories :

– description technique du contenu : ’color’,’duration’,’genres’,’movie_title’,’title_year’,’facenumber_in_poster’, ’plot_keywords’, ’movie_imdb_link’, ’language’, ’country’,’budget’, ’content_rating’, ’aspect_ratio’, ’director_name’,’actor_N_name’ (N ∈ {1,3})

– popularité de l’entrée : ’num_critic_for_reviews’, ’director_facebook_likes’, ’gross’,’actor_N_facebook_likes’ (N ∈ {1,3}), ’num_voted_users’, ’cast_total_facebook_likes’,’num_user_for_reviews’, ’imdb_score’, ’movie_facebook_likes’

Notons de plus que la dataset est assez bien rempli dans la mesure où la majorité des variables sontremplies à plus de 95%, la variable la moins remplie, ’gross’, l’étant à 82%.

Le nettoyage du dataset est fait dans le notebook notebook_CLEANING.ipynb. Par soucis de clarté,un certain nombre de fonctions utilisées lors du nettoyage sont définies dans un autre notebook, fonc-tions.ipynb, qui est chargé au début du notebook de nettoyage. Le nettoyage des données se fait au cours de4 étapes qui sont décrites plus avant et la taille du dataframe à l’issue de chacune de ces étapes est indiquéedans la table 1.

1. https://www.kaggle.com/deepmatrix/imdb-5000-movie-dataset2. http://www.imdb.com/3. dans la suite, par abus de langage, je nommerai les entrées du dataframe "films" bien qu’il puisse s’agir de films ou séries

TV.

2

Etape description nb. d’entrées nb. de variables0 dataset initial 5043 281 entrées dupliquées 4919 282 mots clés // //

3 corrélations 4919 234 remplissage // //

Table 1 – Taille du dataset après les différentes étapes du nettoyage.

2.1 Entrées dupliquéesTout d’abord, je considère la présence de films qui apparaitraient plus d’une fois dans la base de données.

Un examen rapide montre que 45 films apparaissent 2 fois à l’identique et ceci, en considérant les 28variables décrivant les entrées. Ces doublons sont supprimés et le dataframe compte désormais 4998 entrées.

Un examen plus approfondi montre qu’en filtrant les entrées sur un sous–échantillon de variables, cer-tains films appariassent plusieurs fois mais diffèrent sur le contenu de quelques variables. Je décide doncde rechercher les films qui sont identiques par rapport aux variables ’movie_title’, ’title_year’et ’director_name’ et constate qu’environ ∼80 films sont dupliqués vis-à-vis de ces variables. J’exa-mine ensuite au cas par cas l’origine des différences entre doublons et je constate que les écarts portenten général sur des détails mineurs et principalement sur des décomptes de votes (i.e. sur les variables’actor_N_facebook_likes’, ’num_voted_users’, ...). Je décide donc de supprimer les doublonsen ne conservant que la dernière entrée. A ce stade, le dataframe compte 4919 films et 28 variables.

2.2 Nettoyage des mots clésLa variable ’plot_keywords’ contient une liste de mots clés servant à décrire le contenu des films. A

priori, une telle variable s’avèrera certainement utile au moment de développer le moteur de recommanda-tion de films dans la mesure où deux films décrits par des mots clés similaires auront sans doute un contenuassez proche. En conséquence, et compte-tenu de l’importance de cette variable, je décide d’examiner avecattention son contenu afin de pouvoir en tirer parti lors de l’élaboration du moteur de recommandation.

2.2.1 Regroupement par racines

Afin d’analyser les mots–clés, j’utilise le package NLTK qui permet d’effectuer une analyse sémantiquedes mots clés et permet de regrouper ensemble des mots au sens similaire mais qui apparaitraient sousdes formes différentes (e.g. singulier / pluriel, déclinaisons verbales, ...). Pour cela, je prends le parti deconsidérer comme identiques des mots qui ont un racine commune, ce qui permet par exemple de regrouper(c.f. notebook de nettoyage) : kiss↔ kissing ; comic↔ comics ; storytelling↔ storyteller, ... . Lorsqu’unmême mot-clé apparaît sous plusieurs formes, je décide d’effectuer un regroupement en utilisant commemot clé le mot le plus court de la liste (e.g. kiss, comic et storryteller pour les exemples précédents).

Après regroupement, je recense 7904 mots-clés qui servent à décrire ∼5000 films. Ces chiffres im-pliquent que le nombre de mots clés communs à plusieurs films est faible, hypothèse que l’on vérifie ai-sément en considérant le graphique (a) de la figure 1. On constate en effet sur ce graphique que ∼7000mots-clés sont communs à moins de 5 films et parmi eux, ∼5000 n’apparaissent dans la description qued’un seul film !

3

0 1000 2000 3000 4000 5000 6000 7000 8000Index des mots clés

0

5

10

15

20

25

Nb. d

'app

ariti

ons

(a) Nombre d’occurrence des mots clés pour la liste initiale

0 1000 2000 3000 4000 5000 6000 7000 8000Index des mots clés

0

5

10

15

20

25

Nb. d

'app

ariti

ons

limite pour suppresion des mots clefs

avant nettoyageaprès nettoyage

(b) Comparaison du nombre d’occurrence des mots clés avant et après nettoyage

Figure 1 – Décompte du nombre de fois où apparaissent les différents mots-clés. Le graphique (a) montre cedécompte pour la liste initiale de mots clés. Le graphique (b) compare ce décompte initial au dénombrementeffectué après nettoyage.

2.2.2 Regroupement des synonymes

Afin qu’un mot clé soit utile au moteur de recherche, il doit permettre d’effectuer une rapprochementavec d’autres films et devra donc apparaître un nombre significatif de fois. En conséquence, les mots cléspeu fréquents seront inutilisables et pourront donc être supprimés de la description des films. Avant d’ef-fectuer cette suppression, je décide de regarder si, pour les mots clés ayant une fréquence faible (fixée à 5apparitions), il existe un synonyme dans la liste de mot-clés dont la fréquence serait plus élevé. Dans un telcas de figure, le mot-clé de faible fréquence est remplacé par son synomyme. Néanmoins, cette procédurene modifie que légèrement la liste initiale dans la mesure ou elle ne concerne que ∼5% des mots de cette

4

liste. Visuellement, ce remplacement correspond au l’offset entre les courbes bleu et rouge du graphique (b)de la figure 1.

Finalement, après cette modification, je décide de supprimer les mots clés apparaissants dans moins de3 films et la nouvelle liste de mots clés compte désormais 1299 mots-clés.

2.3 Examen des corrélations

budg

et

face

num

ber_

in_p

oste

r

title

_yea

r

aspe

ct_r

atio

acto

r_1_

face

book

_like

s

cast

_tot

al_f

aceb

ook_

likes

acto

r_3_

face

book

_like

s

acto

r_2_

face

book

_like

s

num

_crit

ic_fo

r_re

view

s

mov

ie_f

aceb

ook_

likes

gros

s

num

_vot

ed_u

sers

num

_use

r_fo

r_re

view

s

dire

ctor

_fac

eboo

k_lik

es

dura

tion

imdb

_sco

re

imdb_score

duration

director_facebook_likes

num_user_for_reviews

num_voted_users

gross

movie_facebook_likes

num_critic_for_reviews

actor_2_facebook_likes

actor_3_facebook_likes

cast_total_facebook_likes

actor_1_facebook_likes

aspect_ratio

title_year

facenumber_in_poster

budget

0.031 -0.063 -0.21 0.061 0.077 0.087 0.056 0.084 0.31 0.25 0.2 0.41 0.3 0.17 0.26 1

0.071 0.015 -0.14 -0.092 0.087 0.12 0.12 0.13 0.25 0.2 0.24 0.31 0.32 0.18 1 0.26

0.02 -0.04 -0.0660.0018 0.091 0.12 0.12 0.12 0.18 0.17 0.14 0.3 0.23 1 0.18 0.17

0.081 -0.067-0.0041-0.026 0.15 0.2 0.23 0.22 0.6 0.41 0.56 0.8 1 0.23 0.32 0.3

0.077 -0.0280.0049-0.015 0.19 0.26 0.28 0.26 0.62 0.54 0.64 1 0.8 0.3 0.31 0.41

0.097 -0.026 0.022 0.069 0.15 0.24 0.29 0.25 0.47 0.37 1 0.64 0.56 0.14 0.24 0.2

0.058 0.005 0.21 0.025 0.13 0.2 0.27 0.24 0.68 1 0.37 0.54 0.41 0.17 0.2 0.25

0.12 -0.032 0.28 -0.052 0.19 0.26 0.27 0.28 1 0.68 0.47 0.62 0.6 0.18 0.25 0.31

0.041 0.071 0.1 -0.0075 0.39 0.62 0.55 1 0.28 0.24 0.25 0.26 0.22 0.12 0.13 0.084

0.044 0.1 0.093-0.0029 0.25 0.46 1 0.55 0.27 0.27 0.29 0.28 0.23 0.12 0.12 0.056

0.033 0.091 0.11 -0.018 0.95 1 0.46 0.62 0.26 0.2 0.24 0.26 0.2 0.12 0.12 0.087

0.021 0.071 0.084 -0.02 1 0.95 0.25 0.39 0.19 0.13 0.15 0.19 0.15 0.091 0.087 0.077

0.0058 0.013 0.16 1 -0.02 -0.018-0.0029-0.0075-0.052 0.025 0.069 -0.015 -0.0260.0018-0.092 0.061

0.043 0.059 1 0.16 0.084 0.11 0.093 0.1 0.28 0.21 0.022 0.0049-0.0041-0.066 -0.14 -0.21

-0.02 1 0.059 0.013 0.071 0.091 0.1 0.071 -0.032 0.005 -0.026 -0.028 -0.067 -0.04 0.015 -0.063

1 -0.02 0.043 0.0058 0.021 0.033 0.044 0.041 0.12 0.058 0.097 0.077 0.081 0.02 0.071 0.031

0.8

0.4

0.0

0.4

0.8

Figure 2 – Coefficients de corrélations entre les différentes variables quantitatives du dataframe.

Afin de déterminer s’il existe des variables redondantes et donc inutiles dans le dataframe, j’examineles corrélations entre les différentes variables quantitatives, qui sont représentées sur la figure 2. Notons que

5

sur cette figure, les valeurs des coefficients de corrélations de Pearson (notés α) sont indiqués pour chaquecouple de variables. L’examen de ces coefficients montre :

1. ’cast_total_facebook_likes’ ≡ ’actor_1_facebook_likes’ (α = 0.95)

2. ’budget’, ’facenumber_in_poster’, ’aspect_ratio’ sont décorrélées de l’ensembles desautres variables (α < 0.2 ∀ couple)

Compte-tenu du point 1/, et par consistance avec les autres variables présentes dans le dataframe, jedécide de supprimer la variable ’cast_total_facebook_likes’. Les variables mentionnées au point 2/

représentent respectivement le budget du film, le nombre de personnes sur l’affiche du film et le format del’image. Ces deux dernières variables présentent peu d’intérêt pour le moteur de recherche et sont supri-mées. Dans le cas de la variable ’budget’, il est intéressant de remarquer qu’elle semble décorrélée dela variable ’gross’ qui donne les recettes générées par le film. La raison est que la variable ’budget’contient des budgets mélangeant des devises étrangères, ce qui rend son compte peu significatif 4. Cettevariable est donc supprimée 5

2.4 Remplissage : gestion des valeurs manquantes

gros

spl

ot_k

eywo

rds

title

_yea

rdi

rect

or_n

ame

dire

ctor

_face

book

_like

snu

m_c

ritic_

for_

revi

ews

acto

r_3_

nam

eac

tor_

3_fa

cebo

ok_li

kes

num

_use

r_fo

r_re

view

sco

lor

dura

tion

acto

r_2_

nam

eac

tor_

2_fa

cebo

ok_li

kes

lang

uage

acto

r_1_

nam

eac

tor_

1_fa

cebo

ok_li

kes

coun

trym

ovie

_titl

ege

nres

mov

ie_fa

cebo

ok_li

kes

num

_vot

ed_u

sers

imdb

_sco

rem

ovie

_imdb

_link

0

20

40

60

80

100

% d

e re

mpl

issag

e de

s col

onne

s

remplissage < 99.0%

remplissage = 100.0%

Figure 3 – Taux de remplissage des 23 variables du dataframe. Les limites indiquant des taux de remplissageinférieurs à 99% ou égal à 100% sont indiquées.

Si l’on considère le taux de remplissage des variables restantes dans le dataframe, on constate que letaux de remplissage est bon, avec uniquement 5 variables pour lesquelles ce taux est inférieur à 99%. Les

4. point 6/ des notes importantes énumérées à l’adresse https://www.kaggle.com/deepmatrix/imdb-5000-movie-dataset

5. A ce stade, dans le notebook de cleaning, je supprime aussi la variable qualitative ’content_rating’ qui indique vrai-semblablement le public pour lequel est adapté le contenu du film mais dont la signification exacte des différentes catégoriesn’est pas claire.

6

différents taux de remplissage sont indiqués sur la figure 3. A ce stade, il est nécessaire de gérer les valeursmanquantes en comblant les trous et pour cela, j’examine au cas par cas les différentes variables.

2.4.1 ’color’

En première intention, j’examine la possibilité d’utiliser l’année de sortie du film pour inférer la couleurdu film. Je constate que ce n’est pas possible dans la mesure où une grand nombre de films récents sonttournés en noir et blanc.

Je décide donc d’utiliser une autre approche qui consiste à utiliser les habitudes des réalisateurs : si unréalisateur a tourné plusieurs films qui se trouvent dans la base de données et que tous ces films sont dela même couleur, j’assigne cette couleur au film pour lequel cette mention est manquante. Cette approchepermet de remplir 6 valeurs sur les 19 manquantes. Pour remplir les autres données manquantes, je décided’utiliser les usages dans les différents genres cinématographiques en arrondissant la valeur moyenne de lavariable color à l’entier le plus proche (0 pour le noir et blanc et 1 pour la couleur).

En pratique, cette méthodologie de remplissage revient à supposer que tous les films pour lesquelsl’information est manquante sont en couleur, ce qui ne semble pas aberrant dans la mesure où 14 d’entreeux ont été tourné après 2009.

2.4.2 ’title_year’

Pour ce qui concerne l’année de sortie, 106 valeurs sont manquantes dans le dataframe. Pour inférerles années de sortie, j’utilise la liste des acteurs apparaissant dans les films, ainsi que le réalisateur. Pourchacun d’entre-eux, je détermine l’année moyenne des films associés à cette personne puis je prends lavaleur moyenne des différentes années obtenues, que j’assigne à l’année de sortie du film. Je vérifie ensuitela validité de cette méthodologie sur quelques prédictions, en effectuant une recherche internet :

– Bewitched : estimé à 1951→ série TV entre 1964 et 1972– The A-team : estimé à 1977→ série TV entre 1982 et 1987– Sleepy Hollow : estimé à 2012→ série TV entre 2013 et 2017

Je constate que l’accord entre la prédiction et la réalité est raisonnable ce qui me permet de valider laméthodologie. A l’issue de cette procédure, il ne reste que 23 valeurs manquantes dans le dataframe.

2.4.3 ’language’

Dans le cas de la langue, 10/12 des valeurs manquantes correspondantes à des films tournés aux USA.J’assigne donc l’anglais à la langue du film et laisse telles quelles les 2 autres valeurs pour lesquellesl’origine du film est non spécifiée.

2.4.4 ’duration’

Dans le cas de la durée des films, 15 valeurs sont manquantes et je décide de simplement remplacer cesvaleurs par la valeur moyenne de la variable ’duration’.

7

2.4.5 ’gross’

Pour remplir les valeurs manquantes decette variable, j’utilise le fait que celle-ciest bien corrélée avec la variable’num_voted_users’ (c.f. Fig. 2), avecun coefficient de corrélation de Pearsonα = 0.64 . J’effectue donc une régressionlinéaire entre ces deux variables et utilisele résultat de cette régression afin decombler l’ensemble des valeursmanquantes. Visuellement, le résultat decette régression est donné sur la figure 4.

0250000

500000750000

10000001250000

15000001750000

num_voted_users

0

2

4

6

8

gros

s

1e8

Figure 4 – Interpolation permettant d’inférer les va-leurs manquantes de ’gross’ à partir de la variable’num_voted_users’.

2.4.6 ’plot_keywords’

Pour ce qui concerne les mots-clés, 151 films ne présentent aucune valeur pour la variable ’plot_keywords’.Pour ces films, je décide d’utiliser les mots du titre en cherchant des synonymes de ces mots dans la listepréalablement définie de mots-clés. Ceci permet d’assigner des mots clés à 81 films et je prends le parti delaisser tel quel les films restant.

2.4.7 ’num_critic_for_reviews’, ’num_user_for_reviews’

Finalement, pour les variables ’num_critic_for_reviews’ et ’num_user_for_reviews’, j’utilisele fait que certaines variables sont bien corrélées entre elles, comme indiqué sur la figure 2. Ainsi, j’utiliseune méthodologie similaire à celle utilisée pour la variable ’gross’ en effectuant des régressions entreces variables bien corrélées ce qui me permet de combler l’ensemble des valeurs manquantes de ces deuxvariables.

BILAN : A l’issue de l’ensemble des ces procédures de gestion des valeurs manquantes, toutes lesvariables du dataframe sont remplies à mieux de 98%.

3 Exploration univariéeA la fin de l’étape de nettoyage, j’ai regardé brièvement le contenu de quelques–unes des variables

du dataframe. A ce stade, je fais référence au notebook de cleaning pour l’examen du contenu de cetteexploration. A titre illustratif, je reporte juste la figure 5 qui indique le nombre d’occurrence des différentsmots-clés et qui donne un aperçu du contenu des films les plus populaires.

8

love

frien

dm

urde

rde

ath

polic

ene

w yo

rk c

ityhi

gh sc

hool

alie

npr

ison

boy

scho

olre

veng

e fbi

frien

dshi

pdr

ugtra

inm

oney

mar

riage

fem

ale

prot

agon

istpa

rty dog

islan

des

cape se

xwe

ddin

gde

tect

ive

fight

resc

uefe

mal

e nu

dity

seria

l kille

rte

enag

erbo

x of

fice

flop

lawy

erbe

st fr

iend

battl

ech

ristm

asse

cret

vom

iting

hosp

ital

singe

ras

sass

inco

llege cia

hote

lfu

ture

smal

l tow

nte

xas

teac

her

write

rsp

y

0

25

50

75

100

125

150

175

200

Nom

bre

d'oc

cure

nce

Popularité des mots clés

Figure 5 – Nombre d’occurence des mots clés les plus fréquents.

4 Moteur de recommandationLe moteur de recommandation doit fournir à l’utilisateur une liste de 5 films qu’il appréciera après que

celui–ci lui aît fournit la référence d’un film qu’il a aimé. Compte-tenu des données à disposition, je décidede développer un moteur dont les spécificités seront les suivantes :

1. sélection d’une liste de N films "similaires" au titre sélectionné par l’utilisateur

2. sélection des 5 films les plus "populaires" dans cette liste de N films

Cette approche est relativement standard et la spécificité du travail actuel consiste à définir les notions de"similarité" et "popularité" à partir des données disponibles dans la base de données. Le moteur que j’aidéveloppé consiste en 9 fonctions écrites en python et se trouvant dans le notebook notebook_engine.ipynb.La liste de ces fonctions se trouve en Annexe où le contenu de chacune d’entre–elles est brièvement détaillé.Dans ce qui suit, je vais décrire de manière qualitative le fonctionnement du moteur de recommandation.

4.1 Similarité entre filmsAprès l’étape de nettoyage, le dataframe contenant la base de données de films contient ∼4900 ré-

férences cinématographiques qui sont décrites par 23 variables. Afin d’effectuer une recommandation, ils’agira de définir le degré de similarité existant entre deux entrées et pour cela, j’opte pour effectuer un"calcul de distance" entre le film sélectionné par l’utilisateur et les autres films de la base de donnée. Poureffectuer ce type de calcul, il faudra utiliser des variables quantitatives et dans un premier temps, je sélec-tionne donc dans le dataframe les variables que je juge être pertinentes pour ce calcul. Les variables que j’airetenues sont :

9

1. ’actor_N_name’ (N ∈ 1,2,3) : noms des 3 acteurs principaux

2. ’director_name’ : nom du réalisateur

3. ’plot_keywords’ : mots-clés décrivant les films

4. ’genre’ : genre cinématographique

Toutes ces variables étant de type qualitatif, j’adopterai par la suite une méthodologie où le contenu deces variables sera transformé avant d’être utilisé. Afin d’effectuer le calcul de distance, la première étapeconsiste à définir une matrice M de dimension M × k où M (= 4919) est le nombre de films de la basede données et k un nombre de variables qui dépendra du film sélectionnée. La valeur de k est donnéepar le nombre de valeurs définies pour les variables ci-dessus. Ce nombre va correspondre à la somme :k = N1 + N2 + N3 + N4 avec :

– N1 : nombre d’acteurs (N1 ≤ 3)– N2 : nombre de réalisateurs (N2 ∈ {0, 1})– N3 : nombre de mots-clés décrivant le film de référence 6

– N4 : nombre de genres cinématographiques (N4 = 26)Notons, que les quantités N1, N2 et N3 dépendent du film sélectionné par l’utilisateur mais que la valeur deN4 est fixe et correspond aux 26 genres cinématographiques distincts de la variable ’genre’ (c.f. sectiond’exploration du notebook de cleaning). La matriceM va ensuite être remplie par des 0 ou des 1, suivant 1/la correspondance entre les différentes entrées et le film de référence et 2/ les genres associés au différentesentrées. Ensuite, en choisissant pour le calcul de distance la distance euclidienne, la distance entre les filmsd’indices l et n est :

dl,n =

√√k∑

i=1

(Ml,i − Mn,i

)2 (1)

où Mi, j dénote l’élément de la ieme ligne et jeme colonne de la matriceM. Grâce à cette mesure de distance,il est ensuite possible de définir la liste des N films les plus proches du film sélectionnés par l’utilisateur.J’utilise pour cela la fonction NearestNeighbors du package Scikit-learn et fixe la valeur de N à 31.

4.2 Popularité des entréesUne fois la liste de N films établie, 5 films vont être sélectionnés sur la base d’un système de notation.

La note attribuée à un film va être donnée par une fonction du type :

note = score IMDb2× φ1(année) × φ2(max users) (2)

où φ1 et φ2 vont être respectivement des fonctions gaussiennes centrées sur l’année de sortie du film deréférence et sur le nombre maximum d’utilisateur ayant voté (variable ’num_voted_users’) et recensédans la liste des N films sélectionnés. La première fonction gaussienne permet de donner plus de poids auxfilms dont les dates de sortie sont proches dans le temps de celle du film de référence. La seconde permetde donner plus de poids aux films pour lesquels un grand nombre d’utilisateurs auront voté. A ce stade, lemoteur de recommandation sélectionne les 5 films ayant les meilleures notes.

6. En première intention, j’ai opté pour construire la matrice M en incluant les 1299 mots-clés de la variable’plot_keywords’, ainsi que l’ensemble des acteurs et réalisateurs. La mise en place de cette approche a néanmoins été impos-sible à cause de la taille des matrices générées : les calculs ont été effectués sur AWS sur des instances de type t2-micro pourlesquelles la RAM est limitée à 1Gb. En conséquence, j’ai changé de stratégie en ne considérant que les mots clés du film deréférence dans la construction deM.

10

4.3 Suites de filmsImaginons la cas de figure où un utilisateur choisit "Pirate des caraïbes : la fontaine de jouvence"

comme film de référence. Compte-tenu de ce choix, il serait assez peu judicieux que le moteur renvoie"Pirate des caraïbes : la malédiction du Black Pearl" et "Pirate des caraïbes : la vengeance de Salazar",etc ... dans la liste recommandées dans la mesure où il est très probable que l’utilisateur ait déjà connaissancede l’existence de ces films ! En revanche, ce genre de choix est assez probable compte-tenu des spécificitésdu moteur de recommandation vu que les séries de films ont en règle générale des acteurs et réalisateurs encommun, et vont être décrit par le même genre cinématographique. Il est donc nécessaire de filtrer ce typede résultat.

Dans le cas présent, j’ai opté pour un filtre assez simple se basant sur la similarité entre les type defilms. Pour cela, j’ai utilisé la package fuzzywuzzy qui permet de définir de manière quantitative le degréde similarité entre deux chaines de caractères. De cette manière, j’ai filtré le contenu de la liste de 5 filmsen imposant qu’il n’y ait pas 2 films d’une même série dans cette liste.

4.4 Validation du moteur : exemple de recommandationsAfin de valider le moteur de recommandation, j’ai examiné les résultats que celui–ci fournit sur quelques

cas particuliers. La figure 6 donne une exemple de recommandations obtenues à partir de la méthodologiedécrite précédemment. Compte-tenu des films que je connais personnellement dans les listes que j’ai généré,les recommandations m’ont semblé pertinentes dans la plupart des cas et sur cette base, j’ai donc validé lemoteur.

Figure 6 – Exemple de liste de films obtenue grâce au moteur de recommandation.

11

5 APIPour ce moteur de recommandation, une API a été développée avec le framework FLASK et j’ai pris

le parti de créer un formatage HTML pour améliorer le rendu des requêtes. En conséquence, cette versionde l’API n’est accessible que via un navigateur web et ne l’est pas depuis un terminal, via par exemple lacommande curl.

Le fonctionnement global de cette API est le suivant. Initialement, on charge le contenu de 2 fichiers.csv dans des dataframes via :

– df_liste = pd.read_csv(’liste_des_films.csv’)– df = pd.read_csv(’selection_films.csv’)

Le premier dataframe, df_liste va contenir la correspondance entres les id des films et les titres associés.Au niveau de l’API, j’accède au contenu de ce dataframe à partir du chemin/recommandation/liste_films. La figure 7 montre une capture d’écran obtenue pour cette url.

Figure 7 – Liste des films renvoyée par l’API.

A partir de cette liste, l’utilisateur recherche l’identificateur ’id’ correspondant au titre qu’il aura choi-sit. Les recommandations pour ce film, contenues dans le dataframe df, sont alors accessibles au chemin

12

/recommandation/film_id/id. Un exemple de recommandation est présenté sur la figure 8.

Figure 8 – Liste des films renvoyée par l’API.

6 ConclusionDans ce projet, j’ai développé un moteur de recommandation de films fournissant à un utilisateur une

liste de 5 films, et ceci sur la base d’une similarité avec un film fournit en entrée et que l’utilisateur a appré-cié. Ce moteur a été développé à partir d’une base de donnée téléchargée sur la plateforme Kaggle et ellemême issue de la base de donnée de films et séries TV IMDb. Après avoir nettoyé cette base de donnée, quicontient environ 5000 entrées, j’ai utilisé une méthode d’apprentissage non supervisé se basant sur un al-gorithme de recherche des plus proches voisins (fonction NearestNeighbor du package Scikit-learn).Un examen manuel des résultats fournit par le moteur m’a permis de juger de la pertinence des résultats etde valider sa conception. Finalement, les résultats fournit par ce moteur sont rendus accessibles via une APIdéveloppée avec le framework FLASK.

13

A Annexe : Arborescence et description des fonctions du moteur derecommandation

Cette annexe recense l’ensemble des fonctions définies et utilisées dans le moteur de recommandation,donne une brève description du rôle de chacune d’entre-elles et liste les appels à ces fonctions.

1. find_similarities(df, id_entry, verbose) :Programme principal : renvoie une liste de 5 films sélectionnés dans le dataframe ’df’ et similairesà l’entrée ’id_entry’ de ce dataframe.→ recommand→ extract_parameters→ add_to_selection→ remove_sequels

2. recommand(df, id_entry) :Extrait du dataframe ’df’ une liste de N = 31 films similaires à l’entrée ’id_entry’→ entry_variables→ add_variables

3. entry_variables(df, id_entry) :Renvoie les valeurs prises par les variables ’director_name’, ’actor_N_name’ (N ∈ [1 :3]) et’plot_keywords’ pour l’entrée d’indice ’id_entry’ du dataframe ’df’.

4. add_variables(df, REF_VAR) :Ajoute de nouvelles variables au dataframe ’df’ dont la liste est donnée par REF_VAR. Ces variablessont mises à 0 ou 1 en fonction de la correspondance avec le contenu des variables ’genres’,’actor_N_name’ (N ∈ [1 :3]), ’director_name’, ’plot_keywords’.

5. extract_parameters(df, liste_films) :Extrait du dataframe ’df’ et pour la liste de films ’liste_films’ les valeurs prises par les va-riables ’movie_title’, ’title_year’, ’imdb_score’, ’num_user_for_reviews’,’num_voted_users’. La liste de paramètres extraite est ensuite ordonnée à partir des critères défi-nis dans la fonction critere_selection().→ critere_selection

6. sequel(titre_1, titre_2) :Compare 2 chaines de caractères et renvoie True/False suivant le degré de similarité de ces chaînes.

7. critere_selection(title_main, max_users, annee_ref, titre, annee, imdb_score,votes) :Attribution d’une note au film ’titre’. Cette note dépends de :- son score IMDb ’imdb_score’- de l’écart entre l’année de sortie de ce film et l’année de sortie du film ’title_main’sélectionné par l’utilisateur (correspondant respectivement aux variables ’annee’ et ’annee_ref’)

14

- du nombre de votes ’votes’ collectés par le film ’titre’→ sequel

8. add_to_selection(film_selection, parametres_films) :Crée/complète la liste ’film_selection’ contenant les 5 films recommandés. Les films sont extraitsde ’parametres_films’ et ajoutés si leurs titres sont suffisamment éloignés des titres des films pré-cédemment ajoutés.→ sequel

9. remove_sequels(film_selection) :Filtre la liste ’film_selection’ et repère les séries de films (un film et ses suites) en fonction de lasimilarité entre leurs titres. Lorsqu’une suite est détectée, les films les plus récents sont supprimés.→ sequel

15