NNDL 作业10 BPTT

最新推荐文章于 2024-09-12 18:02:47 发布
最新推荐文章于 2024-09-12 18:02:47 发布
阅读量411 收藏 6
点赞数 9
文章标签： 人工智能 深度学习 cnn
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_72169474/article/details/134886979
版权

习题6-1P 推导RNN反向传播算法BPTT.

注：diag的含义：

习题6-2 推导公式(6.40)和公式(6.41)中的梯度．

习题6-3 当使用公式(6.50)作为循环神经网络的状态更新公式时， 分析其可能存在梯度爆炸的原因并给出解决方法．

公式(6.50)如下

使用上式进行状态更新的优点是：使h(t),h(t-1)既有线性关系，也有非线性关系，既增强了模型的表示能力，也可以缓解梯度消失问题。

但是这种改进策略依然存在两个问题：

（1）梯度爆炸问题：

在利用（6.50）进行更新时，它与原来的更新方式实际上就是增加了一个h(t-1),来增加模型的线性关系，有了h(t-1), 模型不易发生梯度消失，但是模型的梯度爆炸问题并未解决，模型依旧可能因为计算出的误差项过大，而导致梯度过大，也就是梯度爆炸。

（2）记忆容量问题：

当激活函数g(x)为Logistic,ReLU这类输出永远为非负数的函数时，h(t)会随着时间t的增加，而变得越来越大，此时的激活函数趋于饱和值，参数更新前后无明显的差别。可以形象的说，h(t)可以储存的信息是有限的，随着记忆单元存储的内容越来越多，其丢失的信息也越来越多。

解决方法：通过引入门控机制来进一步改善模型

习题6-2P 设计简单RNN模型，分别用Numpy、Pytorch实现反向传播算子，并代入数值测试.

首先，导入软件包

import numpy as np
from rnn_utils import *

rnn_utils.py中的代码如下：

import numpy as np


def softmax(x):
    e_x = np.exp(x - np.max(x))
    return e_x / e_x.sum(axis=0)


def sigmoid(x):
    return 1 / (1 + np.exp(-x))


def initialize_adam(parameters):
    """
    Initializes v and s as two python dictionaries with:
                - keys: "dW1", "db1", ..., "dWL", "dbL"
                - values: numpy arrays of zeros of the same shape as the corresponding gradients/parameters.

    Arguments:
    parameters -- python dictionary containing your parameters.
                    parameters["W" + str(l)] = Wl
                    parameters["b" + str(l)] = bl

    Returns:
    v -- python dictionary that will contain the exponentially weighted average of the gradient.
                    v["dW" + str(l)] = ...
                    v["db" + str(l)] = ...
    s -- python dictionary that will contain the exponentially weighted average of the squared gradient.
                    s["dW" + str(l)] = ...
                    s["db" + str(l)] = ...

    """

    L = len(parameters) // 2  # number of layers in the neural networks
    v = {}
    s = {}

    # Initialize v, s. Input: "parameters". Outputs: "v, s".
    for l in range(L):
        ### START CODE HERE ### (approx. 4 lines)
        v["dW" + str(l + 1)] = np.zeros(parameters["W" + str(l + 1)].shape)
        v["db" + str(l + 1)] = np.zeros(parameters["b" + str(l + 1)].shape)
        s["dW" + str(l + 1)] = np.zeros(parameters["W" + str(l + 1)].shape)
        s["db" + str(l + 1)] = np.zeros(parameters["b" + str(l + 1)].shape)
    ### END CODE HERE ###

    return v, s


