Redes neuronais probabilísticas, pacotes e algoritmos para MT4 - página 11

Novo comentário
 
renegate:
Cavalheiros!
Então, o que devemos alimentar a entrada da rede neural? Que função de erro devemos selecionar?


A julgar pelo conteúdo, não há muitas pessoas interessadas. Muitas pessoas pensam que se trata do software....

Eu sugiro que você comece com a inclinação da linha de regressão com períodos diferentes. E você pode começar com TFs diferentes. :)

Funcionalidade do erro - lucro máximo.

 
klot:

A julgar pelo conteúdo, não há muitas pessoas interessadas. Muita gente pensa que é o software....


Sim, há muitos fios neurônicos em curso. E por todo o lado os inundadores entupem qualquer discussão com pedidos estúpidos de software e dezenas de mensagens "eu e eu e eu".

Portanto, não há lugar para discuti-lo adequadamente. Talvez haja um fórum estritamente moderado onde eles atiram nos flunkies? Se você diz uma palavra, você recebe uma reprimenda; se você diz duas coisas fora do tópico, você é ignorado para sempre.

Pano, você tem muitos lugares para sair, talvez você tenha um lugar em mente?

 
TedBeer:
klot:

A julgar pelo conteúdo, não há muitas pessoas interessadas. Muita gente pensa que se trata do software....


Oh cara!!!, tantos tópicos sobre neurônica. E por todo o lado os inundadores entupem qualquer discussão com pedidos estúpidos de software e dezenas de mensagens "eu e eu e eu".

Portanto, não há lugar para discuti-lo adequadamente. Talvez haja um fórum estritamente moderado onde eles atiram nos flunkies? Se você diz uma palavra, você recebe uma reprimenda; se você diz duas coisas fora do tópico, você é ignorado para sempre.

Pano, você tem muitos lugares para sair, talvez você tenha um lugar que gostaria de tentar.


Comecei um fórum. Vou pastar lá agora :) E estou convidando a todos a terem uma discussão prática. Eu mesmo vou abater os alagadiços :)

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

Estou transferindo minhas descobertas de diferentes lugares de lá pouco a pouco.

 

Um exemplo de uma simples não-rede

MICROSOFT VISUAL C++ 6.0

rede aprender operação 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;
}
Arquivos anexados:
bp_case.zip  41 kb
 

Outra rede simples !

MICROSOFT VISUAL C++ 6.0

esta versão permite que você adicione camadas - altere o número de neurônios em camadas

inicialmente existem 3 camadas na fonte

2 neurônios na entrada - dois em uma camada oculta e um na saída!

// Criar uma rede neural de 3 camadas para resolver o problema XOR, com 2 nós nas duas primeiras camadas,
// e um único nó na camada de saída.
CBPNet XOR( 3 /* num camadas */, 2 /* entradas */,2 /* ocultas */,1 /* saídas */ );

// conectar os neurônios até
//
// O - Saída
// // \
// // O - Escondido
// |
// | | X
// |/ \|
// O - Entrada
//

por exemplo, se você colocar 3 neurônios em uma camada oculta, o resultado se torna mais preciso


CBPNet XOR( 3 /* num camadas */, 2 /* entradas */,3 /* ocultas */,1 /* saídas */ );

aumentar o número de camadas também requer o aumento do número de neurônios nas camadas ocultas

CBPNet XOR( 4 /* num camadas */, 2 /* entradas */,20 /* ocultas 1 */ ,5 /* ocultas 2 */ ,1 /* saídas */ );

Se você aumentar as camadas, você também precisa adicionar uma chamada

// aplicar o viés à camada oculta, e camada de saída
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 );

Consegui obter o resultado, mas a rede é muito mais lenta de aprender!

Arquivos anexados:
cftai.zip  14 kb
 
klot:
Comecei um fórum. Vou pastar lá agora :) E estou convidando a todos a terem uma discussão prática. Eu mesmo vou abater os alagadiços :)
Vou me registrar.
 

e um tutorial absolutamente lindo!

Arquivos anexados:
summing1.zip  48 kb
 

Funciona lindamente. Você também poderia tentar ensinar à rede uma tabela de multiplicação, sob a forma de reconhecimento de padrões.

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

 
YuraZ:

e um tutorial absolutamente lindo!

Quem mais a compilaria para não-programadores.
 
klot:
Renegar:
Cavalheiros!
Então, o que devemos alimentar a entrada da rede neural? Que função de erro devemos escolher?


A julgar pelo conteúdo, não há muitas pessoas interessadas. Muitas pessoas pensam que se trata do software....

Eu sugiro que você comece com a inclinação da linha de regressão com períodos diferentes. E você pode começar com TFs diferentes. :)

Erro funcional - lucro máximo.

Talvez fosse melhor usar a Funcionalidade de Erro - não o lucro máximo, mas a desvinculação (diferença entre previsão e fechamento[0]).

1...456789101112131415161718...20
Novo comentário
Razão: