数据挖掘入门与实践

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60

# -*- coding: utf-8 -*-
import numpy as np
from collections import defaultdict
from operator import itemgetter

if __name__ == '__main__':
    dataset_filename = "affinity_dataset.txt"
    X = np.loadtxt(dataset_filename)
    n_samples, n_features = X.shape  # 样本数，特征数
    features = ["bread", "milk", "cheese", "apples", "bananas"]  # 商品名列表

    # 如果 xxx，那么 xxx 就是一条规则。规则由前提条件和结论两部分组成
    # 这里注意'如果买 A 则他们会买 B'和'如果买 B 则他们会买 A'不是一个规则，在下面的循环中体现出来
    valid_rules = defaultdict(int)  # 规则应验
    invalid_rules = defaultdict(int)  # 规则无效
    num_occurences = defaultdict(int)  # 商品购买数量字典

    for sample in X:  # 对数据集里的每个消费者
        for premise in range(n_features):
            if sample[premise] == 0:  # 如果这个商品没有买，继续看下一个商品
                continue
            num_occurences[premise] += 1  # 记录这个商品购买数量
            for conclusion in range(n_features):
                if premise == conclusion:  # 跳过此商品
                    continue
                if sample[conclusion] == 1:
                    valid_rules[(premise, conclusion)] += 1  # 规则应验
                else:
                    invalid_rules[(premise, conclusion)] += 1  # 规则无效
    support = valid_rules  # 支持度字典，即规则应验次数
    confidence = defaultdict(float)  # 置信度字典
    for premise, conclusion in valid_rules.keys():  # 条件/结论
        rule = (premise, conclusion)
        # 置信度 = 规则发生的次数/条件发生的次数
        confidence[rule] = valid_rules[rule] / num_occurences[premise]

    def print_rule(premise, conclusion, support, confidence, features):
        premise_name = features[premise]
        conclusion_name = features[conclusion]
        print(
            "Rule: If a person buys {0} they will also buy {1}".format(
                premise_name,
                conclusion_name))
        print(
            " - Confidence: {0:.3f}".format(confidence[(premise, conclusion)]))
        print(" - Support: {0}".format(support[(premise, conclusion)]))
        print("")

    # 得到支持度最高的规则，items() 返回字典所有元素的列表，itemgetter(1) 表示用支持度的值作为键，进行降序排列
    sorted_support = sorted(support.items(), key=itemgetter(1), reverse=True)
    for i in range(5):
        print("Rule #{0}".format(i + 1))
        premise, conclusion = sorted_support[i][0]
        print_rule(premise, conclusion, support, confidence, features)

    sorted_confidence = sorted(confidence.items(), key=itemgetter(1), reverse=True)
    for i in range(5):
        print("Rule #{0}".format(i + 1))
        premise, conclusion = sorted_confidence[i][0]
        print_rule(premise, conclusion, support, confidence, features)

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123

# -*- coding: utf-8 -*-
import numpy as np
from sklearn.datasets import load_iris  # Iris 植物分类数据集
from collections import defaultdict  # 初始化数据字典
from operator import itemgetter  # 得到一个列表的制定元素
from sklearn.model_selection import train_test_split  # 将一个数据集且分为训练集和测试集
from sklearn.metrics import classification_report  # 分析预测结果

# 这里保留函数的文档方便查阅
def train(X, y_true, feature):
    """
    Computes the predictors and error for a given feature using the OneR algorithm
    Parameters
    ----------
    X: array [n_samples, n_features]
        The two dimensional array that holds the dataset. Each row is a sample, each column
        is a feature.

    y_true: array [n_samples,]
        The one dimensional array that holds the class values. Corresponds to X, such that
        y_true[i] is the class value for sample X[i].

    feature: int
        An integer corresponding to the index of the variable we wish to test.
        0 <= variable < n_features

    Returns
    -------
    predictors: dictionary of tuples: (value, prediction)
        For each item in the array, if the variable has a given value, make the given prediction.

    error: float
        The ratio of training data that this rule incorrectly predicts.
    """
    # 检查是否为有效数字
    n_samples, n_features = X.shape
    assert 0 <= feature < n_features
    # X[:, feature] 为 numpy 矩阵的索引用法，第一维：所有数组，第二维：feature，set 去重得到 value 有几个取值
    # 这个 feature 特征值在每个数据中有多少个取值
    values = set(X[:, feature])
    # Stores the predictors array that is returned
    predictors = dict()
    errors = []
    # 对每个特征值的每个取值调用 train_feature_value 函数获得该取值出现最多的类和错误率
    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)
    # 返回预测方案（即 feature 的取值分别对应哪个类别）和总错误率
    return predictors, total_error


