Perceptrón en C

Iniciado por karurosu, Marzo 30, 2016, 02:22:13 PM

Tema anterior - Siguiente tema

0 Miembros y 1 Visitante están viendo este tema.

Imprimir
Ir Abajo Páginas1
Acciones del Usuario
Marzo 30, 2016, 02:22:13 PM Ultima modificación: Marzo 30, 2016, 02:38:14 PM por rollth
Buenas, les quiero compartir este código que recién hice, se trata de un perceptrón hecho en C, en mi caso analiza 20 patrones con 64 elementos cada uno (más el primer elemento por default siendo 65), todo lo leo de un archivo .txt lo almaceno en arreglos y realizo las operaciones, para los que no saben que es un perceptrón es un método para comparar patrones que pueden ser linealmente separables, esto verifica que cierto patrón coincida con un valor, en mi caso debe coincidir con las salidas deseadas de mi .txt, en fin les dejo el código:

Código: c
#include <stdio.h>
#include <stdlib.h>

//Declaración de variables globales
char numeroPatron[20][2];
int patrones[20][65];
float salidaDeseada[20];
float pesos[65];
int contadorElementos, contadorPatrones;
float FP[20];
int SP [20];

//Paso 1 se lee el archivo que contiene los patrones
void leerArchivo()
{
     int contadorPatron, contadorNumeros1, contadorNumeros2;
     
     contadorNumeros1 = 0;
     
     printf("Los patrones son: \n");
     
     //Se declara un apuntador al archivo
     FILE * fichero;
     //Se abre el archivo para lectura con "r"
     fichero = fopen ("patrones.txt", "r");
     
     contadorPatrones = 0;
     for (contadorPatron = 0; contadorPatron < 20; contadorPatron++)
     {
         contadorElementos = 1;
         contadorPatrones++;
         //Se lee el valor del documento y se guarda en el arreglo
         fscanf(fichero, "%s", &numeroPatron[contadorPatron]);
         printf("%s\n", numeroPatron[contadorPatron]);
         patrones [contadorNumeros1][0] = 1;
         printf("%d", patrones[contadorNumeros1][0]);
         
         for (contadorNumeros2 = 1; contadorNumeros2 < 65; contadorNumeros2++)
         {
             fscanf(fichero, "%d", &patrones[contadorNumeros1][contadorNumeros2]);
             printf("%d", patrones[contadorNumeros1][contadorNumeros2]);
             contadorElementos++;
         }
         
         fscanf(fichero, "%f", &salidaDeseada[contadorPatron]);
         printf("\n%.2f\n", salidaDeseada[contadorPatron]);
         
         contadorNumeros1++;
     }
     //Se cierra el archivo
     fclose(fichero);
}

void primerosPesos()
{
     int x;
     time_t t;
     
     sleep(5000);
     system("CLS");
         
     srand((unsigned) time(&t));
     printf ("Pesos\n\n");
     for (x = 0; x < contadorElementos; x++)
     {
         pesos [x] = rand() % 201;
         if (pesos[x] <= 100)
         {
            pesos [x] = pesos[x] / -100;             
         }else
         {
            pesos [x] = pesos[x] / 200;
         }
         printf("w%d = %.2f\n", x, pesos[x]);
     }    
}

void recalcularPesos(int y, int bandera)
    {
         int x, z;
         float n = 0.1;
         
         printf("Los nuevos pesos son: \n");
         for(x = 0; x < contadorElementos; x++)
         {
               if (bandera == 1){
                           pesos[x] = pesos[x] + n * patrones [y] [x];
               }
               if (bandera == 0){
                           pesos[x] = pesos[x] - n * patrones [y] [x];
               }
               printf("w%d = %.2f\n", x + 1, pesos[x]);
         }
         printf("\n\n");
    }

