本文介绍了Python数据挖掘中的OneR算法，通过Iris植物分类数据集进行实例解析。首先解释了分类问题的基本概念，然后详细阐述了OneR算法的工作原理，包括特征离散化和错误率计算。最后，文章展示了如何使用OneR算法进行训练和测试，得出基于花瓣长度的分类结果，预测精度达到65.8%。
分类是数据挖掘最为常用的方法之一，无论实际应用还是调研，都需要它的帮忙。对于分类问题，我们通常能拿到表示实际对象或时间的数据及，而数据集中每一条数据都有所属于的类别，这些类别把一条条的数据划分为不同的类。我们举几个例子
根据检测数据确定植物的种类。类别值为“各类植物”（各种各样的植物名称）
图片中是否包含汽车。类别是‘是否包含汽车’（是否）
上面2个问题中第一个类别为各类的植物，例如植物A属于蔷薇科，植物B属于芭蕉科。等等等等
而第二个例子，只有两个类别：1.该图片内包含汽车。2.该图片不包含汽车。
分类的应用目标是，根据已知类别的数据集，经过训练得到一个分类模型，再用模型对位置的数据进行分类，例如我们可以对收到的邮件分类，标注是否是垃圾邮件，用这些数据训练分类模型，实现一个垃圾邮件过滤器，这样在以后我们就无需对邮件进行人工确认是否为垃圾邮件了。
下面我们使用著名的Iris植物分类数据及，这个数据集上有150条植物数据（我相信你在无数的教程里都见过这个数据集）。scikit-learn内置了该数据集，我们先来看一下
In [1]: from sklearn.datasets import load_iris
In [2]: dataset = load_iris()
In [3]: X = dataset.data
In [4]: Y = dataset.target
In [5]: X
Out[5]:
array([[5.1, 3.5, 1.4, 0.2],
[4.9, 3. , 1.4, 0.2],
[4.7, 3.2, 1.3, 0.2],
[4.6, 3.1, 1.5, 0.2],
[5. , 3.6, 1.4, 0.2],
[5.4, 3.9, 1.7, 0.4],
[4.6, 3.4, 1.4, 0.3],
[5. , 3.4, 1.5, 0.2],
[4.4, 2.9, 1.4, 0.2],
[4.9, 3.1, 1.5, 0.1],
[5.4, 3.7, 1.5, 0.2],
[4.8, 3.4, 1.6, 0.2],
[4.8, 3. , 1.4, 0.1],
[4.3, 3. , 1.1, 0.1],
[5.8, 4. , 1.2, 0.2],
[5.7, 4.4, 1.5, 0.4],
[5.4, 3.9, 1.3, 0.4],
[5.1, 3.5, 1.4, 0.3],
[5.7, 3.8, 1.7, 0.3],
[5.1, 3.8, 1.5, 0.3],
[5.4, 3.4, 1.7, 0.2],
[5.1, 3.7, 1.5, 0.4],
[4.6, 3.6, 1. , 0.2],
[5.1, 3.3, 1.7, 0.5],
[4.8, 3.4, 1.9, 0.2],
[5. , 3. , 1.6, 0.2],
[5. , 3.4, 1.6, 0.4],
[5.2, 3.5, 1.5, 0.2],
[5.2, 3.4, 1.4, 0.2],
[4.7, 3.2, 1.6, 0.2],
[4.8, 3.1, 1.6, 0.2],
[5.4, 3.4, 1.5, 0.4],
[5.2, 4.1, 1.5, 0.1],
[5.5, 4.2, 1.4, 0.2],
[4.9, 3.1, 1.5, 0.2],
[5. , 3.2, 1.2, 0.2],
[5.5, 3.5, 1.3, 0.2],
[4.9, 3.6, 1.4, 0.1],
[4.4, 3. , 1.3, 0.2],
[5.1, 3.4, 1.5, 0.2],
[5. , 3.5, 1.3, 0.3],
[4.5, 2.3, 1.3, 0.3],
[4.4, 3.2, 1.3, 0.2],
[5. , 3.5, 1.6, 0.6],
[5.1, 3.8, 1.9, 0.4],
[4.8, 3. , 1.4, 0.3],
[5.1, 3.8, 1.6, 0.2],
[4.6, 3.2, 1.4, 0.2],
[5.3, 3.7, 1.5, 0.2],
[5. , 3.3, 1.4, 0.2],
[7. , 3.2, 4.7, 1.4],
[6.4, 3.2, 4.5, 1.5],
[6.9, 3.1, 4.9, 1.5],
[5.5, 2.3, 4. , 1.3],
[6.5, 2.8, 4.6, 1.5],
[5.7, 2.8, 4.5, 1.3],
[6.3, 3.3, 4.7, 1.6],
[4.9, 2.4, 3.3, 1. ],
[6.6, 2.9, 4.6, 1.3],
[5.2, 2.7, 3.9, 1.4],
[5. , 2. , 3.5, 1. ],
[5.9, 3. , 4.2, 1.5],
[6. , 2.2, 4. , 1. ],
[6.1, 2.9, 4.7, 1.4],
[5.6, 2.9, 3.6, 1.3],
[6.7, 3.1, 4.4, 1.4],
[5.6, 3. , 4.5, 1.5],
[5.8, 2.7, 4.1, 1. ],
[6.2, 2.2, 4.5, 1.5],
[5.6, 2.5, 3.9, 1.1],
[5.9, 3.2, 4.8, 1.8],
[6.1, 2.8, 4. , 1.3],
[6.3, 2.5, 4.9, 1.5],
[6.1, 2.8, 4.7, 1.2],
[6.4, 2.9, 4.3, 1.3],
[6.6, 3. , 4.4, 1.4],
[6.8, 2.8, 4.8, 1.4],
[6.7, 3. , 5. , 1.7],
[6. , 2.9, 4.5, 1.5],
[5.7, 2.6, 3.5, 1. ],
[5.5, 2.4, 3.8, 1.1],
[5.5, 2.4, 3.7, 1. ],
[5.8, 2.7, 3.9, 1.2],
[6. , 2.7, 5.1, 1.6],
[5.4, 3. , 4.5, 1.5],
[6. , 3.4, 4.5, 1.6],
[6.7, 3.1, 4.7, 1.5],
[6.3, 2.3, 4.4, 1.3],
[5.6, 3. , 4.1, 1.3],
[5.5, 2.5, 4. , 1.3],
[5.5, 2.6, 4.4, 1.2],
[6.1, 3. , 4.6, 1.4],
[5.8, 2.6, 4. , 1.2],
[5. , 2.3, 3.3, 1. ],
[5.6, 2.7, 4.2, 1.3],
[5.7, 3. , 4.2, 1.2],
[5.7, 2.9, 4.2, 1.3],
[6.2, 2.9, 4.3, 1.3],
[5.1, 2.5, 3. , 1.1],
[5.7, 2.8, 4.1, 1.3],
[6.3, 3.3, 6. , 2.5],
[5.8, 2.7, 5.1, 1.9],
[7.1, 3. , 5.9, 2.1],
[6.3, 2.9, 5.6, 1.8],
[6.5, 3. , 5.8, 2.2],
[7.6, 3. , 6.6, 2.1],
[4.9, 2.5, 4.5, 1.7],
[7.3, 2.9, 6.3, 1.8],
[6.7, 2.5, 5.8, 1.8],
[7.2, 3.6, 6.1, 2.5],
[6.5, 3.2, 5.1, 2. ],
[6.4, 2.7, 5.3, 1.9],
[6.8, 3. , 5.5, 2.1],
[5.7, 2.5, 5. , 2. ],
[5.8, 2.8, 5.1, 2.4],
[6.4, 3.2, 5.3, 2.3],
[6.5, 3. , 5.5, 1.8],
[7.7, 3.8, 6.7, 2.2],
[7.7, 2.6, 6.9, 2.3],
[6. , 2.2, 5. , 1.5],
[6.9, 3.2, 5.7, 2.3],
[5.6, 2.8, 4.9, 2. ],
[7.7, 2.8, 6.7, 2. ],
[6.3, 2.7, 4.9, 1.8],
[6.7, 3.3, 5.7, 2.1],
[7.2, 3.2, 6. , 1.8],
[6.2, 2.8, 4.8, 1.8],
[6.1, 3. , 4.9, 1.8],
[6.4, 2.8, 5.6, 2.1],
[7.2, 3. , 5.8, 1.6],
[7.4, 2.8, 6.1, 1.9],
[7.9, 3.8, 6.4, 2. ],
[6.4, 2.8, 5.6, 2.2],
[6.3, 2.8, 5.1, 1.5],
[6.1, 2.6, 5.6, 1.4],
[7.7, 3. , 6.1, 2.3],
[6.3, 3.4, 5.6, 2.4],
[6.4, 3.1, 5.5, 1.8],
[6. , 3. , 4.8, 1.8],
[6.9, 3.1, 5.4, 2.1],
[6.7, 3.1, 5.6, 2.4],
[6.9, 3.1, 5.1, 2.3],
[5.8, 2.7, 5.1, 1.9],
[6.8, 3.2, 5.9, 2.3],
[6.7, 3.3, 5.7, 2.5],
[6.7, 3. , 5.2, 2.3],
[6.3, 2.5, 5. , 1.9],
[6.5, 3. , 5.2, 2. ],
[6.2, 3.4, 5.4, 2.3],
[5.9, 3. , 5.1, 1.8]])
In [6]: Y
Out[6]:
array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2])
X数据共4列，这四个特征分别是sepal length、sepal width、petal length、petal width（萼片长度，萼片宽度，花瓣长度，花瓣宽度）这份数据是连续型的，既可以取无数个可能的值，连续值的特点就是如果两个值很相近，表示相似度很大，一个萼片长度为1.2cm的植物跟另外一种萼片长度为1.22cm的植物就很相似。
Y数据中可以取到的值只有0，1，2这三类，Y数据集类别的取值为离散型，0，1，2分别代表Iris Setosa、Iris Versicolour、Iris Virginica,在这里数字只是表示了对应的类型，无法如同连续型的一样判断相似程度。
X数据的值是连续型的，而本章节使用的方法需要类别型的特征值，因此我们需要将连续型的转变为类别性的，这个过程叫离散化。
最简单的方法，给定一个阈值，低于这个值的置为0，高于这个值的置为1
In [10]: X_d = np.array(X >= X.mean(axis=0),dtype = 'int')
In [11]: X_d
Out[11]:
array([[0, 1, 0, 0],
[0, 0, 0, 0],
[0, 1, 0, 0],
[0, 1, 0, 0],
[0, 1, 0, 0],
[0, 1, 0, 0],
[0, 1, 0, 0],
[0, 1, 0, 0],
[0, 0, 0, 0],
[0, 1, 0, 0],
[0, 1, 0, 0],
[0, 1, 0, 0],
[0, 0, 0, 0],
[0, 0, 0, 0],
[0, 1, 0, 0],
[0, 1, 0, 0],
[0, 1, 0, 0],
[0, 1, 0, 0],
[0, 1, 0, 0],
[0, 1, 0, 0],
[0, 1, 0, 0],
[0, 1, 0, 0],
[0, 1, 0, 0],
[0, 1, 0, 0],
[0, 1, 0, 0],
[0, 0, 0, 0],
[0, 1, 0, 0],
[0, 1, 0, 0],
[0, 1, 0, 0],
[0, 1, 0, 0],
[0, 1, 0, 0],
[0, 1, 0, 0],
[0, 1, 0, 0],
[0, 1, 0, 0],
[0, 1, 0, 0],
[0, 1, 0, 0],
[0, 1, 0, 0],
[0, 1, 0, 0],
[0, 0, 0, 0],
[0, 1, 0, 0],
[0, 1, 0, 0],
[0, 0, 0, 0],
[0, 1, 0, 0],
[0, 1, 0, 0],
[0, 1, 0, 0],
[0, 0, 0, 0],
[0, 1, 0, 0],
[0, 1, 0, 0],
[0, 1, 0, 0],
[0, 1, 0, 0],
[1, 1, 1, 1],
[1, 1, 1, 1],
[1, 1, 1, 1],
[0, 0, 1, 1],
[1, 0, 1, 1],
[0, 0, 1, 1],
[1, 1, 1, 1],
[0, 0, 0, 0],
[1, 0, 1, 1],
[0, 0, 1, 1],
[0, 0, 0, 0],
[1, 0, 1, 1],
[1, 0, 1, 0],
[1, 0, 1, 1],
[0, 0, 0, 1],
[1, 1, 1, 1],
[0, 0, 1, 1],
[0, 0, 1, 0],
[1, 0, 1, 1],
[0, 0, 1, 0],
[1, 1, 1, 1],
[1, 0, 1, 1],
[1, 0, 1, 1],
[1, 0, 1, 1],
[1, 0, 1, 1],
[1, 0, 1, 1],
[1, 0, 1, 1],
[1, 0, 1, 1],
[1, 0, 1, 1],
[0, 0, 0, 0],
[0, 0, 1, 0],
[0, 0, 0, 0],
[0, 0, 1, 1],
[1, 0, 1, 1],
[0, 0, 1, 1],
[1, 1, 1, 1],
[1, 1, 1, 1],
[1, 0, 1, 1],
[0, 0, 1, 1],
[0, 0, 1, 1],
[0, 0, 1, 1],
[1, 0, 1, 1],
[0, 0, 1, 1],
[0, 0, 0, 0],
[0, 0, 1, 1],
[0, 0, 1, 1],
[0, 0, 1, 1],
[1, 0, 1, 1],
[0, 0, 0, 0],
[0, 0, 1, 1],
[1, 1, 1, 1],
[0, 0, 1, 1],
[1, 0, 1, 1],
[1, 0, 1, 1],
[1, 0, 1, 1],
[1, 0, 1, 1],
[0, 0, 1, 1],
[1, 0, 1, 1],
[1, 0, 1, 1],
[1, 1, 1, 1],
[1, 1, 1, 1],
[1, 0, 1, 1],
[1, 0, 1, 1],
[0, 0, 1, 1],
[0, 0, 1, 1],
[1, 1, 1, 1],
[1, 0, 1, 1],
[1, 1, 1, 1],
[1, 0, 1, 1],
[1, 0, 1, 1],
[1, 1, 1, 1],
[0, 0, 1, 1],
[1, 0, 1, 1],
[1, 0, 1, 1],
[1, 1, 1, 1],
[1, 1, 1, 1],
[1, 0, 1, 1],
[1, 0, 1, 1],
[1, 0, 1, 1],
[1, 0, 1, 1],
[1, 0, 1, 1],
[1, 1, 1, 1],
[1, 0, 1, 1],
[1, 0, 1, 1],
[1, 0, 1, 1],
[1, 0, 1, 1],
[1, 1, 1, 1],
[1, 1, 1, 1],
[1, 0, 1, 1],
[1, 1, 1, 1],
[1, 1, 1, 1],
[1, 1, 1, 1],
[0, 0, 1, 1],
[1, 1, 1, 1],
[1, 1, 1, 1],
[1, 0, 1, 1],
[1, 0, 1, 1],
[1, 0, 1, 1],
[1, 1, 1, 1],
[1, 0, 1, 1]])
X.mean(axis=0)返回一个长度为4的数组，分别是四个特征值的均值，
我们从新生成的X_d返回的是各个数据是否大于均值的类别型数据。
实现OneR算法
OneR算法的思路很简单，它根据已有的数据中，具有相同特征值的个体最优可能属于哪个类别进行分类，我们只选择四个特种中分类效果最好的一个用作分类依据，后续会讲解更复杂的分类算法，但是这个看起来简单的算法在很多数据集上表现的也很好。
算法首先遍历每个特征的每一个取值，对于每一个特征值，统计它在各个类别中出现的次数，找到他出现次数最多的类别，并统计他在其他类别中出现的次数。
举个例子：一个数据集的某一项特征可以取0或1两个值，数据集共有3个类别A,B,C，特征值为0的情况下，A类有10个这样的个体，B类有70个，C类有20个。那么特征值为0的个体最可能属于B类，（70%）当然了还有30个个体不属于B类，错误的概率就是30%。
统计完所有特征值以及在每个类别出现的次数后，再计算每个特征的错误率，选取错误率最低的特征作为唯一的分类准则（这就是所说的OneR）。
现在我们来实现一下。
In [13]: from sklearn.model_selection import train_test_split
In [14]: random_state = 14
In [15]: X_train, X_test, y_train, y_test = train_test_split(X_d, Y, random_state=random_state)
In [16]: print("有{}个训练样本".format(y_train.shape))
...: print("有{}个测试样本".format(y_test.shape))
有(112,)个训练样本
有(38,)个测试样本
我们把数据集分为2个部分，分别用于训练集和测试集，
scikit-learn提供了一个将数据集切分的函数train_test_split（默认为25%作为测试集）
random_state和我一样，就可以保证切分的训练集和测试集和我展示出的代码结果相同
In [17]: from collections import defaultdict
In [18]: from operator import itemgetter
In [19]: def train(X, y_true, feature):
...: n_samples, n_features = X.shape
...: assert 0 <= feature < n_features
...: values = set(X[:,feature])
...: predictors = dict()
...: errors = []
...: for current_value in values:
...: most_frequent_class, error = train_feature_value(X, y_true, feature, current_value)
...: predictors[current_value] = most_frequent_class
...: errors.append(error)
...: total_error = sum(errors)
...: return predictors, total_error
...:
In [20]: def train_feature_value(X, y_true, feature, value):
...: class_counts = defaultdict(int)
...: for sample,y in zip(X,y_true):
...: if sample[feature] == value:
...: class_counts[y] += 1
...: print(class_counts)
...: sorted_class_counts = sorted(class_counts.items(),key=itemgetter(1),reverse=True)
...: most_frequent_class = sorted_class_counts[0][0]
...: error = sum([class_count for class_value, class_count in class_counts.items()
...: if class_value != most_frequent_class])
...: return most_frequent_class, error
...:
In [21]: all_predictors = {variable: train(X_train, y_train, variable) for variable in range(X_train.shape[1])}
defaultdict(<class 'int'>, {0: 33, 1: 15, 2: 4})
defaultdict(<class 'int'>, {2: 38, 1: 22})
defaultdict(<class 'int'>, {2: 27, 1: 29, 0: 8})
defaultdict(<class 'int'>, {1: 8, 2: 15, 0: 25})
defaultdict(<class 'int'>, {0: 33, 1: 6})
defaultdict(<class 'int'>, {2: 42, 1: 31})
defaultdict(<class 'int'>, {0: 33, 1: 7})
defaultdict(<class 'int'>, {2: 42, 1: 30})
In [22]: errors = {variable: error for variable, (mapping, error) in all_predictors.items()}
In [23]: all_predictors
Out[23]:
{0: ({0: 0, 1: 2}, 41),
1: ({0: 1, 1: 0}, 58),
2: ({0: 0, 1: 2}, 37),
3: ({0: 0, 1: 2}, 37)}
In [24]: errors
Out[24]: {0: 41, 1: 58, 2: 37, 3: 37}
具体的计算方法我们上面也提过了，当然了，你也可以不像我一样构建函数，直接计算。看一下我们的结果
all_predictors，第一行0: ({0: 0, 1: 2}, 41),啥意思呢，这表示如何用我们数据集中第一列（萼片长度）来判断属于0，1，2哪一类。这个0：0表示，如果他的萼片长度小于平均值那么他是属于0类植物，1：2也同理，如果萼片长度大于平均值那么他属于2类植物。后面的41表示预测错误的总数。
在讲解算法的时候我们也提过我们选择错误概率最小的那一项，我们排序看一下。
In [25]: best_variable, best_error = sorted(errors.items(), key=itemgetter(1))[0]
In [26]: print("最佳模型基于变量 {0} 误差为 {1:.2f}".format(best_variable, best_error))
最佳模型基于变量 2 误差为 37.00
我们排序后误差最小的是基于变量2
之后那就根据变量2（ 2: ({0: 0, 1: 2}, 37)）方法来用测试集预测结果
In [27]: model = {'variable': best_variable,
...: 'predictor': all_predictors[best_variable][0]}
In [28]: def predict(X_test, model):
...: variable = model['variable']
...: predictor = model['predictor']
...: y_predicted = np.array([predictor[int(sample[variable])] for sample in X_test])
...: return y_predicted
...:
In [29]: y_predicted = predict(X_test, model)
In [30]: y_predicted
Out[30]:
array([0, 0, 0, 2, 2, 2, 0, 2, 0, 2, 2, 0, 2, 2, 0, 2, 0, 2, 2, 2, 0, 0,
0, 2, 0, 2, 0, 2, 2, 0, 0, 0, 2, 0, 2, 0, 2, 2])
上面我们得出了我们通过变量2的测试结果。也既是通过花瓣长度来判断属于哪类植物。
那么我们的误差又是怎么样的呢
In [31]: accuracy = np.mean(y_predicted == y_test) * 100
...: print("预测精度为 {:.1f}%".format(accuracy))
预测精度为 65.8%
在使用random_state=14的切分情况下，我们预测的精准度为65.8%还不错
扫一扫
1546
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
