UNIVERSIDAD NACIONAL DEL CALLAO

Facultad de Ingeniería Industrial y de Sistemas

SBC

PERCEPTRÓN UNICAPA
PERCEPTRÓN UNICAPA
En 1957 Frank Rosenblat desarrollo el Perceptrón.
El Perceptrón es un tipo de red de aprendizaje supervisado, es decir necesita conocer los
valores esperados para cada una de las entradas presentadas.
Se utiliza para clasificación de patrones linealmente separables. Un patrón es
linealmente separable cuando trazamos una línea en la gráfica, a un lado de la línea
quedan valores con 1 y en el otro lado valores con 0, es decir va a clasificar en dos
clases diferentes.

Figura. 2.12 Cada patrón se clasifica en dos clases diferentes

PERCEPTRÓN UNICAPA
La topología o arquitectura del perceptrón, es una red monocapa en la que recibe un
conjunto de valores como entrada, según el problema, para dar respuesta una o varios
valores de salida.
En la figura 2.13, las entradas son x 1, x2, los pesos son w1 y w2, y la salida es y, además
existe un parámetro adicional llamado umbral, denotado por θ. El umbral se utiliza como
factor de comparación para producir la salida.

Figura 2.13 Arquitectura de un perceptrón con dos entradas y una salida

PERCEPTRÓN UNICAPA
Una neurona biológica no hace nada, a menos que la influencia colectiva de
todas sus entradas alcance un nivel de umbral.
Siempre que se alcanza tal umbral, la neurona produce una salida de potencia
completa, que consiste en un pulso que se desplaza por el cuerpo de célula,
pasa por el axón, hasta las ramas de éste, en este caso se dice que la neurona
se dispara.
Debido a que una neurona se dispara o no hace nada, se dice que este es un
dispositivo de todo o nada.
Para que el perceptrón se dispare o active, la suma de las señales de entrada,
multiplicadas por su respectivo peso debe de ser mayor al umbral, es decir:
∑wixi > umbral
PERCEPTRÓN UNICAPA
Llamamos θ al umbral, y considerando 2 entradas y dos pesos obtenemos:
w1x1 + w2x2 > θ …….. (1)
Restando θ a ambos miembros de la ecuación 1 obtenemos:
w1x1 + w2x2 + (-θ) >0 …. (2)

Esta ecuación equivale a introducir artificialmente un nuevo peso θ, que está

conectada a una entrada ficticia con un valor constante de -1.
Como función de activación usaremos la función escalón.

1 Si y >0
f (y) =
-1 en otro caso
PERCEPTRÓN UNICAPA
La
  salida es binaria, puede ser fácilmente traducible a una clasificación de 2
clases o categorías de la siguiente forma:

Si la red produce salida 1, la entrada pertenece a la categoría A

Si la red produce salida 0, la entrada pertenece a la categoría B.
En el caso de dos dimensiones la ecuación 1 se transforma en:
w1x1 + w2x2 – θ = 0
(ecuación en si forma canónica)

Donde la pendiente es: (-w2/w1) y la ordenada es (θ/w1).

PERCEPTRÓN UNICAPA
Consideremos un perceptrón con varias entradas

Figura 2.14. Perceptrón simple

PERCEPTRÓN UNICAPA
El principal inconveniente del neurón umbral es que no aprende.
Donald Hebb (psicólogo) en 1949, propuso un mecanismo de aprendizaje para
la neurona biológica, cuya idea básica consiste en que cuando un axón
presináptico causa la activación de cierta neurona postsináptica, la eficacia de
la sinapsis que las relaciona se refuerza.
Se denomina aprendizaje hebbiano a aquellas formas de aprendizaje que
involucra una modificación en los pesos ∆wij proporcional al producto de una
entrada j por la salida i de la neurona.

∆wij= ε yixj

Siendo ε un parámetro denominado tasa de aprendizaje. El valor de ε varía

entre 0 y 1.
APRENDIZAJE HEBBIANO
Un valor pequeño de ε tendremos un aprendizaje lento, requiriendo un período más
grande de tiempo para completar el entrenamiento, un valor excesivamente grande
puede conducir oscilaciones excesivas de los pesos, no es aconsejable en el proceso
de entrenamiento.

Haciendo ti = yi, La regla de Hebb puede expresarse como: ∆wij= ε tixj

Y por lo tanto:
wij= wij+ ∆wij= wij+ εtixj
wj= wj+ εtixj

Peso anterior
Peso actual
 
ε: factor de aprendizaje
ti: valor que debe de aprender
xj: entrada
PERCEPTRÓN UNICAPA
El método de aprendizaje de Hebb permite que las neuronas aprendan a
ajustar sus pesos en un entorno de aprendizaje.
Recordar que los pesos representan la memoria a largo plazo en las RN.
Consideremos las funciones lógicas:

Disysunción Conjunción XOR Condicional Bicondicional Negación

p q p v q p ˄ q p ϴ q pq p ↔ q ~ p

f f f f f v v v
f v v f v v f v
v f v f v f f f
v v v v f v v f
 PERCEPTRÓN

• Esta neurona puede resolver algunos problemas lógicos, vamos a ver la

compuerta AND
Entrada Salida Entrada Salida

x1 x2 t X1 x2 t
0 0 0 -1 -1 -1
0 1 0 -1 1 -1
1 0 0 1 -1 -1
1 1 1 1 1 1

w1= 0.32593, w2 = 0.05803, θ = 0.84093, ε=0.5

APRENDIZAJE HEBBIANO
w1= 0.32593, w2 = 0.05803, θ = 0.84093, ε=0.5.
APRENDIZAJE HEBBIANO
w1= 0.32593, w2 = 0.05803, θ = 0.84093, ε=0.5
  yi=x1w1+ x2w2+ θ
Para la entrada (-1,-1) salida -1
y1=(-1)*0.32593+ (-1)*0.05803 +( -1)*0.84093 = -1,22489 -1
La clasificación es correcta (t=-1, y=-1), los pesos no serán modificados.
 
Para la entrada (-1,1) salida -1
y2= (-1)*0.32593+ (1)*0.05803 +( -1)*0.84093 = -1,10883 -1
 La clasificación es correcta (t=-1, y=-1), los pesos no serán modificados

Para la entrada (1,-1) salida -1

y3= (1)*0.32593+ (-1)*0.05803 +( -1)*0.84093 = -0,57303 -1
 La clasificación es correcta (t=-1, y=-1), los pesos no serán modificados
APRENDIZAJE HEBBIANO
Para la entrada (1,1) salida 1 (w1= 0.32593, w2 = 0.05803, θ = 0.84093, ε=0.5)
yi=x1w1+ x2w2+ θ

y4=(1)* 0.32593+ (1)*0,05803+ (-1)* 0.84093 = -0,45697 -1

La clasificación es incorrecta (t=1, y=-1), los pesos serán modificados.

Se recalcula los pesos: wj= wj+ εtixj

w1 = 0,32593 + (0.5)*(1)*(1) = 0.82593

w2 = 0.05803 + (0.5)*(1)*(1) = 0,55803
θ = 0.84093 + (0.5)*(1)*(-1) = 0.34093

Empezamos de nuevo

 
APRENDIZAJE HEBBIANO
Perceptrón con nuevos pesos: (w1= 0.82593, w2 = 0.55803, θ = 0.34093, ε=0.5)
Entradas
APRENDIZAJE HEBBIANO
Para la entrada (-1,-1) salida -1 (w1= 0.82593, w2 = 0.55803, θ = 0.34093, ε=0.5)
yi=x1w1+ x2w2+ θ

y1=(-1)*0.82593+ (-1)*0.55803 +( -1)*0.34093 = -1,72489 -1

La clasificación es correcta (t=-1, y=-1), los pesos no serán modificados.

Para la entrada (-1,1) salida -1

y2= (-1)*0.82593+ (1)*0.55803 +( -1)*0.34093 = -0,60883 -1
La clasificación es correcta (t=-1, y=-1), los pesos no serán modificados
 
Para la entrada (1,-1) salida -1
y3= (1)*0.82593+ (-1)*0.55803 +( -1)*0.34093 = -0,07303 -1
La clasificación es correcta (t=-1, y=-1), los pesos no serán modificados
 
Para la entrada (1,1) salida 1
y4=(1)* 0.82593+ (1)*0,55803+ (-1)* 0.34093 = 1,04303 1
La clasificación es correcta (t=1, y=1), los pesos no serán modificados.
PERCEPTRÓN UNICAPA
Graficamos
  la ecuación de la recta.-
w1 = 0.82593, w2= 0,55803, θ = 0.34093
La ecuación:
y = w1x1+ w2x2 - θ
Hacemos y=0, entonces
w1x1 + w2x2 – θ = 0
(ecuación en si forma canónica)

Usando interceptos:
  x1=0 ; = 0.6109 (0,0.6109)

x2=0 ; = 0.4127 (0.4127,0)

PERCEPTRÓN UNICAPA

