吴恩达DeepLearning第二部分作业week2 优化器设计： min_batch、momentum梯度下降、adam优化算法

最新推荐文章于 2022-11-13 20:41:39 发布
最新推荐文章于 2022-11-13 20:41:39 发布
阅读量887 收藏 1
点赞数
分类专栏： 吴恩达DeepLearning作业 文章标签： python deep learning 神经网络
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_30805765/article/details/124207430
版权
本文探讨了三种深度学习优化算法：批处理梯度下降、动量梯度下降和Adam算法。通过代码实现，展示了它们在训练神经网络时的效率和准确性。实验结果显示，Adam算法的收敛速度最快，其次是动量梯度下降，而批处理梯度下降最慢。分批训练虽然牺牲了向量化的优势，但提高了训练效果。
摘要由CSDN通过智能技术生成

这次作业比较简单按照公式打就行：

首先导包，读取数据并查看数据

import numpy as np
import matplotlib.pyplot as plt
import opt_utils
import time

x_train, y_train = opt_utils.load_dataset()
# print(x_train.shape)
# print(y_train.shape)

构建神经网络

def init(x):
    first_num = 9
    second_num = 5
    third_num = 2
    np.random.seed(5)
    w1 = np.random.randn(first_num, x.shape[0]) * np.sqrt(2 / x.shape[0])
    b1 = np.zeros((first_num, 1))
    w2 = np.random.randn(second_num, first_num) * np.sqrt(2 / first_num)
    b2 = np.zeros((second_num, 1))
    w3 = np.random.randn(third_num, second_num) * np.sqrt(2 / second_num)
    b3 = np.zeros((third_num, 1))
    w4 = np.random.randn(1, third_num) * np.sqrt(2 / third_num)
    b4 = np.zeros((1, 1))
    ini_param = {
        "w1": w1,
        "b1": b1,
        "w2": w2,
        "b2": b2,
        "w3": w3,
        "b3": b3,
        "w4": w4,
        "b4": b4
    }
    return ini_param


# 构建前向
def cal_z(w, a, b):  # a维度：上层节点数*例子数 w维度：该层节点数*上层节点数
    return np.dot(w, a) + b


def cal_sigma(z):  # z维度：该层节点数*例子数
    return 1 / (1 + np.exp(-z))


def cal_tan_h(z):  # z1维度hidden_num*x.shape[1]
    return np.tanh(z)


def cal_relu(z):  # z维度：该层节点数*例子数
    return np.maximum(0, z)


def forward_f(x, p):
    z1 = cal_z(p["w1"], x, p["b1"])
    a1 = cal_relu(z1)
    z2 = cal_z(p["w2"], a1, p["b2"])
    a2 = cal_relu(z2)
    z3 = cal_z(p["w3"], a2, p["b3"])
    a3 = cal_relu(z3)
    z4 = cal_z(p["w4"], a3, p["b4"])
    a4 = cal_sigma(z4)
    forward_param = {
        "z1": z1,
        "a1": a1,
        "z2": z2,
        "a2": a2,
        "z3": z3,
        "a3": a3,
        "z4": z4,
        "a4": a4
    }
    return forward_param


# 计算损失函数
def cost_f(a, y):  # a维度: 1*例子数 y维度：1*例子数
    m = y.shape[1]
    return -np.sum(y * np.log(a) + (1 - y) * np.log(1 - a)) / m


# 后向
def cal_dz_last(a, y):  # ai维度：第i层节点数*例子数 y维度：1*例子数
    return a - y


def cal_dw_db(dz, a, m):  # dzi维度：第i层节点数*例子数 ai维度：第i层节点数*例子数
    return np.dot(dz, a.T) / m, np.sum(dz, axis=1, keepdims=True) / m


def cal_da(dz, w):  # dzi维度：第i层节点数*例子数 wi维度：第i层节点数*第i-1层节点数
    return np.dot(w.T, dz)


def cal_drelu(da, z):  # dai维度：第i层节点数*例子数 zi维度：第i层节点数*例子数
    t = np.ones(z.shape)
    t[z <= 0] = 0
    return da * t


