用纯Python实现循环神经网络RNN向前传播过程(吴恩达DeepLearning.ai作业)

​import numpy as np
​
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)
    """
    # 取计算的参数
    Wax = parameters["Wax"]
    Waa = parameters["Waa"]
    Wya = parameters["Wya"]
    ba = parameters["ba"]
    by = parameters["by"]
​
    # 用公式计算下一个单元的激活值
    a_next = np.tanh(np.dot(Waa, a_prev) + np.dot(Wax, xt) + ba)
    # 计算当前cell的输出 
    yt_pred = softmax(np.dot(Wya, a_next) + by)
    
    # 用于向后传播的缓存值 
    cache = (a_next, a_prev, xt, parameters)
​
    return a_next, yt_pred, cache

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)
    """
​
    # 用于存储所有cache的列表，初始化它
    caches = []
​
    # 取一些纬度值，用于后面初始化变量 
    n_x, m, T_x = x.shape
    n_y, n_a = parameters["Wya"].shape
​
​
    # 初始化 a 和 y_pred 
    a = np.zeros((n_a, m, T_x))
    y_pred = np.zeros((n_y, m, T_x))
​
    # 初始化 a_next 
    a_next = a0
​
    # loop over all time-steps of the input 'x' 
    for t in range(T_x):
        # Update next hidden state, compute the prediction, get the cache 
        xt = x[:,:,t] # 通过切片的方式从输入变量x中取出当前t时间步的输入xt
        a_next, yt_pred, cache = rnn_cell_forward(xt, a_next, parameters)
        # 保存当前单元计算的a_next值
​
        a[:,:,t] = a_next
        # 保存当前单元的预测值y
​
        y_pred[:,:,t] = yt_pred
        # 添加每个单元的缓存值
        caches.append(cache)
​
​
    # store values needed for backward propagation in cache
    caches = (caches, x)
​
    return a, y_pred, caches