Kurz: vytvoření doporučení pro film pomocí Matrix factorizaton s ML.NETTutorial: Build a movie recommender using matrix factorizaton with ML.NET

V tomto kurzu se dozvíte, jak v konzolové aplikaci .NET Core sestavit doporučení pro film pomocí ML.NET.This tutorial shows you how to build a movie recommender with ML.NET in a .NET Core console application. Postup používá C# a Visual Studio 2019.The steps use C# and Visual Studio 2019.

V tomto kurzu se naučíte:In this tutorial, you learn how to:

  • Vyberte algoritmus strojového učení.Select a machine learning algorithm
  • Příprava a načtení datPrepare and load your data
  • Sestavování a výuka modeluBuild and train a model
  • Vyhodnocení modeluEvaluate a model
  • Nasazení a využití modeluDeploy and consume a model

Zdrojový kód pro tento kurz najdete v úložišti dotnet/Samples .You can find the source code for this tutorial at the dotnet/samples repository.

Pracovní postup strojového učeníMachine learning workflow

Pomocí následujících kroků můžete provést úlohu a také všechny další úlohy ML.NET:You will use the following steps to accomplish your task, as well as any other ML.NET task:

  1. Načtení datLoad your data
  2. Sestavování a výuka modeluBuild and train your model
  3. Vyhodnocení modeluEvaluate your model
  4. Použití modeluUse your model

PožadavkyPrerequisites

Vyberte příslušný úkol strojového učení.Select the appropriate machine learning task

Existuje několik způsobů, jak získat přístup k problémům s doporučeními, jako je například doporučený seznam filmů nebo doporučený seznam souvisejících produktů, ale v tomto případě budete předpovídat, jaké hodnocení (1-5) bude uživatel podávat konkrétnímu videu, a doporučit ho, pokud je vyšší než definovaná prahová hodnota (čím vyšší je hodnocení, tím větší je pravděpodobnost, že uživatel míru konkrétní film).There are several ways to approach recommendation problems, such as recommending a list of movies or recommending a list of related products, but in this case you will predict what rating (1-5) a user will give to a particular movie and recommend that movie if it's higher than a defined threshold (the higher the rating, the higher the likelihood of a user liking a particular movie).

Vytvoření konzolové aplikaceCreate a console application

Vytvoření projektuCreate a project

  1. Otevřete Visual Studio 2017.Open Visual Studio 2017. Z řádku nabídek vyberte soubor > Nový > projekt .Select File > New > Project from the menu bar. V dialogovém okně Nový projekt vyberte uzel C# vizuálu následovaný uzlem .NET Core .In the New Project dialog, select the Visual C# node followed by the .NET Core node. Pak vyberte šablonu projektu aplikace konzoly (.NET Core) .Then select the Console App (.NET Core) project template. Do textového pole název zadejte "MovieRecommender" a pak vyberte tlačítko OK .In the Name text box, type "MovieRecommender" and then select the OK button.

  2. Vytvořte v projektu adresář s názvem data pro uložení datové sady:Create a directory named Data in your project to store the data set:

    V Průzkumník řešeníklikněte pravým tlačítkem myši na projekt a vyberte Přidat > Nová složka.In Solution Explorer, right-click the project and select Add > New Folder. Zadejte "data" a stiskněte ENTER.Type "Data" and hit Enter.

  3. Nainstalujte balíčky NuGet Microsoft.ml a Microsoft. ml. doporučování :Install the Microsoft.ML and Microsoft.ML.Recommender NuGet Packages:

    V Průzkumník řešeníklikněte pravým tlačítkem na projekt a vyberte Spravovat balíčky NuGet.In Solution Explorer, right-click the project and select Manage NuGet Packages. Jako zdroj balíčku zvolte "nuget.org", vyberte kartu Procházet , vyhledejte Microsoft.ml, vyberte balíček v seznamu a klikněte na tlačítko nainstalovat .Choose "nuget.org" as the Package source, select the Browse tab, search for Microsoft.ML, select the package in the list, and select the Install button. Pokud souhlasíte s licenčními podmínkami pro uvedené balíčky, klikněte na tlačítko OK v dialogovém okně Náhled změn a potom v dialogovém okně pro přijetí licence vyberte tlačítko přijmout .Select the OK button on the Preview Changes dialog and then select the I Accept button on the License Acceptance dialog if you agree with the license terms for the packages listed. Opakujte tento postup pro Microsoft. ml. doporučujese.Repeat these steps for Microsoft.ML.Recommender.

  4. Do horní části souboru program.cs přidejte následující příkazy using:Add the following using statements at the top of your Program.cs file:

    using System;
    using System.IO;
    using Microsoft.ML;
    using Microsoft.ML.Trainers;
    

Stažení datDownload your data

  1. Stáhněte dvě datové sady a uložte je do složky dat , kterou jste vytvořili dříve:Download the two datasets and save them to the Data folder you previously created:

    • Klikněte pravým tlačítkem na Recommendation-ratings-Train. csv a vyberte Uložit odkaz (nebo cíl) jako...Right click on recommendation-ratings-train.csv and select "Save Link (or Target) As..."

    • Klikněte pravým tlačítkem na Recommendation-ratings-test. csv a vyberte Uložit odkaz (nebo cíl) jako...Right click on recommendation-ratings-test.csv and select "Save Link (or Target) As..."

      Nezapomeňte uložit * soubory. CSV do složky data nebo je po uložení jinam přesunout * soubory. CSV do složky data .Make sure you either save the *.csv files to the Data folder, or after you save it elsewhere, move the *.csv files to the Data folder.

  2. V Průzkumník řešení klikněte pravým tlačítkem na každý ze * souborů. csv a vyberte vlastnosti.In Solution Explorer, right-click each of the *.csv files and select Properties. V části Upřesnitzměňte hodnotu Kopírovat do výstupního adresáře na Kopírovat, pokud je novější.Under Advanced, change the value of Copy to Output Directory to Copy if newer.

    GIF uživatele, který vybírá kopii, pokud je novější v VS.

Načtení datLoad your data

Prvním krokem v procesu ML.NET je příprava a načtení modelu školení a testování dat.The first step in the ML.NET process is to prepare and load your model training and testing data.

Data hodnocení doporučení jsou rozdělená na Train a Test datové sady.The recommendation ratings data is split into Train and Test datasets. Data Train se používají k přizpůsobení modelu.The Train data is used to fit your model. Testová data se používají k zajištění předpovědi s vámi vyškolený model a vyhodnocení výkonu modelu.The Test data is used to make predictions with your trained model and evaluate model performance. Je běžné mít 80/20 rozdělení s Train a Test data.It's common to have an 80/20 split with Train and Test data.

Níže je zobrazená ukázka dat z vašich * souborů. CSV:Below is a preview of the data from your *.csv files:

Snímek obrazovky s náhledem datové sady CVS

V * soubory. csv existují čtyři sloupce:In the *.csv files, there are four columns:

  • userId
  • movieId
  • rating
  • timestamp

Ve službě Machine Learning se ve sloupcích, které se používají k vytvoření předpovědi, říká funkcea sloupec s vrácenou předpověď se nazývá popisek.In machine learning, the columns that are used to make a prediction are called Features, and the column with the returned prediction is called the Label.

Chcete odhadnout hodnocení filmů, takže sloupec hodnocení je Label.You want to predict movie ratings, so the rating column is the Label. Další tři sloupce, userId, movieId a timestamp, jsou všechny Features použity pro předpověď Label.The other three columns, userId, movieId, and timestamp are all Features used to predict the Label.

FunkceFeatures PopisekLabel
userId rating
movieId
timestamp

K tomu, abyste se rozhodli, které Features se používají k předpovídání Label.It's up to you to decide which Features are used to predict the Label. Můžete také použít metody, jako je například funkce permutace důležitost , k usnadnění výběru nejlepší Features.You can also use methods like permutation feature importance to help with selecting the best Features.

V takovém případě byste měli omezit timestamp sloupec jako Feature, protože časové razítko skutečně neovlivňuje způsob, jakým se uživatel podílí na videu, a proto by nemohl přispět k přesnější předpovědi:In this case, you should eliminate the timestamp column as a Feature because the timestamp does not really affect how a user rates a given movie and thus would not contribute to making a more accurate prediction:

FunkceFeatures PopisekLabel
userId rating
movieId

Dále musíte definovat datovou strukturu pro vstupní třídu.Next you must define your data structure for the input class.

Přidejte do projektu novou třídu:Add a new class to your project:

  1. V Průzkumník řešeníklikněte pravým tlačítkem myši na projekt a vyberte Přidat > Nová položka.In Solution Explorer, right-click the project, and then select Add > New Item.

  2. V dialogovém okně Přidat novou položkuvyberte třída a změňte pole název na MovieRatingData.cs.In the Add New Item dialog box, select Class and change the Name field to MovieRatingData.cs. Pak vyberte tlačítko Přidat .Then, select the Add button.

V editoru kódu se otevře soubor MovieRatingData.cs .The MovieRatingData.cs file opens in the code editor. Do horní části MovieRatingData.cspřidejte následující příkaz using:Add the following using statement to the top of MovieRatingData.cs:

using Microsoft.ML.Data;

Vytvořte třídu s názvem MovieRating odebráním existující definice třídy a přidáním následujícího kódu do MovieRatingData.cs:Create a class called MovieRating by removing the existing class definition and adding the following code in MovieRatingData.cs:

public class MovieRating
{
    [LoadColumn(0)]
    public float userId;
    [LoadColumn(1)]
    public float movieId;
    [LoadColumn(2)]
    public float Label;
}

MovieRating určuje vstupní datovou třídu.MovieRating specifies an input data class. Atribut LoadColumn určuje, které sloupce (podle indexu sloupce) v datové sadě by měly být načteny.The LoadColumn attribute specifies which columns (by column index) in the dataset should be loaded. Sloupce userId a movieId jsou vaše Features (vstupy, které model udělíte pro předpověď Label), a sloupec hodnocení je Label, který budete předpovídat (výstup modelu).The userId and movieId columns are your Features (the inputs you will give the model to predict the Label), and the rating column is the Label that you will predict (the output of the model).

Vytvořte další třídu, MovieRatingPrediction, která představuje předpovězené výsledky přidáním následujícího kódu za MovieRating třídy v MovieRatingData.cs:Create another class, MovieRatingPrediction, to represent predicted results by adding the following code after the MovieRating class in MovieRatingData.cs:

public class MovieRatingPrediction
{
    public float Label;
    public float Score;
}

V program.csnahraďte Console.WriteLine("Hello World!") následujícím kódem v rámci Main():In Program.cs, replace the Console.WriteLine("Hello World!") with the following code inside Main():

MLContext mlContext = new MLContext();

Třída MLContext je výchozím bodem pro všechny operace ml.NET a inicializuje se mlContext vytvoří nové prostředí ml.NET, které se dá sdílet napříč objekty pracovního postupu pro vytváření modelů.The MLContext class is a starting point for all ML.NET operations, and initializing mlContext creates a new ML.NET environment that can be shared across the model creation workflow objects. Je podobné, koncepčně, DBContext v Entity Framework.It's similar, conceptually, to DBContext in Entity Framework.

Po Main() vytvořit metodu nazvanou LoadData():After Main(), create a method called LoadData():

public static (IDataView training, IDataView test) LoadData(MLContext mlContext)
{

}

Poznámka

Tato metoda vám poskytne chybu, dokud nepřidáte příkaz return v následujících krocích.This method will give you an error until you add a return statement in the following steps.

Inicializujte proměnné cesty k datům, načtěte data ze souborů *. csv a vraťte Train a Test data jako objekty IDataView přidáním následujícího jako další řádek kódu v LoadData():Initialize your data path variables, load the data from the *.csv files, and return the Train and Test data as IDataView objects by adding the following as the next line of code in 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);

Data v ML.NET jsou reprezentována jako Třída IDataView.Data in ML.NET is represented as an IDataView class. IDataView je flexibilní a efektivní způsob, jak popsat tabulková data (číselná a text).IDataView is a flexible, efficient way of describing tabular data (numeric and text). Data je možné načíst z textového souboru nebo v reálném čase (například databáze SQL nebo soubory protokolu) do objektu IDataView.Data can be loaded from a text file or in real time (for example, SQL database or log files) to an IDataView object.

LoadFromTextFile () definuje schéma dat a čte data v souboru.The LoadFromTextFile() defines the data schema and reads in the file. Převezme proměnné cesty k datům a vrátí IDataView.It takes in the data path variables and returns an IDataView. V takovém případě zadáte cestu pro soubory Test a Train a naznačíte hlavičku textového souboru (aby bylo možné použít názvy sloupců správně) a oddělovač dat znaků čárky (výchozí oddělovač je karta).In this case, you provide the path for your Test and Train files and indicate both the text file header (so it can use the column names properly) and the comma character data separator (the default separator is a tab).

Do metody Main() přidejte následující kód, který volá metodu LoadData() a vrátí Train a Test data:Add the following code in the Main() method to call your LoadData() method and return the Train and Test data:

(IDataView trainingDataView, IDataView testDataView) = LoadData(mlContext);

Sestavování a výuka modeluBuild and train your model

Existují tři hlavní koncepty v ML.NET: data, transformátorya odhady.There are three major concepts in ML.NET: Data, Transformers, and Estimators.

Školicí algoritmy Machine Learning vyžadují data v určitém formátu.Machine learning training algorithms require data in a certain format. Transformers slouží k transformaci tabulkových dat do kompatibilního formátu.Transformers are used to transform tabular data to a compatible format.

Diagram toku dat transformátoru

Transformers vytvoříte v ML.NET vytvořením Estimators.You create Transformers in ML.NET by creating Estimators. Estimators přebírat data a vracet Transformers.Estimators take in data and return Transformers.

Diagram toku dat Estimator

Příkladem Estimator je algoritmus školení doporučení, který budete používat pro školení modelu.The recommendation training algorithm you will use for training your model is an example of an Estimator.

Sestavte Estimator pomocí následujících kroků:Build an Estimator with the following steps:

Vytvořte metodu BuildAndTrainModel() hned za metodou LoadData() pomocí následujícího kódu:Create the BuildAndTrainModel() method, just after the LoadData() method, using the following code:

public static ITransformer BuildAndTrainModel(MLContext mlContext, IDataView trainingDataView)
{

}

Poznámka

Tato metoda vám poskytne chybu, dokud nepřidáte příkaz return v následujících krocích.This method will give you an error until you add a return statement in the following steps.

Definujte transformace dat přidáním následujícího kódu do BuildAndTrainModel():Define the data transformations by adding the following code to BuildAndTrainModel():

IEstimator<ITransformer> estimator = mlContext.Transforms.Conversion.MapValueToKey(outputColumnName: "userIdEncoded", inputColumnName: "userId")
    .Append(mlContext.Transforms.Conversion.MapValueToKey(outputColumnName: "movieIdEncoded", inputColumnName: "movieId"));

Vzhledem k tomu, že userId a movieId reprezentují uživatelské a filmové tituly, ne reálné hodnoty, použijte metodu MapValueToKey () pro transformaci každého userId a každého movieId na typ číselného klíče Feature sloupec (formát přijatý algoritmy doporučení) a Přidejte je jako nové sloupce datové sady:Since userId and movieId represent users and movie titles, not real values, you use the MapValueToKey() method to transform each userId and each movieId into a numeric key type Feature column (a format accepted by recommendation algorithms) and add them as new dataset columns:

userIduserId movieIdmovieId PopisekLabel userIdEncodeduserIdEncoded movieIdEncodedmovieIdEncoded
první1 první1 44 userKey1userKey1 movieKey1movieKey1
první1 33 44 userKey1userKey1 movieKey2movieKey2
první1 66 44 userKey1userKey1 movieKey3movieKey3

Vyberte algoritmus strojového učení a přidejte ho k definicím transformace dat. Přidejte následující kód jako další řádek kódu v BuildAndTrainModel():Choose the machine learning algorithm and append it to the data transformation definitions by adding the following as the next line of code in 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 je váš školicí algoritmus pro doporučení.The MatrixFactorizationTrainer is your recommendation training algorithm. Vytváření matic je obvyklým přístupem k doporučením, když máte data o tom, jak uživatelé mají v minulosti hodnocené produkty, což je případ datových sad v tomto kurzu.Matrix Factorization is a common approach to recommendation when you have data on how users have rated products in the past, which is the case for the datasets in this tutorial. Existují i další algoritmy doporučení, pokud máte dostupná jiná data (Další informace najdete v části ostatní algoritmy doporučení níže).There are other recommendation algorithms for when you have different data available (see the Other recommendation algorithms section below to learn more).

V takovém případě používá algoritmus Matrix Factorization metodu nazvanou "filtrování spolupráce", což předpokládá, že pokud uživatel 1 má stejné stanovisko jako uživatel 2 k určitému problému, pak uživatel 1 je pravděpodobnější, že uživatel 2 má stejný způsob jako uživatel 2 o jiném problému.In this case, the Matrix Factorization algorithm uses a method called "collaborative filtering", which assumes that if User 1 has the same opinion as User 2 on a certain issue, then User 1 is more likely to feel the same way as User 2 about a different issue.

Například pokud uživatel 1 a uživatel 2 znamená filmy podobně, je pravděpodobnější, že uživatel 2 požívá film, který uživatel 1 sledoval a hodnotil vysoce:For instance, if User 1 and User 2 rate movies similarly, then User 2 is more likely to enjoy a movie that User 1 has watched and rated highly:

Incredibles 2 (2018) The Avengers (2012) Guardians of the Galaxy (2014)
Uživatel 1User 1 Sledovaný a nelíbí se filmWatched and liked movie Sledovaný a nelíbí se filmWatched and liked movie Sledovaný a nelíbí se filmWatched and liked movie
Uživatel 2User 2 Sledovaný a nelíbí se filmWatched and liked movie Sledovaný a nelíbí se filmWatched and liked movie Nesledováno – doporučit videoHas not watched -- RECOMMEND movie

Matrix Factorization Trainer má několik možností, které si můžete přečíst v části s parametry algoritmu níže.The Matrix Factorization trainer has several Options, which you can read more about in the Algorithm hyperparameters section below.

Přizpůsobit model na Trainá data a vrátit vyškolený model přidáním následujícího jako další řádek kódu v metodě BuildAndTrainModel():Fit the model to the Train data and return the trained model by adding the following as the next line of code in the BuildAndTrainModel() method:

Console.WriteLine("=============== Training the model ===============");
ITransformer model = trainerEstimator.Fit(trainingDataView);

return model;

Metoda přizpůsobení (): nahlaste svůj model pomocí poskytnuté datové sady školení.The Fit() method trains your model with the provided training dataset. Technicky, provádí Estimator definice pomocí transformace dat a použití školení a vrátí zpět školicí model, což je Transformer.Technically, it executes the Estimator definitions by transforming the data and applying the training, and it returns back the trained model, which is a Transformer.

Přidejte následující jako další řádek kódu v metodě Main() pro volání metody BuildAndTrainModel() a vraťte si školený model:Add the following as the next line of code in the Main() method to call your BuildAndTrainModel() method and return the trained model:

ITransformer model = BuildAndTrainModel(mlContext, trainingDataView);

Vyhodnocení modeluEvaluate your model

Jakmile svůj model provedete, použijte k vyhodnocení způsobu provádění modelu testovací data.Once you have trained your model, use your test data to evaluate how your model is performing.

Vytvořte metodu EvaluateModel() hned za metodou BuildAndTrainModel() pomocí následujícího kódu:Create the EvaluateModel() method, just after the BuildAndTrainModel() method, using the following code:

public static void EvaluateModel(MLContext mlContext, IDataView testDataView, ITransformer model)
{

}

Transformujte data Test přidáním následujícího kódu do EvaluateModel():Transform the Test data by adding the following code to EvaluateModel():

Console.WriteLine("=============== Evaluating the model ===============");
var prediction = model.Transform(testDataView);

Metoda Transforming () zpřístupňuje předpovědi pro více zadaných vstupních řádků testovací sady dat.The Transform() method makes predictions for multiple provided input rows of a test dataset.

Vyhodnoťte model přidáním následujícího jako další řádek kódu v metodě EvaluateModel():Evaluate the model by adding the following as the next line of code in the EvaluateModel() method:

var metrics = mlContext.Regression.Evaluate(prediction, labelColumnName: "Label", scoreColumnName: "Score");

Jakmile máte předpověď nastavenou, metoda Evaluate () posuzuje model, který porovnává předpovězené hodnoty se skutečným Labels v testovací sadě a vrací metriky, jak model provádí.Once you have the prediction set, the Evaluate() method assesses the model, which compares the predicted values with the actual Labels in the test dataset and returns metrics on how the model is performing.

Vytiskněte metriky vyhodnocení do konzoly přidáním následujícího jako další řádek kódu v metodě EvaluateModel():Print your evaluation metrics to the console by adding the following as the next line of code in the EvaluateModel() method:

Console.WriteLine("Root Mean Squared Error : " + metrics.RootMeanSquaredError.ToString());
Console.WriteLine("RSquared: " + metrics.RSquared.ToString());

Přidejte následující jako další řádek kódu v metodě Main() pro volání metody EvaluateModel():Add the following as the next line of code in the Main() method to call your EvaluateModel() method:

EvaluateModel(mlContext, testDataView, model);

Výstup by měl vypadat podobně jako v následujícím textu:The output so far should look similar to the following text:

=============== 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

V tomto výstupu existují 20 iterací.In this output, there are 20 iterations. V každé iteraci se míra chyb zmenší a konverguje blíž a blíže k hodnotě 0.In each iteration, the measure of error decreases and converges closer and closer to 0.

root of mean squared error (RMS nebo RMSE) slouží k měření rozdílů mezi předpovězenými hodnotami modelu a datovou datovou sadou pozorovaných hodnot.The root of mean squared error (RMS or RMSE) is used to measure the differences between the model predicted values and the test dataset observed values. Technicky je to druhá odmocnina průměru průměrných čtverců chyb.Technically it's the square root of the average of the squares of the errors. Čím nižší je, tím lepší je model.The lower it is, the better the model is.

