Código de Python - Descenso de gradiente tipo Adam.

Imágen de perfil

Descenso de gradiente tipo Adam.gráfica de visualizaciones


Python

Publicado el 19 de Octubre del 2023 por Hilario (123 códigos)
483 visualizaciones desde el 19 de Octubre del 2023
El descenso de gradiente tipo Adam, o simplemente Adam (por Adaptive Moment Estimation), es un algoritmo de optimización utilizado en el campo del aprendizaje automático y la inteligencia artificial para ajustar los parámetros de un modelo de manera que se minimice una función de pérdida. Adam es una variante del descenso de gradiente estocástico (SGD) que combina técnicas de otros algoritmos de optimización para mejorar la convergencia y la eficiencia en la búsqueda de los mejores parámetros del modelo.

Aquí hay una explicación simplificada de cómo funciona el algoritmo Adam:

Inicialización de parámetros: Se inician los parámetros del algoritmo, como la tasa de aprendizaje (learning rate), los momentos de primer y segundo orden, y se establece un contador de iteraciones.

Cálculo del gradiente: En cada iteración, se calcula el gradiente de la función de pérdida con respecto a los parámetros del modelo. Esto indica en qué dirección deben ajustarse los parámetros para reducir la pérdida.

Cálculo de momentos de primer y segundo orden: Adam mantiene dos momentos acumulativos, uno de primer orden (media móvil de los gradientes) y otro de segundo orden (media móvil de los gradientes al cuadrado).

Actualización de parámetros: Se utilizan los momentos calculados en el paso anterior para ajustar los parámetros del modelo. Esto incluye un término de corrección de sesgo para tener en cuenta el hecho de que los momentos se inicializan en cero. La tasa de aprendizaje también se aplica en esta etapa.

Iteración y repetición: Los pasos 2-4 se repiten durante un número especificado de iteraciones o hasta que se cumpla un criterio de parada, como la convergencia.

Adam se considera una elección popular para la optimización de modelos de aprendizaje profundo debido a su capacidad para adaptar la tasa de aprendizaje a medida que se entrena el modelo, lo que lo hace efectivo en una variedad de aplicaciones y evita problemas como la convergencia lenta o la divergencia en el entrenamiento de redes neuronales. Sin embargo, es importante ajustar adecuadamente los hiperparámetros de Adam, como la tasa de aprendizaje y los momentos, para obtener un rendimiento óptimo en un problema específico.

Requerimientos

Realizado bajo plataforma Linux.
Ubuntu 20.04.6 LTS
Editado con Sublime text.
---------------------------------------------------------------
Comando de ejecucion:

python3 Desc-Grad-ADAM-Aula-B.28-Gihub.py

También se podría editar y ejecutar con Google Colab.

V-0.

Publicado el 19 de Octubre del 2023gráfica de visualizaciones de la versión: V-0.
484 visualizaciones desde el 19 de Octubre del 2023
estrellaestrellaestrellaestrellaestrella
estrellaestrellaestrellaestrella
estrellaestrellaestrella
estrellaestrella
estrella

descarga
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
import numpy as np
import matplotlib.pyplot as plt
 
# Datos sintéticos con ruido
np.random.seed(0)
X = 3 * np.random.rand(100, 1)
y = 4 + 2 * X + np.random.randn(100, 1)
 
# Agregar una columna de unos a X para el término de sesgo
X_b = np.c_[np.ones((100, 1)), X]
 
# Parámetros iniciales
learning_rate = 0.1
beta1 = 0.9  # Factor de decaimiento para el primer momento
beta2 = 0.999  # Factor de decaimiento para el segundo momento
epsilon = 1e-7  # Pequeña constante para evitar división por cero
 
# Inicialización de pesos
theta = np.random.randn(2, 1)
 
# Listas para almacenar valores de costo y parámetros
costs = []
thetas = []
 
# Número de iteraciones
num_iterations = 40
 
# Algoritmo de descenso de gradiente Adam
m_t = np.zeros_like(theta)  # Primer momento
v_t = np.zeros_like(theta)  # Segundo momento
t = 0  # Contador de iteraciones
 
for i in range(num_iterations):
 
    # Corregimos el cálculo de gradientes
    gradients = 2 / len(X) * X_b.T.dot(X_b.dot(theta) - y)
    t += 1
    m_t = beta1 * m_t + (1 - beta1) * gradients
    v_t = beta2 * v_t + (1 - beta2) * gradients**2
    m_t_hat = m_t / (1 - beta1**t)
    v_t_hat = v_t / (1 - beta2**t)
    theta -= learning_rate * m_t_hat / (np.sqrt(v_t_hat) + epsilon)
    cost = np.mean((X_b.dot(theta) - y)**2)
    costs.append(cost)
    thetas.append(theta)
print("*******************************")
print("Historial de Costo:")
for index, miscostos in enumerate(costs):
  print(f'Iteración {index}:{miscostos}')
print("*******************************")
# Gráfico de los datos y la línea de descenso estimada
plt.figure(figsize=(18, 7))
plt.subplot(1, 2, 1)
plt.scatter(X, y, c='red', marker='o', label='Datos sintéticos')
plt.plot(X, X_b.dot(theta), c='blue', label='Línea de descenso estimada')
plt.xlabel('X')
plt.ylabel('y')
plt.legend()
 
# Gráfico de los valores del costo (MSE)
plt.subplot(1, 2, 2)
plt.plot(costs,color='black',marker='o',markerfacecolor='red', label='Costo MSE (puntos)')
plt.plot(costs, 'b-', label='Costo MSE (línea)')
plt.xlabel('Iteraciones')
plt.ylabel('Costo')
plt.legend()
 
plt.show()
 
"""
*******************************
Historial de Costo:
Iteración 0:91.56756524859085
Iteración 1:86.75310445687964
Iteración 2:82.07653425832954
Iteración 3:77.53989218056768
Iteración 4:73.14500277649827
Iteración 5:68.89346262600118
Iteración 6:64.78662613333714
Iteración 7:60.825592266365746
Iteración 8:57.0111923807028
Iteración 9:53.343979267516296
Iteración 10:49.824217557814436
Iteración 11:46.45187560884406
Iteración 12:43.22661898961988
Iteración 13:40.14780567266817
Iteración 14:37.21448302780997
Iteración 15:34.425386701229854
Iteración 16:31.77894144919029
Iteración 17:29.273263980548446
Iteración 18:26.906167845724145
Iteración 19:24.67517039196439
Iteración 20:22.577501785686362
Iteración 21:20.610116082418322
Iteración 22:18.76970430349543
Iteración 23:17.052709456352876
Iteración 24:15.455343412194921
Iteración 25:13.973605531271811
Iteración 26:12.603302902299683
Iteración 27:11.340072039111554
Iteración 28:10.179401854893252
Iteración 29:9.116657712853906
Iteración 30:8.147106332466226
Iteración 31:7.265941313069641
Iteración 32:6.468309022243808
Iteración 33:5.7493345854920666
Iteración 34:5.104147706933883
Iteración 35:4.527908048323679
Iteración 36:4.015829896116846
Iteración 37:3.563205853690149
Iteración 38:3.1654293082437563
Iteración 39:2.818015439257016
*******************************
"""



Comentarios sobre la versión: V-0. (0)


No hay comentarios
 

Comentar la versión: V-0.

Nombre
Correo (no se visualiza en la web)
Valoración
Comentarios...
CerrarCerrar
CerrarCerrar
Cerrar

Tienes que ser un usuario registrado para poder insertar imágenes, archivos y/o videos.

Puedes registrarte o validarte desde aquí.

Codigo
Negrita
Subrayado
Tachado
Cursiva
Insertar enlace
Imagen externa
Emoticon
Tabular
Centrar
Titulo
Linea
Disminuir
Aumentar
Vista preliminar
sonreir
dientes
lengua
guiño
enfadado
confundido
llorar
avergonzado
sorprendido
triste
sol
estrella
jarra
camara
taza de cafe
email
beso
bombilla
amor
mal
bien
Es necesario revisar y aceptar las políticas de privacidad

http://lwp-l.com/s7449