Reti neurali probabilistiche, pacchetti e algoritmi per MT4 - pagina 11

[Dmitrii]

renegate:
Signori!
Quindi cosa dobbiamo dare in pasto all'input della rete neurale? Quale funzione di errore dobbiamo selezionare?

A giudicare dal contenuto, non ci sono molte persone interessate. Molte persone pensano che si tratti del software....

Ti suggerisco di iniziare con la pendenza della linea di regressione con diversi periodi. E puoi iniziare con diversi TF. :)

Funzionalità dell'errore - massimo profitto.

[Eduard]

klot:

A giudicare dal contenuto, non molte persone sono interessate. Molte persone pensano che sia il software....

Sì, ci sono molti thread neuronici in corso. E dappertutto i flooders intasano qualsiasi discussione con stupide richieste di software e decine di messaggi "io e io e io".

Quindi non c'è un posto dove discutere come si deve. Forse c'è un forum rigorosamente moderato in cui sparano ai fannulloni? Se dici una parola, ricevi un rimprovero; se dici due cose fuori tema, sei ignorato per sempre.

Cloth, hai un sacco di posti da frequentare, forse hai un posto in mente?

[Dmitrii]

TedBeer:

klot:

A giudicare dal contenuto, non ci sono molte persone interessate. Molte persone pensano che si tratti del software....

Oh cavolo!!!, così tanti argomenti sulla neuronica. E dappertutto i flooders intasano qualsiasi discussione con stupide richieste di software e decine di messaggi "io e io e io".

Quindi non c'è un posto dove discutere come si deve. Forse c'è un forum rigorosamente moderato in cui sparano ai fannulloni? Se dici una parola, ottieni un rimprovero; se dici due cose fuori tema, sei ignorato per sempre.

Cloth, hai un sacco di posti da frequentare, forse conosci un posto?

Ho aperto un forum, ora vado a pascolare lì :) E invito tutti a fare una discussione pratica. Io stesso abbatterò gli allagatori :)

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

Sto trasferendo lì, poco a poco, le mie scoperte da diversi luoghi.

[Yuriy Zaytsev]

Un esempio di una semplice non-rete

MICROSOFT VISUAL C++ 6.0

la rete impara l'operazione 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;
}

[Yuriy Zaytsev]

Un'altra rete semplice!

MICROSOFT VISUAL C++ 6.0

questa versione permette di aggiungere strati - cambiare il numero di neuroni negli strati

inizialmente ci sono 3 livelli nella fonte

2 neuroni in ingresso - due in uno strato nascosto e uno in uscita!

// Crea una rete neurale a 3 strati per risolvere il problema XOR, con 2 nodi nei primi due strati,
// e un solo nodo nello strato di uscita.
CBPNet XOR( 3 /* num layers */, 2 /* inputs */,2 /* hidden */,1 /* outputs */ );

// collegare i neuroni su
//
// O - Output
// // \
// // O O - Hidden
// |\ /|
// | | X
// |/ \|
// O - Input
//

per esempio se si mettono 3 neuroni in uno strato nascosto, il risultato diventa più accurato

CBPNet XOR( 3 /* num layers */, 2 /* inputs */,3 /* hidden */,1 /* outputs */ );

aumentare il numero di strati richiede anche l'aumento del numero di neuroni negli strati nascosti

CBPNet XOR( 4 /* num layers */, 2 /* inputs */,20 /* hidden 1 */ ,5 /* hidden 2 */ ,1 /* outputs */ );

Se aumentate i livelli, dovete anche aggiungere una chiamata

// applica il bias allo strato nascosto e allo strato di uscita
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 );

Sono riuscito a ottenere il risultato, ma la rete è molto più lenta da imparare!

[Eduard]

klot:
Ho aperto un forum, ora vado a pascolare lì :) E invito tutti a fare una discussione pratica. Io stesso abbatterò gli allagatori :)

Vado a registrarmi.

[Yuriy Zaytsev]

e un tutorial assolutamente bello!

[Dmitrii]

Funziona meravigliosamente. Si potrebbe anche provare a insegnare alla rete una tabella di moltiplicazione, sotto forma di riconoscimento di modelli.

Come: in[0]=2; in[1]=2; out_des[0]=4; ecc.....

[Виктор]

YuraZ:

e un tutorial assolutamente bello!

Chi altro lo compilerebbe per i non programmatori...

[Prival]

klot:

Rinnegare:
Signori!
Allora, che cosa dobbiamo dare in pasto all'input della rete neurale? Quale funzione di errore dobbiamo scegliere?

A giudicare dal contenuto, non molte persone sono interessate. Molte persone pensano che si tratti del software....

Ti suggerisco di iniziare con la pendenza della linea di regressione con diversi periodi. E puoi iniziare con diversi TF. :)

Errore funzionale - massimo profitto.

Forse sarebbe meglio usare la funzione di errore - non il massimo profitto, ma lo scollegamento (differenza tra la previsione e Close[0]).