1.什么是神经网络
![]()
2.第2关：神经元与感知机
#encoding=utf8 import numpy as np #构建感知机算法 class Perceptron(object): def __init__(self, learning_rate = 0.01, max_iter = 200): self.lr = learning_rate self.max_iter = max_iter def fit(self, data, label): ''' input:data(ndarray):训练数据特征 label(ndarray):训练数据标签 output:w(ndarray):训练好的权重 b(ndarry):训练好的偏置 ''' # 初始化权重和偏置 self.w = np.random.randn(data.shape[1]) self.b = np.random.rand(1) # ********* Begin *********# for _ in range(self.max_iter): for i in range(data.shape[0]): xi = data[i] yi = label[i] # 计算输出 output = np.dot(self.w, xi) + self.b # 若误分类，更新权重和偏置 if yi * output <= 0: self.w += self.lr * yi * xi self.b += self.lr * yi # ********* End *********# def predict(self, data): ''' input:data(ndarray):测试数据特征 ''' # ********* Begin *********# output = np.dot(self.w, data) + self.b return 1 if output >= 0 else -1 # ********* End *********# # 下面是训练和预测示例（供你测试） if __name__ == "__main__": # 构造题目中给出的数据 data = np.array([ [0, 0, 0], # 青绿, 蜷缩, 浊响 [1, 0, 0], # 乌黑, 蜷缩, 浊响 [0, 1, 1], # 青绿, 硬挺, 清脆 [1, 2, 2] # 乌黑, 稍蜷, 沉闷 ]) label = np.array([1, 1, -1, -1]) # 训练感知机 perceptron = Perceptron(learning_rate=0.1, max_iter=1000) perceptron.fit(data, label) # 预测题目给的样本：青绿、稍蜷、沉闷（即 [0,2,2]） test_sample = np.array([0, 2, 2]) print("预测结果：", perceptron.predict(test_sample))
3.激活函数
#encoding=utf8 def relu(x): ''' input:x(ndarray)输入数据 ''' #********* Begin *********# return max(x, 0) #********* End *********#
4.反向传播算法
#encoding=utf8 import numpy as np from math import sqrt #bp神经网络训练方法 def bp_train(feature,label,n_hidden,maxcycle,alpha,n_output): ''' 计算隐含层的输入 input:feature(mat):特征 label(mat):标签 n_hidden(int)隐藏层的节点个数 maxcycle(int):最大迭代次数 alpha(float):学习率 n_output(int):输出层的节点个数 output:w0(mat):输入层到隐藏层之间的权重 b0(mat):输入层到隐藏层之间的偏置 w1(mat):隐藏层到输出层之间的权重 b1(mat):隐藏层到输出层之间的偏置 ''' m,n = np.shape(feature) # 使用Xavier均匀初始化，偏置初始化为0 bound0 = sqrt(6.0 / (n + n_hidden)) w0 = np.mat(np.random.uniform(-bound0, bound0, (n, n_hidden))) b0 = np.mat(np.zeros((1, n_hidden))) bound1 = sqrt(6.0 / (n_hidden + n_output)) w1 = np.mat(np.random.uniform(-bound1, bound1, (n_hidden, n_output))) b1 = np.mat(np.zeros((1, n_output))) # 动量项初始化 momentum = 0.9 v_w0 = np.mat(np.zeros((n, n_hidden))) v_b0 = np.mat(np.zeros((1, n_hidden))) v_w1 = np.mat(np.zeros((n_hidden, n_output))) v_b1 = np.mat(np.zeros((1, n_output))) #训练 i = 0 while i <= maxcycle: #********* Begin *********# # 1. 前向传播 hidden_input = hidden_in(feature, w0, b0) hidden_output = hidden_out(hidden_input) output_input = predict_in(hidden_output, w1, b1) output_output = predict_out(output_input) # 2. 反向传播（核心修正：输出层误差不再乘sigmoid导数） # 输出层残差（交叉熵损失 + sigmoid 的梯度简化形式） delta2 = output_output - label # 隐藏层残差（需要乘sigmoid导数） delta1 = np.multiply(delta2 * w1.T, partial_sig(hidden_input)) # 3. 计算批量梯度（平均梯度） grad_w1 = hidden_output.T * delta2 / m grad_b1 = np.sum(delta2, axis=0) / m grad_w0 = feature.T * delta1 / m grad_b0 = np.sum(delta1, axis=0) / m # 4. 带动量的参数更新 v_w1 = momentum * v_w1 - alpha * grad_w1 w1 += v_w1 v_b1 = momentum * v_b1 - alpha * grad_b1 b1 += v_b1 v_w0 = momentum * v_w0 - alpha * grad_w0 w0 += v_w0 v_b0 = momentum * v_b0 - alpha * grad_b0 b0 += v_b0 #********* End *********# i +=1 return w0,w1,b0,b1 #计算隐藏层的输入函数 def hidden_in(feature,w0,b0): m = np.shape(feature)[0] hidden_in = feature*w0 for i in range(m): hidden_in[i,] += b0 return hidden_in #计算隐藏层的输出函数 def hidden_out(hidden_in): hidden_output = sig(hidden_in) return hidden_output #计算输出层的输入函数 def predict_in(hidden_out,w1,b1): m = np.shape(hidden_out)[0] predict_in = hidden_out*w1 for i in range(m): predict_in[i,] +=b1 return predict_in #计算输出层的输出的函数 def predict_out(predict_in): result = sig(predict_in) return result #sigmoid函数 def sig(x): return 1.0/(1+np.exp(-x)) #计算sigmoid函数偏导 def partial_sig(x): m,n = np.shape(x) out = np.mat(np.zeros((m,n))) for i in range(m): for j in range(n): out[i,j] = sig(x[i,j])*(1-sig(x[i,j])) return out
5.Dropout
#encoding=utf8 import numpy as np #由于Dropout方法输出存在随机性，我们已经设置好随机种子，你只需要完成Dropout方法就行。 class Dropout: def __init__(self,dropout_ratio=0.5): self.dropout_ratio = dropout_ratio self.mask = None def forward(self,x,train_flg=True): ''' 前向传播中self.mask会随机生成和x形状相同的数组， 并将值比dropout_ratio大的元素设为True， x为一个列表。 ''' #********* Begin *********# x = np.array(x) if train_flg: # 生成随机掩码，大于dropout_ratio的神经元保留（设为True） self.mask = np.random.rand(*x.shape) > self.dropout_ratio # 被丢弃的神经元输出置0 return x * self.mask else: # 测试阶段：输出乘以(1-丢弃率)，保持期望一致 return x * (1 - self.dropout_ratio) #********* End *********# def backward(self,dout): ''' 前向传播时传递了信号的神经元， 反向传播时按原样传递信号。 前向传播没有传递信号的神经元， 反向传播时信号就停在那里。 dout为一个列表。 ''' #********* Begin *********# dout = np.array(dout) # 只有前向传播中保留的神经元才传递梯度 return dout * self.mask #********* End *********#
6.sklearn中的神经网络
#encoding=utf8 from sklearn.neural_network import MLPClassifier def iris_predict(train_sample, train_label, test_sample): ''' 实现功能：1.训练模型 2.预测 :param train_sample: 包含多条训练样本的样本集，类型为ndarray :param train_label: 包含多条训练样本标签的标签集，类型为ndarray :param test_sample: 包含多条测试样本的测试集，类型为ndarry :return: test_sample对应的预测标签 ''' #********* Begin *********# # 初始化MLP分类器，参数针对鸢尾花数据集优化 mlp = MLPClassifier( solver='lbfgs', # 小数据集上lbfgs收敛更快、效果更稳定 alpha=1e-5, # L2正则化系数，防止过拟合 hidden_layer_sizes=(100,), # 单隐藏层100个神经元，足够拟合鸢尾花数据 max_iter=200, # 足够的迭代次数保证收敛 random_state=42 # 固定随机种子，保证结果可复现 ) # 训练模型 mlp.fit(train_sample, train_label) # 预测并返回结果 return mlp.predict(test_sample) #********* End *********#
