Neural networks programming with prorealtime

Leo · Fri, 17 Aug 2018 23:07:46 +0000

Hi all, I start to be interesting in Neural Network, it seems to be possible to do in prorealtime even though it has not Arrays (brace yourself, very long codes are coming). Now with multi-time-frame support and neural network, looks very interesting for trading. I found a very useful web that explain neural network in very simple way: http://neuralnetworksanddeeplearning.com/chap1.html I will start experimenting with this topic. For example, I code a Classifier for long entries. //Variables: //candlesback=5 //ProfitRiskRatio=2 //spread=1.5 myATR=average[20](range)//+std[20](range) ExtraStopLoss=MyATR //ExtraStopLoss=3*spread*pipsize classifier=0 //for long trades FOR scan=1 to candlesback DO IF classifier[scan]=1 then BREAK ENDIF LongTradeLength=ProfitRiskRatio*(close[scan]-(low[scan]-ExtraStopLoss[scan])) IF close[scan]+LongTradeLength < high-spread*pipsize then IF lowest[scan+1](low) > low[scan]-ExtraStopLoss[scan]+spread*pipsize then classifier=1 candleentry=barindex-scan BREAK ENDIF ENDIF NEXT IF classifier=1 then DRAWSEGMENT(candleentry,close[barindex-candleentry],barindex,close[barindex-candleentry]+LongTradeLength) COLOURED(0,250,0) DRAWELLIPSE(candleentry-1,low[barindex-candleentry]-ExtraStopLoss,barindex+1,high+ExtraStopLoss) COLOURED(0,250,0) ENDIF return

This topic has 126 replies, 8 voices, and was last updated 7 months ago by MobiusGrey.

Tagged: data mining, machine learning

Viewing 15 posts - 61 through 75 (of 127 total)

← 1 2 3 4 5 6 7 8 9 →

11/02/2018 at 5:41 AM #83980

Leo

Hi all,

Here I add a new classifier that satisfied me: define a very quick movement and only one parameter . When i find the time I update the Neural Network.

Kind Regards

1 user thanked author for this post.

Madrosat

Leo

Participant

Topics: 17

Replies: 357

Been thanked: 144 times

11/09/2018 at 5:46 AM #84453

Leo

Hi all,

I am glad to share with you my new version of a neural network.

I am satisfied (so far) with the performance of the neural network. THE CODE I UPLOAD NOW USES AN OLD VERSION OF THE CLASSIFIER

Here the changes:

–> Implementing gradient descent in mini batches for 10values of data

–> Only 5 epochs per training with constant update of the Learning Rate for faster learning (only 5 because if I incremented to 6 there is an error of infinite loop… I think ProrealCode does not have enough power of press ion to compute a proper gradient descent)

–> I implement learning process with Momentum in order to increase speed of convergence.

–> The Values for the data is an indicator I invent for measure the behaviour of different Moving Averages.

–> If you scroll down the graphic of the indicator (values from -1 to -10), you will see how it shows the different values of weights, bias, Cost and Error which I use to evaluate and check the correct functionality of the Neural Network)

Hope you like it, testing it and sharing your results. I am also glad to hear your opinions.

Cheers

// Hyperparameters to be optimized

// ETA=0.5 //known as the learning rate
// PipsToTrade=25 //pips movement for classifier
// betha=0.1

/////////////////    CLASSIFIER    /////////////


candlerange=average[200](average[100](average[50](abs(close-open))))
candlesback=round(average[200](round(PipsToTrade*pipsize/candlerange)))

IF barindex >600 then
//Supports and resistances
Xcandlesback=round(0.6*candlesback)

highest1=highest[candlesback](high)
IF highest1 = highest1[Xcandlesback] then
Re1=highest1
ENDIF
IF high > Re1 then
Re1=high
ENDIF

lowest1=lowest[candlesback](low)
IF lowest1 = lowest1[Xcandlesback] then
S1=lowest1
ENDIF
If low < S1 then
S1=low
ENDIF


//for long trades
classifierlong=0
IF close - S1 > PipsToTrade*pipsize+candlerange THEN
FOR scanL=1 to candlesback*2 DO
IF classifierlong[scanL]=1 then
BREAK
ENDIF
IF low[scanL]=S1 THEN
classifierlong=1
candleentrylong=barindex-scanL
BREAK
ENDIF
NEXT
ENDIF
//for short trades
classifiershort=0
IF Re1-close > PipsToTrade*pipsize+candlerange THEN
FOR scanS=1 to candlesback*2 DO
IF classifiershort[scanS]=1 then
BREAK
ENDIF
IF High[scanS]=Re1 THEN
classifiershort=1
candleentryshort=barindex-scanS
BREAK
ENDIF
NEXT
ENDIF
ENDIF


/////////////////////////  NEURONAL NETWORK  ///////////////////

// ...INITIAL VALUES...
once a11=1
once a12=-1
once a13=1
once a14=-1

once a21=-1
once a22=1
once a23=-1
once a24=1

once a31=1
once a32=-1
once a33=1
once a34=-1

once a41=-1
once a42=1
once a43=-1
once a44=1

once a51=1
once a52=-1
once a53=1
once a54=-1

once a61=-1
once a62=1
once a63=-1
once a64=1

once Fbias1=1
once Fbias2=1
once Fbias3=1
once Fbias4=1
once Fbias5=1
once Fbias6=1

once b11=1
once b12=1
once b13=1
once b14=1
once b15=1
once b16=1

once b21=1
once b22=1
once b23=1
once b24=1
once b25=1
once b26=1

once Obias1=0
once Obias2=0

// ...DEFINITION OF INPUTS...

//TREND001
SuperPeriod001=7
SuperPeriod002=21
SuperPeriod003=34
SuperPeriod004=77

SuperRange=pipsize*round((average[200](average[100](average[50](average[20](average[5](round(RANGE/pipsize)))))))/2)*2

Curve001=average[SuperPeriod001](close)
Main001=average[SuperPeriod001](Curve001)
Trend001=round(10*(Curve001-Main001)/SuperRange)/10

Curve002=average[SuperPeriod002](close)
Main002=average[SuperPeriod002](Curve002)
Trend002=round(10*(Curve002-Main002)/SuperRange)/10

Curve003=average[SuperPeriod003](close)
Main003=average[SuperPeriod003](Curve003)
Trend003=round(10*(Curve003-Main003)/SuperRange)/10

Curve004=average[SuperPeriod004](close)
Main004=average[SuperPeriod004](Curve004)
Trend004=round(10*(Curve004-Main004)/SuperRange)/10


variable1= Trend001 //or to be defined
variable2= Trend002//or to be defined
variable3= Trend003 // to be defined
variable4= Trend004  // to be defined

//   >>>    LEARNING PROCESS  <<<
// If the classifier has detected a wining trade in the past
//IF hour > 7 and hour < 21 then

//STORING THE LEARNING DATA
IF classifierlong=1 or classifiershort=1 THEN
candleentry0010=candleentry0009
Y10010=Y10009
Y20010=Y20009
candleentry0009=candleentry0008
Y10009=Y10008
Y20009=Y20008
candleentry0008=candleentry0007
Y10008=Y10007
Y20008=Y20007
candleentry0007=candleentry0006
Y10007=Y10006
Y20007=Y20006
candleentry0006=candleentry0005
Y10006=Y10005
Y20006=Y20005
candleentry0005=candleentry0004
Y10005=Y10004
Y20005=Y20004
candleentry0004=candleentry0003
Y10004=Y10003
Y20004=Y20003
candleentry0003=candleentry0002
Y10003=Y10002
Y20003=Y20002
candleentry0002=candleentry0001
Y10002=Y10001
Y20002=Y20001
candleentry0001=max(candleentrylong,candleentryshort)
Y10001=classifierlong
Y20001=classifiershort
ENDIF

once Keta=1
ETAi=ETA*Keta
IF BARINDEX > 3000 THEN
IF classifierlong=1 or classifiershort=1 THEN
IF hour > 8 and hour < 21 then
FOR ii=1 to 5 DO //EPOCHS
//Backing up the old values of the gradient for implement DESCENT GRADIENT WITH MOMENTUM
BDerObias1 = DerObias1
BDerObias2 = DerObias2

BDerb11    = Derb11
BDerb12    = Derb12
BDerb13    = Derb13
BDerb14    = Derb14
BDerb15    = Derb15
BDerb16    = Derb16

BDerb21    = Derb21
BDerb22    = Derb22
BDerb23    = Derb23
BDerb24    = Derb24
BDerb25    = Derb25
BDerb26    = Derb26

