Código de Python - MiniBatch-Datos-Aleatorios

Imágen de perfil

MiniBatch-Datos-Aleatoriosgráfica de visualizaciones


Python

Publicado el 20 de Septiembre del 2023 por Hilario (123 códigos)
388 visualizaciones desde el 20 de Septiembre del 2023
MiniBatch_Aula-228-G.py


El ejercicio se configura y ejecuta con parámetros mínimos con el fin de
que las salidas impresas por consola no sean grandes. Se puede jugar con estos
valores:
np.random.seed(0)
X = 2 * np.random.rand(20, 1)
y = 4 + 3 * X + np.random.randn(20, 1)
learning_rate = 0.1
batch_size = 10
epochs = 10


***************************************************************************************************************
El descenso de gradiente Mini-Batch es una técnica de optimización ampliamente utilizada en el aprendizaje automático y la optimización numérica. Permite entrenar modelos de manera eficiente al actualizar los pesos del modelo en función de un subconjunto (mini-lote o mini-batch) de datos de entrenamiento en lugar de utilizar el conjunto de datos completo en cada iteración. Además, en algunos casos, se introducen elementos de aleatoriedad en la selección de estos mini-lotes para mejorar la convergencia y evitar que el algoritmo quede atrapado en mínimos locales.

Aquí hay un resumen de cómo funciona el descenso de gradiente Mini-Batch con entrada de datos aleatorios:

División del conjunto de datos: En lugar de usar todo el conjunto de datos de entrenamiento en cada iteración (como se hace en el descenso de gradiente por lotes), el conjunto de datos se divide en mini-lotes más pequeños. La elección del tamaño del mini-lote es un hiperparámetro importante que debe ajustarse según las características de los datos y el modelo.

Aleatorización de los datos: Para introducir aleatoriedad, el conjunto de datos se suele barajar (mezclar) al comienzo de cada época (una época se completa después de que el modelo haya visto todos los mini-lotes). Esto evita que el modelo se ajuste a patrones específicos del orden en que se presentan los datos y mejora la generalización.

Iteración: El algoritmo recorre las épocas, y en cada época, se selecciona un mini-lote aleatorio de datos. Los pesos del modelo se actualizan en función del gradiente calculado utilizando solo los ejemplos en ese mini-lote. La actualización de los pesos se realiza de acuerdo con la dirección del gradiente descendente, como en el descenso de gradiente estándar.

Convergencia: El proceso se repite durante varias épocas hasta que el algoritmo alcance un criterio de convergencia predefinido (por ejemplo, una pérdida baja o un número máximo de épocas).

La aleatorización de los mini-lotes y la aleatorización de los datos en cada época ayudan a evitar que el descenso de gradiente Mini-Batch quede atrapado en mínimos locales y mejora la capacidad del algoritmo para generalizar a nuevos datos. También hace que el entrenamiento sea más eficiente en términos de tiempo y memoria en comparación con el descenso de gradiente por lotes.

El descenso de gradiente Mini-Batch es especialmente útil cuando se trabaja con grandes conjuntos de datos que no caben en la memoria, ya que permite entrenar modelos de manera más rápida y escalable utilizando recursos computacionales limitados.

Requerimientos

Programa realizado en plataforma Linux.
Ubuntu 20.04.6 LTS.
Sublime Text.
-------------------------------------------------------------
Ejecucion bajo consola Linux:
python3 MiniBatch_Aula-228-G.py

V-0.

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

descarga
descarga-1
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
"""
MiniBatch_Aula-228-G.py
Ejecucion bajo consola Linux:
python3 MiniBatch_Aula-228-G.py
"""
 
import numpy as np
import matplotlib.pyplot as plt
 
# Generamos datos aleatorios con ruido
np.random.seed(0)
X = 2 * np.random.rand(20, 1)
y = 4 + 3 * X + np.random.randn(20, 1)
 
# Agregamos una columna de unos a la matriz X para el término de sesgo (intercepto)
X_b = np.c_[np.ones((20, 1)), X]
 
# Definimos la función de costo (Mean Squared Error)
def compute_cost(theta, X, y):
    m = len(y)
    predictions = X.dot(theta)
    cost = (1 / (2 * m)) * np.sum(np.square(predictions - y))
    return cost
 
# Inicializamos los parámetros
theta = np.random.randn(2, 1)
 
# Hiperparámetros
learning_rate = 0.1
batch_size = 10
epochs = 10
 
# Historial de costos
cost_history = []
 
# Descenso de gradiente mini-batch
for epoch in range(epochs):
    for i in range(0, len(X), batch_size):
        X_batch = X_b[i:i+batch_size]
        y_batch = y[i:i+batch_size]
        m = len(y_batch)
 
        gradient = (1 / m) * X_batch.T.dot(X_batch.dot(theta) - y_batch)
        theta -= learning_rate * gradient
 
        cost = compute_cost(theta, X_batch, y_batch)
        cost_history.append(cost)
 
print ("**************************************************************************")
print(f"Parámetros finales: theta0 = {theta[0][0]}, theta1 = {theta[1][0]}")
print ("**************************************************************************")
print("Histórico de costos:")
for costos in cost_history:
 print(costos)
print ("*****************************")
# Graficamos el ajuste lineal
plt.figure(figsize=(12,6))
plt.scatter(X, y, label='Datos')
plt.plot(X, X_b.dot(theta), 'r-', label='Ajuste Lineal')
plt.xlabel('X')
plt.ylabel('y')
plt.legend()
plt.show()
 
# Graficamos el historial de costos
plt.figure(figsize=(12,6))
plt.plot(cost_history,color='black', marker='o',markerfacecolor='red')
plt.xlabel('Iteraciones')
plt.ylabel('Costo (MSE)')
plt.title('Historial de Costos')
plt.show()
 
"""
Salida por Consola:
**************************************************************************
Parámetros finales: theta0 = 3.200095792152507, theta1 = 3.650528245973128
**************************************************************************
Histórico de costos:
7.968153103360422
4.288772869769235
3.045718223059513
1.6992952039805251
1.5073797562567552
0.9044400086690034
1.024005735638794
0.6619880806456742
0.870849321474465
0.5885696356417641
0.8217923775651728
0.5663252279263014
0.8059543302896105
0.5592746005908619
0.8009330307310398
0.5565750888797056
0.7995475009987381
0.5550386272645492
0.7994411056668145
0.5537728189145595
*****************************
"""



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