En lugar de estar separando los datos pueden simplemente hacer esto en el fit y así ahorrarán tiempo
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 clasificación binaria
20/29Recursos
¿Cómo construir un modelo de red neuronal para clasificación binaria?
Comenzar a trabajar con redes neuronales para tareas de clasificación binaria puede marcar una gran diferencia en el manejo efectivo de tus datos. En este caso, aprenderemos a crear un modelo que utilice la función de pérdida binary cross entropy, ideal para este tipo de situaciones.
¿Cómo se crean las capas del modelo?
La construcción comienza con el uso de models.Sequential, una herramienta que te permite agregar capas al modelo. Aquí tienes una guía de los pasos necesarios:
-
Agregar capas densas: Utiliza
add(layers.Dense())para añadir capas densas. Estas son manejadas con estructuras de conjunto de datos. -
Configuración de la capa: La configuración incluye:
- 16 neuronas.
- Función de activación
relu. - Los datos de entrada con un
input shapede 10,000.
-
Capas subsecuentes: Agregar más capas sin necesidad de definir el
input, ya que el modelo ya conoce la entrada. -
Capa de salida: La última capa termina en una sola neurona con una función sigmoide, que es perfecta para clasificaciones binarias.
from keras import models, layers
model = models.Sequential()
model.add(layers.Dense(16, activation='relu', input_shape=(10000,)))
model.add(layers.Dense(16, activation='relu'))
model.add(layers.Dense(1, activation='sigmoid'))
¿Cómo compilar y entrenar el modelo?
Luego de establecer las capas de nuestro modelo, pasamos a compilar y entrenar el modelo con los siguientes pasos:
-
Compilación del modelo:
- Optimizador:
rmsprop, una variación del descenso de gradiente, ideal para esta tarea. - Función de pérdida:
binary_crossentropy. - Métrica:
accuracy.
- Optimizador:
-
Entrenamiento del modelo:
- Conjunto de validación: Creación de un conjunto de validación dividiendo los datos originales.
- Proceso de ajuste (fit): Configurado para realizar cuatro iteraciones y lotes de datos de tamaño 512.
model.compile(optimizer='rmsprop',
loss='binary_crossentropy',
metrics=['accuracy'])
history = model.fit(partial_x_train,
partial_y_train,
epochs=4,
batch_size=512,
validation_data=(x_val, y_val))
Visualización y evaluación del modelo ¿Qué se analiza?
La evaluación de un modelo es crucial para entender su rendimiento. Utilizamos matplotlib para graficar resultados, lo que permite analizar la pérdida y la precisión a través de las épocas.
-
Visualización de resultados:
- Pérdida y precisión en el conjunto de entrenamiento.
- Pérdida y precisión en el conjunto de validación, centrándose en si el modelo muestra overfitting, es decir, si se ajusta demasiado a los datos de entrenamiento y permea en el rendimiento en validación.
-
Evaluación del modelo con el conjunto de prueba:
- Utilizamos
model.evaluate()para calcular la exactitud real en los datos de prueba.
- Utilizamos
import matplotlib.pyplot as plt
history_dict = history.history
loss_values = history_dict['loss']
val_loss_values = history_dict['val_loss']
epochs = range(1, len(loss_values) + 1)
plt.plot(epochs, loss_values, 'o', label='Training loss')
plt.plot(epochs, val_loss_values, '-', label='Validation loss')
plt.title('Training and validation loss')
plt.xlabel('Epochs')
plt.ylabel('Loss')
plt.legend()
plt.show()
results = model.evaluate(x_test, y_test)
print(f'Exactitud del modelo: {results[1] * 100:.2f}%')
El modelo presentado mostró un accuracy del 87%. Aunque es elevado, detectamos que sufre de overfitting. Resolver este problema puede llevar nuestro modelo a un nivel de desempeño aún mejor. ¡Sigue explorando y ajustando tu modelo, y no dudes en probar técnicas para reducir el overfitting!
Aportes 12
Preguntas 6
Ordenar por:
Nunca me gustó que al entrenar se genere mucho texto debajo, así que encontré esta barra de carga para entrenar modelos en keras.
Holi
Por si a alguien le interesa, también se puede determinar la precisión de modelo usando el cross validation :
Haciendo esto se puede observar que el score de entrenamiento y el score de prueba presentan un valor cercano a 1 por lo que no habría overfitting y el modelo estaría bien entrenado, sin embargo esto pasó porque use los valores x_train & y_train, cuando en realidad deberían de usarse los valores X ( la suma de x_train y y_train ) & y ( y_train + y_test), sin embargo cuando traté de usar esos valores la RAM de mi colab colapsó, quizas a ustedes si les resulte y puedan ver si en verdad hay overfitting como lo ha determinado el profesor en su ejemplo
Cross Entropy
Lo mas didáctico sería que para cada linea se escriba una breve explicación o tal vez una documentación bien explicita. Tal vez sacrificar un poco de buena practica comentando todas las líneas para que la clase sea mas didáctica. Se que es complicado explicar con precisión mientras se escribe código, pero sería bueno implementar alguna idea que explícitamente le diga al alumno que se está haciendo en caso de que quiera volver a alguna etapa del código que le cueste encajar.
Para ver cuáles son las funciones de optimizacion, perdida, activacion, etc, disponibles en keras, pueden usar las siguientes lineas de codigo.
from tensorflow.keras import (
activations, optimizers, losses, metrics
)
new_dir = lambda func: list(filter(lambda x: False if x.startswith('_') else True,func.__dir__()))
new_dir(metrics)
No todos los elementos de las listas corresponden a una de esas funciones, pero la mayoría si.
También pueden imprimir el atributo doc para ver una breve descripción del mismo.
print(metrics.binary_accuracy.__doc__)
De todas formas es preferible utilizar strings en los argumentos de la red neuronal ya que, en ocasiones, los miembros de los módulos en keras pueden ser movidos a otros, haciendo que nuestro código no sea future-proof.
layers.Dense(16, activation='relu', input_shape= (10000,))
# ambos funcionan igual, pero el primero es preferible
layers.Dense(16, activation=activations.relu, input_shape= (10000,))
Hice el entrenamiento con 20 épocas y el overfitting es bastante claro desde esta perspectiva
Explicacion del overfitting de DotCSV muy bien explicado: https://www.youtube.com/watch?v=7-6X3DTt3R8
Hemos creado una red neuronal, biennn, hemos caido en el overfitting, vale, hemos hecho un monton de cosas, pero sinceramente, alguien me puede decir que es lo que estamos intentando conseguir, me quede en la parte en la que habia un listado con muchas listas que tenian palabras y se expresaban en numeros, y de ahi, que si red, que si train, que si test, que si accuraccy, pero, para conseguir que???..
“overfitting”, es un fenómeno en el aprendizaje automático donde un modelo se ajusta demasiado bien a los datos de entrenamiento, capturando no solo los patrones reales presentes en los datos sino también el ruido o la aleatoriedad. Esto puede llevar a que el modelo tenga un rendimiento deficiente en datos nuevos o no vistos, ya que ha memorizado el conjunto de entrenamiento en lugar de aprender patrones generales.
Epoch 1/10
49/49 [==============================] - 3s 46ms/step - loss: 0.4534 - accuracy: 0.8171 - val_loss: 0.2897 - val_accuracy: 0.9005
Epoch 2/10
49/49 [==============================] - 1s 29ms/step - loss: 0.2674 - accuracy: 0.9043 - val_loss: 0.1995 - val_accuracy: 0.9378
Epoch 3/10
49/49 [==============================] - 1s 25ms/step - loss: 0.2088 - accuracy: 0.9248 - val_loss: 0.1625 - val_accuracy: 0.9495
Epoch 4/10
49/49 [==============================] - 1s 21ms/step - loss: 0.1760 - accuracy: 0.9373 - val_loss: 0.1349 - val_accuracy: 0.9601
Epoch 5/10
49/49 [==============================] - 1s 19ms/step - loss: 0.1536 - accuracy: 0.9469 - val_loss: 0.1163 - val_accuracy: 0.9667
Epoch 6/10
49/49 [==============================] - 1s 20ms/step - loss: 0.1317 - accuracy: 0.9546 - val_loss: 0.1021 - val_accuracy: 0.9714
Epoch 7/10
49/49 [==============================] - 1s 21ms/step - loss: 0.1155 - accuracy: 0.9612 - val_loss: 0.1488 - val_accuracy: 0.9379
Epoch 8/10
49/49 [==============================] - 1s 27ms/step - loss: 0.1054 - accuracy: 0.9650 - val_loss: 0.0763 - val_accuracy: 0.9805
Epoch 9/10
49/49 [==============================] - 1s 20ms/step - loss: 0.0882 - accuracy: 0.9714 - val_loss: 0.0768 - val_accuracy: 0.9773
Epoch 10/10
49/49 [==============================] - 1s 18ms/step - loss: 0.0807 - accuracy: 0.9754 - val_loss: 0.0666 - val_accuracy: 0.9822
Hola. Alguien me puede explicar, ¿por qué con mismo algoritmo de la clase, obtengo resultados tan distintos al del profe?%205.32.54%20p.%C2%A0m..png)
Tengo un inconveniente, ¿no entiendo por qué el loss no disminuye, y el accuracy no aumenta?
¿Quieres ver más aportes, preguntas y respuestas de la comunidad?