Aller au contenu
English

La matrice utilisateurs-articles

  • Leçon 5
  • 35 min
  • Module 2 : Les données, la rétroaction implicite et un découpage honnête

Où nous en sommes

Nous avons transformé les événements en interactions pondérées. La plupart des méthodes en ont besoin dans un seul tableau de clients et de produits. Dans cette leçon, nous construisons la matrice utilisateurs-articles sous forme de matrice creuse et mesurons son taux de vide.

Lue depuis YouTube. Rien ne se charge depuis YouTube avant que vous appuyiez sur lecture. Confidentialité
Leçon 5 sur 29 · Recommandation et personnalisation : montrer à chacun ce qui compteLa matrice utilisateurs-articles
Aperçu du cours

5. La factorisation matricielle pour la rétroaction implicite

  1. Goûts cachés
  2. ALS et BPR avec implicit
  3. Régler sans vous tromper vous-même

Ce que vous saurez faire

Regroupez les interactions de chaque client dans un seul tableau, la matrice utilisateurs-articles. Stockez-la de façon à tenir en mémoire. Mesurez son taux de vide et voyez pourquoi ce vide est la principale difficulté de la recommandation.

Carnet JupyterFaites cette leçon dans un carnet JupyterColab · Kaggle · GitHub · en anglais

Le carnet (notebook) Jupyter construit la matrice de cette leçon avec SciPy et mesure la mémoire qu’elle occupe. Il montre la ligne d’un client et compte les commandes par client. Votre tâche : construire une matrice contenant seulement les commandes. Ses cellules de préparation installent les paquets et téléchargent les données. Environ 20 minutes.

Le carnet est en anglais. Colab et Kaggle ouvrent votre propre copie. Il faut un compte Google ou Kaggle gratuit. Vous êtes bloqué ? Consultez le carnet de solution.

Avant de commencerCe qu’il faut savoir et avoir sous la mainEnviron 35 minutes

Ce que vous devez savoir

  • La rétroaction implicite, les poids consultation 1, panier 3, commande 5, et pourquoi une cellule vide représente une inconnue. Ces notions viennent de Des interactions, pas des notes.

Ce qu’il vous faut sur votre ordinateur

  • Votre projet larkfield-recs de Découvrir le journal du magasin, avec son environnement virtuel actif. recs check affiche Setup check passed. (vérification de la configuration réussie).
  • Votre copie du dépôt des exercices, à côté du projet, à jour (git pull dans nextia-learning-labs).

Après cette leçon, votre projet possède la commande recs matrix de l’instantané end-of-m02. Le journal du magasin est synthétique. L’équipe du cours a exécuté chaque commande sur un portable Apple M4. Testé sur macOS; les commandes Windows ne sont pas testées.

Imaginez que notre vendeuse en magasin tient un cahier. Chaque ligne représente un client. Chaque colonne représente un produit du magasin. Quand un client regarde un produit, elle fait une petite marque dans cette case. Quand le client l’achète, elle fait une grosse marque.

Pour un petit magasin avec 30 clients réguliers et 50 produits, cela fonctionne bien. Une page montre qui aime quoi. Elle voit que deux clients ont des marques sur les mêmes chaises de jardin. Elle peut alors suggérer à l’un ce que l’autre a acheté.

Donnez-lui maintenant Larkfield : 40 000 clients et 2 994 produits. Le cahier contient 119 760 000 cases. Il lui faudrait des milliers de pages, et presque toutes les cases seraient vides.

Le tableau du cahier porte un nom : la matrice utilisateurs-articles. L’« utilisateur » est le client, l’« article » est le produit. Une matrice est un tableau de nombres avec des lignes et des colonnes. Dans la matrice de Larkfield :

  • chaque ligne représente un client (40 000 lignes);
  • chaque colonne représente un produit (2 994 colonnes);
  • chaque cellule contient l’interaction du client avec le produit : la somme des poids de ses événements, expliquée dans Des interactions, pas des notes.

Le client C100134 de la dernière leçon a une ligne avec trois cellules remplies. Le lampadaire a une valeur de 13, et chacune des deux autres lampes a une valeur de 1. Les 2 991 autres cellules de la ligne sont vides.

