Red neuronal para clasificación con Tensorflow

Este artículo fue publicado como parte del Blogatón de ciencia de datos

En este artículo, construiré modelos de redes neuronales con TensorFlow para resolver un problema de clasificación. Exploremos juntos cómo podemos abordar un problema de clasificación en Tensorflow. Pero en primer lugar, me gustaría asegurarme de que podamos responder estas preguntas:

Qué es la red neuronal?

El propósito principal de una red neuronal es tratar de encontrar la relación entre características en un conjunto de datos, y consiste en un conjunto de algoritmos que imitan el trabajo del cerebro humano. Una "neurona" en una red neuronal es una función matemática que recopila y clasifica información de acuerdo con una arquitectura específica.

¿Qué es la clasificación?

El problema de clasificación implica predecir si algo pertenece a una clase o no. En otras palabras, mientras lo hacemos intentamos ver que algo es una cosa u otra.

Tipos de clasificación

• Suponga que desea predecir si una persona tiene diabetes o no. Si te enfrentas a este tipo de situación, hay dos posibilidades, ¿verdad? Eso es llamado Clasificación binaria.
• Suponga que quiere identificar si una foto es de un juguete, una persona o un gato, ¿verdad? se llama Clasificación de clases múltiples porque hay más de dos opciones.
• Suponga que desea decidir qué categorías deben asignarse a un artículo. Si es así, se llama Clasificación de etiquetas múltiples, porque un artículo podría tener más de una categoría asignada. Veamos nuestra explicación a través de este artículo. Podemos asignar categorías como "Aprendizaje profundo, TensorFlow, Clasificación", etc. a este artículo.

Ahora podemos avanzar porque tenemos un entendimiento común del problema en el que trabajaremos. Entonces, es hora de codificar. Espero que los esté escribiendo conmigo porque la única forma de mejorar, cometer menos errores es escribir más código.

Comenzamos con la importación de bibliotecas que usaremos:

importar numpy como np importar pandas como pd importar matplotlib.pyplot como plt importar tensorflow como tf print (tf .__ versión__)

Crear un conjunto de datos

Es hora de crear un conjunto de datos en el que trabajar:

de sklearn.datasets importar make_circles samples = 1000 X, y = make_circles (samples, noise = 0.03, random_state = 42)

