Redes neuronales probabilísticas, paquetes y algoritmos para MT4 - página 11

Nuevo comentario
 
renegate:
¡Caballeros!
Entonces, ¿qué debemos introducir en la entrada de la red neuronal? ¿Qué función de error debemos seleccionar?


A juzgar por el contenido, no hay mucha gente interesada. Mucha gente cree que se trata del software....

Te sugiero que empieces con la pendiente de la línea de regresión con diferentes periodos. Y puedes empezar con diferentes TFs. :)

Funcionalidad del error - máximo beneficio.

 
klot:

A juzgar por el contenido, no hay mucha gente interesada. Mucha gente cree que es el software....


Sí, hay muchos hilos neuronales en marcha. Y por todas partes los inundadores atascan cualquier discusión con estúpidas peticiones de software y decenas de mensajes "yo y yo y yo".

Así que no hay lugar para discutirlo adecuadamente. ¿Tal vez haya un foro estrictamente moderado donde se dispara a los lacayos? Si dices una palabra, recibes una reprimenda; si dices dos cosas fuera del tema, te ignoran para siempre.

Cloth, tienes un montón de lugares para pasar el rato, ¿tal vez tienes un lugar en mente?

 
TedBeer:
klot:

A juzgar por el contenido, no hay mucha gente interesada. Mucha gente cree que se trata del software....


Oh hombre!!!, tantos temas sobre neuronas. Y por todas partes los inundadores atascan cualquier discusión con estúpidas peticiones de software y decenas de mensajes "yo y yo y yo".

Así que no hay lugar para discutirlo adecuadamente. ¿Tal vez haya un foro estrictamente moderado donde se dispara a los lacayos? Si dices una palabra, recibes una reprimenda; si dices dos cosas fuera del tema, te ignoran para siempre.

Cloth, tienes un montón de lugares para pasar el rato, tal vez tienes un lugar que te gustaría probar.


He abierto un foro. Voy a pastar allí ahora :) E invito a todos a tener una discusión práctica. Voy a derribar los inundadores yo mismo. :)

http://www.fxreal.ru/forums/index.php

Estoy trasladando poco a poco mis hallazgos de diferentes lugares allí.

 

Un ejemplo de red simple

MICROSOFT VISUAL C++ 6.0

la red aprende la operación XOR

 
/* ========================================== *
 * Filename:    bpnet.h                       *
 * Author:        James Matthews.               *
 *                                              *
 * Description:                                  *
 * This is a tiny neural network that uses      *
 * back propagation for weight adjustment.      *
 * ========================================== */
 
#include <math.h>
#include <stdlib.h>
#include <time.h>
 
#define BP_LEARNING    (float)(0.5)    // The learning coefficient.
 
class CBPNet {
    public:
        CBPNet();
        ~CBPNet() {};
 
        float Train(float, float, float);
        float Run(float, float);
 
    private:
        float m_fWeights[3][3];        // Weights for the 3 neurons.
 
        float Sigmoid(float);        // The sigmoid function.
};
 
CBPNet::CBPNet() {
    srand((unsigned)(time(NULL)));
    
    for (int i=0;i<3;i++) {
        for (int j=0;j<3;j++) {
            // For some reason, the Microsoft rand() function
            // generates a random integer. So, I divide by the
            // number by MAXINT/2, to get a num between 0 and 2,
            // the subtract one to get a num between -1 and 1.
            m_fWeights[i][j] = (float)(rand())/(32767/2) - 1;
        }
    }
}
 
float CBPNet::Train(float i1, float i2, float d) {
    // These are all the main variables used in the 
    // routine. Seems easier to group them all here.
    float net1, net2, i3, i4, out;
    
    // Calculate the net values for the hidden layer neurons.
    net1 = 1 * m_fWeights[0][0] + i1 * m_fWeights[1][0] +
          i2 * m_fWeights[2][0];
    net2 = 1 * m_fWeights[0][1] + i1 * m_fWeights[1][1] +
          i2 * m_fWeights[2][1];
 
    // Use the hardlimiter function - the Sigmoid.
    i3 = Sigmoid(net1);
    i4 = Sigmoid(net2);
 
    // Now, calculate the net for the final output layer.
    net1 = 1 * m_fWeights[0][2] + i3 * m_fWeights[1][2] +
             i4 * m_fWeights[2][2];
    out = Sigmoid(net1);
 
    // We have to calculate the deltas for the two layers.
    // Remember, we have to calculate the errors backwards
    // from the output layer to the hidden layer (thus the
    // name 'BACK-propagation').
    float deltas[3];
    
    deltas[2] = out*(1-out)*(d-out);
    deltas[1] = i4*(1-i4)*(m_fWeights[2][2])*(deltas[2]);
    deltas[0] = i3*(1-i3)*(m_fWeights[1][2])*(deltas[2]);
 
    // Now, alter the weights accordingly.
    float v1 = i1, v2 = i2;
    for(int i=0;i<3;i++) {
        // Change the values for the output layer, if necessary.
        if (i == 2) {
            v1 = i3;
            v2 = i4;
        }
                
        m_fWeights[0][i] += BP_LEARNING*1*deltas[i];
        m_fWeights[1][i] += BP_LEARNING*v1*deltas[i];
        m_fWeights[2][i] += BP_LEARNING*v2*deltas[i];
    }
 
    return out;
}
 
