See discussions, stats, and author profiles for this publication at: https://www.researchgate.

net/publication/320517270

Implementación función XOR con Perceptrón en Arduino.

Article · October 2017

CITATIONS READS
0 688

1 author:

Siloni Hebreo Castellanos

Universidad Politécnica de Puebla
2 PUBLICATIONS   0 CITATIONS   

SEE PROFILE

All content following this page was uploaded by Siloni Hebreo Castellanos on 20 October 2017.

The user has requested enhancement of the downloaded file.

Autor: Israel Cerón Morales

Código de entrenamiento de Neurona

Siloni Hebreo Castellanos

INTRODUCCIÓN

Las Redes de Neuronas o Redes Neuronales (en la inteligencia artificial) son un

paradigma de aprendizaje y procesamiento automático, inspirado en la forma en
que funciona el sistema nervioso de los animales. Se trata de un sistema de
interconexiones de neuronas que colaboran entre sí para producir una salida.

Como bien sabemos la inteligencia artificial, pretende imitar la inteligencia natural,

por tanto en este caso las redes neuronales pretenden imitar la "arquitectura"
cerebral (neuronas+conexiones) que dan inteligencia a las personas. Es cierto que
el termino inteligencia es bastante ambiguo, pero en este caso en el que hablamos
de redes neuronales, consideraremos inteligencia a aquellas personas que
sabiendo de un cierto tema, sean capaces de dar una respuesta a una
problematizada dada (calculo, clasificación, etc); por ejemplo a poco que sepamos
de animales, las personas somos capaces clasificar a un animal (dada una foto) en
mamífero, ave, reptil, etc. es decir; que de alguna forma hemos aprendido la
diferencia que hay entre esos animales y sabemos clasificarlos.

ANTECEDENTES

En 1943, Warren McCulloch y Walter Pitts introdujeron una de las primeras

neuronas artificiales. La característica principal de su modelo de neurona es que
una suma ponderada de las señales de entrada se compara con un umbral para
determinar la neurona de salida. Cuando la suma es mayor o igual al umbral, la
salida es 1. Cuando la suma es menor que el umbral, la salida es 0. A finales de
1950 Frank Rosenblatt y otros investigadores desarrollaron una clase de redes
neuronales llamadas perceptrones. Las neuronas de estas redes eran similares a
las de McCulloch y Pitts.
La contribución clave de Rosenblatt fue la introducción de una regla de aprendizaje
para la formación de redes perceptrón para resolver problemas de reconocimiento
de patrones. Demostró que su regla de aprendizaje siempre convergirá a los pesos
correctos de la red, si existen pesos que solucionan el problema. El Perceptrón pudo
incluso aprender cuando se inicializaba con valores aleatorios de sus pesos y bias.

El Perceptrón es limitado. Dichas limitaciones fueron publicadas en el libro

Perceptrons por Marvin Minsky y Seymour Papert. Ellos demostraron que las redes
Perceptrón eran incapaces de implementar ciertas funciones elementales. No fue
sino hasta la década de los 8O’s que estas limitaciones fueron superadas con las
redes Perceptrón mejoradas (multicapa) asociadas con reglas de aprendizaje.

DESARROLLO

Consideremos un Perceptrón con dos entradas y dos pesos sinápticos, además de

un valor de predisposición llamado BIAS (B) como lo muestra la Figura 1.

La función limitador fuerte (Hardlim) se define en la ecuación Ec.1.

La ecuación Ec.2 se llama la matriz de pesos sinápticos, en este ejemplo es una
matriz de 1 fila y 2 columnas, y la ecuación Ec.3 si es un vector vertical de 2 filas.
De manera que el producto de la matriz W y el vector P tiene como resultado un
escalar. Además el valor de predisposición o BIAS (B) es un escalar, de manera
que el término es un escalar. Sobre este escalar se aplica la definición de Ec.1. Se
procede con el algoritmo de entrenamiento mediante el cual se encuentran los
valores de W y B con los cuales la red neuronal cumple con la función deseada.
La Tabla 1 muestra las entradas P0 y P1 que serán procesadas por el Perceptrón,
para obtener la función XOR (OR Exclusiva) es necesario hacer uso de dos
funciones de apoyo, debido a que la función XOR no se puede implementar con una
única neurona de tipo Perceptrón. Es necesario utilizar dos neuronas una que
desempeñe la función AND y otra la función OR y con estas saludad entrenar una
tercera neurona para finalmente llegar al objetivo de tener una neurona Perceptrón.
XOR. A continuación se adjunta el código para el entrenamiento de la neurona en
Arduino.