def train_feature_value(X, y_true, feature, value):
    class_counts = defaultdict(int)
    # Iterate through each sample and count the frequency of each class/value pair
    # 第 feature 个特征的值为 value 的时候，在每个种类中出现的次数，这里的植物有三个种类
    # 因此最终 class_counts 有三个键值对
    for sample, y in zip(X, y_true):
        if sample[feature] == value:
            class_counts[y] += 1
    # 对 class_count 以 value 由大到小排列
    sorted_class_counts = sorted(
        class_counts.items(),
        key=itemgetter(1),
        reverse=True)
    most_frequent_class = sorted_class_counts[0][0]  # 出现最多次的类
    n_samples = X.shape[1]
    error = sum([class_count for class_value, class_count in class_counts.items(
    ) if class_value != most_frequent_class])  # error 就是除去上面那个类的其它 value 的和
    return most_frequent_class, error  # 返回出现次数最多的类和错误率


def predict(X_test, model):
    variable = model['variable']  # 使用哪个 feature 作为 OneRule 进行预测
    predictor = model['predictor']  # 一个字典，保存着 feature 取值对应哪一类
    y_predicted = np.array([predictor[int(sample[variable])]
                            for sample in X_test])
    return y_predicted  # 返回预测结果


if __name__ == '__main__':
    dataset = load_iris()
    X = dataset.data
    y = dataset.target
    n_samples, n_features = X.shape

    # 计算每个属性的均值
    attribute_means = X.mean(axis=0)
    assert attribute_means.shape == (n_features,)
    # 对数据集离散化
    X_d = np.array(X >= attribute_means, dtype='int')

    random_state = 14
    X_train, X_test, y_train, y_test = train_test_split(
        X_d, y, random_state=random_state)  # 分割训练集和测试集
    print("There are {} training samples".format(y_train.shape))  # 训练集数量
    print("There are {} testing samples".format(y_test.shape))  # 测试集数量

    # 对每个特征返回预测器和错误率 [0：{0: x, 1: x}, sum_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()}  # 把每个预测器的值提取出来
    # 找出最好（错误最少）的那个 feature 构成的预测器
    best_variable, best_error = sorted(errors.items(), key=itemgetter(1))[0]
    print(
        "The best model is based on variable {0} and has error {1:.2f}%".format(
            best_variable,
            best_error))

    # Choose the bset model
    model = {'variable': best_variable,
             'predictor': all_predictors[best_variable][0]}
    y_predicted = predict(X_test, model)
    print(classification_report(y_test, y_predicted))  # 生成测试结果
    print(np.mean(y_predicted == y_test) * 100)  # 预测正确率

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

# -*- coding: utf-8 -*-
import numpy as np
import csv
from matplotlib import pyplot as plt
from sklearn.neighbors import KNeighborsClassifier  # 导入 K 近邻分类器
from sklearn.model_selection import train_test_split
from sklearn.model_selection import cross_val_score  # 导入交叉检验的
# 把每个特征值的值域规范化到 0，1 之间，最小值用 0 代替，最大值用 1 代替
from sklearn.preprocessing import MinMaxScaler
from sklearn.pipeline import Pipeline  # 流水线


if __name__ == '__main__':
    # 数据集大小已知有 351 行，每行 35 个值前 34 个为天线采集的数据，最后一个 g/b 表示数据的好坏
    X = np.zeros((351, 34), dtype='float')
    y = np.zeros((351,), dtype='bool')

    # 打开根目录的数据集文件
    with open("ionosphere.data", 'r', encoding='utf-8') as input_file:
        # 创建 csv 阅读器对象
        reader = csv.reader(input_file)
        # 使用枚举函数为每行数据创建索引
        for i, row in enumerate(reader):
            # 获取行数据的前 34 个值，并将其转化为浮点型，保存在 X 中
            data = [float(datum) for datum in row[:-1]]
            # Set the appropriate row in our dataset
            X[i] = data  # 数据集
            # 1 if the class is 'g', 0 otherwise
            y[i] = row[-1] == 'g'  # 类别

    # 创建训练集和测试集
    X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=14)
    print(
        "There are {} samples in the training dataset".format(
            X_train.shape[0]))
    print(
        "There are {} samples in the testing dataset".format(
            X_test.shape[0]))
    print("Each sample has {} features".format(X_train.shape[1]))

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

    # 初始化一个 K 近邻分类器实例，该算法默认选择 5 个近邻作为分类依据
    estimator = KNeighborsClassifier()
    # 用训练数据进行训练
    estimator.fit(X_train, y_train)
    # 使用测试集测试算法，评价其表现
    y_predicted = estimator.predict(X_test)
    # 准确性
    accuracy = np.mean(y_test == y_predicted) * 100
    print("The accuracy is {0:.1f}%".format(accuracy))

    # 使用交叉检验的方式获得平均准确性
    scores = cross_val_score(estimator, X, y, scoring='accuracy')
    average_accuracy = np.mean(scores) * 100
    print("The average accuracy is {0:.1f}%".format(average_accuracy))

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

    # 设置参数
    # 参数的选取跟数据集的特征息息相关
    avg_scores = []
    all_scores = []
    parameter_values = list(range(1, 21))
    for n_neighbors in parameter_values:
        estimator = KNeighborsClassifier(n_neighbors=n_neighbors)
        scores = cross_val_score(estimator, X, y, scoring='accuracy')
        avg_scores.append(np.mean(scores))
        all_scores.append(scores)

    # 作出 n_neighbors 不同取值和分类正确率之间的关系的折线图
    plt.figure(figsize=(32, 20))
    plt.plot(parameter_values, avg_scores, '-o', linewidth=5, markersize=24)
    plt.show()

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

    # 模拟脏数据
    X_broken = np.array(X)
    X_broken[:, ::2] /= 10
    # 对比两种情况下预测准确率
    estimator = KNeighborsClassifier()
    original_scores = cross_val_score(estimator, X, y, scoring='accuracy')
    print(
        "The original average accuracy for is {0:.1f}%".format(
            np.mean(original_scores) * 100))
    broken_scores = cross_val_score(estimator, X_broken, y, scoring='accuracy')
    print(
        "The broken average accuracy for is {0:.1f}%".format(
            np.mean(broken_scores) * 100))

