Este sitio utiliza cookies propias y de terceros. Si continúa navegando consideramos que acepta el uso de cookies. OK Más Información.

Perceptrón en C

  • 2 Respuestas
  • 4707 Vistas

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

Desconectado karurosu

  • *
  • Underc0der
  • Mensajes: 183
  • Actividad:
    0%
  • Reputación 1
    • Ver Perfil
« en: Marzo 30, 2016, 02:22:13 pm »
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
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3.  
  4. //Declaración de variables globales
  5. char numeroPatron[20][2];
  6. int patrones[20][65];
  7. float salidaDeseada[20];
  8. float pesos[65];
  9. int contadorElementos, contadorPatrones;
  10. float FP[20];
  11. int SP [20];
  12.  
  13. //Paso 1 se lee el archivo que contiene los patrones
  14. void leerArchivo()
  15. {
  16.      int contadorPatron, contadorNumeros1, contadorNumeros2;
  17.      
  18.      contadorNumeros1 = 0;
  19.      
  20.      printf("Los patrones son: \n");
  21.      
  22.      //Se declara un apuntador al archivo
  23.      FILE * fichero;
  24.      //Se abre el archivo para lectura con "r"
  25.      fichero = fopen ("patrones.txt", "r");
  26.      
  27.      contadorPatrones = 0;
  28.      for (contadorPatron = 0; contadorPatron < 20; contadorPatron++)
  29.      {
  30.          contadorElementos = 1;
  31.          contadorPatrones++;
  32.          //Se lee el valor del documento y se guarda en el arreglo
  33.          fscanf(fichero, "%s", &numeroPatron[contadorPatron]);
  34.          printf("%s\n", numeroPatron[contadorPatron]);
  35.          patrones [contadorNumeros1][0] = 1;
  36.          printf("%d", patrones[contadorNumeros1][0]);
  37.          
  38.          for (contadorNumeros2 = 1; contadorNumeros2 < 65; contadorNumeros2++)
  39.          {
  40.              fscanf(fichero, "%d", &patrones[contadorNumeros1][contadorNumeros2]);
  41.              printf("%d", patrones[contadorNumeros1][contadorNumeros2]);
  42.              contadorElementos++;
  43.          }
  44.          
  45.          fscanf(fichero, "%f", &salidaDeseada[contadorPatron]);
  46.          printf("\n%.2f\n", salidaDeseada[contadorPatron]);
  47.          
  48.          contadorNumeros1++;
  49.      }
  50.      //Se cierra el archivo
  51.      fclose(fichero);
  52. }
  53.  
  54. void primerosPesos()
  55. {
  56.      int x;
  57.      time_t t;
  58.      
  59.      sleep(5000);
  60.      system("CLS");
  61.          
  62.      srand((unsigned) time(&t));
  63.      printf ("Pesos\n\n");
  64.      for (x = 0; x < contadorElementos; x++)
  65.      {
  66.          pesos [x] = rand() % 201;
  67.          if (pesos[x] <= 100)
  68.          {
  69.             pesos [x] = pesos[x] / -100;            
  70.          }else
  71.          {
  72.             pesos [x] = pesos[x] / 200;
  73.          }
  74.          printf("w%d = %.2f\n", x, pesos[x]);
  75.      }    
  76. }
  77.  
  78. void recalcularPesos(int y, int bandera)
  79.     {
  80.          int x, z;
  81.          float n = 0.1;
  82.          
  83.          printf("Los nuevos pesos son: \n");
  84.          for(x = 0; x < contadorElementos; x++)
  85.          {
  86.                if (bandera == 1){
  87.                            pesos[x] = pesos[x] + n * patrones [y] [x];
  88.                }
  89.                if (bandera == 0){
  90.                            pesos[x] = pesos[x] - n * patrones [y] [x];
  91.                }
  92.                printf("w%d = %.2f\n", x + 1, pesos[x]);
  93.          }
  94.          printf("\n\n");
  95.     }
  96.  
  97. void funcionPropagacion()
  98.     {
  99.          int x, y, umbral = 0, malclasificados = 0, bandera1;
  100.          
  101.          printf ("\nCalculando funcion de propagacion y salida del Perceptron\n\n");  
  102.                
  103.                for (x = 0; x < contadorPatrones; x++)
  104.                {
  105.                    FP [x] = 0;
  106.                }
  107.                
  108.                for (x = 0; x < contadorPatrones; x++)
  109.                {
  110.                  printf ("FP%d = ", x + 1);
  111.                  for (y = 0; y < contadorElementos; y++)
  112.                  {
  113.                      FP [x] = FP [x] + pesos [y] * patrones [x] [y];
  114.                      printf ("%.2f * %d + ", pesos[y], patrones [x] [y]);
  115.                  }
  116.                  printf ("= %.2f\n", FP[x]);
  117.                  
  118.                  if(FP [x] > umbral)
  119.                  {
  120.                        SP[x] = 1;
  121.                  }
  122.                  else{
  123.                       SP[x] = -1;
  124.                  }
  125.                  printf ("SP%d = %d\n", x + 1, SP[x]);
  126.                  if (salidaDeseada [x] != SP[x])
  127.                  {
  128.                        malclasificados = malclasificados + 1;
  129.                  }
  130.              }
  131.              printf ("Los mal clasificados son %d\n", malclasificados);
  132.              sleep(5000);
  133.              while(malclasificados > 0)
  134.              {
  135.                                    system("CLS");
  136.                                    malclasificados = 0;
  137.                
  138.                                    for (x = 0; x < contadorPatrones; x++)
  139.                                    {
  140.                                        FP [x] = 0;
  141.                                    }
  142.                
  143.                                    for (x = 0; x < contadorPatrones; x++)
  144.                                    {
  145.                                      printf ("FP%d = ", x + 1);
  146.                                      for (y = 0; y < contadorElementos; y++)
  147.                                      {
  148.                                          FP [x] = FP [x] + pesos [y] * patrones [x] [y];
  149.                                          printf ("%.2f * %d + ", pesos[y], patrones [x] [y]);
  150.                                      }
  151.                                      printf ("= %.2f\n", FP[x]);
  152.                                      
  153.                                      if(FP [x] > umbral)
  154.                                      {
  155.                                            SP[x] = 1;
  156.                                      }
  157.                                      else{
  158.                                           SP[x] = -1;
  159.                                      }
  160.                                      printf ("SP%d = %d\n", x + 1, SP[x]);
  161.                                      if (salidaDeseada [x] != SP[x])
  162.                                      {
  163.                                            printf("\nLos valores son distintos se recalcularan los pesos...\n");
  164.                                            system("CLS");
  165.                                            if (SP[x] < salidaDeseada [x])
  166.                                            {
  167.                                                      bandera1 = 1;
  168.                                            }else{
  169.                                                      bandera1 = 0;
  170.                                            }
  171.                                            recalcularPesos(x, bandera1);
  172.                                            malclasificados = malclasificados + 1;
  173.                                      }
  174.                                  }
  175.                }                      
  176.    
  177.          printf ("\nLas salidas son las deseadas!\n\n");
  178.          printf ("Los pesos son:\n");
  179.          for (x = 0; x < contadorElementos; x++)
  180.          {
  181.              printf ("w%d = %.2f\n", x + 1, pesos[x]);
  182.          }
  183. }
  184.  
  185. int main()
  186. {
  187.   leerArchivo();
  188.   primerosPesos();
  189.   funcionPropagacion();
  190.   system("PAUSE");     
  191. }  

Espero que le sirva a alguien, saludos.  :)
« Última modificación: Marzo 30, 2016, 02:38:14 pm por rollth »

Desconectado tanya

  • *
  • Underc0der
  • Mensajes: 1
  • Actividad:
    0%
  • Reputación 0
    • Ver Perfil
« Respuesta #1 en: Mayo 11, 2016, 07:22:12 pm »
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

Desconectado karurosu

  • *
  • Underc0der
  • Mensajes: 183
  • Actividad:
    0%
  • Reputación 1
    • Ver Perfil
« Respuesta #2 en: Mayo 12, 2016, 05:03:22 pm »
Hola, buenas tardes, el formato es el siguiente:

Citar
p1

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!

 

¿Te gustó el post? COMPARTILO!



Perceptrón en C

Iniciado por karurosu

Respuestas: 23
Vistas: 8812
Último mensaje Marzo 29, 2016, 04:32:34 pm
por karurosu