def update_parameters_with_adam(parameters, grads, v, s, t, learning_rate=0.01,
                                beta1=0.9, beta2=0.999, epsilon=1e-8):
    """
    Update parameters using Adam

    Arguments:
    parameters -- python dictionary containing your parameters:
                    parameters['W' + str(l)] = Wl
                    parameters['b' + str(l)] = bl
    grads -- python dictionary containing your gradients for each parameters:
                    grads['dW' + str(l)] = dWl
                    grads['db' + str(l)] = dbl
    v -- Adam variable, moving average of the first gradient, python dictionary
    s -- Adam variable, moving average of the squared gradient, python dictionary
    learning_rate -- the learning rate, scalar.
    beta1 -- Exponential decay hyperparameter for the first moment estimates
    beta2 -- Exponential decay hyperparameter for the second moment estimates
    epsilon -- hyperparameter preventing division by zero in Adam updates

    Returns:
    parameters -- python dictionary containing your updated parameters
    v -- Adam variable, moving average of the first gradient, python dictionary
    s -- Adam variable, moving average of the squared gradient, python dictionary
    """

    L = len(parameters) // 2  # number of layers in the neural networks
    v_corrected = {}  # Initializing first moment estimate, python dictionary
    s_corrected = {}  # Initializing second moment estimate, python dictionary

    # Perform Adam update on all parameters
    for l in range(L):
        # Moving average of the gradients. Inputs: "v, grads, beta1". Output: "v".
        ### START CODE HERE ### (approx. 2 lines)
        v["dW" + str(l + 1)] = beta1 * v["dW" + str(l + 1)] + (1 - beta1) * grads["dW" + str(l + 1)]
        v["db" + str(l + 1)] = beta1 * v["db" + str(l + 1)] + (1 - beta1) * grads["db" + str(l + 1)]
        ### END CODE HERE ###

        # Compute bias-corrected first moment estimate. Inputs: "v, beta1, t". Output: "v_corrected".
        ### START CODE HERE ### (approx. 2 lines)
        v_corrected["dW" + str(l + 1)] = v["dW" + str(l + 1)] / (1 - beta1 ** t)
        v_corrected["db" + str(l + 1)] = v["db" + str(l + 1)] / (1 - beta1 ** t)
        ### END CODE HERE ###

        # Moving average of the squared gradients. Inputs: "s, grads, beta2". Output: "s".
        ### START CODE HERE ### (approx. 2 lines)
        s["dW" + str(l + 1)] = beta2 * s["dW" + str(l + 1)] + (1 - beta2) * (grads["dW" + str(l + 1)] ** 2)
        s["db" + str(l + 1)] = beta2 * s["db" + str(l + 1)] + (1 - beta2) * (grads["db" + str(l + 1)] ** 2)
        ### END CODE HERE ###

        # Compute bias-corrected second raw moment estimate. Inputs: "s, beta2, t". Output: "s_corrected".
        ### START CODE HERE ### (approx. 2 lines)
        s_corrected["dW" + str(l + 1)] = s["dW" + str(l + 1)] / (1 - beta2 ** t)
        s_corrected["db" + str(l + 1)] = s["db" + str(l + 1)] / (1 - beta2 ** t)
        ### END CODE HERE ###

        # Update parameters. Inputs: "parameters, learning_rate, v_corrected, s_corrected, epsilon". Output: "parameters".
        ### START CODE HERE ### (approx. 2 lines)
        parameters["W" + str(l + 1)] = parameters["W" + str(l + 1)] - learning_rate * v_corrected[
            "dW" + str(l + 1)] / np.sqrt(s_corrected["dW" + str(l + 1)] + epsilon)
        parameters["b" + str(l + 1)] = parameters["b" + str(l + 1)] - learning_rate * v_corrected[
            "db" + str(l + 1)] / np.sqrt(s_corrected["db" + str(l + 1)] + epsilon)
        ### END CODE HERE ###

    return parameters, v, s

1.循环神经网络的正向传播

        RNN基本模型为N vs N

1.1RNN单元：

练习：实现图（2）中描述的RNN单元。

# GRADED FUNCTION: rnn_cell_forward