1
2
3
4
5
6
7

    # 组合成为一个工作流
    X_transformed = MinMaxScaler.fit_transform(X_broken)    # 完成训练和转换
    estimator = KNeighborsClassifier()
    transformed_scores = cross_val_score(
        estimator, X_transformed, y, scoring='accuracy')
    print("The average accuracy for is {0:.1f}%".format(
        np.mean(transformed_scores) * 100))

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

    # 创建流水线
    # 流水线的每一步都用 ('名称',步骤) 的元组表示
    scaling_pipeline = Pipeline([('scale', MinMaxScaler()),  # 规范特征取值
                                 ('predict', KNeighborsClassifier())])  # 预测

    # 调用流水线
    scores = cross_val_score(scaling_pipeline, X_broken, y, scoring='accuracy')
    print(
        "The pipelin scored an average accuracy for is {0:.1f}%".format(
            np.mean(scores) * 100))

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

# -*- coding: utf-8 -*-
import numpy as np
import pandas as pd
from collections import defaultdict
from sklearn.tree import DecisionTreeClassifier  # 创建决策树的类
from sklearn.model_selection import cross_val_score
from sklearn.preprocessing import LabelEncoder  # 能将字符串类型的特征转化成整型
from sklearn.preprocessing import OneHotEncoder  # 将特征转化为二进制数字
from sklearn.ensemble import RandomForestClassifier  # 随机森林
from sklearn.model_selection import GridSearchCV  # 网格搜索，找到最佳参数

