[SOLUCIONADO] Se cierra programa al aproximarse a 1

[shikamarucb]

Hola a todos, tengo el siguiente algoritmo y se me cierra al aproximarse a 1; el algoritmo simula una neurona que reconoce una entrada AND, para probar el algoritmo hay que meter las entradas 1 y 1.

Código C++:

#include <iostream>
#include <math.h>
#include <iomanip>
 
using namespace std;
 
struct dendrita{
    double peso=0.32;
};
 
//3.368998902283415031178037679637782275676727294921875 peso
//0.99883983
class neurona{
private:
    dendrita dendritas[2];
    int i1,i2;
    double sum=0;
    double sesgo=0.02;
 
public:
    neurona(int i, int j){
        i1=i;
        i2=j;
        sum=sesgo+i*dendritas[0].peso+j*dendritas[1].peso;
        cout<<"sum= "<<sum;
    }
 
    void evaluar(){
        double x;
        int xx;
        x=1/(1+pow(2.718281828,(-1*sum)));
        xx=x*10000000;
        x=xx/10000000.0;
 
        cout<<"este es x: "<<x<<endl;
 
        if(x>=1.0){
            cout<<"estoy excitada"<<endl;
            cout<<"Peso: "<<dendritas[0].peso;
        }else{
            //"no estoy excitada, x= "<<
            //cout<<setprecision(150)<<x<<endl<<endl<<endl<<endl;
            recalcular(x);
        }
 
    }
 
    void recalcular(double x){
        double delta=(1-x)*0.01;
 
        int peso1,peso2,delt=delta*10000000;
        delta=delt/10000000.0;
 
 
        dendritas[0].peso=dendritas[0].peso+delta;
        peso1=dendritas[0].peso*100000;
        dendritas[0].peso=peso1/100000.0;
 
        dendritas[1].peso=dendritas[0].peso+delta;
        peso2=dendritas[1].peso*100000;
        dendritas[1].peso=peso2/100000.0;
 
        //cout<<"delta w: "<<setprecision(15)<<delta<<endl;
        cout<<"dendritas peso: "<<dendritas[0].peso<<endl;
        instanciar();
    }
 
    void instanciar(){
        int summ;
        sum=sesgo+i1*dendritas[0].peso+i2*dendritas[1].peso;
        summ=sum*10000000;
        sum=summ/10000000.0;
        cout<<"suma: "<<sum<<endl;
 
        evaluar();
    }
 
    void peso(){
        cout<<"peso= "<<dendritas[0].peso;
    }
};
 
int main()
{
    int x,i1,i2;
 
    cout<<"Digite entrada 1: ";
    cin>>i1;
    cout<<"Digite entrada 2: ";
    cin>>i2;
 
 
    neurona prueba(i1,i2);
 
    prueba.instanciar();
 
    return 0;
}
 

[eferion]

Tu programa tiene dos problemas:

1. la función recalcular no va a alcanzar nunca el valor 1.0. El motivo es que delta tendrá un valor proporcional a la distancia entre el valor real y 1, cuando ambos valores estén lo suficientemente próximos delta tendrá un valor inferior a la precisión de double, de tal forma que:

Código :

dendritas[0].peso=dendritas[0].peso+delta=dendritas[0].peso;
dendritas[1].peso=dendritas[0].peso+delta=dendritas[0].peso;
 

por cierto, fíjate que dendritas[1].peso se igual a dendritas[0].peso, eso no se si es un comportamiento correcto
y esto se producirá para el resto de iteraciones.

esto se podría solucionar si admitieses como valor válido no que x>=1, sino fabs(x-1)<1e-4. De esta forma admites que, por ejemplo, 0.99991 equivale a 1.0

2. El segundo error es un fallo de diseño. Tu programa se basa en la recursividad lo cual no creo que sea lo adecuado dada la naturaleza del algoritmo que pretendes calcular... sería más lógico romper esa recursividad y sustituirla por un bucle, quizás un while sería lo más lógico.

Un saludo

[shikamarucb]

Hola eferion, el valor que tiene alcanzar 1 es el valor de x que esta en la funcion evaluar, delta por el contrario tiene que alcanzar el valor de 0; si delta alcanza el valor de 0 el valor de x tendra que alcanzar el valor de 1 o superior, por eso ando multiplicando por 10000000 para que el double no se me salga del rango de precisión, la verdad no se que pasa...

Iniciado por eferion

Tu programa tiene dos problemas:

1. la función recalcular no va a alcanzar nunca el valor 1.0. El motivo es que delta tendrá un valor proporcional a la distancia entre el valor real y 1, cuando ambos valores estén lo suficientemente próximos delta tendrá un valor inferior a la precisión de double, de tal forma que:

Código :

dendritas[0].peso=dendritas[0].peso+delta=dendritas[0].peso;
dendritas[1].peso=dendritas[0].peso+delta=dendritas[0].peso;
 

por cierto, fíjate que dendritas[1].peso se igual a dendritas[0].peso, eso no se si es un comportamiento correcto
y esto se producirá para el resto de iteraciones.

esto se podría solucionar si admitieses como valor válido no que x>=1, sino fabs(x-1)<1e-4. De esta forma admites que, por ejemplo, 0.99991 equivale a 1.0

2. El segundo error es un fallo de diseño. Tu programa se basa en la recursividad lo cual no creo que sea lo adecuado dada la naturaleza del algoritmo que pretendes calcular... sería más lógico romper esa recursividad y sustituirla por un bucle, quizás un while sería lo más lógico.

Un saludo

[eferion]

Pasa lo siguiente:

Imagina x=0.99999999
delta = (1-x)*0.1 = 0.000000001 (1e-9)
delt = delta*10000000 = 0 (es un int)
delta = delt/10000000.0 = 0

El resto del camino te lo puedes imaginar

[shikamarucb]

Iniciado por eferion

Pasa lo siguiente:

Imagina x=0.99999999
delta = (1-x)*0.1 = 0.000000001 (1e-9)
delt = delta*10000000 = 0 (es un int)
delta = delt/10000000.0 = 0

El resto del camino te lo puedes imaginar

Claro tienes razon; la pregunta es porque se cierra el programa en vez de quedarse en un ciclo infinito..?

[eferion]

Porque las funciones se llaman de forma recursiva, esto es A llama B que a su vez llama a C y esta llama a A y se repite el ciclo. Cada una de estas llamadas va consumiendo la pila del programa... Hasta que la misma se llena y el programa se va al garete.

Si sustituyes la recursividad por un for evitas que la pila se llene.

Si no tienes muy claro que es el stack(pila) y el heap(memoria dinámica) ni sobre las implocaciones de la recursividad deberías consultar sobre ello en google, yo hasta al menos el lunes no voy a sacar tiempo para tratar un tema así.

Un saludo