Implementacinde XORconun Perceptrnen Arduino

Implementación de la Función XOR con un
Perceptrón en Arduino.
Israel.Cerón-Morales1
1Maestría en Ingeniería en Automatización de Procesos Industriales
Universidad Politécnica de Puebla
3er. Carril del ejido serrano s/n, San Mateo Cuanalá, Puebla, México. C.P. 72640
Israel.ceron@uppuebla.edu.mx
Resumen- Este documento presenta un ejemplo que permite

implementar un Perceptron, este desarrollo se presenta muy
pocas veces en la literatura relacionada con la inteligencia
artificial, por lo que con el fin de ayudar a los estudiantes en el
entendimiento de este tema se realiza este documento. Los
resultados muestran la implementación de un Perceptron con el
cual se realiza la función lógica XOR.
Palabras Clave- Algoritmo, Arduino, Entrenamiento,
Perceptron.
INTRODUCCIÓN
El Perceptrón es una de las arquitecturas más básicas en el
desarrollo de la inteligencia artificial y el entrenamiento de
este tipo de neuronas artificiales suele ser poco detallado en la
mayoría de los textos que bordan este tópico, muchas veces el
entrenamiento de los perceptrones suele ser realizado con
programas de computo, sin embargo existe interés por
estudiantes que desean saber cuál es el paso a paso en el
entrenamiento de un Perceptron. Por lo cual se da un ejemplo
en este documento.
ANTECEDENTES
Trabajar con inteligencia artificial hoy día es muy común
por parte de estudiantes universitarios y muchas veces el
entrenamiento de redes neuronales se vuelve difícil de
asimilar debido a que no siempre se tiene practica en el
entrenamiento de redes neuronales paso a paso y esto es
debido a la gran cantidad de aritmética empleada, por lo que
en este documento se desarrolla un ejemplo básico de
entrenamiento lo que permite a los estudiantes interesados
tener un punto de referencia de que es lo que realmente hacen
los programas de computo al momento de entrenar redes
neuronales artificiales tipo Perceptrón.
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.
Figura. 1. Diagrama de un Perceptron con dos entradas y un valor
de predisposición B.
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 W * P +
B 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.
Tabla. 1. Tabla que muestra las entradas Po y P1 y las funciones

lógicas a ser utilizadas para programar un Perceptron XOR.
int xa1=0, xa2=0, ta=0;

