神经网络解决非线性二分类

这份 Python 代码实现了一个简单的神经网络，用于解决复杂的非线性二分类问题。具体步骤包含生成数据集、定义神经网络模型、训练模型、测试模型以及可视化决策边界。

依赖库说明

python

import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import make_moons
from sklearn.model_selection import train_test_split

• numpy：用于数值计算，如数组操作、矩阵运算等。
• matplotlib.pyplot：用于数据可视化，如绘制决策边界和数据点。
• make_moons：从sklearn.datasets导入，用于生成半月形的非线性分类数据集。
• train_test_split：从sklearn.model_selection导入，用于将数据集划分为训练集和测试集。

详细步骤说明

1. 生成复杂的非线性分类数据集

python

np.random.seed(42)
X, y = make_moons(n_samples=1000, noise=0.2, random_state=42)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

• np.random.seed(42)：设置随机数种子，保证结果可复现。
• make_moons(n_samples=1000, noise=0.2, random_state=42)：生成包含 1000 个样本的半月形数据集，噪声水平为 0.2。
• train_test_split(X, y, test_size=0.2, random_state=42)：将数据集按 80:20 的比例划分为训练集和测试集。

2. 定义神经网络（带隐藏层的非线性分类模型）

python

class SimpleNN:def __init__(self, input_size=2, hidden_size=10, output_size=1):self.w1 = np.random.randn(input_size, hidden_size)self.b1 = np.random.randn(hidden_size)self.w2 = np.random.randn(hidden_size, output_size)self.b2 = np.random.randn(output_size)

• __init__方法：初始化神经网络的权重和偏置。input_size为输入层神经元数量，hidden_size为隐藏层神经元数量，output_size为输出层神经元数量。

python

    def sigmoid(self, x):return 1 / (1 + np.exp(-x))def relu(self, x):return np.maximum(0, x)

• sigmoid方法：实现 Sigmoid 激活函数，将输入值映射到 (0, 1) 区间，常用于二分类问题的输出层。
• relu方法：实现 ReLU 激活函数，将小于 0 的值置为 0，大于等于 0 的值保持不变，可缓解梯度消失问题。

python

    def forward(self, x):self.z1 = np.dot(x, self.w1) + self.b1self.a1 = self.relu(self.z1)self.z2 = np.dot(self.a1, self.w2) + self.b2self.a2 = self.sigmoid(self.z2)return self.a2

• forward方法：实现神经网络的前向传播过程。输入数据经过输入层到隐藏层的线性变换，再通过 ReLU 激活函数；然后经过隐藏层到输出层的线性变换，最后通过 Sigmoid 激活函数得到输出。

python

    def binary_cross_entropy(self, y_true, y_pred):return -np.mean(y_true * np.log(y_pred) + (1 - y_true) * np.log(1 - y_pred))

• binary_cross_entropy方法：计算二分类交叉熵损失，衡量模型预测值与真实值之间的差异。

python

    def gradient(self, x, y_true, y_pred):m = x.shape[0]d_z2 = y_pred - y_trued_w2 = np.dot(self.a1.T, d_z2) / md_b2 = np.sum(d_z2, axis=0) / md_a1 = np.dot(d_z2, self.w2.T)d_z1 = d_a1 * (self.z1 > 0)d_w1 = np.dot(x.T, d_z1) / md_b1 = np.sum(d_z1, axis=0) / mreturn d_w1, d_b1, d_w2, d_b2

• gradient方法：实现反向传播算法，计算权重和偏置的梯度。

python

    def train(self, x, y, lr=0.01, epochs=1000):for epoch in range(epochs):y_pred = self.forward(x)dw1, db1, dw2, db2 = self.gradient(x, y, y_pred)self.w1 -= lr * dw1self.b1 -= lr * db1self.w2 -= lr * dw2self.b2 -= lr * db2if (epoch + 1) % 100 == 0:loss = self.binary_cross_entropy(y, y_pred)acc = self.accuracy(y, y_pred)print(f'Epoch [{epoch+1}/{epochs}], Loss: {loss:.4f}, Accuracy: {acc:.4f}')

• train方法：训练神经网络。在每个 epoch 中，先进行前向传播得到预测值，再通过反向传播计算梯度，最后更新权重和偏置。每 100 个 epoch 打印一次损失和准确率。

python

    def accuracy(self, y_true, y_pred):y_pred_class = (y_pred > 0.5).astype(int)return np.mean(y_pred_class == y_true)

• accuracy方法：计算分类准确率，将预测概率大于 0.5 的样本判定为正类，小于等于 0.5 的判定为负类，然后计算预测正确的样本比例。

3. 训练模型

python

model = SimpleNN(input_size=2, hidden_size=10, output_size=1)
model.train(X_train, y_train.reshape(-1, 1), lr=0.01, epochs=2000)

• 创建SimpleNN类的实例model，并调用train方法对模型进行训练，学习率为 0.01，训练 2000 个 epoch。

4. 测试模型

python

y_test_pred = model.forward(X_test)
test_acc = model.accuracy(y_test.reshape(-1, 1), y_test_pred)
print(f'Test Accuracy: {test_acc:.4f}')

• 使用训练好的模型对测试集进行预测，计算测试集的准确率并打印。

5. 可视化决策边界

python

def plot_decision_boundary(model, X, y):x_min, x_max = X[:, 0].min() - 1, X[:, 0].max() + 1y_min, y_max = X[:, 1].min() - 1, X[:, 1].max() + 1xx, yy = np.meshgrid(np.arange(x_min, x_max, 0.01),np.arange(y_min, y_max, 0.01))grid = np.c_[xx.ravel(), yy.ravel()]probs = model.forward(grid).reshape(xx.shape)plt.contourf(xx, yy, probs, levels=[0, 0.5, 1], alpha=0.8, cmap=plt.cm.RdBu)plt.scatter(X[:, 0], X[:, 1], c=y, edgecolors='k', cmap=plt.cm.RdBu)plt.title("Decision Boundary")plt.show()plot_decision_boundary(model, X_test, y_test)

• plot_decision_boundary函数：绘制模型的决策边界。首先创建一个网格，然后对网格中的每个点进行预测，最后使用contourf函数绘制决策区域，并使用scatter函数绘制数据点。
• 调用plot_decision_boundary函数，传入训练好的模型、测试集数据和标签，可视化决策边界。

总结

该代码实现了一个简单的两层神经网络，用于解决复杂的非线性二分类问题。通过生成数据集、定义模型、训练模型、测试模型和可视化决策边界等步骤，展示了神经网络在非线性分类任务中的应用。

完整代码

import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import make_moons
from sklearn.model_selection import train_test_split# 1. 生成复杂的非线性分类数据集
np.random.seed(42)
X, y = make_moons(n_samples=1000, noise=0.2, random_state=42)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)# 2. 定义神经网络（带隐藏层的非线性分类模型）
class SimpleNN:def __init__(self, input_size=2, hidden_size=10, output_size=1):# 初始化权重和偏置self.w1 = np.random.randn(input_size, hidden_size)  # 输入层到隐藏层的权重self.b1 = np.random.randn(hidden_size)              # 隐藏层的偏置self.w2 = np.random.randn(hidden_size, output_size)  # 隐藏层到输出层的权重self.b2 = np.random.randn(output_size)              # 输出层的偏置def sigmoid(self, x):return 1 / (1 + np.exp(-x))  # Sigmoid激活函数def relu(self, x):return np.maximum(0, x)  # ReLU激活函数def forward(self, x):# 前向传播self.z1 = np.dot(x, self.w1) + self.b1  # 隐藏层输入self.a1 = self.relu(self.z1)            # 隐藏层输出（应用ReLU）self.z2 = np.dot(self.a1, self.w2) + self.b2  # 输出层输入self.a2 = self.sigmoid(self.z2)         # 输出层输出（应用Sigmoid）return self.a2def binary_cross_entropy(self, y_true, y_pred):# 二分类交叉熵损失return -np.mean(y_true * np.log(y_pred) + (1 - y_true) * np.log(1 - y_pred))def gradient(self, x, y_true, y_pred):# 反向传播计算梯度m = x.shape[0]# 输出层的梯度d_z2 = y_pred - y_trued_w2 = np.dot(self.a1.T, d_z2) / md_b2 = np.sum(d_z2, axis=0) / m# 隐藏层的梯度d_a1 = np.dot(d_z2, self.w2.T)d_z1 = d_a1 * (self.z1 > 0)  # ReLU的导数d_w1 = np.dot(x.T, d_z1) / md_b1 = np.sum(d_z1, axis=0) / mreturn d_w1, d_b1, d_w2, d_b2def train(self, x, y, lr=0.01, epochs=2000):for epoch in range(epochs):y_pred = self.forward(x)dw1, db1, dw2, db2 = self.gradient(x, y, y_pred)# 更新权重和偏置self.w1 -= lr * dw1self.b1 -= lr * db1self.w2 -= lr * dw2self.b2 -= lr * db2if (epoch + 1) % 100 == 0:loss = self.binary_cross_entropy(y, y_pred)acc = self.accuracy(y, y_pred)print(f'Epoch [{epoch+1}/{epochs}], Loss: {loss:.4f}, Accuracy: {acc:.4f}')def accuracy(self, y_true, y_pred):# 计算分类准确率y_pred_class = (y_pred > 0.5).astype(int)return np.mean(y_pred_class == y_true)# 3. 训练模型
model = SimpleNN(input_size=2, hidden_size=10, output_size=1)
model.train(X_train, y_train.reshape(-1, 1), lr=0.01, epochs=2000)# 4. 测试模型
y_test_pred = model.forward(X_test)
test_acc = model.accuracy(y_test.reshape(-1, 1), y_test_pred)
print(f'Test Accuracy: {test_acc:.4f}')# 5. 可视化决策边界
def plot_decision_boundary(model, X, y):x_min, x_max = X[:, 0].min() - 1, X[:, 0].max() + 1y_min, y_max = X[:, 1].min() - 1, X[:, 1].max() + 1xx, yy = np.meshgrid(np.arange(x_min, x_max, 0.01),np.arange(y_min, y_max, 0.01))grid = np.c_[xx.ravel(), yy.ravel()]probs = model.forward(grid).reshape(xx.shape)plt.contourf(xx, yy, probs, levels=[0, 0.5, 1], alpha=0.8, cmap=plt.cm.RdBu)plt.scatter(X[:, 0], X[:, 1], c=y, edgecolors='k', cmap=plt.cm.RdBu)plt.title("Decision Boundary")plt.show()plot_decision_boundary(model, X_test, y_test)