Código de Python - Descenso Gradiente tipo Nesterov

Imágen de perfil

Descenso Gradiente tipo Nesterovgráfica de visualizaciones


Python

Publicado el 18 de Octubre del 2023 por Hilario (124 códigos)
178 visualizaciones desde el 18 de Octubre del 2023
Sencillo ejemplo de un descenso de gradiente del tipo Nesterov.

Descen_Grad_Nesterov_Aula_B_28_18_OCT_github.py
----------------------------------------------------------------------------------------------------

El descenso de gradiente tipo Nesterov, también conocido como el "descenso de gradiente acelerado de Nesterov" o "NAG" por sus siglas en inglés (Nesterov Accelerated Gradient Descent), es una variante del algoritmo de optimización de descenso de gradiente utilizado en el entrenamiento de redes neuronales y en la optimización de funciones en el aprendizaje automático.

Fue propuesto por Yurii Nesterov en 1983 y es una mejora con respecto al descenso de gradiente estándar, especialmente en términos de velocidad de convergencia. El descenso de gradiente Nesterov se diferencia del descenso de gradiente tradicional en cómo se actualizan los parámetros del modelo.

En el descenso de gradiente Nesterov, en lugar de calcular el gradiente de la función de costo en la posición actual de los parámetros, se calcula el gradiente en una posición ligeramente adelantada de los parámetros. Luego, se utiliza ese gradiente para realizar la actualización de los parámetros. Esto tiene el efecto de "mirar hacia adelante" antes de dar el paso de actualización, lo que puede ayudar a reducir la oscilación y mejorar la velocidad de convergencia.

La fórmula para la actualización de los parámetros en el descenso de gradiente tipo Nesterov es la siguiente:

v = γ * v - η * ∇J(θ - γ * v)
θ = θ + v


Donde:

θ son los parámetros del modelo.
∇J(θ - γ * v) es el gradiente de la función de costo evaluado en la posición adelantada de los parámetros.
v es una especie de "momentum" que acumula la velocidad de los pasos anteriores.
η es la tasa de aprendizaje.
γ es un hiperparámetro que controla la influencia del momentum en la actualización.
En resumen, el descenso de gradiente tipo Nesterov es una técnica de optimización que tiene la ventaja de converger más rápidamente que el descenso de gradiente estándar, lo que lo hace especialmente útil en el entrenamiento de redes neuronales profundas y otros problemas de optimización en el aprendizaje automático.



Requerimientos

El programa fue realizado bajo Consola Linux.
Concretamente:
Ubuntu 20.04.6 LTS
Editado en Sublime text.

Se debe tener en cuenta que en la plataforma Linux que se ejecute, deberán
estar instalados los módulos siguientes, llamados con import:

import numpy as np
import matplotlib.pyplot as plt

---------------------------------------------------------------------------------------------------------
Ejecucion en consola Linux, con este comando.

python3 Descen_Grad_Nesterov_Aula_B_28_18_OCT_github.py

---------------------------------------------------------------------------------------------------
Este ejercicio también se puede editar y ejecutar con google colab.
*********************************************************************************************************



V-0.

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

descarga-1
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
#  Descen_Grad_Nesterov_Aula_B_28_18_OCT_github.py
 
import numpy as np
import matplotlib.pyplot as plt
 
# Definir una función de costo (puedes cambiarla por la que desees)
def cost_function(x):
    return x**4 - 4*x**3 + 2*x**2 + 3*x + 1
 
# Calcular el gradiente de la función de costo
def gradient(x):
    return 4*x**3 - 12*x**2 + 4*x + 3
 
# Inicializar parámetros
learning_rate = 0.1
momentum = 0.9
num_iterations = 50
x = 3  # Valor inicial de x
 
# Listas para almacenar datos de seguimiento
x_values = []
cost_values = []
gradient_values = []
 
for i in range(num_iterations):
    x_values.append(x)
    cost = cost_function(x)
    cost_values.append(cost)
    grad = gradient(x)
    gradient_values.append(grad)
 
    # Calcular el valor adelantado (lookahead)
    lookahead_x = x - learning_rate * (momentum * grad)
 
    # Actualizar x usando el lookahead
    x -= learning_rate * grad
 
# Gráficas
plt.figure(figsize=(15, 5))
 
# Gráfica de la función de costo con valores de descenso
plt.subplot(1, 3, 1)
x_range = np.linspace(min(x_values) - 1, max(x_values) + 1, 100)
plt.plot(x_range, cost_function(x_range), label="Cost Function")
plt.scatter(x_values, cost_values, c='black', marker='o', label="Iterations")
plt.xlabel('x')
plt.ylabel('Cost')
plt.legend()
 
# Gráfica de los gradientes
plt.subplot(1, 3, 2)
plt.plot(gradient_values)
plt.xlabel('Iterations')
plt.ylabel('Gradient')
plt.title('Gradients')
 
# Gráfica de la función de costo 3D
plt.subplot(1, 3, 3)
from mpl_toolkits.mplot3d import Axes3D
 
x_range = np.linspace(min(x_values) - 1, max(x_values) + 1, 100)
cost_range = cost_function(x_range)
X, Y = np.meshgrid(x_range, cost_range)
Z = cost_function(X)
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
ax.plot_surface(X, Y, Z, cmap='viridis', alpha=0.8)
ax.scatter(x_values, cost_values, cost_function(np.array(x_values)), c='r', marker='x', label="Iterations")
ax.set_xlabel('x')
ax.set_ylabel('Cost')
ax.set_zlabel('Cost Function')
ax.set_title('Cost Function')
 
plt.tight_layout()
plt.show()



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/s7448