如何使用ML.NET构建推荐系统?

推荐系统无处不在,从 Netflix、谷歌、亚马逊到小型网店,都能看到它的身影。实际上,推荐系统可能是机器学习最成功的商业应用之一。它具备预测用户喜欢阅读、观看和购买什么的能力。推荐系统不仅对企业有益,对用户也是有益的。对用户而言,推荐系统提供了一种探索产品空间的方式;对企业而言,推荐系统提供了一种增加用户参与的方式,同时也能让企业对客户有更多的了解。本文中,我们将了解如何使用 ML.NET 来创建推荐系统。

本文主要包括以下五个部分:

  • 数据集和前提
  • 推荐系统的类型
  • 协同过滤直觉
  • 矩阵分解直觉
  • 用 ML.NET 实现

1. 数据集和前提

大家都喜欢 Netflix,其中一个原因就是他们的推荐做得很好,这家公司已经在推荐系统方面投入了大量资金。Netflix 因 “Netflix Prize”竞赛而闻名,工程师们在没有关于用户或电影的其他信息的情况下,根据先前的评级,试图预测用户对电影的评级,他们甚至提供了一个数据集,这个数据集包括 480189 个用户给 17770 部电影的 100480507 个评级。每个样本在数据集中被格式化为每组四个特征:用户 ID、电影 ID、评级、评级日期。用户 ID 和电影 ID 的特征是整数 ID,而评级则是从 1 到 5。这些数据看起来像这样:

本文的实现用 C# 语言完成,我们使用最新的 .NET 5,因此要确保你已安装此 SDK。若你正在使用 Visual Studio,则随附 16.8.3 版本。此外,确保你已安装下列软件包:

$ dotnet add package Microsoft.ML$ dotnet add package Microsoft.ML.Recommender

复制代码

你可以在 Package Manager Console 中执行相同操作:

Install-Package Microsoft.MLInstall-Package Microsoft.ML.Recommendation

复制代码

注意,这也会安装默认的 Microsoft .ML 包。你可以使用 Visual Studio 的 Manage NuGetPackage 选项来执行类似操作:

假如你想了解使用 ML.NET 进行机器学习的基本知识,请看这篇文章:《使用 ML.NET 进行机器学习:简介》(Machine Learning with ML.NET – Introduction)

2. 推荐系统的类型

如前所述,Netflix 的数据集包含用户如何为电影评级的信息。在此基础上,我们如何为该用户创建推荐呢?在推荐同类项目前,我们需要考虑用户看过的电影的一些特征并进行排名。此外,我们可以基于这些排名寻找相似用户,并推荐这些用户购买的项目。但这两个项目的相似意味着什么呢?用户之间的相似意味着什么呢?怎样用数学术语计算和表达这种相似呢?

针对这些问题,不同类型的推荐系统采用不同的方法。通常有四种推荐系统:

  • 基于内容的推荐系统:这种类型的推荐系统侧重于内容。也就是说,它们只使用项目的特征和信息,并在此基础上为用户创建推荐。它们忽略了其他用户的信息。
  • 协同过滤推荐系统:推荐系统最强大的地方在于,它们可以根据用户在特定平台上的行为,或者根据同一平台上其他用户的行为,来为用户推荐项目。举例来说,Netflix 会根据你以前看过的电视剧,在用户和你观看并喜欢相同内容的电视剧的基础上,为你推荐下一部精彩的电视剧。
  • 基于知识的推荐系统:这种类型的推荐系统使用明确的用户偏好、项目以及推荐标注知识。本例中,推荐系统询问用户的偏好,并基于这些反馈建立推荐。
  • 混合解决方案推荐系统:通常情况下,我们在一些定制的解决方案中使用所有类型的组合。

如果你想进一步了解这些系统的工作原理,请参阅这篇文章《推荐系统简介》(Introduction to Recommendation Systems)。在这三种类型中,前两种使用最频繁,也最受欢迎。在实践中,可能出现的情况是,我们创建了混合解决方案来实现更好的结果。

