《集体智慧编程》读书笔记6

最近重读《集体智慧编程》，这本当年出版的介绍推荐系统的书，在当时看来很引领潮流，放眼现在已经成了各互联网公司必备的技术。 这次边阅读边尝试将书中的一些Python语言例子用C#来实现，利于自己理解，代码贴在文中方便各位园友学习。

由于本文可能涉及到的与原书版权问题，请第三方不要以任何形式转载，谢谢合作。

第六部分 决策树建模

这一部分我们继续介绍一种分类器算法 - 决策树学习。决策树产生的模型的最大特点就是可以很容易的看出推导分类的过程，甚至可以将其模型表示为if else语句。

预测注册用户

这个场景中我们要实现的功能是，通过用户的一系列行为预测用户成为付费用户，还是继续使用免费账号的可能性。 通过了解什么样的用户更会最终成为付费用户，网站可以更好的做推广或改善相关的功能。所以这就需要知道用户特征及行为和最终付费之间的关系，而决策树方法特有的易理解推导模型的特点恰恰非常适合这种场景。 假设我们收集到了如下信息，前4列是用户的特征及行为，最后一列是用户最终选择了什么服务，这也正式需要预测的内容。

来源网站	位置	是否阅读过FAQ	浏览网页数	选择服务类型
slashdot	USA	yes	18	None
google	France	yes	23	Premium
digg	USA	yes	24	Basic
kiwitobes	France	yes	23	Basic
google	UK	no	21	Premium
(direct)	New Zealand	no	12	None
(direct)	UK	no	21	Basic
google	USA	no	24	Premium
slashdot	France	yes	19	None
digg	USA	no	18	None
google	UK	no	18	None
kiwitobes	UK	no	19	None
digg	New Zealand	yes	12	Basic
slashdot	UK	no	21	None
google	UK	yes	18	Basic
kiwitobes	France	yes	19	Basic

我们在项目中添加一个TreePredict类并将这些数据添加到类中。

public class TreePredict
{
    public static List MyData = new List()
    {
        new object[]{"slashdot","USA","yes",18,"None"},
        new object[]{"google","France","yes",23,"Premium"},
        new object[]{"digg","USA","yes",24,"Basic"},
        new object[]{"kiwitobes","France","yes",23,"Basic"},
        new object[]{"google","UK","no",21,"Premium"},
        new object[]{"(direct)","New Zealand","no",12,"None"},
        new object[]{"(direct)","UK","no",21,"Basic"},
        new object[]{"google","USA","no",24,"Premium"},
        new object[]{"slashdot","France","yes",19,"None"},
        new object[]{"digg","USA","no",18,"None"},
        new object[]{"google","UK","no",18,"None"},
        new object[]{"kiwitobes","UK","no",19,"None"},
        new object[]{"digg","New Zealand","yes",12,"Basic"},
        new object[]{"slashdot","UK","no",21,"None"},
        new object[]{"google","UK","yes",18,"Basic"},
        new object[]{"kiwitobes","France","yes",19,"Basic"}
    };
}

实现决策树算法

新建一个名为DecisionNode的类表示决策树上的一个节点

public class DecisionNode
{
    public DecisionNode()
    {
    }

    public DecisionNode(int col, object value, DecisionNode tb, DecisionNode fb)
    {
        Col = col;
        Value = value;

        Tb = tb;
        Fb = fb;
    }

    public DecisionNode(Dictionary results)
    {
        Results = results;
    }

    public int Col { get; set; }
    public object Value { get; set; }
    public Dictionary Results { get; set; }
    public DecisionNode Tb { get; set; }
    public DecisionNode Fb { get; set; }
}

• Col表示这个节点判断条件对应的上面表格的列的索引
• Value 表示为了使判断条件为true，需要的值是多少
• Tb 当此节点验证结果为true时对应的子节点
• Fb 当此节点验证结果为false时对应的子节点
• Results 只有叶节点这个属性不为空，表示这个分支的结果

构造决策树的函数返回一个根节点，沿着按条件沿着根节点的Tb或Fb往下，最终可以得到结果。

训练决策树

这里训练决策树的算法名为CART(Classification and Regression Trees，即分类回归树)。 算法首先创建一个根节点，然后评估表中所有观测变量，从中选出最合适的变量对数据进行拆分。 函数DivideSet就是用于对数据进行拆分，其接受三个参数，第一个是数据列表，第二个是表示需要拆分的参考列在列表中位置的数字，最后一个是参考值。函数执行完成返回两个列表第一个是匹配参考值的所有记录，另一个是不匹配参考值的所有记录。 我们在类TreePredict中实现这个函数：

// 在某一列上对数据集合进行拆分，能处理数值型数据或名词性数据(字符串)
public Tuple, List> DivideSet(List rows, int column, object value)
{
    // 定义一个lambda用于判断记录应该归为第一组还是第二组（即匹配参考值还是不匹配）
    Func splitFunc = null;
    if (value is int)
        splitFunc = r => Convert.ToInt32(r[column]) >= Convert.ToInt32(value);
    else if (value is float)
        splitFunc = r => Convert.ToSingle(r[column]) >= Convert.ToSingle(value);
    else
        splitFunc = r => r[column].ToString() == value.ToString();

    // 将数据集拆分成两个集合并返回
    var set1 = rows.Where(r => splitFunc(r)).ToList();
    var set2 = rows.Where(r => !splitFunc(r)).ToList();
    return Tuple.Create(set1, set2);
}