BDerFbias1 = DerFbias1
BDerFbias2 = DerFbias2
BDerFbias3 = DerFbias3
BDerFbias4 = DerFbias4
BDerFbias5 = DerFbias5
BDerFbias6 = DerFbias6

BDera11    = Dera11
BDera12    = Dera12
BDera13    = Dera13
BDera14    = Dera14

BDera21    = Dera21
BDera22    = Dera22
BDera23    = Dera23
BDera24    = Dera24

BDera31    = Dera31
BDera32    = Dera32
BDera33    = Dera33
BDera34    = Dera34

BDera41    = Dera41
BDera42    = Dera42
BDera43    = Dera43
BDera44    = Dera44

BDera51    = Dera51
BDera52    = Dera52
BDera53    = Dera53
BDera54    = Dera54

BDera61    = Dera61
BDera62    = Dera62
BDera63    = Dera63
BDera64    = Dera64

//Reseting Error and cost functions
ERROR=0
COST=0
//Reseting the gradient descet for calculting it in the minibatch
DerObias1 = 0
DerObias2 = 0

Derb11    = 0
Derb12    = 0
Derb13    = 0
Derb14    = 0
Derb15    = 0
Derb16    = 0

Derb21    = 0
Derb22    = 0
Derb23    = 0
Derb24    = 0
Derb25    = 0
Derb26    = 0


//   >>> PARTIAL DERIVATES OF COST FUNCTION (LAYER) <<<

DerFbias1 = 0
DerFbias2 = 0
DerFbias3 = 0
DerFbias4 = 0
DerFbias5 = 0
DerFbias6 = 0

Dera11    = 0
Dera12    = 0
Dera13    = 0
Dera14    = 0

Dera21    = 0
Dera22    = 0
Dera23    = 0
Dera24    = 0

Dera31    = 0
Dera32    = 0
Dera33    = 0
Dera34    = 0

Dera41    = 0
Dera42    = 0
Dera43    = 0
Dera44    = 0

Dera51    = 0
Dera52    = 0
Dera53    = 0
Dera54    = 0

Dera61    = 0
Dera62    = 0
Dera63    = 0
Dera64    = 0


FOR i=1 to 10 DO // Gradient descent and backpropagation
IF i = 1 THEN
candleentry=candleentry0010
Y1=Y10010
Y2=Y20010
ELSIF i = 2 THEN
candleentry=candleentry0009
Y1=Y10009
Y2=Y20009
ELSIF i = 3 THEN
candleentry=candleentry0008
Y1=Y10008
Y2=Y20008
ELSIF i = 4 THEN
candleentry=candleentry0007
Y1=Y10007
Y2=Y20007
ELSIF i = 5 THEN
candleentry=candleentry0006
Y1=Y10006
Y2=Y20006
ELSIF i = 6 THEN
candleentry=candleentry0005
Y1=Y10005
Y2=Y20005
ELSIF i = 7 THEN
candleentry=candleentry0004
Y1=Y10004
Y2=Y20004
ELSIF i = 8 THEN
candleentry=candleentry0003
Y1=Y10003
Y2=Y20003
ELSIF i = 9 THEN
candleentry=candleentry0002
Y1=Y10002
Y2=Y20002
ELSIF i = 10 THEN
candleentry=candleentry0001
Y1=Y10001
Y2=Y20001
ENDIF

//    >>> INPUT FOR NEURONS <<<
input1=variable1[barindex-candleentry]
input2=variable2[barindex-candleentry]
input3=variable3[barindex-candleentry]
input4=variable4[barindex-candleentry]

//   >>> FIRST LAYER OF NEURONS <<<
F1=a11*input1+a12*input2+a13*input3+a14*input4+Fbias1
F2=a21*input1+a22*input2+a23*input3+a24*input4+Fbias2
F3=a31*input1+a32*input2+a33*input3+a34*input4+Fbias3
F4=a41*input1+a42*input2+a43*input3+a44*input4+Fbias4
F5=a51*input1+a52*input2+a53*input3+a54*input4+Fbias5
F6=a61*input1+a62*input2+a63*input3+a64*input4+Fbias6
F1=1/(1+EXP(-1*F1))
F2=1/(1+EXP(-1*F2))
F3=1/(1+EXP(-1*F3))
F4=1/(1+EXP(-1*F4))
F5=1/(1+EXP(-1*F5))
F6=1/(1+EXP(-1*F6))
//   >>> OUTPUT NEURONS <<<
output1=b11*F1+b12*F2+b13*F3+b14*F4+b15*F5+b16*F6+Obias1
output2=b21*F1+b22*F2+b23*F3+b24*F4+b25*F5+b26*F6+Obias2
output1=1/(1+EXP(-1*output1))
output2=1/(1+EXP(-1*output2))

//   >>> PARTIAL DERIVATES OF COST FUNCTION <<<
//     ... CROSS-ENTROPY AS COST FUCTION ...
// COST = - ( (Y1*LOG(output1)+(1-Y1)*LOG(1-output1) ) - (Y2*LOG(output2)+(1-Y2)*LOG(1-output2) )

DerObias1 = (output1-Y1) * 1+  DerObias1
DerObias2 = (output2-Y2) * 1+  DerObias2

Derb11    = (output1-Y1) * F1+  Derb11
Derb12    = (output1-Y1) * F2+  Derb12
Derb13    = (output1-Y1) * F3+  Derb13
Derb14    = (output1-Y1) * F4+  Derb14
Derb15    = (output1-Y1) * F5+  Derb15
Derb16    = (output1-Y1) * F6+  Derb16

Derb21    = (output2-Y2) * F1+  Derb21
Derb22    = (output2-Y2) * F2+  Derb22
Derb23    = (output2-Y2) * F3+  Derb23
Derb24    = (output2-Y2) * F4+  Derb24
Derb25    = (output2-Y2) * F5+  Derb25
Derb26    = (output2-Y2) * F6+  Derb26


//   >>> PARTIAL DERIVATES OF COST FUNCTION (LAYER) <<<

DerFbias1 = (output1-Y1) * b11 * F1*(1-F1) * 1 + (output2-Y2) * b21 * F1*(1-F1) * 1+   DerFbias1
DerFbias2 = (output1-Y1) * b12 * F2*(1-F2) * 1 + (output2-Y2) * b22 * F2*(1-F2) * 1+   DerFbias2
DerFbias3 = (output1-Y1) * b13 * F3*(1-F3) * 1 + (output2-Y2) * b23 * F3*(1-F3) * 1+   DerFbias3
DerFbias4 = (output1-Y1) * b14 * F4*(1-F4) * 1 + (output2-Y2) * b24 * F4*(1-F4) * 1+   DerFbias4
DerFbias5 = (output1-Y1) * b15 * F5*(1-F5) * 1 + (output2-Y2) * b25 * F5*(1-F5) * 1+   DerFbias5
DerFbias6 = (output1-Y1) * b16 * F6*(1-F6) * 1 + (output2-Y2) * b26 * F6*(1-F6) * 1+   DerFbias6

Dera11    = (output1-Y1) * b11 * F1*(1-F1) * input1 + (output2-Y2) * b21 * F1*(1-F1) * input1+  Dera11
Dera12    = (output1-Y1) * b11 * F1*(1-F1) * input2 + (output2-Y2) * b21 * F1*(1-F1) * input2+  Dera12
Dera13    = (output1-Y1) * b11 * F1*(1-F1) * input3 + (output2-Y2) * b21 * F1*(1-F1) * input3+  Dera13
Dera14    = (output1-Y1) * b11 * F1*(1-F1) * input4 + (output2-Y2) * b21 * F1*(1-F1) * input4+  Dera14

Dera21    = (output1-Y1) * b12 * F2*(1-F2) * input1 + (output2-Y2) * b22 * F2*(1-F2) * input1+  Dera21
Dera22    = (output1-Y1) * b12 * F2*(1-F2) * input2 + (output2-Y2) * b22 * F2*(1-F2) * input2+  Dera22
Dera23    = (output1-Y1) * b12 * F2*(1-F2) * input3 + (output2-Y2) * b22 * F2*(1-F2) * input3+  Dera23
Dera24    = (output1-Y1) * b12 * F2*(1-F2) * input4 + (output2-Y2) * b22 * F2*(1-F2) * input4+  Dera24

