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

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

问题遇到的现象和发生背景
问题相关代码,请勿粘贴截图

import pandas as pd
import numpy as np
import datetime
import matplotlib.pyplot as plt
from pandas.plotting import radviz
'''
构建一个具有1个隐藏层的神经网络,隐层的大小为10
输入层为4个特征,输出层为3个分类
(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}

return grads

5.更新参数

def update_parameters(parameters, grads, learning_rate=0.4):
w1 = parameters['w1']
b1 = parameters['b1']
w2 = parameters['w2']
b2 = parameters['b2']

dw1 = grads['dw1']
db1 = grads['db1']
dw2 = grads['dw2']
db2 = grads['db2']

# 更新参数
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.更新参数
    parameters = update_parameters(parameters, grads)

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

return parameters
运行结果及报错内容
我的解答思路和尝试过的方法

想问一下各位这个代码的反向传播部分里面的计算公式是对的嘛,尤其是dw1,dw2部分,现在需要学习率很高才能快速收敛

我想要达到的结果

2条回答 默认 最新

相关推荐 更多相似问题