Neurona Sencilla. Fase 1

Neurona Sencilla

La red neuronal más sencilla es la que se conoce como perceptrón de una capa, que consiste en sólo una capa de salida; las entradas en este caso se introducen directamente como una multiplicación de entradas (0's y 1's). Se suman estas multiplicaciones y si es mayor a un umbral la neurona se dispara (se activa).
En general en una neurona sencilla consiste en proporcionarle como parámetros el tamaño del arreglo, un umbral y las entradas de ese arreglo, que para nuestro caso serían 0's o 1's; después se crea un arreglo del mismo tamaño que las entradas pero con números aleatorios entre 0 y 1 que serían los pesos. Luego Se multiplican las entradas por su peso correspondiente y se suman dichas multiplicaciones; ya por último se compara la suma con el umbral y si es mayor al umbral se acepta (arroja un 1), en caso contrario se rechaza (arroja un 0).

Procedimiento

Para la primera fase de una neurona sencilla, el objetivo es no utilizar un umbral establecido globalmente sino que sea una entrada en el vector que se le proporciona como entrada a la neurona.

Como teoría se utilizan las siguientes formulas para saber si la neurona se activa o no, donde $w$ es el vector de pesos y $x$ el vector de entradas:

$w \cdot x >= \theta$

Con un poco de álgebra podemos ver cómo podemos utilizar el umbral en un vector de entrada
$w \cdot x -\theta >= 0$
$w \cdot x+(-1)teta >= 0$

Con esto podemos ver al umbral como un peso extra que está relacionado con una entrada $-1$ , con esto lo que hau que hacer es que necesitamos un vector de $n pesos + 1$

Y ahora para saber conocer la salida y saber si la neurona se activa utilizaríamos las siguientes fórmulas

$w \cdot x >=0 -> y=1$
$w \cdot x < 0 -> y=0$

Código en python

#!/usr/bin/python

from sys import argv
from numpy import *
from numpy.random import *

low = -1
high = 1

class neurona(object):

    #crea vector de pesos
    def getPesos(self,n):
        pesos = uniform(low,high,(1,n+1))#vector de una dimension con n+1 entradas por el umbral
        return pesos

    #crea vector de entradas con 1's y 0's y se le agrega un -1 para el umbral
    def getEntradas(self,n):
        entrada = uniform(low,high,(1,n))
 #print entrada
        entrada = append(entrada, -1.0)
        return entrada

    #función de activacion, se multiplican pesos y entradas
    def Activacion(self,pesos,entrada):
        mult = pesos * entrada
        act = mult.sum()#se suman las multiplicaciones
        return act

    #si act es mayor a cero se aceptan las entradas sino se rechazan
    def Salida(self,act):
        if(act >= 0):
            y = 1
        else:
            y = 0
        return y

    def __init__(self,n,it):
       pesos = self.getPesos(n)
       for i in range (it):
            entrada = self.getEntradas(n)
            act = self.Activacion(pesos,entrada)
            y = self.Salida(act)
            print entrada[0],entrada[1],y

#como argumentos se le proporciona el total de entradas (n) y las veces que se repetiráel proceso (it)
neu = neurona(int(argv[1]) ,int(argv[2]))