Dera31    = (output1-Y1) * b13 * F3*(1-F3) * input1 + (output2-Y2) * b23 * F3*(1-F3) * input1+  Dera31
Dera32    = (output1-Y1) * b13 * F3*(1-F3) * input2 + (output2-Y2) * b23 * F3*(1-F3) * input2+  Dera32
Dera33    = (output1-Y1) * b13 * F3*(1-F3) * input3 + (output2-Y2) * b23 * F3*(1-F3) * input3+  Dera33
Dera34    = (output1-Y1) * b13 * F3*(1-F3) * input4 + (output2-Y2) * b23 * F3*(1-F3) * input4+  Dera34

Dera41    = (output1-Y1) * b14 * F4*(1-F4) * input1 + (output2-Y2) * b24 * F4*(1-F4) * input1+  Dera41
Dera42    = (output1-Y1) * b14 * F4*(1-F4) * input2 + (output2-Y2) * b24 * F4*(1-F4) * input2+  Dera42
Dera43    = (output1-Y1) * b14 * F4*(1-F4) * input3 + (output2-Y2) * b24 * F4*(1-F4) * input3+  Dera43
Dera44    = (output1-Y1) * b14 * F4*(1-F4) * input4 + (output2-Y2) * b24 * F4*(1-F4) * input4+  Dera44

Dera51    = (output1-Y1) * b15 * F5*(1-F5) * input1 + (output2-Y2) * b25 * F5*(1-F5) * input1+  Dera51
Dera52    = (output1-Y1) * b15 * F5*(1-F5) * input2 + (output2-Y2) * b25 * F5*(1-F5) * input2+  Dera52
Dera53    = (output1-Y1) * b15 * F5*(1-F5) * input3 + (output2-Y2) * b25 * F5*(1-F5) * input3+  Dera53
Dera54    = (output1-Y1) * b15 * F5*(1-F5) * input4 + (output2-Y2) * b25 * F5*(1-F5) * input4+  Dera54

Dera61    = (output1-Y1) * b16 * F6*(1-F6) * input1 + (output2-Y2) * b26 * F6*(1-F6) * input1+  Dera61
Dera62    = (output1-Y1) * b16 * F6*(1-F6) * input2 + (output2-Y2) * b26 * F6*(1-F6) * input2+  Dera62
Dera63    = (output1-Y1) * b16 * F6*(1-F6) * input3 + (output2-Y2) * b26 * F6*(1-F6) * input3+  Dera63
Dera64    = (output1-Y1) * b16 * F6*(1-F6) * input4 + (output2-Y2) * b26 * F6*(1-F6) * input4+  Dera64

ERROR= 0.5*( (output1-Y1)*(output1-Y1) + (output2-Y2)*(output2-Y2) )  +  ERROR
COST= - ( Y1*LOG(output1)+(1-Y1)*LOG(1-output1) ) - ( Y2*LOG(output2)+(1-Y2)*LOG(1-output2) ) + COST

NEXT

DerObias1 = DerObias1/10*(1-betha) + betha*BDerObias1
DerObias2 = DerObias2/10*(1-betha) + betha*BDerObias2

Derb11    = Derb11/10*(1-betha) + betha*BDerb11
Derb12    = Derb12/10*(1-betha) + betha*BDerb12
Derb13    = Derb13/10*(1-betha) + betha*BDerb13
Derb14    = Derb14/10*(1-betha) + betha*BDerb14
Derb15    = Derb15/10*(1-betha) + betha*BDerb15
Derb16    = Derb16/10*(1-betha) + betha*BDerb16

Derb21    = Derb21/10*(1-betha) + betha*BDerb21
Derb22    = Derb22/10*(1-betha) + betha*BDerb22
Derb23    = Derb23/10*(1-betha) + betha*BDerb23
Derb24    = Derb24/10*(1-betha) + betha*BDerb24
Derb25    = Derb25/10*(1-betha) + betha*BDerb25
Derb26    = Derb26/10*(1-betha) + betha*BDerb26

DerFbias1 = DerFbias1/10*(1-betha) + betha*BDerFbias1
DerFbias2 = DerFbias2/10*(1-betha) + betha*BDerFbias2
DerFbias3 = DerFbias3/10*(1-betha) + betha*BDerFbias3
DerFbias4 = DerFbias4/10*(1-betha) + betha*BDerFbias4
DerFbias5 = DerFbias5/10*(1-betha) + betha*BDerFbias5
DerFbias6 = DerFbias6/10*(1-betha) + betha*BDerFbias6

Dera11    = Dera11/10*(1-betha) + betha*BDera11
Dera12    = Dera12/10*(1-betha) + betha*BDera12
Dera13    = Dera13/10*(1-betha) + betha*BDera13
Dera14    = Dera14/10*(1-betha) + betha*BDera14

Dera21    = Dera21/10*(1-betha) + betha*BDera21
Dera22    = Dera22/10*(1-betha) + betha*BDera22
Dera23    = Dera23/10*(1-betha) + betha*BDera23
Dera24    = Dera24/10*(1-betha) + betha*BDera24

Dera31    = Dera31/10*(1-betha) + betha*BDera31
Dera32    = Dera32/10*(1-betha) + betha*BDera32
Dera33    = Dera33/10*(1-betha) + betha*BDera33
Dera34    = Dera34/10*(1-betha) + betha*BDera34

Dera41    = Dera41/10*(1-betha) + betha*BDera41
Dera42    = Dera42/10*(1-betha) + betha*BDera42
Dera43    = Dera43/10*(1-betha) + betha*BDera43
Dera44    = Dera44/10*(1-betha) + betha*BDera44

Dera51    = Dera51/10*(1-betha) + betha*BDera51
Dera52    = Dera52/10*(1-betha) + betha*BDera52
Dera53    = Dera53/10*(1-betha) + betha*BDera53
Dera54    = Dera54/10*(1-betha) + betha*BDera54

Dera61    = Dera61/10*(1-betha) + betha*BDera61
Dera62    = Dera62/10*(1-betha) + betha*BDera62
Dera63    = Dera63/10*(1-betha) + betha*BDera63
Dera64    = Dera64/10*(1-betha) + betha*BDera64

//Implementing BackPropagation
Obias1=Obias1-ETAi*DerObias1
Obias2=Obias2-ETAi*DerObias2

b11=b11-ETAi*Derb11
b12=b12-ETAi*Derb12
b13=b11-ETAi*Derb13
b14=b11-ETAi*Derb14
b15=b11-ETAi*Derb15
b16=b11-ETAi*Derb16

b21=b11-ETAi*Derb21
b22=b12-ETAi*Derb22
b23=b11-ETAi*Derb23
b24=b11-ETAi*Derb24
b25=b11-ETAi*Derb25
b26=b11-ETAi*Derb26

Fbias1=Fbias1-ETAi*DerFbias1
Fbias2=Fbias2-ETAi*DerFbias2
Fbias3=Fbias3-ETAi*DerFbias3
Fbias4=Fbias4-ETAi*DerFbias4
Fbias5=Fbias5-ETAi*DerFbias5
Fbias6=Fbias6-ETAi*DerFbias6

a11=a11-ETAi*Dera11
a12=a12-ETAi*Dera12
a13=a13-ETAi*Dera13
a14=a14-ETAi*Dera14

a21=a21-ETAi*Dera21
a22=a22-ETAi*Dera22
a23=a23-ETAi*Dera23
a24=a24-ETAi*Dera24

a31=a31-ETAi*Dera31
a32=a32-ETAi*Dera32
a33=a33-ETAi*Dera33
a34=a34-ETAi*Dera34

a41=a41-ETAi*Dera41
a42=a42-ETAi*Dera42
a43=a43-ETAi*Dera43
a44=a44-ETAi*Dera44

a51=a51-ETAi*Dera51
a52=a52-ETAi*Dera52
a53=a53-ETAi*Dera53
a54=a54-ETAi*Dera54

a61=a61-ETAi*Dera61
a62=a62-ETAi*Dera62
a63=a63-ETAi*Dera63
a64=a64-ETAi*Dera64

ERROR=ERROR/10
ERROR=round(ERROR*1000)/1000

COST = COST/10
COST= round( COST*1000 ) /1000