ML.NET 仅支持协同过滤,或者更确切地说:矩阵分解。因此,在本文中,我们将重点放在这种类型的推荐系统上。让我们进一步了解这些系统是如何在幕后运作的。

3. 协同过滤直觉

创建推荐系统的最流行的技术之一是协同过滤。不像基于内容的过滤,这种方法把用户和项目置于一个共同的嵌入空间中,沿着它们共有的维度(观看特征)。举例来说,让我们考虑两个 Netflix 用户及其对节目的评级。

在 TensorFlow 中,我们可以这样表示(别担心,我们不会研究 TensorFlow 的细节,只是举例说明):

users_tv_shows = tf.constant([                [10,  2,  0,  0, 0, 6],                [0, 1,  0,  2, 10, 0]],dtype=tf.float32)

复制代码

我们现在可以获取每个节目的特征,也就是这一类型的 k-hot 编码:

或者在 TensorFlow 中:

tv_shows_features = tf.constant([                [0, 0, 1, 0, 1],                [1, 0, 0, 0, 0],                [0, 1, 0, 1, 0],                [0, 0, 1, 0, 0],                [0, 1, 0, 0, 0]],dtype=tf.float32)

复制代码

这样就可以对这些矩阵进行简单的点乘,得到每个用户的相似度:

users_features = tf.matmul(users_tv_shows, tv_shows_features)users_features = users_features/tf.reduce_sum(users_features, axis=1, keepdims=True)
top_users_features = tf.nn.top_k(users_features, num_feats)[1]for i in range(num_users):    feature_names = [features[int(index)] for index in top_users_features[i]]    print('{}: {}'.format(users[i],feature_names))

复制代码

User1: ['Comedy', 'Drama', 'Sci-Fi', 'Action', 'Cartoon']User2: ['Comedy', 'Sci-Fi', 'Cartoon', 'Action', 'Drama']

复制代码

我们可以看到,这两个用户的首要特征是喜剧,这意味着他们喜欢相似的东西。我们在这里做了什么?我们不只是用所提到的流派来描述项目,而是用相同的术语来描述每个用户。比如,用户 1 的意思是她喜欢喜剧片 0.5,而他喜欢动作片 0.1。注意,如果我们将用户的嵌入矩阵与转置项目嵌入矩阵相乘,我们会重新创建用户 - 项目交互矩阵。现在,这对于用户和项目很少的简单例子来说效果很好。但是,当向系统添加更多项目和用户时,它就变得不可扩展了。另外,我们如何确定我们所选择的特征是否相关?假如存在一些我们无法识别的潜在特征呢?我们怎样才能找到正确的特征?要想解决这些问题,就需要先了解矩阵分解。

4. 矩阵分解直觉

我们提到,人为定义的项目和用户特征在整体上可能并不是最佳选择。幸好,这些嵌入可以从数据中学习。也就是说,我们不会手工地给项目和用户分配特征,而是用用户 - 项目交互矩阵来学习最佳因子分解的潜在因子。与之前的思维练习一样,这个过程会产生一个用户因子嵌入和项目因子嵌入矩阵。从技术上讲,我们对稀疏的用户 - 项目交互矩阵进行了压缩,提取了潜在因子(类似主成分分析)。这就是矩阵因子分解的意义所在,它能将一个矩阵因子分解成两个较小的矩阵,利用这些矩阵,我们可以重建原始矩阵:

你的内容放在这里,在模块内容设置中编辑或删除此文本。你还可以在模块的设计设置中对这个内容的各个方面进行样式化,甚至在模块的高级设置中将自定义 CSS 应用到这个文本。

像其他降维技术一样,潜在特征的数量也是一个超参数,我们可以对其进行调整,使其在信息压缩和重建误差之间取得平衡。我们有两种方法进行预测,可采用用户与项目因子的点积,或项目与用户因子的点积。矩阵分解法也可以帮助我们求解另一个问题。假设你的系统有数千个用户,你希望计算它们之间的相似性矩阵,这是一个相当大的矩阵,矩阵分解能为我们压缩这些信息。

4.1 矩阵分解算法