Presque toutes les méthodes de ce cours lisent cette matrice. Les méthodes article-article comparent ses colonnes. Les méthodes utilisateur-utilisateur comparent ses lignes. La factorisation matricielle condense tout le tableau en quelques goûts cachés. Nous la construisons donc une seule fois, avec soin.

Faites d’abord une prédiction : quelle proportion des 119 760 000 cellules pensez-vous trouver remplie?

Voici un vrai coin de la matrice : 30 clients et 80 produits, choisis au hasard parmi les événements avant la période de test.

Une grille de 30 lignes (clients) et de 80 colonnes (produits). Presque toutes les cellules sont blanches. 13 cellules sont bleues; un bleu plus foncé indique un signal plus fort. Sous la grille : 13 cellules remplies sur 2 400 (0,54 %); la matrice entière est remplie à 0,390 %.
Un coin aléatoire de la matrice utilisateurs-articles de Larkfield (30 clients × 80 produits, graine 37). 13 cellules sur 2 400 sont remplies. Sur un téléphone, l'image pivote : les produits sont les lignes.
Description textuelle du diagramme

L’image est une grille de 30 lignes et de 80 colonnes. Presque toutes les cellules sont blanches : aucun événement. 13 cellules sont bleues. Les cellules bleu pâle sont des signaux faibles, comme une consultation (poids 1). Les cellules bleu foncé sont des signaux forts, avec un poids de 13 ou plus. Elles représentent plusieurs consultations, des ajouts au panier et une commande. Un client a quatre cellules remplies; la plupart des clients de ce coin n’en ont aucune. La note sous la grille indique : 13 cellules remplies sur 2 400 (0,54 %); la matrice entière est remplie à 0,390 %.

La matrice entière contient 467 160 cellules remplies sur 119 760 000 : 0,390 %. Moins de 4 cellules sur 1 000 contiennent un signal. Une matrice dont presque toutes les cellules sont vides est dite creuse. À l’inverse, une matrice dont la plupart des cellules sont remplies est dite dense.

Le problème : le tableau dense gaspille de la mémoire

Section intitulée « Le problème : le tableau dense gaspille de la mémoire »

Tomás essaie la méthode simple. Il crée un tableau ordinaire, un DataFrame pandas avec une colonne par produit, et y inscrit les nombres. Le tableau stocke chaque cellule, vide ou non. Avec 4 octets par nombre :

40 000 × 2 994 × 4 octets = 479 Mo

Cela fait 479 Mo pour stocker 467 160 nombres utiles. Avec les nombres de 8 octets utilisés par défaut dans pandas, c’est deux fois plus. Chaque calcul sur le tableau lit aussi toutes les cellules vides. Une somme sur une ligne additionne 2 994 nombres pour en trouver trois.

Une matrice creuse conserve seulement les cellules remplies. Pour chacune, elle conserve trois nombres : la ligne, la colonne et la valeur. Les cellules vides n’occupent aucune mémoire. Voici un petit exemple construit avec 4 clients et 5 produits :

À gauche, une matrice de 4 sur 5 avec les clients c0 à c3 en lignes et les produits p0 à p4 en colonnes. Quatre cellules sont remplies : c0 p1 = 5, c1 p3 = 1, c1 p4 = 3, c3 p0 = 1. À droite, trois listes de quatre nombres : ligne 0 1 1 3, colonne 1 3 4 0, valeur 5 1 3 1.
Un exemple construit de 4 × 5. Le tableau dense conserve 20 nombres; la matrice creuse conserve trois courtes listes.
Description textuelle du diagramme

À gauche se trouve une matrice de 4 clients (c0 à c3) et de 5 produits (p0 à p4). Quatre cellules ont une valeur. c0 a commandé p1 (5). c1 a consulté p3 (1) et ajouté p4 au panier (3). c3 a consulté p0 (1). Les 16 autres cellules sont vides. À droite se trouvent les trois listes que conserve une matrice creuse. Les lignes sont 0, 1, 1, 3. Les colonnes sont 1, 3, 4, 0. Les valeurs sont 5, 1, 3, 1. Les cellules vides n’occupent aucune mémoire.

