代码示例

让我们使用加仑公里数这个数据集，格式如下：

代码示例 - 图1

我会通过汽车的以下属性来判断它的加仑公里数：汽缸数、排气量、马力、重量、加速度。我将392条数据都存放在mpgData.txt文件中，并用下面这段Python代码将这些数据按层次等分成十份：

  1. # -*- coding: utf-8 -*-
  2. # 
  3. # 将数据等分成十份的示例代码
  5. import random
  7. def buckets(filename, bucketName, separator, classColumn):
  8.     """filename是源文件名
  9.     bucketName是十个目标文件的前缀名
  10.     separator是分隔符，如制表符、逗号等
  11.     classColumn是表示数据所属分类的那一列的序号"""
  13.     # 将数据分为10份
  14.     numberOfBuckets = 10
  15.     data = {}
  16.     # 读取数据，并按分类放置
  17.     with open(filename) as f:
  18.         lines = f.readlines()
  19.     for line in lines:
  20.         if separator != '\t':
  21.             line = line.replace(separator, '\t')
  22.         # 获取分类
  23.         category = line.split()[classColumn]
  24.         data.setdefault(category, [])
  25.         data[category].append(line)
  26.     # 初始化分桶
  27.     buckets = []
  28.     for i in range(numberOfBuckets):
  29.         buckets.append([])       
  30.     # 将各个类别的数据均匀地放置到桶中
  31.     for k in data.keys():
  32.         # 打乱分类顺序
  33.         random.shuffle(data[k])
  34.         bNum = 0
  35.         # 分桶
  36.         for item in data[k]:
  37.             buckets[bNum].append(item)
  38.             bNum = (bNum + 1) % numberOfBuckets
  40.     # 写入文件
  41.     for bNum in range(numberOfBuckets):
  42.         f = open("%s-%02i" % (bucketName, bNum + 1), 'w')
  43.         for item in buckets[bNum]:
  44.             f.write(item)
  45.         f.close()
  47. # 调用示例      
  48. buckets("pimaSmall.txt", 'pimaSmall',',',8)

执行这个程序后会生成10个文件：mpgData01、mpgData02等。

编程实践

你能否修改上一章的近邻算法程序，让test函数能够执行十折交叉验证？输出的结果应该是这样的：

代码示例 - 图2

解决方案

我们需要进行以下几步：

  • 修改初始化方法，只读取九个桶中的数据作为训练集；
  • 增加一个方法，从第十个桶中读取测试集；
  • 执行十折交叉验证。

下面我们分步来看：

  • 初始化方法__init__

__init__方法的签名会修改成以下形式：

  1. def __init__(self, bucketPrefix, testBucketNumber, dataFormat):

每个桶的文件名是mpgData-01、mpgData-02这样的形式，所以bucketPrefix就是“mpgData”。testBucketNumber是测试集所用的桶，如果是3，则分类器会使用1、2、4-9的桶进行训练。dataFormat用来指定数据集的格式，如：

  1. class    num    num    num    num    num    comment

意味着第一列是所属分类，后五列是特征值，最后一列是备注信息。

以下是初始化方法的示例代码：

  1. class Classifier:
  3.     def __init__(self, bucketPrefix, testBucketNumber, dataFormat):
  4.         """该分类器程序将从bucketPrefix指定的一系列文件中读取数据，
  5.         并留出testBucketNumber指定的桶来做测试集，其余的做训练集。
  6.         dataFormat用来表示数据的格式，如：
  7.         "class    num    num    num    num    num    comment"
  8.         """
  10.         self.medianAndDeviation = []
  12.         # 从文件中读取文件
  14.         self.format = dataFormat.strip().split('\t')
  15.         self.data = []
  16.         # 用1-10来标记桶
  17.         for i in range(1, 11):
  18.             # 判断该桶是否包含在训练集中
  19.             if i != testBucketNumber:
  20.                 filename = "%s-%02i" % (bucketPrefix, i)
  21.                 f = open(filename)
  22.                 lines = f.readlines()
  23.                 f.close()
  24.                 for line in lines[1:]:
  25.                     fields = line.strip().split('\t')
  26.                     ignore = []
  27.                     vector = []
  28.                     for i in range(len(fields)):
  29.                         if self.format[i] == 'num':
  30.                             vector.append(float(fields[i]))
  31.                         elif self.format[i] == 'comment':
  32.                             ignore.append(fields[i])
  33.                         elif self.format[i] == 'class':
  34.                             classification = fields[i]
  35.                     self.data.append((classification, vector, ignore))
  36.         self.rawData = list(self.data)
  37.         # 获取特征向量的长度
  38.         self.vlen = len(self.data[0][1])
  39.         # 标准化数据
  40.         for i in range(self.vlen):
  41.             self.normalizeColumn(i)
  • testBucket方法

下面的方法会使用一个桶的数据进行测试：

  1. def testBucket(self, bucketPrefix, bucketNumber):
  2.     """读取bucketPrefix-bucketNumber所指定的文件作为测试集"""
  4.     filename = "%s-%02i" % (bucketPrefix, bucketNumber)
  5.     f = open(filename)
  6.     lines = f.readlines()
  7.     totals = {}
  8.     f.close()
  9.     for line in lines:
  10.         data = line.strip().split('\t')
  11.         vector = []
  12.         classInColumn = -1
  13.         for i in range(len(self.format)):
  14.               if self.format[i] == 'num':
  15.                   vector.append(float(data[i]))
  16.               elif self.format[i] == 'class':
  17.                   classInColumn = i
  18.         theRealClass = data[classInColumn]
  19.         classifiedAs = self.classify(vector)
  20.         totals.setdefault(theRealClass, {})
  21.         totals[theRealClass].setdefault(classifiedAs, 0)
  22.         totals[theRealClass][classifiedAs] += 1
  23.     return totals

比如说bucketPrefix是mpgData，bucketNumber是3，那么程序会从mpgData-03中读取内容，作为测试集。这个方法会返回如下形式的结果：

  1. {'35': {'35': 1, '20': 1, '30': 1},
  2.  '40': {'30': 1},
  3.  '30': {'35': 3, '30': 1, '45': 1, '25': 1},
  4.  '15': {'20': 3, '15': 4, '10': 1},
  5.  '10': {'15': 1},
  6.  '20': {'15': 2, '20': 4, '30': 2, '25': 1},
  7.  '25': {'30': 5, '25': 3}}

这个字段的键表示真实类别。如第一行的35表示该行数据的真实类别是35加仑公里。这个键又对应一个字典，这个字典表示的是分类器所判断的类别，如：

  1. '15': {'20': 3, '15': 4, '10': 1},

其中的3表示有3条记录真实类别是15加仑公里，但被分类到了20加仑公里；4表示分类正确的记录数；1表示被分到10加仑公里的记录数。

  • 执行十折交叉验证

最后我们需要编写一段程序来执行十折交叉验证，也就是说要用不同的训练集和测试集来构建10个分类器。

  1. def tenfold(bucketPrefix, dataFormat):
  2.     results = {}
  3.     for i in range(1, 11):
  4.         c = Classifier(bucketPrefix, i, dataFormat)
  5.         t = c.testBucket(bucketPrefix, i)
  6.         for (key, value) in t.items():
  7.             results.setdefault(key, {})
  8.             for (ckey, cvalue) in value.items():
  9.                 results[key].setdefault(ckey, 0)
  10.                 results[key][ckey] += cvalue
  12.     # 输出结果
  13.     categories = list(results.keys())
  14.     categories.sort()
  15.     print(   "\n       Classified as: ")
  16.     header =    "        "
  17.     subheader = "      +"
  18.     for category in categories:
  19.         header += category + "   "
  20.         subheader += "----+"
  21.     print (header)
  22.     print (subheader)
  23.     total = 0.0
  24.     correct = 0.0
  25.     for category in categories:
  26.         row = category + "    |"
  27.         for c2 in categories:
  28.             if c2 in results[category]:
  29.                 count = results[category][c2]
  30.             else:
  31.                 count = 0
  32.             row += " %2i |" % count
  33.             total += count
  34.             if c2 == category:
  35.                 correct += count
  36.         print(row)
  37.     print(subheader)
  38.     print("\n%5.3f percent correct" %((correct * 100) / total))
  39.     print("total of %i instances" % total)
  41. # 调用方法
  42. tenfold("mpgData/mpgData", "class num num num num num comment")

执行结果如下：

  1.        Classified as: 
  2.         10   15   20   25   30   35   40   45   
  3.       +----+----+----+----+----+----+----+----+
  4. 10    |  3 | 10 |  0 |  0 |  0 |  0 |  0 |  0 |
  5. 15    |  3 | 68 | 14 |  1 |  0 |  0 |  0 |  0 |
  6. 20    |  0 | 14 | 66 |  9 |  5 |  1 |  1 |  0 |
  7. 25    |  0 |  1 | 14 | 35 | 21 |  6 |  1 |  1 |
  8. 30    |  0 |  1 |  3 | 17 | 21 | 14 |  5 |  2 |
  9. 35    |  0 |  0 |  2 |  8 |  9 | 14 |  4 |  1 |
  10. 40    |  0 |  0 |  1 |  0 |  5 |  5 |  0 |  0 |
  11. 45    |  0 |  0 |  0 |  2 |  1 |  1 |  0 |  2 |
  12.       +----+----+----+----+----+----+----+----+
  14. 53.316 percent correct
  15. total of 392 instances

可以在这里下载代码和数据集。