• 代码示例

    代码示例

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

    代码示例 - 图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

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