IA con Python: redes neuronales

Las redes neuronales son dispositivos informáticos paralelos que intentan crear un modelo informático del cerebro. El principal objetivo detrás es desarrollar un sistema para realizar varias tareas computacionales más rápido que los sistemas tradicionales. Estas tareas incluyen el reconocimiento y clasificación de patrones, la aproximación, la optimización y la agrupación de datos.

¿Qué son las redes neuronales artificiales (ANN)?

La red neuronal artificial (ANN) es un sistema informático eficiente cuyo tema central se toma prestado de la analogía de las redes neuronales biológicas. Las RNA también se denominan sistemas neuronales artificiales, sistemas de procesamiento distribuido en paralelo y sistemas conexionistas. ANN adquiere una gran colección de unidades que están interconectadas en algún patrón para permitir las comunicaciones entre ellas. Estas unidades, también denominadasnodes o neurons, son procesadores simples que operan en paralelo.

Cada neurona está conectada con otra neurona a través de un connection link. Cada enlace de conexión está asociado con un peso que tiene la información sobre la señal de entrada. Esta es la información más útil para que las neuronas resuelvan un problema en particular porque elweightnormalmente excita o inhibe la señal que se está comunicando. Cada neurona tiene su estado interno que se llamaactivation signal. Las señales de salida, que se producen después de combinar las señales de entrada y la regla de activación, pueden enviarse a otras unidades.

Si desea estudiar las redes neuronales en detalle, puede seguir el enlace: Red neuronal artificial .

Instalación de paquetes útiles

Para crear redes neuronales en Python, podemos usar un paquete poderoso para redes neuronales llamado NeuroLab. Es una biblioteca de algoritmos básicos de redes neuronales con configuraciones de red flexibles y algoritmos de aprendizaje para Python. Puede instalar este paquete con la ayuda del siguiente comando en el símbolo del sistema:

pip install NeuroLab

Si está utilizando el entorno Anaconda, utilice el siguiente comando para instalar NeuroLab:

conda install -c labfabulous neurolab

Construyendo redes neuronales

En esta sección, construiremos algunas redes neuronales en Python usando el paquete NeuroLab.

Clasificador basado en perceptrón

Los perceptrones son los componentes básicos de la ANN. Si quieres saber más sobre Perceptron, puedes seguir el enlace - artificial_neural_network

A continuación se muestra una ejecución paso a paso del código Python para construir un clasificador simple basado en perceptrones de redes neuronales:

Importe los paquetes necesarios como se muestra:

import matplotlib.pyplot as plt
import neurolab as nl

Ingrese los valores de entrada. Tenga en cuenta que es un ejemplo de aprendizaje supervisado, por lo que también deberá proporcionar valores objetivo.

input = [[0, 0], [0, 1], [1, 0], [1, 1]]
target = [[0], [0], [0], [1]]

Crea la red con 2 entradas y 1 neurona -

net = nl.net.newp([[0, 1],[0, 1]], 1)

Ahora, entrena la red. Aquí, estamos usando la regla Delta para el entrenamiento.

error_progress = net.train(input, target, epochs=100, show=10, lr=0.1)

Ahora, visualice la salida y trace el gráfico:

plt.figure()
plt.plot(error_progress)
plt.xlabel('Number of epochs')
plt.ylabel('Training error')
plt.grid()
plt.show()

Puede ver el siguiente gráfico que muestra el progreso del entrenamiento utilizando la métrica de error:

Redes neuronales de una sola capa

En este ejemplo, estamos creando una red neuronal de una sola capa que consta de neuronas independientes que actúan sobre los datos de entrada para producir la salida. Tenga en cuenta que estamos usando el archivo de texto llamadoneural_simple.txt como nuestra entrada.

Importe los paquetes útiles como se muestra:

import numpy as np
import matplotlib.pyplot as plt
import neurolab as nl

Cargue el conjunto de datos de la siguiente manera:

