python实现两层全连接网络DNN

下面是一个使用Python实现的两层全连接神经网络（DNN）的示例代码：

import numpy as np

# 定义激活函数sigmoid
def sigmoid(x):
    return 1 / (1 + np.exp(-x))

# 定义DNN类
class DNN:
    def __init__(self, input_size, hidden_size, output_size):
        self.W1 = np.random.randn(input_size, hidden_size) # 第一层权重
        self.b1 = np.zeros((1, hidden_size)) # 第一层偏置
        self.W2 = np.random.randn(hidden_size, output_size) # 第二层权重
        self.b2 = np.zeros((1, output_size)) # 第二层偏置
    
    # 前向传播
    def forward(self, X):
        self.z1 = np.dot(X, self.W1) + self.b1 # 第一层线性变换
        self.a1 = sigmoid(self.z1) # 第一层激活
        self.z2 = np.dot(self.a1, self.W2) + self.b2 # 第二层线性变换
        self.a2 = sigmoid(self.z2) # 第二层激活
        return self.a2
    
    # 反向传播
    def backward(self, X, y, learning_rate):
        # 计算输出层误差
        delta2 = (self.a2 - y) * self.a2 * (1 - self.a2)
        # 计算隐藏层误差
        delta1 = np.dot(delta2, self.W2.T) * self.a1 * (1 - self.a1)
        # 更新第二层权重和偏置
        self.W2 -= learning_rate * np.dot(self.a1.T, delta2)
        self.b2 -= learning_rate * np.sum(delta2, axis=0, keepdims=True)
        # 更新第一层权重和偏置
        self.W1 -= learning_rate * np.dot(X.T, delta1)
        self.b1 -= learning_rate * np.sum(delta1, axis=0)
    
    # 训练模型
    def train(self, X, y, learning_rate, epochs):
        for i in range(epochs):
            # 前向传播
            y_pred = self.forward(X)
            # 反向传播
            self.backward(X, y, learning_rate)
            # 计算训练集上的损失
            loss = np.mean(-y * np.log(y_pred) - (1-y) * np.log(1-y_pred))
            if i % 1000 == 0:
                print("Epoch ", i, " loss: ", loss)
    
    # 预测
    def predict(self, X):
        y_pred = self.forward(X)
        return np.round(y_pred)

使用方法：

# 构造数据集
X = np.array([[0,0], [0,1], [1,0], [1,1]])
y = np.array([[0], [1], [1], [0]])

# 定义模型
dnn = DNN(2, 3, 1)

# 训练模型
dnn.train(X, y, 0.1, 10000)

# 预测
y_pred = dnn.predict(X)
print("预测结果：", y_pred)

这个示例代码实现的是一个两层全连接神经网络，输入层有2个神经元，隐藏层有3个神经元，输出层有1个神经元。该模型使用sigmoid作为激活函数，使用交叉熵作为损失函数，使用梯度下降法进行优化。