Iniciar sesiónCerrar
Correo:
Contraseña:
Entrar
Recordar sesión en este navegador
Iniciar sesiónIniciar sesiónCrear cuentaCrear cuenta
LWP » Código Fuente » C/Visual C » Código de C/Visual C - RED NEURONAL.

Código de C/Visual C - RED NEURONAL.

Volver
Agregar Código Fuente
<<>>
Imágen de perfil

RED NEURONAL.gráfica de visualizaciones


C/Visual C

estrellaestrellaestrellaestrellaestrella(1)
Publicado el 7 de Julio del 2023 por Hilario (122 códigos)
4.407 visualizaciones desde el 7 de Julio del 2023
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////


****************************************************************
Aequam memento rebus in arduis servare mentem
------------------------------------------------------

Hilario Iglesias Martínez

***********************************************************************
neurona.c
*****************************************************************
Este es un ejemplo de lo más básico, hecho en lenguaje C que simula una sencillisima red neuronal, y permite introducir parámetros por el teclado a través de consola linux.
Ten en cuenta que este es solo un ejemplo simple y puede requerir modificaciones o mejoras dependiendo de tus conocimientos del tema y necesidades específicas, por lo que el programa está hecho para interactuar con el, modificando parametros del mismo, como la estructura de la red neuronal,la inicialización de la red neuronal, la propagación de la misma, y el cálculo final de los valores de salida.
******************************************************************************
En principio hemos ido a un esquema sencillo, con el fin de no complicar y no hacer inentendible el programa. El esquemá básico que se propone es como sigue:

Esquemáticamente la red neuronal tiene 2 neuronas de entrada, 3 neuronas ocultas y 1 neurona de salida. Los pesos de conexión se inicializan aleatoriamente entre -1 y 1. Luego, se solicitan los valores de entrada al usuario, y se propagan hacia adelante a través de la red neuronal. Finalmente, se muestran los valores de salida calculados.

Es importante explicar un poco lo que es el peso de conexión:
-------------------------------------------------------------
Los pesos de conexión de una neurona son los valores numéricos que determinan la fuerza y la influencia de las entradas en la salida de la neurona. Cada conexión entre una entrada y una neurona está asociada a un peso.

En una red neuronal artificial, los pesos de conexión son parámetros ajustables que se utilizan durante el proceso de entrenamiento para encontrar la configuración óptima de la red neuronal. Estos pesos se actualizan iterativamente en función de la diferencia entre las salidas deseadas y las salidas producidas por la red neuronal.

Cuando se realiza una propagación hacia adelante en la red neuronal, cada neurona recibe las entradas de las neuronas previas ponderadas por los pesos de conexión. Luego, se aplica una función de activación a la suma ponderada para producir la salida de la neurona.

Los pesos de conexión se inicializan típicamente de forma aleatoria al comienzo del entrenamiento, y luego se ajustan durante el proceso de aprendizaje. El objetivo del entrenamiento es encontrar los valores de los pesos que minimizan la diferencia entre las salidas deseadas y las salidas producidas por la red neuronal.

En resumen, los pesos de conexión son parámetros ajustables que determinan la influencia de las entradas en la salida de una neurona. Estos pesos se actualizan durante el entrenamiento para optimizar el rendimiento de la red neuronal en la tarea específica que se está abordando.
--------------------------------------------------------------------------------------

El programa te pedirá que introduzcas los valores de entrada. Después de ingresar los valores, mostrará los valores de salida calculados por la red neuronal.

---------------------------------------------------------------------
Este programa fue realizado y ejecutado en una plataforma linux.
En mi caso
Ubuntu 20.04.6 LTS.
Bajo consola.
Se ha utilizado el IDE:
Sublime Text.
*************************************************************
COMPILACIÓN:
gcc neurona.c -o neurona -lm

Como ves debes agregar la opción -lm al compilar el programa.
Esta opción indica al compilador que enlace la biblioteca
matemática durante la compilación.

EJECUCION:

./neurona

**************************************



Requerimientos

---------------------------------------------------------------------
Este programa fue realizado y ejecutado en una plataforma linux.
En mi caso
Ubuntu 20.04.6 LTS.
Bajo consola.
Se ha utilizado el IDE:
Sublime Text.
*************************************************************

V-1
estrellaestrellaestrellaestrellaestrella(1)

Actualizado el 1 de Agosto del 2023 (Publicado el 7 de Julio del 2023)gráfica de visualizaciones de la versión: V-1
4.408 visualizaciones desde el 7 de Julio del 2023
estrellaestrellaestrellaestrellaestrella
estrellaestrellaestrellaestrella
estrellaestrellaestrella
estrellaestrella
estrella

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
/*
*************************************************************
COMPILACIÓN:
gcc neurona.c -o neurona -lm
Como ves debes agregar la opción -lm al compilar el programa.
Esta opción indica al compilador que enlace la biblioteca
matemática durante la compilación.
EJECUCION:
./neurona
**************************************
*/
 
 
#include <math.h>
/*
Asegúrate de incluir la biblioteca matemática (math.h)
al principio del código para asegurarte de que la
función exp() se importe correctamente.
Con esta corrección, la función sigmoid()
debería calcular correctamente la salida de
la función sigmoide y producir valores entre 0 y 1.
*/
#include <stdio.h>
#include <stdlib.h>
 
 
#define INPUT_NEURONS 2
#define HIDDEN_NEURONS 3
#define OUTPUT_NEURONS 1
 
/* Función de activación (sigmoidal)
La función sigmoide es una función matemática
comúnmente utilizada en redes neuronales y
otras áreas de aprendizaje automático.
Su forma característica es una curva en forma de "S".
La función sigmoide toma cualquier número real
como entrada y produce una salida en
el rango de 0 a 1. La fórmula matemática
de la función sigmoide es la siguiente:
f(x) = 1 / (1 + exp(-x))
Donde x es la entrada de la función.
La función exp es la función exponencial,
que calcula el valor de e
(la base del logaritmo natural) elevado a la potencia -x.
La función sigmoide es útil en redes neuronales porque
su salida se encuentra en el rango de 0 a 1, lo que
puede interpretarse como una probabilidad o una activación.
Es especialmente útil en problemas de clasificación binaria,
donde se desea asignar una entrada a una de dos categorías.
En la función sigmoide, los valores de entrada muy negativos
(grandes en magnitud) se mapean hacia 0,
y los valores de entrada muy positivos (grandes en magnitud)
se mapean hacia 1. Los valores cercanos a cero
se mapean hacia 0.5, lo que indica una respuesta "neutra" o indeterminada.
En resumen, la función sigmoide es una función
de activación comúnmente utilizada en
redes neuronales para introducir
no linealidad y normalizar las salidas entre 0 y 1.
*/
double sigmoid(double x) {
    return 1.0 / (1.0 + exp(-x));
}
 
// Estructura de la red neuronal
typedef struct {
    double input[INPUT_NEURONS];
    double hidden[HIDDEN_NEURONS];
    double output[OUTPUT_NEURONS];
    double weight_ih[INPUT_NEURONS][HIDDEN_NEURONS];
    double weight_ho[HIDDEN_NEURONS][OUTPUT_NEURONS];
} NeuralNetwork;
 
// Inicializar la red neuronal con pesos aleatorios
void initialize(NeuralNetwork *network) {
    // Inicializar pesos entre -1 y 1
    for (int i = 0; i < INPUT_NEURONS; i++) {
        for (int j = 0; j < HIDDEN_NEURONS; j++) {
            network->weight_ih[i][j] = (double)rand() / RAND_MAX * 2 - 1;
        }
    }
 
    for (int i = 0; i < HIDDEN_NEURONS; i++) {
        for (int j = 0; j < OUTPUT_NEURONS; j++) {
            network->weight_ho[i][j] = (double)rand() / RAND_MAX * 2 - 1;
        }
    }
}
 
// Propagar la entrada hacia adelante a través de la red neuronal
void feedforward(NeuralNetwork *network) {
    // Calcular valores ocultos
    for (int i = 0; i < HIDDEN_NEURONS; i++) {
        double sum = 0.0;
        for (int j = 0; j < INPUT_NEURONS; j++) {
            sum += network->input[j] * network->weight_ih[j][i];
        }
        network->hidden[i] = sigmoid(sum);
    }
 
    // Calcular valores de salida
    for (int i = 0; i < OUTPUT_NEURONS; i++) {
        double sum = 0.0;
        for (int j = 0; j < HIDDEN_NEURONS; j++) {
            sum += network->hidden[j] * network->weight_ho[j][i];
        }
        network->output[i] = sigmoid(sum);
    }
}
 
int main() {
    NeuralNetwork network;
 
    // Inicializar la red neuronal
    initialize(&network);
 
    // Obtener los valores de entrada desde el teclado
    printf("Introduce los valores de entrada:\n");
    for (int i = 0; i < INPUT_NEURONS; i++) {
        printf("Entrada %d: ", i + 1);
        scanf("%lf", &network.input[i]);
    }
 
    // Propagar la entrada hacia adelante
    feedforward(&network);
 
    // Mostrar los resultados
    printf("\nValores de salida:\n");
    for (int i = 0; i < OUTPUT_NEURONS; i++) {
        printf("Salida %d: %lf\n", i + 1, network.output[i]);
    }
 
    return 0;
}



Comentarios sobre la versión: V-1 (1)

Imágen de perfil
Hilario
8 de Julio del 2023
estrellaestrellaestrellaestrellaestrella
No ha dejado ningún comentario
Responder

Comentar la versión: V-1

Nombre
Correo (no se visualiza en la web)
Valoración
Comentarios...
CerrarCerrar
CerrarCerrar
Cerrar

Tienes que ser un usuario registrado para poder insertar imágenes, archivos y/o videos.

Puedes registrarte o validarte desde aquí.

Codigo
Negrita
Subrayado
Tachado
Cursiva
Insertar enlace
Imagen externa
Emoticon
Tabular
Centrar
Titulo
Linea
Disminuir
Aumentar
Vista preliminar
sonreir
dientes
lengua
guiño
enfadado
confundido
llorar
avergonzado
sorprendido
triste
sol
estrella
jarra
camara
taza de cafe
email
beso
bombilla
amor
mal
bien
Es necesario revisar y aceptar las políticas de privacidad
Acepto las políticas de privacidad

http://lwp-l.com/s7391