def back_f(p, f_p, x, y):
    dz4 = cal_dz_last(f_p["a4"], y)
    dw4, db4 = cal_dw_db(dz4, f_p["a3"], y.shape[1])

    da3 = cal_da(dz4, p["w4"])
    dz3 = cal_drelu(da3, f_p["z3"])
    dw3, db3 = cal_dw_db(dz3, f_p["a2"], y.shape[1])

    da2 = cal_da(dz3, p["w3"])
    dz2 = cal_drelu(da2, f_p["z2"])
    dw2, db2 = cal_dw_db(dz2, f_p["a1"], y.shape[1])

    da1 = cal_da(dz2, p["w2"])
    dz1 = cal_drelu(da1, f_p["z1"])
    dw1, db1 = cal_dw_db(dz1, x, y.shape[1])

    back_param = {
        "dw4": dw4,
        "db4": db4,
        "dw3": dw3,
        "db3": db3,
        "dw2": dw2,
        "db2": db2,
        "dw1": dw1,
        "db1": db1
    }
    return back_param



# 更新参数
def update_p(p, b_p, learning_rate):
    upd_p = {
        "w1": p["w1"] - learning_rate * b_p["dw1"],
        "b1": p["b1"] - learning_rate * b_p["db1"],
        "w2": p["w2"] - learning_rate * b_p["dw2"],
        "b2": p["b2"] - learning_rate * b_p["db2"],
        "w3": p["w3"] - learning_rate * b_p["dw3"],
        "b3": p["b3"] - learning_rate * b_p["db3"],
        "w4": p["w4"] - learning_rate * b_p["dw4"],
        "b4": p["b4"] - learning_rate * b_p["db4"]
    }
    return upd_p

这边建模，训练。要改成批处理梯度下降和min_batch梯度下降可以通用的：

# 建模
def model(x, y, learning_rate, loop_num, p):
    cost_t = []
    for i in range(loop_num):
        f_p = forward_f(x, p)
        b_p = back_f(p, f_p, x, y)
        p = update_p(p, b_p, learning_rate)
        if i % 10 == 0:
            cost_t.append(cost_f(f_p["a4"], y))
    return p, np.array(cost_t)


def model_min_batch(x, y, min_batch_size, learning_rate, loop_num):
    # 洗牌
    size = x.shape[1]
    temp = np.random.permutation(size)  # 获取一个0-m之间的随机排列序列数组
    shuttle_x = x[:, temp]
    shuttle_y = y[:, temp]

    # 划分
    p = init(x)
    cost = []
    num = int(size / min_batch_size)
    if size % min_batch_size != 0:
        start = int(num * min_batch_size)
        x_min_batch = shuttle_x[:, start:size - 1]
        y_min_batch = shuttle_y[:, start:size - 1]
        p, cost_t = model(x_min_batch, y_min_batch, learning_rate, loop_num, p)
        cost.extend(cost_t)
    for i in range(num):
        start = int(i * min_batch_size)
        end = int((i + 1) * min_batch_size - 1)
        x_min_batch = shuttle_x[:, start:end]
        y_min_batch = shuttle_y[:, start:end]
        p, cost_t = model(x_min_batch, y_min_batch, learning_rate, loop_num, p)
        cost.extend(cost_t)
    return p, cost

首先，不分块只需将min_batch_size设为数据集大小就行。

model_p_gd, cost_gd = model_min_batch(x_train, y_train, x_train.shape[1], 0.003, 800)

time_start_gd = time.time()
model_p_gd, cost_gd = model_min_batch(x_train, y_train, x_train.shape[1], 0.003, 800)
time_end_gd = time.time()
print("整体运时间：", time_end_gd - time_start_gd)
train_f_p_gd=forward_f(x_train,model_p_gd)
print("整个运行准确度：", 100 * (1 - np.sum(np.abs(np.round(train_f_p_gd["a4"]) - y_train)) / y_train.shape[1]), '%')
print_figure(x_train, y_train, model_p_gd, cost_gd,"batch_gd")

分批运行修改传入参数：

odel_p_mb, cost_mb = model_min_batch(x_train, y_train, 64, 0.003, 800)

time_start_mb = time.time()
model_p_mb, cost_mb = model_min_batch(x_train, y_train, 64, 0.003, 800)  # 分成2^n每份最佳
time_end_mb = time.time()
print("分批：", time_end_mb - time_start_mb)
train_f_p_mb=forward_f(x_train,model_p_mb)
print("分批运行准确度：", 100 * (1 - np.sum(np.abs(np.round(train_f_p_mb["a4"]) - y_train)) / y_train.shape[1]), '%')
print_figure(x_train, y_train, model_p_mb, cost_mb,"minbatch")

使用动量梯度下降，要修改以下三个部分：

1.后向加入vdw和vdb

2.更新w和b的值，需要将传入后向参数改为传入v值

3.修改训练的函数

 修改后向：

def back_f_mementum(p, f_p, x, y, v, beta1):
    dz4 = cal_dz_last(f_p["a4"], y)
    dw4, db4 = cal_dw_db(dz4, f_p["a3"], y.shape[1])
    v["vdw4"] = beta1 * v["vdw4"] + (1 - beta1) * dw4
    v["vdb4"] = beta1 * v["vdb4"] + (1 - beta1) * db4

    da3 = cal_da(dz4, p["w4"])
    dz3 = cal_drelu(da3, f_p["z3"])
    dw3, db3 = cal_dw_db(dz3, f_p["a2"], y.shape[1])
    v["vdw3"] = beta1 * v["vdw3"] + (1 - beta1) * dw3
    v["vdb3"] = beta1 * v["vdb3"] + (1 - beta1) * db3

    da2 = cal_da(dz3, p["w3"])
    dz2 = cal_drelu(da2, f_p["z2"])
    dw2, db2 = cal_dw_db(dz2, f_p["a1"], y.shape[1])
    v["vdw2"] = beta1 * v["vdw2"] + (1 - beta1) * dw2
    v["vdb2"] = beta1 * v["vdb2"] + (1 - beta1) * db2

    da1 = cal_da(dz2, p["w2"])
    dz1 = cal_drelu(da1, f_p["z1"])
    dw1, db1 = cal_dw_db(dz1, x, y.shape[1])
    v["vdw1"] = beta1 * v["vdw1"] + (1 - beta1) * dw1
    v["vdb1"] = beta1 * v["vdb1"] + (1 - beta1) * db1

    back_param = {
        "dw4": dw4,
        "db4": db4,
        "dw3": dw3,
        "db3": db3,
        "dw2": dw2,
        "db2": db2,
        "dw1": dw1,
        "db1": db1
    }
    return back_param, v

修改更新w、b函数：

def update_p_momentum(p, v, learning_rate):
    upd_p = {
        "w1": p["w1"] - learning_rate * v["vdw1"],
        "b1": p["b1"] - learning_rate * v["vdb1"],
        "w2": p["w2"] - learning_rate * v["vdw2"],
        "b2": p["b2"] - learning_rate * v["vdb2"],
        "w3": p["w3"] - learning_rate * v["vdw3"],
        "b3": p["b3"] - learning_rate * v["vdb3"],
        "w4": p["w4"] - learning_rate * v["vdw4"],
        "b4": p["b4"] - learning_rate * v["vdb4"]
    }
    return upd_p

修改训练函数：

def model_momentum(x, y, learning_rate, loop_num, p, v, beta1):
    cost_t = []

    for i in range(loop_num):
        f_p = forward_f(x, p)
        b_p, v = back_f_mementum(p, f_p, x, y, v, beta1)
        p = update_p_momentum(p, v, learning_rate)
        if i % 10 == 0:
            cost_t.append(cost_f(f_p["a4"], y))
    return p, np.array(cost_t), v


