FUNCIONES LÓGICAS CON PERCEPTRONES

 

Click aquí GOOGLE COLAB para abrir el recurso

La lógica binaria es la base de la computación digital, operando con valores binarios donde 0 representa "falso" y 1 representa "verdadero". Los perceptrones, una de las estructuras más simples de las redes neuronales, pueden ser usados para modelar operaciones lógicas binarias al procesar y clasificar entradas binarias según reglas específicas. Un perceptrón toma varias entradas binarias, las pondera, y produce una salida única también binaria basada en una función de activación.

Perceptrones para Funciones Lógicas

Un perceptrón simple consta de:

- Entradas: Valores binarios.

- Pesos y sesgo: Cada entrada tiene un peso asignado, y el perceptrón tiene un sesgo.

- Función de activación: Usualmente, una función escalón donde la salida cambia de 0 a 1 en un cierto umbral.

La salida del perceptrón se calcula como la suma ponderada de sus entradas, más el sesgo, pasando este resultado por la función de activación. Matemáticamente, para una entrada \(x\) con pesos \(w\) y sesgo \(b\), la salida \(y\) es:

\[y = f(\sum (w \cdot x) + b)\]

Donde \(f\) es la función de activación.

Implementando Funciones Lógicas con Python

Para modelar funciones lógicas básicas como NOT, AND, NAND, OR, NOR, y XOR con perceptrones, definimos cada función ajustando los pesos y el sesgo. A continuación, se muestra cómo implementar estas funciones lógicas en Python:

```python

import numpy as np

def perceptron(x, w, b):

    """Función del perceptrón."""

    suma_ponderada = np.dot(x, w) + b

    return 1 if suma_ponderada >= 0 else 0

# Funciones lógicas

def NOT(x):

    return perceptron(x, w=-1, b=0.5)

def AND(x1, x2):

    return perceptron(np.array([x1, x2]), w=np.array([1, 1]), b=-1.5)

def NAND(x1, x2):

    return perceptron(np.array([x1, x2]), w=np.array([-2, -2]), b=3)

def OR(x1, x2):

    return perceptron(np.array([x1, x2]), w=np.array([2, 2]), b=-1)

def NOR(x1, x2):

    return perceptron(np.array([x1, x2]), w=np.array([-2, -2]), b=1)

# XOR no se puede modelar con un solo perceptrón debido a su linealidad

# Pero para propósitos educativos, se muestra una aproximación

# usando perceptrones múltiples (esto requiere una red más compleja)

def XOR(x1, x2):

    s1 = NAND(x1, x2)

    s2 = OR(x1, x2)

    return AND(s1, s2)

# Prueba de las funciones lógicas

print("NOT(1):", NOT(1))

print("AND(1, 0):", AND(1, 0))

print("NAND(1, 1):", NAND(1, 1))

print("OR(0, 0):", OR(0, 0))

print("NOR(0, 1):", NOR(0, 1))

print("XOR(1, 0):", XOR(1, 0))

```

Explicación

- NOT: Invierte el valor de entrada. Usa un peso negativo y un sesgo positivo para cambiar el umbral de activación.

- AND: Devuelve 1 si ambas entradas son 1. Requiere que ambos pesos sean positivos y el sesgo sea lo suficientemente negativo para activarse solo si ambas entradas son verdaderas.

- NAND: Es el inverso de AND, utilizando pesos y sesgo ajustados para activarse excepto cuando ambas entradas son verdaderas.

- **OR:** Devuelve 1 si alguna de las entradas es 1. Los pesos positivos y un sesgo menor permiten activarlo con al menos una entrada verdadera.

- NOR: Inverso de OR, con pesos negativos y un sesgo positivo para activarse solo si ambas entradas son falsas.

- XOR: No es linealmente separable, por lo que no se puede modelar con un solo perceptrón. Sin embargo, combinando NAND, OR y AND, se puede simular el comportamiento XOR.

Esta implementación demuestra cómo los perceptrones pueden modelar operaciones lógicas básicas, siendo los bloques de construcción fundamentales para redes neuronales más complejas.