Perceptrón Simple (Not, AND, OR):

 El Perceptrón

Un perceptrón simple es un tipo de red neuronal artificial que tiene una sola capa de nodos. Cada nodo representa una neurona, y las conexiones entre los nodos representan las sinapsis.

 

La función de activación de un perceptrón simple es generalmente una función lineal, como la función escalón o la función sigmoidea.

Los perceptrones simples se pueden utilizar para implementar funciones booleanas simples, como la negación (NOT), la conjunción (AND) y la disyunción (OR).

Daremos un paso más profundo al introducir el Perceptrón Simple y su aplicación en operadores lógicos NOT, AND y OR. Exploraremos cómo un solo perceptrón puede realizar tareas simples pero fundamentales. Comprenderemos la importancia de los pesos y umbrales en la toma de decisiones y cómo estas unidades básicas son el punto de partida para estructuras más complejas. 

Operador NOT

El modelo tiene una sola capa de neuronas con una sola unidad de salida. La función de activación de la neurona es la función sigmoidea.

Para entrenar el modelo, necesitamos proporcionarle un conjunto de datos de entrenamiento. El conjunto de datos de entrenamiento debe contener dos entradas y una salida.

El siguiente código genera un conjunto de datos de entrenamiento para el operador NOT:

import tensorflow as tf

import numpy as np

# (1) Datos de entrenamiento para NOT

x_not = np.array([[0], [1]])

y_not = np.array([[1], [0]])

# (2) Crear el modelo

model = tf.keras.Sequential([layers.Dense(1, activation='sigmoid')])

# (3) Compilar el modelo

model.compile(optimizer='adam', loss='mse')

# (4) Entrenar el modelo

model.fit(x_not, y_not, epochs=1000)

# (5) Evaluando el modelo con ambas predicciones

result = model.predict(tf.constant([[0], [1]], dtype=tf.float32))

# (6) Mostrar el resultado

print(f"Resultado para NOT(0): {result[0][0].round()}")

print(f"Resultado para NOT(1): {result[1][0].round()}")

Análisis

Después de importar las librerías que necesitamos, (1) generamos el conjunto de datos de entrenamiento para el operador NOT, tanto de entrada como de salida (x_not y y_not). El conjunto de datos de entrenamiento contiene dos entradas, 0 y 1, y una salida, 1 y 0, respectivamente.

(2) Necesitamos crear un modelo de red neuronal simple con una sola capa de neuronas (en nuestro caso una reurona .Dense(1, ...). La función de activación de la neurona será la función sigmoide.

(3) Para que el modelo pueda realizar predicciones, primero debemos compilarlo. La compilación del modelo establece los parámetros de entrenamiento y la función de pérdida.

(4)  Para entrenar el modelo, usamos el método fit(). El método fit() entrena el modelo durante 1000 épocas o repeticiones con diferentes valores.

(5) Una vez que el modelo está entrenado, podemos utilizarlo para realizar predicciones, en este caso, le pasamos dos valores.

(6) Los resultados son:

Resultado para NOT(0): 1.0
Resultado para NOT(1): 0.0

La predicción esta excelente, es importante comprender el proceso de compilación de un modelo de red neuronal para poder utilizarlo de forma efectiva.

Tal vez el ejemplo es muy sencillo, pero ayuda a analizar como trabaja un perceptrón ante un operador tan simple como el NOT. Ahora veamos como funciona con los otros operadores.

Operador AND

El modelo sigue con una sola capa de una neurona con una sola salida. La función de activación de la neurona es la función sigmoidea.

Para entrenar el modelo, el conjunto de datos de entrenamiento incluye 4 entradas.

El siguiente código genera un conjunto de datos de entrenamiento para el operador AND:

import tensorflow as tf

import numpy as np

from tensorflow.keras import layers

# Datos de entrenamiento para AND

x_ent = np.array([[0,0], [0,1], [1,0], [1,1]], "float32")

y_sal = np.array([[0], [0], [0], [1]], "float32")

# Crear el modelo

model = tf.keras.Sequential([layers.Dense(1, activation='sigmoid')])

 

# Compilar el modelo

model.compile(optimizer='adam', loss='mse')

 

# Entrenar el modelo

model.fit(x_ent, y_sal, epochs=1000)

# Evaluando el modelo

result = model.predict(x_ent).round()

# Mostrar el resultado

print('Datos de Entrada')

print(x_ent)

print('Resultado para AND')

print(result)

# otra prueba

x_test = np.array([[1, 1], [1, 0]])

# Realizamos la predicción para x_test

y_pred = model.predict(x_test)

# Imprimimos las predicciones

print(x_test)

print(y_pred.round())

   

Análisis

• El conjunto de datos de entrenamiento contiene cuatro entradas y una salida.
• La primera capa del modelo es una capa densa con una neurona (tf.keras.layers.Dense(1,...).
• La función de activación de la neurona es la función sigmoidea.
• El modelo se compila con el optimizador Adam.
• El modelo se entrena durante 1000 épocas.
• El conjunto de datos de prueba contiene dos tiempos: el primero es general para todas las combinaciones y el segundo solo para dos entradas.
• El modelo realiza predicciones para las entradas de prueba.
• Las predicciones se imprimen en la consola.

 Para el caso del operador AND, contamos con 4 entradas (4 posibles combinaciones) es decir:

Entrada	AND
0, 0	0
0, 1	0
1, 0	0
1, 1	1

Los resultados son:

Datos de Entrada
[[0. 0.]
 [0. 1.]
 [1. 0.]
 [1. 1.]]
Resultado para AND
[[0.]
 [0.]
 [0.]
 [1.]]
1/1 [==============================] - 0s 71ms/step
[[1 1]
 [1 0]]
[[1.]
 [0.]]

La predicción esta de diez. El modelo ha aprendido a implementar el operador AND correctamente.

Hemos logrado crear una red neuronal simple para clasificar los valores del operador AND.

Puedes modificar este código para el operador OR. Cómo lo harías?.

Operador OR

Del código utilizado del operador AND, necesitamos entrenar al modelo con el operador OR, así que, solo cambiamos los datos de entrenamiento.

x_ent = np.array([[0,0], [0,1], [1,0], [1,1]], "float32")

y_sal = np.array([[0], [1], [1], [1]], "float32")

El resto del código es el mismo. El resultado es:

Datos de Entrada
[[0. 0.]
 [0. 1.]
 [1. 0.]
 [1. 1.]]
Resultado para OR
[[0.]
 [1.]
 [1.]
 [1.]]
1/1 [==============================] - 0s 74ms/step
[[1 1]
 [1 0]]
[[1.]
 [1.]]

Con los datos de salida, el modelo ha aprendido a implementar el operador OR correctamente.

 

Hemos logrado crear una red neuronal simple para clasificar los valores del operador OR.

Bien, como podemos ver todo se centra en utilizar las librerías Tensorflow y todos los elementos necesarios para definir el modelo de red, utilizando Keras y sus características como ser Dense, Layers, ... y no nos olvidemos de numpy para trabajar con números y matrices. A seguir practicando