Upload 9 files

.gitattributes

@@ -32,3 +32,9 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+cifar-10-batches-py/data_batch_1 filter=lfs diff=lfs merge=lfs -text
+cifar-10-batches-py/data_batch_2 filter=lfs diff=lfs merge=lfs -text
+cifar-10-batches-py/data_batch_3 filter=lfs diff=lfs merge=lfs -text
+cifar-10-batches-py/data_batch_4 filter=lfs diff=lfs merge=lfs -text
+cifar-10-batches-py/data_batch_5 filter=lfs diff=lfs merge=lfs -text
+cifar-10-batches-py/test_batch filter=lfs diff=lfs merge=lfs -text

all.py

@@ -0,0 +1,223 @@
+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)
+

cifar-10-batches-py/data_batch_1

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:54636561a3ce25bd3e19253c6b0d8538147b0ae398331ac4a2d86c6d987368cd
+size 31035704

cifar-10-batches-py/data_batch_2

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:766b2cef9fbc745cf056b3152224f7cf77163b330ea9a15f9392beb8b89bc5a8
+size 31035320

cifar-10-batches-py/data_batch_3

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0f00d98ebfb30b3ec0ad19f9756dc2630b89003e10525f5e148445e82aa6a1f9
+size 31035999

cifar-10-batches-py/data_batch_4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3f7bb240661948b8f4d53e36ec720d8306f5668bd0071dcb4e6c947f78e9682b
+size 31035696

cifar-10-batches-py/data_batch_5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d91802434d8376bbaeeadf58a737e3a1b12ac839077e931237e0dcd43adcb154
+size 31035623

cifar-10-batches-py/readme.html

@@ -0,0 +1 @@
+<meta HTTP-EQUIV="REFRESH" content="0; url=http://www.cs.toronto.edu/~kriz/cifar.html">

cifar-10-batches-py/test_batch

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f53d8d457504f7cff4ea9e021afcf0e0ad8e24a91f3fc42091b8adef61157831
+size 31035526