接上一篇，使用 oneR算法来实现iris分类.
# coding: utf-8
#使用oneR算法来实现iris分类
#参考: http://www.cnblogs.com/htynkn/archive/2012/04/14/2446905.html
#算法思路: 根据已有数据中，具有相同特征值的个体最可能属于哪个类别进行分类.
#oneR是one rule(一条规则)的简写, 表示只选取四个特征中分类效果最好的一个用作分类的依据.
#步骤:
#1. 离散化特征值: 因为oneR算法使用类别型特征值，而原数据集为连续值。因此需要把连续值转为类别型
#简单的离散方法: 设定一个阈值，将低于该阈值的特征值置为0,高于阈值的置为1. 某特征的阈值设定为该特征所有特征值的均值.
#2. 遍历每个特征的每一个取值，对于每一个特征值，统计它在各个类别中的出现次数。找到它出现次数最多的类别，并统计它在其它类别中的出现次数.
#3. 统计完所有的特征值及其在每个类别的出现次数后，再计算每个特征的错误率。计算方法为把它的各个取值的错误率相加，选取错误率最低的特征作为唯一分类准则,用于接下来的分类
import numpy as np
from sklearn import datasets
iris=datasets.load_iris()
x=iris.data
y=iris.target
n_samples,n_features=x.shape # 结果为: (150,4) 取出数据行数及列数
#计算每个特征列的均值
attribute_means=x.mean(axis=0) #axis=0表示列 1表示行
#以上结果为 ： array([ 5.84333333, 3.054 , 3.75866667, 1.19866667])
#将上面的结果转为一个数组，这个数组正好是四列，分别对应了四个特征值的均值，再用这个均值做阈值将数据集打散，将连续的特征值转为类别型，即完成步骤一
x_d=np.array( x>=attribute_means, dtype='int')
#接下来切分训练集和测试集， 切分数据集为训练集和测试集
#方案一: 像上一个案例一样，切成140:10的比例
#np.random.seed(0)
# permutation函数: 随机排列 https://docs.scipy.org/doc/numpy/reference/generated/numpy.random.permutation.html
#i=np.random.permutation(len(x_d))
#训练集： 取出打乱后的前140条数据
#x_train=x_d[i[:-10]] #前140条数据
#y_train=y[i[:-10]] #前140条数据对应的花的类型
#输出x_train, y_train
#x_train
#y_train
#测试集
#x_test=x_d[i[-10:]] #最后10条数据
#y_test=y[i[-10:]] #最后10条数据对应的花的类型
#方案2: 利用 scikit-learn库提供的切分函数
from sklearn.cross_validation import train_test_split
#train_test_split知识 : http://scikit-learn.org/stable/modules/generated/sklearn.cross_validation.train_test_split.html
x_train,x_test,y_train,y_test=train_test_split( x_d,y,random_state=14)
print("{} training samples".format(x_train.shape))
print("{} testing samples".format(y_test.shape))
from collections import defaultdict # http://www.pythontab.com/html/2013/pythonjichu_1023/594.html
from operator import itemgetter # http://www.cnblogs.com/100thMountain/p/4719503.html
#定义一个函数: 遍历数据集中每一条数据，统计具有给定特征值的个体在各个类别中的出现次数
# 参数说明: 数据集 类别数组 选好的特征索引值 特征值
def train_feature_value( X, y_true, feature_index, value):
class_counts=defaultdict(int)
#zip函数用法: http://www.cnblogs.com/frydsh/archive/2012/07/10/2585370.html
for sample,y in zip(X, y_true):
if sample[feature_index]==value:
class_counts[y]+=1
#对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
#定义另一个函数:
#对于某项特征，遍历其每一个特征值，调用上面的函数，就能得到预测结果和每个特征值所带来的错误率，然后把所有错误率累加起来，就能得到该特征的总错误率。
def train(X,y_true,feature_index):
#以数组形式返回由feature_index所指的列的值.然后以set函数将数组转为集合.
values=set(X[:,feature_index])
#再创建字典
predictors=dict()
errors=[]
for current_value in values:
most_frequent_class,error=train_feature_value( X,y_true, feature_index, current_value)
predictors[current_value]=most_frequent_class
errors.append( error )
#最后计算该规则的总错误率
total_error=sum(errors)
return predictors,total_error
#计算预测器
all_predictors={variable:train(x_train,y_train,variable) for variable in range(x_train.shape[1])}
errors={variable:error for variable, (mapping,error) in all_predictors.items()}
#找出错误率最低的特征,作为分类的唯一规则
best_feature,best_error=sorted(errors.items(),key=itemgetter(1))[0]
#对预测器进行排序，找到最佳特征值,创建模型
model={'feature':best_feature,'predictor':all_predictors[best_feature][0]}
#model中的元素，一个用于分类的特征和预测器
#下面可以开始对测试集进行预测了
#首先定义一个函数
def predict( x_test,model):
feature=model['feature']
predictor=model['predictor']
y_predicted=np.array([predictor[int(sample[feature])] for sample in x_test])
return y_predicted
#调用上面的函数对测试集进行预测
y_predicted=predict( x_test,model)
#使用模型预测的结果: 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])
y_test
#标准结果: array([0, 0, 0, 1, 2, 1, 0, 1, 0, 1, 2, 0, 2, 2, 0, 1, 0, 2, 2, 1, 0, 0, 0,
# 1, 0, 2, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 2, 1])
#计算正确率
accuracy=np.mean( y_predicted==y_test)*100
print(u"模型正确率为:{:.1f}%".format( accuracy)) # 65.8%
最后使用测试集进行测试，正确率为 65.8%. 对于这样一条简单的规则来说，已经非常不错了.