Estás leyendo la publicación: El algoritmo de descenso de gradiente y sus variantes: hacia la IA
Publicado originalmente en Hacia la IA, la empresa líder mundial en noticias y medios de IA y tecnología. Si está creando un producto o servicio relacionado con la IA, lo invitamos a considerar convertirse en patrocinador de la IA. En Hacia la IA, ayudamos a escalar las empresas emergentes de IA y tecnología. Permítanos ayudarlo a dar rienda suelta a su tecnología a las masas.
Algoritmo de descenso de gradiente con ejemplos de código en Python
Autor(es): Pratik Shukla
“Educar la mente sin educar el corazón no es educación en absoluto”. ― Aristóteles
La serie de blogs Gradient Descent:
- El algoritmo de descenso de gradiente
- Intuición matemática detrás del algoritmo de descenso de gradiente
- El Algoritmo de Descenso de Gradiente y sus Variantes (¡Usted está aquí!)
Tabla de contenido:
- Introducción
- Descenso de gradiente por lotes (BGD)
- Descenso de gradiente estocástico (SGD)
- Descenso de gradiente de mini lotes (MBGD)
- Comparación de gráficos
- Notas finales
- Recursos
- Referencias
Introducción:
Redoble de tambores, por favor: ¡Bienvenidos al final de la serie Gradient Descent! En este blog, profundizaremos en el algoritmo de descenso de gradiente. Discutiremos todos los sabores divertidos del algoritmo de descenso de gradiente junto con sus ejemplos de código en Python. También examinaremos las diferencias entre los algoritmos en función del número de cálculos realizados en cada algoritmo. Hoy no dejaremos piedra sin remover, por lo que le solicitamos que ejecute el archivos a medida que lee el documento; hacerlo le dará una comprensión más precisa del tema para verlo en acción. ¡Entremos en ello!
Descenso de gradiente por lotes:
El algoritmo Batch Gradient Descent (BGD) considera todos los ejemplos de entrenamiento en cada iteración. Si el conjunto de datos contiene una gran cantidad de ejemplos de entrenamiento y una gran cantidad de funciones, implementar el algoritmo de descenso de gradiente por lotes (BGD) se vuelve costoso desde el punto de vista computacional, ¡así que tenga cuidado con su presupuesto! Pongamos un ejemplo para entenderlo mejor.
Descenso de gradiente por lotes (BGD):
Número de ejemplos de entrenamiento por iteraciones = 1 millón = 1⁰⁶
Número de iteraciones = 1000 = 1⁰³
Número de parámetros a entrenar = 10000 = 1⁰⁴
Cálculos totales = 1⁰⁶ * 1⁰³* 1⁰⁴ = 1⁰¹³
Ahora, veamos cómo se implementa el algoritmo Batch Gradient Descent (BGD).
1. Paso — 1:
Primero, estamos descargando el archivo de datos del repositorio de GitHub.
2. Paso — 2:
A continuación, importamos algunas bibliotecas necesarias para leer, manipular y visualizar los datos.
3. Paso — 3:
A continuación, leemos el archivo de datos y luego imprimimos las primeras cinco filas.
4. Paso — 4:
A continuación, estamos dividiendo el conjunto de datos en características y variables objetivo.
Dimensiones: X = (200, 3) & Y = (200, )
5. Paso — 5:
Para realizar cálculos matriciales en pasos posteriores, necesitamos remodelar la variable de destino.
Dimensiones: X = (200, 3) & Y = (200, 1)
6. Paso — 6:
A continuación, estamos normalizando el conjunto de datos.
Dimensiones: X = (200, 3) e Y = (200, 1)
7. Paso — 7:
A continuación, obtenemos los valores iniciales para las matrices de sesgo y pesos. Usaremos estos valores en la primera iteración mientras realizamos la propagación hacia adelante.
Dimensiones: sesgo = (1, 1) y pesos = (1, 3)
8. Paso — 8:
A continuación, realizamos el paso de propagación hacia adelante. Este paso se basa en la siguiente fórmula.
Dimensiones: valor_predicho = (1, 1)+(200, 3)*(3,1) = (1, 1)+(200, 1) = (200, 1)
9. Paso — 9:
A continuación, vamos a calcular el coste asociado a nuestra predicción. Este paso se basa en la siguiente fórmula.
Dimensiones: costo = valor escalar
10. Paso — 10:
A continuación, actualizamos los valores de los parámetros de pesos y sesgos utilizando el algoritmo de descenso de gradiente. Este paso se basa en las siguientes fórmulas. Tenga en cuenta que la razón por la que no estamos sumando los valores de los pesos es que nuestra matriz de pesos no es una matriz de 1*1.
Dimensiones: db = suma (200, 1) = (1, 1)
Dimensiones: dw = (1, 200) * (200, 3) = (1, 3)
Dimensiones: sesgo = (1, 1) y pesos = (1, 3)
11. Paso — 11:
A continuación, vamos a utilizar todas las funciones que acabamos de definir para ejecutar el algoritmo de descenso de gradiente. También estamos creando una lista vacía llamada cost_list para almacenar los valores de costo de todas las iteraciones. Esta lista se utilizará para trazar un gráfico en pasos posteriores.
12. Paso — 12:
A continuación, estamos llamando a la función para obtener los resultados finales. Tenga en cuenta que estamos ejecutando el código completo para 200 iteraciones. Además, aquí hemos especificado la tasa de aprendizaje de 0.01.
13. Paso — 13:
A continuación, estamos trazando el gráfico de iteraciones frente a costo.
14. Paso — 14:
A continuación, estamos imprimiendo los valores de los pesos finales después de que se hayan realizado todas las iteraciones.
15. Paso — 15:
A continuación, imprimimos el valor de sesgo final después de que se hayan realizado todas las iteraciones.
16. Paso — 16:
A continuación, trazamos dos gráficos con diferentes tasas de aprendizaje para ver el efecto de la tasa de aprendizaje en la optimización. En el siguiente gráfico podemos ver que el gráfico con mayor tasa de aprendizaje (0.01) converge más rápido que el gráfico con menor tasa de aprendizaje (0.001). Como aprendimos en la Parte 1 de la serie Gradient Descent, esto se debe a que el gráfico con la tasa de aprendizaje más baja toma pasos más pequeños.
17. Paso — 17:
Pongamos todo junto.
Número de cálculos:
Ahora, contemos el número de cálculos realizados en el algoritmo de descenso de gradiente por lotes.
Inclinación: (ejemplos de entrenamiento) x (iteraciones) x (parámetros) = 200 * 200 * 1 = 40000
Pesos: (ejemplos de entrenamiento) x (iteraciones) x (parámetros) = 200 * 200 *3 = 120000
Descenso de gradiente estocástico
En el algoritmo de descenso de gradiente por lotes, consideramos todos los ejemplos de entrenamiento para todas las iteraciones del algoritmo. Pero, si nuestro conjunto de datos tiene una gran cantidad de ejemplos de entrenamiento y/o características, resulta costoso computacionalmente calcular los valores de los parámetros. Sabemos que nuestro algoritmo de aprendizaje automático producirá más precisión si le proporcionamos más ejemplos de entrenamiento. Pero, a medida que aumenta el tamaño del conjunto de datos, también aumentan los cálculos asociados con él. Tomemos un ejemplo para entender esto de una mejor manera.
Descenso de gradiente por lotes (BGD)
Número de ejemplos de entrenamiento por iteraciones = 1 millón = 1⁰⁶
Número de iteraciones = 1000 = 1⁰³
Número de parámetros a entrenar = 10000 = 1⁰⁴
Cálculos totales = 1⁰⁶*1⁰³*1⁰⁴=1⁰¹³
Ahora bien, si nos fijamos en el número anterior, ¡no nos da excelentes vibraciones! Entonces podemos decir que usar el algoritmo Batch Gradient Descent no parece eficiente. Entonces, para lidiar con este problema, usamos el algoritmo Stochastic Gradient Descent (SGD). La palabra “Estocástico” significa aleatorio. Entonces, en lugar de realizar cálculos en todos los ejemplos de entrenamiento de un conjunto de datos, tomamos un ejemplo aleatorio y realizamos los cálculos en eso. Suena interesante, ¿no? Solo consideramos un ejemplo de entrenamiento por iteración en el algoritmo Stochastic Gradient Descent (SGD). Veamos qué tan efectivo es el Descenso de Gradiente Estocástico basado en sus cálculos.
Descenso de gradiente estocástico (SGD):
Número de ejemplos de entrenamiento por iteraciones = 1
Número de iteraciones = 1000 = 1⁰³
Número de parámetros a entrenar = 10000 = 1⁰⁴
Cálculos totales = 1 * 1⁰³*1⁰⁴=1⁰⁷
Comparación con el descenso de gradiente por lotes:
Cálculos totales en BGD = 1⁰¹³
Cómputos totales en SGD = 1⁰⁷
Evaluación: SGD es ¹⁰⁶ veces más rápido que BGD en este ejemplo.
Nota: Tenga en cuenta que es posible que nuestra función de costo no disminuya necesariamente, ya que solo tomamos un ejemplo de capacitación aleatorio en cada iteración, así que no se preocupe. Sin embargo, la función de costo disminuirá gradualmente a medida que realicemos más y más iteraciones.
Ahora, veamos cómo se implementa el algoritmo Stochastic Gradient Descent (SGD).
1. Paso — 1:
Primero, estamos descargando el archivo de datos del repositorio de GitHub.
2. Paso — 2:
A continuación, estamos importando algunas bibliotecas necesarias para leer, manipular y visualizar los datos.
3. Paso — 3:
A continuación, leemos el archivo de datos y luego imprimimos las primeras cinco filas.
4. Paso — 4:
A continuación, estamos dividiendo el conjunto de datos en características y variables objetivo.
Dimensiones: X = (200, 3) & Y = (200, )
5. Paso — 5:
Para realizar cálculos matriciales en pasos posteriores, necesitamos remodelar la variable de destino.
Dimensiones: X = (200, 3) e Y = (200, 1)
6. Paso — 6:
A continuación, estamos normalizando el conjunto de datos.
Dimensiones: X = (200, 3) e Y = (200, 1)
7. Paso — 7:
A continuación, obtenemos los valores iniciales para las matrices de sesgo y pesos. Usaremos estos valores en la primera iteración mientras realizamos la propagación hacia adelante.
Dimensiones: sesgo = (1, 1) y pesos = (1, 3)
8. Paso — 8:
A continuación, realizamos el paso de propagación hacia adelante. Este paso se basa en la siguiente fórmula.
Dimensiones: valor_predicho = (1, 1)+(200, 3)*(3,1) = (1, 1)+(200, 1) = (200, 1)
9. Paso — 9:
A continuación, calcularemos el coste asociado a nuestra predicción. La fórmula utilizada para este paso es la siguiente. Debido a que solo habrá un valor de error, no necesitaremos dividir la función de costo por el tamaño del conjunto de datos o sumar todos los valores de costo.
Dimensiones: costo = valor escalar
10. Paso — 10:
A continuación, actualizamos los valores de los parámetros de pesos y sesgos utilizando el algoritmo de descenso de gradiente. Este paso se basa en las siguientes fórmulas. Tenga en cuenta que la razón por la que no estamos sumando los valores de los pesos es que nuestra matriz de pesos no es una matriz de 1*1. Además, en este caso, dado que solo tenemos un ejemplo de entrenamiento, no necesitaremos realizar la suma sobre todos los ejemplos. La fórmula actualizada se da a continuación.
Dimensiones: db = (1, 1)
Dimensiones: dw = (1, 200) * (200, 3) = (1, 3)
Dimensiones: sesgo = (1, 1) y pesos = (1, 3)
11. Paso — 11:
12. Paso — 12:
A continuación, estamos llamando a la función para obtener los resultados finales. Tenga en cuenta que estamos ejecutando el código completo para 200 iteraciones. Además, aquí hemos especificado la tasa de aprendizaje de 0.01.
13. Paso — 13:
A continuación, imprimimos los valores de los pesos finales después de que se hayan realizado todas las iteraciones.
14. Paso — 14:
A continuación, imprimimos el valor de sesgo final después de que se hayan realizado todas las iteraciones.
15. Paso — 15:
A continuación, estamos trazando el gráfico de iteraciones frente a costo.
16. Paso — 16:
A continuación, trazamos dos gráficos con diferentes tasas de aprendizaje para ver el efecto de la tasa de aprendizaje en la optimización. En el siguiente gráfico podemos ver que el gráfico con mayor tasa de aprendizaje (0.01) converge más rápido que el gráfico con menor tasa de aprendizaje (0.001). Nuevamente, sabemos esto porque el gráfico con una tasa de aprendizaje más baja toma pasos más pequeños.
17. Paso — 17:
Poniendolo todo junto.
Cálculos:
Ahora, contemos el número de cálculos realizados al implementar el algoritmo de descenso de gradiente por lotes.
Inclinación: (ejemplos de entrenamiento) x (iteraciones) x (parámetros) = 1* 200 * 1 = 200
Pesos: (ejemplos de entrenamiento) x (iteraciones) x (parámetros) = 1* 200 *3 = 600
Algoritmo de descenso de gradiente de mini lotes:
En el algoritmo Batch Gradient Descent (BGD), consideramos todos los ejemplos de entrenamiento para todas las iteraciones del algoritmo. Sin embargo, en el algoritmo Stochastic Gradient Descent (SGD), solo consideramos un ejemplo de entrenamiento aleatorio. Ahora, en el algoritmo Mini-Batch Gradient Descent (MBGD), consideramos un subconjunto aleatorio de ejemplos de entrenamiento en cada iteración. Dado que esto no es tan aleatorio como SGD, nos acercamos más al mínimo global. Sin embargo, MBGD es susceptible de quedar atrapado en mínimos locales. Tomemos un ejemplo para entender esto de una mejor manera.
Descenso de gradiente por lotes (BGD):
Número de ejemplos de entrenamiento por iteraciones = 1 millón = 1⁰⁶
Número de iteraciones = 1000 = 1⁰³
Número de parámetros a entrenar = 10000 = 1⁰⁴
Cálculos totales = 1⁰⁶*1⁰³*1⁰⁴=1⁰¹³
Descenso de gradiente estocástico (SGD):
Número de ejemplos de entrenamiento por iteraciones = 1
Número de iteraciones = 1000 = 1⁰³
Número de parámetros a entrenar = 10000 = 1⁰⁴
Cálculos totales = 1*1⁰³*1⁰⁴ = 1⁰⁷
Descenso de gradiente de mini lotes (MBGD):
Número de ejemplos de entrenamiento por iteraciones = 100 = 1⁰²
→Aquí, estamos considerando 1⁰² ejemplos de entrenamiento de 1⁰⁶.
Número de iteraciones = 1000 = 1⁰³
Número de parámetros a entrenar = 10000 = 1⁰⁴
Cómputos totales = 1⁰²*1⁰³*1⁰⁴=1⁰⁹
Comparación con el descenso de gradiente por lotes (BGD):
Cálculos totales en BGD = 1⁰¹³
Cómputos totales en MBGD = 1⁰⁹
Evaluación: MBGD es 1⁰⁴ veces más rápido que BGD en este ejemplo.
Comparación con el descenso de gradiente estocástico (SGD):
Cómputos totales en SGD = 1⁰⁷
Cómputos totales en MBGD = 1⁰⁹
Evaluación: SGD es 1⁰² veces más rápido que MBGD en este ejemplo.
Comparación de BGD, SGD y MBGD:
Cálculos totales en BGD= 1⁰¹³
Cómputos totales en SGD= 1⁰⁷
Cómputos totales en MBGD = 1⁰⁹
Evaluación: SGD > MBGD > GBD
Nota: Tenga en cuenta que es posible que nuestra función de costo no disminuya necesariamente, ya que estamos tomando una muestra aleatoria de los ejemplos de capacitación en cada iteración. Sin embargo, la función de costo disminuirá gradualmente a medida que realicemos más y más iteraciones.
Ahora, veamos cómo se implementa en la práctica el algoritmo Mini-Batch Gradient Descent (MBGD).
1. Paso — 1:
Primero, estamos descargando el archivo de datos del repositorio de GitHub.
2. Paso — 2:
A continuación, estamos importando algunas bibliotecas necesarias para leer, manipular y visualizar los datos.
3. Paso — 3:
A continuación, leemos el archivo de datos y luego imprimimos las primeras cinco filas.
4. Paso — 4:
A continuación, estamos dividiendo el conjunto de datos en características y variables objetivo.
Dimensiones: X = (200, 3) & Y = (200, )
5. Paso — 5:
Para realizar cálculos matriciales en pasos posteriores, necesitamos remodelar la variable de destino.
Dimensiones: X = (200, 3) & Y = (200, 1)
6. Paso — 6:
A continuación, estamos normalizando el conjunto de datos.
Dimensiones: X = (200, 3) & Y = (200, 1)
7. Paso — 7:
A continuación, obtenemos los valores iniciales para las matrices de sesgo y pesos. Usaremos estos valores en la primera iteración mientras realizamos la propagación hacia adelante.
Dimensiones: sesgo = (1, 1) y pesos = (1, 3)
8. Paso — 8:
A continuación, estamos realizando el paso de propagación hacia adelante. Este paso se basa en la siguiente fórmula.
Dimensiones: valor_predicho = (1, 1)+(200, 3)*(3,1) = (1, 1)+(200, 1) = (200, 1)
9. Paso — 9:
A continuación, vamos a calcular el coste asociado a nuestra predicción. Este paso se basa en la siguiente fórmula.
Dimensiones: costo = valor escalar
10. Paso — 10:
A continuación, actualizamos los valores de los parámetros de pesos y sesgos utilizando el algoritmo de descenso de gradiente. Este paso se basa en las siguientes fórmulas. Tenga en cuenta que la razón por la que no estamos sumando los valores de los pesos es que nuestra matriz de pesos no es una matriz de 1*1.
Dimensiones: db = suma (200, 1) = (1, 1)
Dimensiones: dw = (1, 200) * (200, 3) = (1, 3)
Dimensiones: sesgo = (1, 1) y pesos = (1, 3)
11. Paso — 11:
A continuación, vamos a utilizar todas las funciones que acabamos de definir para ejecutar el algoritmo de descenso de gradiente. Además, estamos creando una lista vacía llamada cost_list para almacenar los valores de costo de todas las iteraciones. Usaremos esta lista para trazar un gráfico en pasos posteriores.
12. Paso — 12:
A continuación, estamos llamando a la función para obtener los resultados finales. Tenga en cuenta que estamos ejecutando el código completo para 200 iteraciones. Además, aquí hemos especificado la tasa de aprendizaje de 0.01.
13. Paso — 13:
A continuación, imprimimos los valores de los pesos finales después de que se hayan realizado todas las iteraciones.
14. Paso — 14:
A continuación, imprimimos el valor de sesgo final después de que se hayan realizado todas las iteraciones.
15. Paso — 15:
A continuación, estamos trazando el gráfico de iteraciones frente a costo.
16. Paso — 16:
A continuación, trazamos dos gráficos con diferentes tasas de aprendizaje para ver el efecto de la tasa de aprendizaje en la optimización. En el siguiente gráfico podemos ver que el gráfico con mayor tasa de aprendizaje (0.01) converge más rápido que el gráfico con menor tasa de aprendizaje (0.001). La razón detrás de esto es que el gráfico con una tasa de aprendizaje más baja toma pasos más pequeños.
17. Paso — 17:
Poniendolo todo junto.
Cálculos:
Ahora, contemos el número de cálculos realizados al implementar el algoritmo de descenso de gradiente por lotes.
Inclinación: (ejemplos de entrenamiento) x (iteraciones) x (parámetros) = 20 * 200 * 1 = 4000
Pesos: (ejemplos de entrenamiento) x (iteraciones) x (parámetros) = 20 * 200 *3 = 12000
Comparaciones de gráficos:
Notas finales:
Y así, ¡estamos al final de la serie Gradient Descent! En esta entrega, profundizamos en el código para observar cómo funcionan uno al lado del otro tres de los principales tipos de algoritmos de descenso de gradiente, resumidos en estas notas prácticas:
1. Descenso de gradiente por lotes
Precisión → Alta
Tiempo → Más
2. Descenso de gradiente estocástico
Precisión → Baja
Tiempo → Menos
3. Descenso de gradiente de mini lotes
Precisión → Moderada
Tiempo → Moderado
Esperamos que haya disfrutado de esta serie y aprendido algo nuevo, sin importar su punto de partida o experiencia en aprendizaje automático. Conocer este algoritmo esencial y sus variantes probablemente resulte valioso a medida que continúe con su viaje de IA y comprenda más sobre los aspectos técnicos y generales de esta increíble tecnología. Esté atento a otros blogs que ofrecen, incluso más, lecciones de aprendizaje automático, ¡y manténgase curioso!
Recursos:
Citación:
Para la atribución en contextos académicos, cite este trabajo como:
Shukla, et al., “El algoritmo de descenso de gradiente y sus variantes”, Hacia la IA, 2022
Cita de BibTex:
@article{pratik_2022, title={El algoritmo de descenso de gradiente y sus variantes}, url={https://towardsai.net/neural-networks-with-python}, journal={Hacia la IA}, publisher={Hacia la IA Co .}, autor={Pratik, Shukla}, editor={Lauren, Keegan}, año={2022}, mes={Oct} }
Referencias:
El algoritmo de descenso de gradiente y sus variantes se publicó originalmente en Hacia la IA en Medium, donde las personas continúan la conversación destacando y respondiendo a esta historia.
Publicado a través de Hacia la IA