if __name__ == '__main__':
    # 清洗数据集
    results = pd.read_csv(
        "NBA_data.csv", parse_dates=["Date"], skiprows=[
            0, ], usecols=[
            0, 2, 3, 4, 5, 6, 7, 9])  # 加载数据集
    # 修复数据特征名
    results.columns = [
        "Date",
        "Visitor Team",
        "VisitorPts",
        "Home Team",
        "HomePts",
        "Score Type",
        "OT?",
        "Notes"]
    # results.ix[] 已被弃用
    print(results.loc[:5])  # 查看数据集前五行

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

    # 提取新特征，值为这场中主场队伍是否胜利
    results["HomeWin"] = results["VisitorPts"] < results["HomePts"]
    y_true = results["HomeWin"].values  # 胜负情况
    # 创建两个新 feature，初始值都设为 0，保存这场比赛的两个队伍上场比赛的情况
    results["HomeLastWin"] = False
    results["VisitorLastWin"] = False
    won_last = defaultdict(int)

    for index, row in results.iterrows():
        home_team = row["Home Team"]
        visitor_team = row["Visitor Team"]
        # 这场比赛之前两个球队上次是否获胜保存在 result 中
        row["HomeLastWin"] = won_last[home_team]
        row["VisitorLastWin"] = won_last[visitor_team]
        results.iloc[index] = row
        # 这场比赛的结果更新 won_last 中的情况
        won_last[home_team] = row["HomeWin"]
        won_last[visitor_team] = not row["HomeWin"]

    X_previouswins = results[["HomeLastWin", "VisitorLastWin"]].values
    # 创建决策树生成器实例
    clf = DecisionTreeClassifier(random_state=14)
    # 交叉训练
    scores = cross_val_score(clf, X_previouswins, y_true, scoring='accuracy')
    print("Using just the last result from the home and visitor teams")
    print("Accuracy: {0:.1f}%".format(np.mean(scores) * 100))

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

    ladder = pd.read_csv("NBA_standings.csv", skiprows=[0, ])
    # 创建一个新特征，两个队伍在上个赛季的排名哪个比较高
    results["HomeTeamRanksHigher"] = 0
    for index, row in results.iterrows():
        home_team = row["Home Team"]
        visitor_team = row["Visitor Team"]
        # 这个球队改名了
        if home_team == "New Orleans Pelicans":
            home_team = "New Orleans Hornets"
        elif visitor_team == "New Orleans Pelicans":
            visitor_team = "New Orleans Hornets"
        # 这里源代码无法运行，少加了一个括号 ladder[(ladder["Team"] == home_team)] 表示根据条件获取这一行的数据
        home_row = ladder[(ladder["Team"] == home_team)]
        visitor_row = ladder[(ladder["Team"] == visitor_team)]
        home_rank = home_row["Rk"].values[0]
        visitor_rank = visitor_row["Rk"].values[0]
        row["HomeTeamRanksHigher"] = int(home_rank > visitor_rank)
        results.iloc[index] = row

    X_homehigher = results[["HomeLastWin", "VisitorLastWin", "HomeTeamRanksHigher"]].values
    clf = DecisionTreeClassifier(random_state=14)
    scores = cross_val_score(clf, X_homehigher, y_true, scoring='accuracy')
    print("Using whether the home team is ranked higher")
    print("Accuracy: {0:.1f}%".format(np.mean(scores) * 100))

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

    # 创建新特征，两个队伍上一次进行比赛时的获胜者
    last_match_winner = defaultdict(int)
    results["HomeTeamWonLast"] = 0
    for index, row in results.iterrows():
        home_team = row["Home Team"]
        visitor_team = row["Visitor Team"]
        # 按照英文字母表排序，不去考虑哪个是主场球队
        teams = tuple(sorted([home_team, visitor_team]))
        # 找到两支球队上次比赛的赢家，更新框中的数据，初始为 0
        # 这里的 HomeTeamWonLast 跟主场客场没有什么关系，也可以叫 WhichTeamWonLast，这里为了和源码尽量保持一致使用了源码
        row["HomeTeamWonLast"] = 1 if last_match_winner[teams] == row["Home Team"] else 0
        results.iloc[index] = row
        winner = row["Home Team"] if row["HomeWin"] else row["Visitor Team"]
        # 将两个球队上次遇见比赛的情况存到字典中去
        last_match_winner[teams] = winner

    X_home_higher = results[["HomeTeamRanksHigher", "HomeTeamWonLast"]].values
    clf = DecisionTreeClassifier(random_state=14)
    scores = cross_val_score(clf, X_home_higher, y_true, scoring='accuracy')
    print("Using whether the home team is ranked higher")
    print("Accuracy: {0:.1f}%".format(np.mean(scores) * 100))

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

    # 创建一个转化器实例
    encoding = LabelEncoder()
    # 将球队名转化为整型
    encoding.fit(results["Home Team"].values)
    # 抽取所有比赛中主客场球队的球队名，组合起来形成一个矩阵
    home_teams = encoding.transform(results["Home Team"].values)
    visitor_teams = encoding.transform(results["Visitor Team"].values)
    # 建立训练集，[["Home Team Feature"，"Visitor Team Feature"],["Home Team Feature"，"Visitor Team Feature"]...]
    X_teams = np.vstack([home_teams, visitor_teams]).T
    # 创建转化器实例
    onehot = OneHotEncoder()
    # 生成转化后的特征
    X_teams = onehot.fit_transform(X_teams).todense()

    clf = DecisionTreeClassifier(random_state=14)
    scores = cross_val_score(clf, X_teams, y_true, scoring='accuracy')
    print("Accuracy: {0:.1f}%".format(np.mean(scores) * 100))

    clf = RandomForestClassifier(random_state=14, n_jobs=-1)
    scores = cross_val_score(clf, X_teams, y_true, scoring='accuracy')
    print("Using full team labels is ranked higher")
    print("Accuracy: {0:.1f}%".format(np.mean(scores) * 100))

1
2
3
4
5

    X_all = np.hstack([X_home_higher, X_teams])  # 将上面计算的特征进行组合
    print(X_all.shape)
    scores = cross_val_score(clf, X_all, y_true, scoring='accuracy')
    print("Using whether the home team is ranked higher")
    print("Accuracy: {0:.1f}%".format(np.mean(scores) * 100))

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

    # 设置参数搜索范围
    parameter_space = {
        "max_features": [2, 10, 'auto'],
        "n_estimators": [100, ],
        "criterion": ["gini", "entropy"],
        "min_samples_leaf": [2, 4, 6],
    }
    grid = GridSearchCV(clf, parameter_space)
    grid.fit(X_all, y_true)
    print("Accuracy: {0:.1f}%".format(grid.best_score_ * 100))
    # 输出最佳方案
    print(grid.best_estimator_)

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
import datetime
import numpy as np
import pandas as pd
from collections import defaultdict
from sklearn.model_selection import cross_val_score
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier
from ch3.nba_test import X_all
from sklearn.model_selection import GridSearchCV  # 网格搜索，找到最佳参数


