Google+ Seguidores

miércoles, 8 de agosto de 2018

Introducción a las Redes Neuronales: Parte #2 - Red Neurona para el reconocimiento de patrones

Introducción:

Ya hemos adquirido los conocimientos suficientes para crear nuestro primer perceptrón, y lo hicimos de manera fácil y comprensible.

Lo siguiente que haremos, sera programar una red neuronal para el reconocimiento de patrones. 

Utilizaremos la librería numpy, de la cual utilizaremos algunos métodos para ahorrar algo de tiempo. Aunque te darás cuenta que son métodos que se pueden implementar de manera rápida en una función, todo depende de ti.

Por ultimo quiero advertirles que utilizaremos la función de activación sigmoide. Ya hemos hablado de las funciones de activación y de la función sigmoide en la parte #1 de la guía.


Red Neuronal para el reconocimiento de patrones:

¿A que me refiero con "Reconocimiento de Patrones"? 

111 = 1
101 = 1
011 = 0
010 = 0

El cerebro humano tiene la capacidad de aprender de su entorno gracias a que podemos reconocer patrones de manera rápida. 

En secuencia mostrada anteriormente, podemos ver un patrón muy sencillo. Si la cadena comienza o termina con el uno (1), esta cadena o datos, se clasificara como "1". Si la cadena empieza o termina con un cero (0) se clasificara como "0".

Nuestro objetivo es programar una red neuronal que pueda hacer lo que nosotros hemos hecho, reconocer este patrón.

# Importamos los métodos de numpy que utilizaremos
from numpy import exp, array, random, dot

# exp: Calcular la exponencialidad de los elementos de la matriz de entrada
# dot: Método para realizar producto de matrices

class neural_network_patterns():
    def __init__(self):
        random.seed(1)
        # Pesos iniciales
        # Red neuronal con 3 entradas y una salida
        self.weights = 2 * random.random((3,1)) - 1
        
    def sigmoide(self, x):
        return 1 / (1 + exp(-x))
    
    def train(self, inputs, outputs, num):
        for i in range(num): # Iteración
            output = self.prediction(inputs) # Salida 
            error = outputs - output # Calculo de error
            # Ajustamos los pesos
            # Formula: error * input * output * (1-output)
            ajuste = dot(inputs.T, error * output * (1-output)) 
            self.weights += ajuste
            
    def prediction(self, inputs):
        # Función sigmoide
        resultado = self.sigmoide(dot(inputs, self.weights))
        return resultado

# Instancia de nuestra clase
red = neural_network_patterns()

# Datos de entrenamiento
inputs = array([[1,1,1],[1,0,1],[0,1,1]])
outputs = array([[1,1,0]]).T # Salidas de los datos de entrenamiento
        
# Entrenamiento de la red neuronal
# inputs = datos de entrada
# outputs = salida de cada entrada
# 10000 = cuantas veces se repetira el entrenamiento de la red
red.train(inputs, outputs, 10000)

# Prueba 1
pre_1 = red.prediction(array([1,1,1]))[0]

# Prueba 2
pre_2 = red.prediction(array([0,1,0]))[0]

# round nos permitira redondear el numero
# y saber con más precisión la predicción
print("[1,1,1] = %s" % round(pre_1))
print("[0,1,0] = %s" % round(pre_2))


[1,1,1] = 1.0
[0,1,0] = 0.0


¿Alguna duda? No dudes en dejar tu comentario.

No hay comentarios :
Write comentarios

Tu comentario es importante y nos motiva a seguir escribiendo...

Powered by Blogger .