1 python numpy 常用函数
1.1 cPickle
Python标准库提供pickle和cPickle模块用于序列化。pickle模块中的两个主要函数是dump()和load()。
1.2 numpy
numpy.concatenate 连接两个矩阵 可以是按行连接或按列连接
numpy.tile(arr, (x, y)) 用于扩充数组 如果是数组扩充几倍 如果是举证扩充 (x, y) x行y列
numpy.bincount(a) 返回索引值在 a 出现的次数 比 a 中最大值大 1
2 KNN 详细实现以及交叉验证
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import cPickle as pickle
import numpy as np
import os
import random
import matplotlib.pyplot as plt
def load_CIFAR_batch(filename):
with open(filename, 'r') as f: # rb
datadict = pickle.load(f)
X = datadict['data']
Y = datadict['labels']
X = X.reshape(10000, 3, 32, 32).transpose(0, 2, 3, 1).astype(float)
Y = np.array(Y) # 转换成一个 labels 的数组
# X 为 10000 * 3 * 32 * 32 的矩阵
return X, Y
def load_CIFAR1O(ROOT):
print('start load_CIFAR1O')
xs = []
ys = []
for b in range(1, 6):
f = os.path.join(ROOT, 'data_batch_%d' % (b, ))
X, Y = load_CIFAR_batch(f)
xs.append(X)
ys.append(Y)
Xtr = np.concatenate(xs)
Ytr = np.concatenate(ys)
del X, Y
Xte, Yte = load_CIFAR_batch(os.path.join(ROOT, 'test_batch'))
return Xtr, Ytr, Xte, Yte
class KNearestNeighbor:
def __init__(self):
pass
def train(self, X, y):
self.X_train = X # dataset
self.y_train = y # label
def predict(self, X, k=1):
dists = self.compute_distances_two_loops(X)
return self.predict_labels(dists, k=k)
def compute_distances_no_loops(self, X):
num_test = X.shape[0]
num_train = self.X_train.shape[0]
dists = np.zeros((num_test, num_train))
"""
公式: (x - y) ^2 = x^2 + y^2 -2xy
1 - np.sum( (self.X_train)**2, axis=1)
计算训练集列方向的和 得到列方向的距离数组 即 y^2
2 - np.tile( np.sum( (self.X_train)**2, axis=1), [num_test, 1])
将 y^2 数组扩充成 [num_test, 1] 既 num_test 行 1 列的矩阵 例如： [1, 2, 3, 4, 5]
3 - np.tile( np.sum( (X)**2, axis=1), [num_train, 1]).T
计算 x^2 数组并且扩充成 [num_train, 1].T 的矩阵 例如: [1, 1, 1, 2, 2].T
矩阵乘法是行乘以列这样来计算的所以需要转置
4 - 计算 xy 矩阵相乘
5 - 计算 x^2 + y^2 - 2xy 的值
"""
train_2 = np.tile( np.sum( (self.X_train)**2, axis=1), [num_test, 1])
test_2 = np.tile( np.sum( (X)**2, axis=1), [num_train, 1]).T
test_train = X.dot(self.X_train.T)
dists = train_2 + test_2 - 2*test_train
return dists
def predict_labels(self, dists, k=1):
"""
返回预测的 labels
"""
num_test = dists.shape[0]
y_pred = np.zeros(num_test)
for i in xrange(num_test):
# 得到最近的k个点索引id 再得到这些 索引对应的 label
# [:k] 表示从 [0:k]个点索引
closest_y = []
closest_idx = np.argsort(dists[i, :])[:k].tolist()
closest_y = self.y_train[closest_idx]
# numpy.bincount 返回索引值在 closest_y 出现的次数 比 closest_y 中最大值大 1
# 得到这k个点label出现的次数 选取出现次数最多的 label 为最好的结果
counts = np.bincount(closest_y)
y_pred[i] = np.argmax(counts)
return y_pred
cifar10_dir = 'datasets/cifar-10-batches-py'
X_train, y_train, X_test, y_test = load_CIFAR1O(cifar10_dir)
# 数据库中有5w张图片 这里只使用了 5k
num_training = 5000
mask = range(num_training)
X_train = X_train[mask]
y_train = y_train[mask]
num_test = 500
mask = range(num_test)
X_test = X_test[mask]
y_test = y_test[mask]
X_train = np.reshape(X_train, (X_train.shape[0], -1))
X_test = np.reshape(X_test, (X_test.shape[0], -1))
# 测试分类器
def test_classifier():
classifier = KNearestNeighbor()
classifier.train(X_train, y_train) # KNN 实际上没啥训练过程
y_test_pred = classifier.predict(k=5)
# 看下准确率
num_correct = np.sum(y_test_pred == y_test)
accuracy = float(num_correct) / num_test
print '%d个预测对了，总共%d个测试样本 => 准确率: %f' % (num_correct, num_test, accuracy)
# 交叉验证
def cost_validation():
# K 折交叉验证 1.选取 n 个不同的 k 2.把数据分成 m 份
# 每一个 k 在这 m 分数据上做预测 取平均值即为在这个k对应的准确值 然后再选取最优的
num_folds = 5 # 同一个k 5个结果取平均值
k_choices = [1, 3, 5, 8, 10, 12, 15, 20, 50, 100]
X_train_folds = []
y_train_folds = []
idxes = range(num_training)
idx_folds = np.array_split(idxes, num_folds)
for idx in idx_folds:
X_train_folds.append( X_train[idx] )
y_train_folds.append( y_train[idx] )
k_to_accuracies = {}
import sys
classifier = KNearestNeighbor()
Verbose = False
for k in k_choices:
if Verbose: print "processing k=%f" % k
else: sys.stdout.write('.')
k_to_accuracies[k] = list()
for num in xrange(num_folds):
if Verbose: print "processing fold#%i/%i" % (num, num_folds)
X_cv_train = np.vstack( [ X_train_folds[x] for x in xrange(num_folds) if x != num ])
y_cv_train = np.hstack( [ y_train_folds[x].T for x in xrange(num_folds) if x != num ])
# 需要特别主要的是交叉验证过程中不能用测试集上的数据 所以这里是选了训练集上的某折数据来当测试集
X_cv_test = X_train_folds[num]
y_cv_test = y_train_folds[num]
classifier.train(X_cv_train, y_cv_train)
dists = classifier.compute_distances_no_loops(X_cv_test)
y_cv_test_pred = classifier.predict_labels(dists, k=k)
num_correct = np.sum(y_cv_test_pred == y_cv_test)
k_to_accuracies[k].append( float(num_correct) / y_cv_test.shape[0] )
# 输出k和对应的准确率
for k in sorted(k_to_accuracies):
for accuracy in k_to_accuracies[k]:
print 'k = %d, accuracy = %f' % (k, accuracy)
best_k = 6 # 根据上面交叉验证的结果，咱们确定最合适的k值为6，然后重新训练和测试一遍吧
3 为什么 KNN 没法用于实际生产中？
1.准确度不高
2.需要大量的实时计算和耗费空间 KNN 在训练期间实际上没做什么事情
4 做N折交叉验证
N折交叉验证
1.选取 n 个不同的 k
2.把数据分成 m 份
3.对于每个k 都可以做m次训练 每次训练的时候
从这m中选一个当测试集而不能把预先的测试集拿来用
从 [1, m] 依次选取当测试集 其他的当数据集来预测
每一个 k 在这 m 分数据上做预测 取平均值即为在这个k对应的准确值
然后再选取最优的K来得到最好的预测结果
交叉验证
交叉验证的结果
网友评论