def model_min_batch_momentum(x, y, min_batch_size, learning_rate, loop_num, beta1=0.9):
    # 洗牌
    size = x.shape[1]
    temp = np.random.permutation(size)  # 获取一个0-m之间的随机排列序列数组
    shuttle_x = x[:, temp]
    shuttle_y = y[:, temp]

    # 划分
    p = init(x)
    cost = []
    num = int(size / min_batch_size)
    v = {
        "vdw4": 0,
        "vdb4": 0,
        "vdw3": 0,
        "vdb3": 0,
        "vdw2": 0,
        "vdb2": 0,
        "vdw1": 0,
        "vdb1": 0
    }
    if size % min_batch_size != 0:
        start = int(num * min_batch_size)
        x_min_batch = shuttle_x[:, start:size - 1]
        y_min_batch = shuttle_y[:, start:size - 1]
        p, cost_t, v = model_momentum(x_min_batch, y_min_batch, learning_rate, loop_num, p, v, beta1)
        cost.extend(cost_t)
    for i in range(num):
        start = int(i * min_batch_size)
        end = int((i + 1) * min_batch_size - 1)
        x_min_batch = shuttle_x[:, start:end]
        y_min_batch = shuttle_y[:, start:end]
        p, cost_t, v = model_momentum(x_min_batch, y_min_batch, learning_rate, loop_num, p, v, beta1)
        cost.extend(cost_t)
    return p, cost

 用Adam算法需要修改：

1.后向在mementum基础上引入s

2.更新w和b的值

3修改训练的函数

修改后向：

def back_f_Adam(p, f_p, x, y, v, s, beta1, beta2):
    dz4 = cal_dz_last(f_p["a4"], y)
    dw4, db4 = cal_dw_db(dz4, f_p["a3"], y.shape[1])
    v["vdw4"] = beta1 * v["vdw4"] + (1 - beta1) * dw4
    v["vdb4"] = beta1 * v["vdb4"] + (1 - beta1) * db4
    s["sdw4"] = beta2 * s["sdw4"] + (1 - beta2) * (dw4 ** 2)
    s["sdb4"] = beta2 * s["sdb4"] + (1 - beta2) * (db4 ** 2)

    da3 = cal_da(dz4, p["w4"])
    dz3 = cal_drelu(da3, f_p["z3"])
    dw3, db3 = cal_dw_db(dz3, f_p["a2"], y.shape[1])
    v["vdw3"] = beta1 * v["vdw3"] + (1 - beta1) * dw3
    v["vdb3"] = beta1 * v["vdb3"] + (1 - beta1) * db3
    s["sdw3"] = beta2 * s["sdw3"] + (1 - beta2) * (dw3 ** 2)
    s["sdb3"] = beta2 * s["sdb3"] + (1 - beta2) * (db3 ** 2)

    da2 = cal_da(dz3, p["w3"])
    dz2 = cal_drelu(da2, f_p["z2"])
    dw2, db2 = cal_dw_db(dz2, f_p["a1"], y.shape[1])
    v["vdw2"] = beta1 * v["vdw2"] + (1 - beta1) * dw2
    v["vdb2"] = beta1 * v["vdb2"] + (1 - beta1) * db2
    s["sdw2"] = beta2 * s["sdw2"] + (1 - beta2) * (dw2 ** 2)
    s["sdb2"] = beta2 * s["sdb2"] + (1 - beta2) * (db2 ** 2)

    da1 = cal_da(dz2, p["w2"])
    dz1 = cal_drelu(da1, f_p["z1"])
    dw1, db1 = cal_dw_db(dz1, x, y.shape[1])
    v["vdw1"] = beta1 * v["vdw1"] + (1 - beta1) * dw1
    v["vdb1"] = beta1 * v["vdb1"] + (1 - beta1) * db1
    s["sdw1"] = beta2 * s["sdw1"] + (1 - beta2) * (dw1 ** 2)
    s["sdb1"] = beta2 * s["sdb1"] + (1 - beta2) * (db1 ** 2)

    back_param = {
        "dw4": dw4,
        "db4": db4,
        "dw3": dw3,
        "db3": db3,
        "dw2": dw2,
        "db2": db2,
        "dw1": dw1,
        "db1": db1
    }
    return back_param, v, s

 修改更新函数：

