Compartir a través de

Tutorial: Creación de un recomendador de películas mediante factorización matricial con ML.NET

  • Artículo

Este tutorial muestra cómo compilar una recomendación de películas con ML.NET en una consola de aplicación de .NET Core. Los pasos utilizan C# y Visual Studio 2019.

En este tutorial aprenderá a:

  • Seleccionar un algoritmo de Machine Learning
  • Preparar y cargar los datos
  • Compilar y entrenar un modelo
  • Evaluar un modelo
  • Implementar y consumir un modelo

Puede encontrar el código fuente para este tutorial en el repositorio dotnet/samples.

Flujo de trabajo del aprendizaje automático

Usará los pasos siguientes para realizar la tarea, así como cualquier otra tarea de ML.NET:

  1. Cargar los datos
  2. Compilar y entrenar el modelo
  3. Evaluar el modelo
  4. Usar el modelo

Requisitos previos

Seleccionar la tarea de aprendizaje automático adecuada

Hay varias maneras de enfocar los problemas vinculados a las recomendaciones, como recomendar una lista de películas o recomendar una lista de productos relacionados. En este caso, predecirá qué clasificación (de 1 a 5) asignará un usuario a una película concreta y recomendará esa película si es superior a un umbral definido (cuanto mayor sea la clasificación, más probable será que a un usuario le guste una película concreta).

Creación de una aplicación de consola

Crear un proyecto

  1. Cree una aplicación de consola en C# llamada "MovieRecommender". Haga clic en el botón Next (Siguiente).

  2. Seleccione .NET 6 como marco de trabajo que va a usarse. Haga clic en el botón Crear.

  3. Cree un directorio denominado Datos en el proyecto para almacenar el conjunto de datos:

    En el Explorador de soluciones, haga clic con el botón derecho en el proyecto y seleccione Agregar>Nueva carpeta. Escriba "Datos" y presione Entrar.

  4. Instale los paquetes NuGet Microsoft.ML y Microsoft.ML.Recommender:

    Nota

    En este ejemplo se usa la versión estable más reciente de los paquetes NuGet mencionados, a menos que se indique lo contrario.

    En el Explorador de soluciones, haga clic con el botón derecho en el proyecto y seleccione Administrar paquetes NuGet. Elija "nuget.org" como origen del paquete, seleccione la pestaña Examinar, busque Microsoft.ML, seleccione el paquete en la lista y seleccione el botón Instalar. Seleccione el botón Aceptar en el cuadro de diálogo Vista previa de cambios y, a continuación, seleccione el botón Acepto del cuadro de diálogo Aceptación de la licencia en caso de que esté de acuerdo con los términos de licencia de los paquetes mostrados. Repita estos pasos para Microsoft.ML.Recommender.

  5. Agregue las instrucciones using siguientes en la parte superior del archivo Program.cs:

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

Descarga de los datos

  1. Descargue los dos conjuntos de datos y guárdelos en la carpeta Datos que creó anteriormente:

    • Haga clic con el botón derecho en recommendation-ratings-train.csv y seleccione "Save Link (or Target) As…" ("Guardar vínculo (o destino) como…").

    • Haga clic con el botón derecho en recommendation-ratings-test.csv y seleccione "Save Link (or Target) As…" ("Guardar vínculo (o destino) como…").

      Asegúrese de guardar los archivos *.csv en la carpeta Datos. Si los guarda en otro lugar, recuerde que debe mover los archivos *.csv a la carpeta Datos.

  2. En el Explorador de soluciones, haga clic con el botón derecho en cada uno de los archivos *.csv y seleccione Propiedades. En Avanzadas, cambie el valor de Copiar en el directorio de salida por Copiar si es posterior.

    GIF de un usuario que selecciona Copiar si es posterior en VS.

Carga de los datos

El primer paso en el proceso de ML.NET consiste en preparar y cargar los datos de entrenamiento y prueba del modelo.

Los datos de las clasificaciones de recomendación se dividen en conjuntos de datos Train y Test. Los datos Train se usan para ajustar el modelo, mientras que los datos Test sirven para realizar predicciones con el modelo entrenado y evaluar el rendimiento del modelo. Los datos Train y Test suelen dividirse con una proporción de 80/20.

