Keras trabaja con el concepto de modelo (red neuronal). Un modelo es una serie de pasos a realizar sobre un conjunto de datos para crear una predicción o una clasificación. El modelo está construido de capas, comenzando con la capa de entrada, donde los datos se insertan en el modelo. Continuando en las capas ocultas, donde se procesan los datos. Y finalmente culmina en la capa de salida, donde se encuentra la predicción o clasificación.
 |
| Más fotos de circuitos aquí |
Una vez se han definido las capas del modelo, se compila este. La compilación utiliza un marco para optimizar el cálculo a realizar. Y permite que se especifique una determinada configuración, como el optimizador y las funciones de pérdida.
Los optimizadores y las funciones de pérdida son los parámetros que el modelo de aprendizaje automático utiliza para entrenar. La función de pérdida es una forma matemática de medir cuán erróneas son las predicciones. Y el optimizador une la función de pérdida y los parámetros al actualizar el modelo en función de la salida de la función de pérdida.
El optimizador modifica los pesos de las neuronas para aumentar la precisión. Con la función de pérdida retornando resultados que guían al optimizador hacia el éxito. Los optimizadores tienen diferentes casos de uso y deben evaluarse según el tipo de modelo que estemos creando.
Si la precisión está por debajo de lo esperado, entonces se debe hacer un optimizador diferente para mejorar. Por ejemplo, RMS Prop, es el nombre de un modelo, debe usarse para redes neuronales recurrentes. Y Adagrad es útil cuando los datos son escasos.
También hay que especificar en la etapa de compilación las métricas que se utilizarán para evaluar el modelo durante el entrenamiento y las pruebas. Estos se devuelven como enteros. Con un cero como una falla total de predicción, y uno siendo una predicción hecha con absoluta precisión.
Una vez compilado, el modelo debe ajustarse a los datos. Esto se conoce como entrenamiento de la máquina. Cuando se completa el entrenamiento, el modelo puede usarse para hacer predicciones sobre nuevos datos.
Vamos a ver un ejemplo:
#cargamos los paquetes
from tensorflow.keras.layers import Dense
import numpy as np
import pandas as pd
from sklearn.model_selection import train_test_split
np.random.seed(7)
*******************************
A continuación presentamos tres formas diferentes de cargar un dataset a una red neuronal.
#Para leer desde una URL:
url = "https://raw.githubusercontent.com/jbrownlee/Datasets/master/iris.csv"
names = ['sepal-length', 'sepal-width', 'petal-length', 'petal-width', 'class']
data = pd.read_csv(url, names=names)
*******************************************
#O bien desde nuestro equipo:
data = pd.read_csv("C:\Temp\Archivo_dataset.csv")
#Modificamos los datos para añadir etiquetas
label = data['Outcome']
features = data.drop('Outcome',1)
*********************************************
#Si trabajamos con Colaboratory y deseamos subir un
archivo de nuestro equipo podemos hacerlo con:
from google.colab import files
uploaded =
files.upload()
Dividimos los datos en variables x e y, para poder identificar la entrada y la salida de manera adecuada.
#separamos en variables input(x) y output(y)
x_train, x_test, y_train, y_test = train_test_split(data, label, test_size=0.2, random_state= 42)
Escribimos
data.shape
y nos devuelve (768,9) Esto significa que los datos se componen de una matriz de 768 filas y 9 columnas.
Creamos una red neuronal secuencial básica.
Para compilar la red utilizaremos Adam como optimizador. Y la función de pérdida se establecerá como binaria.
model=Sequiential()
model.add(Dense(12, input_dim=9, activation='relu'))
model.add(Dense(8, activation='relu'))
model.add(Dense(1, activation='sigmoid'))
model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])
model.fit(x_train, y_train, epochs=20, batch_size=10)
Especificamos 20 épocas, con un tamaño de lote de 10, y ejecutamos estas líneas de código. Veremos que la pérdida y la precisión serán diferentes cada vez.
Si queremos, podemos ejecutarlo de nuevo con una cantidad diferente de épocas, o en lotes de diferente tamaño por ejemplo.
Después hacemos una evaluación de la red neuronal. Esto nos dirá la precisión
print("\n%s: %.2f%%" % (model.metrics_names[1], scores[1]*100))
77.36%
Vemos aquí una precisión del 77,36%. Dependiendo del tipo de datos que estemos manejando, eso puede ser muy bueno o muy malo.
model.compile(loss = 'mse', optimicer = 'sgd', metrics = ['accuracy'])
model.fit(x_train, y_train, epochs=20, batch_size=10)
Ahora cambiamos nuestras funciones de optimización y pérdida para ver cómo afecta. Para ello, Reajustamos la red neuronal.
Nuevamente, vamos a obtener nuestra precisión de pérdida aquí. Observamos que los valores son significativamente diferentes de cuando lo ejecutamos por primera vez. Vamos a seguir y evaluando el modelo nuevamente.
print("\n%s: %.2f%%" % (model.metrics_names[1], scores[1]*100))
68,57%
Notemos la diferencia en precisión. En lugar de estar en el 70%, ahora estamos en el 60%, de hecho, 68.57. Como podemos ver, la función de optimización y pérdida especificada durante la etapa de compilación puede afectar el rendimiento de nuestra red neuronal.
Las redes neuronales deben estar sujetas a múltiples rondas de pruebas antes de ser puestas en producción. Con varios cambios de configuración hasta que se encuentre la combinación óptima.
Entrenamiento y prueba de redes neuronales
Las redes neuronales contienen una serie de nodos, conocidos como neuronas porque el concepto simula el funcionamiento de un cerebro, y cada neurona o nodo acepta una entrada, ejecuta una computación y luego crea una salida.
Una red neuronal puede estar comprendida por muchas neuronas dispuestas múltiples capas. A la capa de entrada se le proporciona un conjunto de datos, que es una recopilación de información que se ha estructurado y vinculado de tal manera que la máquina pueda reconocer patrones. Las siguientes capas del modelo o red neuronal se denominan capas ocultas. A ellas no se accede directamente por entradas accesibles a humanos.
Las capas ocultas toman como entrada la salida de la capa anterior. Las capas ocultas asignan una ruta a la información que pasa y producen otra salida. Este es el ciclo a través de muchas capas ocultas hasta que se llega a la capa de salida donde esta produce el resultado final.
La tarea de las redes neuronales es mapear los datos que se ingresan y reconocer en ellos patrones. Cuando esto sucede, se pueden agregar nuevos datos al modelo a analizar. Para los modelos de regresión, esto se usaría para predecir la probabilidad y el evento que sucederá. Por ejemplo, la probabilidad de que suceda un acontecimiento basándose en sucesos anteriores de ese acontecimiento. Los modelos de clasificación clasificarán los nuevos datos en una categoría definida durante el proceso de modelado. Como reconocer si una imagen es de un perro o un gato.
Por lo general, los datos se clasifican o dividen en dos conjuntos de datos. Uno se usa para el entrenamiento y el otro para las pruebas. El conjunto de datos de entrenamiento generalmente comprendería la mayor parte de los datos. Entrenamiento o ajuste es el proceso de hacer que la máquina procese los datos. Es durante esta etapa de entrenamiento cuando se configuran y llevan a cabo varios elementos relacionados con el aprendizaje de la máquina.
El comando para entrenar un modelo en Keras es fit. Los parámetros requeridos son el nombre del modelo, los ejes x e y son los conjuntos de datos y el número de épocas a ejecutar.
Una época es una iteración completa de los datos de un lote. El tamaño del lote es el número de muestras por actualización de gradiente. El modelo se actualiza cada vez que se procesa un lote. Por lo tanto, se puede actualizar varias veces durante una sola época. Si el conjunto de datos consta de 10.000 artículos, con un tamaño de lote de 128, se actualizará 70 veces por época.
from tensorflow.keras.layers import Dense, Dropout
from tensorflow.keras.utils import to_categorical
from tensorflow.keras.datasets import mnist
from tensorflow.keras.models import Sequential
NUM_ROWS = 28
NUM_COLS = 28
NUM_CLASSES = 10
BATCH_SIZE = 128
EPOCHS = 10
#Cargamos los datos
(X_train, y_train), (X_test, y_test) = mnist.load_data()
#modificamos los datos
X_train = X_train.reshape((X_train.shape[0], NUM_ROWS * NUM_COLS))
X_train = X_train.astype('float32') /255
X_test = X_test.reshape((X_test.shape[0], NUM_ROWS * NUM_COLS))
X_test = X_test.astype('float32') / 255
#Categorically encode labels
y_train =to_categorical(y_train, NUM_CLASSES)
y_test = to_categorical(y_test, NUM_CLASSES)
Hacemos las importaciones correspondientes, incluyendo la biblioteca mnist, después especificamos el número de filas, columnas, el tamaño de lote y las épocas.
Finalmente hemos cargado los datos del paquete mnist en sus correspondientes variables y os hemos modificado para poder utilizarlos mejor, también se han modificado las etiquetas como to_categorical.
A continuación creamos el modelo secuencial y lo compilamos.
#creamos las capas de la red neuronal
model = Sequential()
model.add(Dense(512, activation='relu', input_shape=(NUM_ROWS * NUM_COLS,)))
model.add(Dropout(0.5))
model.add(Dense(256, activation='relu'))
model.add(Dropout(0.25))
model.add(Dense(10, activation='softmax'))
#compilamos la red neuronal
model.compile(optimizer='rmsprop',loss='categorical_crossentropy', metrics=['accuracy'])
model.fit(X_train, y_train, batch_size = 128, epochs=10, verbose=1, validation_data=(X_test, y_test))
Como se puede ver, especificamos los parámetros como el optimizador como rms, la pérdida, la métrica establecida como ‘accuracy’ y, lo que es más importante, compilamos la red neuronal.
Al ejecutar estas instrucciones comienza la compilación, vemos que hay 60.000 muestras, con un conjunto de datos de validación separado de 10.000 muestras. Le hemos especificado que muestre la pérdida de precisión en cada época, para ambos conjuntos de datos. En la primera época, podemos ver que tardó 8 segundos, y también nos muestra los valores de la pérdida y la precisión. Para la segunda época fue un poco más rápido. Entonces, lo único que queremos hacer aquí es observar el puntaje general de pérdida y precisión de todo el modelo para su entrenamiento y prueba.
No hay comentarios:
Publicar un comentario