float CBPNet::Sigmoid(float num) {
    return (float)(1/(1+exp(-num)));
}
 
float CBPNet::Run(float i1, float i2) {
    // I just copied and pasted the code from the Train() function,
    // so see there for the necessary documentation.
    
    float net1, net2, i3, i4;
    
    net1 = 1 * m_fWeights[0][0] + i1 * m_fWeights[1][0] +
          i2 * m_fWeights[2][0];
 
    net2 = 1 * m_fWeights[0][1] + i1 * m_fWeights[1][1] +
          i2 * m_fWeights[2][1];
 
    i3 = Sigmoid(net1);
    i4 = Sigmoid(net2);
 
    net1 = 1 * m_fWeights[0][2] + i3 * m_fWeights[1][2] +
             i4 * m_fWeights[2][2];
    return Sigmoid(net1);
}
 
//---
 
#include <iostream.h>
#include "bpnet.h"
 
#define BPM_ITER    2000
 
void main() {
 
    CBPNet bp;
 
    for (int i=0;i<BPM_ITER;i++) {
        bp.Train(0,0,0);
        bp.Train(0,1,1);
        bp.Train(1,0,1);
        bp.Train(1,1,0);
    }
 
    cout << "0,0 = " << bp.Run(0,0) << endl;
    cout << "0,1 = " << bp.Run(0,1) << endl;
    cout << "1,0 = " << bp.Run(1,0) << endl;
    cout << "1,1 = " << bp.Run(1,1) << endl;
}
Archivos adjuntos:
bp_case.zip  41 kb
 

Otra red sencilla.

MICROSOFT VISUAL C++ 6.0

esta versión permite añadir capas - cambiar el número de neuronas en las capas

inicialmente hay 3 capas en la fuente

2 neuronas en la entrada, dos en la capa oculta y una en la salida.

// Crear una red neuronal de 3 capas para resolver el problema XOR, con 2 nodos en las dos primeras capas,
// y un solo nodo en la capa de salida.
CBPNet XOR( 3 /* número de capas */, 2 /* entradas */,2 /* ocultas */,1 /* salidas */ );


// Conectar las neuronas hacia arriba
//
// O - Salida
// // \3 // O - Oculta
// || /|
// | | X
// |/ \|
// O - Entrada
//

por ejemplo, si se ponen 3 neuronas en una capa oculta, el resultado es más preciso


CBPNet XOR( 3 /* número de capas */, 2 /* entradas */,3 /* ocultas */,1 /* salidas */ );

el aumento del número de capas requiere también el aumento del número de neuronas en las capas ocultas

CBPNet XOR( 4 /* número de capas */, 2 /* entradas */,20 /* oculta 1 */ ,5 /* oculta 2 */ ,1 /* salidas */ );

Si se aumentan las capas, también hay que añadir una llamada

// aplicar el sesgo a la capa oculta, y a la capa de salida
XOR.SetBias( POINT2D(0,1),BIAS_GLOBAL );
XOR.SetBias( POINT2D(1,1),BIAS_GLOBAL );
XOR.SetBias( POINT2D(1,1),BIAS_GLOBAL );
XOR.SetBias( POINT2D(0,2),BIAS_GLOBAL );

He conseguido el resultado, pero la red es mucho más lenta de aprender.

Archivos adjuntos:
cftai.zip  14 kb
 
klot:
He abierto un foro. Voy a pastar allí ahora :) E invito a todos a tener una discusión práctica. Voy a derribar los inundadores yo mismo. :)
Voy a registrarme.
 

¡y un tutorial absolutamente hermoso!

Archivos adjuntos:
summing1.zip  48 kb
 

Funciona de maravilla. También puedes intentar enseñar a la red una tabla de multiplicar, en forma de reconocimiento de patrones.

Como: in[0]=2; in[1]=2; out_des[0]=4; etc.....

 
YuraZ:

¡y un tutorial absolutamente hermoso!

¿Quién más lo compilaría para los no programadores...
 
klot:
Renégate:
¡Caballeros!
Entonces, ¿qué debemos introducir en la entrada de la red neuronal? ¿Qué función de error debemos elegir?


A juzgar por el contenido, no hay mucha gente interesada. Mucha gente cree que se trata del software....

Te sugiero que empieces con la pendiente de la línea de regresión con diferentes periodos. Y puedes empezar con diferentes TFs. :)

Error funcional - máximo beneficio.

Tal vez sería mejor utilizar la funcionalidad de error - no la ganancia máxima, sino la desvinculación (diferencia entre el pronóstico y Close[0]).

1...456789101112131415161718...20
Nuevo comentario