Resumen de la primera semana del segundo curso de aprendizaje profundo de Andrew Ng

Vayamos primero a la tabla de contenido:
En
la tabla de contenido, podemos ver que dos problemas se resolvieron principalmente en la primera semana: sobreajuste y prevención de la desaparición/explosión del gradiente. Ahora analicemos e implementemos el código por separado.

1. Desaparición/explosión de gradientes y soluciones.

Al entrenar una red neuronal, a veces la derivada o pendiente (dW, db) se vuelve particularmente grande o pequeña, que es lo que llamamos explosión de gradiente o desaparición de gradiente. Como resultado, el algoritmo de descenso de gradiente tarda más o incluso no se entrena. Para evitar esta situación, se puede utilizar el método de inicialización de peso para que W no sea ni mucho mayor que 1 ni mucho menor que 1.

En cursos anteriores, generalmente usamos el método np.random.randn () para inicializar la matriz de peso W, que toma muestras de la distribución normal estándar unitaria con una media de 0, pero con un cierto valor en la red neuronal como entrada de capa. aumenta, la varianza en la distribución de los datos de salida también aumentará, por lo que existe un método de inicialización de peso mejorado, es decir, al escalar el vector de peso de acuerdo con la raíz cuadrada de la entrada, cada neurona La varianza de salida se normaliza de 1 a asegúrese de que todas las neuronas de la red se distribuyan inicialmente aproximadamente de la misma manera y mejore empíricamente la velocidad de convergencia.

Si la función de activación es una función tanh, la fórmula es:, esto se llama inicialización de Xavier;

Si la función de activación es una función relu, la fórmula es:, esto se llama inicialización de Xavier,

def init_parameters(layer_dims,initialization):
    np.random.seed(3)
    parameters = {}
    if initialization=='zeros':
        for i in range(1,len(layer_dims)):
            parameters['W'+str(i)] = np.zeros((layer_dims[i],layer_dims[i-1]))
            parameters['b'+str(i)] = np.zeros((layer_dims[i],1))
    elif initialization=='random':
        for i in range(1,len(layer_dims)):
            parameters['W'+str(i)] = np.random.randn(layer_dims[i],layer_dims[i-1])
            parameters['b'+str(i)] = np.zeros((layer_dims[i],1))
    elif initialization=='he':  #这是由He等人在所写的Delving Deep into Rectifiers: Surpassing Human-Level Performance on ImageNet Classification论文中得到的结论
        for i in range(1,len(layer_dims)):
            parameters['W'+str(i)] = np.random.randn(layer_dims[i],layer_dims[i-1]) * np.sqrt(2/layer_dims[i-1])
            parameters['b'+str(i)] = np.zeros((layer_dims[i],1))
    else:
        print("错误的初始化参数！程序退出")
        exit()
            
    assert(parameters['W'+str(i)].shape == (layer_dims[i],layer_dims[i-1]))
    assert(parameters['b'+str(i)].shape == (layer_dims[i],1))
    
    return parameters

1.layer_dims = [tren_X.shape[0],10,10,1]，tasa_de aprendizaje=0.5

• inicialización = 'ceros'

Figura 1 curva de cambio de valor de costo

Figura 2 Resultados del entrenamiento

• inicialización = 'aleatorio'

Figura 1 curva de cambio de costos

Figura 2 Resultados del entrenamiento

• inicialización = 'él'

Figura 1 curva de cambio de costos

Figura 2 Resultados del entrenamiento

2.layer_dims = [train_X.shape[0],100,100,1]，learning_rate=0.5

• inicialización = 'ceros'

Figura 1 curva de cambio de valor de costo

Figura 2 Resultados del entrenamiento

• inicialización = 'aleatorio'

Figura 1 curva de cambio de costos

Figura 2 Resultados del entrenamiento

• inicialización = 'él'

Figura 1 curva de cambio de costos

Figura 2 Resultados del entrenamiento