函数中定义了名为splitFunc的lambda用于按照不同的类型对列值和参考值进行对比处理。

接着我们测试一下上面的函数，按照"是否阅读过FAQ"来对结果进行拆分：

var treePredict = new TreePredict();
var splitSet = treePredict.DivideSet(TreePredict.MyData, 2, "yes");
Action printRow = r => { Console.WriteLine($"{r[0]},{r[1]},{r[2]},{r[3]},{r[4]}"); };
Console.WriteLine("set1:");
splitSet.Item1.ForEach(r => printRow(r));
Console.WriteLine("set2:");
splitSet.Item2.ForEach(r => printRow(r));

拆分结果如下：

是否阅读过FAQ - True	是否阅读过FAQ - False
None	Premium
Premium	None
Basic	Basic
Basic	Premium
None	None
Basic	None
Basic	None

可以看到拆分的两个集合中不同的结果混在一起。这说明按照“是否阅读过FAQ”这个列来分类不合理。 所以需要找一种方法来确定使用哪个列来对数据表进行划分。

选择拆分方案

好的拆分方案得到的集合中，结果列的混杂程度应尽可能的小。 首先我们添加一个函数UniqueCounts到TreePredict对结果列进行计数：

// 对结果列（最后一列）进行计数
public Dictionary UniqueCounts(List rows)
{
    var results = new Dictionary();
    foreach (var row in rows)
    {
        // 计数结果在最后一列
        var r = row.Last().ToString();
        if (!results.ContainsKey(r))
            results.Add(r, 0);
        results[r] += 1;
    }
    return results;
}

这个函数的作用就是找出所有不同的结果，并对结果进行计数。这个结果将用于计算数据集合的混杂程度。 下面介绍两种度量混杂程度的算法：基尼不纯度(Giniimpurity)和熵(entropy)。

基尼不纯度

基尼不纯度是指将来自集合中某个值随机应用于集合中某一数据项的预期误差率。 假如集合中的每个数据都是同一分类，那么推测总是正确的，所以预期误差率总是为0。而如果有4种类别的数据且数量相等，则只有25%的概率推测正确，所以误差率为75%。 在TreePredict中添加基尼不纯度的计算方法GiniImpurity：

// 随机放置的数据项出现于错误分类中的概率
public float GiniImpurity(List rows)
{
    var total = rows.Count;
    var counts = UniqueCounts(rows);
    var imp = 0f;
    foreach (var k1 in counts.Keys)
    {
        var p1 = counts[k1] / (float)total;
        foreach (var k2 in counts.Keys)
        {
            if (k1 == k2)
                continue;
            var p2 = counts[k2] / (float)total;
            imp += p1 * p2;
        }
    }
    return imp;
}

这个函数累加了某一行数据被随机分配到错误结果的概率，得到总概率。 这个概率越高说明数据拆分越不理想，而0说明每一行数据都被分到正确的集合中。

熵

熵在信息理论中用于表示集合的无序程度，和这里要求的混杂程度很类似。 将计算熵的Entropy方法加入到TreePredict中：

// 熵是遍历所有可能结果之后所得到的p(x)log(p(x))之和
public float Entropy(List rows)
{
    Func log2 = x => (float)(Math.Log(x) / Math.Log(2));
    var results = UniqueCounts(rows);
    // 开始计算熵值
    var ent = 0f;
    foreach (var r in results.Keys)
    {
        var p = results[r] / (float)rows.Count;
        ent -= p * log2(p);
    }
    return ent;
}

如果所有结果都相同，上面方法计算的熵为0，而如果数据集越是混乱，相应熵就越高。我们的目标就是拆分数据集并降低熵。

我们通过下面的代码测试基尼不纯度和熵的计算：

var treePredict = new TreePredict();
var gini = treePredict.GiniImpurity(TreePredict.MyData);
Console.WriteLine(gini);
var entr = treePredict.Entropy(TreePredict.MyData);
Console.WriteLine(entr);
var setTuple = treePredict.DivideSet(TreePredict.MyData, 2, "yes");
gini = treePredict.GiniImpurity(setTuple.Item1);
Console.WriteLine(gini);
entr = treePredict.Entropy(setTuple.Item1);
Console.WriteLine(entr);

在现实中熵的使用更为普遍，后文将以熵作为度量混杂程度的标准。

递归方式构造决策树

有了判断集合混杂度的方法，我们可以通过计算群组拆分后熵的信息增益来判断拆分的好坏。 信息增益是指整个群组的熵与拆分后两个新群组的熵的加权平均值之间的差。差值即信息增益越大说明拆分效果越好。我们在每个列上都进行拆分尝试并计算信息增益，最终找出信息增益最大的列。 对于新得到的子集合，如果子集合可以继续拆分（如结果有不同值存在才有必要继续拆分），将在其上继续这个拆分过程直到信息增益为0。 我们在TreePredict添加一个递归函数BuildTree来实现这个递归构建树的过程。

public DecisionNode BuildTree(List rows, Func, float> scoref = null)
{
    if (scoref == null)
        scoref = Entropy;
    var rowsCount = rows.Count;
    if (rowsCount == 0) return new DecisionNode();
    var currentScore = scoref(rows);

    //定义一些变量记录最佳拆分条见
    var bestGain = 0f;
    Tuple bestCriteria = null;
    Tuple, List> bestSets = null;

    var columnCount = rows[0].Length - 1;
    for (int i = 0; i < columnCount; i++)
    {
        // 在当前列中生成一个由不同值构成的序列
        var columnValues = new List