Código de Python - Descenso Gradiente Batch(GD)

Imágen de perfil

Descenso Gradiente Batch(GD)gráfica de visualizaciones


Python

Publicado el 2 de Septiembre del 2023 por Hilario (124 códigos)
330 visualizaciones desde el 2 de Septiembre del 2023
*****************************************************************************************************
Hilario Iglesias Martínez


ClaseViernes-F543.py


DESCENSO DE GRADIENTE BATCH

*********************************************************************************************************
El "descenso de gradiente tipo Batch" es una técnica de optimización utilizada en el aprendizaje automático y la estadística para ajustar los parámetros de un modelo matemático, como una regresión lineal o una red neuronal, de manera que se minimice una función de costo específica. Es una de las variantes más simples y fundamentales del descenso de gradiente.

Aquí tienes una explicación de cómo funciona el descenso de gradiente tipo Batch:

Inicialización de parámetros: Comienza con un conjunto inicial de parámetros para tu modelo, que generalmente se eligen de manera aleatoria o se establecen en valores iniciales.

Selección de lote (Batch): En el descenso de gradiente tipo Batch, se divide el conjunto de datos de entrenamiento en lotes o subconjuntos más pequeños. Cada lote contiene un número fijo de ejemplos de entrenamiento. Por ejemplo, si tienes 1000 ejemplos de entrenamiento, puedes dividirlos en lotes de 32 ejemplos cada uno.

Cálculo del gradiente: Para cada lote, calculas el gradiente de la función de costo con respecto a los parámetros del modelo. El gradiente es una medida de cómo cambia la función de costo cuando se hacen pequeños ajustes en los parámetros. Indica la dirección en la que debes moverte para minimizar la función de costo.

Actualización de parámetros: Después de calcular el gradiente para cada lote, promedias los gradientes de todos los lotes y utilizas ese gradiente promedio para actualizar los parámetros del modelo. Esto se hace multiplicando el gradiente promedio por una tasa de aprendizaje (learning rate) y restando ese valor de los parámetros actuales. El learning rate controla el tamaño de los pasos que das en la dirección del gradiente.

Repetición: Los pasos 2-4 se repiten varias veces (llamadas épocas) a través de todo el conjunto de datos de entrenamiento. Cada época consiste en procesar todos los lotes y ajustar los parámetros del modelo.

Convergencia: El proceso de ajuste de parámetros continúa hasta que se alcanza un criterio de convergencia, que generalmente se establece en función de la precisión deseada o el número de épocas.

El descenso de gradiente tipo Batch es eficiente en términos de cómputo, ya que utiliza todos los datos de entrenamiento en cada paso de actualización de parámetros. Sin embargo, puede ser lento en conjuntos de datos grandes, y su convergencia puede ser más lenta en comparación con otras variantes del descenso de gradiente, como el descenso de gradiente estocástico (SGD) o el mini-batch SGD.

En resumen, el descenso de gradiente tipo Batch es una técnica de optimización que ajusta los parámetros de un modelo mediante el cálculo y la actualización de gradientes en lotes de datos de entrenamiento, con el objetivo de minimizar una función de costo. Es una parte fundamental en la optimización de modelos de aprendizaje automático.


*********************************************************************************************************
Ejecucion.
Bajo consola de Linux.
python3 ClaseViernes-F543.py

Requerimientos

Realizado sobre plataforma Linux.
Ubuntu 20.04.6 LTS
Editado con Sublime Text.

V-0

Publicado el 2 de Septiembre del 2023gráfica de visualizaciones de la versión: V-0
331 visualizaciones desde el 2 de Septiembre 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
"""
Ejecucion.
Bajo consola de Linux.
python3 ClaseViernes-F543.py
----------------------------
Realizado sobre plataforma Linux.
Ubuntu 20.04.6 LTS
Editado con Sublime Text.
"""
 
 
import numpy as np
import matplotlib.pyplot as plt
 
# Generar datos de muestra sintéticos.
"""
generación de números aleatorios utilizando una
biblioteca o módulo de Python, como NumPy.
Esta línea de código genera una matriz (array)
de números aleatorios distribuidos normalmente
(conocida como distribución normal o gaussiana)
con 100 filas y 1 columna.
seed(0): La función seed() se utiliza para inicializar
el generador de números aleatorios con una semilla
específica. En este caso, se establece la semilla en 0.
Esto significa que, cada vez que generes números aleatorios
después de esta línea de código, obtendrás la misma secuencia de números
aleatorios. Esto es útil para fines de reproducibilidad,
ya que garantiza que, si vuelves a ejecutar
tu código en el mismo entorno, obtendrás los mismos resultados aleatorios.
"""
 
# Generar datos de muestra sintéticos.
np.random.seed(0)
X = 2 * np.random.rand(100, 1)
y = 4 + 3 * X + np.random.randn(100, 1)
 
# Inicializar parámetros m y b
m = 0
b = 0
 
# Declaramos los parámetros del descenso de gradiente
learning_rate = 0.01
iterations = 1000
 
# Listas para almacenar el historial de MSE
mse_history = []
 
# Descenso de gradiente tipo Batch
for i in range(iterations):
    # Calcular las predicciones del modelo
    y_pred = m * X + b
 
    # Calcular el error cuadrático medio (MSE)
    mse = np.mean((y_pred - y)**2)
    mse_history.append(mse)
 
    # Calcular el gradiente de la función de costo (MSE)
    gradient_m = np.mean((y_pred - y) * X)
    gradient_b = np.mean(y_pred - y)
 
    # Actualizar los parámetros m y b
    m = m - learning_rate * gradient_m
    b = b - learning_rate * gradient_b
 
# Hacer predicciones en nuevos datos
new_x = np.array([[1.5]])  # Nuevo valor de x
new_y = m * new_x + b
 
# Graficar los datos y la línea de regresión
plt.scatter(X, y, label='Datos de muestra')
plt.plot(X, m * X + b, color='red', label='Línea de regresión')
plt.scatter(new_x, new_y, color='green', marker='o', label='Predicción')
plt.xlabel('Eje X')
plt.ylabel('Eje y')
plt.title('Regresión lineal con descenso de gradiente')
plt.legend()
plt.grid(True)
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/s7425