int xb1=0, xb2=1, tb=1;
int xc1= 1, xc2=0, tc=1;
int xd1=1, xd2=1, td=0;
int wa0 = 2, wa1 = 1, ba = -3;
int wo0 = 1,wo1 = 1, bo = -1;
int w1=0, w2=0, b=0;
int i, j, p;
float e=0, ax=0, a=0;
void setup() {
Serial.begin(9600);
}
void loop() {
while(i<10){
Serial.println();
Serial.print("i");
Serial.print('\t');
Serial.print("w1");
Serial.print('\t');
Serial.print("w2");
Serial.print('\t');
Serial.print(ax);
Serial.print('\t');
Serial.print("b");
Serial.print('\t');
for(i=0;i<=10;i++){
ax=(((w1*xa1)+(w2*xa2)+b)+((wa0*xa1)+(wa1*xa2)+ba));
if(ax>=0){
a=1;}
else if(ax<0){
a=0;}
e=ta-a;
w1=(wa0+e*xa1);
w2=(wa1+e*xa2);
b=b+e;
Serial.println();
Serial.print(i);
Serial.print('\t');
Serial.print(w1);
Serial.print('\t');
Serial.print(w2);
Serial.print('\t');
Serial.print(a);
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(i);
Serial.print('\t');
Serial.print(w1);
Serial.print('\t');
Serial.print(w2);
Serial.print('\t');
Serial.print(a);
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(i);
Serial.print('\t');
Serial.print(w1);
Serial.print('\t');
Serial.print(w2);
Serial.print('\t');
Serial.print(a);
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(j=0;j<=10;j++){
ax=(((w1*xa1)+(w2*xa2)+b)+((wo0*xa1)+(wo1*xa2)+bo));
if(ax>=0){
a=1;}
else if(ax<0){
a=0;}
e=ta-a;
w1=(w1+e*xa1);
w2=(w2+e*xa2);
b=b+e;
Serial.println();
Serial.print(j);
Serial.print('\t');
Serial.print(w1);
Serial.print('\t');
Serial.print(w2);
Serial.print('\t');
Serial.print(a);
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(j);
Serial.print('\t');
Serial.print(w1);
Serial.print('\t');
Serial.print(w2);
Serial.print('\t');
Serial.print(a);
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(j);
Serial.print('\t');
Serial.print(w1);
Serial.print('\t');
Serial.print(w2);
Serial.print('\t');
Serial.print(a);
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++){
ax=(((w1*xa1)+(w2*xa2)+b));
if(ax>=0){
a=1;}
else if(ax<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(w1);
Serial.print('\t');
Serial.print(w2);
Serial.print('\t');
Serial.print(a);
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(w1);
Serial.print('\t');
Serial.print(w2);
Serial.print('\t');
Serial.print(a);
Serial.print('\t');
Serial.print(b);
Serial.print('\t');
if(((w1*xb1)+(w2*xb2)+b)>=0)
a=1;
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(w1);
Serial.print('\t');
Serial.print(w2);
Serial.print('\t');
Serial.print(a);
Serial.print('\t');
Serial.print(b);
Serial.print('\t');
if(((w1*xb1)+(w2*xb2)+b)>=0)
a=1;
a=0;
e=td-a;
w1=w1+e*xd1;
w2=w2+e*xd2;
b=b+e;
}
}
}
Valores obtenidos para el entrenamiento en XOR en el programa arduino.

Entrenamiento AND
Pa=[1 0]Pb=[0 1]Pc=[1 0]Pd=[1 1]

Ta=0 Tb=0 Tc=0 Td=1
W=[0 0]
b=0
Primero
a=H (([0 0][1 0]+0)
a=H (0*1+0*0+0)
a=H (0)
a=1
e=0-1
e=-1
wnew=[0 0]+(−1)[0 0]
wnew=[0 0]+[0 0]
wnew=[0 0]
bnew=0+(−1)
bnew=−1
Segundo
a=H (([00][01]+(−1))
a=H (0*0+0*1+(-1))
a=H (-1)
a=0
e=0-0
e=0
Wnew=[0 0]+(0)[0 1]
Wnew=[0 0]+[0 0]
Wnew=[0 0]
bnew=(−1)+0
bnew=−1
Tercero
a=H (([0 0][1 0]+(−1))
a=H (0*1+0*0+(-1))
a=H (-1)
a=0
e=0-0
e=0
Wnew=[0 0]+(0)[10]
Wnew=[0 0]+[0 0]
Wnew=[0 0]
bnew=(−1)+0
bnew=−1
Cuarto
a=H (([0 0][11]+(−1))
a=H (0*1+0*1+(-1))
a=H (-1)
a=0
e=1-0
e=1
Wnew=[0 0]+(1)[1 1]
Wnew=[0 0]+[1 1]
Wnew=[1 1]
bnew=(−1)+1
bnew=0
Se hacen los demás entrenamientos hasta obtener un límite de resultados. Se obtuvieron los
siguientes resultados: Wnew= [2 1] y bnew[-3]
A continuación, se hace el entrenamiento OR. Las operaciones son similares a lo anterior, se

prosigue la siguiente operación.
Pa=[0 0], Pb=[0 1], Pc=[1 0], Pd=[11]

Ta=0, Tb=1, Tc=1, Td=1
Wnew=[0 0]
b=0
Primero
a=H(([0 0][0 0]+0)
a=H(0*0+0*0+0)
a=H(0)
a=1
e=0-1
e=-1
Wnew=[0 0]+(−1)[0 0]
Wnew=[0 0]+[00 ]
Wnew=[0 0]
bnew=0+(−1)
bnew=−1
Segundo
a=H (([0 0][0 1]+0)
a=H (0*0+0*0+(-1)
a=H (-1)
a=0
e=1-0
e=1
Wnew=[0 0]+(1)[0 1]
Wnew=[0 0]+[01]
Wnew=[0 1]
bnew=(−1)+1
bnew=0
Tercero
a=H (([0 1][1 0]+0)
a=H (0*1+1*0+0)
a=H (0)
a=1
e=1-1
e=0
Wnew=[0 1]+(0)[1 0]
Wnew=[0 1]+[0 0]
Wnew=[0 1]
bnew=0+0
bnew=0
Cuarto
a=H (([0 1][1 1]+0)
a=H (0*1+1*1+0)
a=H (1)
a=1
e=1-1
e=0
Wnew=[0 1]+(0)[1 1]
Wnew=[0 1]+[0 0]
Wnew=[0 1]
bnew=0+0
bnew=0
Resultado Finalizado
Wnew=[1 1] y bnew= -1
CONCLUSIONES
1.- Implementar un Perceptron 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 Perceptron, 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 Perceptron 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.

Implementacinde XORconun Perceptrnen Arduino

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Implementacinde XORconun Perceptrnen Arduino

Cargado por

Copyright:

Formatos disponibles

Implementación de la Función XOR con un

Resumen- Este documento presenta un ejemplo que permite

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

Tabla. 1. Tabla que muestra las entradas Po y P1 y las funciones

int xa1=0, xa2=0, ta=0;

Valores obtenidos para el entrenamiento en XOR en el programa arduino.

Pa=[1 0]Pb=[0 1]Pc=[1 0]Pd=[1 1]

A continuación, se hace el entrenamiento OR. Las operaciones son similares a lo anterior, se

Pa=[0 0], Pb=[0 1], Pc=[1 0], Pd=[11]

También podría gustarte