Perceptron
El modelo biológico más simple de un perceptrón es una neurona y viceversa. Es decir, el modelo matemático más simple de una neurona es un perceptrón. La neurona es una célula especializada y caracterizada por poseer una cantidad indefinida de canales de entrada llamados dendritas y un canal de salida llamado axón. Las dendritas operan como sensores que recogen información de la región donde se hallan y la derivan hacia el cuerpo de la neurona que reacciona mediante una sinapsis que envía una respuesta hacia el cerebro, esto en el caso de los seres vivos.
Una neurona sola y aislada carece de razón de ser. Su labor especializada se torna valiosa en la medida en que se asocia a otras neuronas, formando una red. Normalmente, el axón de una neurona entrega su información como "señal de entrada" a una dendrita de otra neurona y así sucesivamente.
El perceptrón usa una matriz para representar las redes neuronales y es un discriminador terciario que traza su entrada x (un vector binario) a un único valor de salida f(x) (un solo valor binario) a través de dicha matriz.
Donde w es un vector de pesos reales y W*X es el producto escalar (que computa una suma ponderada). U es el 'umbral', el cual representa el grado de inhibición de la neurona, es un término constante que no depende del valor que tome la entrada.
El valor de f(x)= (0,1) se usa para clasificar x como un caso positivo o un caso negativo, en el caso de un problema de clasificación binario. El umbral puede entenderse como una manera de compensar la función de activación, o una forma de fijar un nivel mínimo de actividad a la neurona para considerarse como activa. La suma ponderada de las entradas debe producir un valor mayor que U para cambiar la neurona de estado 0 a 1.
El perceptrón puede utilizarse con otros tipos de perceptrones o de neurona artificial, para formar una red neuronal artificial más compleja.
EJERCICIO PERCEPTRÓN
#include <stdio.h>
#include <time.h>
#include <stdlib.h>
#include <unistd.h>
using namespace std;
class Perceptron{
public:
Perceptron();
void Calcular(void);
~Perceptron();
};
Perceptron::Perceptron()
{
printf("Iniciando Perceptron\n");
}
Perceptron::~Perceptron()
{
printf("\n\nPerceptron Finalizado\n");
}
void Perceptron::Calcular(void)
{
srand(time(NULL));
float rangos[] = {-0.98,-0.87,-0.65,-0.75,0.45,0.95,-0.32,-0.28,-0.11,-0.06,0.023,0.23,0.23,0.46,0.67,0.78, 0.75,0.82,0.98};
float aprendizaje[] = {0.023,0.23,0.233,0.467,0.675,0.788, 0.752,0.823,0.987};
float Umbral,defumbral,factor;
int i;
int x1[] = {-1,1,-1,1,-1,1};
int x2[] = {1,-1,-1,1,1,-1};
int x3[] = {1,1,-1,-1,-1,1};
int x4[] = {1,1,1,-1,1,1};
int x5[] = {1,1,1,1,1,1};
int x6[] = {1,1,1,1,1,1};
int result[] = {1,1,-1,-1,-1,1};
float w[6] = {rangos[rand() % 18],rangos[rand() % 18],rangos[rand() % 18],rangos[rand() % 18],rangos[rand() % 18],rangos[rand() % 18]};
factor = rangos[rand() % 18];
Umbral = rangos[rand() % 18];
defumbral = 1;
int verdad = 0;
int op;
int cont = 0;
int n = 0;
// Entrenamiento
while(verdad == 0){
n++;
for(i=0;i<6;i++){
op = ((x1[i]*w[0])+(x2[i]*w[1])+(x3[i]*w[2])+(x4[i]*w[3])+(x5[i]*w[4])+(x6[i]*w[5])) + (defumbral*Umbral);
if(op >= 0){
op = 1;
}
else{
op = -1;
}
if(op != result[i]){
w[0] = w[0] + (6*factor)*(x1[i]*result[i]);
w[1] = w[1] + (6*factor)*(x2[i]*result[i]);
w[2] = w[2] + (6*factor)*(x3[i]*result[i]);
w[3] = w[3] + (6*factor)*(x4[i]*result[i]);
w[4] = w[4] + (6*factor)*(x5[i]*result[i]);
w[5] = w[5] + (6*factor)*(x6[i]*result[i]);
Umbral = Umbral + (6*factor)*(defumbral*result[i]);
}
}
for(i=0;i<6;i++){
op = ((x1[i]*w[0])+(x2[i]*w[1])+(x3[i]*w[2])+(x4[i]*w[3])+(x5[i]*w[4])+(x6[i]*w[5])) + (defumbral*Umbral);
if(op == result[i]){
cont++;
}
if(cont == 6){
verdad = 1;
}
}
if(n > 900000000){
printf("Demasiadas epocas realizadas\n");
printf("Es necesario intentar nuevamente con otros pesos.\n");
exit(1);
}
}
//RESULTADO
printf("\nFINALIZANDO ENTRENAMIENTO...\n");
printf("\n--------------- DATOS RESULTANTES --------------------------------\n\n");
printf("# Total de epocas: (%i)\n",n);
printf("Valor Peso 1 w[1]\t\t--> %2.2f\n",w[0]);
printf("Valor Peso 2 w[2]\t\t--> %2.2f\n",w[1]);
printf("Valor Peso 3 w[3]\t\t--> %2.2f\n",w[2]);
printf("Valor Peso 4 w[4]\t\t--> %2.2f\n",w[3]);
printf("Valor Peso 5 w[5]\t\t--> %2.2f\n",w[4]);
printf("Valor Peso 6 w[6]\t\t--> %2.2f\n",w[5]);
printf("Valor Umbral(Polarizacion)\t\t--> %2.2f\n",Umbral);
for(i=0;i<6;i++){
op = ((x1[i]*w[0])+(x2[i]*w[1])+(x3[i]*w[2])+(x4[i]*w[3])+(x5[i]*w[4])+(x6[i]*w[5])) + (defumbral*Umbral);
if(op >= 0){
op = 1;
}
else{
op = -1;
}
printf("\nEntradas: (%2i,%2i,%2i,%2i,%2i,%2i) --> Salida: %2i",x1[i],x2[i],x3[i],x4[i],x5[i],x6[i],op);
if(op != result[i]){
printf("\nDemasiadas epocas realizadas\n");
printf("Es necesario intentar nuevamente con otros pesos.\n");
exit(1);
Calcular();
}
}
}
int main()
{
Perceptron x;
x.Calcular();
return 0;
}
No hay comentarios:
Publicar un comentario