数年前,Netflix 举办了一场价值 100 万美元的推荐系统竞赛。目标是根据用户的评级来改进系统的准确性。获胜者使用了奇异值分解算法来获得最佳结果。这种算法现在仍然很流行。形式上,可以这样定义:

设 A 是一个 m×n 矩阵,则 A 的奇异值分解(Singular Value Decomposition,SVD)为:

其中 U 是 m×m 且正交,V 是 n×n 且正交,Σ 是一个 m×n 的对角矩阵,具有非负对角线项 σ1≥σ2≥--≥σp,p=min{m,n},称为 A 的奇异值。

另一种非常流行的算法是交替最小二乘法或 ALS 及其变体。正如它的名字一样,该算法在保持 V 不变的情况下交替求解 U,然后在保持 U 不变的情况下求解 V,仅适用于最小二乘问题。但是,因为它是专用的,ALS 可以并行化,所以算法非常快速。

它的一个变体是加权交替最小二乘法或 WALS。其区别在于处理缺失数据的方式。正如我们在以前的文章中多次提到的那样,推荐系统最大的敌人之一是稀疏数据。WALS 为特定项目增加权重,并使用这些权重向量,它们可以通过线性或指数缩放来规范行和 / 或列的频率。

在矩阵分解中,NMF 是另一种常用算法。它表示非负矩阵分解。该算法基于获取低秩表示的矩阵,它包含有非负或正元素。NMF 使用迭代过程来修改 U 和 V 的初始值,使其积接近 V。

5 用 ML.NET 实现

ML.NET 目前仅支持带有随机梯度下降的标准矩阵分解。正如我们稍后将看到的,MatrixFactorization Trainer 支持这一点。

5.1 高层架构

在深入研究这个实现之前,让我们先来考虑该实现的高层架构。正如之前的 ML.NET 指南一样,我们想要建立一个易于扩展的解决方案,并且我们能够轻易地扩展出 ML.NET 未来可能包含的新矩阵分解算法。本文所提供的解决方案是 Auto ML 的一种简单形式。下面显示了我们的解决方案的文件夹结构法:

Data 文件夹包含输入数据的 .csv,MachineLearning 文件夹包含我们使用算法所需的所有东西。可以这样表示架构概述:

该解决方案的核心是一个抽象的 TrainerBase 类。这个类位于 Common 文件夹中,其主要目标是规范整个过程的完成方式。这是一个处理数据和进行特征工程的类,此类还负责训练机器学习算法。实现这个抽象类的类位于 Trainers 文件夹中,在这里我们可以找到多个利用 ML.NET 算法的类,这些类定义了应该使用哪种算法。在这种特殊情况下,我们只有一个 Predictor,位于 Predictor 文件夹中。

5.2 数据模型

要从数据集中加载数据,并使用 ML.NET 算法,需要实现类来建模这些数据。在 Data 文件夹中可以找到两个文件:MovieRating 和 MovieRatingPredictions。MovieRating 类为输入数据建模,看起来如下所示:

using Microsoft.ML.Data;
namespace RecommendationSystem.MachineLearning.DataModels{    public class MovieRating    {        [LoadColumn(0)]         public int UserId;
        [LoadColumn(1)]         public int MovieId;
        [LoadColumn(2)]         public float Label;    }}

复制代码

正如你所看到的,我们不使用来自数据集的数据。

MovieRatingPredictions 类为输出数据建模:

namespace RecommendationSystem.MachineLearning.DataModels{    public class MovieRatingPrediction    {        public float Label;        public float Score;    }}

复制代码

5.3 TrainerBase 和 ITrainerBase

这个类是该实现的核心。从本质上讲,它有两个部分:一个是用于描述该类的接口;另一个是需要用具体实现重写的抽象类,不过,它实现了接口方法。下面是 ITrainerBase 的接口:

using Microsoft.ML.Data;
namespace RandomForestClassification.MachineLearning.Common{    public interface ITrainerBase    {        string Name { get; }        void Fit(string trainingFileName);        BinaryClassificationMetrics Evaluate();        void Save();    }}

复制代码

该接口由 TrainerBase 类实现。但是,它是抽象的,因为我们希望注入特定的算法:

using Microsoft.ML;using Microsoft.ML.Data;using Microsoft.ML.Trainers;using Microsoft.ML.Trainers.Recommender;using Microsoft.ML.Transforms;using RecommendationSystem.MachineLearning.DataModels;using System;using System.IO;
namespace RecommendationSystem.MachineLearning.Common{    /// <summary>    /// Base class for Trainers.    /// This class exposes methods for training, evaluating and saving ML Models.    /// </summary>    public abstract class TrainerBase : ITrainerBase    {        public string Name { get; protected set; }                protected static string ModelPath => Path.Combine(AppContext.BaseDirectory,                "recommender.mdl");
        protected readonly MLContext MlContext;
        protected DataOperationsCatalog.TrainTestData _dataSplit;        protected ITrainerEstimator<MatrixFactorizationPredictionTransformer,                                           MatrixFactorizationModelParameters> _model;        protected ITransformer _trainedModel;
        protected TrainerBase()        {            MlContext = new MLContext(111);        }
        /// <summary>        /// Train model on defined data.        /// </summary>        /// <param name="trainingFileName"></param>        public void Fit(string trainingFileName)        {            if (!File.Exists(trainingFileName))            {                throw new FileNotFoundException($"File {trainingFileName} doesn't exist.");            }
            _dataSplit = LoadAndPrepareData(trainingFileName);            var dataProcessPipeline = BuildDataProcessingPipeline();            var trainingPipeline = dataProcessPipeline.Append(_model);
            _trainedModel = trainingPipeline.Fit(_dataSplit.TrainSet);        }
        /// <summary>        /// Evaluate trained model.        /// </summary>        /// <returns>RegressionMetrics object.</returns>        public RegressionMetrics Evaluate()        {            var testSetTransform = _trainedModel.Transform(_dataSplit.TestSet);
            return MlContext.Regression.Evaluate(testSetTransform);        }
        /// <summary>        /// Save Model in the file.        /// </summary>        public void Save()        {            MlContext.Model.Save(_trainedModel, _dataSplit.TrainSet.Schema, ModelPath);        }
        /// <summary>        /// Feature engeneering and data pre-processing.        /// </summary>        /// <returns>Data Processing Pipeline.</returns>        private EstimatorChain<ValueToKeyMappingTransformer> BuildDataProcessingPipeline()        {            var dataProcessPipeline = MlContext.Transforms.Conversion.MapValueToKey(                    inputColumnName: "UserId",                    outputColumnName: "UserIdEncoded")                .Append(MlContext.Transforms.Conversion.MapValueToKey(                    inputColumnName: "MovieId",                    outputColumnName: "MovieIdEncoded"))                .AppendCacheCheckpoint(MlContext);
            return dataProcessPipeline;        }
        private DataOperationsCatalog.TrainTestData LoadAndPrepareData(string trainingFileName)        {            IDataView trainingDataView = MlContext.Data.LoadFromTextFile<MovieRating>                  (trainingFileName, hasHeader: true, separatorChar: ',');            return MlContext.Data.TrainTestSplit(trainingDataView, testFraction: 0.1);        }    }}

复制代码

这是一个大类,它控制着整个过程。我们把它拆开,看看它到底是怎么回事。首先,我们观察这个类的字段和属性:

public string Name { get; protected set; }                protected static string ModelPath => Path.Combine(AppContext.BaseDirectory,                 "recommender.mdl");
        protected readonly MLContext MlContext;
        protected DataOperationsCatalog.TrainTestData _dataSplit;        protected ITrainerEstimator<MatrixFactorizationPredictionTransformer,                                          MatrixFactorizationModelParameters> _model;        protected ITransformer _trainedModel;

复制代码

继承该属性的类使用 Name 属性为算法添加名称。ModelPath 字段用于定义模型训练完成后将其存储在何处。注意,文件名的扩展名是 .mdl。接下来是 MlContext,以便我们能够使用 ML.NET 的功能。不要忘记,这个类是一个单例,因此在我们的解决方案中只有一个。_dataSplit 字段包含加载的数据。该结构将数据分割成训练数据集和测试数据集。