def update_p_Adam(p, v, s, learning_rate, i, beta1, beta2):
    e = 0.000000001
    vbias_cor = (1 - beta1 ** (i+1)) + e
    sbias_cor = (1 - beta2 ** (i+1)) + e
    upd_p = {
        "w1": p["w1"] - learning_rate * (v["vdw1"] / vbias_cor) / np.sqrt(s["sdw1"] / sbias_cor),
        "b1": p["b1"] - learning_rate * (v["vdb1"] / vbias_cor) / np.sqrt(s["sdb1"] / sbias_cor),
        "w2": p["w2"] - learning_rate * (v["vdw2"] / vbias_cor) / np.sqrt(s["sdw2"] / sbias_cor),
        "b2": p["b2"] - learning_rate * (v["vdb2"] / vbias_cor) / np.sqrt(s["sdb2"] / sbias_cor),
        "w3": p["w3"] - learning_rate * (v["vdw3"] / vbias_cor) / np.sqrt(s["sdw3"] / sbias_cor),
        "b3": p["b3"] - learning_rate * (v["vdb3"] / vbias_cor) / np.sqrt(s["sdb3"] / sbias_cor),
        "w4": p["w4"] - learning_rate * (v["vdw4"] / vbias_cor) / np.sqrt(s["sdw4"] / sbias_cor),
        "b4": p["b4"] - learning_rate * (v["vdb4"] / vbias_cor) / np.sqrt(s["sdb4"] / sbias_cor)
    }
    return upd_p

修改训练函数：

def model_Adam(x, y, learning_rate, loop_num, p, v, s, beta1, beta2):
    cost_t = []

    for i in range(loop_num):
        f_p = forward_f(x, p)
        b_p, v, s = back_f_Adam(p, f_p, x, y, v, s, beta1, beta2)
        p = update_p_Adam(p, v, s, learning_rate, i,beta1,beta2)
        if i % 10 == 0:
            cost_t.append(cost_f(f_p["a4"], y))
    return p, np.array(cost_t), v, s


def model_min_batch_Adam(x, y, min_batch_size, learning_rate, loop_num, beta1=0.9, beta2=0.999):
    # 洗牌
    size = x.shape[1]
    temp = np.random.permutation(size)  # 获取一个0-m之间的随机排列序列数组
    shuttle_x = x[:, temp]
    shuttle_y = y[:, temp]

    # 划分
    p = init(x)
    cost = []
    num = int(size / min_batch_size)

    v = {
        "vdw4": 0,
        "vdb4": 0,
        "vdw3": 0,
        "vdb3": 0,
        "vdw2": 0,
        "vdb2": 0,
        "vdw1": 0,
        "vdb1": 0
    }
    s = {
        "sdw4": 0,
        "sdb4": 0,
        "sdw3": 0,
        "sdb3": 0,
        "sdw2": 0,
        "sdb2": 0,
        "sdw1": 0,
        "sdb1": 0
    }
    if size % min_batch_size != 0:
        start = int(num * min_batch_size)
        x_min_batch = shuttle_x[:, start:size - 1]
        y_min_batch = shuttle_y[:, start:size - 1]
        p, cost_t, v, s = model_Adam(x_min_batch, y_min_batch, learning_rate, loop_num, p, v, s, beta1, beta2)
        cost.extend(cost_t)

    for i in range(num):
        start = int(i * min_batch_size)
        end = int((i + 1) * min_batch_size - 1)
        x_min_batch = shuttle_x[:, start:end]
        y_min_batch = shuttle_y[:, start:end]
        p, cost_t, v, s = model_Adam(x_min_batch, y_min_batch, learning_rate, loop_num, p, v,s, beta1, beta2)
        cost.extend(cost_t)

    return p, cost

整体运行时间： 0.28107190132141113
整个运行准确度： 84.33333333333333 %


分批运行时间： 0.9800760746002197
分批运行准确度： 88.66666666666667 %


动量运行时间： 1.166001319885254
动量下降准确度： 88.66666666666667 %


Adam： 1.5370657444000244
Adam准确度： 92.0 %
 

4次训练采用相同epoch次数和学习率，根据loss图可以看出下降速率Adam>mementum=min_batch>batch gradient decent

min_batch牺牲了向量化，运行时间变长，可能数据太小mementum和min_batch没有明显区别

我来试试水
关注
专栏目录
4-Week1-PA1_deeplearning_吴恩达深度学习作业第四周_
10-04
吴恩达深度学习第四周课程代码，希望大家能从中有所收获
Cousera吴恩达深度学习第二次编程作业
OldDriver1995的博客
06-13 314
第二次编程作业出现在第三周，下载链接如下： https://mp.csdn.net/console/upDetailed （6月13日上传，如果看不到可能还在审核）
Pytorch深度学习——用Mini-Batch训练数据（B站刘二大人P8学习笔记）
Learning_AI的博客
01-12 6358
先前我们学习的内容一种情况是采用Full-Batch来训练数据，还有一种情况是在随机梯度下降中，只去其中一个数据来计算梯度，这种情况可以使我我们很好的解决训练数据时遇到的鞍点问题，但是会导致时间过长。所以，接下来我们要学习的是采用Mini-Batch的方法来训练数据，这种方式可以均衡性能和训练时间上的需求。 Epoch Batch-Size Iteration shuffle 是否打乱顺序
吴恩达 深度学习 编程作业（1-2）- Python Basics with Numpy & Logistic Regression with a Neural Network mindset
热门推荐
大树先生的博客
09-21 7万+
Part 1：Python Basics with Numpy (optional assignment) Part 2： Logistic Regression with a Neural Network mindset
吴恩达deeplearning第二周作业
m0_57302305的博客
01-07 1140
参考【目录】【中文】【deplearning.ai】【吴恩达课后作业目录】_何宽的博客-CSDN博客_吴恩达课后作业 目的：搭建一个能够【识别猫】的简单的神经网络。 先试着查看一下训练集中的图片： PS：在pycharm里会出现无法显示Matplotlib绘图的情况，这是由于matplotlib.imshow()导致的，在绘图参数等语句和plt.imshow()之后加上plt.show()，即可正常显示Matplotlib绘图。 改变index的值，可以查看不同的图片，eg分别将index的值改为3
吴恩达Deep Learning编程作业 Course1-神经网络和深度学习-第二周作业
qq_34621022的博客
02-29 675
吴恩达Deep Learning编程作业 Course1-神经网络和深度学习-第二周作业 Logistic Regression with a Neural Network mindset 具有神经网络思维的逻辑回归 编程要求： 在代码中不要使用循环，除非说明中明确告诉你需要使用。 编程目的： 建立学习算法的一般架构，包括： 初始化参数 计算代价函数及其梯度 使用优化算法（梯...
吴恩达deeplearning课后作业Course_1代码.zip
12-06
在这个“吴恩达deeplearning课后作业Course_1代码.zip”压缩包中，包含了课程第一部分（Course_1）的三个不同作业的源代码，分别是关于搭建深层神经网络、神经网络思维的逻辑回归以及使用一个隐藏层解决平面数据分类...
Adam优化算法原理详解（吴恩达深度学习笔记）
01-06
在介绍Adam之前首先介绍一下momentum和RMSprop优化算法。 一、momentum 1、指数加权平均数 指数加权平均数不仅考虑了当前数值也涵盖了以前的数据对现在的影响。 解释指数加权平均值名称的由来： 指数加权平均值的...
吴恩达DeepLearning课后作业Course_2代码.zip
12-06
在本压缩包“吴恩达DeepLearning课后作业Course_2代码.zip”中，包含了深度学习领域的核心概念和实践应用，主要围绕三个主题展开：初始化、正则化和梯度检验，优化算法，以及超参数调整、批量归一化和编程框架。...
吴恩达 深度学习 第一课到第四课全部课后练习
01-30
吴恩达深度学习的课后练习，从第一课到第四课，截止到目前，第五课视频网易上还没有，所以第五课作业还没出。每课每周的作业都有，包含答案，第三课只有习题测试没有编程，所以不要误会资源不全，前三课的练习和第四课第一周的练习在压缩包中，第四课后三周的编程练习由于数据集太大，超出上传限制，所以给出的是一个下载链接（百度云）（搜集他人的资源）。非常好的学习资源，虽然资源分有点多，但是这是全部四课的练习，性价比还是很高的。
吴恩达深度学习课程 第二课 作业 （原题 + 自己写的答案）
12-28
吴恩达深度学习课程 第二课作业：包括 原题 以及 自己写的答案。 自己写的答案均检测过，其中因为代码更新而导致的问题也修改了。 原题没任何改动，但我加了一个修改提示文档。
吴恩达 [deeplearning.ai 神经网络和深度学习] 第二周编程作业总结
yvetteQXX的博客
09-18 408
本文参考：https://blog.csdn.net/u013733326/article/details/79639509 进入研究生阶段后，首先意识到的是需要尽快对神经网络进行熟悉与学习，于是参加了网易云课堂吴恩达老师发布的一系列课程，并跟随课程完成课后作业，并进行简单理解与记录。需要注意的是，本文是在参考文基础上，进行简单总结与理解，若需要参考算法具体的分析，可查看本文所参考的文章。 第...
神经网络优化——梯度下降常用算法：随机梯度下降、批处理梯度下降、Momentum、move average、RMSprop、Adma
jmu201521121021的博客
02-04 3136
神经网络优化——梯度下降常用算法：min-batch、随机梯度下降、批处理梯度下降、Momentum、move average、RMSprop、Adma 简介 梯度下降算法是应用于神经网络反向传播过程的计算梯度，然后更新参数,最终找到最优的位置。本博客主要介绍随机梯度下降、批处理梯度下降、Momentum、move average、RMSprop、Adma。也是对Andrew NG 的deepl...
mini-batch梯度下降
baicaiBC3的博客
12-22 148
一般来说，当m<2000时直接一个batch即可，否则尝试用幂mini-batch。考虑到计算机内存是二进制的形式，所以一个mini-batch的大小设置为2的次方数，比如64、128、256、512。 由于篇幅较少，所以就直接和代码放到一起了。 import numpy as np import matplotlib.pyplot as plt import copy import math from scipy.io import loadmat, savemat # 读入样本数据（已经随..
（吴恩达课后编程作业）Course 1 - 神经网络和深度学习 - 第二周作业01
cheryl88的博客
10-10 1381
吴恩达课后编程作业）Course 1 - 神经网络和深度学习 - 第二周作业环境准备下载资料安装库显示图片查看数据集情况数据维度转换标准化数据定义sigmoid函数初始化参数w和b了计算成本函数优化函数预测函数整合到model函数中 首先进行数据处理 然后建立神经网络，主要步骤是： 定义模型结构（例如输入特征的数量） 初始化模型的参数 循环： 3.1 计算当前损失（正向传播） 3.2 计算当前梯度（反向传播） 3.3 更新参数（梯度下降） 环境准备 pycharm+anaconda 我是用p
吴恩达深度学习作业（week2）-(1)
最新发布
Runasia的博客
11-13 2079
b=np.sum(a,axis=1,dtype=None,out=None,keepdims=True) ### 即计算没一行的总值 组成一个向量。x = np.linspace(-5, 5, 100) #numpy中的切分，即将x=-5到5中的值切成100份创建一个数组。x = np.array([1, 2, 3])## 如果是([[1,2,3]])就会创建向量，且为1行3列的行向量。sigmoid的导数 sigmoid=a(x) a(x)`=a(x)(1-a(x))
minibatch
qq_39861441的博客
10-13 1万+
转自：https://testerhome.com/topics/10877 回顾 之前我们讲到了一些在训练模型的时候用到的超参数，例如上一次说的L2 正则， 在过拟合的场景中增加L2的值有助于减小网络的复杂度。 还有诸如学习率， 在梯度下降中，每一次迭代的下降的步长是学习率乘以成本函数对w的导数。所以如果我们想让算法训练的快一点，调高学习率可以有效的减少迭代次数。 诸如此类的还有迭代次数，激...
吴恩达深度学习第二章编程作业
qq_38816432的博客
07-25 367
#!/usr/bin/env python # coding: utf-8 # In[3]: import numpy as np import h5py import matplotlib.pyplot as plt np.set_printoptions(threshold=np.inf) def load_dataset(): train_dataset = h5py.File('datasets/train_catvnoncat.h5',"r") # print([keys
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值