A continuación se muestra una vista previa de los datos de los archivos *.csv:

Captura de pantalla de la vista previa del conjunto de datos CSV.

En los archivos *.csv, hay cuatro columnas:

  • userId
  • movieId
  • rating
  • timestamp

En Machine Learning, las columnas que se usan para realizar una predicción se denominan Features (Características), mientras que la columna con la predicción devuelta recibe el nombre de Label (Etiqueta).

En su caso, quiere predecir clasificaciones de películas, por lo que la columna de clasificación es Label. Las otras tres columnas (userId, movieId y timestamp) son Features que se usan para predecir la Label.

Características Etiqueta
userId rating
movieId
timestamp

Usted decide qué Features se usan para predecir la Label. También puede usar métodos como la importancia de la característica de permutación para ayudar a seleccionar las mejores Features.

En este caso, debe eliminar la columna timestamp como Feature porque la marca de tiempo no afecta realmente a la manera en que un usuario clasifica una película determinada y, por tanto, no contribuye a realizar una predicción más exacta:

Características Etiqueta
userId rating
movieId

Después, debe definir la estructura de datos para la clase de entrada.

Agregue una nueva clase a su proyecto:

  1. En el Explorador de soluciones, haga clic con el botón derecho en el proyecto y seleccione Agregar > Nuevo elemento.

  2. En el cuadro de diálogo Agregar nuevo elemento, seleccione Clase y cambie el campo Nombre a MovieRatingData.cs. A continuación, seleccione el botón Agregar.

Se abre el archivo MovieRatingData.cs en el editor de código. Agregue la siguiente instrucción using a la parte superior de MovieRatingData.cs:

using Microsoft.ML.Data;

Cree una clase denominada MovieRating. Para ello, quite la definición de clase existente y agregue el siguiente código en MovieRatingData.cs:

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

MovieRating especifica una clase de datos de entrada. El atributo LoadColumn especifica qué columnas (por índice de columna) del conjunto de datos se deben cargar. Las columnas userId y movieId son las Features (las entradas que proporcionará al modelo para predecir la Label), y la columna de clasificación es la Label que predecirá (la salida del modelo).

Cree otra clase (MovieRatingPrediction) para representar los resultados predichos. Para ello, agregue el código siguiente después de la clase MovieRating en MovieRatingData.cs:

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

En Program.cs, reemplace Console.WriteLine("Hello World!") por el código siguiente:

MLContext mlContext = new MLContext();

La clase MLContext es un punto de partida para todas las operaciones de ML.NET. Al inicializar mlContext, se crea un entorno de ML.NET que se puede compartir entre los objetos del flujo de trabajo de creación de modelos. Como concepto, se parece a DBContext en Entity Framework.

En la parte inferior del archivo, cree un método llamado LoadData():

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

}

Nota

Este método generará un error hasta que agregue una instrucción return en los pasos siguientes.

Inicialice las variables de ruta de acceso de datos, cargue los datos de los archivos *.csv y devuelva los datos Train y Test como objetos IDataView. Para ello, agregue lo que se indica a continuación como la siguiente línea de código en 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);

Los datos de ML.NET se representan como una interfaz IDataView. IDataView es una manera flexible y eficiente de describir datos tabulares (numéricos y de texto). Los datos se pueden cargar desde un archivo de texto o en tiempo real (por ejemplo, archivos de registro o base de datos SQL) en un objeto IDataView.

LoadFromTextFile() define el esquema de datos y lee en el archivo. Toma las variables de ruta de acceso de datos y devuelve IDataView. En este caso, usted proporciona la ruta de acceso a los archivos Test y Train e indica el encabezado del archivo de texto (para que pueda usar correctamente los nombres de columna) y el separador de datos de caracteres de coma (el separador predeterminado es el tabulador).

Agregue el siguiente código para llamar al método LoadData() y devolver los datos de Train y Test:

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

Compilación y entrenamiento del modelo

Cree el método BuildAndTrainModel(), justo después del método LoadData(), mediante el código siguiente:

ITransformer BuildAndTrainModel(MLContext mlContext, IDataView trainingDataView)
{

}

Nota

Este método generará un error hasta que agregue una instrucción return en los pasos siguientes.

Defina las transformaciones de datos mediante la adición del código siguiente a BuildAndTrainModel():

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

Puesto que userId y movieId representan usuarios y títulos de películas, en lugar de valores reales, debe usar el método MapValueToKey() para transformar cada userId y movieId en una columna Feature de tipo de clave numérica (un formato que aceptan los algoritmos de recomendación) y agregarlos como nuevas columnas del conjunto de datos:

userId movieId Etiqueta userIdEncoded movieIdEncoded
1 1 4 userKey1 movieKey1
1 3 4 userKey1 movieKey2
1 6 4 userKey1 movieKey3

Elija el algoritmo de Machine Learning y anéxelo a las definiciones de transformación de datos. Para ello, agregue lo que se indica a continuación como la siguiente línea de código en 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 es el algoritmo de entrenamiento de recomendación. La factorización matricial es una manera común de enfocar la recomendación cuando se dispone de datos que muestran cómo los usuarios clasificaron anteriormente los productos, que es el caso de los conjuntos de datos de este tutorial. Existen otros algoritmos de recomendación para cuando se dispone de datos diferentes (vea más adelante la sección Otros algoritmos de recomendación para obtener más información).

En este caso, el algoritmo Matrix Factorization usa un método denominado "filtrado de colaboración", que presupone que si el Usuario 1 tiene la misma opinión que el Usuario 2 en un tema determinado, lo más probable es que el Usuario 1 piense lo mismo que el Usuario 2 sobre otro tema.

Por ejemplo, si el Usuario 1 y el Usuario 2 clasifican las películas de forma similar, lo más probable es que el Usuario 2 disfrute de una película que el Usuario 1 ha visto y ha clasificado con una puntuación alta:

Incredibles 2 (2018) The Avengers (2012) Guardians of the Galaxy (2014)
Usuario 1 Ha visto la película y le ha gustado Ha visto la película y le ha gustado Ha visto la película y le ha gustado
Usuario 2 Ha visto la película y le ha gustado Ha visto la película y le ha gustado No ha visto la película. RECOMENDARLA

El instructor Matrix Factorization tiene varias opciones, sobre las que puede informarse más adelante en la sección Hiperparámetros de algoritmo.

Ajuste el modelo a los datos Train y devuelva el modelo entrenado. Para ello, agregue lo que se indica a continuación como la siguiente línea de código en el método BuildAndTrainModel():

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

return model;

El método Fit() entrena el modelo con el conjunto de datos de entrenamiento proporcionado. Técnicamente, ejecuta las definiciones de Estimator, para lo que transforma los datos y aplica el entrenamiento, y devuelve el modelo entrenado, que es un Transformer.

Para obtener más información sobre el flujo de trabajo de entrenamiento de modelos en ML.NET, vea ¿Qué es ML.NET y cómo funciona?.

Agregue lo que se indica a continuación como la siguiente línea de código debajo del método LoadData() para llamar al método BuildAndTrainModel() y devolver el modelo entrenado:

ITransformer model = BuildAndTrainModel(mlContext, trainingDataView);

Evaluación del modelo

Una vez que haya entrenado el modelo, use los datos de prueba para evaluar el rendimiento del modelo.

Cree el método EvaluateModel(), justo después del método BuildAndTrainModel(), mediante el código siguiente:

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

}

Transforme los datos Test mediante la adición del código siguiente a EvaluateModel():

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

El método Transform() realiza predicciones para varias filas de entrada proporcionadas de un conjunto de datos de prueba.

Para evaluar el modelo, agregue lo que se indica a continuación como la siguiente línea de código en el método EvaluateModel():

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

Una vez que se ha establecido la predicción, el método Evaluate() valora el modelo, que compara los valores predichos con las Labels reales del conjunto de datos de prueba y devuelve métricas sobre el rendimiento del modelo.

Imprima las métricas de evaluación en la consola. Para ello, agregue lo que se indica a continuación como la siguiente línea de código en el método EvaluateModel():

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

Agregue lo que se indica a continuación como la siguiente línea de código debajo del método BuildAndTrainModel() para llamar al método EvaluateModel():

EvaluateModel(mlContext, testDataView, model);

Por el momento, la salida debe ser similar a la del texto siguiente:

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

