Tutoriel : Générer un système de suggestion de films à l’aide de la factorisation de matrice avec ML.NET
Ce tutoriel explique comment créer un système de suggestion de films à l’aide de ML.NET dans une application console .NET. Les étapes de ce tutoriel utilisent le langage C# et Visual Studio 2019.
Dans ce tutoriel, vous allez apprendre à :
- Sélectionner un algorithme de machine learning.
- Préparer et charger vos données.
- Créer et entraîner un modèle.
- Évaluer un modèle.
- Déployer et consommer un modèle.
Vous trouverez le code source de ce tutoriel dans le référentiel dotnet/samples.
Flux de travail de l’apprentissage automatique
Vous effectuerez les étapes suivantes pour accomplir votre tâche, ainsi que toute autre tâche ML.NET :
Prérequis
Sélectionner la tâche d’apprentissage automatique appropriée
Il existe plusieurs façons d’aborder les problèmes de suggestion, par exemple la suggestion d’une liste de films ou d’une liste de produits associés. Dans le cas présent, vous allez prédire l’évaluation (1-5) qu’un utilisateur attribuera à un film spécifique et suggérer ce film si la note est supérieure à un seuil défini (plus l’évaluation est élevée, plus il est probable qu’un utilisateur apprécie un film).
Création d’une application console
Création d’un projet
Créez une application console C# appelée « MovieRecommender ». Cliquez sur le bouton Suivant.
Choisissez .NET 6 comme framework à utiliser. Cliquez sur le bouton Créer.
Créez un répertoire nommé Données dans votre projet pour enregistrer le jeu de données :
Dans l’Explorateur de solutions, cliquez avec le bouton droit sur le projet, puis sélectionnez Ajouter>Nouveau dossier. Tapez « Données » et appuyez sur Entrée.
Installez les packages NuGet Microsoft.ML et Microsoft.ML.Recommender :
Notes
Cet exemple utilise la dernière version stable des packages NuGet mentionnés, sauf indication contraire.
Dans l’Explorateur de solutions, cliquez avec le bouton droit sur le projet, puis sélectionnez Gérer les packages NuGet. Choisissez « nuget.org » comme source du package, sélectionnez l’onglet Parcourir, recherchez Microsoft.ML, sélectionnez le package dans la liste, puis sélectionnez le bouton Installer. Cliquez sur le bouton OK dans la boîte de dialogue Aperçu des modifications, puis sur le bouton J’accepte dans la boîte de dialogue Acceptation de la licence si vous acceptez les termes du contrat de licence pour les packages répertoriés. Répétez ces étapes pour Microsoft.ML.Recommender.
Ajoutez les instructions
usingsuivantes en tête de votre fichier Program.cs :using Microsoft.ML; using Microsoft.ML.Trainers; using MovieRecommendation;
Télécharger vos données
Téléchargez les deux jeux de données et enregistrez-les dans le dossier Données que vous avez créé :
Cliquez avec le bouton droit sur recommendation-ratings-train.csv et sélectionnez « Enregistrer le lien (ou la cible) sous... ».
Cliquez avec le bouton droit sur recommendation-ratings-test.csv et sélectionnez « Enregistrer le lien (ou la cible) sous... ».
Veillez à enregistrer les fichiers *.csv dans le dossier Données ou, après les avoir enregistrés ailleurs, à les y déplacer.
Dans l’Explorateur de solutions, cliquez avec le bouton droit sur chacun des fichiers *.csv, puis sélectionnez Propriétés. Sous Avancé, définissez la valeur Copier dans le répertoire de sortie sur Copier si plus récent.
Charger vos données
La première étape du processus ML.NET consiste à préparer et à charger les données d’entraînement et de test de votre modèle.
Les données d’évaluation pour les suggestions sont divisées en jeux de données Train et Test. Les données Train sont utilisées pour ajuster votre modèle. Les données Test sont utilisées pour élaborer des prédictions avec votre modèle entraîné et à évaluer les performances du modèle. Il est courant d’avoir une répartition 80/20 avec les données Train et Test.
Voici un aperçu des données de vos fichiers *.csv :
Les fichiers *.csv comportent quatre colonnes :
userIdmovieIdratingtimestamp
En machine learning, les colonnes qui servent à élaborer une prédiction sont appelées Caractéristiques, et la colonne contenant la prédiction retournée est appelée Étiquette.
Puisque vous souhaitez prédire des évaluations de films, c’est la colonne d’évaluation qui est la Label. Les trois autres colonnes, userId, movieId et timestamp, sont toutes des Features utilisées pour prédire la Label.
| Fonctionnalités | Étiquette |
|---|---|
userId |
rating |
movieId |
|
timestamp |
C’est à vous de décider quelles Features sont utilisées pour prévoir la Label. Vous pouvez également utiliser des méthodes telles que l’importance de la permutation de caractéristiques pour faciliter la sélection des meilleures Features.
Dans ce cas, vous devez retirer la colonne timestamp comme Feature, car l’horodatage n’affecte pas vraiment comment un utilisateur évalue un film donné et ne contribue donc pas à la précision de la prédiction :
| Fonctionnalités | Étiquette |
|---|---|
userId |
rating |
movieId |
Ensuite, vous devez définir votre structure de données pour la classe d’entrée.
Ajoutez une nouvelle classe à votre projet :
Dans l’Explorateur de solutions, cliquez avec le bouton droit sur le projet, puis sélectionnez Ajouter > Nouvel élément.
Dans la boîte de dialogue Ajouter un nouvel élément, sélectionnez Classe, puis remplacez la valeur du champ Nom par MovieRatingData.cs. Ensuite, sélectionnez le bouton Ajouter.
Le fichier MovieRatingData.cs s’ouvre dans l’éditeur de code. Ajoutez l’instruction using suivante en haut de MovieRatingData.cs :
using Microsoft.ML.Data;
Créez une classe nommée MovieRating en supprimant la définition de classe existante et en ajoutant le code suivant dans MovieRatingData.cs :
public class MovieRating
{
[LoadColumn(0)]
public float userId;
[LoadColumn(1)]
public float movieId;
[LoadColumn(2)]
public float Label;
}
MovieRating spécifie une classe de données d’entrée. L’attribut LoadColumn spécifie les colonnes (par index de colonne) du jeu de données qui doivent être chargées. Les colonnes userId et movieId correspondent à vos Features (il s’agit des entrées que vous fournirez au modèle pour prédire la Label), et la colonne d’évaluation est la Label que vous allez prédire (la sortie du modèle).
Créez une autre classe, MovieRatingPrediction, pour représenter les résultats prédits en ajoutant le code suivant après la classe MovieRating dans MovieRatingData.cs :
public class MovieRatingPrediction
{
public float Label;
public float Score;
}
Dans Program.cs, remplacez Console.WriteLine("Hello World!") par le code suivant :
MLContext mlContext = new MLContext();
La classe MLContext est un point de départ pour toutes les opérations ML.NET, et l’initialisation de mlContext crée un environnement ML.NET qui peut être partagé par les objets de flux de travail de création de modèle. Sur le plan conceptuel, elle est similaire à DBContext dans Entity Framework.
En bas du fichier, créez une méthode appelée LoadData() :
(IDataView training, IDataView test) LoadData(MLContext mlContext)
{
}
Notes
Cette méthode donne une erreur tant que vous n’avez pas ajouté d’instruction de retour aux étapes suivantes.
Initialisez vos variables de chemin de données, chargez les données à partir des fichiers *.csv, et retournez les données Train et Test en tant qu’objets IDataView en ajoutant la ligne de code suivante dans LoadData() :
var trainingDataPath = Path.Combine(Environment.CurrentDirectory, "Data", "recommendation-ratings-train.csv");
var testDataPath = Path.Combine(Environment.CurrentDirectory, "Data", "recommendation-ratings-test.csv");
IDataView trainingDataView = mlContext.Data.LoadFromTextFile<MovieRating>(trainingDataPath, hasHeader: true, separatorChar: ',');
IDataView testDataView = mlContext.Data.LoadFromTextFile<MovieRating>(testDataPath, hasHeader: true, separatorChar: ',');
return (trainingDataView, testDataView);
Les données dans ML.NET sont représentées en tant qu’interface IDataView. IDataView est un moyen flexible et efficace de décrire des données tabulaires (numériques et texte). Les données peuvent être chargées à partir d’un fichier texte ou en temps réel (par exemple, fichiers journaux ou de base de données SQL) dans un objet IDataView.
LoadFromTextFile() définit le schéma de données et lit le fichier. Elle prend les variables de chemin de données et retourne un IDataView. Dans ce cas, fournissez le chemin pour vos fichiers Test et Train, et indiquez l’en-tête du fichier texte (pour qu’elle puisse utiliser les noms de colonnes correctement) et la virgule de séparation des données caractère (le séparateur par défaut est un onglet).
Ajoutez le code suivant pour appeler votre méthode LoadData() et retourner les données Train et Test :
(IDataView trainingDataView, IDataView testDataView) = LoadData(mlContext);
Créer et entraîner votre modèle
Créez la méthode BuildAndTrainModel() juste après la méthode LoadData(), en utilisant le code suivant :
ITransformer BuildAndTrainModel(MLContext mlContext, IDataView trainingDataView)
{
}
Notes
Cette méthode donne une erreur tant que vous n’avez pas ajouté d’instruction de retour aux étapes suivantes.
Définissez les transformations de données en ajoutant le code suivant à BuildAndTrainModel() :
IEstimator<ITransformer> estimator = mlContext.Transforms.Conversion.MapValueToKey(outputColumnName: "userIdEncoded", inputColumnName: "userId")
.Append(mlContext.Transforms.Conversion.MapValueToKey(outputColumnName: "movieIdEncoded", inputColumnName: "movieId"));
Étant donné que userId et movieId représentent des utilisateurs et des titres de films, et non des valeurs réelles, vous utilisez la méthode MapValueToKey() pour transformer chaque userId et chaque movieId en colonne Feature de type de clé numérique (un format accepté par les algorithmes de suggestion) et vous les ajoutez en tant que nouvelles colonnes de jeu de données :
| userId | movieId | Étiquette | userIdEncoded | movieIdEncoded |
|---|---|---|---|---|
| 1 | 1 | 4 | userKey1 | movieKey1 |
| 1 | 3 | 4 | userKey1 | movieKey2 |
| 1 | 6 | 4 | userKey1 | movieKey3 |
Choisissez l’algorithme de machine learning et ajoutez-le aux définitions de transformation de données en ajoutant la ligne de code suivante dans BuildAndTrainModel() :
var options = new MatrixFactorizationTrainer.Options
{
MatrixColumnIndexColumnName = "userIdEncoded",
MatrixRowIndexColumnName = "movieIdEncoded",
LabelColumnName = "Label",
NumberOfIterations = 20,
ApproximationRank = 100
};
var trainerEstimator = estimator.Append(mlContext.Recommendation().Trainers.MatrixFactorization(options));
MatrixFactorizationTrainer est votre algorithme d’entraînement de suggestion. La factorisation de matrice est une approche courante pour la suggestion quand vous avez des données concernant la façon dont les utilisateurs ont évalué des produits dans le passé, ce qui est le cas pour les jeux de données dans ce tutoriel. Il existe d’autres algorithmes de suggestion adaptés quand vous avez des données différentes (voir la section Autres algorithmes de suggestion ci-dessous pour en savoir plus).
Dans ce cas, l’algorithme Matrix Factorization utilise une méthode appelée « filtrage collaboratif », qui part du principe que si l’utilisateur 1 a le même avis que l’utilisateur 2 sur une certaine question, alors l’utilisateur 1 est davantage susceptible d’avoir le même avis que l’utilisateur 2 sur une autre question.
Par exemple, si les utilisateurs 1 et 2 donnent une évaluation similaire à des films, il est plus probable que l’utilisateur 2 appréciera un film que l’utilisateur 1 a vu et auquel il a donné une évaluation élevée :
Incredibles 2 (2018) |
The Avengers (2012) |
Guardians of the Galaxy (2014) |
|
|---|---|---|---|
| Utilisateur 1 | A vu et apprécié le film | A vu et apprécié le film | A vu et apprécié le film |
| Utilisateur 2 | A vu et apprécié le film | A vu et apprécié le film | N’a pas vu --SUGGÉRER le film |
L’entraîneur de Matrix Factorization dispose de plusieurs Options, qui sont détaillées dans la section Hyperparamètres d’algorithme ci-dessous.
Ajustez le modèle aux données Train et retournez le modèle entraîné en ajoutant la ligne de code suivante dans la méthode BuildAndTrainModel() :
Console.WriteLine("=============== Training the model ===============");
ITransformer model = trainerEstimator.Fit(trainingDataView);
return model;
La méthode Fit() entraîne votre modèle avec le jeu de données d’entraînement fourni. Techniquement, elle exécute les définitions Estimator en transformant les données et en appliquant l’entraînement, puis retourne le modèle entraîné, qui est un Transformer.
Pour plus d’informations sur le flux de travail d’apprentissage du modèle dans ML.NET, consultez Présentation de ML.NET et de son fonctionnement.
Ajoutez la ligne de code suivante sous l’appel vers la méthode LoadData() pour appeler votre méthode BuildAndTrainModel() et retourner le modèle formé :
ITransformer model = BuildAndTrainModel(mlContext, trainingDataView);
Évaluer votre modèle
Une fois que vous avez entraîné votre modèle, utilisez vos données de test pour évaluer ses performances.
Créez la méthode EvaluateModel() juste après la méthode BuildAndTrainModel(), en utilisant le code suivant :
void EvaluateModel(MLContext mlContext, IDataView testDataView, ITransformer model)
{
}
Transformez les données Test en ajoutant le code suivant à EvaluateModel() :
Console.WriteLine("=============== Evaluating the model ===============");
var prediction = model.Transform(testDataView);
La méthode Transform() établit des prédictions pour plusieurs lignes d’entrée fournies d’un jeu de données de test.
Évaluez le modèle en ajoutant la ligne de code suivante dans la méthode EvaluateModel() :
var metrics = mlContext.Regression.Evaluate(prediction, labelColumnName: "Label", scoreColumnName: "Score");
Une fois que vous avez le jeu de prédiction, la méthode Evaluate() évalue le modèle (elle compare les valeurs prédites aux Labels réelles dans le jeu de données de test et retourne des métriques relatives aux performances du modèle).
Imprimez vos métriques d’évaluation sur la console en ajoutant la ligne de code suivante dans la méthode EvaluateModel() :
Console.WriteLine("Root Mean Squared Error : " + metrics.RootMeanSquaredError.ToString());
Console.WriteLine("RSquared: " + metrics.RSquared.ToString());
Ajoutez la ligne de code suivante sous l’appel vers la méthode BuildAndTrainModel() pour appeler votre méthode EvaluateModel() :
EvaluateModel(mlContext, testDataView, model);
À ce stade, la sortie doit ressembler au texte suivant :
=============== Training the model ===============
iter tr_rmse obj
0 1.5403 3.1262e+05
1 0.9221 1.6030e+05
2 0.8687 1.5046e+05
3 0.8416 1.4584e+05
4 0.8142 1.4209e+05
5 0.7849 1.3907e+05
6 0.7544 1.3594e+05
7 0.7266 1.3361e+05
8 0.6987 1.3110e+05
9 0.6751 1.2948e+05
10 0.6530 1.2766e+05
11 0.6350 1.2644e+05
12 0.6197 1.2541e+05
13 0.6067 1.2470e+05
14 0.5953 1.2382e+05
15 0.5871 1.2342e+05
16 0.5781 1.2279e+05
17 0.5713 1.2240e+05
18 0.5660 1.2230e+05
19 0.5592 1.2179e+05
=============== Evaluating the model ===============
Rms: 0.994051469730769
RSquared: 0.412556298844873
Dans cette sortie, il existe 20 itérations. Dans chaque itération, la mesure d’erreur diminue et converge de plus en plus proche de 0.
La mesure RMSE (root of mean squared error) sert à mesurer les différences entre les valeurs prédites par un modèle et les valeurs observées dans un jeu de données de test. Techniquement, il s’agit de la racine carrée de la moyenne des carrés des erreurs. Plus sa valeur est faible, plus le modèle est bon.
R Squared indique le niveau d’adéquation des données avec un modèle. Cette valeur est comprise entre 0 et 1. Une valeur de 0 signifie que les données sont aléatoires ou ne s’intègrent pas au modèle. Une valeur de 1 signifie que le modèle correspond exactement aux données. Il faut que le score R Squared soit le plus proche possible de 1.
La création de modèles efficaces est un processus itératif. Celui-ci présente une qualité initiale médiocre, car le tutoriel utilise de petits jeux de données pour permettre un apprentissage rapide du modèle. Si vous n’êtes pas satisfait de la qualité du modèle, vous pouvez essayer de l’améliorer en fournissant de plus gros jeux de données d’apprentissage ou en choisissant d’autres algorithmes d’apprentissage avec différents hyperparamètres pour chacun. Pour plus d’informations, voir la section Améliorer le modèle ci-dessous.
Utiliser le modèle
Vous pouvez maintenant utiliser votre modèle entraîné pour établir des prédictions sur de nouvelles données.
Créez la méthode UseModelForSinglePrediction() juste après la méthode EvaluateModel(), en utilisant le code suivant :
void UseModelForSinglePrediction(MLContext mlContext, ITransformer model)
{
}
Utilisez le PredictionEngine pour prédire l’évaluation en ajoutant le code suivant à UseModelForSinglePrediction() :
Console.WriteLine("=============== Making a prediction ===============");
var predictionEngine = mlContext.Model.CreatePredictionEngine<MovieRating, MovieRatingPrediction>(model);
PredictionEngine est une API pratique qui vous permet d’effectuer une prédiction sur une seule instance de données. PredictionEngine n’est pas thread-safe. Il est acceptable de l’utiliser dans des environnements monothreads ou de prototype. Pour améliorer les performances et la sécurité des threads dans les environnements de production, utilisez le service PredictionEnginePool, qui crée un ObjectPool de PredictionEngine objets à utiliser dans votre application. Consultez ce guide sur l’utilisation de PredictionEnginePool dans une API web ASP.NET Core.
Notes
L’extension de service PredictionEnginePool est disponible en préversion.
Créez une instance de MovieRating nommée testInput et transmettez-la au moteur de prédiction en ajoutant les lignes de code suivantes dans la méthode UseModelForSinglePrediction() :
var testInput = new MovieRating { userId = 6, movieId = 10 };
var movieRatingPrediction = predictionEngine.Predict(testInput);
La fonction Predict() établit une prédiction sur une seule colonne de données.
Vous pouvez ensuite utiliser le Score, ou évaluation prédite, pour déterminer si vous souhaitez suggérer le film avec movieId 10 à l’utilisateur 6. Plus Score est élevé, plus il est probable qu’un utilisateur appréciera un film donné. Dans le cas présent, supposez que vous recommandez des films avec une évaluation prédite > 3,5.
Pour afficher les résultats, ajoutez les lignes de code suivantes dans la méthode UseModelForSinglePrediction() :
if (Math.Round(movieRatingPrediction.Score, 1) > 3.5)
{
Console.WriteLine("Movie " + testInput.movieId + " is recommended for user " + testInput.userId);
}
else
{
Console.WriteLine("Movie " + testInput.movieId + " is not recommended for user " + testInput.userId);
}
Ajoutez la ligne de code suivante après l’appel vers la méthode EvaluateModel() pour appeler votre méthode UseModelForSinglePrediction() :
UseModelForSinglePrediction(mlContext, model);
La sortie de cette méthode doit ressembler au texte suivant :
=============== Making a prediction ===============
Movie 10 is recommended for user 6
Enregistrez votre modèle
Pour utiliser votre modèle afin d’établir des prédictions dans des applications pour utilisateur final, vous devez d’abord enregistrer le modèle.
Créez la méthode SaveModel() juste après la méthode UseModelForSinglePrediction(), en utilisant le code suivant :
void SaveModel(MLContext mlContext, DataViewSchema trainingDataViewSchema, ITransformer model)
{
}
Enregistrez votre modèle entraîné en ajoutant le code suivant dans la méthode SaveModel() :
var modelPath = Path.Combine(Environment.CurrentDirectory, "Data", "MovieRecommenderModel.zip");
Console.WriteLine("=============== Saving the model to a file ===============");
mlContext.Model.Save(model, trainingDataViewSchema, modelPath);
Cette méthode enregistre votre modèle entraîné dans un fichier .zip (dans le dossier « Données »), qui peut ensuite être utilisé dans d’autres applications .NET pour établir des prédictions.
Ajoutez la ligne de code suivante après l’appel vers la méthode UseModelForSinglePrediction() pour appeler votre méthode SaveModel() :
SaveModel(mlContext, trainingDataView.Schema, model);
Utiliser le modèle enregistré
Une fois que vous avez enregistré votre modèle formé, vous pouvez utiliser le modèle dans différents environnements. Consultez Enregistrer et charger des modèles formés pour apprendre à opérationnaliser un modèle Machine Learning formé dans des applications.
Résultats
Après avoir effectué les étapes ci-dessus, exécutez votre application console (Ctrl + F5). Les résultats de la prédiction unique ci-dessus doivent ressembler à ce qui suit. Des messages d’avertissement ou de traitement peuvent s’afficher, mais nous les avons supprimés dans les résultats suivants pour plus de clarté.
=============== Training the model ===============
iter tr_rmse obj
0 1.5382 3.1213e+05
1 0.9223 1.6051e+05
2 0.8691 1.5050e+05
3 0.8413 1.4576e+05
4 0.8145 1.4208e+05
5 0.7848 1.3895e+05
6 0.7552 1.3613e+05
7 0.7259 1.3357e+05
8 0.6987 1.3121e+05
9 0.6747 1.2949e+05
10 0.6533 1.2766e+05
11 0.6353 1.2636e+05
12 0.6209 1.2561e+05
13 0.6072 1.2462e+05
14 0.5965 1.2394e+05
15 0.5868 1.2352e+05
16 0.5782 1.2279e+05
17 0.5713 1.2227e+05
18 0.5637 1.2190e+05
19 0.5604 1.2178e+05
=============== Evaluating the model ===============
Rms: 0.977175077487166
RSquared: 0.43233349213192
=============== Making a prediction ===============
Movie 10 is recommended for user 6
=============== Saving the model to a file ===============
Félicitations ! Vous avez réussi à créer un modèle Machine Learning pour la suggestion de films. Vous trouverez le code source de ce tutoriel dans le référentiel dotnet/samples.
Améliorer votre modèle
Il existe plusieurs façons d’améliorer les performances du modèle afin d’obtenir des prédictions plus précises.
Données
L’ajout de données d’entraînement comportant suffisamment d’échantillons pour chaque utilisateur et ID de film peut aider à améliorer la qualité du modèle de suggestion.
La validation croisée est une technique d’évaluation des modèles qui fractionne aléatoirement les données en sous-ensembles (au lieu d’extraire des données de test à partir du jeu de données comme vous l’avez fait dans ce tutoriel) et prend certains groupes comme données d’entraînement et certains autres comme données de test. En termes de qualité du modèle, cette méthode est supérieure à un fractionnement entraînement-test.
Fonctionnalités
Dans ce tutoriel, vous utilisez uniquement les trois Features (user id, movie id et rating) qui sont fournies par le jeu de données.
Même si c’est un bon point de départ, en réalité vous souhaiterez sans doute ajouter d’autres attributs ou Features (par exemple l’âge, le sexe, l’emplacement géographique et ainsi de suite) s’ils sont inclus dans le jeu de données. L’ajout de Features plus pertinentes peut aider à améliorer les performances de votre modèle de suggestion.
Si vous ne savez pas trop quelles Features peuvent être les plus appropriées pour votre tâche machine learning, vous pouvez également utiliser le calcul de contribution de caractéristique et l’importance de la permutation de caractéristiques, qui sont des fonctionnalités proposées par ML.NET pour découvrir les Features les plus influentes.
Hyperparamètres d’algorithme
Bien que ML.NET fournisse de bons algorithmes d’entraînement par défaut, vous pouvez optimiser les performances en changeant les hyperparamètres d’algorithme.
Pour la Matrix Factorization, vous pouvez expérimenter avec des hyperparamètres comme NumberOfIterations et ApproximationRank pour voir si cela donne de meilleurs résultats.
Par exemple, dans ce tutoriel, les options d’algorithme sont :
var options = new MatrixFactorizationTrainer.Options
{
MatrixColumnIndexColumnName = "userIdEncoded",
MatrixRowIndexColumnName = "movieIdEncoded",
LabelColumnName = "Label",
NumberOfIterations = 20,
ApproximationRank = 100
};
Autres algorithmes de suggestion
L’algorithme de factorisation de matrice avec filtrage collaboratif n’est qu’une approche parmi d’autres pour effectuer des suggestions de films. Dans de nombreux cas, vous ne disposerez peut-être pas des données d’évaluation et aurez uniquement l’historique des films des utilisateurs. Dans d’autres cas, vous aurez peut-être davantage que juste les données d’évaluation de l’utilisateur.
| Algorithm | Scénario | Exemple |
|---|---|---|
| Factorisation de matrice à une classe | Utilisez-la quand vous avez uniquement userId et movieId. Ce style de suggestion est basé sur le scénario de coachat (ou produits fréquemment achetés ensemble), ce qui signifie qu’il suggérera aux clients un ensemble de produits en fonction de leur propre historique de commandes. | >Faire un essai |
| Machines de factorisation prenant en charge les champs | Elles permettent d’effectuer des suggestions quand vous disposez d’autres caractéristiques en plus de userId, productId et rating (par exemple la description du produit ou le prix du produit). Cette méthode adopte également une approche avec filtrage collaboratif. | >Faire un essai |
Scénario avec nouvel utilisateur
L’un des problèmes courants dans le filtrage collaboratif est le problème de démarrage à froid, c’est-à-dire quand vous avez un nouvel utilisateur sans données à partir desquelles tirer des inférences. Pour le résoudre, il suffit souvent de demander aux nouveaux utilisateurs de créer un profil et, par exemple, d’évaluer les films qu’ils ont déjà vus. Même si cette méthode met un poids sur l’utilisateur, elle fournit certaines données de départ pour les nouveaux utilisateurs sans aucun historique d’évaluation.
Ressources
Les données utilisées dans ce tutoriel sont dérivées du Jeu de données MovieLens.
Étapes suivantes
Dans ce didacticiel, vous avez appris à :
- Sélectionner un algorithme de machine learning.
- Préparer et charger vos données.
- Créer et entraîner un modèle.
- Évaluer un modèle.
- Déployer et consommer un modèle.
Passer au tutoriel suivant pour en savoir plus
Commentaires
Bientôt disponible : Tout au long de 2024, nous allons supprimer progressivement GitHub Issues comme mécanisme de commentaires pour le contenu et le remplacer par un nouveau système de commentaires. Pour plus d’informations, consultez https://aka.ms/ContentUserFeedback.
Envoyer et afficher des commentaires pour