input_data = np.loadtxt(“/Users/admin/neural_simple.txt')

Los siguientes son los datos que vamos a utilizar. Tenga en cuenta que en estos datos, las dos primeras columnas son las características y las dos últimas columnas son las etiquetas.

array([[2. , 4. , 0. , 0. ],
      [1.5, 3.9, 0. , 0. ],
      [2.2, 4.1, 0. , 0. ],
      [1.9, 4.7, 0. , 0. ],
      [5.4, 2.2, 0. , 1. ],
      [4.3, 7.1, 0. , 1. ],
      [5.8, 4.9, 0. , 1. ],
      [6.5, 3.2, 0. , 1. ],
      [3. , 2. , 1. , 0. ],
      [2.5, 0.5, 1. , 0. ],
      [3.5, 2.1, 1. , 0. ],
      [2.9, 0.3, 1. , 0. ],
      [6.5, 8.3, 1. , 1. ],
      [3.2, 6.2, 1. , 1. ],
      [4.9, 7.8, 1. , 1. ],
      [2.1, 4.8, 1. , 1. ]])

Ahora, separe estas cuatro columnas en 2 columnas de datos y 2 etiquetas:

data = input_data[:, 0:2]
labels = input_data[:, 2:]

Trace los datos de entrada usando los siguientes comandos:

plt.figure()
plt.scatter(data[:,0], data[:,1])
plt.xlabel('Dimension 1')
plt.ylabel('Dimension 2')
plt.title('Input data')

Ahora, defina los valores mínimo y máximo para cada dimensión como se muestra aquí:

dim1_min, dim1_max = data[:,0].min(), data[:,0].max()
dim2_min, dim2_max = data[:,1].min(), data[:,1].max()

A continuación, defina el número de neuronas en la capa de salida de la siguiente manera:

nn_output_layer = labels.shape[1]

Ahora, defina una red neuronal de una sola capa:

dim1 = [dim1_min, dim1_max]
dim2 = [dim2_min, dim2_max]
neural_net = nl.net.newp([dim1, dim2], nn_output_layer)

Entrene la red neuronal con el número de épocas y la tasa de aprendizaje como se muestra:

error = neural_net.train(data, labels, epochs = 200, show = 20, lr = 0.01)

Ahora, visualice y trace el progreso del entrenamiento usando los siguientes comandos:

plt.figure()
plt.plot(error)
plt.xlabel('Number of epochs')
plt.ylabel('Training error')
plt.title('Training error progress')
plt.grid()
plt.show()

Ahora, use los puntos de datos de prueba en el clasificador anterior:

print('\nTest Results:')
data_test = [[1.5, 3.2], [3.6, 1.7], [3.6, 5.7],[1.6, 3.9]] for item in data_test:
   print(item, '-->', neural_net.sim([item])[0])

Puede encontrar los resultados de la prueba como se muestra aquí:

[1.5, 3.2] --> [1. 0.]
[3.6, 1.7] --> [1. 0.]
[3.6, 5.7] --> [1. 1.]
[1.6, 3.9] --> [1. 0.]

Puede ver los siguientes gráficos como resultado del código discutido hasta ahora:

Redes neuronales multicapa

En este ejemplo, estamos creando una red neuronal multicapa que consta de más de una capa para extraer los patrones subyacentes en los datos de entrenamiento. Esta red neuronal multicapa funcionará como un regresor. Vamos a generar algunos puntos de datos basados ​​en la ecuación: y = 2x ² +8.

Importe los paquetes necesarios como se muestra:

import numpy as np
import matplotlib.pyplot as plt
import neurolab as nl

Genere algún punto de datos basado en la ecuación mencionada anteriormente:

min_val = -30
max_val = 30
num_points = 160
x = np.linspace(min_val, max_val, num_points)
y = 2 * np.square(x) + 8
y /= np.linalg.norm(y)

Ahora, modifique este conjunto de datos de la siguiente manera:

data = x.reshape(num_points, 1)
labels = y.reshape(num_points, 1)

Visualice y grafique el conjunto de datos de entrada usando los siguientes comandos:

plt.figure()
plt.scatter(data, labels)
plt.xlabel('Dimension 1')
plt.ylabel('Dimension 2')
plt.title('Data-points')

Ahora, construya la red neuronal con dos capas ocultas con neurolab con ten neuronas en la primera capa oculta, six en la segunda capa oculta y one en la capa de salida.

neural_net = nl.net.newff([[min_val, max_val]], [10, 6, 1])

Ahora use el algoritmo de entrenamiento de gradiente -

neural_net.trainf = nl.train.train_gd

Ahora entrene a la red con el objetivo de aprender sobre los datos generados anteriormente:

error = neural_net.train(data, labels, epochs = 1000, show = 100, goal = 0.01)

Ahora, ejecute las redes neuronales en los puntos de datos de entrenamiento:

output = neural_net.sim(data)
y_pred = output.reshape(num_points)

Ahora trazar y visualizar la tarea -

plt.figure()
plt.plot(error)
plt.xlabel('Number of epochs')
plt.ylabel('Error')
plt.title('Training error progress')

Ahora graficaremos la salida real frente a la prevista:

x_dense = np.linspace(min_val, max_val, num_points * 2)
y_dense_pred = neural_net.sim(x_dense.reshape(x_dense.size,1)).reshape(x_dense.size)
plt.figure()
plt.plot(x_dense, y_dense_pred, '-', x, y, '.', x, y_pred, 'p')
plt.title('Actual vs predicted')
plt.show()

Como resultado de los comandos anteriores, puede observar los gráficos como se muestra a continuación: