Descripción general de la implementación de redes neuronales
Las redes neuronales artificiales están inspiradas en redes neuronales biológicas. Las redes neuronales ayudan a resolver los problemas sin ser programados con las reglas y condiciones específicas del problema. Son modelos genéricos con la mayoría de los cálculos matemáticos complejos como BlackBox. Los diferentes tipos de redes neuronales son como la red neuronal de convolución, la red neuronal recurrente, la red neuronal Feedforward, el perceptrón multicapa y muchos otros. En este tema, estamos dispuestos a aprender sobre la implementación de redes neuronales.
La arquitectura de las redes neuronales
Hay 3 capas principalmente en redes neuronales.
- Capa de entrada
- Capas ocultas
- Capa de salida
1. Capa de entrada: la capa de entrada contiene las neuronas para la entrada de características. También hay un sesgo agregado a la capa de entrada además de las características. Entonces, si hay n características, entonces la capa de entrada contiene n + 1 neuronas.
2. Capa oculta: las capas ocultas son las capas intermedias entre las capas de entrada y salida. Puede haber cualquier cantidad de capas ocultas. La red con más de una capa oculta se denomina redes neuronales profundas. Las neuronas en la capa oculta obtienen información de la capa de entrada y dan salida a la capa de salida.
3. Capa de salida: la capa de salida contiene el número de neuronas en función del número de clases de salida. Si se trata de un problema de clasificación de varias clases, entonces contiene el número de neuronas igual al número de clases. Para la clasificación binaria, contiene una neurona.
Las entradas se multiplican con pesos y luego se alimentan a la siguiente capa oculta. El sesgo también se proporciona como entrada junto con entradas ponderadas. La suma ponderada se pasa a través de una función no lineal llamada función de activación.
Ejemplo de implementacion
Aquí está el ejemplo de implementación mencionado a continuación
Instalación de bibliotecas
Existen muchas bibliotecas integradas para la implementación de redes neuronales artificiales en diferentes lenguajes de programación. Aquí hablaremos de dos de las famosas bibliotecas tensorflow y Keras que usan python como lenguaje de programación para la implementación de redes neuronales. Keras es una compilación de API de nivel superior en tensorflow o theano como backend. Es mucho más fácil de implementar. Puede elegir cualquiera de las bibliotecas para su modelo. Hay algunos otros también disponibles como PyTorch, theano, Caffe y muchos más.
Para instalar el tensorflow / Keras usando pip, ejecute el siguiente comando:
pip install tensorflow
pip install Keras
Alternativamente, se puede instalar usando el comando conda,
conda install -c conda-forge tensorflow
conda install -c conda-forge keras
Implementación
Aquí hablaremos de Keras para la generación de los modelos de aprendizaje profundo. Es una biblioteca de aprendizaje profundo de código abierto de Python.
- Importe el conjunto de datos MNIST disponible. MNIST es el conjunto de datos de números escritos a mano de dígitos en inglés.
from tensorflow.examples.tutorials.mnist import input_data
train_images = mnist.train.images.reshape(mnist.train.images.shape(0), image_rows, image_cols, 1)
test_images = mnist.test.images.reshape(mnist.test.images.shape(0), image_rows, image_cols, 1)
- Inicialice los parámetros e hiperparámetros necesarios para el modelo.
- Luego, inicialice el modelo de aprendizaje profundo.
model = Sequential()
- Agregue la capa de convolución, la capa de activación y la capa de agrupación máxima para cada una de las capas de convolución que estamos agregando entre la capa de entrada y la de salida (capas ocultas). Aquí estamos agregando dos capas de convolución.
model.add(Convolution2D(num_filters, conv_kernel_size(0), conv_kernel_size(1), border_mode='valid', input_shape=imag_shape))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=max_pool_size))
- Se pueden utilizar diferentes funciones de activación según el problema. Algunas funciones de activación comunes son la activación de relu, la activación de tanh, la fuga de relu, y muchas otras.
- Luego viene una capa completamente conectada antes de la capa densa. Recopilan los datos extraídos por las capas anteriores para formar el resultado final.
- La dimensión de la capa de salida depende del número de clases. Las funciones de activación utilizadas para la capa de salida son generalmente la activación sigmoidea para la clasificación binaria y la activación softmax para la clasificación de múltiples clases.
model.add(Dense(num_classes))
model.add(Activation('softmax'))
El código completo para la red neuronal convolucional profunda para la clasificación de datos MNIST es el siguiente.
from tensorflow.examples.tutorials.mnist import input_data
from keras.models import Sequential from keras.layers import Dense, Dropout, Activation, Flatten from keras.layers import Convolution2D, MaxPooling2D
# we use TF helper function to pull down the data from the MNIST site mnist_data = input_data.read_data_sets("MNIST_data/", one_hot=True)
img_rows = 28
img_cols = 28
# Reshape training and test images to 28x28x1
train_images = mnist_data.train.images.reshape(mnist_data.train.images.shape(0), img_rows, img_cols, 1)
test_images = mnist_data.test.images.reshape(mnist_data.test.images.shape(0), img_rows, img_cols, 1)
num_of_filters = 32 # No. of conv filters maxPoolSize = (2, 2) # shape of max_pool convKrnSize = (3, 3) # conv kernel shape imgShape = (28, 28, 1) num_of_classes = 10
dropProb = 0.5
model = Sequential()
# define layers in NN
# Define 1st convolution layer.
model.add(Convolution2D(num_of_filters, convKrnSize(0), convKrnSize(1), border_mode='valid', input_shape=imgShape))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=maxPoolSize))
# 2nd Convolution Layer
model.add(Convolution2D(num_of_filters, convKrnSize(0), convKrnSize(1))) model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=maxPoolSize))
#Fully Connected Layer model.add(Flatten())
model.add(Dense(128)) #Fully connected layer in Keras model.add(Activation('relu'))
# Dropout some neurons to reduce overfitting model.add(Dropout(dropProb))
#Readout Layer model.add(Dense(num_of_classes))
model.add(Activation('softmax'))
# Compile the model
model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=('accuracy'))
# Training settings batch_size = 128
num_of_epoch = 2
# fit the training data to the model.
model.fit(train_images, mnist_data.train.labels, batch_size=batch_size,
nb_epoch=num_of_epoch, verbose=1, validation_data=(test_images, mnist_data.test.labels))
# predict the test_data using the model
test_labels_predicted = model.predict_classes(test_images)
# To get the predicted labels of all test images for i in range(len(test_images)):
print ("Image () -> Label ()".format(i+1, test_labels_predicted(0)))
Formación
El entrenamiento del modelo se ve así,
Conclusión - Implementación de redes neuronales
Las redes neuronales proporcionan una forma fácil de problemas de clasificación o regresión en el aprendizaje automático cuando el espacio de características de las muestras es muy grande, principalmente para imágenes grandes u otros medios o señales.
Artículos recomendados
Esta es una guía para la implementación de redes neuronales. Aquí discutimos la arquitectura e implementación de las redes neuronales con un modelo de capacitación y un código de muestra. También puede consultar el siguiente artículo para obtener más información:
- Clasificación de la red neuronal
- ¿Qué son las redes neuronales?
- Redes neuronales convolucionales
- Algoritmos de red neuronal
- Gráficos 2D en Java