R Squared určuje, jak dobře data vyhovují modelu.R Squared indicates how well data fits a model. Rozsah od 0 do 1.Ranges from 0 to 1. Hodnota 0 znamená, že data jsou náhodná nebo jinak nelze přizpůsobit modelu.A value of 0 means that the data is random or otherwise can't be fit to the model. Hodnota 1 znamená, že model přesně odpovídá datům.A value of 1 means that the model exactly matches the data. Požadujete, aby se skóre R Squared co nejblíže k 1.You want your R Squared score to be as close to 1 as possible.

Sestavování úspěšných modelů je iterativní proces.Building successful models is an iterative process. Tento model má počáteční nižší kvalitu, protože kurz používá pro zajištění rychlého školení modelů malé datové sady.This model has initial lower quality as the tutorial uses small datasets to provide quick model training. Pokud nejste spokojeni s kvalitou modelu, můžete se pokusit ho zlepšit poskytnutím větších školicích datových sad nebo výběrem různých školicích algoritmů s různými parametry Hyper-v pro každý algoritmus.If you aren't satisfied with the model quality, you can try to improve it by providing larger training datasets or by choosing different training algorithms with different hyper-parameters for each algorithm. Další informace najdete v části vylepšení modelu níže.For more information, check out the Improve your model section below.

Použití modeluUse your model

Nyní můžete použít svůj vycvičený model k vytvoření předpovědi pro nová data.Now you can use your trained model to make predictions on new data.

Vytvořte metodu UseModelForSinglePrediction() hned za metodou EvaluateModel() pomocí následujícího kódu:Create the UseModelForSinglePrediction() method, just after the EvaluateModel() method, using the following code:

public static void UseModelForSinglePrediction(MLContext mlContext, ITransformer model)
{

}

Pomocí PredictionEngine předpovědět hodnocení přidáním následujícího kódu do UseModelForSinglePrediction():Use the PredictionEngine to predict the rating by adding the following code to UseModelForSinglePrediction():

Console.WriteLine("=============== Making a prediction ===============");
var predictionEngine = mlContext.Model.CreatePredictionEngine<MovieRating, MovieRatingPrediction>(model);

PredictionEngine je praktické rozhraní API, které umožňuje provádět předpovědi pro jednu instanci dat.The PredictionEngine is a convenience API, which allows you to perform a prediction on a single instance of data. PredictionEngine není bezpečný pro přístup z více vláken.PredictionEngine is not thread-safe. Je přijatelné pro použití v prostředích s jedním vláknem nebo prototypem.It's acceptable to use in single-threaded or prototype environments. Pro zvýšení výkonu a bezpečnosti vláken v produkčních prostředích použijte službu PredictionEnginePool, která vytvoří ObjectPool objektů PredictionEngine pro použití v celé aplikaci.For improved performance and thread safety in production environments, use the PredictionEnginePool service, which creates an ObjectPool of PredictionEngine objects for use throughout your application. V této příručce najdete informace o tom, jak používat PredictionEnginePool ve ASP.NET corem webovém rozhraní API.See this guide on how to use PredictionEnginePool in an ASP.NET Core Web API.

Poznámka

rozšíření služby PredictionEnginePool je aktuálně ve verzi Preview.PredictionEnginePool service extension is currently in preview.

Vytvořte instanci MovieRating nazvanou testInput a předejte ji do modulu předpovědi přidáním následujícího jako další řádky kódu v metodě UseModelForSinglePrediction():Create an instance of MovieRating called testInput and pass it to the Prediction Engine by adding the following as the next lines of code in the UseModelForSinglePrediction() method:

var testInput = new MovieRating { userId = 6, movieId = 10 };

var movieRatingPrediction = predictionEngine.Predict(testInput);

Funkce prediktivní () provede předpověď na jeden sloupec dat.The Predict() function makes a prediction on a single column of data.

Pak můžete použít Score nebo předpovězené hodnocení, abyste zjistili, jestli chcete pro uživatele 6 doporučit video s movieId 10.You can then use the Score, or the predicted rating, to determine whether you want to recommend the movie with movieId 10 to user 6. Čím vyšší je Score, tím větší je pravděpodobnost, že uživatel míru konkrétní film.The higher the Score, the higher the likelihood of a user liking a particular movie. V takovém případě řekněme, že doporučujeme filmy s předpokládaným hodnocením > 3,5.In this case, let’s say that you recommend movies with a predicted rating of > 3.5.

Chcete-li vytisknout výsledky, přidejte následující jako další řádky kódu v metodě UseModelForSinglePrediction():To print the results, add the following as the next lines of code in the UseModelForSinglePrediction() method:

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);
}

Přidejte následující jako další řádek kódu v metodě Main() pro volání metody UseModelForSinglePrediction():Add the following as the next line of code in the Main() method to call your UseModelForSinglePrediction() method:

UseModelForSinglePrediction(mlContext, model);

Výstup této metody by měl vypadat podobně jako následující text:The output of this method should look similar to the following text:

=============== Making a prediction ===============
Movie 10 is recommended for user 6

Uložení modeluSave your model

Pokud chcete model použít k tomu, aby předpovědi aplikace pro koncové uživatele, musíte nejdřív model Uložit.To use your model to make predictions in end-user applications, you must first save the model.

Vytvořte metodu SaveModel() hned za metodou UseModelForSinglePrediction() pomocí následujícího kódu:Create the SaveModel() method, just after the UseModelForSinglePrediction() method, using the following code:

public static void SaveModel(MLContext mlContext, DataViewSchema trainingDataViewSchema, ITransformer model)
{

}

Uložte svůj vycvičený model přidáním následujícího kódu do metody SaveModel():Save your trained model by adding the following code in the SaveModel() method:

var modelPath = Path.Combine(Environment.CurrentDirectory, "Data", "MovieRecommenderModel.zip");

Console.WriteLine("=============== Saving the model to a file ===============");
mlContext.Model.Save(model, trainingDataViewSchema, modelPath);

Tato metoda uloží váš vyškolený model do souboru. zip (do složky "data"), který pak můžete použít v jiných aplikacích .NET k vytvoření předpovědi.This method saves your trained model to a .zip file (in the "Data" folder), which can then be used in other .NET applications to make predictions.

Přidejte následující jako další řádek kódu v metodě Main() pro volání metody SaveModel():Add the following as the next line of code in the Main() method to call your SaveModel() method:

SaveModel(mlContext, trainingDataView.Schema, model);

Použití uloženého modeluUse your saved model

Po uložení svého vyučeného modelu můžete model využívat v různých prostředích.Once you have saved your trained model, you can consume the model in different environments. Další informace o tom, jak zprovoznění model strojového učení v aplikacích, najdete v tématu ukládání a načítání školicích modelů.See Save and load trained models to learn how to operationalize a trained machine learning model in apps.

VýsledkyResults

Po provedení kroků uvedených výše spusťte konzolovou aplikaci (CTRL + F5).After following the steps above, run your console app (Ctrl + F5). Vaše výsledky z jedné předpovědi výše by měly být podobné následujícímu.Your results from the single prediction above should be similar to the following. Můžou se zobrazovat upozornění nebo zprávy o zpracování, ale tyto zprávy se z následujících výsledků odebraly z důvodu srozumitelnosti.You may see warnings or processing messages, but these messages have been removed from the following results for clarity.

=============== 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 ===============

Blahopřejeme!Congratulations! Teď jste úspěšně vytvořili model strojového učení pro doporučování filmů.You've now successfully built a machine learning model for recommending movies. Zdrojový kód pro tento kurz najdete v úložišti dotnet/Samples .You can find the source code for this tutorial at the dotnet/samples repository.

Vylepšení modeluImprove your model

Existuje několik způsobů, jak můžete zlepšit výkon modelu, abyste mohli získat přesnější předpovědi.There are several ways that you can improve the performance of your model so that you can get more accurate predictions.

DataData

Přidání dalších školicích dat, která mají dostatek ukázek pro každého uživatele a ID filmu, může pomoci zlepšit kvalitu modelu doporučení.Adding more training data that has enough samples for each user and movie id can help improve the quality of the recommendation model.

Mezi ověřováním je metoda pro vyhodnocování modelů, které náhodně rozdělí data do podmnožiny (místo extrakce testovacích dat z datové sady, jako jste to udělali v tomto kurzu), a jako testovací data převezme některé skupiny jako data výukového programu.Cross validation is a technique for evaluating models that randomly splits up data into subsets (instead of extracting out test data from the dataset like you did in this tutorial) and takes some of the groups as train data and some of the groups as test data. Tato metoda vykonává rozdělení výukového testu z hlediska kvality modelu.This method outperforms making a train-test split in terms of model quality.

FunkceFeatures

V tomto kurzu použijete jenom tři Features (user id, movie id a rating), které jsou k dispozici v datové sadě.In this tutorial, you only use the three Features (user id, movie id, and rating) that are provided by the dataset.

I když je to dobrý začátek, možná budete chtít přidat další atributy nebo Features (například věk, pohlaví, geografické umístění atd.), pokud jsou zahrnuté v datové sadě.While this is a good start, in reality you might want to add other attributes or Features (for example, age, gender, geo-location, etc.) if they are included in the dataset. Přidání dalších relevantních Features může pomoci zlepšit výkon vašeho modelu doporučení.Adding more relevant Features can help improve the performance of your recommendation model.

Pokud si nejste jistí, které Features můžou být pro úlohu strojového učení nejrelevantnější, můžete také využít důležitou funkcivýpočtu příspěvků funkcí (FCC) a permutace, která ml.NET poskytuje k tomu, co nejvíc nemonitorovaných Features.If you are unsure about which Features might be the most relevant for your machine learning task, you can also make use of Feature Contribution Calculation (FCC) and permutation feature importance, which ML.NET provides to discover the most influential Features.

Parametry algoritmuAlgorithm hyperparameters

I když ML.NET poskytuje dobré výchozí algoritmy pro školení, můžete ještě více ladit výkon změnou parametrůalgoritmu.While ML.NET provides good default training algorithms, you can further fine-tune performance by changing the algorithm's hyperparameters.

Pro Matrix Factorization můžete experimentovat s parametry, jako je NumberOfIterations a ApproximationRank , abyste viděli, jestli vám dává lepší výsledky.For Matrix Factorization, you can experiment with hyperparameters such as NumberOfIterations and ApproximationRank to see if that gives you better results.

Například v tomto kurzu jsou k disřadě možnosti algoritmu:For instance, in this tutorial the algorithm options are:

var options = new MatrixFactorizationTrainer.Options
{
    MatrixColumnIndexColumnName = "userIdEncoded",
    MatrixRowIndexColumnName = "movieIdEncoded",
    LabelColumnName = "Label",
    NumberOfIterations = 20,
    ApproximationRank = 100
};

Další algoritmy doporučeníOther Recommendation Algorithms

Algoritmus vyfaktoringu matice s filtrováním pro spolupráci je jediným řešením pro provádění doporučení filmu.The matrix factorization algorithm with collaborative filtering is only one approach for performing movie recommendations. V mnoha případech možná nemáte dostupná data hodnocení a k dispozici máte jenom historii filmů od uživatelů.In many cases, you may not have the ratings data available and only have movie history available from users. V jiných případech možná budete mít více než jenom data hodnocení uživatele.In other cases, you may have more than just the user’s rating data.

AlgoritmusAlgorithm ScénářScenario UkázkaSample
Faktor vytváření matic třídyOne Class Matrix Factorization Toto použijte, když máte jenom userId a movieId.Use this when you only have userId and movieId. Tento styl doporučení je založen na scénáři společného nákupu, nebo na produktech, které se často kupují, což znamená, že zákazníkům doporučí sadu produktů na základě vlastní historie nákupních objednávek.This style of recommendation is based upon the co-purchase scenario, or products frequently bought together, which means it will recommend to customers a set of products based upon their own purchase order history. > vyzkoušet>Try it out
Počítače pro vytváření faktoringu s podporou políField Aware Factorization Machines Použijte k tomu doporučení, když máte víc funkcí nad ID uživatele, productId a hodnocení (například popis produktu nebo cena produktu).Use this to make recommendations when you have more Features beyond userId, productId, and rating (such as product description or product price). Tato metoda také používá přístup pro filtrování spolupráce.This method also uses a collaborative filtering approach. > vyzkoušet>Try it out

Scénář nového uživateleNew user scenario

Jedním z běžných potíží při filtrování spolupráce je problém s studeným startem, který je v případě, že máte nového uživatele, který nemá žádná předchozí data pro vykreslování odvození z.One common problem in collaborative filtering is the cold start problem, which is when you have a new user with no previous data to draw inferences from. Tento problém se často vyřeší tím, že požádá nového uživatele, aby vytvořil profil a například rychlost, jakou videa viděli v minulosti.This problem is often solved by asking new users to create a profile and, for instance, rate movies they have seen in the past. I když tato metoda přináší uživateli určitou režii, poskytuje několik počátečních dat pro nové uživatele bez historie hodnocení.While this method puts some burden on the user, it provides some starting data for new users with no rating history.

ProstředkyResources

Data použitá v tomto kurzu jsou odvozena z datové sady MovieLens.The data used in this tutorial is derived from MovieLens Dataset.

Další krokyNext steps

V tomto kurzu jste zjistili, jak:In this tutorial, you learned how to:

  • Vyberte algoritmus strojového učení.Select a machine learning algorithm
  • Příprava a načtení datPrepare and load your data
  • Sestavování a výuka modeluBuild and train a model
  • Vyhodnocení modeluEvaluate a model
  • Nasazení a využití modeluDeploy and consume a model

Pokud se chcete dozvědět víc, přejděte k dalšímu kurzu.Advance to the next tutorial to learn more