子类将使用字段 _model。这些类定义了该字段中使用哪种机器学习算法。_trainedModel 字段是结果模型,应该对其进行评估和保存。从本质上讲,继承和实现此类的唯一工作是定义应该使用的算法,通过实例化作为 _model 的所需算法的对象。

现在让我们来探索 Fit() 方法:

public void Fit(string trainingFileName){  if (!File.Exists(trainingFileName))  {    throw new FileNotFoundException($"File {trainingFileName} doesn't exist.");  }
  _dataSplit = LoadAndPrepareData(trainingFileName);  var dataProcessPipeline = BuildDataProcessingPipeline();  var trainingPipeline = dataProcessPipeline.Append(_model);
  _trainedModel = trainingPipeline.Fit(_dataSplit.TrainSet);}

复制代码

这个方法是训练算法的蓝图。它接收 .csv 文件的路径作为输入参数。确定文件存在之后,我们使用私有方法 loadAndPrepareData。该方法将数据加载到内存中,并将其分割成两个数据集,即训练数据集和测试数据集。在 _dataSplit 中保存返回值,因为我们需要一个用于评估阶段的测试数据集。接着我们调用 BuildDataProcessingPipeline()。

这就是进行数据预处理和特征工程的方法。对于这些数据,无需做大量工作,我们只需通过以下方式对其进行编码:

 private EstimatorChain<ValueToKeyMappingTransformer> BuildDataProcessingPipeline()        {            var dataProcessPipeline = MlContext.Transforms.Conversion.MapValueToKey(                    inputColumnName: "UserId",                    outputColumnName: "UserIdEncoded")                .Append(MlContext.Transforms.Conversion.MapValueToKey(                    inputColumnName: "MovieId",                    outputColumnName: "MovieIdEncoded"))                .AppendCacheCheckpoint(MlContext);
            return dataProcessPipeline;        }

复制代码

接下来是 Evaluate() 方法:

public RegressionMetrics Evaluate(){  var testSetTransform = _trainedModel.Transform(_dataSplit.TestSet);
  return MlContext.Regression.Evaluate(testSetTransform);}

复制代码

通过使用 _trainedModel 和测试数据集创建 Transformer 对象是一种非常简单的方法。接着,利用 MlContext 来检索回归指标。最后,让我们看看 Save() 方法。

public void Save(){  MlContext.Model.Save(_trainedModel, _dataSplit.TrainSet.Schema, ModelPath);}

复制代码

这是另一个简单的方法,只是使用 MLContext 将模型保存到定义的路径中。

5.4 训练器

因为我们在 TrainerBase 类中完成了所有繁重的工作,所以唯一的 Trainer 类非常简单,只专注于 ML.NET 算法的实例化。下面看看 RandomForestTrainer 类:

using Microsoft.ML;using Microsoft.ML.Trainers.Recommender;using RecommendationSystem.MachineLearning.Common;
namespace RecommendationSystem.MachineLearning.Trainers{    /// <summary>    /// Class that uses Decision Tree algorithm.    /// </summary>    public sealed class MatrixFactorizationTrainer : TrainerBase    {        public MatrixFactorizationTrainer(int numberOfIterations,             int approximationRank,             double learningRate) : base()        {            Name = $"Matrix Factorization {numberOfIterations}-{approximationRank}";
            _model = MlContext.Recommendation().Trainers.MatrixFactorization(                                                      labelColumnName: "Label",                                                      matrixColumnIndexColumnName: "UserIdEncoded",                                                      matrixRowIndexColumnName: "MovieIdEncoded",                                                      approximationRank: approximationRank,                                                      learningRate: learningRate,                                                      numberOfIterations: numberOfIterations);        }    }}

复制代码

正如你所看到的那样,这个类非常简单。我们覆写了 Name 和 _model。在 Recommendation 扩展中使用 MatrixFactorization 类。注意,我们是如何使用这个算法所提供的一些超参数的。有了这个,我们可以做更多的实验。

5.5 预测器

Predictor 类用于加载保存的模型并运行一些预测。通常,这个类与训练器不是同一个微服务的一部分。我们通常有一个微服务来执行模型的训练。该模型被保存到文件中,其他模型从该文件加载该模型,并基于用户输入运行预测。该类看上去如下:

using RecommendationSystem.MachineLearning.DataModels;using Microsoft.ML;using System;using System.IO;
namespace RecommendationSystem.MachineLearning.Predictors{    /// <summary>    /// Loads Model from the file and makes predictions.    /// </summary>    public class Predictor    {        protected static string ModelPath => Path.Combine(AppContext.BaseDirectory,                "recommender.mdl");        private readonly MLContext _mlContext;
        private ITransformer _model;
        public Predictor()        {            _mlContext = new MLContext(111);        }
        /// <summary>        /// Runs prediction on new data.        /// </summary>        /// <param name="newSample">New data sample.</param>        /// <returns>Prediction object</returns>        public MovieRatingPrediction Predict(MovieRating newSample)        {            LoadModel();
            var predictionEngine = _mlContext.Model.CreatePredictionEngine<MovieRating,                                                                    MovieRatingPrediction>(_model);
            return predictionEngine.Predict(newSample);        }
        private void LoadModel()        {            if (!File.Exists(ModelPath))            {                throw new FileNotFoundException($"File {ModelPath} doesn't exist.");            }
            using (var stream = new FileStream(ModelPath, FileMode.Open, FileAccess.Read,                             FileShare.Read))            {                _model = _mlContext.Model.Load(stream, out _);            }
            if (_model == null)            {                throw new Exception($"Failed to load Model");            }        }    }}

复制代码

简单地说,模型是从已定义的文件加载,并预测新的样本。要做到这一点,我们需要创建 PredictionEngine 来执行此操作。

5.6 用法和结果

让我们把所有这些放在一起。

using RecommendationSystem.MachineLearning.Common;using RecommendationSystem.MachineLearning.DataModels;using RecommendationSystem.MachineLearning.Predictors;using RecommendationSystem.MachineLearning.Trainers;using System;using System.Collections.Generic;
namespace RecommendationSystem{    class Program    {        static void Main(string[] args)        {            var newSample = new MovieRating            {                UserId = 6,                MovieId = 11            };
            var trainers = new List<ITrainerBase>            {                new MatrixFactorizationTrainer(10, 50, 0.1),                new MatrixFactorizationTrainer(10, 50, 0.01),                new MatrixFactorizationTrainer(20, 100, 0.1),                new MatrixFactorizationTrainer(20, 100, 0.01),                new MatrixFactorizationTrainer(30, 100, 0.1),                new MatrixFactorizationTrainer(30, 100, 0.01)
            };
            trainers.ForEach(t => TrainEvaluatePredict(t, newSample));        }
        static void TrainEvaluatePredict(ITrainerBase trainer, MovieRating newSample)         {            Console.WriteLine("*******************************");            Console.WriteLine($"{ trainer.Name }");            Console.WriteLine("*******************************");
            trainer.Fit(".\\Data\\recommendation-ratings.csv");
            var modelMetrics = trainer.Evaluate();
            Console.WriteLine($"Loss Function: {modelMetrics.LossFunction:0.##}{Environment.NewLine}" +                              $"Mean Absolute Error: {modelMetrics.MeanAbsoluteError:#.##}{Environment.NewLine}" +                              $"Mean Squared Error: {modelMetrics.MeanSquaredError:#.##}{Environment.NewLine}" +                              $"RSquared: {modelMetrics.RSquared:0.##}{Environment.NewLine}" +                              $"Root Mean Squared Error: {modelMetrics.RootMeanSquaredError:#.##}");
            trainer.Save();
            var predictor = new Predictor();            var prediction = predictor.Predict(newSample);            Console.WriteLine("------------------------------");            Console.WriteLine($"Prediction: {prediction.Score:#.##}");            Console.WriteLine("------------------------------");        }    }}

复制代码

非 TrainEvaluatePredict() 方法在这里做的是重头戏。使用这个方法,我们可以注入继承 TrainerBase 类的一个实例,以及一个新的样本,以便进行预测。接着调用 Fit() 方法对算法进行训练,并调用 Evaluate() 方法、打印出指标。最后,我们保存该模型。这样做之后,我们创建一个 Predictor 的实例,用一个新的样本调用 Predict() 方法,并打印出预测结果。在 Main 中,我们创建一个训练器对象列表,然后在这些对象上调用 TrainEvaluatePredict。

我们根据这些超参数创建了算法列表中随机森林的一些变体。结果如下:

*******************************Matrix Factorization 10-50*******************************iter      tr_rmse          obj   0       1.4757   2.4739e+05   1       0.9161   1.2617e+05   2       0.8666   1.1798e+05   3       0.8409   1.1348e+05   4       0.8240   1.1079e+05   5       0.8100   1.0897e+05   6       0.7980   1.0736e+05   7       0.7847   1.0575e+05   8       0.7691   1.0405e+05   9       0.7549   1.0284e+05Loss Function: 0.77Mean Absolute Error: .68Mean Squared Error: .77RSquared: 0.29Root Mean Squared Error: .88------------------------------Prediction: 3.94------------------------------*******************************Matrix Factorization 10-50*******************************iter      tr_rmse          obj   0       3.1309   9.0205e+05   1       2.3707   5.4640e+05   2       1.7857   3.3435e+05   3       1.5459   2.6501e+05   4       1.4055   2.2888e+05   5       1.3103   2.0634e+05   6       1.2430   1.9129e+05   7       1.1902   1.8002e+05   8       1.1493   1.7159e+05   9       1.1185   1.6546e+05Loss Function: 1.27Mean Absolute Error: .89Mean Squared Error: 1.27RSquared: -0.17Root Mean Squared Error: 1.13------------------------------Prediction: 4.01------------------------------*******************************Matrix Factorization 20-100*******************************iter      tr_rmse          obj   0       1.5068   2.5551e+05   1       0.9232   1.2707e+05   2       0.8675   1.1773e+05   3       0.8426   1.1358e+05   4       0.8260   1.1082e+05   5       0.8116   1.0874e+05   6       0.7984   1.0705e+05   7       0.7849   1.0547e+05   8       0.7699   1.0374e+05   9       0.7556   1.0222e+05  10       0.7407   1.0084e+05  11       0.7252   9.9587e+04  12       0.7108   9.8130e+04  13       0.6962   9.6890e+04  14       0.6845   9.6048e+04  15       0.6718   9.4877e+04  16       0.6615   9.4167e+04  17       0.6510   9.3413e+04  18       0.6419   9.2767e+04  19       0.6322   9.1971e+04Loss Function: 0.75Mean Absolute Error: .67Mean Squared Error: .75RSquared: 0.31Root Mean Squared Error: .86------------------------------Prediction: 4.06------------------------------*******************************Matrix Factorization 20-100*******************************iter      tr_rmse          obj   0       3.1188   8.9340e+05   1       2.4196   5.6643e+05   2       1.8203   3.4467e+05   3       1.5710   2.7129e+05   4       1.4210   2.3212e+05   5       1.3245   2.0894e+05   6       1.2559   1.9343e+05   7       1.2024   1.8189e+05   8       1.1592   1.7289e+05   9       1.1247   1.6594e+05  10       1.0956   1.6027e+05  11       1.0717   1.5566e+05  12       1.0506   1.5171e+05  13       1.0326   1.4838e+05  14       1.0169   1.4550e+05  15       1.0032   1.4306e+05  16       0.9907   1.4085e+05  17       0.9798   1.3893e+05  18       0.9698   1.3718e+05  19       0.9610   1.3563e+05Loss Function: 0.99Mean Absolute Error: .78Mean Squared Error: .99RSquared: 0.09Root Mean Squared Error: .99------------------------------Prediction: 3.92------------------------------*******************************Matrix Factorization 30-100*******************************iter      tr_rmse          obj   0       1.4902   2.5094e+05   1       0.9364   1.2934e+05   2       0.8672   1.1737e+05   3       0.8428   1.1349e+05   4       0.8264   1.1104e+05   5       0.8114   1.0883e+05   6       0.7966   1.0681e+05   7       0.7836   1.0532e+05   8       0.7698   1.0378e+05   9       0.7540   1.0209e+05  10       0.7402   1.0089e+05  11       0.7248   9.9437e+04  12       0.7098   9.7999e+04  13       0.6966   9.6791e+04  14       0.6826   9.5745e+04  15       0.6687   9.4572e+04  16       0.6593   9.3841e+04  17       0.6480   9.3017e+04  18       0.6404   9.2448e+04  19       0.6321   9.1986e+04  20       0.6238   9.1298e+04  21       0.6160   9.0879e+04  22       0.6090   9.0430e+04  23       0.6025   9.0006e+04  24       0.5962   8.9550e+04  25       0.5909   8.9269e+04  26       0.5859   8.9011e+04  27       0.5809   8.8598e+04  28       0.5764   8.8393e+04  29       0.5714   8.8086e+04Loss Function: 0.74Mean Absolute Error: .67Mean Squared Error: .74RSquared: 0.32Root Mean Squared Error: .86------------------------------Prediction: 3.98------------------------------*******************************Matrix Factorization 30-100*******************************iter      tr_rmse          obj   0       3.1699   9.2239e+05   1       2.4110   5.6279e+05   2       1.8361   3.4988e+05   3       1.5652   2.6961e+05   4       1.4201   2.3188e+05   5       1.3248   2.0902e+05   6       1.2537   1.9291e+05   7       1.2017   1.8175e+05   8       1.1583   1.7271e+05   9       1.1237   1.6575e+05  10       1.0953   1.6017e+05  11       1.0711   1.5555e+05  12       1.0502   1.5162e+05  13       1.0324   1.4834e+05  14       1.0168   1.4549e+05  15       1.0036   1.4316e+05  16       0.9905   1.4080e+05  17       0.9795   1.3886e+05  18       0.9697   1.3715e+05  19       0.9607   1.3558e+05  20       0.9526   1.3418e+05  21       0.9452   1.3293e+05  22       0.9384   1.3175e+05  23       0.9322   1.3070e+05  24       0.9265   1.2976e+05  25       0.9211   1.2883e+05  26       0.9163   1.2802e+05  27       0.9118   1.2727e+05  28       0.9075   1.2653e+05  29       0.9036   1.2589e+05Loss Function: 0.9Mean Absolute Error: .74Mean Squared Error: .9RSquared: 0.17Root Mean Squared Error: .95------------------------------Prediction: 3.86------------------------------

复制代码

我们使用用户 ID-6 和电影 ID-11 进行测试。如果你看一下数据集,你会发现这一对和评级是 4。 正如你所看到的那样,大多数矩阵分解的变体都很好用。迭代 10 次,近似秩 50,学习率 0.01 的变化似乎最接近。而且,它的指标似乎也非常好。但是,还需要进一步的测试才能确定那种变体表现最佳。

结语

本文涉及了很多方面。我们了解了不同类型的推荐系,接着研究了协同过滤和矩阵分解。另外,我们也有机会了解如何将其应用于电影推荐。最终,我们使用 ML.NET 实现了这一切。

作者介绍:

Nikola M. Zivkovic,是 Rubik's Code 的首席人工智能官,也是《Deep Learning for Programmers》(尚无中译本)一书的作者。热爱知识分享,是一位经验丰富的演讲者,也是塞尔维亚诺维萨德大学的客座讲师。

原文链接:

https://rubikscode.net/2021/03/15/machine-learning-with-ml-net-recommendation-systems/

  • 发表于:
  • 本文为 InfoQ 中文站特供稿件
  • 首发地址https://www.infoq.cn/article/RriNk3hjlL9Keue6MRu0
  • 如有侵权,请联系 yunjia_community@tencent.com 删除。

扫码关注云+社区

领取腾讯云代金券