Se puede ver que el término de corrección de si se multiplica np.sqrt(2/layer_dims[n]) afecta principalmente el valor del costo inicial. Cuando el número de neuronas en cada capa de la red es pequeño, si se multiplica este término tendrá El efecto final tiene un mayor impacto. El impacto es pequeño. A medida que aumenta el número de neuronas, el valor del costo inicial sin términos de corrección aumenta gradualmente y la asimetría de los resultados del entrenamiento se vuelve cada vez más obvia. Sin embargo, a medida que el número de neuronas a medida que aumentan los términos de corrección, el entrenamiento final Los resultados no se verán particularmente afectados.

2. Método de regularización

Lo primero que hay que entender aquí es el concepto de sesgo y variación en el aprendizaje automático. Según la explicación del Sr. Ng Enda, la desviación es el tamaño del error del conjunto de entrenamiento y la varianza es la comparación del tamaño del error del conjunto de entrenamiento y el conjunto de prueba. La figura muestra el mismo conjunto de entrenamiento:

" Para la imagen de la izquierda, el conjunto de datos no está bien ajustado. Dado que el efecto de ajuste del conjunto de entrenamiento es tan pobre, es concebible que la precisión del conjunto de prueba no sea mucho mayor. A esto se le llama desviación alta. Esto se llama "desajuste". En la imagen de la derecha, puede ver que el conjunto de entrenamiento está básicamente 100% ajustado y la precisión es muy alta. Sin embargo, la adaptabilidad de este resultado de entrenamiento es muy pobre, por lo que el ajuste El efecto del conjunto de prueba es el mismo que el del conjunto de prueba. El conjunto de entrenamiento será muy diferente, lo cual es una alta varianza. Es decir, la precisión del conjunto de entrenamiento es muy alta, pero el conjunto de prueba es relativamente baja. Esto Esta situación se llama "sobreajuste". El del medio es "ajuste moderado" y la precisión del conjunto de entrenamiento y del conjunto de prueba es casi la misma.

en conclusión:

La precisión del conjunto de entrenamiento es baja - desviación alta.
Evalúe el rendimiento del conjunto de entrenamiento. Si la desviación es demasiado alta, es posible que deba intentar reemplazarlo con una nueva red.

La precisión del conjunto de entrenamiento es muy alta, pero la precisión del conjunto de prueba es baja:
la primera es expandir su propio conjunto de datos y la segunda es la regularización.

La la la, ¡vamos a nuestro punto! ¿Cómo solucionar el problema del sobreajuste mediante la regularización? Tomemos como ejemplo la regresión logística.

1.regularización L1/L2

La regularización consiste en agregar un término de regularización a la función de costo J. Hay dos de uso común: regularización L1 y regularización L2.

• Regularización L1
  

  en:
  

• Regularización de L2
  
  Entre ellos:
  
  Con respecto a la elección de L1 y L2, aquí hay una cita del profesor Ng Enda:

Si se usa la regularización L1, W eventualmente será escaso, lo que significa que hay muchos 0 en el vector W. Algunas personas dicen que esto es beneficioso para comprimir el modelo, porque los parámetros en el conjunto son todos 0 y el modelo de almacenamiento toma ocupar menos memoria. De hecho, aunque la regularización L1 hace que el modelo sea escaso, no reduce mucho la memoria de almacenamiento, por lo que creo que este no es el propósito de la regularización L1, al menos no comprimir el modelo. La gente se inclina cada vez más a hacer esto cuando entrena redes. Utilice la regularización L2.

Agregue términos de regularización a la función de costo de la red neuronal:

Porque W es ${norte}^{\left[l\right]}\times {norte}^{}$Matriz de${}^{[}$${}^l$${}^{-}$${}^1$${}^{]}$${norte}^{\left[l\right]}$ representael número de neuronas en la capal${norte}^{[l-1]}$ representael número de neuronas en la capal-1