if __name__ == '__main__':
    """
    - 球队上次打比赛距今有多长时间？
    - 两支球队过去五场比赛结果如何？
    - 球队是不是跟某支特定球队打比赛时发挥更好？
    """
    dataset = pd.read_csv(
        "NBA_data.csv", parse_dates=["Date"], skiprows=[
            0, ], usecols=[
            0, 2, 3, 4, 5, 6, 7, 9])  # 加载数据集
    dataset.columns = [
        "Date",
        "Visitor Team",
        "VisitorPts",
        "Home Team",
        "HomePts",
        "Score Type",
        "OT?",
        "Notes"]
    dataset["HomeWin"] = dataset["VisitorPts"] < dataset["HomePts"]
    y_true = dataset["HomeWin"].values  # 胜负情况

    # 保存上次打比赛的时间
    last_played_date = defaultdict(datetime.date)
    # 手动为每个球队初始化
    for team in set(dataset["Home Team"]):
        last_played_date[team] = datetime.date(year=2013, month=10, day=25)
    # 两支球队过去的比赛结果，每个球队的数据是 [True,False,,,] 的序列
    last_five_games = defaultdict(list)

    # 存放 Home 和 Visitor 前五次比赛的获胜次数
    dataset["HWinTimes"] = 0
    dataset["VWinTimes"] = 0
    # 存放距离上次比赛的时间间隔，用天计数
    dataset["HLastPlayedSpan"] = 0
    dataset["VLastPlayedSpan"] = 0
    for index, row in dataset.iterrows():
        home_team = row["Home Team"]
        visitor_team = row["Visitor Team"]

        row["HWinTimes"] = sum(last_five_games[home_team][-5:])
        row["VWinTimes"] = sum(last_five_games[visitor_team][-5:])
        row["HLastPlayedSpan"] = (
            row["Date"].date() -
            last_played_date[home_team]).days
        row["VLastPlayedSpan"] = (
            row["Date"].date() -
            last_played_date[visitor_team]).days

        dataset.iloc[index] = row

        last_played_date[home_team] = row["Date"].date()
        last_played_date[visitor_team] = row["Date"].date()
        last_five_games[home_team].append(row["HomeWin"])
        last_five_games[visitor_team].append(not row["HomeWin"])

    X_1 = dataset[["HLastPlayedSpan",
                             "VLastPlayedSpan", "HWinTimes", "VWinTimes"]].values
    clf = DecisionTreeClassifier(random_state=14)
    scores = cross_val_score(clf, X_1, y_true, scoring='accuracy')
    print("DecisionTree: Using time span and win times")
    print("Accuracy: {0:.1f}%".format(np.mean(scores) * 100))

    clf = RandomForestClassifier(random_state=14, n_jobs=-1)
    scores = cross_val_score(clf, X_1, y_true, scoring='accuracy')
    print("RandomForest: Using time span and win times")
    print("Accuracy: {0:.1f}%".format(np.mean(scores) * 100))
    print("---------------------------------")

    X_all = np.hstack([X_1, X_all])

    clf = DecisionTreeClassifier(random_state=14)
    scores = cross_val_score(clf, X_all, y_true, scoring='accuracy')
    print("DecisionTree: Using time span and win times")
    print("Accuracy: {0:.1f}%".format(np.mean(scores) * 100))

    clf = RandomForestClassifier(random_state=14, n_jobs=-1)
    scores = cross_val_score(clf, X_all, y_true, scoring='accuracy')
    print("RandomForest: Using time span and win times")
    print("Accuracy: {0:.1f}%".format(np.mean(scores) * 100))
    print("---------------------------------")
    parameter_space = {
        "max_features": [2, 10, 'auto'],
        "n_estimators": [100, ],
        "criterion": ["gini", "entropy"],
        "min_samples_leaf": [2, 4, 6],
    }
    grid = GridSearchCV(clf, parameter_space)
    grid.fit(X_all, y_true)
    print("Accuracy: {0:.1f}%".format(grid.best_score_ * 100))
    print(grid.best_estimator_)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

import sys
import pandas as pd
from collections import defaultdict
from operator import itemgetter