void funcionPropagacion()
    {
         int x, y, umbral = 0, malclasificados = 0, bandera1;
         
         printf ("\nCalculando funcion de propagacion y salida del Perceptron\n\n");  
               
               for (x = 0; x < contadorPatrones; x++)
               {
                   FP [x] = 0;
               }
               
               for (x = 0; x < contadorPatrones; x++)
               {
                 printf ("FP%d = ", x + 1);
                 for (y = 0; y < contadorElementos; y++)
                 {
                     FP [x] = FP [x] + pesos [y] * patrones [x] [y];
                     printf ("%.2f * %d + ", pesos[y], patrones [x] [y]);
                 }
                 printf ("= %.2f\n", FP[x]);
                 
                 if(FP [x] > umbral)
                 {
                       SP[x] = 1;
                 }
                 else{
                      SP[x] = -1;
                 }
                 printf ("SP%d = %d\n", x + 1, SP[x]);
                 if (salidaDeseada [x] != SP[x])
                 {
                       malclasificados = malclasificados + 1;
                 }
             }
             printf ("Los mal clasificados son %d\n", malclasificados);
             sleep(5000);
             while(malclasificados > 0)
             {
                                   system("CLS");
                                   malclasificados = 0;
               
                                   for (x = 0; x < contadorPatrones; x++)
                                   {
                                       FP [x] = 0;
                                   }
               
                                   for (x = 0; x < contadorPatrones; x++)
                                   {
                                     printf ("FP%d = ", x + 1);
                                     for (y = 0; y < contadorElementos; y++)
                                     {
                                         FP [x] = FP [x] + pesos [y] * patrones [x] [y];
                                         printf ("%.2f * %d + ", pesos[y], patrones [x] [y]);
                                     }
                                     printf ("= %.2f\n", FP[x]);
                                     
                                     if(FP [x] > umbral)
                                     {
                                           SP[x] = 1;
                                     }
                                     else{
                                          SP[x] = -1;
                                     }
                                     printf ("SP%d = %d\n", x + 1, SP[x]);
                                     if (salidaDeseada [x] != SP[x])
                                     {
                                           printf("\nLos valores son distintos se recalcularan los pesos...\n");
                                           system("CLS");
                                           if (SP[x] < salidaDeseada [x])
                                           {
                                                     bandera1 = 1;
                                           }else{
                                                     bandera1 = 0;
                                           }
                                           recalcularPesos(x, bandera1);
                                           malclasificados = malclasificados + 1;
                                     }
                                 }
               }                       
    
         printf ("\nLas salidas son las deseadas!\n\n");
         printf ("Los pesos son:\n");
         for (x = 0; x < contadorElementos; x++)
         {
             printf ("w%d = %.2f\n", x + 1, pesos[x]);
         }
}

int main()
{
  leerArchivo();
  primerosPesos();
  funcionPropagacion();
  system("PAUSE");	
}   


Espero que le sirva a alguien, saludos.  :)
Mayo 11, 2016, 07:22:12 PM #1
Hola compañero buenas tardes, quisiera saber si me podrías ayudar para ver como esta estructurado tu archivo txt, he hecho algunas pruebas pero no obtengo los resultados que esperaba, me gustaría comparar con lo que estoy probando.
Saludos y Gracias
Mayo 12, 2016, 05:03:22 PM #2
Hola, buenas tardes, el formato es el siguiente:

Citarp1

0   0   0   0   0   0   0   0
0   0   0   0   1   1   0   0
0   0   0   0   1   1   0   0
0   0   0   0   1   1   0   0
0   0   0   0   1   1   0   0
0   0   0   0   1   1   0   0
0   0   0   0   1   1   0   0
0   0   0   0   0   0   0   0

1

con el numero de patrón primeramente y luego los elementos del patrón, por último va la salida deseada, que en este caso es 1, y así todos los patrones hasta el 20 en mi caso, ¡saludos!
Imprimir
Ir Arriba Páginas1
Acciones del Usuario