${\sum }_{yo=1}^{}{\Vert {W.}^{\left[l\right]}\Vert }_F^{}={\sum }_{yo=1}^{{norte}^{[l}}{\sum }_{j=1}^{{norte}^{[l-1}}(w_{yoj}^{[l}{)}^2$

Es decir, representa la suma de todos los elementos de una matriz. Cuando se utiliza esta norma para implementar el descenso de gradiente, según los resultados originales, se debe agregar un término regular para obtener la derivada parcial de w, es decir

$re{W}^{\left[l\right]}=\frac{\partial L}{\partial W{\_}^{\left[l\right]}}+\frac{}{metro}{W.}^{\left[l\right]}$

Actualización de peso:

${W.}^{\left[l\right]}={W.}^{\left[l\right]}-\alpha d{W}^{\left[l\right]}={W.}^{\left[l\right]}-un(\frac{\partial L}{\partial W{\_}^{\left[l\right]}}+\frac{}{metro}{W.}^{\left[l\right]})=(1-\frac{un}{metro})W^{\left[l\right]}-\alpha d{W}^{\left[l\right]}$

Como se puede ver en la fórmula anterior, la regularización intenta hacer que ${W.}^{\left[l\right]}$ se multiplica por un coeficiente de peso menor que 1, lo que lo hace más pequeño, por lo que la regularización L2 también se denomina "disminución de peso". Para conocer las razones específicas por las que la regularización es beneficiosa para prevenir el sobreajuste, consulte la Sección 1.5 de la primera semana del segundo curso (enlace de referencia: http://www.ai-start.com/dl2017/html/lesson2-week1.html# encabezado -n89).

Echemos un vistazo a cómo implementarlo usando código y cuál es el efecto.
Tomemos la segunda clasificación como ejemplo: para que el efecto sea más obvio, la cambiamos a otro conjunto de datos (enlace de referencia: https://blog.csdn.net/weixin_42604446/article/details/81369224)

Figura 1 Conjunto de entrenamiento

Figura 2 Conjunto de prueba

Código de referencia:

def datagen(m,lambd,is_plot):   
    np.random.seed(1)
    N = int(m/2)                            #分为两类
    D = 2                                   #样本的特征数或维度
    X = np.zeros((m,D))                     #初始化样本坐标
    Y = np.zeros((m,1))                     #初始化样本标签
    for j in range(2):
        ix = range(N*j,N*(j+1))
        t = np.random.randn(N)*lambd                          
        r = np.random.randn(N)*lambd
        if j==0:
            X[ix] = np.c_[t-0.4, r-0.4]
        else:
            X[ix] = np.c_[t+0.4, r+0.4]      
        Y[ix] = j #red or blue
    if is_plot:
        fig = plt.figure()
        plt.rcParams['figure.figsize']=(7.0,4.0)
        plt.rcParams['image.interpolation']='nearset'
        plt.rcParams['image.cmap']='gray'
        plt.title('training dataset')
        plt.scatter(X[:, 0], X[:, 1], c=np.squeeze(Y), s=40, cmap=plt.cm.Spectral)
        plt.show()
    return X.T,Y.T

Código actualizado después de agregar la regularización:

• Calcular costo

def compute_cost_with_regulation(A,Y,parameters,lambd):
    m = Y.shape[1]
    sum = 0.
    cross_entropy_cost = compute_cost(A[len(A)-1],Y)
    for i in range(len(A)):
        sum += np.sum(np.square(parameters["W"+str(i+1)]))
    L2_regularization_cost = lambd * sum / (2 * m)
    cost = cross_entropy_cost + L2_regularization_cost
    
    return cost

• Propagación hacia atrás

def backward_propagation_with_regulation(X,Y,Z,A,W,lambd,derivate_function):
    l = len(W)
    dZ = list(range(l))
    dA = list(range(l))
    dW = list(range(l))
    db = list(range(l))
    m = Y.shape[1]
    grads = {}
    
    dZ[l-1] = A[l-1] - Y
    for i in range(l-1,-1,-1):
        if i>0:
            dW[i] = (1/m)*np.dot(dZ[i],A[i-1].T) + ((lambd * W[i] / m))
        else:
            dW[i] = (1/m)*np.dot(dZ[i],X.T) + ((lambd * W[i] / m))
        db[i] = (1/m)*np.sum(dZ[i],axis=1,keepdims=True)
        dA[i-1] = np.dot(W[i].T,dZ[i])
        dZ[i-1] = np.multiply(dA[i-1],np.int64(A[i-1]>0))
    for i in range(len(dW)):
        grads["dW"+str(i+1)] = dW[i]
        grads["db"+str(i+1)] = db[i]
        
    return grads  

Echemos un vistazo a los resultados experimentales:

• No se agregó regularización

Figura 1 Resultados de la clasificación del conjunto de entrenamiento

Figura 2 Resultados de clasificación del conjunto de pruebas

• Agregar regularización, $yo=0.5$

Se puede ver que cuando no se agrega regularización, se produce un fenómeno de sobreajuste obvio y la varianza es relativamente grande. Después de agregar la regularización, el problema de sobreajuste se resuelve. Aunque la precisión del conjunto de entrenamiento disminuye, la precisión del conjunto de entrenamiento y el conjunto de prueba La tasa es cercana, lo que es un ajuste moderado.

Figura 1 Resultados de la clasificación del conjunto de entrenamiento

Figura 2 Resultados de clasificación del conjunto de pruebas

2. El principio de la regularización de abandono
es establecer la probabilidad de eliminar nodos en cada capa de la red neuronal, luego el abandono atravesará cada capa de la red y retendrá y eliminará aleatoriamente los nodos correspondientes con la probabilidad establecida, y finalmente obtendrá un nodo. con menos nodos. , redes más pequeñas. Debido a que cada nodo tiene la misma posibilidad de ser eliminado, evita que la red neuronal dependa de ciertos nodos específicos, lo que reduce la variación, comprime los pesos y evita el sobreajuste.

El método más utilizado para implementar el abandono es el abandono invertido (desactivación aleatoria inversa). Este método requiere establecer la probabilidad de desactivación para cada capa de la red, representada por keep-prob. Por ejemplo, keep-prob = 0,8, luego elimine cualquier oculta unidad La probabilidad es 0,2. Tome una red de tres capas como ejemplo:
primero defina un vector d. Si la deserción se implementa en la tercera capa de la red, entonces:
$re3=nortep.\_aleatorio.\_\_\_\_\_rynd(A{}^{\left[3\right]}.forma[0],\_\_\_\_A^{\left[3\right]}.forma[1\left]\right)\_\_\_\_<mantener\_\_\_-prob$
$A^{\left[3\right]}=nortep.\_multiply(A{}^{\left[3\right]},d3)/mantenerp\_\_-probEl$
d3 obtenido por la fórmula en la primera línea es una matriz booleana y el valor es Verdadero o Falso. <keep-prob significa que si es menor que keep-prob, se establece en Verdadero, y si es mayor que keep-prob, se establece en False. La segunda línea La fórmula es eliminar los nodos correspondientes, y dividir por keep-prob es compensar la parte eliminada, de modo que A [ 3 ] A^{$A^{El\; valor\; esperado\; de\; [3]}$ permanece sin cambios.

Echemos un vistazo a cómo implementarlo con código y los resultados experimentales (aún tomando como ejemplo el conjunto de entrenamiento en la regularización L2):

El abandono no se implementa para la última capa y los códigos para la propagación hacia adelante y hacia atrás son los siguientes:

• propagación hacia adelante

def forward_propagation_with_dropout(X,parameters,activate_fun,keep_prob):
    #retrieve parameters
    W = []
    b = []
    for i in range(1,len(parameters)//2+1):
        W.append(parameters["W"+str(i)])
        b.append(parameters["b"+str(i)])
    #compute forward_propagation
    Z = []
    A = []
    D = []
    for i in range(len(W)):
        if i==0:
            sZ = np.dot(W[i],X)+b[i]
        else:
            sZ = np.dot(W[i],A[i-1])+b[i]
        sA = activate_fun[i](sZ)
        if i<(len(W)-1):
            sD = np.random.rand(sA.shape[0],sA.shape[1]) < keep_prob
            sA = np.multiply(sA,sD) / keep_prob
        Z.append(sZ)
        A.append(sA)
        D.append(sD)
    return Z,A,W,D

• Propagación hacia atrás

def backward_propagation_with_dropout(X,Y,Z,A,W,D,keep_prob):
    l = len(W)
    dZ = list(range(l))
    dA = list(range(l-1))
    dW = list(range(l))
    db = list(range(l))
    m = Y.shape[1]
    grads = {}
    
    dZ[l-1] = A[l-1] - Y

    for i in range(l-1,0,-1):
        if i>0:
            dW[i] = (1/m)*np.dot(dZ[i],A[i-1].T)
        else:
            dW[i] = (1/m)*np.dot(dZ[i],X.T)
        db[i] = (1/m)*np.sum(dZ[i],axis=1,keepdims=True)
        dA[i-1] = np.dot(W[i].T,dZ[i])*D[i-1]/keep_prob
        dZ[i-1] = np.multiply(dA[i-1],np.int64(A[i-1]>0))
    for i in range(len(dW)):
        grads["dW"+str(i+1)] = dW[i]
        grads["db"+str(i+1)] = db[i]
        
    return grads

Resultados del entrenamiento:

• No implementar el abandono, es decir, keep_prob=1

Figura 1 Resultados de la clasificación del conjunto de entrenamiento

Figura 2 Resultados de clasificación del conjunto de pruebas

• Implementar abandono, keep_prob=0.6

Figura 1 Resultados de la clasificación del conjunto de entrenamiento

Figura 2 Resultados de clasificación del conjunto de pruebas

Como se puede ver en la figura anterior, si no se implementa la regularización de la deserción, se producirá el problema de sobreajuste, pero una vez implementada la deserción, el sobreajuste básicamente se elimina.

¡Finalizar! ! !
Descarga de recursos relacionados: https://download.csdn.net/download/weixin_42149550/11666926
******************************* ************************** Esta es la línea divisoria ******************* * *************************************************
Adjunto:

1. Se corrigió la sección de propagación hacia atrás de la tarea de la tercera semana del primer curso.

def backward_propagation_with_regulation(X,Y,Z,A,W,lambd):
    l = len(W)
    dZ = list(range(l))
    dA = list(range(l-1)) #更正前为dA = list(range(l))，实际需要记录的dA不需要包括最后一层，因为代码直接算出了最后一层的dZ
    dW = list(range(l))
    db = list(range(l))
    m = Y.shape[1]
    grads = {}
    
    dZ[l-1] = A[l-1] - Y

    for i in range(l-1,0,-1):  #更正前为 range(l-1,-1,-1)，后面计算的dA，dZ的索引值包括i-1，如果为-1，最后dA的索引就有负数了，显然不行
        if i>0:
            dW[i] = (1/m)*np.dot(dZ[i],A[i-1].T) + ((lambd * W[i] / m))
        else:
            dW[i] = (1/m)*np.dot(dZ[i],X.T) + ((lambd * W[i] / m))
        db[i] = (1/m)*np.sum(dZ[i],axis=1,keepdims=True)
        dA[i-1] = np.dot(W[i].T,dZ[i])
        dZ[i-1] = np.multiply(dA[i-1],np.int64(A[i-1]>0))
    for i in range(len(dW)):
        grads["dW"+str(i+1)] = dW[i]
        grads["db"+str(i+1)] = db[i]
        
    return grads

2. ¿Cómo centrar varias imágenes una al lado de la otra en el editor Markdown?

<table>
    <tr>
        <td ><center><img src="https://img-blog.csdnimg.cn/20190904211338386.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjE0OTU1MA==,size_16,color_FFFFFF,t_70" width=480 >图1   训练集分类结果</center></td>
        <td ><center><img src="https://img-blog.csdnimg.cn/2019090421135561.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjE0OTU1MA==,size_16,color_FFFFFF,t_70" width=480 >图2 测试集分类结果</center></td>
    </tr>