if __name__ == '__main__':
    # header=None 不把第一行当做表头
    all_ratings = pd.read_csv(
        "ml-100k/u.data",
        delimiter="\t",
        header=None,
        names=[
            "UserID",
            "MovieID",
            "Rating",
            "Datetime"])
    # 转化时间戳为 datetime
    all_ratings["Datetime"] = pd.to_datetime(all_ratings["Datetime"], unit='s')
    # 输出用户 - 电影 - 评分稀疏矩阵
    print(all_ratings[:5])
    print()
    # 创建 Favorite 特征，将评分属性二值化为是否喜欢
    all_ratings["Favorable"] = all_ratings["Rating"] > 3
    # 取用户 ID 为前 200 的用户的打分数据
    ratings = all_ratings[all_ratings["UserID"].isin(range(200))]
    favorable_ratings = ratings[ratings["Favorable"]]
    # 创建用户喜欢哪些电影的字典
    favorable_reviews_by_users = dict(
        (k,
         frozenset(
             v.values)) for k,
        v in favorable_ratings.groupby("UserID")["MovieID"])
    # 创建一个数据框，了解每部电影的影迷数量
    num_favorable_by_movie = ratings[[
        "MovieID", "Favorable"]].groupby("MovieID").sum()
    # 查看最受欢迎的五部电影
    print(num_favorable_by_movie.sort_values("Favorable", ascending=False)[:5])

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

    # 字典保存最新发现的频繁项集
    frequent_itemsets = {}
    min_support = 50

    # 第一步，每一步电影生成只包含它自己的项集
    # frozenset() 返回一个冻结的集合，冻结后集合不能再添加或删除任何元素
    # 普通集合可变，集合中不能有可变的元素，因此普通集合不能被放在集合中；冻结集合不可变，因此可以被放入集合
    frequent_itemsets[1] = dict((frozenset((movie_id,)),
         row["Favorable"]) for movie_id,
        row in num_favorable_by_movie.iterrows() if row["Favorable"] > min_support)

    # 会有重复，导致喜欢电影 1,50 的人分别为 50,100 但是 {1,50} 的集合有 100 个
    # 两个原因，第一在 current_superset 时项集有时候会突然调换位置
    def find_frequent_itemsets(
            favorable_reviews_by_users,
            k_1_itemsets,
            min_support):
        counts = defaultdict(int)
        # 遍历每一个用户，获取其喜欢的电影
        for user, reviews in favorable_reviews_by_users.items():
            # 遍历每个项集
            for itemset in k_1_itemsets:
                if itemset.issubset(reviews):  # 判断 itemset 是否是用户喜欢的电影的子集
                    # 对用户喜欢的电影中除了这个子集的电影进行遍历
                    for other_reviewed_movie in reviews - itemset:
                        # 将该电影并入项集中
                        current_superset = itemset | frozenset(
                            {other_reviewed_movie})
                        counts[current_superset] += 1  # 这个项集的支持度 +1
        # 返回元素数目 +1 的项集和数量
        res = dict([(itemset, frequency) for itemset,
                                             frequency in counts.items() if frequency >= min_support])
        return res

    for k in range(2, 20):
        cur_frequent_itemsets = find_frequent_itemsets(
            favorable_reviews_by_users, frequent_itemsets[k - 1], min_support)
        frequent_itemsets[k] = cur_frequent_itemsets
        if len(cur_frequent_itemsets) == 0:
            print("Did not find any frequent itemsets of length {}".format(k))
            sys.stdout.flush()  # 将缓冲区内容输出到终端，不宜多用，输出操作带来的计算开销会拖慢程序运行速度
            break
        else:
            print(
                "I found {} frequent itemsets of length {}".format(
                    len(cur_frequent_itemsets), k))
            sys.stdout.flush()
    # 除去只包含一个元素的初始集合
    del frequent_itemsets[1]