imprimir (X >> [[0.75424625 0.23148074] [-0.75615888 0.15325888] [-0.81539193 0.17328203] ... [-0.13690036 -0.81001183] [0.67036156 -0.76750154] [0.28105665 0.96382443]]

imprimir (y) >> [1 1 1 1 0 1 1 1 1 0]

De acuerdo, hemos visto nuestro conjunto de datos con más detalle, pero todavía no sabemos nada al respecto, ¿verdad? Es por eso que aquí un paso importante es convertirse en uno con los datos, y la visualización es la mejor manera de hacerlo.

circle = pd.DataFrame ({'X0': X [:, 0], 'X1': X [:, 1], 'etiqueta': y}) circle.head ()

Aquí surge una pregunta, ¿con qué tipo de etiquetas estamos lidiando?

circle.label.value_counts () >> 1 500 Nombre: etiqueta, dtype: int0

Parece que estamos tratando con un problema de clasificación binaria, porque tenemos 2 etiquetas (0 y 1).

plt.scatter (X [:, 0], X [:, 1], c = y, cmap = plt.cm.RdYlBu)

Como mencioné anteriormente, la mejor manera de obtener uno con los datos es la visualización. Ahora la trama dice por sí misma qué tipo de modelo necesitamos construir. Construiremos un modelo que sea capaz de distinguir los puntos azules de los rojos.

Antes de construir cualquier modelo de red neuronal, debemos verificar las formas de nuestras características de entrada y salida. ¡deben ser iguales!

print (X.shape, y.shape) print (len (X), len (y)) >> (1000, 2) (1000,) 1000 1000

Tenemos la misma cantidad de valores para cada característica, pero ¿la forma de X es diferente? ¿Por qué? Vamos a ver.

X [0], y [0] >> (matriz ([0.75424625, 0.23148074]), 1)

De acuerdo, tenemos 2 funciones X para 1 año. Para que podamos avanzar sin ningún problema.

Pasos en el modelado de redes neuronales para la clasificación con Tensorflow

En TensorFlow hay etapas fijas para crear un modelo:

• Creando un modelo - junte las capas de una red neuronal utilizando la API funcional o secuencial
• Compilando un modelo - definir cómo se debe medir el rendimiento de un modelo y cómo debe mejorar (función de pérdida y optimizador)
• Ajustar un modol - dejar que un modelo encuentre patrones en los datos

Usaremos la API secuencial. Entonces empecemos

tf.random.set_seed (42)

model_1 = tf.keras.Sequential ([tf.keras.layers.Dense (1)])

 optimizer = tf.keras.optimizers.SGD (), #SGD son las siglas de Stochastic Gradient Descent metrics = ['precisión']) model_1.fit (X, y, epochs = 5)

>> Época 1/5 32/32 [==============================] - 1s 1ms / paso - pérdida: 2.8544 - precisión: 0.4600 Epoch 2/5 32/32 [==============================] - 0s 2ms / paso - pérdida : 0.7131 - precisión: 0.5430 Época 3/5 32/32 [==============================] - 0 s 2ms / paso - pérdida: 0.6973 - precisión: 0.5090 Época 4/5 32/32 [==============================] - 0s 2ms / paso - pérdida: 0.6950 - precisión: 0.5010 Época 5/5 32/32 [==============================] - 0s 1ms / paso - pérdida: 0.6942 - precisión: 0.4830

La precisión del modelo es de aproximadamente el 50%, lo que básicamente significa que el modelo solo está adivinando, intentemos entrenarlo por más tiempo.

model_1.fit (X, y, epochs = 200, verbose = 0) # establecemos verbose = 0 para eliminar el procedimiento de entrenamiento) model_1.evaluate (X, y)

>> 32/32 [==============================] - 0s 1ms / paso - pérdida: 0.6935 - precisión: 0.5000 [0.6934829950332642, 0.5]

Incluso después de 200 épocas, todavía funciona como si estuviera adivinando. El siguiente paso es agregar más capas y entrenar durante más tiempo.

tf.random.set_seed (42)

model_2 = tf.keras.Sequential ([tf.keras.layers.Dense (1), tf.keras.layers.Dense (1)]) model_2.compile (loss = tf.keras.losses.BinaryCrossentropy (), optimizer = tf.keras.optimizers.SGD (), metrics = ['precisión']) model_2.fit (X, y, epochs = 100, verbose = 0)

 model_2.evaluate (X, y)

>> 32/32 [==============================] - 0s 1ms / paso - pérdida: 0.6933 - precisión: 0.5000 [0.6933314800262451, 0.5]

Aún así, no hay ni un pequeño cambio, parece que algo anda mal.

Mejora del modelo de red neuronal para clasificación con Tensorflow

Hay diferentes formas de mejorar un modelo en diferentes etapas:

• Creando un modelo - agregar más capas, aumentar el número de unidades ocultas (neuronas), cambiar las funciones de activación de cada capa
• Compilar un modelo - pruebe diferentes funciones de optimización, por ejemplo, use Adam () en lugar de SGD ().
• Ajuste de un modelo - podríamos aumentar el número de épocas

Vamos a intentar agregar más neuronas y tratar de Adam optimizador

tf.random.set_seed (42)

model_3 = tf.keras.Sequential ([tf.keras.layers.Dense (100), # agrega 100 neuronas densas tf.keras.layers.Dense (10), # agrega otra capa con 10 neuronas tf.keras.layers.Dense (1)]) model_3.compile (loss = tf.keras.losses.BinaryCrossentropy (), optimizer = tf.keras.optimizers.Adam (), metrics = ['precisión']) model_3.fit (X, y, épocas = 100, detallado = 0)

model_3.evaluate (X, y) >> 32/32 [==============================] - 0s 1ms / paso - pérdida: 0.6980 - precisión: 0.5080 [0.6980254650115967, 0.5080000162124634]

¡Todavía no está mejorando! Visualicemos los datos para ver qué está mal.

Visualizar el modelo de red neuronal

Para visualizar las predicciones de nuestro modelo, crearemos una función plot_decision_boundary () que:

• Toma un modelo entrenado, características y etiquetas
• Cree una cuadrícula de los diferentes valores de X.
• Hace predicciones a través de la malla.
• Traza las predicciones con línea.

Nota:   Esta función se ha adaptado de dos recursos:

CS231n Hecho con conceptos básicos de ML 

def plot_decision_boundary (modelo, X, y): # Defina los límites del eje del gráfico y cree una cuadrícula de malla x_min, x_max = X [:, 0] .min () - 0.1, X [:, 0] .max () + 0.1 y_min, y_max = X [:, 1] .min () - 0.1, X [:, 1] .max () + 0.1 xx, yy = np.meshgrid (np.linspace (x_min, x_max, 100), np .linspace (y_min, y_max, 100)) # Crea valores X (vamos a predecir en todos estos) x_in = np.c_ [xx.ravel (), yy.ravel ()] # Haz predicciones usando el model y_pred = model.predict (x_in) # Comprobar si hay varias clases

 if len (y_pred [0])> 1: print ("haciendo clasificación multiclase ...") # Tenemos que remodelar nuestras predicciones para que estén listas para graficar y_pred = np.argmax (y_pred, axis = 1) .reshape ( xx.shape) else: print ("haciendo clasifcación binaria ...") y_pred = np.round (y_pred) .reshape (xx.shape) # Plotear el límite de decisión plt.contourf (xx, yy, y_pred, cmap = plt. cm.RdYlBu, alpha = 0.7) plt.scatter (X [:, 0], X [:, 1], c = y, s = 40, cmap = plt.cm.RdYlBu) plt.xlim (xx.min ( ), xx.max ()) plt.ylim (yy.min (), yy.max ()) plot_decision_boundary (model_3, X, y)

¡Aquí está! Una vez más, la visualización nos muestra qué está mal y qué hacer. Nuestro modelo está tratando de trazar una línea recta a través de los datos, pero nuestros datos no son separables por una línea recta. ¿Hay algo que se está perdiendo en nuestro problema de clasificación? ¿Lo que es?

¡Esto es no linealidad! Necesitamos algunas líneas no lineales. Puede confundirse ahora, si está pensando que no vio ese tipo de función antes, está equivocado, porque lo ha hecho. Veámoslos visualmente. ¡La visualización siempre funciona mejor!

Hay algunas funciones de activación en Neural Network que podemos usar, como ReLu, Sigmoideo. Creemos un poco tensor de juguete y verifique esas funciones en él.

Funciones de activación para redes neuronales

A = tf.cast (tf.range (-12,12), tf.float32) print (A) >> tf.Tensor ([-12. -11. -10. -9. -8. -7. - 6. -5. -4. -3. -2. -1. 0. 1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11.], forma = (24,), dtype = float32)

Veamos cómo se ve nuestro tensor de juguete.

plt.plot (A)

Se ve así, ¡una línea recta! 

Ahora vamos a recrear las funciones de activación para ver qué le hacen a nuestro tensor.

Sigmoideo:

def sigmoide (x): return 1 / (1 + tf.exp (-x)) sigmoide (A) plt.plot (sigmoide (A))

¡Una línea no recta!

ReLu:

def relu (x): return tf.maximum (0, x) plt.plot (relu (A))

¡Otra línea no recta!

Ahora que ha visto funciones de activación no lineales, y estas son las que funcionarán para nosotros, ¡el modelo no puede aprender nada en un conjunto de datos no lineal con funciones de activación lineal! Si ha aprendido esto, es hora de dividir nuestros datos en conjuntos de prueba y entrenamiento y construir modelos sólidos.

X_train, y_train = X [: 800], y [: 800] X_test, y_test = X [800:], y [800:] X_train.shape, X_test.shape >> ((800, 2), (200, 2 ))

tf.random.set_seed (42)

model_4 = tf.keras.Sequential ([tf.keras.layers.Dense (4, activación = 'relu'), # podemos corregirlo "tf.keras.activations.relu" también tf.keras.layers.Dense (4 , activación = 'relu'), tf.keras.layers.Dense (1, activación = 'sigmoide')]) model_4.compile (loss = tf.keras.losses.binary_crossentropy, optimizer = tf.keras.optimizers.Adam ( lr = 0.01), métricas = ['precisión']) model_4.fit (X_train, y_train, epochs = 25, verbose = 0)

Evaluar el modelo

loss, precision = model_4.evaluate (X_test, y_test) print (f 'Pérdida del modelo en el conjunto de prueba: {pérdida}') print (f 'Precisión del modelo en el conjunto de prueba: {100 * exactitud}')

>> 7/7 [==============================] - 0 s 2 ms / paso - pérdida: 0.1247 - precisión: 1.0000 Pérdida de modelo en el equipo de prueba: 0.1246885135769844 Precisión del modelo en el equipo de prueba: 100.0

plt.figure (figsize = (12, 6)) plt.subplot (1, 2, 1) plt.title ("Train") plot_decision_boundary (model_4, X = X_train, y = y_train) plt.subplot (1, 2, 2) plt.title ("Prueba") plot_decision_boundary (model_4, X = X_test, y = y_test) plt.show ()

Echemos un vistazo breve a lo que estamos hablando en este artículo. Juntos, analizamos cómo abordar una tarea de clasificación en la red neuronal con TensorFlow. Creamos 3 modelos de la primera forma que se nos ocurrió, y con la ayuda de la visualización nos dimos cuenta de dónde estábamos equivocados, exploramos la linealidad, la no linealidad y, finalmente, logramos construir un modelo generalizado. Lo que estaba tratando de mostrar con todos estos códigos y los pasos que seguía era que nada es 100 por ciento exacto o fijo, todo sigue cambiando todos los días. Para adivinar qué problema es probable que enfrente en qué tipo de datos y ver qué combinaciones conducen a un mejor resultado, todo lo que necesita es escribir mucho más código y ganar experiencia.

Espero que el artículo te haya sido de alguna ayuda y haya hecho algunas contribuciones.

Los medios que se muestran en este artículo no son propiedad de Analytics Vidhya y se utilizan a discreción del autor.

Relacionado:

Fuente: https://www.analyticsvidhya.com/blog/2021/11/neural-network-for-classification-with-tensorflow/