Lisez la première colonne des listes : ligne 0, colonne 1, valeur 5. C’est le client c0 et le produit p1, avec un poids de 5. Chaque cellule remplie correspond à une colonne des trois listes.

SciPy, la bibliothèque scientifique pour Python, propose plusieurs formats creux. Le projet utilise CSR (« compressed sparse row », ou stockage creux compressé par lignes). CSR conserve les colonnes et les valeurs dans l’ordre des lignes. Plutôt qu’un numéro de ligne par cellule, il conserve la position où chaque ligne commence dans les listes. Il peut donc lire très vite la ligne d’un client. C’est ce qu’un système de recommandation fait constamment : « donnez-moi les produits de ce client ».

Avec CSR et des nombres de 4 octets, la matrice de Larkfield occupe 3,9 Mo plutôt que 479 Mo.

La matrice n’est pas seulement vide. Le vide est réparti de façon très inégale entre ses lignes. Voici les commandes passées par chaque client avant la période de test :

Commandes par client avant le 22 juin 2026 (journal synthétique), pour les 22 857 clients qui ont commandé. Plus de la moitié ont commandé une fois.
Description textuelle du graphique

Six barres. 1 commande : 12 281 clients. 2 commandes : 4 633. 3 commandes : 2 216. 4 commandes : 1 248. 5 commandes : 734. 6 commandes ou plus : 1 745. Au total, 22 857 clients ont commandé au moins une fois avant la période de test; 17 143 des 40 000 clients n’ont jamais commandé.

Plus de la moitié des clients qui ont commandé l’ont fait une fois. Un client avec une commande et quelques consultations a une ligne avec seulement quelques cellules remplies. Le client médian ayant au moins un événement a 7 cellules remplies : 7 produits sur 2 994.

Les colonnes sont aussi inégales, dans l’autre sens. Le 1 % des produits ayant le plus d’interactions regroupe 7,8 % de toutes les cellules remplies. Et 6 produits n’ont aucune cellule remplie. C’est la longue traîne de Découvrir le journal du magasin, vue dans la matrice.

Pourquoi est-ce important? Chaque méthode de ce cours remplit les cellules vides avec une estimation. Pour un client avec 40 cellules remplies, il y a beaucoup à apprendre. Pour un client avec une commande, il n’y a presque rien. C’est la vraie difficulté de la recommandation. C’est pourquoi les leçons suivantes évaluent chaque segment de clients séparément : nouveaux, occasionnels et fidèles.

Erreur courante

Appeler toarray() « juste pour voir »

Tomás a la matrice creuse M et veut la voir sous forme de tableau, alors il appelle M.toarray(). Python construit maintenant le tableau dense : 479 Mo avec des nombres de 4 octets. Avec les nombres de 8 octets utilisés par défaut dans pandas, c’est environ 958 Mo. Sur un portable où d’autres programmes sont ouverts, cela peut tout ralentir. Un magasin plus grand rend même cela impossible. Un magasin avec 1 million de clients et 50 000 produits aurait besoin de 200 Go. Regardez plutôt de petites parties : M[:5, :10].toarray() pour un coin, ou M.getrow(i) pour un client. Gardez la matrice entière creuse.

La commande recs matrix construit la matrice à partir des événements avant la période de test et affiche son taux de vide. C’est un nouveau fichier de l’instantané end-of-m02.

  1. Dans le dossier de votre projet, avec l’environnement virtuel actif, copiez la commande depuis l’instantané :

    Fenêtre de terminal
    cp ../nextia-learning-labs/C37/snapshots/end-of-m02/larkfield_recs/commands/matrix.py larkfield_recs/commands/matrix.py
  2. Ouvrez larkfield_recs/commands/matrix.py et lisez run(). Elle charge le magasin, prend la période de test et appelle p.matrix(w) avec vos poids. p.matrix() se trouve dans larkfield_recs/data.py (fonction interaction_matrix). Lisez-la aussi.

  3. Construisez la matrice avec les poids par défaut : recs matrix.

  4. Construisez-la avec les commandes seulement : recs matrix --weights view=0,basket=0,order=1.

