NN_Delta

//+------------------------------------------------------------------+
//|                                                  BH_NN_Train.mq4 |
//|                                       Copyright © 2008, BizHobby |
//|                                          http://www.bizhobby.com |
//+------------------------------------------------------------------+
#property copyright "Copyright © 2008, BizHobby"
#property link      "http://www.bizhobby.com"

#include <MT4_FANN.mqh>

string EA_NAME = "NN_Delta";

int train_iterations = 10000;
int input_fields = 1;
int window_size = 4;
int hidden_layer_size = 5;

int train_size = 100;
int test_size = 20;

double min_err = 0.1;

double input[];
double output[];

int input_size;
int output_size;

int fann = 0;

double pip_scale = 300;

bool refresh = false;

double clamp( double d )
{
  d = MathMin( d, 1 );
  d = MathMax( d, -1 );
  return(d);
}

double get_delta_close( int i )
{
  double d = (Close[i] - Close[i+1]) / (pip_scale*Point);
  return(clamp(d));
}

double get_delta_open( int i )
{
  double d = (Open[i] - Open[i+1]) / (pip_scale*Point);
  return(clamp(d));
}

double get_delta_high( int i )
{
  double d = (High[i] - High[i+1]) / (pip_scale*Point);
  return(clamp(d));
}

double get_delta_low( int i )
{
  double d = (Low[i] - Low[i+1]) / (pip_scale*Point);
  return(clamp(d));
}

void train( int s )
{
  double d;

  for ( int i = 1; i <= window_size; i++ )
  {
    input[i] = get_delta_close( s + i );

/*
    input[3 * i + 0] = get_delta_close( s + i );
    input[3 * i + 1] = get_delta_high( s + i );
    input[3 * i + 2] = get_delta_low( s + i );
*/
  }
  
  // Day of the week
  double day = DayOfWeek() / 6 - 3;
  input[input_size - 1] = day;
  
  d = get_delta_high(s);
  output[0] = d;

  d = get_delta_low(s);
  output[1] = d;

  if ( s > test_size )
    FANN_Train( fann, input, output );
  FANN_Run( fann, input, output );

  if ( refresh )
  {
/*    if ( s > test_size )
    {
      double err = FANN_Test( fann, input, output );
      Print ( "Error = " + err );
    }
*/

    double p;
    string o;

    p = High[s + 1] + output[0] * pip_scale * Point;
    o = "PH" + s;
    ObjectCreate( o, OBJ_RECTANGLE, 0, Time[s], p - 3 * Point, Time[s + 1], p + 3 * Point );
    ObjectSet( o, OBJPROP_COLOR, Purple );

    p = Low[s + 1] + output[1] * pip_scale * Point;
    o = "PL" + s;
    ObjectCreate( o, OBJ_RECTANGLE, 0, Time[s], p - 3 * Point, Time[s + 1], p + 3 * Point );
    ObjectSet( o, OBJPROP_COLOR, Lime );

/*
    o = "L" + s;
    p = High[s];
    ObjectCreate( o, OBJ_RECTANGLE, 0, Time[s], p - 5 * Point, Time[s + 1], p + 5 * Point );
    ObjectSet( o, OBJPROP_COLOR, Red );

    p = Low[s];
    o = "H" + s;
    ObjectCreate( o, OBJ_RECTANGLE, 0, Time[s], p - 5 * Point, Time[s + 1], p + 5 * Point );
    ObjectSet( o, OBJPROP_COLOR, Blue );
*/
  }
}

int start()
{
  // *** INITIALIZE ***
  input_size = input_fields * window_size + 1;
  output_size = 2;
  ArrayResize( input, input_size );
  ArrayResize( output, output_size );

  string fname = EA_NAME + Symbol() + "P" + Period() + ".NN";
  Print( "Trying to load " + fname ) ;
  fann = FANN_CreateFromFile( fname );

  if ( fann == 0 )
  {
    Print( "Failed to load! Creating a brand new Neural Network..." );
    fann = FANN_Create( input_size, output_size, hidden_layer_size );
  }

  // *** TRAIN ***
  for ( int k = 1; k < train_iterations; k++ )
  {
    refresh = (k%1000) == 0;
    if ( refresh )
    {
      ObjectsDeleteAll( 0 ) ;
      Print( "Iteration " + k );
    }
    for( int s = train_size + test_size; s >= 0; s-- )
    {
      train(s);
    }
    if ( refresh )
    {
      WindowRedraw();
    }
  }

  // *** SHUTDOWN ***
  Print( "Saving network..." + fname );
  FANN_Save( fann, fname );
  Print( "Cleanup..." );
  FANN_Destroy( fann );

  return(0);
}