Para lograr el ciclo de la red neuronal proceso de propagación hacia adelante RNN con Python puro (trabajo Andrew Ng DeepLearning.ai)

Google TensorFlow pulgares programador artículo!

 

prefacio

contenido:

    - representación vectorial y sus dimensiones

    - RNN celular

    - RNN propagación hacia adelante

 

Centrará en:

    - la forma de cuantificar, su dimensión es cómo los datos a

    - de hecho un total de dos pasos: cálculo RNN sola unidad, para tirar a través de la RNN computación

​

Antes de ver este artículo, se puede leer el retiro de este artículo:

Andrew Ng deepLearning.ai Son recurrentes red neuronal notas de estudio RNN (parte teórica)

 

Vamos a lograr RNN siguiente estructura, en este caso Tx = Ty.

 

representación vectorial y sus dimensiones

De entrada con el número de unidades nx

• Una muestra de entrada única, x (i) es un vector de entrada unidimensional.

• Idioma por ejemplo, tener 5k lenguaje palabra del vocabulario con codificada uno en caliente con un vector 5k unidades, de modo que x (i) es la dimensión (5000).

• Vamos a indicar el número de participaciones de un único muestras de entrenamiento con el símbolo nx.

Los lotes de tamaño  m

• Si tomamos pequeñas cantidades (mini-lotes), hay 20 entrenamiento cada lote de muestras.

• Con el fin de beneficiarse de vectorización, vamos a 20 muestras x (i) en una matriz de 2 dimensiones (matriz).

• una dimensión de este tipo es (5000,20) vector.

• Utilizamos m para representar el número de muestras de entrenamiento.

• Por lo que las dimensiones de las pequeñas cantidades de datos de entrenamiento es (nx, m).

Tiempo pasos de tamaño  Tx

• la red neuronal recurrente tiene más pasos de tiempo, usamos t representar.

• Veremos la muestra de entrenamiento x (i) experimentarán tiempo múltiples pasos Tx, por ejemplo, si hay 10 pasos de tiempo, entonces Tx = 10.

3D Tensor de forma  (nx, m, Tx)

• se utiliza Dimensión de entrada x es de (nx, m, Tx) para representar un tensor tridimensional.

Tomando una rebanada 2D para cada paso de tiempo:  

• Cada paso de tiempo, utilizamos pequeñas cantidades de datos de entrenamiento (muestra de entrenamiento no individual).

• Por lo tanto, para cada paso de tiempo t, utilizamos la dimensión es de (nx, m) de la rebanada de 2 dimensiones.

• Lo representamos como xt.

Una dimensión oculta

• una definición: un tiempo de paso a paso el valor de activación en otro momento, lo llamamos oculto.

• Tensor x con la entrada como para ocultar el estado de las muestras individuales de formación, es la longitud del vector na.

• Si incluimos pequeñas cantidades de datos m de muestras de entrenamiento, a continuación, las dimensiones son pequeñas cantidades (na, m).

• Si tomamos el tiempo de paso añadido a la lista, a continuación, la dimensión oculta es (na, m, Tx).

• Vamos a utilizar el índice para Traverse paso de tiempo t, para cada operación es una rebanada de un tensor tridimensional en un vector de dos dimensiones.

• Estamos representados en las rebanadas bidimensionales, y sus dimensiones son (na, m).

valor de predicción y ^ dimensión

• Y escondida con la entrada x como, y ^ es una dimensión es (ny, m, Ty) del tensor tridimensional.

• Nueva York: número de unidades en nombre del valor predicho.

• m: el número de muestras en los pequeños lotes de formación.

• Ty: Número de la predicción del tiempo.

• Por ejemplo, un solo paso de tiempo t, una rebanada bidimensional de la dimensión y ^ es (ny, m).

 

RNN celular

 

Nuestra primera tarea es llevar a cabo un solo paso momento del cálculo, se calcula como se muestra a continuación.

De entrada es a ^ <t-1>, xt, se emite en, yt ^. El código siguiente es en realidad la codificación de la fórmula anterior, el paso total de 4 pasos:

1. Retire parámetros.

2. Calculado al.

3. Computar yt ^.

4. salida de vuelta en, yt ^, sino también para almacenar algunos valores almacenados en caché.

numpy importación como np 
def rnn_cell_forward (xt, a_prev, parámetros): 
    """ 
    implementa un solo paso adelante de la célula RNN como se describe en la figura (2) 
    Argumentos: 
    xt - los datos de entrada en timestep 't' , array numpy de forma (n_x, m). 
    a_prev - estado oculto en timestep "t-1", array numpy de forma (N_A, m) 
    parámetros - Diccionario pitón que contienen: 
                        Wax - matriz de peso multiplicando la entrada, numpy matriz de forma (N_A, n_x) Waa - matriz Peso multiplicando el estado oculto, array numpy de forma (N_A, N_A) 
                        BA - Bias, array numpy de forma (N_A, 1) 
                        Wya - matriz de peso relativa del Estado-oculto a la salida, una matriz numpy de forma (n_y,n / A)
                        por - Bias relacionar el estado oculto a la salida, una matriz numpy de forma (n_y, 1) 
    Devuelve: 
    a_next - siguiente estado oculto, de forma (N_A, m) 
    yt_pred - predicción en timestep "t", array numpy de forma (n_y, m) 
    cache - tupla de valores necesarios para el pase hacia atrás, contiene (a_next, a_prev, xt, parámetros) 
    "" " 
    #取计算的参数
    Cera = parámetros [ "Wax"] 
    Waa = parámetros [" Waa "] 
    Wya = parámetros [" Wya "] 
    ba = parámetros [" BA "] 
    de parámetros = [" por "] 
    #用公式计算下一个单元的激活值
    a_next = np.tanh (np.dot (Waa, a_prev) + np.dot (Wax,XT) + BA) 
    # calcular una corriente de salida de la célula
    = SoftMax yt_pred (np.dot (WYA, a_next) + by) 
    
    # valor almacenado en caché por el que se propaga hacia atrás 
    Cache = (a_next, a_prev, XT, parámetros) 
    a_next retorno, yt_pred, Cache

 

RNN propagación hacia adelante

• Una red neuronal recurrente se repite constantemente unidades RNN que creó anteriormente.

• Si la secuencia de datos de entrada es de 10 pasos de tiempo, entonces usted tiene que repetir su celular RNN 10 veces.

• En cada paso de tiempo, cada uno de la unidad con dos entradas:

• a <t-1>: un estado antes de una unidad oculta.

• xt: entrada de corriente paso de tiempo de datos.

• Tiene dos salidas cada paso de tiempo: 

• Un estado escondido una camiseta

• Un valor de medición de ^ Y ⟨t⟩

• Pesos y sesgo  (Waa, ba, Wax, bx ) ciclo voluntad en cada paso de tiempo, se almacenan en la variable "parámetros".

 

def rnn_forward (x, a0, parámetros): 
    """ 
    Implementar la propagación de avance de la red neuronal recurrente se describe en la figura (3). 
    Argumentos: 
    x - datos de entrada para cada paso de tiempo, de forma (n_x, m, T_x). 
    a0 - estado oculto inicial, de forma (N_A, m) 
    parámetros - Diccionario pitón que contiene: 
                        Waa - matriz Peso multiplicando el estado oculto, array numpy de forma (N_A, N_A) 
                        Wax - matriz Peso multiplicando el de entrada, matriz numpy de forma (N_A, n_x) 
                        Wya - matriz de peso relativa del Estado-oculto a la salida, una matriz numpy de forma (n_y, N_A) 
                        BA - Bias array numpy de forma (N_A, 1) 
                        por - Bias relacionar el estado oculto a la salida, una matriz numpy de forma (n_y, 1) 
    Devuelve: 
    A - Cada vez que los Estados Ocultos-STEP, de configuración de red numpy (N_A, m, T_x) 
    y_pred - Predicciones para cada paso de tiempo, Array numpy forma de (n_y, m, T_x) 
    caches - la tupla de valores necesarios para Pase Hacia Atrás, la contiene (lista de cachés, X) 
    "" " 
    # una lista de toda la memoria caché, lo inicializa 
    cachés = [] 
    # retirar algún valor latitud, inicializar variables para más tarde 
    n_x, m, = T_x x.shape 
    n_y, N_A = Parámetros [ "WYA"]. Forma 
    # inicialización y un y_pred 
    un np.zeros = ((N_A, m, T_x )) 
    y_pred np.zeros = ((n_y, m, T_x)) 
    # initialize a_next 
    a_next = A0
    # Bucle para todos los pasos de tiempo de la entrada 'X' 
    para T en el rango (T_x): 
        # Estado de actualización Siguiente oculta, Calcular la predicción, obtener la caché 
        XT = X [:,:, T] # en forma de rebanado de eliminado variable de entrada de entrada x xt de la hora actual paso t 
        a_next, yt_pred, Cache rnn_cell_forward = (xt, a_next, parámetros) 
        # Guardar la unidad de cálculo del valor actual a_next 
        un [:,:, t] = a_next 
        # Guardar la unidad actual valor de predicción Y 
        y_pred [:,:, T] = yt_pred 
        # Añadir caché por unidad de valor 
        caches.append (cache) 
    # Almacenar los valores hacia atrás necesario para la propagación en caché 
    cachés = (caches, X) 
    volver a, y_pred, cachés

　 

Felicidades (* ^ ▽ ^ *), en las que tienen que ser capaces de construir ciclo de proceso de red neuronal de propagación hacia adelante de 0 a 1.

En el marco del aprendizaje profundo moderna, sólo tiene que pasar antes de la implementación y post-procesamiento para ofrecer el marco, por lo que la mayoría de los ingenieros no necesitan aprender la profundidad de detalle para pasar después de la atención. No escribo posterior difusión.