xuetuzzz 2022-03-17 01:20 采纳率: 100%

# Python BP神经网络两分类 反向传播代码问题

###### 问题相关代码，请勿粘贴截图

import pandas as pd
import numpy as np
import datetime
import matplotlib.pyplot as plt
'''

(1,0,0)为第一类，(0,1,0)为第二类，(0,0,1)为第三类
'''

# 1.初始化参数

def initialize_parameters(n_x, n_h, n_y):
np.random.seed(2)

``````# 权重和偏置矩阵
w1 = np.random.randn(n_h, n_x) * 0.01
b1 = np.zeros(shape=(n_h, 1))
w2 = np.random.randn(n_y, n_h) * 0.01
b2 = np.zeros(shape=(n_y, 1))

# 通过字典存储参数
parameters = {'w1': w1, 'b1': b1, 'w2': w2, 'b2': b2}

return parameters
``````

# 2.前向传播

def forward_propagation(X, parameters):
w1 = parameters['w1']
b1 = parameters['b1']
w2 = parameters['w2']
b2 = parameters['b2']

``````# 通过前向传播来计算a2
z1 = np.dot(w1, X) + b1     # 这个地方需注意矩阵加法：虽然(w1*X)和b1的维度不同，但可以相加
a1 = np.tanh(z1)            # 使用tanh作为第一层的激活函数
z2 = np.dot(w2, a1) + b2
a2 = 1 / (1 + np.exp(-z2))  # 使用sigmoid作为第二层的激活函数

# 通过字典存储参数
cache = {'z1': z1, 'a1': a1, 'z2': z2, 'a2': a2}

return a2, cache
``````

# 3.计算代价函数

def compute_cost(a2, Y):
m = Y.shape[1] # Y的列数即为总的样本数

``````# 采用交叉熵（cross-entropy）作为代价函数
logprobs = np.multiply(np.log(a2), Y) + np.multiply(np.log(1 - a2),(1 - Y))
cost = - np.sum(logprobs) / m

return cost
``````

# 4.反向传播（计算代价函数的导数）

def backward_propagation(parameters, cache, X, Y):
m = Y.shape[1]

``````w2 = parameters['w2']

a1 = cache['a1']
a2 = cache['a2']

# 反向传播，计算dw1、db1、dw2、db2
dz2 = a2 - Y
dw2 = (1 / m) * np.dot(dz2, a1.T)
db2 = (1 / m) * np.sum(dz2, axis=1, keepdims=True)
dz1 = np.multiply(np.dot(w2.T, dz2), 1 - np.power(a1, 2))
dw1 = (1 / m) * np.dot(dz1, X.T)
db1 = (1 / m) * np.sum(dz1, axis=1, keepdims=True)

grads = {'dw1': dw1, 'db1': db1, 'dw2': dw2, 'db2': db2}

``````

# 5.更新参数

w1 = parameters['w1']
b1 = parameters['b1']
w2 = parameters['w2']
b2 = parameters['b2']

``````dw1 = grads['dw1']

# 更新参数
w1 = w1 - dw1 * learning_rate
b1 = b1 - db1 * learning_rate
w2 = w2 - dw2 * learning_rate
b2 = b2 - db2 * learning_rate

parameters = {'w1': w1, 'b1': b1, 'w2': w2, 'b2': b2}

return parameters
``````

# 建立神经网络

def nn_model(X, Y, n_h, n_input, n_output, num_iterations=10000, print_cost=False):
np.random.seed(3)

``````n_x = n_input           # 输入层节点数
n_y = n_output          # 输出层节点数

# 1.初始化参数
parameters = initialize_parameters(n_x, n_h, n_y)

# 梯度下降循环
for i in range(0, num_iterations):
# 2.前向传播
a2, cache = forward_propagation(X, parameters)
# 3.计算代价函数
cost = compute_cost(a2, Y)
# 4.反向传播
grads = backward_propagation(parameters, cache, X, Y)
# 5.更新参数

# 每1000次迭代，输出一次代价函数
if print_cost and i % 1000 == 0:
print('迭代第%i次，代价函数为：%f' % (i, cost))

return parameters
``````

• 写回答

#### 2条回答默认 最新

• 关注
本回答被题主选为最佳回答 , 对您是否有帮助呢?
评论

• 系统已结题 3月25日
• 已采纳回答 3月17日
• 创建了问题 3月17日

#### 悬赏问题

• ¥20 求友友们解惑，感激不尽
• ¥15 python中aiohttp.client_exceptions.ContentTypeError
• ¥30 DeepLung肺结节检测生成最大froc值对应的epoch报错
• ¥15 信号发生器如何将频率调大，步尽值改成10
• ¥15 keil 5 编程智能家具，风扇台灯开关，人体感应等
• ¥100 找一名渗透方面的专家
• ¥20 使用Matlab APP设计一个插补小程序
• ¥15 evo评估时曲线出现问题
• ¥15 eNSP拓扑图配置实验
• ¥20 有没有兄弟会替换fmod studio的.bank文件内的音效？