La commande recs trouve ses sous-commandes à partir de leurs fichiers. Le nouveau fichier suffit donc : aucun autre fichier ne change. Le cœur de interaction_matrix tient en trois lignes :

w = events.event.map(weights).astype(float).fillna(0).to_numpy()
m = sp.csr_matrix((w, (events.c.to_numpy(), events.p.to_numpy())), shape=(n_customers, n_products))
m.sum_duplicates()

La première ligne donne son poids à chaque événement. La deuxième crée une matrice CSR à partir de trois listes : les poids, les numéros de clients (lignes) et de produits (colonnes). Un client avec cinq événements sur un produit donne cinq entrées pour la même cellule. La troisième ligne les additionne en une seule valeur : la somme des poids.

Afficher le résultat attendu

L’étape 3 affiche ceci (exécution de l’équipe du cours) :

Events before 2026-06-22: 770,140; weights {'view': 1.0, 'basket': 3.0, 'order': 5.0}
Matrix: 40,000 customers x 2,994 products, 467,160 filled cells (0.390%); memory 3.9 MB sparse, 479 MB if it were dense
Customers with a filled cell: 38,377; products per customer: median 7, mean 12.2
Orders per customer (customers who ordered): 1: 12,281, 2: 4,633, 3: 2,216, 4: 1,248, 5: 734, 6 or more: 1,745
Products: the 1% most touched products have 7.8% of the filled cells; 6 products have none

L’étape 4 affiche ceci :

Events before 2026-06-22: 770,140; weights {'view': 0.0, 'basket': 0.0, 'order': 1.0}
Matrix: 40,000 customers x 2,994 products, 73,593 filled cells (0.061%); memory 0.7 MB sparse, 479 MB if it were dense
Customers with a filled cell: 22,857; products per customer: median 2, mean 3.2
Orders per customer (customers who ordered): 1: 12,281, 2: 4,633, 3: 2,216, 4: 1,248, 5: 734, 6 or more: 1,745
Products: the 1% most touched products have 20.8% of the filled cells; 430 products have none

Les données sont les mêmes pour tous, donc vos nombres sont identiques. Chaque commande prend moins d’une seconde.

Comparez les deux exécutions. Avec les commandes seulement, la matrice conserve 73 593 cellules plutôt que 467 160. Elle est plus de six fois plus vide. 15 520 clients perdent toute leur ligne (38 377 contre 22 857), et 430 produits n’ont aucun signal. Les signaux faibles de la dernière leçon remplissent la majeure partie de la matrice.

Matrice creuse (CSR) Tableau dense
Mémoire environ 8 octets par cellule remplie : 3,9 Mo ici 4 octets par cellule : 479 Mo ici
Lire la ligne d’un client rapide rapide
Modifier les cellules une à une lent : la reconstruire à partir des listes rapide
Utile pour la matrice entière, toutes les méthodes de ce cours une petite partie à afficher ou à tracer

Une règle pratique : quand moins d’environ 10 % des cellules sont remplies, gardez la matrice creuse. Les données de recommandation sont presque toujours bien en dessous de ce seuil. Les bibliothèques de rétroaction implicite prennent une matrice CSR en entrée. C’est le cas de la bibliothèque implicit de Goûts cachés.

Le coût est faible : modifier une matrice CSR cellule par cellule est lent. Le projet construit donc la matrice une seule fois à partir des événements, en une étape, et ne la modifie jamais.

  1. Ouvrez le carnet de cette leçon et exécutez les cellules de préparation. Attendez Ready: 4 files in larkfield-recs. (prêt : 4 fichiers dans larkfield-recs).
  2. Exécutez la section 1. Elle donne à chaque événement un numéro de ligne (son client) et un numéro de colonne (son produit).
  3. Prédisez la proportion de cellules remplies. Puis exécutez la section 2.
  4. Exécutez la cellule suivante : la ligne du client C100134.
  5. Exécutez la section 3 : les commandes par client, sous forme de diagramme à barres.
Afficher le résultat attendu

La section 2 affiche ceci :

40,000 x 2,994 = 119,760,000 cells; 467,160 filled (0.390%)
memory: 3.9 MB sparse, 479 MB as a dense table

