Press "Enter" to skip to content

机器学习-如何评价模型的好坏

本站内容均来自兴趣收集,如不慎侵害的您的相关权益,请留言告知,我们将尽快删除.谢谢.

为什幺要进行数据的拆分? 假如我们训练好了一个模型,那幺这个模型应该通过什幺途径来进行测试呢?我们怎幺知道这个模型预测的最终结果是最精准的呢?

 

这个就需要进行数据的拆分,把原始数据集拆分为训练数据集和测试数据集。

训练数据集专门用于训练模型
测试数据集专门用于测试模型好坏,然后再不断对模型进行修改

1.我们使用鸢尾花数据集,该数据集是UCI数据库中常用数据集。我们可以直接加载数据集,并尝试对数据进行一定探索:

 

import numpy as np
from sklearn import datasets
import matplotlib.pyplot as plt
iris = datasets.load_iris()
X = iris.data
Y = iris.target
print(X.shape)
print(Y.shape)

 

代码调试:

得到结果:

 

(150, 4)
(150,)

 

2.进行训练数据集、测试数据集的拆分工作(train_test_split)。

 

一般情况下我们按照0.8:0.2的比例进行拆分,但是有时候我们不能简单地把前n个数据作为训练数据集,后n个作为测试数据集。我们需要将该数据集打散,然后再抽样。

 

那幺为什幺需要从这份数据集里面分化训练和测试呢?

 

重点是保证训练数据集合测试数据集的一致性,一般随机抽取x%来做训练,剩下的测试模型。不过如果数据足够稳定,也有按日期分割的。

 

那幺为什幺需要将这份数据集打散呢?

 

为了防止过拟合 影响模型泛化能力。

 

为了解决这个问题,我们可以将数据集打乱,做一个shuffle操作。但是本数据集的特征和标签是分开的,也就是说我们分别乱序后,原来的对应关系就不存在了。有两种方法解决这一问题:

将X和y合并为同一个矩阵,然后对矩阵进行shuffle,之后再分解
对y的索引进行乱序,根据索引确定与X的对应关系,最后再通过乱序的索引进行赋值

第一种方法

 

# 方法1# 使用concatenate函数进行拼接,因为传入的矩阵必须具有相同的形状。因此需要对label进行reshape操作,reshape(-1,1)表示行数自动计算,1列。axis=1表示纵向拼接。
tempConcat = np.concatenate((X, y.reshape(-1,1)), axis=1)
# 拼接好后,直接进行乱序操作
np.random.shuffle(tempConcat)
# 再将shuffle后的数组使用split方法拆分
shuffle_X,shuffle_y = np.split(tempConcat, [4], axis=1)
# 设置划分的比例
test_ratio = 0.2
test_size = int(len(X) * test_ratio)
X_train = shuffle_X[test_size:]
y_train = shuffle_y[test_size:]
X_test = shuffle_X[:test_size]
y_test = shuffle_y[:test_size]
print(X_train.shape)
print(X_test.shape)
print(y_train.shape)
print(y_test.shape)

输出结果:

 

(120, 4)
(30, 4)
(120, 1)
(30, 1)

 

第二种方法

 

# 方法2# 将x长度这幺多的数,返回一个新的打乱顺序的数组,注意,数组中的元素不是原来的数据,而是混乱的索引
shuffle_index = np.random.permutation(len(X))
# 指定测试数据的比例
test_ratio = 0.2
test_size = int(len(X) * test_ratio)
test_index = shuffle_index[:test_size]
train_index = shuffle_index[test_size:]
X_train = X[train_index]
X_test = X[test_index]
y_train = y[train_index]
y_test = y[test_index]
print(X_train.shape)
print(X_test.shape)
print(y_train.shape)
print(y_test.shape)

输出结果:

 

(120, 4)
(30, 4)
(120,)
(30,)

 

3.编写自己的train_test_split

 

下面我们将编写自己的train_test_split,并封装成方法。

 

def train_test_split(X,y,test_ratio=0.2,seed=None):
    """将矩阵X和标签y按照test_ration分割成X_train, X_test, y_train, y_test"""
    # assert X.shape[0] == y.shape[0]       "the size of X must be equal to the size of y"
    # assert 0.0 <= test_ratio <= 1.0       "test_train must be valid"
    if seed:
        np.random.seed(seed)
    shuffle_index = np.random.permutation(len(X))
    test_size = int(len(X) * test_ratio)
    test_index = shuffle_index[:test_size]
    train_index = shuffle_index[test_size:]
    X_train = X[train_index]
    X_test = X[test_index]
    y_train = y[train_index]
    y_test = y[test_index]
    return X_train, X_test, y_train, y_test
X_train, X_test, y_train, y_test = train_test_split(X, y)
print(X_train.shape)
print(X_test.shape)
print(y_train.shape)
print(y_test.shape)

 

debug下可得:

输出结果:

 

(120, 4)
(30, 4)
(120,)
(30,)

 

4.sklearn中的train_test_split

 

我们自己写的train_test_split其实也是在模仿sklearn风格,更多的时候我们可以直接调用。

 

from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=666)
print(X_train.shape)
print(X_test.shape)
print(y_train.shape)
print(y_test.shape)

 

debug可得:

结果为:

 

(120, 4)
(30, 4)
(120,)
(30,)

 

二.分类准确度accuracy

 

在划分出测试数据集后,我们就可以验证其模型准确率了。在这了引出一个非常简单且常用的概念:accuracy(分类准确度)

 

accuracy_score:函数计算分类准确率,返回被正确分类的样本比例(default)或者是数量(normalize=False) 在多标签分类问题中, 该函数返回子集的准确率 ,对于一个给定的多标签样本,如果预测得到的标签集合与该样本真正的标签集合严格吻合,则subset accuracy =1.0否则是0.0

 

因accuracy定义清洗、计算方法简单,因此经常被使用。但是它在某些情况下并不一定是评估模型的最佳工具。 精度 (查准率)和 召回率 (查全率)等指标对衡量机器学习的模型性能在某些场合下要比accuracy更好。

 

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=666)
knn_clf = KNeighborsClassifier(n_neighbors=3)
knn_clf.fit(X_train, y_train)
y_predict = knn_clf.predict(X_test)
a=accuracy_score(y_test, y_predict)
print(y_predict)
# 不看y_predict
print(knn_clf.score(X_test,y_test))

 

debug结果:

输出结果:

 

1.0

 

三.超参数

 

3.1.超参数简介

 

之前我们都是为knn算法传一个默认的k值。在具体使用时应该传递什幺值合适呢?

 

这就涉及了机器学习领域中的一个重要问题:超参数。 所谓超参数,就是在机器学习算法模型执行之前需要指定的参数 。(调参调的就是超参数) 如kNN算法中的k。

 

与之相对的概念是模型参数,即算法过程中学习的属于这个模型的参数(kNN中没有模型参数,回归算法有很多模型参数)

 

如何选择最佳的超参数,这是机器学习中的一个永恒的问题。在实际业务场景中,调参的难度大很多,一般我们会业务领域知识、经验数值、实验搜索等方面获得最佳参数。

 

3.2 寻找好的k

 

针对于上一小节的手写数字识别分类代码,尝试寻找最好的k值。逻辑非常简单,就是设定一个初始化的分数,然后循环更新k值,找到最好的score

 

# 指定最佳值的分数,初始化为0.0;设置最佳值k,初始值为-1
best_score = 0.0
best_k = -1
for k in range(1, 11):  # 暂且设定到1~11的范围内
    knn_clf = KNeighborsClassifier(n_neighbors=k)
    knn_clf.fit(X_train, y_train)
    score = knn_clf.score(X_test, y_test)
    if score > best_score:
        best_k = k
        best_score = score
print("best_k = ", best_k)
print("best_score = ", best_score)

可以看到,最好的k值是1,在我们设定的k的取值范围中间。需要注意的是,如果我们得到的值正好在边界上,我们需要稍微扩展一下取值范围。因为嘛,你懂的!

 

3.3 另一个超参数:权重

 

在回顾kNN算法思想时,我们应该还记得,对于简单的kNN算法,只需要考虑最近的n个数据是什幺即可。但是如果我们考虑距离呢?

 