Figura 2.18. Recta determinada por el perceptrón, función lógica AND

PERCEPTRÓN UNICAPA
Hemos trazado una línea recta, observamos que en un lado de la línea, están
los que clasifican con 1 y en el otro lado de la línea los que clasifican con -1.
En el punto (1,1) colocamos su salida que es 1.
En el punto (1,-1) colocamos su salida que es -1.
En el punto (-1,1) colocamos su salida que es -1.
En el punto (-1,-1) colocamos su salida que es -1.
 PERCEPTRÓN - OR

• Esta neurona puede resolver algunos problemas lógicos, vamos a ver la compuerta OR

Entrada Salida Entrada Salida

x1 x2 t X1 x2 t
0 0 0 -1 -1 -1
0 1 1 -1 1 1
1 0 1 1 -1 1
1 1 1 1 1 1

W1= 0.2871; W2=0.5746; Ɵ = 0.7228, Ɛ=0.5

APRENDIZAJE HEBBIANO
W1= 0.2871; W2=0.5746; Ɵ = 0.7228, Ɛ=0.5
 PERCEPTRÓN
Se propone W1= 0.2871; W2=0.5746; Ɵ = 0.7228, Ɛ=0.5
y=x1w1+x2w2 - Ɵ
Para la entrada (-1,-1) Salida -1
Y= (-1)*0.2871+ (-1)*0.5745 +(-1)*0.72281= -1.5845 -1
La clasificación es correcta

Para la entrada (-1,1) Salida 1

Y= (-1)*0.2871+ (1)*0.5746 +(-1)*0.7228= -0.4353 -1

La clasificación es incorrecto(t=1, y=-1) los pesos serán modificados

se recalculan los pesos: wj= wj+ εtixj

W1= 0.2871 +(0.5)*(1)*(-1) = -0,2129

W2= 0.5746 +(0.5)*(1)*(1) = 1,0746
Ɵ =0.7228 +(0.5)*(1)*(-1) = 0,2228
Empezamos de nuevo
APRENDIZAJE HEBBIANO
W1= -0,2129; W2=1,0746; Ɵ = 0,2228; Ɛ=0.5
 PERCEPTRÓN
Los nuevos pesos:W1= -0,2129; W2=1,0746; Ɵ = 0,2228; Ɛ=0.5
y=x1w1+x2w2 + Ɵ

Para la entrada (-1,-1) Salida -1

Y= (-1)*(-0.2129)+ (-1)*(1,0746) +(-1)*0.2228= -1.0845 -1
La clasificación es correcta

Para la entrada (-1,1) Salida 1

Y= (-1)*(-0.2129)+ (1)*(1,0746) +(-1)*0.2228= 1,0647 1
La clasificación es correcta

Para la entrada (1,-1) Salida 1

Y= (1)*( -0.2129)+ (-1)*(1,0746) +(-1)*0.2228= -1,0845 -1
La clasificación es incorrecto(t=1, y=-1) los pesos serán modificados
se recalculan los pesos:wj= wj+ εtixj

W1= -0.2129 +(0.5)*(1)*(1) = 0,2871

W2= 1.0746 +(0.5)*(1)*(-1) = 0,5746
Ɵ =0.2228 +(0.5)*(1)*(-1) = -0,2772
Empezamos de nuevo

W1=0,2871
W2=0,5746
Ɵ = -0,2772
APRENDIZAJE HEBBIANO
W1= 0,2871; W2=0,5746; Ɵ = -0,2772; Ɛ=0.5
 PERCEPTRÓN-prueba
Se propone W1= 0.2871; W2=0.5746; Ɵ = -0.2772, Ɛ=0.5
y=x1w1+x2w2 + Ɵ

Para la entrada (-1,-1) Salida -1

Y= (-1)*0.2871+ (-1)*0.5745 +(-1)*0.72281= -0,5845 -1
La clasificación es correcta

Para la entrada (-1,1) Salida 1

Y= (-1)*0.2871+ (1)*0.5746 +(-1)*0.7228= 0.5647 1
La clasificación es correcta

Para la entrada (1,-1) Salida 1

Y= (1)*0.2871+ (-1)*0.5746 +(-1)*0.7228=-0,01033 -1

La clasificación es incorrecto(t=1, y=-1) los pesos serán modificados

