Upload 20 files

Attributes.txt

@@ -0,0 +1,40 @@
+0: denotes that the attribute is number;
+1: denotes that the attribute is nominal.
+
+aut = [0,1,1,1,1,1,1,1,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0];
+aba = [1,0,0,0,0,0,0,0];
+bal = [0,0,0,0];
+car = [1,1,1,1,1,1];
+cle = [0,1,1,0,0,1,1,0,1,0,1,1,1];
+con = [0,0,0,0,1,1,0,0,1];
+der = [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0];
+eco = [0,0,0,0,0,0,0];
+fla = [1,1,1,1,1,1,1,1,1,1,1];
+gla = [0,0,0,0,0,0,0,0,0];
+hay = [0,0,0,0];
+iri = [0,0,0,0];
+kr-vs-k = [1,1,1,1,1,1];
+led = [1,1,1,1,1,1,1];
+let = [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0];
+lym = [1,1,1,1,1,1,1,1,0,0,1,1,1,1,1,1,1,0];
+mar = [0,0,0,0,0,0,0,0,0,0,0,0,0];
+mov = [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0];
+new = [0,0,0,0,0];
+nur = [1,1,1,1,1,1,1,1];
+OPT = [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0];
+pag = [0,0,0,0,0,0,0,0,0,0];
+pen = [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0];
+sat = [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0];
+shu = [0,0,0,0,0,0,0,0,0];
+seg = [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0];
+spl = [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1];
+tae = [1,1,1,1,0];
+tex = [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0];
+thy = [0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0];
+veh = [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0];
+vow = [0,0,0,0,0,0,0,0,0,0,0,0,0];
+win = [0,0,0,0,0,0,0,0,0,0,0,0,0];
+wqr = [0,0,0,0,0,0,0,0,0,0,0];
+wqw = [0,0,0,0,0,0,0,0,0,0,0];
+yea = [0,0,0,0,0,0,0,0];
+zoo = [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1];

BP神经网络对excel文件数据，小批量训练并且包含交叉验证.py

@@ -0,0 +1,140 @@
+import numpy as np
+import pandas as pd
+import os
+
+class Network(object):
+    def __init__(self, sizes):
+        self.num_layers = len(sizes)
+        self.sizes = sizes
+        self.biases = [np.random.randn(y, 1) for y in sizes[1:]]
+        self.weights = [np.random.randn(y, x) for x, y in zip(sizes[:-1], sizes[1:])]
+    
+    def feedforward(self, a):
+        for b, w in zip(self.biases, self.weights):
+            a = sigmoid(np.dot(w, a) + b)
+        return a
+    
+    def SGD(self, training_data, epochs, mini_batch_size, eta, k, file_name):
+        n = len(training_data)
+        for j in range(epochs):
+            np.random.shuffle(training_data)
+            folds = [training_data[i::k] for i in range(k)]
+
+            # 在每个 epoch 的开始打印文件名和 epoch 信息
+            if j == 0:
+                print(f"\nTraining on file: {file_name}")
+            print(f"\nEpoch {j}:")
+            
+            for i in range(k):
+                validation_data = folds[i]
+                train_data = [item for fold in folds if fold is not validation_data for item in fold]
+
+                for mini_batch in [train_data[m:m+mini_batch_size] for m in range(0, len(train_data), mini_batch_size)]:
+                    self.update_mini_batch(mini_batch, eta)
+
+                # 在每个 fold 结束后打印验证结果
+                print(f"Fold {i}: {self.evaluate(validation_data)}/{len(validation_data)}")
+
+                
+                
+    def update_mini_batch(self, mini_batch, eta):
+        nabla_b = [np.zeros(b.shape) for b in self.biases]
+        nabla_w = [np.zeros(w.shape) for w in self.weights]
+        for x, y in mini_batch:
+            delta_nabla_b, delta_nabla_w = self.backprop(x, y)
+            nabla_b = [nb + dnb for nb, dnb in zip(nabla_b, delta_nabla_b)]
+            nabla_w = [nw + dnw for nw, dnw in zip(nabla_w, delta_nabla_w)]
+        self.weights = [w - (eta / len(mini_batch)) * nw for w, nw in zip(self.weights, nabla_w)]
+        self.biases = [b - (eta / len(mini_batch)) * nb for b, nb in zip(self.biases, nabla_b)]
+    
+    
+    def cost_derivative(self, output_activations, y):
+        return output_activations - y
+    
+    
+    def evaluate(self, test_data):
+        test_results = [(np.argmax(self.feedforward(x)), np.argmax(y)) for (x, y) in test_data]
+        return sum(int(x == y) for (x, y) in test_results)
+
+
+    def backprop(self, x, y):
+        nabla_b = [np.zeros(b.shape) for b in self.biases]
+        nabla_w = [np.zeros(w.shape) for w in self.weights]
+        activation = x
+        activations = [x]
+        zs = []
+        
+        for b, w in zip(self.biases, self.weights):
+            z = np.dot(w, activation)+b
+            zs.append(z)
+            activation = sigmoid(z)
+            activations.append(activation)
+        delta = self.cost_derivative(activations[-1], y) * sigmoid_prime(zs[-1])
+        nabla_b[-1] = delta
+        nabla_w[-1] = np.dot(delta, activations[-2].transpose())
+            
+        for l in range(2, self.num_layers):
+            z = zs[-l]
+            sp = sigmoid_prime(z)
+            delta = np.dot(self.weights[-l+1].transpose(), delta) * sp
+            nabla_b[-l] = delta
+            nabla_w[-l] = np.dot(delta, activations[-l-1].transpose())
+        return (nabla_b, nabla_w)
+        
+def sigmoid(z):
+    return 1.0 / (1.0 + np.exp(-z))
+
+def sigmoid_prime(z):
+    return sigmoid(z) * (1 - sigmoid(z))
+
+def load_and_preprocess_data(file_path):
+    # Load the dataset
+    data = pd.read_excel(file_path, header=None)
+    # Normalize numerical features
+    data.iloc[:, :-1] = (data.iloc[:, :-1] - data.iloc[:, :-1].mean()) / data.iloc[:, :-1].std()
+    
+    # Ensure labels are starting from 0 and continuous
+    if data.iloc[:, -1].dtype == object or np.issubdtype(data.iloc[:, -1].dtype, np.integer):
+        # Create a mapping for labels to integers
+        label_mapping = {label: idx for idx, label in enumerate(np.unique(data.iloc[:, -1]))}
+        # Apply mapping
+        data.iloc[:, -1] = data.iloc[:, -1].map(label_mapping)
+    
+    # Split data into features and labels
+    features = data.iloc[:, :-1].values
+    labels = data.iloc[:, -1].values
+    
+    # Determine the size for the vectorized result
+    unique_labels = len(np.unique(labels))
+    
+    # Vectorize labels for the network
+    labels = np.array([vectorized_result(label, unique_labels) for label in labels])
+    
+    # Combine features and labels
+    dataset = list(zip([np.reshape(x, (len(x), 1)) for x in features], labels))
+    return dataset
+
+
+
+def vectorized_result(j, size):
+    e = np.zeros((size, 1))
+    e[j] = 1.0
+    return e
+
+# Directory containing the .xls files
+folder_path = 'C:\\Users\\tt235\\Desktop\\Code\\code\\代码复现\\算法学习测试数据集'
+files = [f for f in os.listdir(folder_path) if f.endswith('.xls')]
+
+for file in files:
+    file_path = os.path.join(folder_path, file)
+    data = load_and_preprocess_data(file_path)
+
+    # Infer input and output sizes
+    input_size = len(data[0][0])
+    output_size = len(data[0][1])
+
+    # Initialize the network
+    net = Network([input_size, 30, output_size])  # Example: one hidden layer with 30 neurons
+    
+    # Train the network with k-fold cross-validation
+    net.SGD(data, 5, 10, 3.0, 5, file)  # 5-fold cross-validation

BP神经网络，10次10折.py

@@ -0,0 +1,105 @@
+import numpy as np
+import pandas as pd
+import os
+
+class Network(object):
+    def __init__(self, sizes):
+        self.num_layers = len(sizes)
+        self.sizes = sizes
+        self.biases = [np.random.randn(y, 1) for y in sizes[1:]]
+        self.weights = [np.random.randn(y, x) for x, y in zip(sizes[:-1], sizes[1:])]
+    
+    def feedforward(self, a):
+        for b, w in zip(self.biases, self.weights):
+            a = sigmoid(np.dot(w, a) + b)
+        return a
+    
+    def train(self, training_data, epochs, eta):
+        n = len(training_data)
+        for j in range(epochs):
+            np.random.shuffle(training_data)
+            for x, y in training_data:
+                self.update_network(x, y, eta)
+            
+    
+    def update_network(self, x, y, eta):
+        nabla_b, nabla_w = self.backprop(x, y)
+        self.weights = [w - eta * nw for w, nw in zip(self.weights, nabla_w)]
+        self.biases = [b - eta * nb for b, nb in zip(self.biases, nabla_b)]
+    
+    def evaluate(self, test_data):
+        test_results = [(np.argmax(self.feedforward(x)), np.argmax(y)) for (x, y) in test_data]
+        return sum(int(x == y) for (x, y) in test_results)
+
+    def backprop(self, x, y):
+        nabla_b = [np.zeros(b.shape) for b in self.biases]
+        nabla_w = [np.zeros(w.shape) for w in self.weights]
+        activation = x
+        activations = [x]
+        zs = []
+        for b, w in zip(self.biases, self.weights):
+            z = np.dot(w, activation) + b
+            zs.append(z)
+            activation = sigmoid(z)
+            activations.append(activation)
+        delta = self.cost_derivative(activations[-1], y) * sigmoid_prime(zs[-1])
+        nabla_b[-1] = delta
+        nabla_w[-1] = np.dot(delta, activations[-2].transpose())
+        for l in range(2, self.num_layers):
+            z = zs[-l]
+            sp = sigmoid_prime(z)
+            delta = np.dot(self.weights[-l + 1].transpose(), delta) * sp
+            nabla_b[-l] = delta
+            nabla_w[-l] = np.dot(delta, activations[-l - 1].transpose())
+        return (nabla_b, nabla_w)
+    
+    def cost_derivative(self, output_activations, y):
+        return (output_activations - y)
+    
+def sigmoid(z):
+    return 1.0 / (1.0 + np.exp(-z))
+
+def sigmoid_prime(z):
+    return sigmoid(z) * (1 - sigmoid(z))
+
+def k_fold_cross_validation(dataset, k):
+    np.random.shuffle(dataset)
+    fold_size = len(dataset) // k
+    for i in range(k):
+        validation_data = dataset[i * fold_size:(i + 1) * fold_size]
+        training_data = dataset[:i * fold_size] + dataset[(i + 1) * fold_size:]
+        yield training_data, validation_data
+
+def load_and_preprocess_data(file_path):
+    data = pd.read_excel(file_path, header=None)
+    features = data.iloc[:, :-1]
+    features = (features - features.mean()) / features.std()
+    labels = data.iloc[:, -1]
+    if labels.dtype == object or np.issubdtype(labels.dtype, np.integer):
+        unique_labels = labels.unique()
+        label_mapping = {label: idx for idx, label in enumerate(unique_labels)}
+        labels = labels.map(label_mapping)
+    label_vectors = np.zeros((labels.size, len(unique_labels)))
+    for i, label in enumerate(labels):
+        label_vectors[i, label] = 1
+    dataset = list(zip([np.reshape(x, (len(x), 1)) for x in features.to_numpy()], [np.reshape(y, (len(y), 1)) for y in label_vectors]))
+    return dataset
+
+folder_path = 'C:\\Users\\tt235\\Desktop\\Code\\code\\代码复现\\算法学习测试数据集'
+files = [f for f in os.listdir(folder_path) if f.endswith('.xls')]
+
+for file in files:
+    file_path = os.path.join(folder_path, file)
+    dataset = load_and_preprocess_data(file_path)
+    for iteration in range(10):  
+        accuracies = []  
+        for i, (train_data, validation_data) in enumerate(k_fold_cross_validation(dataset, 10)):
+            input_size = len(train_data[0][0])
+            output_size = len(train_data[0][1])
+            net = Network([input_size, 30, output_size])
+            net.train(train_data, 30, 1.0)  
+            validation_accuracy = net.evaluate(validation_data)
+            accuracies.append(validation_accuracy / len(validation_data))
+        average_accuracy = (sum(accuracies) / len(accuracies)) * 100
+        print(f"\nIteration {iteration + 1} Training on file: {file}")
+        print(f"Average Validation Accuracy: {average_accuracy:.2f}%")

mnist.pkl.gz

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

neural network.py

@@ -0,0 +1,136 @@
+import numpy as np
+import gzip
+import pickle
+
+
+
+class Network(object):
+    
+    def __init__(self, sizes):
+        self.num_layers = len(sizes)#sizes 列表包含 各层神经元的数量。
+        self.sizes = sizes
+        self.biases = [np.random.randn(y, 1) for y in sizes[1:]]
+        self.weights = [np.random.randn(y, x) for x,y in zip(sizes[:-1], sizes[1:])]
+        
+        
+        
+#例：net = Network([2,3,1]) 创建一个 第一层2个 第二层3个 第三层1个 神经元的 Network对象
+
+
+
+    def feedforward(self, a):
+        #当a为输入时，返回神经网络的输出
+        for b, w in zip(self.biases, self.weights):
+            a = sigmoid(np.dot(w, a) + b)
+        
+        return a
+
+
+
+    def SGD(self, training_data, epochs, mini_batch_size, eta, test_data = None):
+            #epochs=迭代次数 eta=学习速率  
+            if test_data: n_test = len(test_data)
+            n = len(training_data)
+            
+            for j in range(epochs):
+                np.random.shuffle(training_data)
+                
+                mini_batches = [training_data[k:k+mini_batch_size] for k in range(0, n, mini_batch_size)]
+                
+                for mini_batch in mini_batches:
+                    self.update_mini_batch(mini_batch, eta)
+                
+                if test_data:
+                    print("Epoch {0}: {1}/ {2}".format(j, self.evaluate(test_data), n_test))
+                else:
+                    print("Epoch {0} complete".format(j))
+                
+    
+    def update_mini_batch(self, mini_batch, eta):
+        nabla_b = [np.zeros(b.shape) for b in self.biases]
+        nabla_w = [np.zeros(w.shape) for w in self.weights]
+        
+        for x, y in mini_batch:
+            delta_nabla_b, delta_nabla_w = self.backdrop(x, y)
+            
+            nabla_b = [nb+dnb for nb, dnb in zip(nabla_b, delta_nabla_b)]
+            nabla_w = [nw+dnw for nw, dnw in zip(nabla_w, delta_nabla_w)]
+            
+            self.weights = [w-(eta/len(mini_batch))*nw for w, nw in zip(self.weights, nabla_w)]
+            self.biases = [b-(eta/len(mini_batch))*nb for b, nb in zip(self.biases, nabla_b)]
+
+
+    def evaluate(self, test_data): #测试当前迭代期对测试数据的效果
+        test_results = [(np.argmax(self.feedforward(x)), y) for (x, y) in test_data]
+        return sum(int(x == y) for (x, y) in test_results)
+        
+    
+    def cost_derivative(self, output_activations, y):
+        return output_activations - y
+        
+    def backdrop(self, x, y):
+        nabla_b = [np.zeros(b.shape) for b in self.biases]
+        nabla_w = [np.zeros(w.shape) for w in self.weights]
+        activation = x
+        activations = [x]
+        zs = []
+        #z是上一层的输入
+        for b, w in zip(self.biases, self.weights):
+            z = np.dot(w, activation)+b
+            zs.append(z)
+            activation = sigmoid(z)
+            activations.append(activation)
+        delta = self.cost_derivative(activations[-1], y) * sigmoid_prime(zs[-1])
+        nabla_b[-1] = delta
+        nabla_w[-1] = np.dot(delta, activations[-2].transpose())
+            
+        for l in range(2, self.num_layers):
+            z = zs[-l]
+            sp = sigmoid_prime(z)
+            delta = np.dot(self.weights[-l+1].transpose(), delta) * sp
+            nabla_b[-l] = delta
+            nabla_w[-l] = np.dot(delta, activations[-l-1].transpose())
+        return (nabla_b, nabla_w)
+        
+     
+     
+     
+     
+     
+            
+def sigmoid(z):    #激活函数 常用于二分类 等问题 不过存在 极大值或极小值 梯度趋于0的问题
+    return 1.0/(1.0+np.exp(-z))            
+
+def sigmoid_prime(z):   # 计算sigmoid函数的导数
+    return sigmoid(z)*(1-sigmoid(z))
+
+
+
+
+
+def load_data():
+    with gzip.open('C:\\Users\\tt235\\Desktop\\Code\\code\\代码复现\\BP神经网络\\mnist.pkl.gz', 'rb') as f:
+        training_data, validation_data, test_data = pickle.load(f, encoding='latin1')
+
+    return (training_data, validation_data, test_data)
+
+def load_data_wrapper():
+    tr_d, va_d, te_d = load_data()
+    training_inputs = [np.reshape(x, (784, 1)) for x in tr_d[0]]
+    training_results = [vectorized_result(y) for y in tr_d[1]]
+    training_data = list(zip(training_inputs, training_results))
+    validation_inputs = [np.reshape(x, (784, 1)) for x in va_d[0]]
+    validation_data = list(zip(validation_inputs, va_d[1]))
+    test_inputs = [np.reshape(x, (784, 1)) for x in te_d[0]]
+    test_data = list(zip(test_inputs, te_d[1]))
+    return (training_data, validation_data, test_data)
+
+def vectorized_result(j):
+    e = np.zeros((10, 1))
+    e[j] = 1.0
+    return e
+
+
+training_data, validation_data, test_data = load_data_wrapper()
+net = Network([784, 41, 10])
+net.SGD(training_data, 3, 10, 3.0, test_data = test_data)

test.py

@@ -0,0 +1,137 @@
+import numpy as np
+import gzip
+import pickle
+import pandas as pd
+
+class Network(object):
+    
+    def __init__(self, sizes):
+        self.num_layers = len(sizes)
+        self.sizes = sizes
+        self.biases = [np.random.randn(y, 1) for y in sizes[1:]]
+        self.weights = [np.random.randn(y, x) for x,y in zip(sizes[:-1], sizes[1:])]
+        
+        
+        
+
+
+
+
+    def feedforward(self, a):
+        
+        for b, w in zip(self.biases, self.weights):
+            a = sigmoid(np.dot(w, a) + b)
+        
+        return a
+    
+    
+    def SGD(self, training_data, epochs, mini_batch_size, eta, k, test_data=None):
+        if test_data: 
+            n_test = len(test_data)
+
+        for j in range(epochs):
+            np.random.shuffle(training_data)
+            k_fold = self.k_fold_split(training_data, k)
+
+            for fold in range(k):
+                validation_data = k_fold[fold]
+                train_data = [item for sublist in k_fold[:fold] + k_fold[fold + 1:] for item in sublist]
+
+                for mini_batch in [train_data[k:k+mini_batch_size] for k in range(0, len(train_data), mini_batch_size)]:
+                    self.update_mini_batch(mini_batch, eta)
+                
+                print(f"Epoch {j}, Fold {fold}: {self.evaluate(validation_data)}/{len(validation_data)}")
+            
+            if test_data:
+                print(f"Epoch {j}: {self.evaluate(test_data)}/{n_test}")
+
+    def k_fold_split(self, data, k):
+        fold_size = len(data) // k
+        return [data[i*fold_size:(i+1)*fold_size] for i in range(k)]
+    
+    def update_mini_batch(self, mini_batch, eta):
+        nabla_b = [np.zeros(b.shape) for b in self.biases]
+        nabla_w = [np.zeros(w.shape) for w in self.weights]
+        
+        for x, y in mini_batch:
+            delta_nabla_b, delta_nabla_w = self.backdrop(x, y)
+            
+            nabla_b = [nb+dnb for nb, dnb in zip(nabla_b, delta_nabla_b)]
+            nabla_w = [nw+dnw for nw, dnw in zip(nabla_w, delta_nabla_w)]
+            
+            self.weights = [w-(eta/len(mini_batch))*nw for w, nw in zip(self.weights, nabla_w)]
+            self.biases = [b-(eta/len(mini_batch))*nb for b, nb in zip(self.biases, nabla_b)]
+
+    def evaluate(self, test_data): 
+        test_results = [(np.argmax(self.feedforward(x)), np.argmax(y)) for (x, y) in test_data]
+        return sum(int(x == y) for (x, y) in test_results)
+    
+    def cost_derivative(self, output_activations, y):
+        return output_activations - y
+        
+    def backdrop(self, x, y):
+        nabla_b = [np.zeros(b.shape) for b in self.biases]
+        nabla_w = [np.zeros(w.shape) for w in self.weights]
+        activation = x
+        activations = [x]
+        zs = []
+        
+        for b, w in zip(self.biases, self.weights):
+            z = np.dot(w, activation)+b
+            zs.append(z)
+            activation = sigmoid(z)
+            activations.append(activation)
+        delta = self.cost_derivative(activations[-1], y) * sigmoid_prime(zs[-1])
+        nabla_b[-1] = delta
+        nabla_w[-1] = np.dot(delta, activations[-2].transpose())
+            
+        for l in range(2, self.num_layers):
+            z = zs[-l]
+            sp = sigmoid_prime(z)
+            delta = np.dot(self.weights[-l+1].transpose(), delta) * sp
+            nabla_b[-l] = delta
+            nabla_w[-l] = np.dot(delta, activations[-l-1].transpose())
+        return (nabla_b, nabla_w)
+
+
+def sigmoid(z):
+        sig = np.zeros_like(z)
+        sig[z >= 0] = 1 / (1 + np.exp(-z[z >= 0]))
+        sig[z < 0] = np.exp(z[z < 0]) / (1 + np.exp(z[z < 0]))
+        return sig            
+
+def sigmoid_prime(z):   
+    return sigmoid(z)*(1-sigmoid(z))
+
+
+
+
+
+def load_data():
+    with gzip.open('C:\\Users\\tt235\\Desktop\\Code\\code\\代码复现\\BP神经网络\\mnist.pkl.gz', 'rb') as f:
+        training_data, validation_data, test_data = pickle.load(f, encoding='latin1')
+
+    return (training_data, validation_data, test_data)
+
+def load_data_wrapper():
+    tr_d, va_d, te_d = load_data()
+    training_inputs = [np.reshape(x, (784, 1)) for x in tr_d[0]]
+    training_results = [vectorized_result(y) for y in tr_d[1]]
+    training_data = list(zip(training_inputs, training_results))
+    validation_inputs = [np.reshape(x, (784, 1)) for x in va_d[0]]
+    validation_data = list(zip(validation_inputs, va_d[1]))
+    test_inputs = [np.reshape(x, (784, 1)) for x in te_d[0]]
+    test_results = [vectorized_result(y) for y in te_d[1]]
+    test_data = list(zip(test_inputs, test_results))
+    return (training_data, validation_data, test_data)
+
+def vectorized_result(j):
+    e = np.zeros((10, 1))
+    e[j] = 1.0
+    return e
+
+
+training_data, validation_data, test_data = load_data_wrapper()
+net = Network([784, 41, 10])
+
+net.SGD(training_data, 3, 8, 3.0, 5, test_data=test_data)

test0.py

@@ -0,0 +1,105 @@
+import numpy as np
+import pandas as pd
+import os
+
+class Network(object):
+    def __init__(self, sizes):
+        self.num_layers = len(sizes)
+        self.sizes = sizes
+        self.biases = [np.random.randn(y, 1) for y in sizes[1:]]
+        self.weights = [np.random.randn(y, x) for x, y in zip(sizes[:-1], sizes[1:])]
+    
+    def feedforward(self, a):
+        for b, w in zip(self.biases, self.weights):
+            a = sigmoid(np.dot(w, a) + b)
+        return a
+    
+    def train(self, training_data, epochs, eta):
+        n = len(training_data)
+        for j in range(epochs):
+            np.random.shuffle(training_data)
+            for x, y in training_data:
+                self.update_network(x, y, eta)
+            # print(f"Epoch {j} complete")  # 注释掉每个 epoch 完成后的打印
+    
+    def update_network(self, x, y, eta):
+        nabla_b, nabla_w = self.backprop(x, y)
+        self.weights = [w - eta * nw for w, nw in zip(self.weights, nabla_w)]
+        self.biases = [b - eta * nb for b, nb in zip(self.biases, nabla_b)]
+    
+    def evaluate(self, test_data):
+        test_results = [(np.argmax(self.feedforward(x)), np.argmax(y)) for (x, y) in test_data]
+        return sum(int(x == y) for (x, y) in test_results)
+
+    def backprop(self, x, y):
+        nabla_b = [np.zeros(b.shape) for b in self.biases]
+        nabla_w = [np.zeros(w.shape) for w in self.weights]
+        activation = x
+        activations = [x]
+        zs = []
+        for b, w in zip(self.biases, self.weights):
+            z = np.dot(w, activation) + b
+            zs.append(z)
+            activation = sigmoid(z)
+            activations.append(activation)
+        delta = self.cost_derivative(activations[-1], y) * sigmoid_prime(zs[-1])
+        nabla_b[-1] = delta
+        nabla_w[-1] = np.dot(delta, activations[-2].transpose())
+        for l in range(2, self.num_layers):
+            z = zs[-l]
+            sp = sigmoid_prime(z)
+            delta = np.dot(self.weights[-l + 1].transpose(), delta) * sp
+            nabla_b[-l] = delta
+            nabla_w[-l] = np.dot(delta, activations[-l - 1].transpose())
+        return (nabla_b, nabla_w)
+    
+    def cost_derivative(self, output_activations, y):
+        return (output_activations - y)
+    
+def sigmoid(z):
+    return 1.0 / (1.0 + np.exp(-z))
+
+def sigmoid_prime(z):
+    return sigmoid(z) * (1 - sigmoid(z))
+
+def k_fold_cross_validation(dataset, k):
+    np.random.shuffle(dataset)
+    fold_size = len(dataset) // k
+    for i in range(k):
+        validation_data = dataset[i * fold_size:(i + 1) * fold_size]
+        training_data = dataset[:i * fold_size] + dataset[(i + 1) * fold_size:]
+        yield training_data, validation_data
+
+def load_and_preprocess_data(file_path):
+    data = pd.read_excel(file_path, header=None)
+    features = data.iloc[:, :-1]
+    features = (features - features.mean()) / features.std()
+    labels = data.iloc[:, -1]
+    if labels.dtype == object or np.issubdtype(labels.dtype, np.integer):
+        unique_labels = labels.unique()
+        label_mapping = {label: idx for idx, label in enumerate(unique_labels)}
+        labels = labels.map(label_mapping)
+    label_vectors = np.zeros((labels.size, len(unique_labels)))
+    for i, label in enumerate(labels):
+        label_vectors[i, label] = 1
+    dataset = list(zip([np.reshape(x, (len(x), 1)) for x in features.to_numpy()], [np.reshape(y, (len(y), 1)) for y in label_vectors]))
+    return dataset
+
+folder_path = 'C:\\Users\\tt235\\Desktop\\Code\\code\\代码复现\\算法学习测试数据集'
+files = [f for f in os.listdir(folder_path) if f.endswith('.xls')]
+
+for file in files:
+    file_path = os.path.join(folder_path, file)
+    dataset = load_and_preprocess_data(file_path)
+    for iteration in range(10):  # 外层循环，进行十次交叉验证
+        accuracies = []  # 存储当前次交叉验证的所有准确率
+        for i, (train_data, validation_data) in enumerate(k_fold_cross_validation(dataset, 10)):
+            input_size = len(train_data[0][0])
+            output_size = len(train_data[0][1])
+            net = Network([input_size, 30, output_size])
+            net.train(train_data, 30, 3.0)  # 根据需要调整 epochs 和学习率
+            validation_accuracy = net.evaluate(validation_data)
+            accuracies.append(validation_accuracy / len(validation_data))
+        average_accuracy = (sum(accuracies) / len(accuracies)) * 100
+        print(f"\nIteration {iteration + 1} Training on file: {file}")
+        print(f"Average Validation Accuracy: {average_accuracy:.2f}%")

神经网络，有留出测试集.py

@@ -0,0 +1,133 @@
+import numpy as np
+import pandas as pd
+import os
+
+
+class Network(object):
+    def __init__(self, sizes):
+        self.num_layers = len(sizes)
+        self.sizes = sizes
+        self.biases = [np.random.randn(y, 1) for y in sizes[1:]]
+        self.weights = [np.random.randn(y, x) for x, y in zip(sizes[:-1], sizes[1:])]
+    
+    def feedforward(self, a):
+        for b, w in zip(self.biases, self.weights):
+            a = sigmoid(np.dot(w, a) + b)
+        return a
+    
+    def SGD(self, training_data, epochs, mini_batch_size, eta, k, file_name, test_data):
+        n = len(training_data)
+        for j in range(epochs):
+            np.random.shuffle(training_data)
+            folds = [training_data[i::k] for i in range(k)]
+
+            if j == 0:
+                print(f"\nTraining on file: {file_name}")
+            print(f"\nEpoch {j}:")
+            
+            for i in range(k):
+                validation_data = folds[i]
+                train_data = [item for fold in folds if fold is not validation_data for item in fold]
+
+                for mini_batch in [train_data[m:m+mini_batch_size] for m in range(0, len(train_data), mini_batch_size)]:
+                    self.update_mini_batch(mini_batch, eta)
+
+                print(f"Fold {i}: {self.evaluate(validation_data)}/{len(validation_data)}")
+            
+            test_accuracy = self.evaluate(test_data)
+            print(f"Test Accuracy: {test_accuracy}/{len(test_data)}")
+
+    def update_mini_batch(self, mini_batch, eta):
+        nabla_b = [np.zeros(b.shape) for b in self.biases]
+        nabla_w = [np.zeros(w.shape) for w in self.weights]
+        for x, y in mini_batch:
+            delta_nabla_b, delta_nabla_w = self.backprop(x, y)
+            nabla_b = [nb + dnb for nb, dnb in zip(nabla_b, delta_nabla_b)]
+            nabla_w = [nw + dnw for nw, dnw in zip(nabla_w, delta_nabla_w)]
+        self.weights = [w - (eta / len(mini_batch)) * nw for w, nw in zip(self.weights, nabla_w)]
+        self.biases = [b - (eta / len(mini_batch)) * nb for b, nb in zip(self.biases, nabla_b)]
+    
+    
+    def cost_derivative(self, output_activations, y):
+        return output_activations - y
+    
+    
+    def evaluate(self, test_data):
+        test_results = [(np.argmax(self.feedforward(x)), np.argmax(y)) for (x, y) in test_data]
+        return sum(int(x == y) for (x, y) in test_results)
+
+
+    def backprop(self, x, y):
+        nabla_b = [np.zeros(b.shape) for b in self.biases]
+        nabla_w = [np.zeros(w.shape) for w in self.weights]
+        activation = x
+        activations = [x]
+        zs = []
+        
+        for b, w in zip(self.biases, self.weights):
+            z = np.dot(w, activation)+b
+            zs.append(z)
+            activation = sigmoid(z)
+            activations.append(activation)
+        delta = self.cost_derivative(activations[-1], y) * sigmoid_prime(zs[-1])
+        nabla_b[-1] = delta
+        nabla_w[-1] = np.dot(delta, activations[-2].transpose())
+            
+        for l in range(2, self.num_layers):
+            z = zs[-l]
+            sp = sigmoid_prime(z)
+            delta = np.dot(self.weights[-l+1].transpose(), delta) * sp
+            nabla_b[-l] = delta
+            nabla_w[-l] = np.dot(delta, activations[-l-1].transpose())
+        return (nabla_b, nabla_w)
+
+
+def sigmoid(z):
+    return 1.0 / (1.0 + np.exp(-z))
+
+def sigmoid_prime(z):
+    return sigmoid(z) * (1 - sigmoid(z))
+
+
+def load_and_preprocess_data(file_path):
+    data = pd.read_excel(file_path, header=None)
+    data.iloc[:, :-1] = (data.iloc[:, :-1] - data.iloc[:, :-1].mean()) / data.iloc[:, :-1].std()
+
+    if data.iloc[:, -1].dtype == object or np.issubdtype(data.iloc[:, -1].dtype, np.integer):
+        label_mapping = {label: idx for idx, label in enumerate(np.unique(data.iloc[:, -1]))}
+        data.iloc[:, -1] = data.iloc[:, -1].map(label_mapping)
+
+    features = data.iloc[:, :-1].values
+    labels = data.iloc[:, -1].values
+
+    unique_labels = len(np.unique(labels))
+    labels = np.array([vectorized_result(label, unique_labels) for label in labels])
+    
+    dataset = list(zip([np.reshape(x, (len(x), 1)) for x in features], labels))
+    
+    
+    split_index = int(len(dataset) * 0.9)
+    training_data = dataset[:split_index]
+    test_data = dataset[split_index:]
+    
+    return training_data, test_data
+
+
+def vectorized_result(j, size):
+    e = np.zeros((size, 1))
+    e[j] = 1.0
+    return e
+
+
+folder_path = 'C:\\Users\\tt235\\Desktop\\Code\\code\\代码复现\\算法学习测试数据集'
+files = [f for f in os.listdir(folder_path) if f.endswith('.xls')]
+
+for file in files:
+    file_path = os.path.join(folder_path, file)
+    training_data, test_data = load_and_preprocess_data(file_path)
+
+    input_size = len(training_data[0][0])
+    output_size = len(training_data[0][1])
+
+    net = Network([input_size, 30, output_size])  
+    net.SGD(training_data, 5, 10, 3.0, 10, file, test_data)  

神经网络，没有留出.py

@@ -0,0 +1,131 @@
+import numpy as np
+import pandas as pd
+import os
+
+class Network(object):
+    def __init__(self, sizes):
+        self.num_layers = len(sizes)
+        self.sizes = sizes
+        self.biases = [np.random.randn(y, 1) for y in sizes[1:]]
+        self.weights = [np.random.randn(y, x) for x, y in zip(sizes[:-1], sizes[1:])]
+    
+    def feedforward(self, a):
+        for b, w in zip(self.biases, self.weights):
+            a = sigmoid(np.dot(w, a) + b)
+        return a
+    
+    def SGD(self, training_data, epochs, mini_batch_size, eta, k, file_name):
+        n = len(training_data)
+        for j in range(epochs):
+            np.random.shuffle(training_data)
+            folds = [training_data[i::k] for i in range(k)]
+
+            print(f"\nTraining on file: {file_name}")
+            print(f"\nEpoch {j}:")
+
+            for i in range(k):
+                validation_data = folds[i]
+                train_data = [item for fold in folds if fold is not validation_data for item in fold]
+
+                for mini_batch in [train_data[m:m+mini_batch_size] for m in range(0, len(train_data), mini_batch_size)]:
+                    self.update_mini_batch(mini_batch, eta)
+
+                print(f"Fold {i}: {self.evaluate(validation_data)}/{len(validation_data)}")
+
+    def update_mini_batch(self, mini_batch, eta):
+        nabla_b = [np.zeros(b.shape) for b in self.biases]
+        nabla_w = [np.zeros(w.shape) for w in self.weights]
+        for x, y in mini_batch:
+            delta_nabla_b, delta_nabla_w = self.backprop(x, y)
+            nabla_b = [nb + dnb for nb, dnb in zip(nabla_b, delta_nabla_b)]
+            nabla_w = [nw + dnw for nw, dnw in zip(nabla_w, delta_nabla_w)]
+        self.weights = [w - (eta / len(mini_batch)) * nw for w, nw in zip(self.weights, nabla_w)]
+        self.biases = [b - (eta / len(mini_batch)) * nb for b, nb in zip(self.biases, nabla_b)]
+    
+    
+    def cost_derivative(self, output_activations, y):
+        return output_activations - y
+    
+    
+    def evaluate(self, test_data):
+        test_results = [(np.argmax(self.feedforward(x)), np.argmax(y)) for (x, y) in test_data]
+        return sum(int(x == y) for (x, y) in test_results)
+
+
+    def backprop(self, x, y):
+        nabla_b = [np.zeros(b.shape) for b in self.biases]
+        nabla_w = [np.zeros(w.shape) for w in self.weights]
+        activation = x
+        activations = [x]
+        zs = []
+        
+        for b, w in zip(self.biases, self.weights):
+            z = np.dot(w, activation)+b
+            zs.append(z)
+            activation = sigmoid(z)
+            activations.append(activation)
+        delta = self.cost_derivative(activations[-1], y) * sigmoid_prime(zs[-1])
+        nabla_b[-1] = delta
+        nabla_w[-1] = np.dot(delta, activations[-2].transpose())
+            
+        for l in range(2, self.num_layers):
+            z = zs[-l]
+            sp = sigmoid_prime(z)
+            delta = np.dot(self.weights[-l+1].transpose(), delta) * sp
+            nabla_b[-l] = delta
+            nabla_w[-l] = np.dot(delta, activations[-l-1].transpose())
+        return (nabla_b, nabla_w)
+
+
+def sigmoid(z):
+    return 1.0 / (1.0 + np.exp(-z))
+
+def sigmoid_prime(z):
+    return sigmoid(z) * (1 - sigmoid(z))
+
+
+def load_and_preprocess_data(file_path):
+    
+    data = pd.read_excel(file_path, header=None)
+
+   
+    features = data.iloc[:, :-1]
+    features = (features - features.mean()) / features.std()
+    
+   
+    labels = data.iloc[:, -1]
+    if labels.dtype == object or np.issubdtype(labels.dtype, np.integer):
+        unique_labels = labels.unique()
+        label_mapping = {label: idx for idx, label in enumerate(unique_labels)}
+        labels = labels.map(label_mapping)
+    
+   
+    label_vectors = np.zeros((labels.size, len(unique_labels)))
+    for i, label in enumerate(labels):
+        label_vectors[i, label] = 1
+    
+   
+    dataset = list(zip([np.reshape(x, (len(x), 1)) for x in features.to_numpy()], [np.reshape(y, (len(y), 1)) for y in label_vectors]))
+
+    return dataset
+
+
+
+def vectorized_result(j, size):
+    e = np.zeros((size, 1))
+    e[j] = 1.0
+    return e
+
+
+folder_path = 'C:\\Users\\tt235\\Desktop\\Code\\code\\代码复现\\算法学习测试数据集'
+files = [f for f in os.listdir(folder_path) if f.endswith('.xls')]
+
+for file in files:
+    file_path = os.path.join(folder_path, file)
+    dataset = load_and_preprocess_data(file_path)
+
+    input_size = len(dataset[0][0])
+    output_size = len(dataset[0][1])
+
+    net = Network([input_size, 30, output_size])
+    net.SGD(dataset, 5, 10, 3.0, 5, file)  # 这里我们只用dataset，不再分出test_data

神经网络，添加k折交叉验证.py

@@ -0,0 +1,138 @@
+import numpy as np
+import gzip
+import pickle
+
+
+
+class Network(object):
+    
+    def __init__(self, sizes):
+        self.num_layers = len(sizes)
+        self.sizes = sizes
+        self.biases = [np.random.randn(y, 1) for y in sizes[1:]]
+        self.weights = [np.random.randn(y, x) for x,y in zip(sizes[:-1], sizes[1:])]
+        
+        
+        
+
+
+
+
+    def feedforward(self, a):
+        
+        for b, w in zip(self.biases, self.weights):
+            a = sigmoid(np.dot(w, a) + b)
+        
+        return a
+    
+    
+    def SGD(self, training_data, epochs, mini_batch_size, eta, k, test_data=None):
+        if test_data: 
+            n_test = len(test_data)
+
+        for j in range(epochs):
+            np.random.shuffle(training_data)
+            k_fold = self.k_fold_split(training_data, k)
+
+            for fold in range(k):
+                validation_data = k_fold[fold]
+                train_data = [item for sublist in k_fold[:fold] + k_fold[fold + 1:] for item in sublist]
+
+                for mini_batch in [train_data[k:k+mini_batch_size] for k in range(0, len(train_data), mini_batch_size)]:
+                    self.update_mini_batch(mini_batch, eta)
+                
+                print(f"Epoch {j}, Fold {fold}: {self.evaluate(validation_data)}/{len(validation_data)}")
+            
+            if test_data:
+                print(f"Epoch {j}: {self.evaluate(test_data)}/{n_test}")
+
+    def k_fold_split(self, data, k):
+        fold_size = len(data) // k
+        return [data[i*fold_size:(i+1)*fold_size] for i in range(k)]
+    
+    def update_mini_batch(self, mini_batch, eta):
+        nabla_b = [np.zeros(b.shape) for b in self.biases]
+        nabla_w = [np.zeros(w.shape) for w in self.weights]
+        
+        for x, y in mini_batch:
+            delta_nabla_b, delta_nabla_w = self.backdrop(x, y)
+            
+            nabla_b = [nb+dnb for nb, dnb in zip(nabla_b, delta_nabla_b)]
+            nabla_w = [nw+dnw for nw, dnw in zip(nabla_w, delta_nabla_w)]
+            
+            self.weights = [w-(eta/len(mini_batch))*nw for w, nw in zip(self.weights, nabla_w)]
+            self.biases = [b-(eta/len(mini_batch))*nb for b, nb in zip(self.biases, nabla_b)]
+
+    def evaluate(self, test_data): 
+        test_results = [(np.argmax(self.feedforward(x)), np.argmax(y)) for (x, y) in test_data]
+        return sum(int(x == y) for (x, y) in test_results)
+    
+    def cost_derivative(self, output_activations, y):
+        return output_activations - y
+        
+    def backdrop(self, x, y):
+        nabla_b = [np.zeros(b.shape) for b in self.biases]
+        nabla_w = [np.zeros(w.shape) for w in self.weights]
+        activation = x
+        activations = [x]
+        zs = []
+        
+        for b, w in zip(self.biases, self.weights):
+            z = np.dot(w, activation)+b
+            zs.append(z)
+            activation = sigmoid(z)
+            activations.append(activation)
+        delta = self.cost_derivative(activations[-1], y) * sigmoid_prime(zs[-1])
+        nabla_b[-1] = delta
+        nabla_w[-1] = np.dot(delta, activations[-2].transpose())
+            
+        for l in range(2, self.num_layers):
+            z = zs[-l]
+            sp = sigmoid_prime(z)
+            delta = np.dot(self.weights[-l+1].transpose(), delta) * sp
+            nabla_b[-l] = delta
+            nabla_w[-l] = np.dot(delta, activations[-l-1].transpose())
+        return (nabla_b, nabla_w)
+
+
+def sigmoid(z):
+        sig = np.zeros_like(z)
+        sig[z >= 0] = 1 / (1 + np.exp(-z[z >= 0]))
+        sig[z < 0] = np.exp(z[z < 0]) / (1 + np.exp(z[z < 0]))
+        return sig            
+
+def sigmoid_prime(z):   
+    return sigmoid(z)*(1-sigmoid(z))
+
+
+
+
+
+def load_data():
+    with gzip.open('C:\\Users\\tt235\\Desktop\\Code\\code\\代码复现\\BP神经网络\\mnist.pkl.gz', 'rb') as f:
+        training_data, validation_data, test_data = pickle.load(f, encoding='latin1')
+
+    return (training_data, validation_data, test_data)
+
+def load_data_wrapper():
+    tr_d, va_d, te_d = load_data()
+    training_inputs = [np.reshape(x, (784, 1)) for x in tr_d[0]]
+    training_results = [vectorized_result(y) for y in tr_d[1]]
+    training_data = list(zip(training_inputs, training_results))
+    validation_inputs = [np.reshape(x, (784, 1)) for x in va_d[0]]
+    validation_data = list(zip(validation_inputs, va_d[1]))
+    test_inputs = [np.reshape(x, (784, 1)) for x in te_d[0]]
+    test_results = [vectorized_result(y) for y in te_d[1]]
+    test_data = list(zip(test_inputs, test_results))
+    return (training_data, validation_data, test_data)
+
+def vectorized_result(j):
+    e = np.zeros((10, 1))
+    e[j] = 1.0
+    return e
+
+
+training_data, validation_data, test_data = load_data_wrapper()
+net = Network([784, 41, 10])
+
+net.SGD(training_data, 3, 8, 3.0, 5, test_data=test_data)

移除小批量之后的算法.py

@@ -0,0 +1,114 @@
+import numpy as np
+import gzip
+import pickle
+
+class Network(object):
+
+    def __init__(self, sizes):
+        self.num_layers = len(sizes)
+        self.sizes = sizes
+        self.biases = [np.random.randn(y, 1) for y in sizes[1:]]
+        self.weights = [np.random.randn(y, x) for x, y in zip(sizes[:-1], sizes[1:])]
+
+    def feedforward(self, a):
+        for b, w in zip(self.biases, self.weights):
+            a = sigmoid(np.dot(w, a) + b)
+        return a
+
+    def SGD(self, training_data, epochs, eta, k, test_data=None):
+        if test_data:
+            n_test = len(test_data)
+        n = len(training_data)
+
+        for j in range(epochs):
+            np.random.shuffle(training_data)
+            k_fold = self.k_fold_split(training_data, k)
+
+            for fold in range(k):
+                train_data = [item for sublist in k_fold[:fold] + k_fold[fold + 1:] for item in sublist]
+                self.update_mini_batch(train_data, eta)
+
+                print(f"Epoch {j}, Fold {fold}: {self.evaluate(k_fold[fold])}/{len(k_fold[fold])}")
+
+            if test_data:
+                print(f"Epoch {j}: {self.evaluate(test_data)}/{n_test}")
+
+    def k_fold_split(self, data, k):
+        fold_size = len(data) // k
+        return [data[i * fold_size:(i + 1) * fold_size] for i in range(k)]
+
+    def update_mini_batch(self, mini_batch, eta):
+        nabla_b = [np.zeros(b.shape) for b in self.biases]
+        nabla_w = [np.zeros(w.shape) for w in self.weights]
+
+        for x, y in mini_batch:
+            delta_nabla_b, delta_nabla_w = self.backdrop(x, y)
+            nabla_b = [nb + dnb for nb, dnb in zip(nabla_b, delta_nabla_b)]
+            nabla_w = [nw + dnw for nw, dnw in zip(nabla_w, delta_nabla_w)]
+
+        self.weights = [w - (eta / len(mini_batch)) * nw for w, nw in zip(self.weights, nabla_w)]
+        self.biases = [b - (eta / len(mini_batch)) * nb for b, nb in zip(self.biases, nabla_b)]
+
+    def evaluate(self, test_data):
+        test_results = [(np.argmax(self.feedforward(x)), np.argmax(y)) for (x, y) in test_data]
+        return sum(int(x == y) for (x, y) in test_results)
+
+    def cost_derivative(self, output_activations, y):
+        return output_activations - y
+
+    def backdrop(self, x, y):
+        nabla_b = [np.zeros(b.shape) for b in self.biases]
+        nabla_w = [np.zeros(w.shape) for w in self.weights]
+        activation = x
+        activations = [x]
+        zs = []
+
+        for b, w in zip(self.biases, self.weights):
+            z = np.dot(w, activation) + b
+            zs.append(z)
+            activation = sigmoid(z)
+            activations.append(activation)
+
+        delta = self.cost_derivative(activations[-1], y) * sigmoid_prime(zs[-1])
+        nabla_b[-1] = delta
+        nabla_w[-1] = np.dot(delta, activations[-2].transpose())
+
+        for l in range(2, self.num_layers):
+            z = zs[-l]
+            sp = sigmoid_prime(z)
+            delta = np.dot(self.weights[-l + 1].transpose(), delta) * sp
+            nabla_b[-l] = delta
+            nabla_w[-l] = np.dot(delta, activations[-l - 1].transpose())
+
+        return (nabla_b, nabla_w)
+
+def sigmoid(z):
+    return 1.0 / (1.0 + np.exp(-z))
+
+def sigmoid_prime(z):
+    return sigmoid(z) * (1 - sigmoid(z))
+
+def load_data():
+    with gzip.open('C:\\Users\\tt235\\Desktop\\Code\\code\\代码复现\\BP神经网络\\mnist.pkl.gz', 'rb') as f:
+        training_data, validation_data, test_data = pickle.load(f, encoding='latin1')
+    return (training_data, validation_data, test_data)
+
+def load_data_wrapper():
+    tr_d, va_d, te_d = load_data()
+    training_inputs = [np.reshape(x, (784, 1)) for x in tr_d[0]]
+    training_results = [vectorized_result(y) for y in tr_d[1]]
+    training_data = list(zip(training_inputs, training_results))
+    validation_inputs = [np.reshape(x, (784, 1)) for x in va_d[0]]
+    validation_data = list(zip(validation_inputs, va_d[1]))
+    test_inputs = [np.reshape(x, (784, 1)) for x in te_d[0]]
+    test_data = list(zip(test_inputs, te_d[1]))
+    return (training_data, validation_data, test_data)
+
+def vectorized_result(j):
+    e = np.zeros((10, 1))
+    e[j] = 1.0
+    return e
+
+training_data, validation_data, test_data = load_data_wrapper()
+net = Network([784, 41, 10])
+net.SGD(training_data, 10, 3.0, 5, test_data=test_data)

网络，k折，无测集，小批量梯度下降优化算法.py

@@ -0,0 +1,127 @@
+import numpy as np
+import pandas as pd
+import os
+
+class Network(object):
+    def __init__(self, sizes):
+        self.num_layers = len(sizes)
+        self.sizes = sizes
+        self.biases = [np.random.randn(y, 1) for y in sizes[1:]]
+        self.weights = [np.random.randn(y, x) for x, y in zip(sizes[:-1], sizes[1:])]
+    
+    def feedforward(self, a):
+        for b, w in zip(self.biases, self.weights):
+            a = sigmoid(np.dot(w, a) + b)
+        return a
+    
+    def SGD(self, training_data, epochs, mini_batch_size, eta, file_name):
+        n = len(training_data)
+        for j in range(epochs):
+            np.random.shuffle(training_data)
+            mini_batches = [training_data[k:k+mini_batch_size] for k in range(0, n, mini_batch_size)]
+            for mini_batch in mini_batches:
+                self.update_mini_batch(mini_batch, eta)
+            print(f"Epoch {j} complete")
+
+    def update_mini_batch(self, mini_batch, eta):
+        nabla_b = [np.zeros(b.shape) for b in self.biases]
+        nabla_w = [np.zeros(w.shape) for w in self.weights]
+        for x, y in mini_batch:
+            delta_nabla_b, delta_nabla_w = self.backprop(x, y)
+            nabla_b = [nb + dnb for nb, dnb in zip(nabla_b, delta_nabla_b)]
+            nabla_w = [nw + dnw for nw, dnw in zip(nabla_w, delta_nabla_w)]
+        self.weights = [w - (eta / len(mini_batch)) * nw for w, nw in zip(self.weights, nabla_w)]
+        self.biases = [b - (eta / len(mini_batch)) * nb for b, nb in zip(self.biases, nabla_b)]
+    
+    
+    def cost_derivative(self, output_activations, y):
+        return output_activations - y
+    
+    
+    def evaluate(self, test_data):
+        test_results = [(np.argmax(self.feedforward(x)), np.argmax(y)) for (x, y) in test_data]
+        return sum(int(x == y) for (x, y) in test_results)
+
+    
+    def backprop(self, x, y):
+        nabla_b = [np.zeros(b.shape) for b in self.biases]
+        nabla_w = [np.zeros(w.shape) for w in self.weights]
+        activation = x
+        activations = [x]
+        zs = []
+        
+        for b, w in zip(self.biases, self.weights):
+            z = np.dot(w, activation)+b
+            zs.append(z)
+            activation = sigmoid(z)
+            activations.append(activation)
+        delta = self.cost_derivative(activations[-1], y) * sigmoid_prime(zs[-1])
+        nabla_b[-1] = delta
+        nabla_w[-1] = np.dot(delta, activations[-2].transpose())
+            
+        for l in range(2, self.num_layers):
+            z = zs[-l]
+            sp = sigmoid_prime(z)
+            delta = np.dot(self.weights[-l+1].transpose(), delta) * sp
+            nabla_b[-l] = delta
+            nabla_w[-l] = np.dot(delta, activations[-l-1].transpose())
+        return (nabla_b, nabla_w)
+    
+def sigmoid(z):
+    return 1.0 / (1.0 + np.exp(-z))
+
+def sigmoid_prime(z):
+    return sigmoid(z) * (1 - sigmoid(z))
+
+def k_fold_cross_validation(dataset, k):
+    fold_size = len(dataset) // k
+    for i in range(k):
+        validation_data = dataset[i*fold_size:(i+1)*fold_size]
+        training_data = dataset[:i*fold_size] + dataset[(i+1)*fold_size:]
+        yield training_data, validation_data
+
+def load_and_preprocess_data(file_path):
+    
+    data = pd.read_excel(file_path, header=None)
+
+   
+    features = data.iloc[:, :-1]
+    features = (features - features.mean()) / features.std()
+    
+   
+    labels = data.iloc[:, -1]
+    if labels.dtype == object or np.issubdtype(labels.dtype, np.integer):
+        unique_labels = labels.unique()
+        label_mapping = {label: idx for idx, label in enumerate(unique_labels)}
+        labels = labels.map(label_mapping)
+    
+   
+    label_vectors = np.zeros((labels.size, len(unique_labels)))
+    for i, label in enumerate(labels):
+        label_vectors[i, label] = 1
+    
+   
+    dataset = list(zip([np.reshape(x, (len(x), 1)) for x in features.to_numpy()], [np.reshape(y, (len(y), 1)) for y in label_vectors]))
+
+    return dataset
+
+def vectorized_result(j, size):
+    e = np.zeros((size, 1))
+    e[j] = 1.0
+    return e
+folder_path = 'C:\\Users\\tt235\\Desktop\\Code\\code\\代码复现\\算法学习测试数据集'
+files = [f for f in os.listdir(folder_path) if f.endswith('.xls')]
+
+for file in files:
+    file_path = os.path.join(folder_path, file)
+    dataset = load_and_preprocess_data(file_path)
+
+    for i, (train_data, validation_data) in enumerate(k_fold_cross_validation(dataset, 10)):
+        input_size = len(train_data[0][0])
+        output_size = len(train_data[0][1])
+
+        net = Network([input_size, 30, output_size])
+        print(f"\nTraining on file: {file}, Fold: {i+1}")
+        net.SGD(train_data, 5, 10, 3.0, file)
+        validation_accuracy = net.evaluate(validation_data)
+        print(f"Validation Accuracy: {validation_accuracy}/{len(validation_data)}")

调包版.py

@@ -0,0 +1,34 @@
+import numpy as np
+import pandas as pd
+from sklearn.preprocessing import StandardScaler
+from sklearn.model_selection import KFold, cross_val_score
+from sklearn.neural_network import MLPClassifier
+import os
+
+def load_and_preprocess_data(file_path):
+    data = pd.read_excel(file_path, header=None)
+    features = data.iloc[:, :-1]
+    labels = data.iloc[:, -1]
+
+    if labels.dtype == object or np.issubdtype(labels.dtype, np.integer):
+        labels, unique_labels = pd.factorize(labels)
+    
+    scaler = StandardScaler()
+    features_scaled = scaler.fit_transform(features)
+
+    return features_scaled, labels
+
+folder_path = 'C:\\Users\\tt235\\Desktop\\Code\\code\\代码复现\\算法学习测试数据集'
+files = [f for f in os.listdir(folder_path) if f.endswith('.xls')]
+
+for file in files:
+    file_path = os.path.join(folder_path, file)
+    features_scaled, labels = load_and_preprocess_data(file_path)
+    mlp = MLPClassifier(hidden_layer_sizes=(30,), max_iter=10000,learning_rate_init=0.1)
+
+    for i in range(10):  
+        kf = KFold(n_splits=10, shuffle=True, random_state=i)  
+        scores = cross_val_score(mlp, features_scaled, labels, cv=kf)
+        average_accuracy = scores.mean() * 100
+        print(f"\nIteration {i + 1} Training on file: {file}")
+        print(f"Average Validation Accuracy: {average_accuracy:.2f}%")