【学习打卡】第8天 Python3入门机器学习

课程介绍

---

课程名称：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算法竟然对手写数字和鸢尾花有极高的准确率是我所没想到的，不知道是数据整齐，还是这个算法简单就是最好的，希望能多多学习不同的算法。

课程截图

---