Underc0de

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:

#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.  :)

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:

#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.  :)

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:

#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.  :)

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:

#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.  :)

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:

#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.  :)

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:

#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.  :)

Hola querida comunidad, les pido un favor, de casualidad usted tienen algún formato que se use para presentar los resultados de un pentesting para una app web, estoy buscando y no encuentro nada, el cliente espera respuestas técnicas y administrativas, algún sitio web que conozcan o algo por el estilo, de antemano muchas gracias.

Hola querida comunidad, les pido un favor, de casualidad usted tienen algún formato que se use para presentar los resultados de un pentesting para una app web, estoy buscando y no encuentro nada, el cliente espera respuestas técnicas y administrativas, algún sitio web que conozcan o algo por el estilo, de antemano muchas gracias.

Faster Ddos Attack (Unknow Doser) Es un denegación de servicio muy bueno , ojo es potente pero no mucho  ;) ;)
Llegate al MP & te paso link de descarga..
Espero que les sirva :P Saludos & hasta la próxima...

Faster Ddos Attack (Unknow Doser) Es un denegación de servicio muy bueno , ojo es potente pero no mucho  ;) ;)
Llegate al MP & te paso link de descarga..
Espero que les sirva :P Saludos & hasta la próxima...

Necesito que me pasen links de libros o manuales de hacking , carding , pentestin & esas cosas pues se lo agradeceria mucho gente  8)  ;D

Saludos & nos vemos la próxima   ::)

jjhgjh

jkhkjh

kjhkjh

lkjlkjlkj

kjhkjhkjhkjh

kjhkjhkjh

Hola Underc0ders!
ya habían leído acerca de lo nuevo que propone Microsoft?


Holoportation, la comunicación holográfica está aquí.

Así la nueva propuesta es el Skype holográfico que Microsoft nos tiene preparado y quiere revolucionar la manera en la que nos comunicamos con Hololens.

En plena lucha entre los distintos fabricantes que están apostando mucho por crear la mejor solución de realidad virtual.



Algunos de los protagonistas como Oculus, HTC Vive y más, pero no todo es cuestión de conseguir más y más juegos y contenidos exclusivos para una plataforma. Microsoft sigue con su táctica de mostrar usos reales de sus Hololens, que combinan realidad virtual y aumentada.

Literalmente, la comunicación holográfica que hemos visto en decenas de películas de ciencia ficción.

La Holoportation recrea en tiempo real y a tamaño completo a los usuarios en otro lugar, pudiendo comunicarse e interaccionar entre ellos pese a estar separados por kilómetros.

Pero para conseguirlo utilizan un arsenal de cámaras de detección 3D, sensores y, por supuesto, las gafas Hololens, así que de momento no es más que una demostración de lo que son capaces de hacer con ellas.


Como siempre Microsoft nos está vendiendo muy bien Hololens, pero de momento no hay un producto final.

Recordemos que las primeras unidades estarán disponibles para desarrolladores a un módico precio de 3.000 dólares la unidad.




Fuente:
Omicrono.com

Ahora bien ¿que opinan ustedes de la Holoportation?

Que pasen un lindo dia tod@s :D

Bueno ante todo un saludo, llevo tiempo viendo esta web desde fuera y me he aventurado a escribir.
Tengo en casa un router cisco rv042g, mi idea es montar una DMZ para el proyecto integrado, que es lo que pasa, que cuando configuro la DMZ en el router cisco (a través de su interfaz web ) no funciona como debería. Todo lo que yo ponga en la DMZ no tiene conexión con nada, he probado el manual..etc, etc. Entonces, seguramente se me esté escapando algo, os dejo alguna info:

LAN: 192.168.1.1
MasK: 255.255.255.0
Subnet creada para la DMZ: 192.168.20.1

La DMZ tiene una opción de hacer una subred para la DMZ, he creado antes la subred que veis arriba para indicarle a la DMZ que use esa subred.
No se si se me escapa algo o que pero se me han acabado las ideas jajajaja.
Un saludo compas

Hola Underc0ders!
ya habían leído acerca de lo nuevo que propone Microsoft?


Holoportation, la comunicación holográfica está aquí.

Así la nueva propuesta es el Skype holográfico que Microsoft nos tiene preparado y quiere revolucionar la manera en la que nos comunicamos con Hololens.

En plena lucha entre los distintos fabricantes que están apostando mucho por crear la mejor solución de realidad virtual.