se recalculan los pesos
W1= 0.2871 +(0.5)*(1)*(1) = 0,7871
W2= 0.5746 +(0.5)*(1)*(-1) = 0,0746
Ɵ = -0.2772 +(0.5)*(1)*(-1) = -0,7772
Empezamos de nuevo
APRENDIZAJE HEBBIANO
W1= 0,7871; W2=0,0746; Ɵ = -0,7772; Ɛ=0.5
APRENDIZAJE HEBBIANO
w1=0,7871, w2 = 0.0746, θ = -0,7772, ε=0.5)
y=x1w1+x2w2 + Ɵ

Para la entrada (-1,-1) salida -1

y1=(-1)*0.7871+ (-1)*0.0746 +( -1)*(-0.7772) = -0,0845 -1
La clasificación es correcta (t=-1, y=-1), los pesos no serán modificados.

Para la entrada (-1,1) salida -1

y2= (-1)*0.7871+ (1)*0.0746 +( -1)*(-0.7772)= 00647 1
La clasificación es correcta (t=1, y=1), los pesos no serán modificados
 
Para la entrada (1,-1) salida -1
y3= (1)*0.7871+ (-1)*0.0746 +( -1)*(-0.7772) = 1,4897 1
La clasificación es correcta (t=1, y=1), los pesos no serán modificados
 
Para la entrada (1,1) salida 1
y4=(1)* 0.7871+ (1)*0,0746+ (-1)* (-0.7772) = 1,6389 1
La clasificación es incorrecta (t=1, y=1), los pesos no serán modificados.

El aprendizaje ha sido exitoso

Algoritmo de perceptron
Inicio
Inicializa matriz de entrada
Inicializa vector salidas
Inicializa vector pesos
i=0
Mientras (i<longitud de entradas) Hacer
yi = pesos[0]*entradas[i][0]+pesos[1]*entradas[i][1]+pesos[2]*entradas[i][2]
Si (yi >0 ) entonces
yi=1
Sino
yi=0
Fin_si
Si (yi = salidas[i]) entonces
Escribir ("entrada“,entradas[i][0],“ , “,entradas[i][1],"salida “,salidas[i]," correcto“);
Sino
// corrección de pesos
Desde k=0 hasta (k<longitud pesos) con incremento 1 Hacer
pesos[k]=recalculaPesos(pesos[k],salidas[i],entradas[i][k])
Fin_desde
i = -1 // para que empiece de nuevo
Fin_si
i =i+1
Fin_mientras
Fin
PERCEPTRÓN UNICAPA
Función recalculaPesos(wj, ti, xj)
Real wj
wj = wj + 0.5*ti*xj
retornar wj
Fin_funcion
PRUEBA DE LA FUNCION AND
Programa-perceptron
#include <iostream>
using namespace std;
double recalculaPesos(double pesos, double ti,double xi);
int main(int argc, char** argv) {
double entradas[4][3]={{-1,-1,-1},{-1,1,-1},{1,-1,-1},{1,1,-1}};
double pesos[]={0.32593,0.05803,0.84093};
double salidas[]={-1,-1,-1,1}; // funcion and
double yi=0;
int i,k=0;
for(i=0;i<3;i++){
cout<<"pesos " <<i <<" = " <<pesos[i]<<endl;
}
cout<<" **************************"<<endl;
Programa-perceptron
i=0;
while(i<4){
yi=pesos[0]*entradas[i][0]+pesos[1]*entradas[i][1]+pesos[2]*entradas[i][2];
cout<<"Yi "<<yi<<endl;
if (yi>=0) // utilizar la funcion escalon
yi=1;
else
yi=-1;
Programa-perceptron
if (yi==salidas[i])
cout<<"entrada"<<entradas[i][0]<<","<<entradas[i][1]<<"salida "<<salidas[i]<<"
correcto"<<endl;
else{
cout<<"entrada"<<entradas[i][0]<<","<<entradas[i][1]<<"salida"<<salidas[i]<<" incorrecto"<<endl;
cout<<"*********"<<" correccion de pesos "<<"***********"<<endl;
for(k=0;k<3;k++){
pesos[k]=recalculaPesos(pesos[k],salidas[i],entradas[i][k]);
cout<<" "<<pesos[k]<<endl;
}
cout<<"*********************"<<endl;
i=-1;
}
i++;
}
return 0;
}
Programa-perceptron
double recalculaPesos(double pesosj, double ti,double xi){
double wj;
wj=pesosj+0.5*ti*xi;
return wj;
}
Nota
Para que funcione el programa or debe de cambiar

double entradas[4][3]={{-1,-1,-1},{-1,1,-1},{1,-1,-1},{1,1,-1}};
double pesos[ ]={0.2871,0.5746,0.7228};
double salidas[ ]={-1,1,1,1};

Los pesos y la salida