def rnn_cell_forward(xt, a_prev, parameters):
    """
    Implements a single forward step of the RNN-cell as described in Figure (2)

    Arguments:
    xt -- your input data at timestep "t", numpy array of shape (n_x, m).
    a_prev -- Hidden state at timestep "t-1", numpy array of shape (n_a, m)
    parameters -- python dictionary containing:
                        Wax -- Weight matrix multiplying the input, numpy array of shape (n_a, n_x)
                        Waa -- Weight matrix multiplying the hidden state, numpy array of shape (n_a, n_a)
                        Wya -- Weight matrix relating the hidden-state to the output, numpy array of shape (n_y, n_a)
                        ba --  Bias, numpy array of shape (n_a, 1)
                        by -- Bias relating the hidden-state to the output, numpy array of shape (n_y, 1)
    Returns:
    a_next -- next hidden state, of shape (n_a, m)
    yt_pred -- prediction at timestep "t", numpy array of shape (n_y, m)
    cache -- tuple of values needed for the backward pass, contains (a_next, a_prev, xt, parameters)
    """
    
    # Retrieve parameters from "parameters"
    Wax = parameters["Wax"]
    Waa = parameters["Waa"]
    Wya = parameters["Wya"]
    ba = parameters["ba"]
    by = parameters["by"]
    
    ### START CODE HERE ### (≈2 lines)
    # compute next activation state using the formula given above
    a_next = np.tanh(np.dot(Wax,xt)+np.dot(Waa,a_prev)+ba)
    # compute output of the current cell using the formula given above
    yt_pred = softmax(np.dot(Wya,a_next)+by)   
    ### END CODE HERE ###
    
    # store values you need for backward propagation in cache
    cache = (a_next, a_prev, xt, parameters)
    
    return a_next, yt_pred, cache

np.random.seed(1)
xt = np.random.randn(3,10)
a_prev = np.random.randn(5,10)
Waa = np.random.randn(5,5)
Wax = np.random.randn(5,3)
Wya = np.random.randn(2,5)
ba = np.random.randn(5,1)
by = np.random.randn(2,1)
parameters = {"Waa": Waa, "Wax": Wax, "Wya": Wya, "ba": ba, "by": by}

a_next, yt_pred, cache = rnn_cell_forward(xt, a_prev, parameters)
print("a_next[4] = ", a_next[4])
print("a_next.shape = ", a_next.shape)
print("yt_pred[1] =", yt_pred[1])
print("yt_pred.shape = ", yt_pred.shape)
a_next[4] =  [ 0.59584544  0.18141802  0.61311866  0.99808218  0.85016201  0.99980978
 -0.18887155  0.99815551  0.6531151   0.82872037]
a_next.shape =  (5, 10)
yt_pred[1] = [0.9888161  0.01682021 0.21140899 0.36817467 0.98988387 0.88945212
 0.36920224 0.9966312  0.9982559  0.17746526]
yt_pred.shape =  (2, 10)

输出：

1.2RNN正向传播

练习：编码实现图（3）中描述的RNN的正向传播。

# GRADED FUNCTION: rnn_forward

def rnn_forward(x, a0, parameters):
    """
    Implement the forward propagation of the recurrent neural network described in Figure (3).

    Arguments:
    x -- Input data for every time-step, of shape (n_x, m, T_x).
    a0 -- Initial hidden state, of shape (n_a, m)
    parameters -- python dictionary containing:
                        Waa -- Weight matrix multiplying the hidden state, numpy array of shape (n_a, n_a)
                        Wax -- Weight matrix multiplying the input, numpy array of shape (n_a, n_x)
                        Wya -- Weight matrix relating the hidden-state to the output, numpy array of shape (n_y, n_a)
                        ba --  Bias numpy array of shape (n_a, 1)
                        by -- Bias relating the hidden-state to the output, numpy array of shape (n_y, 1)

    Returns:
    a -- Hidden states for every time-step, numpy array of shape (n_a, m, T_x)
    y_pred -- Predictions for every time-step, numpy array of shape (n_y, m, T_x)
    caches -- tuple of values needed for the backward pass, contains (list of caches, x)
    """
    
    # Initialize "caches" which will contain the list of all caches
    caches = []
    
    # Retrieve dimensions from shapes of x and Wy
    n_x, m, T_x = x.shape
    n_y, n_a = parameters["Wya"].shape
    
    ### START CODE HERE ###
    
    # initialize "a" and "y" with zeros (≈2 lines)
    a = np.zeros((n_a,m,T_x))
    y_pred = np.zeros((n_y,m,T_x))
    
    # Initialize a_next (≈1 line)
    a_next = a0
    
    # loop over all time-steps
    for t in range(T_x):
        # Update next hidden state, compute the prediction, get the cache (≈1 line)
        a_next, yt_pred, cache = rnn_cell_forward(x[:,:,t],a_next,parameters)
        # Save the value of the new "next" hidden state in a (≈1 line)
        a[:,:,t] = a_next
        # Save the value of the prediction in y (≈1 line)
        y_pred[:,:,t] = yt_pred
        # Append "cache" to "caches" (≈1 line)
        caches.append(cache)
        
    ### END CODE HERE ###
    
    # store values needed for backward propagation in cache
    caches = (caches, x)
    
    return a, y_pred, caches

np.random.seed(1)
x = np.random.randn(3,10,4)
a0 = np.random.randn(5,10)
Waa = np.random.randn(5,5)
Wax = np.random.randn(5,3)
Wya = np.random.randn(2,5)
ba = np.random.randn(5,1)
by = np.random.randn(2,1)
parameters = {"Waa": Waa, "Wax": Wax, "Wya": Wya, "ba": ba, "by": by}

a, y_pred, caches = rnn_forward(x, a0, parameters)
print("a[4][1] = ", a[4][1])
print("a.shape = ", a.shape)
print("y_pred[1][3] =", y_pred[1][3])
print("y_pred.shape = ", y_pred.shape)
print("caches[1][1][3] =", caches[1][1][3])
print("len(caches) = ", len(caches))
a[4][1] =  [-0.99999375  0.77911235 -0.99861469 -0.99833267]
a.shape =  (5, 10, 4)
y_pred[1][3] = [0.79560373 0.86224861 0.11118257 0.81515947]
y_pred.shape =  (2, 10, 4)
caches[1][1][3] = [-1.1425182  -0.34934272 -0.20889423  0.58662319]
len(caches) =  2

2 长短期记忆网络（LSTM）

2.1 LSTM单元

练习：实现图(3)中描述的LSTM单元。

# GRADED FUNCTION: lstm_cell_forward

def lstm_cell_forward(xt, a_prev, c_prev, parameters):
    """
    Implement a single forward step of the LSTM-cell as described in Figure (4)

    Arguments:
    xt -- your input data at timestep "t", numpy array of shape (n_x, m).
    a_prev -- Hidden state at timestep "t-1", numpy array of shape (n_a, m)
    c_prev -- Memory state at timestep "t-1", numpy array of shape (n_a, m)
    parameters -- python dictionary containing:
                        Wf -- Weight matrix of the forget gate, numpy array of shape (n_a, n_a + n_x)
                        bf -- Bias of the forget gate, numpy array of shape (n_a, 1)
                        Wi -- Weight matrix of the save gate, numpy array of shape (n_a, n_a + n_x)
                        bi -- Bias of the save gate, numpy array of shape (n_a, 1)
                        Wc -- Weight matrix of the first "tanh", numpy array of shape (n_a, n_a + n_x)
                        bc --  Bias of the first "tanh", numpy array of shape (n_a, 1)
                        Wo -- Weight matrix of the focus gate, numpy array of shape (n_a, n_a + n_x)
                        bo --  Bias of the focus gate, numpy array of shape (n_a, 1)
                        Wy -- Weight matrix relating the hidden-state to the output, numpy array of shape (n_y, n_a)
                        by -- Bias relating the hidden-state to the output, numpy array of shape (n_y, 1)
                        
    Returns:
    a_next -- next hidden state, of shape (n_a, m)
    c_next -- next memory state, of shape (n_a, m)
    yt_pred -- prediction at timestep "t", numpy array of shape (n_y, m)
    cache -- tuple of values needed for the backward pass, contains (a_next, c_next, a_prev, c_prev, xt, parameters)
    
    Note: ft/it/ot stand for the forget/update/output gates, cct stands for the candidate value (c tilda),
          c stands for the memory value
    """

    # Retrieve parameters from "parameters"
    Wf = parameters["Wf"]
    bf = parameters["bf"]
    Wi = parameters["Wi"]
    bi = parameters["bi"]
    Wc = parameters["Wc"]
    bc = parameters["bc"]
    Wo = parameters["Wo"]
    bo = parameters["bo"]
    Wy = parameters["Wy"]
    by = parameters["by"]
    
    # Retrieve dimensions from shapes of xt and Wy
    n_x, m = xt.shape
    n_y, n_a = Wy.shape

    ### START CODE HERE ###
    # Concatenate a_prev and xt (≈3 lines)
    concat = np.zeros((n_x+n_a,m))
    concat[: n_a, :] = a_prev
    concat[n_a :, :] = xt

    # Compute values for ft, it, cct, c_next, ot, a_next using the formulas given figure (4) (≈6 lines)
    ft = sigmoid(np.dot(Wf,concat)+bf)
    it = sigmoid(np.dot(Wi,concat)+bi)
    cct = np.tanh(np.dot(Wc,concat)+bc)
    c_next = ft*c_prev + it*cct
    ot = sigmoid(np.dot(Wo,concat)+bo)
    a_next = ot*np.tanh(c_next)
    
    # Compute prediction of the LSTM cell (≈1 line)
    yt_pred = softmax(np.dot(Wy, a_next) + by)
    ### END CODE HERE ###

    # store values needed for backward propagation in cache
    cache = (a_next, c_next, a_prev, c_prev, ft, it, cct, ot, xt, parameters)

    return a_next, c_next, yt_pred, cache


