Tutorial: Criar um recomendador de filmes com a fatorização de matriz com ML.NET
Este tutorial mostra-lhe como criar um recomendador de filmes com ML.NET numa aplicação de consola .NET Core. Os passos utilizam C# e Visual Studio 2019.
Neste tutorial, ficará a saber como:
- Selecionar um algoritmo de machine learning
- Preparar e carregar os seus dados
- Criar e preparar um modelo
- Avaliar um modelo
- Implementar e consumir um modelo
Pode encontrar o código fonte deste tutorial no repositório dotnet/samples .
Fluxo de trabalho de machine learning
Irá utilizar os seguintes passos para realizar a sua tarefa, bem como qualquer outra tarefa ML.NET:
Pré-requisitos
Selecione a tarefa de machine learning adequada
Existem várias formas de abordar problemas de recomendação, tais como recomendar uma lista de filmes ou recomendar uma lista de produtos relacionados, mas neste caso irá prever a classificação (1-5) que um utilizador dará a um filme específico e recomendar que o filme seja superior a um limiar definido (quanto maior for a classificação, maior será a probabilidade de um utilizador gostar de um filme específico).
Criar uma aplicação de consola
Criar um projeto
Crie uma Aplicação de Consola C# denominada "MovieRecommender". Clique no botão Seguinte .
Selecione .NET 6 como a arquitetura a utilizar. Clique no botão Criar.
Crie um diretório com o nome Dados no projeto para armazenar o conjunto de dados:
No Explorador de Soluções, clique com o botão direito do rato no projeto e selecione Adicionar>Nova Pasta. Escreva "Dados" e prima Enter.
Instale os Pacotes NuGet Microsoft.ML e Microsoft.ML.Recommender :
Nota
Este exemplo utiliza a versão estável mais recente dos pacotes NuGet mencionados, salvo indicação em contrário.
No Explorador de Soluções, clique com o botão direito do rato no projeto e selecione Gerir Pacotes NuGet. Selecione "nuget.org" como origem do pacote, selecione o separador Procurar, procure Microsoft.ML, selecione o pacote na lista e selecione o botão Instalar . Selecione o botão OK na caixa de diálogo Pré-visualizar Alterações e, em seguida, selecione o botão Aceito na caixa de diálogo Aceitação da Licença se concordar com os termos de licenciamento dos pacotes listados. Repita estes passos para Microsoft.ML.Recommender.
Adicione as seguintes
usinginstruções na parte superior do ficheiro Program.cs :using Microsoft.ML; using Microsoft.ML.Trainers; using MovieRecommendation;
Transferir os seus dados
Transfira os dois conjuntos de dados e guarde-os na pasta Dados que criou anteriormente:
Clique com o botão direito do rato emrecommendation-ratings-train.csv e selecione "Guardar Ligação (ou Destino) Como..."
Clique com o botão direito do rato emrecommendation-ratings-test.csv e selecione "Guardar Ligação (ou Destino) Como..."
Certifique-se de que guarda os ficheiros *.csv na pasta Dados ou, depois de os guardar noutro local, mova os ficheiros *.csv para a pasta Dados .
No Explorador de Soluções, clique com o botão direito do rato em cada um dos ficheiros *.csv e selecione Propriedades. Em Avançadas, altere o valor de Copiar para Diretório de Saída para Copiar se for mais recente.
Carregar os seus dados
O primeiro passo no processo de ML.NET é preparar e carregar os dados de preparação e teste do modelo.
Os dados de classificações de recomendação são divididos em Train conjuntos de dados e Test . Os Train dados são utilizados para se ajustarem ao seu modelo. Os Test dados são utilizados para fazer predições com o modelo preparado e avaliar o desempenho do modelo. É comum ter uma divisão 80/20 com Train e Test dados.
Segue-se uma pré-visualização dos dados dos seus ficheiros *.csv:
Nos ficheiros *.csv, existem quatro colunas:
userIdmovieIdratingtimestamp
No machine learning, as colunas que são utilizadas para fazer uma predição são denominadas Funcionalidades e a coluna com a predição devolvida é denominada Etiqueta.
Quer prever classificações de filmes, para que a coluna de classificação seja .Label As outras três colunas, userId, movieIde timestamp são todas Features utilizadas para prever o Label.
| Funcionalidades | Etiqueta |
|---|---|
userId |
rating |
movieId |
|
timestamp |
Cabe-lhe a si decidir quais Features são os utilizados para prever o Label. Também pode utilizar métodos como a importância da funcionalidade de permutação para ajudar a selecionar o melhor Features.
Neste caso, deve eliminar a timestamp coluna como um Feature porque o carimbo de data/hora não afeta realmente a forma como um utilizador classifica um determinado filme e, portanto, não contribuiria para fazer uma predição mais precisa:
| Funcionalidades | Etiqueta |
|---|---|
userId |
rating |
movieId |
Em seguida, tem de definir a sua estrutura de dados para a classe de entrada.
Adicione uma nova classe ao seu projeto:
No Explorador de Soluções, clique com o botão direito do rato no projeto e, em seguida, selecione Adicionar > Novo Item.
Na caixa de diálogo Adicionar Novo Item, selecione Classe e altere o campo Nome para MovieRatingData.cs. Em seguida, selecione o botão Adicionar .
O ficheiro MovieRatingData.cs é aberto no editor de código. Adicione a seguinte using instrução à parte superior de 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 as colunas (por índice de coluna) no conjunto de dados que devem ser carregadas. As userId colunas e movieId são as suas Features (as entradas que vai dar ao modelo para prever o Label) e a coluna de classificação é a Label que irá prever (a saída do modelo).
Crie outra classe, MovieRatingPrediction, para representar os resultados previstos ao adicionar 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 pelo Console.WriteLine("Hello World!") seguinte código:
MLContext mlContext = new MLContext();
A classe MLContext é um ponto de partida para todas as operações de ML.NET e inicializar mlContext cria um novo ambiente de ML.NET que pode ser partilhado entre os objetos de fluxo de trabalho de criação de modelos. É semelhante, conceptualmente, a DBContext no Entity Framework.
Na parte inferior do ficheiro, crie um método chamado LoadData():
(IDataView training, IDataView test) LoadData(MLContext mlContext)
{
}
Nota
Este método irá apresentar-lhe um erro até adicionar uma instrução return nos passos seguintes.
Inicialize as variáveis do caminho de dados, carregue os dados dos ficheiros *.csv e devolva os Train dados e Test como IDataView objetos ao adicionar 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 no ML.NET são representados como uma interface IDataView. IDataView é uma forma flexível e eficiente de descrever dados tabulares (numéricos e texto). Os dados podem ser carregados a partir de um ficheiro de texto ou em tempo real (por exemplo, base de dados SQL ou ficheiros de registo) para um IDataView objeto.
LoadFromTextFile() define o esquema de dados e lê no ficheiro. Utiliza as variáveis de caminho de dados e devolve um IDataView. Neste caso, fornece o caminho para os seus Test ficheiros e Train indica o cabeçalho do ficheiro de texto (para que possa utilizar os nomes das colunas corretamente) e o separador de dados de carateres de vírgula (o separador predefinido é um separador).
Adicione o seguinte código para chamar o seu LoadData() método e devolver os Train dados e Test :
(IDataView trainingDataView, IDataView testDataView) = LoadData(mlContext);
Criar e preparar o modelo
Crie o BuildAndTrainModel() método logo após o LoadData() método, com o seguinte código:
ITransformer BuildAndTrainModel(MLContext mlContext, IDataView trainingDataView)
{
}
Nota
Este método irá apresentar-lhe um erro até adicionar uma instrução return nos passos seguintes.
Defina as transformações de dados ao adicionar 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"));
Uma userId vez que e movieId representa utilizadores e títulos de filmes, não valores reais, utiliza o método MapValueToKey() para transformar cada userIdmovieId um deles numa coluna de tipo Feature de chave numérica (um formato aceite por algoritmos de recomendação) e adicioná-los como novas colunas de conjuntos de dados:
| userId | movieId | Etiqueta | userIdEncoded | movieIdEncoded |
|---|---|---|---|---|
| 1 | 1 | 4 | userKey1 | movieKey1 |
| 1 | 3 | 4 | userKey1 | movieKey2 |
| 1 | 6 | 4 | userKey1 | movieKey3 |
Escolha o algoritmo de machine learning e acrescente-o às definições de transformação de dados ao adicionar 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));
MatrixFactorizationTrainer é o algoritmo de preparação de recomendações. A Fatorização de Matriz é uma abordagem comum à recomendação quando tem dados sobre como os utilizadores classificaram os produtos no passado, o que é o caso dos conjuntos de dados neste tutorial. Existem outros algoritmos de recomendação para quando tiver dados diferentes disponíveis (consulte a secção Outros algoritmos de recomendação abaixo para saber mais).
Neste caso, o Matrix Factorization algoritmo utiliza um método chamado "filtragem colaborativa", que pressupõe que se o Utilizador 1 tiver a mesma opinião que o Utilizador 2 sobre um determinado problema, é mais provável que o Utilizador 1 sinta o mesmo que o Utilizador 2 sobre um problema diferente.
Por exemplo, se o Utilizador 1 e o Utilizador 2 classificarem os filmes de forma semelhante, é mais provável que o Utilizador 2 desfrute de um filme que o Utilizador 1 tenha visto e classificado de forma alta:
Incredibles 2 (2018) |
The Avengers (2012) |
Guardians of the Galaxy (2014) |
|
|---|---|---|---|
| Utilizador 1 | Filme assistido e apreciado | Filme assistido e apreciado | Filme assistido e apreciado |
| Utilizador 2 | Filme assistido e apreciado | Filme assistido e apreciado | Não viu - FILME RECOMENDADO |
O Matrix Factorization formador tem várias Opções, sobre as quais pode ler mais na secção Hiperparâmetros de algoritmo abaixo.
Ajuste o modelo aos Train dados e devolva o modelo preparado ao adicionar 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() prepara o modelo com o conjunto de dados de preparação fornecido. Tecnicamente, executa as Estimator definições ao transformar os dados e aplicar a preparação, e devolve o modelo preparado, que é um Transformer.
Para obter mais informações sobre o fluxo de trabalho de preparação de modelos no ML.NET, consulte O que é ML.NET e como funciona?.
Adicione o seguinte como a próxima linha de código abaixo da chamada ao método para chamar o LoadData() seu BuildAndTrainModel() método e devolver o modelo preparado:
ITransformer model = BuildAndTrainModel(mlContext, trainingDataView);
Avaliar o modelo
Depois de preparar o modelo, utilize os dados de teste para avaliar o desempenho do modelo.
Crie o EvaluateModel() método logo após o BuildAndTrainModel() método, com o seguinte código:
void EvaluateModel(MLContext mlContext, IDataView testDataView, ITransformer model)
{
}
Transforme os Test dados ao adicionar o seguinte código a EvaluateModel():
Console.WriteLine("=============== Evaluating the model ===============");
var prediction = model.Transform(testDataView);
O método Transform() faz predições para várias linhas de entrada fornecidas de um conjunto de dados de teste.
Avalie o modelo ao adicionar o seguinte como a próxima linha de código no EvaluateModel() método :
var metrics = mlContext.Regression.Evaluate(prediction, labelColumnName: "Label", scoreColumnName: "Score");
Assim que tiver o conjunto de predição, o método Evaluate() avalia o modelo, que compara os valores previstos com os valores reais Labels no conjunto de dados de teste e devolve métricas sobre o desempenho do modelo.
Imprima as métricas de avaliação na consola ao adicionar 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 chamar o BuildAndTrainModel() seu EvaluateModel() método:
EvaluateModel(mlContext, testDataView, model);
O resultado até agora deverá ter um aspeto semelhante ao 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
Neste resultado, existem 20 iterações. Em cada iteração, a medida do erro diminui e converge cada vez mais perto de 0.
O root of mean squared error (RMS ou RMSE) é utilizado 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 mais baixo 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. Quer que a sua R Squared classificação seja o mais próxima possível de 1.
A criação de modelos com êxito é um processo iterativo. Este modelo tem uma qualidade inferior inicial, uma vez que o tutorial utiliza pequenos conjuntos de dados para fornecer preparação rápida de modelos. Se não estiver satisfeito com a qualidade do modelo, pode tentar melhorá-la ao fornecer conjuntos de dados de preparação maiores ou ao escolher diferentes algoritmos de preparação com diferentes hiperparâmetres para cada algoritmo. Para obter mais informações, consulte a secção Melhorar o modelo abaixo.
Utilizar o modelo
Agora, pode utilizar o modelo preparado para fazer predições sobre novos dados.
Crie o UseModelForSinglePrediction() método logo após o EvaluateModel() método, com o seguinte código:
void UseModelForSinglePrediction(MLContext mlContext, ITransformer model)
{
}
Utilize o PredictionEngine para prever a classificação ao adicionar o seguinte código a UseModelForSinglePrediction():
Console.WriteLine("=============== Making a prediction ===============");
var predictionEngine = mlContext.Model.CreatePredictionEngine<MovieRating, MovieRatingPrediction>(model);
PredictionEngine é uma API de conveniência, que lhe permite efetuar uma predição numa única instância de dados. PredictionEngine não é seguro para threads. É aceitável utilizar em ambientes de thread único ou protótipo. Para melhorar o desempenho e a segurança dos threads em ambientes de produção, utilize o PredictionEnginePool serviço, que cria um ObjectPool dos PredictionEngine objetos para utilização em toda a sua aplicação. Veja este guia sobre como utilizar PredictionEnginePool numa API Web ASP.NET Core.
Nota
PredictionEnginePool A extensão de serviço está atualmente em pré-visualização.
Crie uma instância chamada MovieRatingtestInput e transmita-a para o Motor de Predição ao adicionar o seguinte como as linhas de código seguintes no UseModelForSinglePrediction() método :
var testInput = new MovieRating { userId = 6, movieId = 10 };
var movieRatingPrediction = predictionEngine.Predict(testInput);
A função Predict() faz uma predição numa única coluna de dados.
Em seguida, pode utilizar a Score, ou a classificação prevista, para determinar se pretende recomendar o filme com movieId 10 para o utilizador 6. Quanto maior for o Score, maior é a probabilidade de um utilizador gostar de um filme específico. Neste caso, digamos que recomenda filmes com uma classificação prevista de > 3,5.
Para imprimir os resultados, adicione o seguinte como as linhas de código seguintes 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 método para chamar o EvaluateModel() seu UseModelForSinglePrediction() método:
UseModelForSinglePrediction(mlContext, model);
O resultado deste método deve ter um aspeto semelhante ao seguinte texto:
=============== Making a prediction ===============
Movie 10 is recommended for user 6
Guardar o modelo
Para utilizar o modelo para fazer predições em aplicações de utilizador final, primeiro tem de guardar o modelo.
Crie o SaveModel() método logo após o UseModelForSinglePrediction() método, com o seguinte código:
void SaveModel(MLContext mlContext, DataViewSchema trainingDataViewSchema, ITransformer model)
{
}
Guarde o modelo preparado ao adicionar 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);
Este método guarda o modelo preparado num ficheiro de .zip (na pasta "Dados"), que pode ser utilizado noutras aplicações .NET para fazer predições.
Adicione o seguinte como a próxima linha de código após a chamada ao método para chamar o UseModelForSinglePrediction() seu SaveModel() método:
SaveModel(mlContext, trainingDataView.Schema, model);
Utilizar o modelo guardado
Depois de guardar o modelo preparado, pode consumir o modelo em ambientes diferentes. Veja Guardar e carregar modelos preparados para saber como operacionalizar um modelo de machine learning preparado nas aplicações.
Resultados
Depois de seguir os passos acima, execute a aplicação de consola (Ctrl + F5). Os resultados da predição única acima devem ser semelhantes aos seguintes. Poderá ver avisos ou mensagens de processamento, mas estas 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! Criou com êxito um modelo de machine learning para recomendar filmes. Pode encontrar o código fonte deste tutorial no repositório dotnet/samples .
Melhore o seu modelo
Existem várias formas de melhorar o desempenho do modelo para que possa obter predições mais precisas.
Dados
Adicionar mais dados de preparação que tenham amostras suficientes para cada ID de utilizador 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 aleatoriamente dados em subconjuntos (em vez de extrair dados de teste do conjunto de dados como fez neste tutorial) e utiliza alguns dos grupos como dados de preparação e alguns dos grupos como dados de teste. Este método supera a divisão train-test em termos de qualidade de modelo.
Funcionalidades
Neste tutorial, só utiliza os três Features (user id, movie id, e rating) que são fornecidos pelo conjunto de dados.
Embora este seja um bom começo, na realidade poderá querer adicionar outros atributos ou Features (por exemplo, idade, sexo, localização geográfica, etc.) se estiverem incluídos no conjunto de dados. Adicionar mais relevante Features pode ajudar a melhorar o desempenho do modelo de recomendação.
Se não tiver a certeza sobre qual Features poderá ser a mais relevante para a sua tarefa de machine learning, também pode utilizar o Cálculo da Contribuição de Funcionalidades (FCC) e a importância da funcionalidade de permutação, que ML.NET fornece para descobrir o mais influente Features.
Hiperparâmetros de algoritmos
Embora ML.NET forneça bons algoritmos de preparação predefinidos, pode otimizar ainda mais o desempenho ao alterar os hiperparâmetros do algoritmo.
Para Matrix Factorization, pode experimentar com 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 realizar recomendações de filmes. Em muitos casos, pode não ter os dados de classificações disponíveis e ter apenas o histórico de filmes disponível dos utilizadores. Noutros casos, pode ter mais do que apenas os dados de classificação do utilizador.
| Algoritmo | Scenario | Sample |
|---|---|---|
| Factorização de Matriz de Uma Classe | Utilize isto quando tiver apenas userId e movieId. Este estilo de recomendação baseia-se no cenário de co-compra ou nos produtos comprados frequentemente em conjunto, o que significa que recomendará aos clientes um conjunto de produtos com base no seu próprio histórico de encomendas de compras. | >Experimente |
| Máquinas de Factorização com Deteção de Campos | Utilize esta opção para fazer recomendações quando tiver mais Funcionalidades para além do userId, productId e classificação (como a descrição do produto ou o preço do produto). Este método também utiliza uma abordagem de filtragem colaborativa. | >Experimente |
Novo cenário de utilizador
Um problema comum na filtragem colaborativa é o problema de arranque a frio, que é quando tem um novo utilizador sem dados anteriores para extrair inferências. Este problema é muitas vezes resolvido ao pedir aos novos utilizadores que criem um perfil e, por exemplo, classificam os filmes que viram no passado. Apesar de este método sobrecarregar o utilizador, fornece alguns dados iniciais para novos utilizadores sem histórico de classificações.
Recursos
Os dados utilizados neste tutorial derivam do Conjunto de Dados movieLens.
Passos seguintes
Neste tutorial, ficou a saber como:
- Selecionar um algoritmo de machine learning
- Preparar e carregar os seus dados
- Criar e preparar um modelo
- Avaliar um modelo
- Implementar e consumir um modelo
Avance para o tutorial seguinte para saber mais