1
2
3
4
5
6
7
8

    # 规则形式：如果用户喜欢前提中的所有电影，那么他们也会喜欢结论中的电影
    candidate_rules = []
    for itemset_length, itemset_counts in frequent_itemsets.items():
        for itemset in itemset_counts.keys():
            for conclusion in itemset:
                premise = itemset - {conclusion}
                candidate_rules.append((premise, conclusion))
    print(candidate_rules[:5])

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

    # 计算置信度
    correct_counts = defaultdict(int)
    incorrect_counts = defaultdict(int)

    # 遍历每一个用户，获取其喜欢的电影
    for user, reviews in favorable_reviews_by_users.items():
        # 遍历每个规则
        for candidate_rule in candidate_rules:
            # 获取规则的条件和结论
            premise, conclusion = candidate_rule
            # 如果条件是喜欢电影的子集（条件成立）
            if premise.issubset(reviews):
                # 如果用户也喜欢结论的电影
                if conclusion in reviews:
                    correct_counts[candidate_rule] += 1
                else:
                    incorrect_counts[candidate_rule] += 1
    # 计算置信度，结论发生的次数除以条件发生的次数
    rule_confidence = {
        candidate_rule: correct_counts[candidate_rule] /
        float(
            correct_counts[candidate_rule] +
            incorrect_counts[candidate_rule]) for candidate_rule in candidate_rules}
    # 给置信度排序
    sorted_confidence = sorted(
        rule_confidence.items(),
        key=itemgetter(1),
        reverse=True)
    for index in range(5):
        print("Rule #{}".format(index + 1))
        (premise, conclusion) = sorted_confidence[index][0]
        print(
            "Rule: If a person recommends {} they will also recommand {}".format(
                premise,
                conclusion))
        print(
            "- Confidence: {0:.3f}".format(rule_confidence[(premise, conclusion)]))
        print("--------------------")

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

    movie_name_data = pd.read_csv(
        "ml-100k/u.item",
        delimiter='|',
        header=None,
        encoding="mac-roman")
    movie_name_data.columns = [
        'MovieID',
        'Title',
        'Release Date',
        'Video Release',
        'IMDB',
        '<UNK>',
        'Action',
        'Adventure',
        'Animation',
        "Children's",
        'Comedy',
        'Crime',
        'Documentary',
        'Drama',
        'Fantasy',
        'Film-Noir',
        'Horror',
        'Musical',
        'Mystery',
        'Romance',
        'Sci-Fi',
        'Thriller',
        'War',
        'Western']

    for index in range(5):
        print('Rule #{0}'.format(index + 1))
        (premise, conclusion) = sorted_confidence[index][0]
        premise_names = ', '.join(get_movie_name(idx) for idx in premise)
        conclusion_name = get_movie_name(conclusion)
        print(
            'Rule: if a person recommends {0} they will also recommend {1}'.format(
                premise_names,
                conclusion_name))
        print(
            ' - Confidence: {0:.3f}'.format(rule_confidence[(premise, conclusion)]))
        print("--------------------")

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

    # 评估测试
    test_dataset = all_ratings[~all_ratings['UserID'].isin(range(200))]
    test_favorable = test_dataset[test_dataset["Favorable"]]
    test_favorable_by_users = dict((k, frozenset(v.values))
                                   for k, v in test_favorable.groupby("UserID")["MovieID"])

    correct_counts = defaultdict(int)
    incorrect_counts = defaultdict(int)
    for user, reviews in test_favorable_by_users.items():
        for candidate_rule in candidate_rules:
            premise, conclusion = candidate_rule
            if premise.issubset(reviews):
                if conclusion in reviews:
                    correct_counts[candidate_rule] += 1
                else:
                    incorrect_counts[candidate_rule] += 1

    test_confidence = {
        candidate_rule: correct_counts[candidate_rule] /
        float(
            correct_counts[candidate_rule] +
            incorrect_counts[candidate_rule]) for candidate_rule in rule_confidence}
    for index in range(5):
        print("Rule #{0}".format(index + 1))
        (premise, conclusion) = sorted_confidence[index][0]
        premise_names = ", ".join(get_movie_name(idx) for idx in premise)
        conclusion_name = get_movie_name(conclusion)
        print(
            'Rule: if a person recommends {0} they will also recommend {1}'.format(
                premise_names,
                conclusion_name))
        print(
            ' - Confidence: {0:.3f}'.format(rule_confidence[(premise, conclusion)]))
        print("--------------------")

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

import numpy as np
import pandas as pd

if __name__ == '__main__':
    adult = pd.read_csv("adult.data", header=None, names=["Age", "Work-Class", "fnlwgt", "Education",
                                                          "Education-Num", "Marital-Status", "Occupation",
                                                          "Relationship", "Race", "Sex", "Capital-gain",
                                                          "Capital-loss", "Hours-per-week", "Native-Country",
                                                          "Earnings-Raw"])
    # 去除空值
    adult.dropna(how='all', inplace=True)
    # 输出详细描述
    print(adult["Hours-per-week"].describe())
    # 输出中位数
    print(adult["Education-Num"].median())
    # 输出工作的种类
    print(adult["Work-Class"].unique())
    # 将工作时长二值化为是否超过 40h
    adult["LongHours"] = adult["Hours-per-week"] > 40

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

    # 构造测试数据集
    X = np.arange(30).reshape((10, 3))
    X[:, 1] = 1
    print(X)
    print("----------------")
    vt = VarianceThreshold()
    Xt = vt.fit_transform(X)
    # 第二列消失了，因为第二列都是 1，方差为 0，不包括具有区别意义的信息
    print(Xt)
    print("----------------")
    print(vt.variances_)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

    # 构造数据集
    X = adult[["Age",
               "Education-Num",
               "Capital-gain",
               "Capital-loss",
               "Hours-per-week"]]
    y = (adult["Earnings-Raw"] == ' >50K').values
    # 使用 SelectKBest 转换器，用卡方打分
    transformer = SelectKBest(score_func=chi2, k=3)
    # 调用 fit_transform 方法对相同的数据集进行预处理和转换
    Xt_chi2 = transformer.fit_transform(X, y)
    # 输出每个特征的得分
    print(transformer.scores_)
    print("----------------")

    # 用皮尔逊相关系数计算相关性，创建包装函数
    def mutivariate_pearsonr(X, y):
        scores, pvalues = [], []
        for column in range(X.shape[1]):
            cur_score, cur_p = pearsonr(X[:, column], y)
            scores.append(abs(cur_score))
            pvalues.append(cur_p)
        return np.array(scores), np.array(pvalues)

    transformer = SelectKBest(score_func=mutivariate_pearsonr, k=3)
    Xt_pearson = transformer.fit_transform(X, y)
    print(transformer.scores_)
    print("----------------")

    clf = DecisionTreeClassifier(random_state=14)
    scores_chi2 = cross_val_score(clf, Xt_chi2, y, scoring='accuracy')
    scores_pearson = cross_val_score(clf, Xt_pearson, y, scoring='accuracy')
    print('卡方：{}'.format(np.mean(scores_chi2)))
    print("----------------")
    print("pearson:  {}".format(np.mean(scores_pearson)))

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