Algunos de los protagonistas como Oculus, HTC Vive y más, pero no todo es cuestión de conseguir más y más juegos y contenidos exclusivos para una plataforma. Microsoft sigue con su táctica de mostrar usos reales de sus Hololens, que combinan realidad virtual y aumentada.

Literalmente, la comunicación holográfica que hemos visto en decenas de películas de ciencia ficción.

La Holoportation recrea en tiempo real y a tamaño completo a los usuarios en otro lugar, pudiendo comunicarse e interaccionar entre ellos pese a estar separados por kilómetros.

Pero para conseguirlo utilizan un arsenal de cámaras de detección 3D, sensores y, por supuesto, las gafas Hololens, así que de momento no es más que una demostración de lo que son capaces de hacer con ellas.


Como siempre Microsoft nos está vendiendo muy bien Hololens, pero de momento no hay un producto final.

Recordemos que las primeras unidades estarán disponibles para desarrolladores a un módico precio de 3.000 dólares la unidad.


(http://i.imgur.com/9neCrxV.png)

Holoportation:
https://youtu.be/7d59O6cfaM0


Fuente:
Omicrono.com

Ahora bien ¿que opinan ustedes de la Holoportation?

Que pasen un lindo dia tod@s :D

Hola Underc0ders!
ya habían leído acerca de lo nuevo que propone Microsoft?


Holoportation, la comunicación holográfica está aquí.

Así la nueva propuesta es el Skype holográfico que Microsoft nos tiene preparado y quiere revolucionar la manera en la que nos comunicamos con Hololens.

En plena lucha entre los distintos fabricantes que están apostando mucho por crear la mejor solución de realidad virtual.



Algunos de los protagonistas como Oculus, HTC Vive y más, pero no todo es cuestión de conseguir más y más juegos y contenidos exclusivos para una plataforma. Microsoft sigue con su táctica de mostrar usos reales de sus Hololens, que combinan realidad virtual y aumentada.

Literalmente, la comunicación holográfica que hemos visto en decenas de películas de ciencia ficción.

La Holoportation recrea en tiempo real y a tamaño completo a los usuarios en otro lugar, pudiendo comunicarse e interaccionar entre ellos pese a estar separados por kilómetros.

Pero para conseguirlo utilizan un arsenal de cámaras de detección 3D, sensores y, por supuesto, las gafas Hololens, así que de momento no es más que una demostración de lo que son capaces de hacer con ellas.


Como siempre Microsoft nos está vendiendo muy bien Hololens, pero de momento no hay un producto final.

Recordemos que las primeras unidades estarán disponibles para desarrolladores a un módico precio de 3.000 dólares la unidad.


(http://i.imgur.com/9neCrxV.png)

Holoportation:
https://youtu.be/7d59O6cfaM0


Fuente:
Omicrono.com

Ahora bien ¿que opinan ustedes de la Holoportation?

Que pasen un lindo dia tod@s :D

Hola Underc0ders!
ya habían leído acerca de lo nuevo que propone Microsoft?


Holoportation, la comunicación holográfica está aquí.

Así la nueva propuesta es el Skype holográfico que Microsoft nos tiene preparado y quiere revolucionar la manera en la que nos comunicamos con Hololens.

En plena lucha entre los distintos fabricantes que están apostando mucho por crear la mejor solución de realidad virtual.



Algunos de los protagonistas como Oculus, HTC Vive y más, pero no todo es cuestión de conseguir más y más juegos y contenidos exclusivos para una plataforma. Microsoft sigue con su táctica de mostrar usos reales de sus Hololens, que combinan realidad virtual y aumentada.

Literalmente, la comunicación holográfica que hemos visto en decenas de películas de ciencia ficción.

La Holoportation recrea en tiempo real y a tamaño completo a los usuarios en otro lugar, pudiendo comunicarse e interaccionar entre ellos pese a estar separados por kilómetros.

Pero para conseguirlo utilizan un arsenal de cámaras de detección 3D, sensores y, por supuesto, las gafas Hololens, así que de momento no es más que una demostración de lo que son capaces de hacer con ellas.


Como siempre Microsoft nos está vendiendo muy bien Hololens, pero de momento no hay un producto final.

Recordemos que las primeras unidades estarán disponibles para desarrolladores a un módico precio de 3.000 dólares la unidad.


(http://i.imgur.com/9neCrxV.png)

Holoportation:
https://youtu.be/7d59O6cfaM0


Fuente:
Omicrono.com

Ahora bien ¿que opinan ustedes de la Holoportation?

Que pasen un lindo dia tod@s :D

okokok