En esta salida, hay 20 iteraciones. En cada iteración, la medida de error disminuye y converge cada vez más hacia 0.

El valor root of mean squared error (RMS o RMSE) se usa para medir las diferencias entre los valores previstos por un modelo y los valores observados en un conjunto de datos de prueba. Técnicamente, es la raíz cuadrada de la media de los cuadrados de los errores. Cuanto menor sea su valor, mejor será el modelo.

R Squared indica en qué grado los datos se ajustan a un modelo. Va de 0 a 1. Un valor de 0 significa que los datos son aleatorios o no pueden ajustarse al modelo. Un valor de 1 significa que el modelo coincide exactamente con los datos. Le interesa que la puntuación de R Squared esté lo más cerca posible de 1.

La creación de modelos correctos es un proceso iterativo. Este modelo tiene una calidad inicial más baja, ya que el tutorial utiliza pequeños conjuntos de datos para proporcionar un entrenamiento rápido del modelo. Si no está satisfecho con la calidad del modelo, puede intentar mejorarlo proporcionando conjuntos de datos de entrenamiento más grandes o eligiendo algoritmos de entrenamiento distintos con diferentes hiperparámetros para cada algoritmo. Para más información, revise la sección Mejora del modelo a continuación.

Uso del modelo

Ahora puede usar el modelo entrenado para realizar predicciones sobre datos nuevos.

Cree el método UseModelForSinglePrediction(), justo después del método EvaluateModel(), mediante el código siguiente:

void UseModelForSinglePrediction(MLContext mlContext, ITransformer model)
{

}

Use PredictionEngine para predecir la clasificación. Para ello, agregue el código siguiente a UseModelForSinglePrediction():

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

PredictionEngine es una API de conveniencia, que le permite realizar una predicción en una única instancia de datos. PredictionEngine no es seguro para subprocesos. Es aceptable usarlo en entornos de un solo subproceso o prototipo. Para mejorar el rendimiento y la seguridad para subprocesos en entornos de producción, use el servicio PredictionEnginePool, que crea un ObjectPool de objetos de PredictionEngine para su uso en toda la aplicación. Consulte esta guía sobre cómo usar PredictionEnginePool en una API web de ASP.NET Core.

Nota

La extensión del servicio PredictionEnginePool está actualmente en versión preliminar.

Cree una instancia de MovieRating denominada testInput y pásela al motor de predicción. Para ello, agregue lo que se indica a continuación como las siguientes líneas de código en el método UseModelForSinglePrediction():

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

var movieRatingPrediction = predictionEngine.Predict(testInput);

La función Predict() realiza una predicción en una sola columna de datos.

Después, puede usar Score, o la clasificación predicha, para determinar si quiere recomendar la película con el movieId 10 al usuario 6. Cuanto más alto sea Score, más probable será que a un usuario le guste una película concreta. En este caso, supongamos que recomienda películas con una clasificación predicha superior a 3,5.

Para imprimir los resultados, agregue lo que se indica a continuación como las siguientes líneas de código en el método 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);
}

Agregue lo que se indica a continuación como siguiente línea de código después de la llamada al método EvaluateModel() para llamar al método UseModelForSinglePrediction():

UseModelForSinglePrediction(mlContext, model);

La salida de este método debe ser similar a la del texto siguiente:

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

Guardado del modelo

Para usar el modelo con el objeto de realizar predicciones en aplicaciones de usuario final, primero debe guardarlo.

Cree el método SaveModel(), justo después del método UseModelForSinglePrediction(), mediante el código siguiente:

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

}

Para guardar el modelo entrenado, agregue el código siguiente en el método SaveModel():

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 el modelo entrenado en un archivo .zip (en la carpeta "Datos"), que puede usarse después en otras aplicaciones .NET para realizar predicciones.

Agregue lo que se indica a continuación como siguiente línea de código después de la llamada al método UseModelForSinglePrediction() para llamar al método SaveModel():

SaveModel(mlContext, trainingDataView.Schema, model);

Uso del modelo guardado

Una vez que haya guardado el modelo entrenado, puede usarlo en entornos diferentes. Consulte Guardar y cargar modelos entrenados para obtener información sobre cómo poner en marcha un modelo de aprendizaje automático entrenado en aplicaciones.

Resultados

Después de seguir los pasos anteriores, ejecute la aplicación de consola (CTRL + F5). Los resultados de la predicción anterior deben ser similares a lo que se indica a continuación. Es posible que vea advertencias o mensajes de procesamiento, si bien se han quitado de los resultados siguientes para mayor claridad.

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

¡Enhorabuena! Ha compilado correctamente un modelo de Machine Learning para la recomendación de películas. Puede encontrar el código fuente para este tutorial en el repositorio dotnet/samples.

Mejora del código

Hay varias maneras de mejorar el rendimiento del modelo para obtener predicciones más precisas.

Datos

El hecho de agregar más datos de entrenamiento con suficientes ejemplos para cada usuario e identificador de película puede ayudar a mejorar la calidad del modelo de recomendación.

La validación cruzada es una técnica para evaluar modelos que divide aleatoriamente los datos en subconjuntos (en lugar de extraer datos de prueba del conjunto de datos, como ha hecho en este tutorial) y toma algunos grupos como datos de entrenamiento y otros como datos de prueba. Este método supera en lo que respecta a la calidad del modelo la división en entrenamiento/prueba.

Características

En este tutorial, solo ha usado las tres Features (user id, movie id y rating) que proporciona el conjunto de datos.

Aunque es un buen comienzo, tal vez le interese agregar otros atributos o Features (por ejemplo, edad, sexo, ubicación geográfica, etc.) si se incluyen en el conjunto de datos. El hecho de agregar Features más pertinentes puede ayudar a mejorar el rendimiento del modelo de recomendación.

Si no está seguro de qué Features pueden ser más pertinentes para la tarea de aprendizaje automático, puede usar el Cálculo de la contribución de las características (FCC) y la importancia de la característica de permutación, que proporciona ML.NET para descubrir las Features más influyentes.

Hiperparámetros de algoritmo

Aunque ML.NET proporciona algoritmos de entrenamiento predeterminados de calidad, puede ajustar aún más el rendimiento si cambia los hiperparámetros del algoritmo.

Para Matrix Factorization, puede experimentar con hiperparámetros como NumberOfIterations y ApproximationRank para ver si así obtiene mejores resultados.

Por ejemplo, en este tutorial, las opciones de algoritmo son las siguientes:

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

Otros algoritmos de recomendación

El algoritmo de factorización matricial con filtrado de colaboración es solo un enfoque para realizar recomendaciones de películas. En muchos casos, es posible que no tenga a su disposición los datos de las clasificaciones y que solo cuente con el historial de películas de los usuarios. En otros casos, podría disponer de más datos que la clasificación del usuario.

Algoritmo Escenario Ejemplo
Factorización matricial de una clase Úselo cuando solo tenga los valores userId y movieId. Este tipo de recomendación se basa en el escenario de compra conjunta, es decir, en los productos que se suelen comprar juntos. Esto significa que se recomendará a los clientes un conjunto de productos en función de su propio historial de pedidos de compra. >Probarlo
Máquinas de factorización con reconocimiento de campo Úselo para realizar recomendaciones cuando disponga de más características que userId, productId y la clasificación (por ejemplo, la descripción o el precio del producto). Este método también usa un enfoque de filtrado de colaboración. >Probarlo

Escenario de nuevo usuario

Un problema común en el filtrado de colaboración es el "arranque en frío", que es cuando tiene un nuevo usuario sin ningún dato anterior a partir del cual pueda realizar inferencias. Por lo general, para solucionarlo se les pide a los nuevos usuarios que creen un perfil y, por ejemplo, clasifiquen películas que ya han visto. Aunque este método supone una relativa carga para el usuario, proporciona algunos datos iniciales para los usuarios nuevos que carecen de historial de clasificaciones.

Recursos

Los datos que se han usado en este tutorial se han tomado del conjunto de datos MovieLens.

Pasos siguientes

En este tutorial ha aprendido a:

  • Seleccionar un algoritmo de Machine Learning
  • Preparar y cargar los datos
  • Compilar y entrenar un modelo
  • Evaluar un modelo
  • Implementar y consumir un modelo

Siga con el siguiente tutorial para obtener más información

Análisis de sentimiento