# -*- coding: utf-8 -*-
import numpy as np
import pandas as pd
from collections import defaultdict
from sklearn.decomposition import PCA
from sklearn.tree import DecisionTreeClassifier
from sklearn.model_selection import cross_val_score
from matplotlib import pyplot as plt


# 创建转换函数
def convert_number(x):
    try:
        res = float(x)
        return res
    except ValueError:
        return np.nan


if __name__ == '__main__':
    # 创建数据加载的转换器
    converters = defaultdict(convert_number, {i: convert_number for i in range(1588)})
    converters[1558] = lambda x: 1 if x.strip() == "ad." else 0
    # 使用转换器读取数据集
    temp = pd.read_csv("ad.data", header=None, converters=converters)
    # 删除所有含有 nan 的行，axis=0 是数据索引 (index)，axis=1 是列标签 (column)
    ads = temp.dropna(axis=0, how='any')
    print(ads[10:15])

1
2
3
4
5
6
7
8
9

    X = ads.drop(1558, axis=1).values
    y = ads[1558]
    # 参数为主成分数量
    pca = PCA(n_components=5)
    Xd = pca.fit_transform(X)
    # 设置输出选项
    # 第一个参数为输出精度位数，第二个参数是使用定点表示法打印浮点数
    np.set_printoptions(precision=3, suppress=True)
    print(pca.explained_variance_ratio_)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

    clf = DecisionTreeClassifier(random_state=14)
    scores_reduced = cross_val_score(clf, Xd, y, scoring='accuracy')
    print(np.mean(scores_reduced))

    # 获取数据集类别的所有取值
    classes = set(y)
    # 指定在图形中用什么颜色表示这两个类别
    colors = ['red', 'green']
    # 同时遍历这两个容器
    for cur_class, color in zip(classes, colors):
        # 为属于当前类别的所有个体创建遮罩层
        mask = (y == cur_class).values
        plt.scatter(Xd[mask, 0], Xd[mask, 1], marker='o',
                    color=color, label=int(cur_class))
    plt.legend()
    plt.show()

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

# -*- coding: utf-8 -*-
import numpy as np
from sklearn.base import TransformerMixin
from sklearn.utils import as_float_array
from numpy.testing import assert_array_equal


class MeanDiscrete(TransformerMixin):
    def fit(self, X):
        # 尝试对 X 进行转换，数据转换成 float 类型
        X = as_float_array(X)
        # 计算数据集的均值
        self.mean = X.mean(axis=0)
        # 返回它本身，进行链式调用 transformer.fit(X).transform(X)
        return self

    def transform(self, X):
        X = as_float_array(X)
        # 检查输入是否合法
        assert X.shape[1] == self.mean.shape[0]
        # 返回 X 中大于均值的数据
        return X > self.mean


def test_meandiscrete():
    X_test = np.array([[0, 2], [3, 5], [6, 8], [9, 11], [12, 14], [15, 17], [18, 20], [21, 23], [24, 26], [27, 29]])
    mean_discrete = MeanDiscrete()
    mean_discrete.fit(X_test)
    # 与正确的计算结果进行比较，检查内部参数是否正确设置
    assert_array_equal(mean_discrete.mean, np.array([13.5, 15.5]))
    # 转换后的 X
    X_transfromed = mean_discrete.transform(X_test)
    # 验证数据
    X_expected = np.array([[0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [1, 1], [1, 1], [1, 1], [1, 1], [1, 1]])
    assert_array_equal(X_transfromed, X_expected)


if __name__ == '__main__':
    test_meandiscrete()