MT4를 위한 확률적 신경망, 패키지 및 알고리즘 - 페이지 11

새 코멘트
 
renegate :
주님!
그래서 우리는 신경망 의 입력에 무엇을 공급할 것인가? 어떤 오류 함수를 선택할 것인가?


내용으로 판단하면 이것은 누구에게나 별로 관심이 없습니다. 많은 사람들이 소프트웨어라고 생각합니다 ...

나는 선의 경사각으로 시작하는 것을 제안합니다. 다른 기간의 회귀. 그리고 당신은 다른 TF로 할 수 있습니다. :)

오류 기능은 최대 이익입니다.

 
klot :

내용으로 판단하면 이것은 거의 관심이 없습니다. 많은 사람들이 소프트웨어라고 생각합니다 ...


예, 젠장 !!! 그들은 뉴런에 대한 주제를 일으켰습니다. 그리고 어디에서나 Fluders는 소프트웨어의 어리석은 요청과 "나와 나, 그리고 나에게" 수십 개의 메시지로 토론을 채웁니다.

그래서 그것은 정상이며 논의할 곳이 없습니다. 홍수범이 총에 맞는 심하게 중재된 포럼이 있습니까? 그가 한 번 뻔뻔하게 말하자 그는 두 가지 주제에서 벗어난 말을 했습니다. 영원한 무시였습니다.

많은 곳에서 방목하는 응고 , 아마도 염두에두고있는 곳이 있습니까?

 
TedBeer :
클로트 :

내용으로 판단하면 이것은 누구에게나 별로 관심이 없습니다. 많은 사람들이 소프트웨어라고 생각합니다 ...


예, 젠장 !!! 그들은 뉴런에 대한 주제를 일으켰습니다. 그리고 어디에서나 Fluders는 소프트웨어의 어리석은 요청과 "나와 나, 그리고 나에게" 수십 개의 메시지로 토론을 채웁니다.

그래서 그것은 정상이며 논의할 곳이 없습니다. 홍수범이 총에 맞는 심하게 중재된 포럼이 있습니까? 그가 한 번 뻔뻔하게 말하자 그는 두 가지 주제에서 벗어난 말을 했습니다. 영원한 무시였습니다.

많은 곳에서 방목하는 응고 , 아마도 염두에두고있는 곳이 있습니까?


자신을 위한 포럼을 열었습니다. 이제 저는 그곳에서 방목할 것입니다. :) 그리고 저는 모두를 실용적인 토론에 초대합니다. Fluders는 자신을 쏠 것입니다. :)

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

조금씩 다른 곳에서 내 작업을 전송합니다.

 

가장 단순한 비 네트워크의 예

마이크로소프트 비주얼 C++ 6.0

네트워크 학습 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 ;
}
파일:
bp_case.zip  41 kb
 

또 다른 간단한 네트워크!

마이크로소프트 비주얼 C++ 6.0

이 버전에서는 레이어를 추가할 수 있습니다 - 레이어의 뉴런 수 변경

처음에 소스 3 레이어에서

입력에 2개의 뉴런, 은닉층에 2개, 출력에 1개!

// XOR 문제를 풀기 위해 처음 두 레이어에 2개의 노드가 있는 3레이어 신경망을 만듭니다.
// 그리고 출력 레이어의 단일 노드.
CBPNet XOR( 3 /* 레이어 수 */, 2 /* 입력 */,2 /* 은닉 */,1 /* 출력 */ );

// 뉴런을 위로 연결
//
// O - 출력
// / \
// OO - 숨김
// |\ /|
// | 엑스 |
// |/ \|
// OO-입력
//

예를 들어 은닉층에 3개의 뉴런을 넣으면 결과가 더 정확해집니다.


CBPNet XOR( 3 /* 레이어 수 */, 2 /* 입력 */,3 /* 은닉 */,1 /* 출력 */ );

레이어의 수를 늘리면 은닉 레이어의 뉴런 수가 동일한 만큼 증가해야 합니다.

CBPNet XOR( 4 /* num layer */, 2 /* 입력 */,20 /* hidden 1 */ ,5 /* hidden 2 */ ,1 /* 출력 */ );

레이어를 늘릴 때 호출도 추가해야 합니다.

// 은닉층에 바이어스를 적용하고 출력층
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 );

결과는 얻었지만 네트워크는 훨씬 느리게 학습하기 시작했습니다!

파일:
cftai.zip  14 kb
 
klot :
자신을 위한 포럼을 열었습니다. 이제 저는 그곳에서 방목할 것입니다. :) 그리고 저는 모두를 실용적인 토론에 초대합니다. Fluders는 자신을 쏠 것입니다. :)
등록하러 갔다
 

그리고 아주 좋은 튜토리얼!

파일:
summing1.zip  48 kb
 

그것은 아름답게 밝혀졌습니다. 패턴 인식의 형태로 구구단을 네트워크에 가르칠 수도 있습니다.

유형: in[0]=2; in[1]=2; out_des[0]=4; 등....

 
YuraZ :

그리고 아주 좋은 튜토리얼!

프로그래머가 아닌 사람을 위해 누가 컴파일하겠습니까...
 
klot :
배신자 :
주님!
그래서 우리는 신경망 의 입력에 무엇을 공급할 것인가? 어떤 오류 함수를 선택할 것인가?


내용으로 판단하면 이것은 누구에게나 별로 관심이 없습니다. 많은 사람들이 소프트웨어라고 생각합니다 ...

나는 선의 경사각으로 시작하는 것을 제안합니다. 다른 기간의 회귀. 그리고 당신은 다른 TF로 할 수 있습니다. :)

오류 기능은 최대 이익입니다.

오류 기능 이 더 나은 것은 최대 이익이 아니라 불일치(예측과 Close[0]의 차이)입니다.

1...456789101112131415161718...20
새 코멘트
사유: