深度学习入门_神经网络基础

引言

深度学习作为人工智能领域的核心技术，已经广泛应用于图像识别、自然语言处理、语音识别等多个领域。本文将深入介绍神经网络的基础知识，包括其原理、结构以及实际应用。

神经网络的生物启发

人工神经网络（ANN）的灵感来源于生物神经系统的结构和功能。人脑由数十亿个神经元组成，这些神经元通过突触相互连接，形成复杂的网络结构。每个神经元接收来自其他神经元的信号，进行处理后传递给下一个神经元。

人工神经元模仿了这种机制：

• 接收输入信号
• 对输入进行加权求和
• 应用激活函数
• 产生输出

感知器：最早的神经网络模型

感知器（Perceptron）由Frank Rosenblatt在1957年提出，是最简单的人工神经网络模型。

感知器的工作原理

感知器接收多个输入，对每个输入赋予一个权重，然后计算加权和，最后通过激活函数产生输出。

importnumpyasnpclassPerceptron:def__init__(self,input_size,learning_rate=0.01,epochs=100):self.weights=np.zeros(input_size+1)# +1 for biasself.learning_rate=learning_rate self.epochs=epochsdefpredict(self,inputs):# 添加偏置项inputs_with_bias=np.insert(inputs,0,1)# 计算加权和weighted_sum=np.dot(inputs_with_bias,self.weights)# 应用阶跃激活函数return1ifweighted_sum>0else0deftrain(self,training_inputs,labels):for_inrange(self.epochs):forinputs,labelinzip(training_inputs,labels):prediction=self.predict(inputs)# 计算误差error=label-prediction# 更新权重inputs_with_bias=np.insert(inputs,0,1)self.weights+=self.learning_rate*error*inputs_with_bias# 示例：使用感知器实现AND逻辑门training_inputs=np.array([[0,0],[0,1],[1,0],[1,1]])labels=np.array([0,0,0,1])perceptron=Perceptron(input_size=2)perceptron.train(training_inputs,labels)# 测试test_inputs=np.array([[0,0],[0,1],[1,0],[1,1]])forinputsintest_inputs:print(f"输入:{inputs}, 输出:{perceptron.predict(inputs)}")

感知器的局限性

感知器只能解决线性可分问题，对于异或（XOR）这样的非线性问题无能为力。这一局限性导致了第一次"AI冬天"的到来。

多层感知器（MLP）

为了解决感知器的局限性，研究人员提出了多层感知器，也称为前馈神经网络。

MLP的结构

多层感知器包含：

• 输入层：接收原始数据
• 隐藏层：提取特征和进行非线性变换
• 输出层：产生最终预测

importnumpyasnpclassMLP:def__init__(self,input_size,hidden_size,output_size):# 初始化权重self.weights1=np.random.randn(input_size,hidden_size)self.bias1=np.zeros(hidden_size)self.weights2=np.random.randn(hidden_size,output_size)self.bias2=np.zeros(output_size)defsigmoid(self,x):return1/(1+np.exp(-x))defsigmoid_derivative(self,x):returnx*(1-x)defforward(self,X):# 前向传播self.hidden=self.sigmoid(np.dot(X,self.weights1)+self.bias1)self.output=self.sigmoid(np.dot(self.hidden,self.weights2)+self.bias2)returnself.outputdefbackward(self,X,y,learning_rate):# 反向传播# 计算输出层误差output_error=y-self.output output_delta=output_error*self.sigmoid_derivative(self.output)# 计算隐藏层误差hidden_error=output_delta.dot(self.weights2.T)hidden_delta=hidden_error*self.sigmoid_derivative(self.hidden)# 更新权重self.weights2+=self.hidden.T.dot(output_delta)*learning_rate self.bias2+=np.sum(output_delta,axis=0)*learning_rate self.weights1+=X.T.dot(hidden_delta)*learning_rate self.bias1+=np.sum(hidden_delta,axis=0)*learning_ratedeftrain(self,X,y,epochs,learning_rate):for_inrange(epochs):self.forward(X)self.backward(X,y,learning_rate)defpredict(self,X):returnself.forward(X)# 示例：使用MLP解决XOR问题X=np.array([[0,0],[0,1],[1,0],[1,1]])y=np.array([[0],[1],[1],[0]])mlp=MLP(input_size=2,hidden_size=4,output_size=1)mlp.train(X,y,epochs=10000,learning_rate=0.1)# 测试predictions=mlp.predict(X)foriinrange(len(X)):print(f"输入:{X[i]}, 期望:{y[i][0]}, 预测:{predictions[i][0]:.4f}")

激活函数

激活函数引入非线性特性，使神经网络能够学习复杂的模式。

常用激活函数

1. Sigmoid函数

   • 公式：σ ( x ) = 1 1 + e − x \sigma(x) = \frac{1}{1 + e^{-x}}σ(x)=1+e−x1​
   • 特点：输出范围(0,1)，适合概率输出
   • 缺点：存在梯度消失问题

2. Tanh函数

   • 公式：tanh ⁡ ( x ) = e x − e − x e x + e − x \tanh(x) = \frac{e^x - e^{-x}}{e^x + e^{-x}}tanh(x)=ex+e−xex−e−x​
   • 特点：输出范围(-1,1)，零中心化

3. ReLU函数

   • 公式：ReLU ( x ) = max ⁡ ( 0 , x ) \text{ReLU}(x) = \max(0, x)ReLU(x)=max(0,x)
   • 特点：计算简单，缓解梯度消失
   • 缺点：存在"死亡ReLU"问题

4. Leaky ReLU

   • 公式：LeakyReLU ( x ) = max ⁡ ( α x , x ) \text{LeakyReLU}(x) = \max(\alpha x, x)LeakyReLU(x)=max(αx,x)，其中α \alphaα是小常数
   • 特点：解决死亡ReLU问题

importnumpyasnpimportmatplotlib.pyplotaspltdefsigmoid(x):return1/(1+np.exp(-x))deftanh(x):returnnp.tanh(x)defrelu(x):returnnp.maximum(0,x)defleaky_relu(x,alpha=0.01):returnnp.maximum(alpha*x,x)# 生成输入值x=np.linspace(-5,5,100)# 计算各激活函数的输出y_sigmoid=sigmoid(x)y_tanh=tanh(x)y_relu=relu(x)y_leaky_relu=leaky_relu(x)# 绘制激活函数plt.figure(figsize=(12,8))plt.subplot(2,2,1)plt.plot(x,y_sigmoid)plt.title('Sigmoid')plt.grid(True)plt.subplot(2,2,2)plt.plot(x,y_tanh)plt.title('Tanh')plt.grid(True)plt.subplot(2,2,3)plt.plot(x,y_relu)plt.title('ReLU')plt.grid(True)plt.subplot(2,2,4)plt.plot(x,y_leaky_relu)plt.title('Leaky ReLU')plt.grid(True)plt.tight_layout()plt.show()

损失函数

损失函数衡量模型预测与真实值之间的差异。

常用损失函数

1. 均方误差（MSE）

   • 适用于回归问题
   • 公式：M S E = 1 n ∑ i = 1 n ( y i − y ^ i ) 2 MSE = \frac{1}{n}\sum_{i=1}^{n}(y_i - \hat{y}_i)^2MSE=n1​∑i=1n​(yi​−y^​i​)2

2. 交叉熵损失

   • 适用于分类问题
   • 二分类：L = − [ y log ⁡ ( y ^ ) + ( 1 − y ) log ⁡ ( 1 − y ^ ) ] L = -[y\log(\hat{y}) + (1-y)\log(1-\hat{y})]L=−[ylog(y^​)+(1−y)log(1−y^​)]
   • 多分类：L = − ∑ i = 1 c y i log ⁡ ( y ^ i ) L = -\sum_{i=1}^{c}y_i\log(\hat{y}_i)L=−∑i=1c​yi​log(y^​i​)

defmean_squared_error(y_true,y_pred):returnnp.mean((y_true-y_pred)**2)defbinary_cross_entropy(y_true,y_pred):# 避免log(0)的情况y_pred=np.clip(y_pred,1e-15,1-1e-15)return-np.mean(y_true*np.log(y_pred)+(1-y_true)*np.log(1-y_pred))defcategorical_cross_entropy(y_true,y_pred):# 避免log(0)的情况y_pred=np.clip(y_pred,1e-15,1-1e-15)return-np.mean(np.sum(y_true*np.log(y_pred),axis=1))

反向传播算法

反向传播是训练神经网络的核心算法，通过链式法则计算梯度。

classNeuralNetwork:def__init__(self,layers):self.layers=[]self.weights=[]# 初始化网络foriinrange(len(layers)-1):self.weights.append(np.random.randn(layers[i],layers[i+1])*0.01)defrelu(self,x):returnnp.maximum(0,x)defrelu_derivative(self,x):return(x>0).astype(float)defsoftmax(self,x):exp_x=np.exp(x-np.max(x,axis=1,keepdims=True))returnexp_x/np.sum(exp_x,axis=1,keepdims=True)defforward(self,X):self.layers=[X]# 前向传播foriinrange(len(self.weights)-1):self.layers.append(self.relu(np.dot(self.layers[-1],self.weights[i])))# 输出层使用softmaxself.layers.append(self.softmax(np.dot(self.layers[-1],self.weights[-1])))returnself.layers[-1]defbackward(self,X,y,learning_rate):m=X.shape[0]# 样本数量# 前向传播output=self.forward(X)# 计算输出层梯度delta=output-y d_weights=[np.dot(self.layers[-2].T,delta)/m]# 反向传播foriinrange(len(self.weights)-2,-1,-1):delta=np.dot(delta,self.weights[i+1].T)*self.relu_derivative(self.layers[i+1])d_weights.insert(0,np.dot(self.layers[i].T,delta)/m)# 更新权重foriinrange(len(self.weights)):self.weights[i]-=learning_rate*d_weights[i]deftrain(self,X,y,epochs,learning_rate,batch_size=32):n_samples=X.shape[0]forepochinrange(epochs):# 随机打乱数据permutation=np.random.permutation(n_samples)X_shuffled=X[permutation]y_shuffled=y[permutation]# 批量训练foriinrange(0,n_samples,batch_size):X_batch=X_shuffled[i:i+batch_size]y_batch=y_shuffled[i:i+batch_size]self.backward(X_batch,y_batch,learning_rate)# 计算损失output=self.forward(X)loss=-np.mean(np.sum(y*np.log(output+1e-15),axis=1))ifepoch%100==0:print(f"Epoch{epoch}, Loss:{loss:.4f}")defpredict(self,X):output=self.forward(X)returnnp.argmax(output,axis=1)

实战项目：手写数字识别

让我们使用神经网络实现MNIST手写数字识别。

importnumpyasnpfromsklearn.datasetsimportfetch_openmlfromsklearn.model_selectionimporttrain_test_splitfromsklearn.preprocessingimportOneHotEncoder# 加载MNIST数据集print("加载MNIST数据集...")mnist=fetch_openml('mnist_784',version=1)X,y=mnist['data'],mnist['target']# 数据预处理X=X/255.0# 归一化到[0,1]范围X=X.values# 转换为numpy数组# 将标签转换为one-hot编码encoder=OneHotEncoder(sparse=False)y_onehot=encoder.fit_transform(y.values.reshape(-1,1))# 划分训练集和测试集X_train,X_test,y_train,y_test=train_test_split(X,y_onehot,test_size=0.2,random_state=42)# 创建神经网络nn=NeuralNetwork(layers=[784,128,64,10])# 训练网络print("开始训练神经网络...")nn.train(X_train,y_train,epochs=500,learning_rate=0.01,batch_size=64)# 评估模型print("评估模型性能...")predictions=nn.predict(X_test)true_labels=np.argmax(y_test,axis=1)accuracy=np.mean(predictions==true_labels)print(f"测试集准确率:{accuracy:.4f}")# 可视化一些预测结果importmatplotlib.pyplotaspltdefplot_predictions(images,true_labels,predicted_labels,n=10):plt.figure(figsize=(20,4))foriinrange(n):plt.subplot(1,n,i+1)plt.imshow(images[i].reshape(28,28),cmap='gray')plt.title(f"True:{true_labels[i]}\nPred:{predicted_labels[i]}")plt.axis('off')plt.show()# 显示前10个测试样本的预测结果plot_predictions(X_test[:10],true_labels[:10],predictions[:10])

优化技巧

1. 学习率调度

动态调整学习率可以提高训练效果：

deflearning_rate_schedule(epoch,initial_lr=0.01):ifepoch<100:returninitial_lrelifepoch<300:returninitial_lr*0.1else:returninitial_lr*0.01

2. Dropout正则化

Dropout防止过拟合：

classNeuralNetworkWithDropout:def__init__(self,layers,dropout_rate=0.5):self.layers=[]self.weights=[]self.dropout_rate=dropout_rateforiinrange(len(layers)-1):self.weights.append(np.random.randn(layers[i],layers[i+1])*0.01)defdropout(self,X):ifself.dropout_rate>0:mask=np.random.binomial(1,1-self.dropout_rate,size=X.shape)returnX*mask/(1-self.dropout_rate)returnXdefforward(self,X,training=True):self.layers=[X]foriinrange(len(self.weights)-1):linear=np.dot(self.layers[-1],self.weights[i])activation=self.relu(linear)iftraining:activation=self.dropout(activation)self.layers.append(activation)# 输出层self.layers.append(self.softmax(np.dot(self.layers[-1],self.weights[-1])))returnself.layers[-1]

3. 批量归一化

批量归一化加速训练并提高稳定性：

classBatchNormalization:def__init__(self,input_dim,momentum=0.9):self.gamma=np.ones(input_dim)self.beta=np.zeros(input_dim)self.momentum=momentum self.running_mean=np.zeros(input_dim)self.running_var=np.zeros(input_dim)defforward(self,X,training=True):iftraining:mean=np.mean(X,axis=0)var=np.var(X,axis=0)# 更新运行均值和方差self.running_mean=self.momentum*self.running_mean+(1-self.momentum)*mean self.running_var=self.momentum*self.running_var+(1-self.momentum)*var# 归一化X_normalized=(X-mean)/np.sqrt(var+1e-8)self.X_normalized=X_normalizedelse:X_normalized=(X-self.running_mean)/np.sqrt(self.running_var+1e-8)# 缩放和偏移out=self.gamma*X_normalized+self.betareturnout

实际应用：鸢尾花分类

让我们用神经网络解决经典的鸢尾花分类问题：

importnumpyasnpfromsklearn.datasetsimportload_irisfromsklearn.model_selectionimporttrain_test_splitfromsklearn.preprocessingimportStandardScaler,OneHotEncoder# 加载数据iris=load_iris()X=iris.data y=iris.target.reshape(-1,1)# 数据预处理scaler=StandardScaler()X_scaled=scaler.fit_transform(X)# 标签编码encoder=OneHotEncoder(sparse=False)y_onehot=encoder.fit_transform(y)# 划分数据集X_train,X_test,y_train,y_test=train_test_split(X_scaled,y_onehot,test_size=0.2,random_state=42)# 创建并训练网络nn=NeuralNetwork(layers=[4,8,3])nn.train(X_train,y_train,epochs=1000,learning_rate=0.01,batch_size=16)# 评估predictions=nn.predict(X_test)true_labels=np.argmax(y_test,axis=1)accuracy=np.mean(predictions==true_labels)print(f"鸢尾花分类准确率:{accuracy:.4f}")# 显示分类报告fromsklearn.metricsimportclassification_reportprint("\n分类报告:")print(classification_report(true_labels,predictions,target_names=iris.target_names))

总结

神经网络是深度学习的基础，通过模仿生物神经系统的结构和功能，能够学习复杂的模式。本文介绍了：

1. 感知器及其局限性
2. 多层感知器的原理和实现
3. 常用的激活函数和损失函数
4. 反向传播算法的细节
5. 实际项目案例和优化技巧

神经网络的发展仍在继续，新的架构和优化方法不断涌现。掌握这些基础知识将为深入学习更复杂的深度学习模型打下坚实基础。

学习建议

1. 探索更先进的优化算法（Adam、RMSprop等）
2. 学习卷积神经网络（CNN）处理图像数据
3. 研究循环神经网络（RNN）处理序列数据
4. 了解注意力机制和Transformer架构
5. 尝试使用深度学习框架（TensorFlow、PyTorch）

深度学习是一个不断发展的领域，持续学习和实践是掌握这项技术的关键。