Redes Neuronales: vista rápida de implementación

Este post tiene como objetivo proporcionar una comprensión simple de las redes neuronales convolucionales (CNN). Esto se logrará en el siguiente orden:

• Entendiendo la operación de convolución
• Entendiendo las redes neuronales
• Pre-procesamiento de los datos
• Entendiendo el CNN utilizado
• Entendiendo los optimizadores
• Comprensión ImageDataGenerator
• Realizando las predicciones y calculando la precisión.
• Viendo una red neuronal en acción

¿Qué es la convolución?

En matemáticas (y, en particular, el análisis funcional), la convolución es una operación matemática en dos funciones (f y g) para producir una tercera función que expresa cómo la forma de una es modificada por la otra.

Esta operación se utiliza en varias áreas, como probabilidad, estadísticas, visión artificial, procesamiento de lenguaje natural, procesamiento de imágenes y señales, ingeniería y ecuaciones diferenciales.

Compruebe este enlace para una comprensión visual de la operación de convolución.

¿Qué son las redes neuronales artificiales?

Las redes neuronales artificiales (ANN) o los sistemas conexionistas son sistemas informáticos vagamente inspirados en las redes neuronales biológicas que constituyen los cerebros de los animales. Dichos sistemas “aprenden” a realizar tareas considerando ejemplos, generalmente sin estar programados con ninguna regla específica de la tarea.

(Fuente: Wikipedia )

Una redes neuronal artificial (ANN) es una colección de unidades de procesamiento más pequeñas llamadas neuronas artificiales que se asemejan a la neurona biológica.

Circuito Neuronal Biológico

Un circuito neuronal (también conocido como red neuronal biológica BNNs ) es una población de neuronas interconectadas por sinapsis para llevar a cabo una función específica cuando se activan. ^[1] Múltiples circuitos neuronales se interconectan entre sí para formar redes cerebrales a gran escala . 

Los circuitos neuronales han inspirado el diseño de redes neuronales artificiales , aunque existen diferencias significativas.

Una colección de circuitos interconectados forman una red

Redes neuronales artificiales

Las redes neuronales artificiales ( RNA , también abreviadas como redes neuronales (NN) o redes neuronales ) son una rama de los modelos de aprendizaje automático que se construyen utilizando principios de organización neuronal descubiertos por el conexionismo en las redes neuronales biológicas que constituyen los cerebros de los animales .

Una ANN se basa en una colección de unidades o nodos conectados llamados neuronas artificiales , que modelan vagamente las neuronas de un cerebro biológico. Cada conexión, como las sinapsis en un cerebro biológico, puede transmitir una señal a otras neuronas. Una neurona artificial recibe señales, luego las procesa y puede enviar señales a las neuronas conectadas a ella.

La “señal” en una conexión es un número real y la salida de cada neurona se calcula mediante alguna función no lineal de la suma de sus entradas. Las conexiones se llaman aristas .

Las neuronas y los bordes suelen tener un peso que se ajusta a medida que avanza el aprendizaje. El peso aumenta o disminuye la intensidad de la señal en una conexión. Las neuronas pueden tener un umbral tal que se envíe una señal sólo si la señal agregada cruza ese umbral.

Normalmente, las neuronas se agregan en capas. Diferentes capas pueden realizar diferentes transformaciones en sus entradas. Las señales viajan desde la primera capa (la capa de entrada) hasta la última capa (la capa de salida), posiblemente después de atravesar las capas varias veces.

Ahora , comenzamos con la implementación.

Importando las librerías necesarias.

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns

import tflearn.data_utils as du
from keras.models import Sequential
from keras.layers import Dense, Dropout, Flatten, Conv2D, MaxPool2D
from keras.optimizers import RMSprop
from keras.preprocessing.image import ImageDataGenerator
from sklearn.metrics import confusion_matrix

Carga del conjunto de datos

train_data = pd.read_csv('../input/csvTrainImages 13440x1024.csv', header = None)
train_label = pd.read_csv('../input/csvTrainLabel 13440x1.csv', header = None)
test_data = pd.read_csv('../input/csvTestImages 3360x1024.csv', header = None)
test_label = pd.read_csv('../input/csvTestLabel 3360x1.csv', header = None)

