Me gusta de estas clases el hecho de que se equivoque y corrija el error en la misma clase. También te enseña de que manera se pueden entender los errores que se comenten.
Fundamentos en la arquitectura de redes neuronales
La importancia de las redes neuronales en la actualidad
¿Que herramientas usaremos para redes neuronales?
¿Qué es deep learning?
Tu primera red neuronal con Keras
Entrenando el modelo de tu primera red neuronal
La neurona: una pequeña y poderosa herramienta
Arquitectura de una red neuronal
Funciones de activación
Funcion de pérdida (loss function)
Descenso del gradiente
Backpropagation
Playground - Tensorflow
Quiz: Fundamentos en la arquitectura de redes neuronales
Redes neuronales con Python
Dimensiones, tensores y reshape
Creando nuestra red neuronal usando numpy y matemáticas
Entrenamiento forward de la red neuronal
Aplicando backpropagation y descenso del gradiente
Entrenamiento y análisis de resultados de tu red neuronal
Quiz: Redes neuronales con Python
Manejo de redes neuronales con Keras
Data: train, validation, test
Resolviendo un problema de clasificacion binaria
Entrenamiento del modelo de clasificación binaria
Regularización - Dropout
Reduciendo el overfitting
Resolviendo un problema de clasificación múltiple
Entrenamiento del modelo de clasificación múltiple
Resolviendo un problema de regresión
Entrenamiento del modelo de regresión
Análisis de resultados del modelo de regresión
Cierre
¿Qué sigue por aprender de redes neuronales?
Comparte tu proyecto de tu primera red neuronal y certifícate
No tienes acceso a esta clase
¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera
Si ya tienes una cuenta,
Entrenamiento del modelo de regresión
26/29Recursos
Aportes 10
Preguntas 6
Ordenar por:
Hay clases que dejan mucho que desear como esta que siento que solo leen y copian codigo. ):
Estaria super bien un poco mas de explicacion del codigo de manera sencilla, no solo leerlo.
para solucionar este error en keras
module 'keras.optimizers' has no attribute 'RMSprop'
importe el modulo de la siguiente manera:
from keras import layers, models
from tensorflow.keras import optimizers
En lugar de poner input_shape pueden poner input_dim y en ese caso se ahorran el estar poniendo las comas en lugar del numero dado
Encontre esto con GPT y da bien:
`from sklearn.model_selection import KFold`
`from sklearn.linear_model import LinearRegression # Ejemplo de modelo`
`# Supongamos que tienes tus datos X e y`
`# Definir el número de particiones (folds)`
`k = 5`
`# Inicializar el objeto KFold`
`kf = KFold(n_splits=k)`
`# Inicializar una lista para almacenar los puntajes de validación`
`scores = []`
`# Iterar sobre las particiones generadas por KFold`
`for train_index, test_index in kf.split(X):`
` # Dividir los datos en conjunto de entrenamiento y conjunto de prueba`
` X_train, X_test = X[train_index], X[test_index]`
` y_train, y_test = y[train_index], y[test_index]`
` `
` # Inicializar y entrenar el modelo (ejemplo con regresión lineal)`
` model = LinearRegression()`
` model.fit(X_train, y_train)`
` `
` # Evaluar el modelo en el conjunto de prueba`
` score = model.score(X_test, y_test)`
` `
` # Agregar el puntaje a la lista`
` scores.append(score)`
`# Calcular el puntaje promedio de validación`
`mean_score = sum(scores) / len(scores)`
`print("Puntaje promedio de validación:", mean_score)`
```js
# Actualizacion de la implementacion
for i in range(k):
print('processing fold #', i)
val_data = train_data[i * num_val_samples: (i + 1) * num_val_samples]
val_targets = train_targets[i * num_val_samples: (i + 1) * num_val_samples]
partial_train_data = np.concatenate(
[train_data[:i * num_val_samples],
train_data[(i + 1) * num_val_samples:]],
axis=0)
partial_train_targets = np.concatenate(
[train_targets[:i * num_val_samples],
train_targets[(i + 1) * num_val_samples:]],
axis=0)
model = build_model_regression(0.001, 13)
history = model.fit(partial_train_data, partial_train_targets,
epochs=num_epochs,
batch_size=16,
validation_data=(val_data, val_targets),
verbose=0)
all_history.append(history.history)
val_mse, val_mae = model.evaluate(val_data, val_targets, verbose=0)
all_scores.append(val_mae)
```
**Dejo una pequeña explicación del ciclo for:**
`for i in range(k): print("Fold:", i) `
`#Aquí se realiza un slice del train_data< #si k = 0 entonces val_data considera el slice de train_data[0:101] #y val_targets considera el slice de [0:101] val_data = train_data[i * num_val_samples: (i+1) * num_val_samples] val_targets = train_labels[i * num_val_samples: (i+1) * num_val_samples]`
`#Aquí se añade toda la data de entrenamiento (la que no es usada para validación) desde de una lista, #si k = 0 entonces partial_train_data será desde train_data[:0] concatenado con train_data[101:] partial_train_data = np.concatenate( [train_data[:i * num_val_samples], train_data[(i+1) * num_val_samples:] ], axis = 0 )`
Dejo una pequeña explicación del ciclo for:
for i in range(k): print("Fold:", i)
#Aquí se realiza un slice del train\_data< #si k = 0 entonces val\_data considera el slice de train\_data\[0:101] #y val\_targets considera el slice de \[0:101] val\_data = train\_data\[i \* num\_val\_samples: (i+1) \* num\_val\_samples] val\_targets = train\_labels\[i \* num\_val\_samples: (i+1) \* num\_val\_samples]
#Aquí se añade toda la data de entrenamiento (la que no es usada para validación) desde de una lista, #si k = 0 entonces partial\_train\_data será desde train\_data\[:0] concatenado con train\_data\[101:] partial\_train\_data = np.concatenate( \[train\_data\[:i \* num\_val\_samples], train\_data\[(i+1) \* num\_val\_samples:] ], axis = 0 )
- Entrenar un modelo de regresión implica ajustar los parámetros del modelo para minimizar la diferencia entre las predicciones del modelo y los valores reales del conjunto de datos de entrenamiento. En el contexto de regresión, se busca encontrar la mejor relación matemática entre las características de entrada (variables independientes) y la variable de salida (variable dependiente).
para los que tenian la advertencia de lr
def build_model_regression(lr_var,input_data):
model = models.Sequential()
model.add(layers.Dense(64,activation=‘relu’,input_shape=(input_data,)))
model.add(layers.Dense(64,activation=‘relu’))
model.add(layers.Dense(1))#numero continuo sin capa de activacion
model.compile(optimizer= optimizers.RMSprop(learning_rate=lr_var),#con learning rate
loss=‘mse’,
metrics=[‘mae’])
return model
for i in range(k):
print("Fold " , i)
val_data = train_data[inum_val_samples: (i+1) * num_val_samples]
val_targets = train_targets[inum_val_samples: (i+1) * num_val_samples]
partial_train_data = np.concatenate(
[train_data[:i * num_val_samples],
train_data[(i+1) * num_val_samples:]],
axis= 0
)
partial_train_targets = np.concatenate(
[train_targets[:i * num_val_samples],
train_targets[(i+1) * num_val_samples:]],
axis= 0
)
model = build_model_regression(0.001,13)
history = model.fit(partial_train_data, partial_train_targets, epochs=num_epoch, batch_size =16,
validation_data = (val_data, val_targets),
verbose=0)
all_history.append(history.history['val_mae'])
Se debe de arreglar con esto
¿Quieres ver más aportes, preguntas y respuestas de la comunidad?