Código

int n,k,p;
int xa1 = 0, xa2=0, ta=0, xb1=0,xb2=1, tb=1, xc1= 1, xc2=0, tc=1, xd1=1, xd2=1,
td=0;
int wa0 = 2, wa1 = 1, ba = -3; //Valores funcion AND
int wo0 = 1,wo1 = 1, bo = -1; // Valores funcion OR
int w1=0, w2=0, b=0;
float e=0, a=0, axon=0;
void setup() {
Serial.begin(9600);
}
void loop() {
while(n<10){
Serial.println();
Serial.print("n");
Serial.print('\t');
Serial.print("axn");
Serial.print('\t');
Serial.print("w1");
Serial.print('\t');
Serial.print("w2");
Serial.print('\t');
Serial.print("b");
Serial.print('\t');
for(n=0;n<=10;n++){
axon=(((w1*xa1)+(w2*xa2)+b)+((wa0*xa1)+(wa1*xa2)+ba));
if(axon>=0){
a=1;}
else if(axon<0){
a=0;}
e=ta-a;
w1=(wa0+e*xa1);
w2=(wa1+e*xa2);
b=b+e;
Serial.println();
Serial.print(n);
Serial.print('\t');
Serial.print(a);
Serial.print('\t');
Serial.print(w1);
Serial.print('\t');
Serial.print(w2);
Serial.print('\t');
Serial.print(b);
Serial.print('\t');
if(((w1*xb1)+(w2*xb2)+b)+((wa0*xb1)+(wa1*xb2)+ba)>=0)
a=1;
else if(((w1*xb1)+(w2*xb2)+b)+((wa0*xb1)+(wa1*xb2)+ba)<0)
a=0;
e=tb-a;
w1=(w1+e*xb1);
w2=w2+e*xb2;
b=b+e;
Serial.println();
Serial.print(n);
Serial.print('\t');
Serial.print(a);
Serial.print('\t');
Serial.print(w1);
Serial.print('\t');
Serial.print(w2);
Serial.print('\t');
Serial.print(b);
Serial.print('\t');
if(((w1*xb1)+(w2*xb2)+b)+((wa0*xc1)+(wa1*xc2)+ba)>=0)
a=1;
else if(((w1*xb1)+(w2*xb2)+b)+((wa0*xc1)+(wa1*xc2)+ba)<0)
a=0;
e=tc-a;
w1=w1+e*xc1;
w2=w2+e*xc2;
b=b+e;
Serial.println();
Serial.print(n);
Serial.print('\t');
Serial.print(a);
Serial.print('\t');
Serial.print(w1);
Serial.print('\t');
Serial.print(w2);
Serial.print('\t');
Serial.print(b);
Serial.print('\t');
if(((w1*xb1)+(w2*xb2)+b)+((wa0*xd1)+(wa1*xd2)+ba)>=0)
a=1;
else if(((w1*xb1)+(w2*xb2)+b)+((wa0*xd1)+(wa1*xd2)+ba)<0)
a=0;
e=td-a;
w1=w1+e*xd1;
w2=w2+e*xd2;
b=b+e;
}
for(k=0;k<=10;k++){
axon=(((w1*xa1)+(w2*xa2)+b)+((wo0*xa1)+(wo1*xa2)+bo));
if(axon>=0){
a=1;}
else if(axon<0){
a=0;}
e=ta-a;
w1=(w1+e*xa1);
w2=(w2+e*xa2);
b=b+e;
Serial.println();
Serial.print(k);
Serial.print('\t');
Serial.print(a);
Serial.print('\t');
Serial.print(w1);
Serial.print('\t');
Serial.print(w2);
Serial.print('\t');
Serial.print(b);
Serial.print('\t');
if(((w1*xb1)+(w2*xb2)+b)+((wo0*xb1)+(wo1*xb2)+bo)>=0)
a=1;
else if(((w1*xb1)+(w2*xb2)+b)+((wo0*xb1)+(wo1*xb2)+bo)<0)
a=0;
e=tb-a;
w1=(w1+e*xb1);
w2=w2+e*xb2;
b=b+e;
Serial.println();
Serial.print(k);
Serial.print('\t');
Serial.print(a);
Serial.print('\t');
Serial.print(w1);
Serial.print('\t');
Serial.print(w2);
Serial.print('\t');
Serial.print(b);
Serial.print('\t');
if(((w1*xb1)+(w2*xb2)+b)+((wo0*xc1)+(wo1*xc2)+bo)>=0)
a=1;
else if(((w1*xb1)+(w2*xb2)+b)+((wo0*xc1)+(wo1*xc2)+bo)<0)
a=0;
e=tc-a;
w1=w1+e*xc1;
w2=w2+e*xc2;
b=b+e;
Serial.println();
Serial.print(k);
Serial.print('\t');
Serial.print(a);
Serial.print('\t');
Serial.print(w1);
Serial.print('\t');
Serial.print(w2);
Serial.print('\t');
Serial.print(b);
Serial.print('\t');
if(((w1*xb1)+(w2*xb2)+b)+((wo0*xd1)+(wo1*xd2)+bo)>=0)
a=1;
else if(((w1*xb1)+(w2*xb2)+b)+((wo0*xd1)+(wo1*xd2)+bo)<0)
a=0;
e=td-a;
w1=w1+e*xd1;
w2=w2+e*xd2;
b=b+e;
}
for(p=0;p<=10;p++){
axon=(((w1*xa1)+(w2*xa2)+b));
if(axon>=0){
a=1;}
else if(axon<0){
a=0;}
e=ta-a;
w1=(w1+e*xa1);
w2=(w2+e*xa2);
b=b+e;
Serial.println();
Serial.print(p);
Serial.print('\t');
Serial.print(a);
Serial.print('\t');
Serial.print(w1);
Serial.print('\t');
Serial.print(w2);
Serial.print('\t');
Serial.print(b);
Serial.print('\t');
if(((w1*xb1)+(w2*xb2)+b)>=0)
a=1;
else if(((w1*xb1)+(w2*xb2)+b)<0)
a=0;
e=tb-a;
w1=(w1+e*xb1);
w2=w2+e*xb2;
b=b+e;
Serial.println();
Serial.print(p);
Serial.print('\t');
Serial.print(a);
Serial.print('\t');
Serial.print(w1);
Serial.print('\t');
Serial.print(w2);
Serial.print('\t');
Serial.print(b);
Serial.print('\t');
if(((w1*xb1)+(w2*xb2)+b)>=0)
a=1;
else if(((w1*xb1)+(w2*xb2)+b)<0)
a=0;
e=tc-a;
w1=w1+e*xc1;
w2=w2+e*xc2;
b=b+e;
Serial.println();
Serial.print(p);
Serial.print('\t');
Serial.print(a);
Serial.print('\t');
Serial.print(w1);
Serial.print('\t');
Serial.print(w2);
Serial.print('\t');
Serial.print(b);
Serial.print('\t');
if(((w1*xb1)+(w2*xb2)+b)>=0)
a=1;
else if(((w1*xb1)+(w2*xb2)+b)<0)
a=0;
e=td-a;
w1=w1+e*xd1;
w2=w2+e*xd2;
b=b+e;
}
}
}