Redes Neuronales: El Dataset

El conjunto de datos utilizado aquí es el conjunto de datos de caracteres escritos a mano en árabe .

El trainImages.csv tiene 1024 columnas y 13440 filas. Cada columna representa un píxel en una imagen y cada fila representa una imagen individual en escala de grises. El valor de cada píxel varía de 0 -255.

train_data = train_data.iloc[:,:].values.astype('float32')
train_label = train_label.iloc[:,:].values.astype('int32')-1
test_data = test_data.iloc[:,:].values.astype('float32')
test_label = test_label.iloc[:,:].values.astype('int32')-1

Visualizando el conjunto de datos

def row_calculator(number_of_images, number_of_columns):
    if number_of_images % number_of_columns != 0:
        return (number_of_images / number_of_columns)+1
    else:
        return (number_of_images / number_of_columns)

def display_image(x, img_size, number_of_images):
    plt.figure(figsize = (8, 7))
    if x.shape[0] > 0:
        n_samples = x.shape[0]
        x = x.reshape(n_samples, img_size, img_size)
        number_of_rows = row_calculator(number_of_images, 4)
        for i in range(number_of_images):
            plt.subplot(number_of_rows, 4, i+1)
            plt.imshow(x[i])

El conjunto de entrenamiento

display_image(train_data, 32, 16)

El conjunto de prueba

display_image(test_data, 32, 16)

Preprocesamiento de datos

Redes Neuronales: Codificación de variables categóricas

¿Qué son las variables categóricas?

En estadística, una variable categórica es una variable que puede tomar uno de un número limitado y generalmente fijo de valores posibles, asignando cada individuo u otra unidad de observación a un grupo particular o categoría nominal sobre la base de alguna propiedad cualitativa.

En términos simples, el valor de una variable categórica representa una categoría o clase.

¿Por qué necesitamos codificar las variables categóricas?

No tiene sentido realizar operaciones en un número que representa una categoría. Por lo tanto, la codificación categórica debe hacerse.

Echa un vistazo a este enlace en stackoverflow para entender con un ejemplo.

Hay 28 letras en el alfabeto árabe. Por lo tanto, hay 28 clases.

train_label = du.to_categorical(train_label,28)

Normalización

¿Qué es la normalización?

La normalización se realiza para llevar todos los datos a un rango bien definido, preferiblemente entre 0 y 1

En las redes neuronales, es una buena idea no solo normalizar los datos, sino también escalarlos. Esto está destinado a acercarse más rápidamente a los mínimos globales en la superficie de error.

(Fuente: desbordamiento de pila )

train_data = train_data/255
test_data = test_data/255

train_data = train_data.reshape([-1, 32, 32, 1])
test_data = test_data.reshape([-1, 32, 32, 1])

Se realiza una remodelación para que los datos representen una imagen 2D:

train_data, mean1 = du.featurewise_zero_center(train_data)
test_data, mean2 = du.featurewise_zero_center(test_data)

El Centro de Zero con características se realiza para centrar a cero cada muestra con la media especificada. Si no se especifica, la media se evalúa en todas las muestras.

Construyendo redes neuronales (CNN)

recognizer = Sequential()

recognizer.add(Conv2D(filters = 32, kernel_size = (5,5),padding = 'Same', activation ='relu', input_shape = (32,32,1)))
recognizer.add(Conv2D(filters = 32, kernel_size = (5,5),padding = 'Same', activation ='relu'))
recognizer.add(MaxPool2D(pool_size=(2,2)))
recognizer.add(Dropout(0.25))

recognizer.add(Conv2D(filters = 64, kernel_size = (3,3),padding = 'Same', activation ='relu'))
recognizer.add(Conv2D(filters = 64, kernel_size = (3,3),padding = 'Same', activation ='relu'))
recognizer.add(MaxPool2D(pool_size=(2,2), strides=(2,2)))
recognizer.add(Dropout(0.25))

recognizer.add(Flatten())
recognizer.add(Dense(units = 256, input_dim = 1024, activation = 'relu'))
recognizer.add(Dense(units = 256, activation = "relu"))
recognizer.add(Dropout(0.5))
recognizer.add(Dense(28, activation = "softmax"))

