Perceptrón en C

Iniciado por karurosu, Marzo 29, 2016, 04:22:22 PM

Tema anterior - Siguiente tema

0 Miembros y 2 Visitantes están viendo este tema.

Imprimir
Ir Abajo Páginas1 2
Acciones del Usuario
Marzo 29, 2016, 04:22:22 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: php
#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.  :)
Marzo 29, 2016, 04:23:26 PM #1
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: php
#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.  :)
Marzo 29, 2016, 04:25:33 PM #2
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: php
#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.  :)
Marzo 29, 2016, 04:28:46 PM #3
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: php
#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.  :)
Marzo 29, 2016, 04:32:34 PM #4
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: php
#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.  :)
Marzo 29, 2016, 04:33:10 PM #5
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: php
#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.  :)
Marzo 29, 2016, 06:34:45 PM #6
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.
Marzo 29, 2016, 06:48:18 PM #7
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.
Marzo 29, 2016, 10:57:30 PM #8
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...
01000110 01101001 01110010 01101101 01100001 00111010 00100000 01000001 01101110 01101111 01101110 01101001 01101101 01100001 00101110
Marzo 29, 2016, 11:02:21 PM #9
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...
01000110 01101001 01110010 01101101 01100001 00111010 00100000 01000001 01101110 01101111 01101110 01101001 01101101 01100001 00101110
Marzo 29, 2016, 11:16:09 PM #10
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   ::)
01000110 01101001 01110010 01101101 01100001 00111010 00100000 01000001 01101110 01101111 01101110 01101001 01101101 01100001 00101110
gh
Marzo 29, 2016, 11:18:02 PM #11
jjhgjh

Marzo 29, 2016, 11:20:41 PM #12
jkhkjh

Marzo 29, 2016, 11:22:24 PM #13
kjhkjh

Marzo 29, 2016, 11:29:24 PM #14
lkjlkjlkj

Marzo 29, 2016, 11:35:52 PM #15
kjhkjhkjhkjh

Marzo 29, 2016, 11:39:54 PM #16
kjhkjhkjh

Marzo 30, 2016, 12:54:12 AM #17
DATABASE PREMIUM
ACTUALIZADO AL 30/03/2016


¿Por qué debería descargar el DATABASE de JDownloader?
Porque le proporcionara cuentas premium como filesmonster, megashares, 1fichier, ryushare, No tienes permitido ver los links. Registrarse o Entrar a mi cuenta, turbobit, uploading y muchas mas... podras descargar como un usuario Premium

DATABASE JDownloader v.2
Código: php
http://datoteke.com/8c50373bf0f441596392d0a2d9b4520c


JDownloader 2 - Offline Installer Para Windows x86/x64
Código: php
http://uploaded.net/file/ufxnlbnz


JDownloader 2 - Offline Installer Para Mac OS X
Código: php
http://uploaded.net/file/7iya5l1t


JDownloader 2 - Offline Installer Para Linux x86/x64
Código: php
http://uploaded.net/file/h571ln2t


JDownloader 2 - Portable(Extraer & Usar)
Código: php
http://uploaded.net/file/nki0u75z
Marzo 30, 2016, 03:57:14 AM #18
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

Marzo 30, 2016, 04:02:40 AM #19
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
Imprimir
Ir Arriba Páginas1 2
Acciones del Usuario