import os from sklearn.preprocessing import OneHotEncoder # 独热编码 import numpy as np import pickle as pk # 载入数据 def load_batch(file): # 读取一个批次的数据 with open(file, 'rb') as f: data_dict = pk.load(f, encoding='bytes') images = data_dict[b'data'] labels = data_dict[b'labels'] images = images.reshape(10000, 3072) labels = np.array(labels) return (images / 255), labels def load_data(data_dir): images_train = [] labels_train = [] for i in range(5): file = os.path.join(data_dir, 'data_batch_%d' % (i + 1)) print('加载文件：', file) # 按批次读取训练集数据并拼接到图像和标签列表后，直到读入所有批次数据 images_batch, labels_batch = load_batch(file) images_train.append(images_batch) labels_train.append(labels_batch) # 将多个批次的数组统一为一个数组 x_train = np.concatenate(images_train) t_train = np.concatenate(labels_train) del images_batch, labels_batch # 加载测试集图像和标签 x_test, t_test = load_batch(os.path.join(data_dir, 'test_batch')) return x_train, t_train, x_test, t_test def sigmoid(x): return 1 / (1 + np.exp(-x)) def sigmoid_grad(x): return (1.0 - sigmoid(x)) * sigmoid(x) def softmax(x): if x.ndim == 2: x = x.T x = x - np.max(x, axis=0) y = np.exp(x) / np.sum(np.exp(x), axis=0) return y.T x = x - np.max(x) # 溢出对策 return np.exp(x) / np.sum(np.exp(x)) class neuralNetwork: def __init__(self, numNeuronLayers, numNeurons_perLayer, learningRate): self.numNeurons_perLayer = numNeurons_perLayer self.numNeuronLayers = numNeuronLayers self.learningRate = learningRate self.weight = [] self.bias = [] for i in range(numNeuronLayers): self.weight.append( learningRate * np.random.randn(self.numNeurons_perLayer[i], self.numNeurons_perLayer[i + 1])) self.bias.append(np.zeros(self.numNeurons_perLayer[i + 1])) def predict(self, x): z = x # 走一遍前向传播得到输出 for i in range(self.numNeuronLayers - 1): a = np.dot(z, self.weight[i]) + self.bias[i] z = sigmoid(a) an = np.dot(z, self.weight[self.numNeuronLayers - 1]) + self.bias[self.numNeuronLayers - 1] y = softmax(an) return y def gradient(self, x, t): z = [] a = [] z.append(x) # 走一遍前向传播得到输出 for i in range(self.numNeuronLayers): a.append(np.dot(z[i], self.weight[i]) + self.bias[i]) z.append(sigmoid(a[i])) y = softmax(a[self.numNeuronLayers - 1]) num = x.shape[0] dy = (y - t) / num dz = [] da = [] dz.append(dy) for i in range(self.numNeuronLayers - 1): da.append(np.dot(dz[i], self.weight[self.numNeuronLayers - i - 1].T)) dz.append(sigmoid_grad(a[self.numNeuronLayers - i - 2]) * da[i]) for i in range(self.numNeuronLayers): self.weight[i] -= self.learningRate * np.dot(z[i].T, dz[self.numNeuronLayers - i - 1]) self.bias[i] -= self.learningRate * np.sum(dz[self.numNeuronLayers - i - 1], axis=0) def loss(self, x, t): y = self.predict(x) t = t.argmax(axis=1) num = y.shape[0] s = y[np.arange(num), t] return -np.sum(np.log(s)) / num def accuracy(self, x, t): y = self.predict(x) p = np.argmax(y, axis=1) q = np.argmax(t, axis=1) acc = np.sum(p == q) / len(y) return acc def kNN(x_train, x_test, t_train, k): px = list() for i in range(len(x_test)): px.append([]) for j in range(10): px[i].append(0) for i in range(len(x_test)): dis = getODistance(x_test[i], x_train) index = np.argsort(dis) count = list() r = np.sort(dis)[k - 1] for j in range(len(t_train[0])): count.append(0) for j in range(k): for w in range(10): if t_train[index[j]][w] == 1: count[w] = count[w] + 1 for j in range(10): px[i][j] = count[j] return px def getODistance(sample, train): a = np.tile(sample, [1000, 1]) a = a - train a = np.square(a) a = a.sum(axis=1) dis = np.sqrt(a) dis = dis.T dis = dis.tolist() return dis[0] def runNetwork(): numNeuronLayers = 3 numNeurons_perLayer = [3072, 50, 20, 10] learningRate = 0.05 epoch = 50000 batch_size = 100 train_size = x_train.shape[0] # 50000 net = neuralNetwork(numNeuronLayers, numNeurons_perLayer, learningRate) for i in range(epoch): batch_mask = np.random.choice(train_size, batch_size) # 从0到50000 随机选100个数 x_batch = x_train[batch_mask] t_batch = t_train[batch_mask] net.gradient(x_batch, t_batch) y = net.predict(x_test[0:1000, 0:3072]) p = np.argmax(y, axis=1) q = np.argmax(t_test[0:1000, 0:3072], axis=1) acc = np.sum(p == q) / len(y) print("神经网络正确率为：", acc) return p def runKnn(x_train, x_test): x_train = np.mat(x_train) x_test = np.mat(x_test) px = kNN(x_train[0:1000, 0:3072], x_test[0:1000, 0:3072], t_train[0:1000, 0:10], 7) p = np.argmax(px, axis=1) q = np.argmax(t_test[0:1000, 0:3072], axis=1) acc = np.sum(p == q) / 1000 print("knn正确率为：", acc) return p from sklearn import svm def runSvm(): clf = svm.SVC(probability=True) t = np.argmax(t_train[0:1000, 0:3072], axis=1) clf.fit(x_train[0:1000, 0:3072], t) p = clf.predict(x_test[0:1000, 0:3072]) q = np.argmax(t_test[0:1000, 0:3072], axis=1) acc = np.sum(p == q) / 1000 print("svm正确率为：", acc) return p data_dir = 'cifar-10-batches-py' x_train, t_train, x_test, t_test = load_data(data_dir) encoder = OneHotEncoder(sparse=False) one_format = [[0], [1], [2], [3], [4], [5], [6], [7], [8], [9]] encoder.fit(one_format) t_train = t_train.reshape(-1, 1) # 数组化为一维包含一个元素的二维数组，-1代表二维的数量自适应 t_train = encoder.transform(t_train) t_test = t_test.reshape(-1, 1) t_test = encoder.transform(t_test) p1 = runNetwork() p2 = runSvm() p3 = runKnn(x_train, x_test) p1 = p1.reshape(-1, 1) # 数组化为一维包含一个元素的二维数组，-1代表二维的数量自适应 p1 = encoder.transform(p1) p2 = p2.reshape(-1, 1) p2 = encoder.transform(p2) p3 = p3.reshape(-1, 1) p3 = encoder.transform(p3) vote = p1+p2+p3 p = np.argmax(vote, axis=1) q = np.argmax(t_test[0:1000, 0:3072], axis=1) acc = np.sum(p == q) / 1000 print("最终正确率为", acc)