DRAWTEXT("C= #COST# , ETAi=#ETAi#", candleentry, -0.15*(ii-1)-0.05, Dialog, Bold, 10) COLOURED(50,150,50)
DRAWTEXT("E= #ERROR#", candleentry, -0.15*(ii-1)-0.11, Dialog, Bold, 10) COLOURED(50,150,50)
DRAWTEXT("a1i: #a11# ; #a12# ; #a13# ; #a14# ; Fb1:#Fbias1#", candleentry, -1-0.1*(ii-1), Dialog, Bold, 10) COLOURED(50,150,50)
DRAWTEXT("a2i: #a21# ; #a22# ; #a23# ; #a24# ; Fb2:#Fbias2#", candleentry, -2-0.1*(ii-1), Dialog, Bold, 10) COLOURED(50,150,50)
DRAWTEXT("a3i: #a31# ; #a32# ; #a33# ; #a34# ; Fb3:#Fbias3#", candleentry, -3-0.1*(ii-1), Dialog, Bold, 10) COLOURED(50,150,50)
DRAWTEXT("a4i: #a41# ; #a42# ; #a43# ; #a44# ; Fb4:#Fbias4#", candleentry, -4-0.1*(ii-1), Dialog, Bold, 10) COLOURED(50,150,50)
DRAWTEXT("a5i: #a51# ; #a52# ; #a53# ; #a54# ; Fb5:#Fbias5#", candleentry, -5-0.1*(ii-1), Dialog, Bold, 10) COLOURED(50,150,50)
DRAWTEXT("a6i: #a61# ; #a62# ; #a63# ; #a64# ; Fb6:#Fbias6#", candleentry, -6-0.1*(ii-1), Dialog, Bold, 10) COLOURED(50,150,50)
DRAWTEXT("b1i: #b11# ; #b12# ; #b13# ; #b14# ; #b15# ; #b16# ; Ob1:#Obias1#", candleentry, -7-0.1*(ii-1), Dialog, Bold, 10) COLOURED(50,150,50)
DRAWTEXT("b2i: #b21# ; #b22# ; #b23# ; #b24# ; #b25# ; #b26# ; Ob2:#Obias2#", candleentry, -8-0.1*(ii-1), Dialog, Bold, 10) COLOURED(50,150,50)

//GradientNorm = SQRT(DerObias1*DerObias1 + DerObias2*DerObias2+Derb11*Derb11+Derb12*Derb12+Derb13*Derb13+Derb14*Derb14+Derb15*Derb15+Derb16*Derb16 + Derb21*Derb21+Derb22*Derb22+Derb23*Derb23+Derb24*Derb24+Derb25*Derb25+Derb26*Derb26 + DerFbias1*DerFbias1+DerFbias2*DerFbias2+DerFbias3+DerFbias3+DerFbias4*DerFbias4+DerFbias4*DerFbias5+DerFbias6*DerFbias6 + Dera11*Dera11+Dera12*Dera12+Dera13*Dera13+Dera14*Dera14 + Dera21*Dera21+Dera22*Dera22+Dera23*Dera23+Dera24*Dera24 + Dera31*Dera31+Dera32*Dera32+Dera33*Dera33+Dera34*Dera34 + Dera41*Dera41+Dera42*Dera42+Dera43*Dera43+Dera44*Dera44 + Dera51*Dera51+Dera52*Dera52+Dera53*Dera53+Dera54*Dera54 + Dera61*Dera61+Dera62*Dera62+Dera63*Dera63+Dera64*Dera64)
//DRAWTEXT("GradientNorm: #GradientNorm#", candleentry, 2-0.1*(ii), Dialog, Bold, 10) COLOURED(50,150,50)

COST2=COST1
COST1=COST

IF COST1 > COST2 and ii>=2 THEN //ETAi must be reduced
ETAi=ETAi/1.5
ELSE //ETAi can be increased
ETAi=ETAi*(1.5+0.2*ii)
ENDIF
COST2=COST1


NEXT
//DRAWTEXT("#candleentry0001#,#candleentry0002#,#candleentry0003#,#candleentry0004#,#candleentry0005#,#candleentry0006#,#candleentry0007#,#candleentry0008#,#candleentry0009#,#candleentry0010#", candleentry, -0.7, Dialog, Bold, 10) COLOURED(50,150,50)
once error1=ERROR
error2=error1
error1=ERROR
//IF error1 < error2 THEN
//Keta=Keta+0.05
//ELSE
//Keta=Keta-0.05
//ENDIF
Keta=Keta*(1+min(0.1,abs((error2-error1)/error1))*SGN(error2-error1))

ENDIF
ENDIF
//ENDIF

///////////////////    NEW PREDICTION  ///////////////////
//    >>> INPUT NEURONS <<<
input1=variable1
input2=variable2
input3=variable3
input4=variable4
//   >>> FIRST LAYER OF NEURONS <<<
F1=a11*input1+a12*input2+a13*input3+a14*input4+Fbias1
F2=a21*input1+a22*input2+a23*input3+a24*input4+Fbias2
F3=a31*input1+a32*input2+a33*input3+a34*input4+Fbias3
F4=a41*input1+a42*input2+a43*input3+a44*input4+Fbias4
F5=a51*input1+a52*input2+a53*input3+a54*input4+Fbias5
F6=a61*input1+a62*input2+a63*input3+a64*input4+Fbias6
F1=1/(1+EXP(-1*F1))
F2=1/(1+EXP(-1*F2))
F3=1/(1+EXP(-1*F3))
F4=1/(1+EXP(-1*F4))
F5=1/(1+EXP(-1*F5))
F6=1/(1+EXP(-1*F6))
//   >>> OUTPUT NEURONS <<<
output1=b11*F1+b12*F2+b13*F3+b14*F4+b15*F5+b16*F6+Obias1
output2=b21*F1+b22*F2+b23*F3+b24*F4+b25*F5+b26*F6+Obias2
output1=1/(1+EXP(-1*output1))
output2=1/(1+EXP(-1*output2))
ENDIF

return output1 coloured(0,150,0) style(line,1) as "prediction long" , output2 coloured(200,0,0) style(line,1) as "prediction short",classifierlong coloured(0,150,0) STYLE(HISTOGRAM,2) AS "classifier_long" , classifiershort coloured(200,0,0) STYLE(HISTOGRAM,2) AS "classifier_short", 0.5 coloured(0,0,200) as "0.5", 0.6 coloured(0,0,200) as "0.6", 0.7 coloured(0,0,200) as "0.7", 0.8 coloured(0,0,200) as "0.8"

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

310

311

312

313

314

315

316

317

318

319

320

321

322

323

324

325

326

327

328

329

330

331

332

333

334

335

336

337

338

339

340

341

342

343

344

345

346

347

348

349

350

351

352

353

354

355

356

357

358

359

360

361

362

363

364

365

366

367

368

369

370

371

372

373

374

375

376

377

378

379

380

381

382

383

384

385

386

387

388

389

390

391

392

393

394

395

396

397

398

399

400

401

402

403

404

405

406

407

408

409

410

411

412

413

414

415

416

417

418

419

420

421

422

423

424

425

426

427

428

429

430

431

432

433

434

435

436

437

438

439

440

441

442

443

444

445

446

447

448

449

450

451

452

453

454

455

456

457

458

459

460

461

462

463

464

465

466

467

468

469

470

471

472

473

474

475

476

477

478

479

480

481

482

483

484

485

486

487

488

489

490

491

492

493

494

495

496

497

498

499

500

501

502

503

504

505

506

507

508

509

510

511

512

513

514

515

516

517

518

519

520

521

522

523

524

525

526

527

528

529

530

531

532

533

534

535

536

537

538

539

540

541

542

543

544

545

546

547

548

549

550

551

552

553

554

555

556

557

558

559

560

561

562

563

564

565

566

567

568

569

570

571

572

573

574

575

576

577

578

579

580

581

582

583

584

585

586

587

588

589

590

591

592

593

594

595

596

597

598

599

600

601

602

603

604

605

606

607

608

609

610

611

612

613

614

615

616

617

618

619

620

621

622

623

624

625

626

627

628

629

630

631

// Hyperparameters to be optimized

// ETA=0.5 //known as the learning rate

// PipsToTrade=25 //pips movement for classifier

// betha=0.1

///////////////// CLASSIFIER /////////////

candlerange=average[200](average[100](average[50](abs(close-open))))

candlesback=round(average[200](round(PipsToTrade*pipsize/candlerange)))

IF barindex >600 then

//Supports and resistances

Xcandlesback=round(0.6*candlesback)

highest1=highest[candlesback](high)

IF highest1 = highest1[Xcandlesback] then

Re1=highest1

ENDIF

IF high > Re1 then

Re1=high

ENDIF

lowest1=lowest[candlesback](low)

IF lowest1 = lowest1[Xcandlesback] then

S1=lowest1

ENDIF

If low < S1 then

S1=low

ENDIF

//for long trades

classifierlong=0

IF close - S1 > PipsToTrade*pipsize+candlerange THEN

FOR scanL=1 to candlesback*2 DO

IF classifierlong[scanL]=1 then

BREAK

ENDIF

IF low[scanL]=S1 THEN

classifierlong=1

candleentrylong=barindex-scanL

BREAK

ENDIF

//for short trades

classifiershort=0

IF Re1-close > PipsToTrade*pipsize+candlerange THEN

FOR scanS=1 to candlesback*2 DO

IF classifiershort[scanS]=1 then

BREAK

ENDIF

IF High[scanS]=Re1 THEN

classifiershort=1

candleentryshort=barindex-scanS

BREAK

ENDIF

///////////////////////// NEURONAL NETWORK ///////////////////

// ...INITIAL VALUES...

once a11=1

once a12=-1

once a13=1

once a14=-1

once a21=-1

once a22=1

once a23=-1

once a24=1

once a31=1

once a32=-1

once a33=1

once a34=-1

once a41=-1

once a42=1

once a43=-1

once a44=1

once a51=1

once a52=-1

once a53=1

once a54=-1

once a61=-1

once a62=1

once a63=-1

once a64=1

once Fbias1=1

once Fbias2=1

once Fbias3=1

once Fbias4=1

once Fbias5=1

once Fbias6=1

once b11=1

once b12=1

once b13=1

once b14=1

once b15=1

once b16=1

once b21=1

once b22=1

once b23=1

once b24=1

once b25=1

once b26=1

once Obias1=0

once Obias2=0

// ...DEFINITION OF INPUTS...

//TREND001

SuperPeriod001=7

SuperPeriod002=21

SuperPeriod003=34

SuperPeriod004=77

SuperRange=pipsize*round((average[200](average[100](average[50](average[20](average[5](round(RANGE/pipsize)))))))/2)*2

Curve001=average[SuperPeriod001](close)

Main001=average[SuperPeriod001](Curve001)

Trend001=round(10*(Curve001-Main001)/SuperRange)/10

Curve002=average[SuperPeriod002](close)

Main002=average[SuperPeriod002](Curve002)

Trend002=round(10*(Curve002-Main002)/SuperRange)/10

Curve003=average[SuperPeriod003](close)

Main003=average[SuperPeriod003](Curve003)

Trend003=round(10*(Curve003-Main003)/SuperRange)/10

Curve004=average[SuperPeriod004](close)

Main004=average[SuperPeriod004](Curve004)

Trend004=round(10*(Curve004-Main004)/SuperRange)/10

variable1= Trend001 //or to be defined

variable2= Trend002//or to be defined

variable3= Trend003 // to be defined

variable4= Trend004 // to be defined

// >>> LEARNING PROCESS <<<

// If the classifier has detected a wining trade in the past

//IF hour > 7 and hour < 21 then

//STORING THE LEARNING DATA

IF classifierlong=1 or classifiershort=1 THEN

candleentry0010=candleentry0009

Y10010=Y10009

Y20010=Y20009

candleentry0009=candleentry0008

Y10009=Y10008

Y20009=Y20008

candleentry0008=candleentry0007

Y10008=Y10007

Y20008=Y20007

candleentry0007=candleentry0006

Y10007=Y10006

Y20007=Y20006

candleentry0006=candleentry0005

Y10006=Y10005

Y20006=Y20005

candleentry0005=candleentry0004

Y10005=Y10004

Y20005=Y20004

candleentry0004=candleentry0003

Y10004=Y10003

Y20004=Y20003

candleentry0003=candleentry0002

Y10003=Y10002

Y20003=Y20002

candleentry0002=candleentry0001

Y10002=Y10001

Y20002=Y20001

candleentry0001=max(candleentrylong,candleentryshort)

Y10001=classifierlong

Y20001=classifiershort

ENDIF

once Keta=1

ETAi=ETA*Keta

IF BARINDEX > 3000 THEN

IF classifierlong=1 or classifiershort=1 THEN

IF hour > 8 and hour < 21 then

FOR ii=1 to 5 DO //EPOCHS

//Backing up the old values of the gradient for implement DESCENT GRADIENT WITH MOMENTUM

BDerObias1 = DerObias1

BDerObias2 = DerObias2

BDerb11 = Derb11

BDerb12 = Derb12

BDerb13 = Derb13

BDerb14 = Derb14

BDerb15 = Derb15

BDerb16 = Derb16

BDerb21 = Derb21

BDerb22 = Derb22

BDerb23 = Derb23

BDerb24 = Derb24

BDerb25 = Derb25

BDerb26 = Derb26

BDerFbias1 = DerFbias1

BDerFbias2 = DerFbias2

BDerFbias3 = DerFbias3

BDerFbias4 = DerFbias4

BDerFbias5 = DerFbias5

BDerFbias6 = DerFbias6

BDera11 = Dera11

BDera12 = Dera12

BDera13 = Dera13

BDera14 = Dera14

BDera21 = Dera21

BDera22 = Dera22

BDera23 = Dera23

BDera24 = Dera24

BDera31 = Dera31

BDera32 = Dera32

BDera33 = Dera33

BDera34 = Dera34

BDera41 = Dera41

BDera42 = Dera42

BDera43 = Dera43

BDera44 = Dera44

BDera51 = Dera51

BDera52 = Dera52

BDera53 = Dera53

BDera54 = Dera54

BDera61 = Dera61

BDera62 = Dera62

BDera63 = Dera63

BDera64 = Dera64

//Reseting Error and cost functions

ERROR=0

COST=0

//Reseting the gradient descet for calculting it in the minibatch

DerObias1 = 0

DerObias2 = 0

Derb11 = 0

Derb12 = 0

Derb13 = 0

Derb14 = 0

Derb15 = 0

Derb16 = 0

Derb21 = 0

Derb22 = 0

Derb23 = 0

Derb24 = 0

Derb25 = 0

Derb26 = 0

// >>> PARTIAL DERIVATES OF COST FUNCTION (LAYER) <<<

DerFbias1 = 0

DerFbias2 = 0

DerFbias3 = 0

DerFbias4 = 0

DerFbias5 = 0

DerFbias6 = 0

Dera11 = 0

Dera12 = 0

Dera13 = 0

Dera14 = 0

Dera21 = 0

Dera22 = 0

Dera23 = 0

Dera24 = 0

Dera31 = 0

Dera32 = 0

Dera33 = 0

Dera34 = 0

Dera41 = 0

Dera42 = 0

Dera43 = 0

Dera44 = 0

Dera51 = 0

Dera52 = 0

Dera53 = 0

Dera54 = 0

Dera61 = 0

Dera62 = 0

Dera63 = 0

Dera64 = 0

FOR i=1 to 10 DO // Gradient descent and backpropagation

IF i = 1 THEN

candleentry=candleentry0010

Y1=Y10010

Y2=Y20010

ELSIF i = 2 THEN

candleentry=candleentry0009

Y1=Y10009

Y2=Y20009

ELSIF i = 3 THEN

candleentry=candleentry0008

Y1=Y10008

Y2=Y20008

ELSIF i = 4 THEN

candleentry=candleentry0007

Y1=Y10007

Y2=Y20007

ELSIF i = 5 THEN

candleentry=candleentry0006

Y1=Y10006

Y2=Y20006

ELSIF i = 6 THEN

candleentry=candleentry0005

Y1=Y10005

Y2=Y20005

ELSIF i = 7 THEN

candleentry=candleentry0004

Y1=Y10004

Y2=Y20004

ELSIF i = 8 THEN

candleentry=candleentry0003

Y1=Y10003

Y2=Y20003

ELSIF i = 9 THEN

candleentry=candleentry0002

Y1=Y10002

Y2=Y20002

ELSIF i = 10 THEN

candleentry=candleentry0001

Y1=Y10001

Y2=Y20001

ENDIF

// >>> INPUT FOR NEURONS <<<

input1=variable1[barindex-candleentry]

input2=variable2[barindex-candleentry]

input3=variable3[barindex-candleentry]

input4=variable4[barindex-candleentry]

// >>> FIRST LAYER OF NEURONS <<<

F1=a11*input1+a12*input2+a13*input3+a14*input4+Fbias1

F2=a21*input1+a22*input2+a23*input3+a24*input4+Fbias2

F3=a31*input1+a32*input2+a33*input3+a34*input4+Fbias3

F4=a41*input1+a42*input2+a43*input3+a44*input4+Fbias4

F5=a51*input1+a52*input2+a53*input3+a54*input4+Fbias5

F6=a61*input1+a62*input2+a63*input3+a64*input4+Fbias6

F1=1/(1+EXP(-1*F1))

F2=1/(1+EXP(-1*F2))

F3=1/(1+EXP(-1*F3))

F4=1/(1+EXP(-1*F4))

F5=1/(1+EXP(-1*F5))

F6=1/(1+EXP(-1*F6))

// >>> OUTPUT NEURONS <<<

output1=b11*F1+b12*F2+b13*F3+b14*F4+b15*F5+b16*F6+Obias1

output2=b21*F1+b22*F2+b23*F3+b24*F4+b25*F5+b26*F6+Obias2

output1=1/(1+EXP(-1*output1))

output2=1/(1+EXP(-1*output2))

// >>> PARTIAL DERIVATES OF COST FUNCTION <<<

// ... CROSS-ENTROPY AS COST FUCTION ...

// COST = - ( (Y1*LOG(output1)+(1-Y1)*LOG(1-output1) ) - (Y2*LOG(output2)+(1-Y2)*LOG(1-output2) )

DerObias1 = (output1-Y1) * 1+ DerObias1

DerObias2 = (output2-Y2) * 1+ DerObias2

Derb11 = (output1-Y1) * F1+ Derb11

Derb12 = (output1-Y1) * F2+ Derb12

Derb13 = (output1-Y1) * F3+ Derb13

Derb14 = (output1-Y1) * F4+ Derb14

Derb15 = (output1-Y1) * F5+ Derb15

Derb16 = (output1-Y1) * F6+ Derb16

Derb21 = (output2-Y2) * F1+ Derb21

Derb22 = (output2-Y2) * F2+ Derb22

Derb23 = (output2-Y2) * F3+ Derb23

Derb24 = (output2-Y2) * F4+ Derb24

Derb25 = (output2-Y2) * F5+ Derb25

Derb26 = (output2-Y2) * F6+ Derb26

// >>> PARTIAL DERIVATES OF COST FUNCTION (LAYER) <<<

DerFbias1 = (output1-Y1) * b11 * F1*(1-F1) * 1 + (output2-Y2) * b21 * F1*(1-F1) * 1+ DerFbias1

DerFbias2 = (output1-Y1) * b12 * F2*(1-F2) * 1 + (output2-Y2) * b22 * F2*(1-F2) * 1+ DerFbias2

DerFbias3 = (output1-Y1) * b13 * F3*(1-F3) * 1 + (output2-Y2) * b23 * F3*(1-F3) * 1+ DerFbias3

DerFbias4 = (output1-Y1) * b14 * F4*(1-F4) * 1 + (output2-Y2) * b24 * F4*(1-F4) * 1+ DerFbias4

DerFbias5 = (output1-Y1) * b15 * F5*(1-F5) * 1 + (output2-Y2) * b25 * F5*(1-F5) * 1+ DerFbias5

DerFbias6 = (output1-Y1) * b16 * F6*(1-F6) * 1 + (output2-Y2) * b26 * F6*(1-F6) * 1+ DerFbias6

Dera11 = (output1-Y1) * b11 * F1*(1-F1) * input1 + (output2-Y2) * b21 * F1*(1-F1) * input1+ Dera11

Dera12 = (output1-Y1) * b11 * F1*(1-F1) * input2 + (output2-Y2) * b21 * F1*(1-F1) * input2+ Dera12

Dera13 = (output1-Y1) * b11 * F1*(1-F1) * input3 + (output2-Y2) * b21 * F1*(1-F1) * input3+ Dera13

Dera14 = (output1-Y1) * b11 * F1*(1-F1) * input4 + (output2-Y2) * b21 * F1*(1-F1) * input4+ Dera14

Dera21 = (output1-Y1) * b12 * F2*(1-F2) * input1 + (output2-Y2) * b22 * F2*(1-F2) * input1+ Dera21

Dera22 = (output1-Y1) * b12 * F2*(1-F2) * input2 + (output2-Y2) * b22 * F2*(1-F2) * input2+ Dera22

Dera23 = (output1-Y1) * b12 * F2*(1-F2) * input3 + (output2-Y2) * b22 * F2*(1-F2) * input3+ Dera23

Dera24 = (output1-Y1) * b12 * F2*(1-F2) * input4 + (output2-Y2) * b22 * F2*(1-F2) * input4+ Dera24

Dera31 = (output1-Y1) * b13 * F3*(1-F3) * input1 + (output2-Y2) * b23 * F3*(1-F3) * input1+ Dera31

Dera32 = (output1-Y1) * b13 * F3*(1-F3) * input2 + (output2-Y2) * b23 * F3*(1-F3) * input2+ Dera32

Dera33 = (output1-Y1) * b13 * F3*(1-F3) * input3 + (output2-Y2) * b23 * F3*(1-F3) * input3+ Dera33

Dera34 = (output1-Y1) * b13 * F3*(1-F3) * input4 + (output2-Y2) * b23 * F3*(1-F3) * input4+ Dera34

Dera41 = (output1-Y1) * b14 * F4*(1-F4) * input1 + (output2-Y2) * b24 * F4*(1-F4) * input1+ Dera41

Dera42 = (output1-Y1) * b14 * F4*(1-F4) * input2 + (output2-Y2) * b24 * F4*(1-F4) * input2+ Dera42

Dera43 = (output1-Y1) * b14 * F4*(1-F4) * input3 + (output2-Y2) * b24 * F4*(1-F4) * input3+ Dera43

Dera44 = (output1-Y1) * b14 * F4*(1-F4) * input4 + (output2-Y2) * b24 * F4*(1-F4) * input4+ Dera44

Dera51 = (output1-Y1) * b15 * F5*(1-F5) * input1 + (output2-Y2) * b25 * F5*(1-F5) * input1+ Dera51

Dera52 = (output1-Y1) * b15 * F5*(1-F5) * input2 + (output2-Y2) * b25 * F5*(1-F5) * input2+ Dera52

Dera53 = (output1-Y1) * b15 * F5*(1-F5) * input3 + (output2-Y2) * b25 * F5*(1-F5) * input3+ Dera53

Dera54 = (output1-Y1) * b15 * F5*(1-F5) * input4 + (output2-Y2) * b25 * F5*(1-F5) * input4+ Dera54

Dera61 = (output1-Y1) * b16 * F6*(1-F6) * input1 + (output2-Y2) * b26 * F6*(1-F6) * input1+ Dera61

Dera62 = (output1-Y1) * b16 * F6*(1-F6) * input2 + (output2-Y2) * b26 * F6*(1-F6) * input2+ Dera62

Dera63 = (output1-Y1) * b16 * F6*(1-F6) * input3 + (output2-Y2) * b26 * F6*(1-F6) * input3+ Dera63

Dera64 = (output1-Y1) * b16 * F6*(1-F6) * input4 + (output2-Y2) * b26 * F6*(1-F6) * input4+ Dera64

ERROR= 0.5*( (output1-Y1)*(output1-Y1) + (output2-Y2)*(output2-Y2) ) + ERROR

COST= - ( Y1*LOG(output1)+(1-Y1)*LOG(1-output1) ) - ( Y2*LOG(output2)+(1-Y2)*LOG(1-output2) ) + COST

DerObias1 = DerObias1/10*(1-betha) + betha*BDerObias1

DerObias2 = DerObias2/10*(1-betha) + betha*BDerObias2

Derb11 = Derb11/10*(1-betha) + betha*BDerb11

Derb12 = Derb12/10*(1-betha) + betha*BDerb12

Derb13 = Derb13/10*(1-betha) + betha*BDerb13

Derb14 = Derb14/10*(1-betha) + betha*BDerb14

Derb15 = Derb15/10*(1-betha) + betha*BDerb15

Derb16 = Derb16/10*(1-betha) + betha*BDerb16

Derb21 = Derb21/10*(1-betha) + betha*BDerb21

Derb22 = Derb22/10*(1-betha) + betha*BDerb22

Derb23 = Derb23/10*(1-betha) + betha*BDerb23

Derb24 = Derb24/10*(1-betha) + betha*BDerb24

Derb25 = Derb25/10*(1-betha) + betha*BDerb25

Derb26 = Derb26/10*(1-betha) + betha*BDerb26

DerFbias1 = DerFbias1/10*(1-betha) + betha*BDerFbias1

DerFbias2 = DerFbias2/10*(1-betha) + betha*BDerFbias2

DerFbias3 = DerFbias3/10*(1-betha) + betha*BDerFbias3

DerFbias4 = DerFbias4/10*(1-betha) + betha*BDerFbias4

DerFbias5 = DerFbias5/10*(1-betha) + betha*BDerFbias5

DerFbias6 = DerFbias6/10*(1-betha) + betha*BDerFbias6

Dera11 = Dera11/10*(1-betha) + betha*BDera11

Dera12 = Dera12/10*(1-betha) + betha*BDera12

Dera13 = Dera13/10*(1-betha) + betha*BDera13

Dera14 = Dera14/10*(1-betha) + betha*BDera14

Dera21 = Dera21/10*(1-betha) + betha*BDera21

Dera22 = Dera22/10*(1-betha) + betha*BDera22

Dera23 = Dera23/10*(1-betha) + betha*BDera23

Dera24 = Dera24/10*(1-betha) + betha*BDera24

Dera31 = Dera31/10*(1-betha) + betha*BDera31

Dera32 = Dera32/10*(1-betha) + betha*BDera32

Dera33 = Dera33/10*(1-betha) + betha*BDera33

Dera34 = Dera34/10*(1-betha) + betha*BDera34

Dera41 = Dera41/10*(1-betha) + betha*BDera41

Dera42 = Dera42/10*(1-betha) + betha*BDera42

Dera43 = Dera43/10*(1-betha) + betha*BDera43

Dera44 = Dera44/10*(1-betha) + betha*BDera44

Dera51 = Dera51/10*(1-betha) + betha*BDera51

Dera52 = Dera52/10*(1-betha) + betha*BDera52

Dera53 = Dera53/10*(1-betha) + betha*BDera53

Dera54 = Dera54/10*(1-betha) + betha*BDera54

Dera61 = Dera61/10*(1-betha) + betha*BDera61

Dera62 = Dera62/10*(1-betha) + betha*BDera62

Dera63 = Dera63/10*(1-betha) + betha*BDera63

Dera64 = Dera64/10*(1-betha) + betha*BDera64

//Implementing BackPropagation

Obias1=Obias1-ETAi*DerObias1

Obias2=Obias2-ETAi*DerObias2

b11=b11-ETAi*Derb11

b12=b12-ETAi*Derb12

b13=b11-ETAi*Derb13

b14=b11-ETAi*Derb14

b15=b11-ETAi*Derb15

b16=b11-ETAi*Derb16

b21=b11-ETAi*Derb21

b22=b12-ETAi*Derb22

b23=b11-ETAi*Derb23

b24=b11-ETAi*Derb24

b25=b11-ETAi*Derb25

b26=b11-ETAi*Derb26

Fbias1=Fbias1-ETAi*DerFbias1

Fbias2=Fbias2-ETAi*DerFbias2

Fbias3=Fbias3-ETAi*DerFbias3

Fbias4=Fbias4-ETAi*DerFbias4

Fbias5=Fbias5-ETAi*DerFbias5

Fbias6=Fbias6-ETAi*DerFbias6

a11=a11-ETAi*Dera11

a12=a12-ETAi*Dera12

a13=a13-ETAi*Dera13

a14=a14-ETAi*Dera14

a21=a21-ETAi*Dera21

a22=a22-ETAi*Dera22

a23=a23-ETAi*Dera23

a24=a24-ETAi*Dera24

a31=a31-ETAi*Dera31

a32=a32-ETAi*Dera32

a33=a33-ETAi*Dera33

a34=a34-ETAi*Dera34

a41=a41-ETAi*Dera41

a42=a42-ETAi*Dera42

a43=a43-ETAi*Dera43

a44=a44-ETAi*Dera44

a51=a51-ETAi*Dera51

a52=a52-ETAi*Dera52

a53=a53-ETAi*Dera53

a54=a54-ETAi*Dera54

a61=a61-ETAi*Dera61

a62=a62-ETAi*Dera62

a63=a63-ETAi*Dera63

a64=a64-ETAi*Dera64

ERROR=ERROR/10

ERROR=round(ERROR*1000)/1000

COST = COST/10

COST= round( COST*1000 ) /1000

DRAWTEXT("C= #COST# , ETAi=#ETAi#", candleentry, -0.15*(ii-1)-0.05, Dialog, Bold, 10) COLOURED(50,150,50)

DRAWTEXT("E= #ERROR#", candleentry, -0.15*(ii-1)-0.11, Dialog, Bold, 10) COLOURED(50,150,50)

DRAWTEXT("a1i: #a11# ; #a12# ; #a13# ; #a14# ; Fb1:#Fbias1#", candleentry, -1-0.1*(ii-1), Dialog, Bold, 10) COLOURED(50,150,50)

DRAWTEXT("a2i: #a21# ; #a22# ; #a23# ; #a24# ; Fb2:#Fbias2#", candleentry, -2-0.1*(ii-1), Dialog, Bold, 10) COLOURED(50,150,50)

DRAWTEXT("a3i: #a31# ; #a32# ; #a33# ; #a34# ; Fb3:#Fbias3#", candleentry, -3-0.1*(ii-1), Dialog, Bold, 10) COLOURED(50,150,50)

DRAWTEXT("a4i: #a41# ; #a42# ; #a43# ; #a44# ; Fb4:#Fbias4#", candleentry, -4-0.1*(ii-1), Dialog, Bold, 10) COLOURED(50,150,50)

DRAWTEXT("a5i: #a51# ; #a52# ; #a53# ; #a54# ; Fb5:#Fbias5#", candleentry, -5-0.1*(ii-1), Dialog, Bold, 10) COLOURED(50,150,50)

DRAWTEXT("a6i: #a61# ; #a62# ; #a63# ; #a64# ; Fb6:#Fbias6#", candleentry, -6-0.1*(ii-1), Dialog, Bold, 10) COLOURED(50,150,50)

DRAWTEXT("b1i: #b11# ; #b12# ; #b13# ; #b14# ; #b15# ; #b16# ; Ob1:#Obias1#", candleentry, -7-0.1*(ii-1), Dialog, Bold, 10) COLOURED(50,150,50)

DRAWTEXT("b2i: #b21# ; #b22# ; #b23# ; #b24# ; #b25# ; #b26# ; Ob2:#Obias2#", candleentry, -8-0.1*(ii-1), Dialog, Bold, 10) COLOURED(50,150,50)

//GradientNorm = SQRT(DerObias1*DerObias1 + DerObias2*DerObias2+Derb11*Derb11+Derb12*Derb12+Derb13*Derb13+Derb14*Derb14+Derb15*Derb15+Derb16*Derb16 + Derb21*Derb21+Derb22*Derb22+Derb23*Derb23+Derb24*Derb24+Derb25*Derb25+Derb26*Derb26 + DerFbias1*DerFbias1+DerFbias2*DerFbias2+DerFbias3+DerFbias3+DerFbias4*DerFbias4+DerFbias4*DerFbias5+DerFbias6*DerFbias6 + Dera11*Dera11+Dera12*Dera12+Dera13*Dera13+Dera14*Dera14 + Dera21*Dera21+Dera22*Dera22+Dera23*Dera23+Dera24*Dera24 + Dera31*Dera31+Dera32*Dera32+Dera33*Dera33+Dera34*Dera34 + Dera41*Dera41+Dera42*Dera42+Dera43*Dera43+Dera44*Dera44 + Dera51*Dera51+Dera52*Dera52+Dera53*Dera53+Dera54*Dera54 + Dera61*Dera61+Dera62*Dera62+Dera63*Dera63+Dera64*Dera64)

//DRAWTEXT("GradientNorm: #GradientNorm#", candleentry, 2-0.1*(ii), Dialog, Bold, 10) COLOURED(50,150,50)

COST2=COST1

COST1=COST

IF COST1 > COST2 and ii>=2 THEN //ETAi must be reduced

ETAi=ETAi/1.5

ELSE //ETAi can be increased

ETAi=ETAi*(1.5+0.2*ii)

ENDIF

COST2=COST1

//DRAWTEXT("#candleentry0001#,#candleentry0002#,#candleentry0003#,#candleentry0004#,#candleentry0005#,#candleentry0006#,#candleentry0007#,#candleentry0008#,#candleentry0009#,#candleentry0010#", candleentry, -0.7, Dialog, Bold, 10) COLOURED(50,150,50)

once error1=ERROR

error2=error1

error1=ERROR

//IF error1 < error2 THEN

//Keta=Keta+0.05

//ELSE

//Keta=Keta-0.05

//ENDIF

Keta=Keta*(1+min(0.1,abs((error2-error1)/error1))*SGN(error2-error1))

