NLP之统计机器学习中的协同推荐

这次通过一个实例来讲解一下协同推荐的问题。在实际生活中，我们会经常收到当当，卓马逊等购物网站发来的商品推荐邮件。很奇怪卓马逊是依据什么来给我发一些相关商品的推荐，但是今天我们就假定他是根据协同推荐的机制来实现这一功能的吧。

很多时候购物网站都是根据其他用户的评价给一个用户推荐商品或者图书等。很多购物网站都会有这种长尾效益，用户购买或者评价的商品都是少数，而大多数商品只是得到很少几个用户的评价。所以存在数据稀疏的问题。这里就叫“cold start”问题。SlopeOne算法可以用来解决这个问题，这个算法很简单，易于实现且效率较高。

SlopeOne的基本概念很简单，例如用户X,Y和A都对项目1打了分。同时用户X,Y还对项目2打了分，用户A对项目2可能会打多少分呢？如下表1-1

用户	对项目1的评分	对项目2的评分
X	5	3
Y	4	3
A	4	？

 

 

 

 

根据SlopeOne算法，应该是：4-（（5-3）+（4-3））/2=2.5.我想这个应该是很好理解的，实际上就是找到对项目1和项目2都打过分的用户，算出评分差的平均值，我们就可以推测出对项目1打过分的用户A对项目2的可能评分，并向用户A推荐新项目。这里可以看出SolpeOne有一个很大的优点，在有很少数据的时候也能得到一个相对准确的推荐，这一点可以解决“cold start”问题。当然，我们这里的情况是最简单的，根据项目1的评价估计项目2的评价，如果要根据好几个项目的评价来估计某一个项目的评价就要用到加权算法（weighted SolpeOne）。如果有100个用户对项目1和项目2做了评价，1000个用户对项目3和项目2也打了分。显然这两个的权重是不同的。我们的计算方法：（100*（rating 1 to 2）+1000*（rating 3 to 2））/（100+1000）

使用基于SolpeOne算法的推荐需要以下数据：

1）有一组用户

2）有一组项目（items），例如图书，商品等

3）用户对其中某些项目打分（rating）表达他们的喜好

SolpeOne算法要解决的问题是：对某个用户，已经知道他对其中一些项目的评价，向他推荐一些他还没有评分的项目，以增加销售机会。

一个推荐系统的实现包括以下三步：

1）计算出任意两个项目之间评分的差值

2）输入某个用户的评分记录，推算出对其他项目的可能评分值

3）根据评分的值排序，给出评分最高的项目列表

第一步：例如我们有三个用户和四个项目，用户打分的情况如表1-2

项目	用户1	用户2	用户3
Item1	5	4	4
Item2	4	5	4
Item3	4	3	N/A
Item4	N/A	5	5

 

 

 

 

在第一步中我们的工作就是计算出项目之间两两打分之差，计算出如下矩阵1-3

	Item1	Item2	Item3	Item4
Item1	N/A	0/3	2/2	-2/2
Item2	0/3	N/A	2/2	-1/2
Item3	-2/2	-2/2	N/A	-2/1
Item4	2/2	1/2	2/1	N/A

 

 

 

 

 

首先要定义一个数据结构来存储该矩阵中的每个打分情况：

public class Rating
{
  public float Vlaue {get; set;}
  public int Freq {get; set;}
  public float AverageValue  {
    get {return Value/Freq;}
    }
}

 用一个Dictionary来保存这个结果矩阵，Dictionary的key是Item1Id加上Item2Id,值是Rating：

    /************************************************************************/
    /* 评分差均值矩阵                                                                     */
    /************************************************************************/
    class RatingDifferenceCollection : Dictionary<string,Rating>
    {
        //获得评分差值矩阵中的key值
        private string GetKey(int Item1Id,int Item2Id)
        {
            //return Item1Id + "/" + Item2Id;
            //根据差异矩阵的对称性来简化存储
            return (Item1Id < Item2Id) ? Item1Id + "/" + Item2Id : Item2Id + "/" + Item1Id;
        }

        //判断矩阵中是否存在一对项目的评分差记录
        public bool Contains(int Item1Id,int Item2Id)
        {
            return this.Keys.Contains<string>(GetKey(Item1Id, Item2Id));
        }

        //获得评分差值矩阵中的Value值
        public Rating this[int Item1Id,int Item2Id]{
            get {
                return this[this.GetKey(Item1Id,Item2Id)];
            }
            set {
                this[this.GetKey(Item1Id, Item2Id)] = value;
            }
        }
    }

接下来实现slopeOne类。首先创建一个RatingDifferenceCollection来保存矩阵，还要创建HashSet来保持系统中总共有那些项目：

        //保存评分差异矩阵的字典
        public RatingDifferenceCollection _DiffMarix = new RatingDifferenceCollection();

        //系统中总共有多少项目
        public HashSet<int> _Items = new HashSet<int>();

public void AddUserRatings(IDictionary<int ,float> userRatings)来实现差异矩阵的构建。

第二步：输入某个用户的评分记录，推算出其对其他项目的可能评分值，实现如下

        //输入某个用户的评分记录，推算出对其他项目的可能评分值
        public IDictionary<int ,float> Predict (IDictionary<int ,float> userRatings)
        {
            Dictionary<int, float> Predictions = new Dictionary<int, float>();
            //遍历所有的项目
            foreach (var itemId in this._Items)
            {
                //如果是该用户已经评论过的项目，忽略它
                if (userRatings.Keys.Contains(itemId)) continue;

                Rating itemRating = new Rating();

                foreach (var userRating in userRatings)
                {
                    if (userRating.Key == itemId) continue;
                    int inputItemId = userRating.Key;
                    if(_DiffMarix.Contains(itemId,inputItemId))
                    {
                        //在差异矩阵中找到相应的项
                        Rating diff=_DiffMarix[itemId,inputItemId];
                        itemRating.Value += diff.Freq * (userRating.Value+diff.AverageValue*((itemId<inputItemId)? 1:-1));
                        itemRating.Freq += diff.Freq;
                    }
                }
                Predictions.Add(itemId,itemRating.AverageValue);
            }
            return Predictions;
        }

第三步就是测试了，根据对用户的评分推测来进行相应商品的推荐

            userRating = new Dictionary<int, float>();
            userRating.Add(1,5);
            userRating.Add(3,4);

            IDictionary<int, float> Predictions = test.Predict(userRating);
            foreach(var rating in Predictions)
            {
                Console.WriteLine("Item"+rating.Key+"Rating:"+rating.Value);
            }

输出：
Item2 Rating:5

Item4 Rating:6

因为矩阵的对称性，在代码中对差异矩阵的存储和相应评分项的存储都有所调整，这里不详细介绍了，完整的实现了一下这个算法，给出了一个Demo在附件中。