Código de Python - Descenso de Gradiente Estocástico(SGD)

Imágen de perfil

Descenso de Gradiente Estocástico(SGD)gráfica de visualizaciones


Python

Publicado el 13 de Septiembre del 2023 por Hilario (123 códigos)
373 visualizaciones desde el 13 de Septiembre del 2023
[
b]AulaF_658-Gradiente_Estocastico.py
*************************************************[/b]

El descenso de gradiente estocástico (SGD por sus siglas en inglés, Stochastic Gradient Descent) es un algoritmo de optimización ampliamente utilizado en el campo del aprendizaje automático y la inteligencia artificial para entrenar modelos de machine learning, especialmente en el contexto de aprendizaje profundo (deep learning). SGD es una variante del algoritmo de descenso de gradiente clásico.

La principal diferencia entre el descenso de gradiente estocástico y el descenso de gradiente tradicional radica en cómo se actualizan los parámetros del modelo durante el proceso de entrenamiento. En el descenso de gradiente tradicional, se calcula el gradiente de la función de pérdida utilizando todo el conjunto de datos de entrenamiento en cada paso de la optimización, lo que puede ser computacionalmente costoso en conjuntos de datos grandes.

En contraste, en SGD, en cada paso de optimización se utiliza un único ejemplo de entrenamiento (o un pequeño lote de ejemplos de entrenamiento) de forma aleatoria. Esto introduce estocasticidad en el proceso, ya que el gradiente calculado en cada paso se basa en una muestra aleatoria de datos. Como resultado, el proceso de optimización es más rápido y puede converger a un mínimo local o global de la función de pérdida de manera más eficiente en muchos casos.

Los pasos generales del algoritmo de descenso de gradiente estocástico son los siguientes:

Inicializar los parámetros del modelo de manera aleatoria o utilizando algún valor inicial.

Mezclar aleatoriamente el conjunto de datos de entrenamiento.

Realizar iteraciones sobre el conjunto de datos de entrenamiento, tomando un ejemplo (o un pequeño lote) a la vez.

Calcular el gradiente de la función de pérdida con respecto a los parámetros utilizando el ejemplo seleccionado.

Actualizar los parámetros del modelo utilizando el gradiente calculado y una tasa de aprendizaje predefinida.

Repetir los pasos 3-5 durante un número fijo de iteraciones o hasta que se cumpla un criterio de convergencia.

El uso de SGD es beneficioso en situaciones donde el conjunto de datos es grande o cuando se necesita un entrenamiento rápido. Sin embargo, la estocasticidad puede hacer que el proceso sea más ruidoso y requiera una sintonización cuidadosa de hiperparámetros, como la tasa de aprendizaje. Además, existen variantes de SGD, como el Mini-Batch Gradient Descent, que toman un pequeño lote de ejemplos en lugar de uno solo, lo que ayuda a suavizar las actualizaciones de parámetros sin la necesidad de calcular el gradiente en todo el conjunto de datos.

Requerimientos

Código realizado bajo Plataforma Linux.
Ubuntu 20.04.6 LTS.
Editado con Sublime Text.
****************************************
Ejecución en Consola Linux.
Comando:
python3 AulaF_658-Gradiente_Estocastico.py

V-0.

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

descarga
descarga-2
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
"""
AulaF_658-Gradiente_Estocastico.py
Ejecución, en consola Linux.
python3 AulaF_658-Gradiente_Estocastico.py
"""
 
import numpy as np
import matplotlib.pyplot as plt
 
np.random.seed(0)  # Fijar la semilla para reproducibilidad
x = np.random.randn(100)  # Generar 100 características aleatorias
y = 3 * x + 2 + np.random.randn(100)  # Generar 100 etiquetas con ruido
iteraciones = 100
alpha = 0.01  # Tasa de aprendizaje
 
# Función de costo
def costo(w, b, x_i, y_i):
    return ((w * x_i + b) - y_i) ** 2
 
# Gradiente de la función de costo para un solo punto de datos
def gradiente_w(w, b, x_i, y_i):
    return 2 * ((w * x_i + b) - y_i) * x_i
 
def gradiente_b(w, b, x_i, y_i):
    return 2 * ((w * x_i + b) - y_i)
 
# Descenso de gradiente estocástico
def descenso_gradiente_sgd(w, b, x, y, alpha, iteraciones):
    # Inicializar el historial de costo y parámetro
    historial_costo = []
    historial_w = [w]
    historial_b = [b]
 
    # Repetir hasta alcanzar el número máximo de iteraciones
    for i in range(iteraciones):
        # Seleccionar un punto de datos aleatorio
        random_index = np.random.randint(len(x))
        x_i, y_i = x[random_index], y[random_index]
 
        # Calcular el costo y los gradientes para el punto de datos actual
        costo_actual = costo(w, b, x_i, y_i)
        gradiente_w_actual = gradiente_w(w, b, x_i, y_i)
        gradiente_b_actual = gradiente_b(w, b, x_i, y_i)
 
        # Actualizar los parámetros usando el descenso de gradiente
        w = w - alpha * gradiente_w_actual
        b = b - alpha * gradiente_b_actual
 
        # Guardar el costo y los parámetros actuales en el historial
        historial_costo.append(costo_actual)
        historial_w.append(w)
        historial_b.append(b)
 
        # Mostrar el progreso cada 10 iteraciones
        if i % 10 == 0:
            print(f"Iteración {i}, costo = {costo_actual}, w = {w}, b = {b}")
 
    # Devolver el historial de costo, parámetros w y b
    return historial_costo, historial_w, historial_b
 
# Llamada a la función descenso_gradiente_sgd con valores iniciales
w_inicial = 1.0  # Cambia este valor si lo deseas
b_inicial = 0.0  # Valor inicial para el sesgo
historial_costo, historial_w, historial_b = descenso_gradiente_sgd(w_inicial, b_inicial, x, y, alpha, iteraciones)
 
# Graficar el valor del costo MSE
plt.figure(figsize=(15, 7))
plt.plot(historial_costo, label='MSE')
plt.xlabel("Iteraciones del modelo")
plt.ylabel("Valores del Costo")
plt.show()
 
# Graficar los datos y el ajuste lineal final
plt.figure(figsize=(15, 7))
plt.scatter(x, y, label='Datos')
plt.plot(x, historial_w[-1] * x + historial_b[-1], color='red', label='Ajuste Lineal')
plt.xlabel('Eje x')
plt.ylabel('Eje y')
plt.legend()
plt.show()
 
"""
RESULTADO.
Iteración 0, costo = 8.934905529019504, w = 1.0093469517364042, b = 0.0597826246630892
Iteración 10, costo = 14.221515595340962, w = 1.0679507053117598, b = 0.45054407461049417
Iteración 20, costo = 2.845351461031384, w = 1.353177202346895, b = 0.8786202864689188
Iteración 30, costo = 0.006820166126873642, w = 1.9513653095767454, b = 1.2344706988556235
Iteración 40, costo = 5.3733988475668015, w = 2.2073554853726183, b = 1.4005374105361053
Iteración 50, costo = 2.790175544241999, w = 2.567434800260463, b = 1.5223638379296611
Iteración 60, costo = 2.99911102247693, w = 2.7171751098309467, b = 1.6606887214827835
Iteración 70, costo = 0.20612899093941442, w = 2.845551538064422, b = 1.838934955151344
Iteración 80, costo = 1.0725918742456721, w = 3.0649544732436285, b = 1.9129072228563198
Iteración 90, costo = 0.18848102264854408, w = 3.129395035474455, b = 1.8847834336305669
"""



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