np.random.seed(1)
xt = np.random.randn(3,10)
a_prev = np.random.randn(5,10)
c_prev = np.random.randn(5,10)
Wf = np.random.randn(5, 5+3)
bf = np.random.randn(5,1)
Wi = np.random.randn(5, 5+3)
bi = np.random.randn(5,1)
Wo = np.random.randn(5, 5+3)
bo = np.random.randn(5,1)
Wc = np.random.randn(5, 5+3)
bc = np.random.randn(5,1)
Wy = np.random.randn(2,5)
by = np.random.randn(2,1)

parameters = {"Wf": Wf, "Wi": Wi, "Wo": Wo, "Wc": Wc, "Wy": Wy, "bf": bf, "bi": bi, "bo": bo, "bc": bc, "by": by}

a_next, c_next, yt, cache = lstm_cell_forward(xt, a_prev, c_prev, parameters)
print("a_next[4] = ", a_next[4])
print("a_next.shape = ", c_next.shape)
print("c_next[2] = ", c_next[2])
print("c_next.shape = ", c_next.shape)
print("yt[1] =", yt[1])
print("yt.shape = ", yt.shape)
print("cache[1][3] =", cache[1][3])
print("len(cache) = ", len(cache))
a_next[4] =  [-0.66408471  0.0036921   0.02088357  0.22834167 -0.85575339  0.00138482
  0.76566531  0.34631421 -0.00215674  0.43827275]
a_next.shape =  (5, 10)
c_next[2] =  [ 0.63267805  1.00570849  0.35504474  0.20690913 -1.64566718  0.11832942
  0.76449811 -0.0981561  -0.74348425 -0.26810932]
c_next.shape =  (5, 10)
yt[1] = [0.79913913 0.15986619 0.22412122 0.15606108 0.97057211 0.31146381
 0.00943007 0.12666353 0.39380172 0.07828381]
yt.shape =  (2, 10)
cache[1][3] = [-0.16263996  1.03729328  0.72938082 -0.54101719  0.02752074 -0.30821874
  0.07651101 -1.03752894  1.41219977 -0.37647422]
len(cache) =  10

2.2 LSTM的正向传播

练习：实现以在lstm_forward()Tx​个时间步上运行LSTM。

# GRADED FUNCTION: lstm_forward

def lstm_forward(x, a0, parameters):
    """
    Implement the forward propagation of the recurrent neural network using an LSTM-cell described in Figure (3).

    Arguments:
    x -- Input data for every time-step, of shape (n_x, m, T_x).
    a0 -- Initial hidden state, of shape (n_a, m)
    parameters -- python dictionary containing:
                        Wf -- Weight matrix of the forget gate, numpy array of shape (n_a, n_a + n_x)
                        bf -- Bias of the forget gate, numpy array of shape (n_a, 1)
                        Wi -- Weight matrix of the save gate, numpy array of shape (n_a, n_a + n_x)
                        bi -- Bias of the save gate, numpy array of shape (n_a, 1)
                        Wc -- Weight matrix of the first "tanh", numpy array of shape (n_a, n_a + n_x)
                        bc -- Bias of the first "tanh", numpy array of shape (n_a, 1)
                        Wo -- Weight matrix of the focus gate, numpy array of shape (n_a, n_a + n_x)
                        bo -- Bias of the focus gate, numpy array of shape (n_a, 1)
                        Wy -- Weight matrix relating the hidden-state to the output, numpy array of shape (n_y, n_a)
                        by -- Bias relating the hidden-state to the output, numpy array of shape (n_y, 1)
                        
    Returns:
    a -- Hidden states for every time-step, numpy array of shape (n_a, m, T_x)
    y -- Predictions for every time-step, numpy array of shape (n_y, m, T_x)
    caches -- tuple of values needed for the backward pass, contains (list of all the caches, x)
    """

    # Initialize "caches", which will track the list of all the caches
    caches = []
    
    ### START CODE HERE ###
    # Retrieve dimensions from shapes of xt and Wy (≈2 lines)
    n_x, m, T_x = x.shape
    n_y, n_a = parameters['Wy'].shape
    
    # initialize "a", "c" and "y" with zeros (≈3 lines)
    a = np.zeros((n_a, m, T_x))
    c = np.zeros((n_a, m, T_x))
    y = np.zeros((n_y, m, T_x))
    
    # Initialize a_next and c_next (≈2 lines)
    a_next = a0
    c_next = np.zeros((n_a, m))
    
    # loop over all time-steps
    for t in range(T_x):
        # Update next hidden state, next memory state, compute the prediction, get the cache (≈1 line)
        a_next, c_next, yt, cache = lstm_cell_forward(x[:, :, t], a_next, c_next, parameters)
        # Save the value of the new "next" hidden state in a (≈1 line)
        a[:,:,t] = a_next
        # Save the value of the prediction in y (≈1 line)
        y[:,:,t] = yt
        # Save the value of the next cell state (≈1 line)
        c[:,:,t]  = c_next
        # Append the cache into caches (≈1 line)
        caches.append(cache)
        
    ### END CODE HERE ###
    
    # store values needed for backward propagation in cache
    caches = (caches, x)

    return a, y, c, caches

np.random.seed(1)
x = np.random.randn(3,10,7)
a0 = np.random.randn(5,10)
Wf = np.random.randn(5, 5+3)
bf = np.random.randn(5,1)
Wi = np.random.randn(5, 5+3)
bi = np.random.randn(5,1)
Wo = np.random.randn(5, 5+3)
bo = np.random.randn(5,1)
Wc = np.random.randn(5, 5+3)
bc = np.random.randn(5,1)
Wy = np.random.randn(2,5)
by = np.random.randn(2,1)

parameters = {"Wf": Wf, "Wi": Wi, "Wo": Wo, "Wc": Wc, "Wy": Wy, "bf": bf, "bi": bi, "bo": bo, "bc": bc, "by": by}

a, y, c, caches = lstm_forward(x, a0, parameters)
print("a[4][3][6] = ", a[4][3][6])
print("a.shape = ", a.shape)
print("y[1][4][3] =", y[1][4][3])
print("y.shape = ", y.shape)
print("caches[1][1[1]] =", caches[1][1][1])
print("c[1][2][1]", c[1][2][1])
print("len(caches) = ", len(caches))
a[4][3][6] =  0.17211776753291672
a.shape =  (5, 10, 7)
y[1][4][3] = 0.9508734618501101
y.shape =  (2, 10, 7)
caches[1][1[1]] = [ 0.82797464  0.23009474  0.76201118 -0.22232814 -0.20075807  0.18656139
  0.41005165]
c[1][2][1] -0.8555449167181981
len(caches) =  2