Después de realizar el entrenamiento de las neuronas se tienen los valores de los

pesos sinápticos y los valores de las predisposiciones para cada neurona. Como se
observa en la figura 3.
Con los valores calculados se desarrolla el código de programación que se observa
en el Cuadro 1. En la Figura 4 se observa la fotografía de la implementación del
Perceptron en una tarjeta de desarrollo Arduino Uno.
Finalmente en la Figura 5 vemos la salida del monitor Serial de Arduino en el cual
se observa el comportamiento XOR programado con este Perceptrón.

RESULTADOS
Se obtuvo la función XOR mediante el entrenamiento de un Perceptrón de tres
neuronas, y la implementación fue posible en Arduino sin requerir demasiados
accesorios, solo fueron necesarias unas resistencias y un Diodo LED para visualizar
la salida, la cual está entre cero y uno lógico.
CONCLUSIONES
1.- Implementar un Perceptrón en Arduino que desempeñe la función Lógica XOR
es posible solo hay que ser cuidadosos en el desarrollo del entrenamiento de las
neuronas que componen el Perceptrón, Además se muestra el comportamiento de
la función XOR en el monitor serial, las entradas P0 y P1 se muestran con puntos
decimales porque son entradas analógicas, la salida es en formato digital.
 2.- Este Perceptrón puede ser utilizado con mayores ventajas que las que ofrece la
compuesta lógica XOR debido a que las entradas son analógicas y no tiene una
zona de trabajo indeterminada como ocurre con las compuertas de la familia TTL y
CMOS.
REFERENCIAS
[1] – Howard Demuth, Mark Beale, Neural Network Toolbox or Use with MATLAB,
User Guide, Version 4, The MathWorks, Inc. 2002.

View publication stats