这样某一个特征只有0和1两种取值，数据集有三个类别。当取0的时候，假如类别A有20个这样的个体，类别B有60个这样的个体，类别C有20个这样的个体。所以，这个特征为0时，最有可能的是类别B，但是，还是有40个个体不在B类别中，所以，将这个特征为0分到类别B中的错误率是40%。然后，将所有的特征统计完，计算所有的特征错误率，再选择错误率最低的特征作为唯一的分类准则――这就是OneR。

现在用代码来实现算法。

    # OneR算法实现
    import numpy as np
    from sklearn.datasets import load_iris
    # 加载iris数据集
    dataset = load_iris()
    # 加载iris数据集中的data数组（数据集的特征）
    X = dataset.data
    # 加载iris数据集中的target数组（数据集的类别）
    y_true = dataset.target
    # 计算每一项特征的平均值
    attribute_means = X.mean(axis=0)
    # 与平均值比较，大于等于的为"1"，小于的为"0".将连续性的特征值变为离散性的类别型。
    x = np.array(X >= attribute_means, dtype="int")


    from sklearn.model_selection import train_test_split
    x_train, x_test, y_train, y_test = train_test_split(x, y_true, random_state=14)
    from operator import itemgetter
    from collections import defaultdict
    # 找到一个特征下的不同值的所属的类别。
    def train_feature_class(x, y_true, feature_index, feature_values):
      num_class = defaultdict(int)
      for sample, y in zip(x, y_true):
        if sample[feature_index] == feature_values:
          num_class[y] += 1
      # 进行排序，找出最多的类别。按从大到小排列
      sorted_num_class = sorted(num_class.items(), key=itemgetter(1), reverse=True)
      most_frequent_class = sorted_num_class[0][0]
      error = sum(value_num for class_num , value_num in sorted_num_class if class_num != most_frequent_class)
      return most_frequent_class, error
    # print train_feature_class(x_train, y_train, 0, 1)
    # 接着定义一个以特征为自变量的函数，找出错误率最低的最佳的特征，以及该特征下的各特征值所属的类别。
    def train_feature(x, y_true, feature_index):
      n_sample, n_feature = x.shape
      assert 0 <= feature_index < n_feature
      value = set(x[:, feature_index])
      predictors = {}
      errors = []
      for current_value in value:
        most_frequent_class, error = train_feature_class(x, y_true, feature_index, current_value)
        predictors[current_value] = most_frequent_class
        errors.append(error)
      total_error = sum(errors)
      return predictors, total_error
    # 找到所有特征下的各特征值的类别，格式就如：{0：({0: 0, 1: 2}, 41)}首先为一个字典，字典的键是某个特征，字典的值由一个集合构成，这个集合又是由一个字典和一个值组成，字典的键是特征值，字典的值为类别，最后一个单独的值是错误率。
    all_predictors = {feature: train_feature(x_train, y_train, feature) for feature in xrange(x_train.shape[1])}
    # print all_predictors
    # 筛选出每个特征下的错误率出来
    errors = {feature: error for feature, (mapping, error) in all_predictors.items()}
    # 对错误率排序，得到最优的特征和最低的错误率，以此为模型和规则。这就是one Rule（OneR）算法。
    best_feature, best_error = sorted(errors.items(), key=itemgetter(1), reverse=False)[0]
    # print "The best model is based on feature {0} and has error {1:.2f}".format(best_feature, best_error)
    # print all_predictors[best_feature][0]
    # 建立模型
    model = {"feature": best_feature, "predictor": all_predictors[best_feature][0]}
    # print model
    # 开始测试――对最优特征下的特征值所属类别进行分类。
    def predict(x_test, model):
      feature = model["feature"]
      predictor = model["predictor"]
      y_predictor = np.array([predictor[int(sample[feature])] for sample in x_test])
      return y_predictor

    y_predictor = predict(x_test, model)
    # print y_predictor
    # 在这个最优特征下，各特征值的所属类别与测试数据集相对比，得到准确率。
    accuracy = np.mean(y_predictor == y_test) * 100
    print "The test accuracy is {0:.2f}%".format(accuracy)

    from sklearn.metrics import classification_report

    # print(classification_report(y_test, y_predictor))

总结：OneR算法，我在最开始的以为它是找到一个错误率最低的特征之后可以判断所有特征的分类，其实，现在明白它只能判断这个特征下的各特征值的分类，所以，明显它会有一些局限性。只是说它比较快捷也比较简单明了。但是，还是得是情况而判断是否使用它。

class precision recall f1-score support

0 0.94 1.00 0.97 17
1 0.00 0.00 0.00 13
2 0.40 1.00 0.57 8

avg / total 0.51 0.66 0.55 38

注：

在上面代码中。

for sample in x_test:
print sample[0]

得到的是x_test的第一列数据。而用下面的代码得到的是x_test的第一行数据。

print x_test[0]

注意两者区别

以上这篇python算法演练_One Rule 算法(详解)就是小编分享给大家的全部内容了，希望能给大家一个参考，也希望大家多多支持脚本之家。