Redes neuronales: ¿Qué es Max Pooling?

Pooling significa combinar un conjunto de datos. El proceso de combinación de datos sigue algunas reglas.

Por definición, max pool toma el valor máximo de una cuadrícula definida.

La agrupación máxima se utiliza para reducir las dimensiones. También puede evitar el exceso de ajuste.

¿Qué es Dropout?

Dropout es una técnica de regularización para reducir el sobreajuste en redes neuronales al evitar complejas adaptaciones en los datos de entrenamiento. Es una forma muy eficiente de realizar promedios de modelos con redes neuronales convolucionales (CNN). El término “abandono” se refiere al abandono de unidades (tanto ocultas como visibles) en redes neuronales.

( Fuente: Wikipedia ) 

¿Qué es Flatten?

Flatten se realiza para convertir los datos multidimensionales en un vector de características 1D para ser utilizado por la siguiente capa que es la capa densa

¿Qué es una capa densa?

La capa densa es solo una capa de red neuronal artificial

Optimizador de redes neuronales convolusionales (CNN)

¿Qué es un optimizador?

Los algoritmos de optimización nos ayudan a minimizar (o maximizar) una función Objetivo (otro nombre para la función Error).

E (x) que es simplemente una función matemática que depende de los parámetros de aprendizaje interno del Modelo que se utilizan para calcular los valores objetivo (Y) a partir del conjunto de predictores (X) utilizados en el modelo.

Por ejemplo, llamamos a los valores de Pesos (W) y Sesgo (b) de la red neuronal como sus parámetros de aprendizaje interno que se utilizan para calcular los valores de salida y se aprenden y actualizan en la dirección de solución óptima, es decir, minimizando la Pérdida el proceso de formación de la red y también desempeña un papel importante en el proceso de formación del modelo de red neuronal.

optimizer = RMSprop(lr=0.001, rho=0.9, epsilon=1e-08, decay=0.0)

El optimizador utilizado aquí es un RMSprop.

recognizer.compile(optimizer = optimizer , loss = "categorical_crossentropy", metrics=["accuracy"])

¿Qué es ImageDataGenerator?

El generador de datos de imagen es utilizado para generar lotes de datos de imagen de tensor con aumento en tiempo real. Este dato se bifurca en lotes.

Se utiliza para cargar las imágenes en lotes.

datagen = ImageDataGenerator(
        featurewise_center=False, 
        samplewise_center=False,  
        featurewise_std_normalization=False,
        samplewise_std_normalization=False,
        zca_whitening=False,
        rotation_range=10,
        zoom_range = 0.1,  
        width_shift_range=0.1, 
        height_shift_range=0.1,
        horizontal_flip=False,
        vertical_flip=False)

datagen.fit(train_data)

Ajuste de redes neuronales convolusionales (CNN) a los datos de entrenamiento

recognizer.fit_generator(datagen.flow(train_data,train_label, batch_size=100), epochs = 30, verbose = 2, steps_per_epoch=train_data.shape[0] // 100)

Haciendo las predicciones

predictions = recognizer.predict(test_data)
predictions = np.argmax(predictions,axis = 1)

Generando una matriz de confusión

¿Qué es una matriz de confusión?

Una matriz de confusión es una técnica para resumir el rendimiento de un algoritmo de clasificación.

La precisión de la clasificación por sí sola puede ser engañosa si tiene una cantidad desigual de observaciones en cada clase o si tiene más de dos clases en su conjunto de datos.

Calcular una matriz de confusión puede darle una mejor idea de cuál es su modelo de clasificación y qué tipo de errores está cometiendo.

cm = confusion_matrix(test_label, predictions)

Cálculo de Accuracy

accuracy = sum(cm[i][i] for i in range(28)) / test_label.shape[0]
print("accuracy = " + str(accuracy))

Una precisión del 97% se obtuvo

Viendo una redes neuronales convolucionales (CNN) en acción

Para ver el funcionamiento de las redes neuronales convolucionales en tiempo real, consulte este enlace . Muestra el funcionamiento de una red neuronal convolucional que está entrenada para reconocer dígitos escritos a mano.