dabulalala
关注
NNDL 作业10：第六章课后题（LSTM | GRU）
m0_73478739的博客
11-29 668
NNDL 作业10：第六章课后题（LSTM | GRU）
NNDL 作业1：第二章课后习题
Guo_weiqi的博客
09-18 164
NNDL 作业1：第二章课后习题
【23-24 秋学期】NNDL 作业10 BPTT
Notebook
12-04 379
BPTT
NNDL 作业10 BPTT [HBU]
weixin_63010525的博客
12-08 359
习题6-1P 推导RNN反向传播算法BPTT.循环神经网络的参数通过梯度下降方法学习，以随机梯度下降为例，给定一个训练样本(x,y),其中:长度为T的输入序列为:长度为T的标签序列为:即在每个时刻t，都有一个监督信息，定义时刻t的损失函数为：(其中为第t时刻的输出，L为可微分的损失函数)即。随时间反向传播(BackPropagation Through Time,BPTT)算法的主要思想是通过类似前馈神经网络的错误反向传播算法来计算梯度。
NNDL 作业十 RNN-BPTT
m0_63010299的博客
12-11 816
BPTT一、习题6-1P 推导RNN反向传播算法BPTT.二、习题6-2 推导公式∂zk∂W\frac{\boldsymbol{\partial z}_{\boldsymbol{k}}}{\boldsymbol{\partial W}}∂W∂zk​​和公式∂zk∂b\frac{\boldsymbol{\partial z}_{\boldsymbol{k}}}{\boldsymbol{\partial b}}∂b∂zk​​．三、长程依赖问题四、长程依赖问题的解决方案五、习题6-3 当使用公式ht=ht−1+g
NNDL作业10 手动推导BPTT+numpy和Pytorch代码实现梯度计算
q100112的博客
12-10 280
首先，先记住！画了以下两个图就能理解了，结合老师给的灵感图（给了我很大灵感~）和链式法则，很容易就能理解式子的来源了。三个式子，道理相同：接下来就是推导时间啦：首先说明一下对应的是里面的第i个，里面的第j个。
生成式人工智能在新加坡的发展现状和地位
wukangjupingbb的博客
09-11 637
依据国际隐私专业人员协会(IAPP)的相关报告，2020年，上述两机构更新了该模型框架，发布了第二版，并推出了《组织实施和自我评估指南》，帮助组织评估其人工智能治理实践与型框架的匹配程度，还发布了《案例汇编》，展示了组织如何实施负责任的人工智能治理实践。2019年，金融管理局宣布与金融行业合作创建Veritas框架，为金融机构提供可验证的方法，将FEAT原则纳入其人工智能和数据分析驱动的解决方案中。新加坡在人工智能治理方面采取了部门性的方法，即通过各个行业的监管机构来管理人工智能的使用。
【提效工具】AI工作流的1-10个实际落地场景
万物皆有灵
09-09 1133
在这个快速发展的数字时代，人工智能（AI）正在以惊人的速度改变我们的工作方式。无论你是开发者、教育工作者还是内容创作者，AI工作流提示词助手都能为你提供无与伦比的支持。今天，我们将深入探讨，20个实际落地场景，帮助你更好地理解如何利用这些工具提升工作效率和创造力。💡。
基于人工智能的音乐情感分类系统
stm32d1219的博客
09-06 1326
音乐作为一种强烈的情感表达方式，不同的音调、节奏和和声传递着不同的情感信息。通过人工智能技术，能够自动识别音乐中的情感，为用户提供个性化的音乐推荐或情感分析服务。通过使用MFCC特征提取与神经网络分类算法，音乐情感分类系统可以有效地分析音乐中的情感信息，并根据不同情感对音乐进行分类。随着深度学习技术的进一步发展，音乐情感分类系统的准确性和应用范围将得到进一步提升。音乐情感分类是通过对音乐音频信号进行分析，识别出音乐传递的情感，如“愉快”、“悲伤”、“愤怒”等。问题讨论，人工智能的资料领取可以私信！
第九届“创客中国”生成式人工智能（AIGC）中小企业创新创业大赛圆满落幕
luojiezong的博客
09-09 825
江西省工业和信息化厅党组成员、副厅长郭启东表示,“创客中国”始终秉持“围绕产业链,部署创新链,配置资金链,培育人才链”的宗旨,为中小企业和创客搭建了广阔平台。江西深刻认识到以人工智能为代表的产业变革的发展方向,努力推动人工智能等先进产业加速发展,以本次大赛为契机,优化创新生态,强化政策引导,加强人才培养,深化国际合作,加大对中小企业创新发展的支持力度,营造更加开放包容的创新环境,推动中小企业创新发展。南昌市委常委、市委秘书长、办公室主任赵捷;经过初赛、复赛的严格筛选,21个杰出项目脱颖而出,荣获赛事奖项。
图神经网络（2）预备知识
m0_63860007的博客
09-07 1091
对于接触过数据结构和算法的读者来说，图并不是一个陌生的概念。如果图里的边不仅表示连接关系，而且具有表示连接强弱的权重，则这个。从图的某个顶点出发，沿着图中的边访问每个顶点且只访问一次，这叫作。在图上模拟一个热扩散的过程，φ(t)是图上每个顶点的热量分布，热量传播。如果一个图的每个边都有一个方向，则称这个图为有向图。图的同构指的是两个图完全等价。很显然，这个大于等于0的，所以L是半正定的。拉普拉斯矩阵的另一个重要作用是作为图上的离散拉普拉斯算子。然地，我们把拉普拉斯算子的特征函数换成拉普拉斯矩阵的特征。
深度学习算法，该如何深入，举例说明
liyy614的博客
09-10 924
深度学习算法的深入学习可以从理论和实践两个方面进行。理论上，深入理解深度学习需要掌握数学基础（如线性代数、概率论、微积分）、机器学习基础和深度学习框架原理。实践上，可以通过实现和优化深度学习模型来提升技能。
高效率的开发工具
最新发布
鱼遇海
09-12 499
智能代码编辑:语法高亮: 支持多种编程语言的语法高亮。代码补全: 提供智能代码补全和提示，减少打字量。代码片段: 支持代码片段和模板，帮助快速编写常用代码。调试功能:集成调试器: 支持多种语言的调试，提供断点、变量监视、调用堆栈等功能。调试配置: 允许用户自定义调试配置，以适应不同的开发需求。版本控制:Git 集成: 内置 Git 支持，可以直接从编辑器进行版本控制操作，如提交、推送、拉取等。版本差异查看: 提供图形化界面查看文件差异和版本历史。
【AIGC】对AI编程常用的工具提供简要介绍和应用场景
weixin_51306394的博客
09-08 1630
I编程工具的选择和使用对于构建高效的机器学习和深度学习系统至关重要。这些工具涵盖了从数据处理、模型训练、模型优化到模型部署的各个环节。下面是一个全面的AI编程工具合集，按功能分类列出了一些常用的工具，并提供了简要介绍和应用场景。
【IT】软件行业发展的前瞻性和希望的广度
weixin_56334307的博客
09-07 1188
这些观点其实非常具有前瞻性和深度，尤其是在自动驾驶技术的安全性考量上，以及程序在医学、国防、教育等领域的潜在应用。作为一个程序员，我完全同意这些领域有着巨大的发展空间和重要的社会价值。下面我将针对您提到的每个领域，简要探讨一些可能的实现方式和技术趋势。总之，随着技术的不断进步，程序在医学、国防、教育等领域的应用前景越来越广阔。作为程序员，我们应当积极投身于这些领域的研究和开发，为社会的进步和发展贡献自己的力量。
sheng的学习笔记-AI-规则学习（rule learning）
coldstarry的专栏
09-09 1092
机器学习中的“规则”(rule)通常是指语义明确、能描述数据分布所隐含的客观规律或领域概念、可写成“若……，则……”形式的逻辑规则。​“规则学习”(rule learning)是从训练数据中学习出一组能用于对未见示例进行判别的规则。一条规则形如：在数理逻辑中“文字”专指原子公式(atom)及其否定。与神经网络、支持向量机这样的“黑箱模型”相比，规则学习具有更好的可解释性，能使用户更直观地对判别过程有所了解。另一方面，数理逻辑具有极强的表达能力，绝大多数人类知识都能通过数理逻辑进行简洁的刻画和表达。
NVDLA专题13：NVDLA软件部分设计和Compiler library
fangfanglovezhou的博客
09-10 450
NVDLA软件部分设计和Compiler library介绍。
使用 BentoML快速实现Llama-3推理服务
CSDNDN的博客
09-08 1157
本教程手把手的演示了一遍怎么快速的使用一个开源大模型进行推理，通过使用BentoML这一强大的工具。BentoML不仅简化了模型部署过程，还提供了便捷的API接口，使得开发者能够轻松地将大模型集成到各种应用场景中。这种快速部署和使用的方法，为大模型的广泛应用铺平了道路，让更多人能够享受到人工智能带来的便利。然而，尽管BentoML大大简化了大模型的部署和使用流程，我们仍需要注意一些关键点。首先，选择合适的硬件资源至关重要，这直接影响到模型的运行效率和响应速度。
深度学习入门：神经网络与Michael Nielsen的NNDL中文版详解
"《神经网络与深度学习》(Neural Networks and Deep Learning) 是Michael Nielsen的一部经典著作，中文版由Xiaohu Zhu和Freeman Zhang翻译，于2016年8月8日发布。该书专注于深度学习的基础理论，尤其强调了神经网络...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值