课程介绍
课程名称：Python3入门机器学习 经典算法与应用 入行人工智能
课程章节：4-3；4-4
主讲老师：liuyubobobo
内容导读
- 第一部分 训练数据集，测试数据集
- 第二部分 分类准确度
- 第三部分 scikit-learn中的accuracy_score
- 第四部分 代码展示
课程详细
第一部分 训练数据集，测试数据集
将原始数据分开来，一部分用来训练模型，一部分用来测试模型 来判断机器学习算法的性能
#准备工作，导入函数和载入数据
import numpy as np
import matplotlib.pyplot as plt
from sklearn import datasets
iris = datasets.load_iris()
X = iris.data
y = np.array(iris.target).reshape(-1,1)
第一步就是对函数进行切割以分成训练数据集，测试数据集
#我这里使用的是，y放到X矩阵的右边
#老师使用的是，对y索引进行随机排序，并切分，然后用排序获得训练集X，y
#和测试数据集X，y
X_y=np.concatenate([X,y.reshape[-1,1]],axis=1)
#输入分割点，
train_size = int(X_y.shape[0] * 0.7)
#然后将合并后的矩阵按行随机排序
np.random.shuffle(X_y)
#然后将随机排序后的矩阵，从70%的位置分为两份数据
X_y , X_y_train = np.split(X_y, [train_size], axis=0)
#通过切片分别赋值
X_train = X_y[:,:-2]
y_train = X_y[:,-1]
X_test = X_y_train[:,:-2]
y_test = X_y_train[:,-1]
使用我后面的的代码来展示怎么使用两个数据集
from nike.model import train_test_split
#导入我们python写的函数
#%run nike/model.py
#输入原始数据，并自动进行分割
X_train,X_test,y_train,y_test = train_test_split(X, y)
#输出文字检测
print(X_train.shape)
print(y_train.shape)
print(X_test.shape)
print(y_test.shape)
#导入自己写的KNN函数
from nike.KNN2 import KNNClassifier
#输入k创建对象
my_knn_clf = KNNClassifier(k=3)
#输入拟合数据，进行训练
my_knn_clf.fit(X_train, y_train)
#输入测试数据，得出预测的数据的y
y_predict = my_knn_clf.predict(X_test)
#通过比较两个y_predict和y_test来确认有几个函数是正确的
y_predict_true = sum(y_predict == y_test)
#与总数相除得出准确率
y_predict_true/len(y_test)
#0.9333333333333333
第二部分 分类准确度
多种方式来使用准确度
#准备工作
import numpy as np
import matplotlib
import matplotlib.pyplot as plt
from sklearn import datasets
#载入手写数字，函数
digits = datasets.load_digits()
#查看一下有什么键值
digits.keys()
#阅读文档内容
print(digits.DESCR)
#载入特征量X，一共有(1797, 64)
X = digits.data
X.shape
#载入y值，一共有(1797,)
y = digits.target
y.shape
#查看y有哪几种分类，，为0-9的数字
digits.target_names
#通过观察y的前100个数字也可以得出相同的结论
y[:100]
#取出一个数，来可视化看看
some_digit = X[666]
#y是多少_>>0
y[666]
#一个很cool的可视化的过程
#是一个手写数字0
some_digit_image = some_digit.reshape(8, 8)
plt.imshow(some_digit_image, cmap = matplotlib.cm.binary)
plt.show()
#from nike.model_selection import train_test_split
#对数据进行随机排列和拆分
%run nike\model_selection.py
X_train, X_test, y_train, y_test = train_test_split(X, y, train_ratio=0.8)
#导入knn运算过程
%run nike\KNN2.py
#创建对象，调整参数k=3
my_knn_clf = KNNClassifier(k=3)
#输入数据，拟合函数，
my_knn_clf.fit(X_train,y_train)
第一种求准确度的方法，就是求出预测值，自己进行计算
#得出预测值
y_predict = my_knn_clf.predict(X_test)
sum(y_predict == y_test) / len(y_test)
第二种就是封装一个函数，输入得到的预测值，来计算
%run nike\metrics
accuracy_score(y_test, y_predict)
第三种就是直接在knn函数内调用计算，这样预测值可以摈弃
my_knn_clf.score(X_test, y_test)
第三部分 scikit-learn中的accuracy_score
#别人写的函数，的随即拆分的方法
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)
#别人的knn算法
from sklearn.neighbors import KNeighborsClassifier
knn_clf = KNeighborsClassifier(n_neighbors=3)
knn_clf.fit(X_train, y_train)
y_predict = knn_clf.predict(X_test)
#别人的计算准确度的方法
from sklearn.metrics import accuracy_score
accuracy_score(y_test, y_predict)
#0.9916666666666667
#其实scikit-learn中页自己封装了一个直接看准确率的方法
knn_clf.score(X_test, y_test)
#0.9916666666666667
第四部分 代码展示
KNN算法实现
import numpy as np
from math import sqrt
from collections import Counter
from metrics import accuracy_score
class KNNClassifier:
def __init__(self, k):
assert k>=1,'k is small'
#赋值
self.k = k
self._X_train = None
self._y_train = None
def fit(self,X_train, y_train):
"""根据训练数据集X_train 和 y_train训练KNN分类器。
就KNN算法而言其实没有训练fit的过程"""
#判断X和y的训练量是否相同
assert X_train.shape[0] == y_train.shape[0], \
'the data X_train and y_train is mismatch'
#判断k是不是小于X_train
assert self.k <= X_train.shape[0], \
'k is big to X_train'
self._X_train = X_train
self._y_train = y_train
return self
def predict(self,X_predict):
#判断训练量不为空
assert self._X_train is not None and self._y_train is not None ,\
'No X_train and y_train'
#判断新的数据与与测量特征量相同
assert X_predict.shape[1] == self._X_train.shape[1],\
'X_predict and _X_train 特征 is not same'
#调用私有方法，返回预测的y的值
y_predict = [self._predict(x) for x in X_predict]
return np.array(y_predict)
def _predict(self,x):
"给定单个待预测数据x，返回x的预测结果值"
assert x.shape[0] ==self._X_train.shape[1],\
'x 特征 is not X_train'
# 算出每个data中x与新增x的欧几里和距离
distances = [sqrt(np.sum((x_train - x) ** 2)) for x_train in self._X_train ]
# 排序并用下标表示，从小到大
nearest = np.argsort(distances)
# 表达式，分别算出第k个下标下的y的原始值
topK_y = [self._y_train[i] for i in nearest[:self.k]]
# 算出这个topK_y中的数据种类和数量
votes = Counter(topK_y)
# 返回，数量最大的数量种类和数量数量
return votes.most_common(1)[0][0]
def score(self,X_text, y_text):
"""根据测试数据集X_test 和 y_test 确定当前模型准确度"""
y_predict = self.predict(X_text)
return accuracy_score(y_text, y_predict)
def __repr__(self):
return "KNN(k=%d)"%self.k
model_selection算法实现
将输入的X和y按照给定或者默认的test_ratio的比例进行分割"
def train_test_split(X, y, train_ratio=0.7, seed=None):
"""将输入的X和y按照给定或者默认的test_ratio的比例进行分割"""
assert X.shape[0] == y.shape[0],\
'the size of X must be equal to the size of y'
assert 0.0< train_ratio <=1.0,\
'test_ratio must be valid'
#随机种子，用于两次随机一致的数据
if seed:
np.random.seed(seed)
# 我这里使用的是，y放到X矩阵的右边,一起进行随机操作
X_y = np.concatenate([X, y.reshape(-1,1)], axis=1)
# 输入分割点，
train_size = int(X_y.shape[0] * train_ratio)
# 然后将合并后的矩阵按行随机排序
np.random.shuffle(X_y)
# 然后将随机排序后的矩阵，从train_ratio的位置分为两份数据
X_y, X_y_train = np.split(X_y, [train_size], axis=0)
# 通过切片分别赋值
X_train = X_y[:, :-2]
y_train = X_y[:, -1]
X_test = X_y_train[:, :-2]
y_test = X_y_train[:, -1]
# print(type(X_train),type(X_test),type(y_train),type(y_test))
return X_train,X_test,y_train,y_test
metrice实现
我这里就简单的实现了，准确率的计算，这个函数里可以度量各种性能或者指标，距离，相似性
def accuracy_score(y_true, y_predict):
assert y_true.shape[0] == y_predict.shape[0],\
'the size of y_true mus be equal to ' \
'the size of y_predict'
return sum(y_true ==y_predict) / len(y_predict)
课程思考
虽然今天只看了两章，但是其实是学习量最大的一天，代码细节暂且不提，对于KNN算法竟然对手写数字和鸢尾花有极高的准确率是我所没想到的，不知道是数据整齐，还是这个算法简单就是最好的，希望能多多学习不同的算法。