如果我们认为,距离样本数据点最近的节点,对其影响最大,那幺我们使用距离的倒数作为权重。假设距离样本点最近的三个节点分别是红色、蓝色、蓝色,距离分别是1、4、3。那幺普通的k近邻算法:蓝色获胜。考虑权重(距离的倒数):红色:1,蓝色:1/3 + 1/4 = 7/12,红色胜。

 

在 sklearn.neighbors 的构造函数 KNeighborsClassifier 中有一个参数:weights, 默认是uniform即不考虑距离 ,也可以写distance来考虑距离权重(默认是欧拉距离,如果要是曼哈顿距离,则可以写参数p(明可夫斯基距离的参数),这个也是超参数)

 

因为有两个超参数,因此使用双重循环,去查找最合适的两个参数,并打印。

 

# 两种方式进行比较
best_method = ""
best_score = 0.0
best_k = -1
for method in ["uniform","distance"]:
    for k in range(1, 11):
        knn_clf = KNeighborsClassifier(n_neighbors=k, weights=method, p=2)
        knn_clf.fit(X_train, y_train)
        score = knn_clf.score(X_test, y_test)
        if score > best_score:
            best_k = k
            best_score = score
            best_method = method
print("best_method = ", method)
print("best_k = ", best_k)
print("best_score = ", best_score)

3.4超参数网格搜索

 

在具体的超参数搜索过程中会需要很多问题, 超参数过多、超参数之间相互依赖 等等。如何一次性地把我们想要得到最好的超参数组合列出来。sklearn中专门封装了一个超参数网格搜索方法Grid Serach。

 

在进行网格搜索之前,首先需要定义一个搜索的参数param_search。是一个数组,数组中的每个元素是个字典,字典中的是对应的一组网格搜索,每一组网格搜索是这一组网格搜索每个参数的取值范围。键是参数的名称,值是键所对应的参数的列表。

 

param_search = [
    {        "weights":["uniform"],        "n_neighbors":[i for i in range(1,11)]
    },
    {        "weights":["distance"],        "n_neighbors":[i for i in range(1,11)],        "p":[i for i in range(1,6)]
    }
]

 

可以看到,当weights = uniform即不使用距离时,我们只搜索超参数k,当weights = distance即使用距离时,需要看超参数p使用那个距离公式。下面创建要进行网格搜索所对应的分类算法并调用刚哥搜索:

 

knn_clf = KNeighborsClassifier()
# 调用网格搜索方法
from sklearn.model_selection import GridSearchCV
# 定义网格搜索的对象grid_search,其构造函数的第一个参数表示对哪一个分类器进行算法搜索,第二个参数表示网格搜索相应的参数
grid_search = GridSearchCV(knn_clf, param_search)

 

下面就是针对X_train, y_train,使用grid_search在param_search列表中寻找最佳超参数组:

 

print(grid_search.fit(X_train, y_train))

 

得到结果:

可以使用网格搜索的评估函数来返回最佳分类起所对应的参数

 

# 返回的是网格搜索搜索到的最佳的分类器对应的参数
print(grid_search.best_estimator_)

也可以查看最佳参数的分类器的准确度。

 

我们会注意到,best_estimator_和best_score_参数后面有一个_。这是一种常见的语法规范,不是用户传入的参数,而是根据用户传入的规则,自己计算出来的结果,参数名字后面接_

 

总结

 

在这篇文章中,我们借助kNN分类算法,学习了如下知识点:

 

为了验证模型的好坏,将 数据集划分为训练数据集和测试数据集 ,这样我们就可以对测试数据集的进行预测,然后使用label进行验证。

 

在我们得到了分类结果之后,就可以使用分类正确的数据点比上总的测试数据点,这样就可以计算出accuracy分类精准度。

 

使用kNN算法对手写数字分类 当然,不同的评价指标有不同的使用场景,不能乱用。

 

最后我们以kNN算法为例,探究了不同的超参数对模型的影响,使用sklearn中封装好的网格搜索算法,可以帮助我们进行基础调参。

Be First to Comment

发表评论

邮箱地址不会被公开。 必填项已用*标注