ENDIF

//ENDIF

/////////////////// NEW PREDICTION ///////////////////

// >>> INPUT NEURONS <<<

input1=variable1

input2=variable2

input3=variable3

input4=variable4

// >>> FIRST LAYER OF NEURONS <<<

F1=a11*input1+a12*input2+a13*input3+a14*input4+Fbias1

F2=a21*input1+a22*input2+a23*input3+a24*input4+Fbias2

F3=a31*input1+a32*input2+a33*input3+a34*input4+Fbias3

F4=a41*input1+a42*input2+a43*input3+a44*input4+Fbias4

F5=a51*input1+a52*input2+a53*input3+a54*input4+Fbias5

F6=a61*input1+a62*input2+a63*input3+a64*input4+Fbias6

F1=1/(1+EXP(-1*F1))

F2=1/(1+EXP(-1*F2))

F3=1/(1+EXP(-1*F3))

F4=1/(1+EXP(-1*F4))

F5=1/(1+EXP(-1*F5))

F6=1/(1+EXP(-1*F6))

// >>> OUTPUT NEURONS <<<

output1=b11*F1+b12*F2+b13*F3+b14*F4+b15*F5+b16*F6+Obias1

output2=b21*F1+b22*F2+b23*F3+b24*F4+b25*F5+b26*F6+Obias2

output1=1/(1+EXP(-1*output1))

output2=1/(1+EXP(-1*output2))

ENDIF

return output1 coloured(0,150,0) style(line,1) as "prediction long" , output2 coloured(200,0,0) style(line,1) as "prediction short",classifierlong coloured(0,150,0) STYLE(HISTOGRAM,2) AS "classifier_long" , classifiershort coloured(200,0,0) STYLE(HISTOGRAM,2) AS "classifier_short", 0.5 coloured(0,0,200) as "0.5", 0.6 coloured(0,0,200) as "0.6", 0.7 coloured(0,0,200) as "0.7", 0.8 coloured(0,0,200) as "0.8"

6 users thanked author for this post.

Gianluca,

Raspoutine,

Nicolas,

Meta Signals Pro,

GraHal,

swapping

Leo

Participant

Topics: 17

Replies: 357

Been thanked: 144 times

11/09/2018 at 11:45 AM #84477

Meta Signals Pro

Hi Leo,

I feel like in Sci-Fi with this indicator;-) and it is great;

thanks a lot for sharing;

I tried it on stocks but was unable to make it release its prediction! I surely missed smthing (see picture).

Should we change smthing?

Can you give us on which asset you were able to have the graph you mentioned in your post?

1 user thanked author for this post.

Madrosat

Meta Signals Pro

Participant

Topics: 40

Replies: 310

Been thanked: 37 times

11/09/2018 at 12:46 PM #84480

Leo

Hi.

Well. First you should know that this is not a universal indicator. Not like, we both see the same stuff if we open it.

You need to load many bars like 20000bars then you give enough time to the indicator to learn. If you open it with 20k and me with 30k. My indicator has learn more than yours.

Another parameters is the pips to a metaphirc trade. Now we look for possible trades and learn what has happend in the moment of entry the trade.

For the prediction you take a value from 0.5 to 0.999 for make where is ypur predicition.

In any case, There is a lot of work ahead. Thats why I share. Me alone I can not do it as faster I want.

The neural network itself is working properlly ( with the limitations of prorealtime). That I recheck and recheck. And corrected and redoing stufff and checked it againg. Pufff

Leo

Participant

Topics: 17

Replies: 357

Been thanked: 144 times

11/09/2018 at 1:40 PM #84483

GraHal

Thank you Leo for your ongoing work and for being so kind to share with us!

I made a System out of your latest NN Code … equity curve attached over 100k bars with spread = 4.

I have it on Demo Fwd Test from today … I’ll report back on here after 10 trades.

GraHal

Participant

Topics: 204

Replies: 8397

Been thanked: 2039 times

11/09/2018 at 2:09 PM #84489

Nicolas

@Kris75

100 units is far from sufficient for the machine to has learned something!

1 user thanked author for this post.

Meta Signals Pro

Nicolas

Keymaster

Topics: 81

Replies: 20828

Been thanked: 4739 times

11/09/2018 at 2:58 PM #84495

Meta Signals Pro

thanks Leo for your precautions and Nicolas for your both answers;

still blocked here; I get this message; with all TF;

Best

Meta Signals Pro

Participant

Topics: 40

Replies: 310

Been thanked: 37 times

11/09/2018 at 2:59 PM #84497

Meta Signals Pro

great Grahal, can you share it too?

Meta Signals Pro

Participant

Topics: 40

Replies: 310

Been thanked: 37 times

11/09/2018 at 4:10 PM #84499

Leo

Kris 75. Take pips per trade higher number because you loaded it in daily time frame.

1 user thanked author for this post.

Meta Signals Pro

Leo

Participant

Topics: 17

Replies: 357

Been thanked: 144 times

11/09/2018 at 5:12 PM #84502

Meta Signals Pro

thanks Leo; was able to make it work in daily with “trade perpips” = 100 ;

Hope Grahal will share the straegy so I can backtest it;

Best

Chris

Meta Signals Pro

Participant

Topics: 40

Replies: 310

Been thanked: 37 times

11/09/2018 at 6:12 PM #84504

GraHal

Kris75 wrote:

Hope Grahal will share the strategy so I can backtest it;

I will share for sure, but I’d prefer the System to do a few trades first.

All I did was use output1 as a Long entry and output2 as a Short entry and added TP and SL (rough feel for profit / loss) and optimisation, oh and a simple Filter.

Am I the only one who has makes Leo’s NN Indicator code into Systems? I have about 5 or 6 versions running in Demo Forward Test?

This Thread needs to be kept clean for discussion re Leo’s NN Code.

I have shared a few Systems based on Leo / NN code on my Thread …

GraHal wrote:

Right full Neural Network now, huge thanks to Leo!

What we need is cross-fertilisation of ideas as I’m sure there are better ways (than mine) of using Leo’s code to make profitable Systems? Different TF and Markets even? The wider view? Feedback will likely help Leo with his superlative NN coding??

So there’s a challenge @Kris75 … you show me yours and I’ll show you mine? 🙂

I will post the System (based on Leo 1.3.2 code) on the other Thread (link above), after I’ve seen at least one trade open and closed.

Cheers
GraHal

GraHal

Participant

Topics: 204

Replies: 8397

Been thanked: 2039 times

11/11/2018 at 11:34 AM #84592

Leo

Forgot to tell you there is a line at 196.

It is about the time for intraday… by daily bars you should delete it

Leo

Participant

Topics: 17

Replies: 357

Been thanked: 144 times

11/11/2018 at 11:37 AM #84593

Leo

Hi all,

I posted something interesting here:

https://www.prorealcode.com/topic/weekly-seasonality-analysis/#post-84588

What if do something similar for weekly? and then also for daily?

when 3 predictions are showing the same then we entry in daily or hourly time frame…

mmm…. sexy…

2 users thanked author for this post.

Raspoutine,

Vonasi

Leo

Participant

Topics: 17

Replies: 357

Been thanked: 144 times

11/12/2018 at 7:13 PM #84703

Raspoutine

Hi Leo,
Why not use a special type of recurrent neural network called LSTM network?
A solution to the vanishing gradient problem is to use cells to remember longterm dependencies
Cordially

Sources:
http://colah.github.io/posts/2015-08-Understanding-LSTMs/
https://github.com/llSourcell/How-to-Predict-Stock-Prices-Easily-Demo

Raspoutine

Participant

Topics: 0

Replies: 3

Been thanked: 0 times

11/12/2018 at 9:41 PM #84720

Leo

How man! sorry for disappoint you. What I posted here is the first attempt ever (as far as I know) of creating artificial intelligent using such a basic language like ProBuilder with no array support. It only has memory for execute 5 epochs per mini batch, I do not even think to make something like a recurrent neural network.

I only start with a Feed Forward Neural Network! with only 1 hidden layer!!! with only 6 neurons! do you think that my decent gradient is vanishing? really? I have other problems, but definitely not a vanishing gradient.

I will be happy if I were able one of those days to increase the number of neurons… maybe you Raspoutine can help us with this endeavour.

Leo

Participant

Topics: 17

Replies: 357

Been thanked: 144 times

Author

Posts

Viewing 15 posts - 61 through 75 (of 127 total)

← 1 2 3 4 5 6 7 8 9 →

Find exclusive trading pro-tools on