Tutorial: Criar um recomendador de filme usando a fatorização de matriz com ML.NET

Este tutorial mostra como criar um recomendador de filme com ML.NET em um aplicativo de console do .NET. As etapas usam C# e Visual Studio 2019.

Neste tutorial, você aprenderá como:

Você pode encontrar o código-fonte deste tutorial no repositório dotnet/samples .

Fluxo de trabalho de machine learning

Você usará as seguintes etapas para realizar sua tarefa, bem como qualquer outra tarefa ML.NET:

1. Carregar seus dados
2. Criar e treinar seu modelo
3. Avaliar seu modelo
4. Usar seu modelo

Pré-requisitos

• Visual Studio 2022 ou posterior.

Selecione a tarefa de machine learning apropriada

Há várias maneiras de abordar problemas de recomendação, como recomendar uma lista de filmes ou recomendar uma lista de produtos relacionados, mas nesse caso você preverá qual classificação (1-5) um usuário dará a um filme específico e recomendará esse filme se ele for maior que um limite definido (quanto maior a classificação, maior a probabilidade de um usuário gostar de um filme específico).

Criar um aplicativo de console

Criar um projeto

1. Crie um aplicativo de console C# chamado "MovieRecommender". Clique no botão Avançar.

2. Escolha .NET 8 como a estrutura a ser usada. Clique no botão Criar .

3. Crie um diretório chamado Dados em seu projeto para armazenar o conjunto de dados:

   No Gerenciador de Soluções, clique com o botão direito do mouse no projeto e selecione Adicionar>Nova Pasta. Digite "Dados" e selecione Enter.

4. Instale os pacotes NuGet Microsoft.ML e Microsoft.ML.Recommender

   Observação

   Este exemplo usa a versão estável mais recente dos pacotes NuGet mencionados, a menos que indicado de outra forma.

   No Gerenciador de Soluções, clique com o botão direito no projeto e escolha Gerenciar Pacotes NuGet. Escolha "nuget.org" como a origem do pacote, selecione a guia Procurar , pesquise Microsoft.ML, selecione o pacote na lista e selecione Instalar. Selecione o botão OK na caixa de diálogo Alterações de Visualização e, em seguida, selecione o botão I Accept na caixa de diálogo Aceitação da Licença se você concordar com os termos de licença dos pacotes listados. Repita estas etapas para Microsoft.ML.Recommender.

5. Adicione as seguintes using diretivas na parte superior do arquivo Program.cs :

   using Microsoft.ML;
   using Microsoft.ML.Trainers;
   using MovieRecommendation;
   

Baixe seus dados

1. Baixe os dois conjuntos de dados e salve-os na pasta Dados que você criou anteriormente:

   • Clique com o botão direito do mouse norecommendation-ratings-train.csv e selecione "Salvar Link (ou Destino) Como..."

   • Clique com o botão direito do mouse em recommendation-ratings-test.csv e selecione "Salvar Link (ou Destino) Como..."

     Salve os arquivos *.csv na pasta Dados ou, depois de salvá-lo em outro lugar, mova os arquivos *.csv para a pasta Dados .

2. No Gerenciador de Soluções, clique com o botão direito do mouse em cada um dos arquivos *.csv e selecione Propriedades. Em Avançado, altere o valor de Copiar para Diretório de Saída para Copiar se for mais recente.

   

Carregar seus dados

A primeira etapa no processo de ML.NET é preparar e carregar os dados de treinamento e teste do modelo.

Os dados de classificação de recomendação são divididos em conjuntos de dados Train e Test. Os Train dados são usados para se ajustar ao seu modelo. Os Test dados são usados para fazer previsões com seu modelo treinado e avaliar o desempenho do modelo. É comum ter uma divisão 80/20 e TrainTest dados.

Abaixo está uma visualização dos dados de seus arquivos *.csv:

Nos arquivos *.csv, há quatro colunas:

• userId
• movieId
• rating
• timestamp

No aprendizado de máquina, as colunas usadas para fazer uma previsão são chamadas de Recursos e a coluna com a previsão retornada é chamada de Rótulo.

Você deseja prever as classificações de filmes, então a coluna de classificação é a Label. As outras três colunas, userId, movieId, e timestamp são todos Features usados para prever o Label.

Cabe a você decidir quais Features são usados para prever o Label. Você também pode usar métodos como a importância do recurso de permutação para ajudar na seleção dos melhores Features.

Nesse caso, você deve eliminar a timestamp coluna como um Feature porque o carimbo de data/hora realmente não afeta como um usuário classifica um determinado filme e, portanto, não contribuiria para fazer uma previsão mais precisa:

Em seguida, você deve definir sua estrutura de dados para a classe de entrada.

Adicione uma nova classe ao seu projeto:

1. No Gerenciador de Soluções, clique com o botão direito do mouse no projeto e selecione Adicionar > Novo Item.

2. Na caixa de diálogo Adicionar Novo Item, selecione Classe e altere o campo Nome para MovieRatingData.cs. Em seguida, selecione Adicionar.

O arquivo MovieRatingData.cs é aberto no editor de código. Adicione a seguinte using diretiva à parte superior do MovieRatingData.cs:

using Microsoft.ML.Data;

Crie uma classe chamada MovieRating removendo a definição de classe existente e adicionando o seguinte código em MovieRatingData.cs:

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

MovieRating especifica uma classe de dados de entrada. O atributo LoadColumn especifica quais colunas (por índice de coluna) no conjunto de dados devem ser carregadas. As colunas userId e movieId são suas Features (entradas que você dará ao modelo para prever Label), e a coluna de avaliação é o Label que você deve prever (a saída do modelo).

Crie outra classe, MovieRatingPredictionpara representar os resultados previstos adicionando o seguinte código após a MovieRating classe em MovieRatingData.cs:

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

Em Program.cs, substitua o Console.WriteLine("Hello World!") código a seguir:

MLContext mlContext = new MLContext();

A classe MLContext é um ponto de partida para todas as operações de ML.NET e a inicialização mlContext cria um novo ambiente ML.NET que pode ser compartilhado entre os objetos de fluxo de trabalho de criação de modelo. É semelhante, conceitualmente, ao DBContext Entity Framework.

Na parte inferior do arquivo, crie um método chamado LoadData():

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

}

Inicialize suas variáveis de caminho de dados, carregue os dados dos arquivos *.csv e retorne os dados Train e Test como objetos IDataView adicionando o seguinte como a próxima linha de código em 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);

Os dados em ML.NET são representados como uma interface IDataView. IDataView é uma maneira flexível e eficiente de descrever dados tabulares (numérico e texto). Os dados podem ser carregados de um arquivo de texto ou em tempo real (por exemplo, banco de dados SQL ou arquivos de log) para um IDataView objeto.

O LoadFromTextFile() define o esquema de dados e as leituras no arquivo. Ele recebe as variáveis de caminho de dados e retorna um IDataView. Nesse caso, você fornece o caminho para seus arquivos Test e Train, e indica o cabeçalho do arquivo de texto (para que ele possa usar os nomes de coluna corretamente) e o separador de dados como caractere vírgula (o separador padrão é uma guia).

Adicione o seguinte código para chamar seu LoadData() método e retornar os Train dados e Test :

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

Criar e treinar seu modelo

Crie o BuildAndTrainModel() método, logo após o LoadData() método, usando o seguinte código:

ITransformer BuildAndTrainModel(MLContext mlContext, IDataView trainingDataView)
{

}

Defina as transformações de dados adicionando o seguinte código a BuildAndTrainModel():

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

Desde userId e movieId representam usuários e títulos de filme, não valores reais, você deve usar o método MapValueToKey() para transformar cada userId e cada movieId em uma coluna de tipo chave numérica Feature (um formato aceito por algoritmos de recomendação) e adicioná-las ao conjunto de dados como novas colunas.

Escolha o algoritmo de machine learning e acrescente-o às definições de transformação de dados adicionando o seguinte como a próxima linha de código em 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));

O MatrixFactorizationTrainer é seu algoritmo de treinamento de recomendação. A Fatoração de Matriz é uma abordagem comum de recomendação quando você tem dados sobre como os usuários classificaram produtos no passado, que é o caso dos conjuntos de dados neste tutorial. Há outros algoritmos de recomendação para quando você tiver dados diferentes disponíveis (consulte a seção Outros algoritmos de recomendação abaixo para saber mais).

Nesse caso, o Matrix Factorization algoritmo usa um método chamado "filtragem colaborativa", que pressupõe que, se o Usuário 1 tiver a mesma opinião que o Usuário 2 em um determinado problema, é mais provável que o Usuário 1 sinta o mesmo que o Usuário 2 sobre um problema diferente.

Por exemplo, se o Usuário 1 e o Usuário 2 avaliam filmes de forma semelhante, o Usuário 2 é mais propenso a desfrutar de um filme que o Usuário 1 assistiu e avaliou positivamente.

O Matrix Factorization treinador tem várias Opções, que você pode ler mais sobre na seção Hiperparâmetros de algoritmo abaixo .

Ajuste o modelo aos Train dados e retorne o modelo treinado adicionando o seguinte como a próxima linha de código no BuildAndTrainModel() método:

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

return model;

O método Fit() treina seu modelo com o conjunto de dados de treinamento fornecido. Tecnicamente, ele executa as Estimator definições transformando os dados e aplicando o treinamento e retornando o modelo treinado, que é um Transformer.

Para obter mais informações sobre o fluxo de trabalho de treinamento de modelo em ML.NET, consulte O que é ML.NET e como ele funciona?.

Adicione o seguinte como a próxima linha de código abaixo da chamada ao método para LoadData() chamar seu BuildAndTrainModel() método e retornar o modelo treinado:

ITransformer model = BuildAndTrainModel(mlContext, trainingDataView);

Avaliar o modelo

Depois de treinar seu modelo, use os dados de teste para avaliar o desempenho do modelo.

Crie o EvaluateModel() método, logo após o BuildAndTrainModel() método, usando o seguinte código:

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

}

Transforme os Test dados adicionando o seguinte código a EvaluateModel():

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

O método Transform() faz previsões para várias linhas de entrada fornecidas de um conjunto de dados de teste.

Avalie o modelo adicionando o seguinte como a próxima linha de código no EvaluateModel() método:

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

Depois que você tiver o conjunto de previsões, o método Evaluate() avaliará o modelo, que compara os valores previstos com o real Labels no conjunto de dados de teste e retorna métricas sobre como o modelo está sendo executado.

Imprima suas métricas de avaliação ao console adicionando o seguinte como a próxima linha de código no EvaluateModel() método:

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

Adicione o seguinte como a próxima linha de código abaixo da chamada ao método para BuildAndTrainModel() chamar seu EvaluateModel() método:

EvaluateModel(mlContext, testDataView, model);

O resultado até agora deve ser parecido com o seguinte texto:

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

Nesta saída, há 20 iterações. Em cada iteração, a medida de erro diminui e converge cada vez mais perto de 0.

O root of mean squared error (RMS ou RMSE) é usado para medir as diferenças entre os valores previstos do modelo e os valores observados do conjunto de dados de teste. Tecnicamente, é a raiz quadrada da média dos quadrados dos erros. Quanto menor for, melhor será o modelo.

R Squared indica o quão bem os dados se ajustam a um modelo. Varia de 0 a 1. Um valor de 0 significa que os dados são aleatórios ou não podem ser adequados ao modelo. Um valor de 1 significa que o modelo corresponde exatamente aos dados. Você quer que sua R Squared pontuação seja o mais próxima possível de 1.

A criação de modelos bem-sucedidos é um processo iterativo. Esse modelo tem menor qualidade inicial, pois o tutorial usa pequenos conjuntos de dados para fornecer treinamento rápido de modelo. Se você não estiver satisfeito com a qualidade do modelo, poderá tentar melhorá-lo fornecendo conjuntos de dados de treinamento maiores ou escolhendo algoritmos de treinamento diferentes com hipermetrâmetros diferentes para cada algoritmo. Para obter mais informações, confira a seção Melhorar seu modelo abaixo.

Usar seu modelo

Agora você pode usar seu modelo treinado para fazer previsões sobre novos dados.

Crie o UseModelForSinglePrediction() método, logo após o EvaluateModel() método, usando o seguinte código:

void UseModelForSinglePrediction(MLContext mlContext, ITransformer model)
{

}

Use a PredictionEngine para prever a classificação adicionando o seguinte código a UseModelForSinglePrediction():

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

O PredictionEngine é uma API de conveniência, que permite que você execute uma previsão em uma única instância de dados. PredictionEngine não é thread-safe. É aceitável usar em ambientes monothread ou de protótipo. Para melhorar o desempenho e a segurança de threads em ambientes de produção, use o PredictionEnginePool serviço, que cria um ObjectPool dos PredictionEngine objetos para uso em todo o aplicativo. Consulte este guia sobre como usar PredictionEnginePool em uma API Web do ASP.NET Core.

Crie uma instância de MovieRating chamada testInput e passe-a para o Mecanismo de Previsão adicionando o seguinte como as próximas linhas de código no UseModelForSinglePrediction() método:

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

var movieRatingPrediction = predictionEngine.Predict(testInput);

A função Predict() faz uma previsão em uma única coluna de dados.

Em seguida, você pode usar a Scoreclassificação , ou a classificação prevista, para determinar se deseja recomendar o filme com movieId 10 para o usuário 6. Quanto maior a Scoreprobabilidade de um usuário gostar de um filme específico. Nesse caso, digamos que você recomende filmes com uma classificação prevista de > 3,5.

Para imprimir os resultados, adicione o seguinte como as próximas linhas de código no UseModelForSinglePrediction() método:

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

Adicione o seguinte como a próxima linha de código após a chamada ao EvaluateModel() método para chamar seu UseModelForSinglePrediction() método:

UseModelForSinglePrediction(mlContext, model);

A saída desse método deve ser semelhante ao seguinte texto:

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

Salvar seu modelo

Para usar seu modelo para fazer previsões em aplicativos de usuário final, primeiro você deve salvar o modelo.

Crie o SaveModel() método, logo após o UseModelForSinglePrediction() método, usando o seguinte código:

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

}

Salve seu modelo treinado adicionando o seguinte código no SaveModel() método:

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

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

Esse método salva seu modelo treinado em um arquivo de .zip (na pasta "Dados"), que pode ser usado em outros aplicativos .NET para fazer previsões.

Adicione o seguinte como a próxima linha de código após a chamada ao UseModelForSinglePrediction() método para chamar seu SaveModel() método:

SaveModel(mlContext, trainingDataView.Schema, model);

Usar seu modelo salvo

Depois de salvar seu modelo treinado, você pode consumir o modelo em ambientes diferentes. Consulte Salvar e carregar modelos treinados para saber como operacionalizar um modelo de machine learning treinado em aplicativos.

Results

Depois de seguir as etapas acima, execute seu aplicativo de console (Ctrl + F5). Os resultados da previsão única acima devem ser semelhantes aos seguintes. Você pode ver avisos ou mensagens de processamento, mas essas mensagens foram removidas dos seguintes resultados para maior clareza.

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

Parabéns! Agora você criou com êxito um modelo de machine learning para recomendar filmes. Você pode encontrar o código-fonte deste tutorial no repositório dotnet/samples .

Melhorar o modelo

Há várias maneiras de melhorar o desempenho do modelo para que você possa obter previsões mais precisas.

Dados

Adicionar mais dados de treinamento que têm exemplos suficientes para cada ID de usuário e filme pode ajudar a melhorar a qualidade do modelo de recomendação.

A validação cruzada é uma técnica para avaliar modelos que dividem dados aleatoriamente em subconjuntos (em vez de extrair dados de teste do conjunto de dados como você fez neste tutorial) e usa alguns dos grupos como dados de treinamento e alguns dos grupos como dados de teste. Esse método supera a divisão de teste de treinamento em termos de qualidade do modelo.

Features

Neste tutorial, você usa apenas os três Features (user ide movie idrating) fornecidos pelo conjunto de dados.

Embora este seja um bom começo, na realidade, talvez você queira adicionar outros atributos ou Features (por exemplo, idade, sexo, localização geográfica etc.) se eles estiverem incluídos no conjunto de dados. Adicionar mais relevante Features pode ajudar a melhorar o desempenho do seu modelo de recomendação.

Se você não tiver certeza sobre qual Features pode ser a mais relevante para sua tarefa de aprendizado de máquina, também poderá usar o Cálculo de Contribuição de Características (FCC) e a importância da característica por permutação, que o ML.NET fornece para descobrir a mais influente Features.

Hiperparâmetros de algoritmo

Embora ML.NET forneça bons algoritmos de treinamento padrão, você pode ajustar ainda mais o desempenho alterando os hiperparâmetros do algoritmo.

Para Matrix Factorization, você pode experimentar hiperparâmetros como NumberOfIterations e ApproximationRank para ver se isso lhe dá melhores resultados.

Por exemplo, neste tutorial, as opções de algoritmo são:

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

Outros algoritmos de recomendação

O algoritmo de fatorização de matriz com filtragem colaborativa é apenas uma abordagem para executar recomendações de filmes. Em muitos casos, talvez você não tenha os dados de classificação disponíveis e tenha apenas o histórico de filmes disponível dos usuários. Em outros casos, você pode ter mais do que apenas os dados de classificação do usuário.

Novo cenário de usuário

Um problema comum na filtragem colaborativa é o problema de cold start, que ocorre quando você tem um novo usuário sem dados anteriores para inferir. Esse problema geralmente é resolvido solicitando que novos usuários criem um perfil e, por exemplo, classifiquem os filmes que eles viram no passado. Embora esse método coloque algum peso no usuário, ele fornece alguns dados iniciais para novos usuários sem histórico de classificação.

Recursos

Os dados usados neste tutorial são derivados do Conjunto de Dados MovieLens.

Próximas etapas

Neste tutorial, você aprendeu a:

Avançar para o próximo tutorial para saber mais