La ligne de C100134 a 3 cellules remplies : les trois lampes, avec les poids 13, 1 et 1. La section 3 montre les mêmes décomptes que recs matrix : 12 281 clients avec 1 commande, jusqu’à 1 745 avec 6 ou plus.

À vous : une matrice contenant seulement les commandes

Section intitulée « À vous : une matrice contenant seulement les commandes »

Construisez une deuxième matrice avec les commandes seulement : 1 dans une cellule si le client a commandé le produit au moins une fois. Faites d’abord une prédiction : combien de cellules sont remplies? Puis écrivez la cellule de la section 4 et lancez la vérification.

Afficher la réponse

73 593 cellules remplies (0,061 %), comme avec recs matrix --weights view=0,basket=0,order=1. La vérification affiche Check passed: filled_orders is 73593. (vérification réussie : filled_orders vaut 73593). La solution :

o = train[train["event"] == "order"]
O = sp.csr_matrix((np.ones(len(o)), (pd.Categorical(o["customer_id"], categories=cust).codes,
pd.Categorical(o["product_id"], categories=prod).codes)), shape=M.shape)
O.sum_duplicates()
filled_orders = O.nnz

sum_duplicates() transforme deux commandes du même produit en une cellule de valeur 2. Ainsi, nnz, le nombre de cellules stockées, compte chaque paire client-produit une seule fois.

Vérifiez votre compréhension

Expliquez la matrice utilisateurs-articles dans vos mots : que représentent une ligne, une colonne et une cellule? Pourquoi dit-on que la matrice de Larkfield est creuse?

Afficher la réponse

Une ligne représente un client, et une colonne représente un produit. Une cellule contient l’interaction du client avec le produit : la somme des poids de ses événements. La matrice de Larkfield est creuse parce que presque toutes les cellules sont vides. Seulement 467 160 cellules sur 119 760 000 ont une valeur : 0,390 %.

Vérifiez votre compréhension

Un magasin a 200 000 clients et 10 000 produits, et 0,2 % des cellules sont remplies. Estimez la mémoire d'un tableau dense avec des nombres de 4 octets. Estimez aussi celle d'une matrice creuse à environ 8 octets par cellule remplie.

Afficher la réponse

Dense : 200 000 × 10 000 × 4 octets = 8 000 000 000 octets, soit environ 8 Go. Creuse : 0,2 % de 2 000 000 000 cellules donne 4 000 000 de cellules remplies. À environ 8 octets chacune, cela fait environ 32 Mo, plus un peu pour la position de début de chaque ligne. La matrice creuse est environ 250 fois plus petite.

Vérifiez votre compréhension

Plus de la moitié des acheteurs de Larkfield n'ont commandé qu'une fois. Pourquoi cela rend-il la recommandation difficile, même avec une méthode parfaite?

Afficher la réponse

Un client avec une commande et quelques consultations a une ligne contenant seulement quelques cellules remplies : très peu pour apprendre. Toute méthode doit estimer la plupart de ses intérêts à partir des actions des autres clients. Les scores des leçons suivantes sont donc plus faibles pour les clients ayant peu d’historique. Pour le voir, nous examinons les segments (nouveaux, occasionnels, fidèles) séparément.

Récapitulatif

  • La matrice utilisateurs-articles a une ligne par client, une colonne par produit et l’interaction dans chaque cellule. Cette interaction est la somme des poids des événements. Presque toutes les méthodes de ce cours la lisent.
  • La matrice de Larkfield a 467 160 cellules remplies sur 119 760 000 : 0,390 %. Elle est creuse.
  • Une matrice creuse conserve seulement les cellules remplies : ligne, colonne et valeur. Au format CSR, elle occupe 3,9 Mo plutôt que 479 Mo. N’appelez jamais toarray() sur la matrice entière.
  • Les lignes sont très inégales : plus de la moitié des acheteurs ont commandé une fois, et le client médian a 7 cellules remplies.
  • recs matrix la construit; --weights view=0,basket=0,order=1 conserve seulement les commandes : 73 593 cellules, soit plus de six fois plus vide.

Ensuite, nous cachons certaines cellules et demandons à une méthode de les estimer. Nous verrons pourquoi la façon de les cacher change le score.

Leçon suivante : Découper selon le temps