MALE5-V3.0.0

[MegaJoctan]

Documentations and examples prioritized in this Major release

-> I have been receiving complaints that the library is hard to use as it is not well documented for people with no ML background and coming across this repo from Github, There are plenty of README files to explain each model inside its folder

-> Some might still find the wiki useful

-> Compatibility Checked!! users may not be able to find errors during compilation on this release than the previous ones

-> KMeans class updates and version compatibility

-> Dimensionality reduction Base class renamed to BaseDimRed to avoid conflicts with other base classes when multiple files are imported

-> Kohonen Maps PlotScatterCurveMatrix compatibility fixed, this method has been revoked matrix of maps or clusters can be plotted as follows

-> Kohonen maps fit & predicts methods

-> Metrics | scaler save methods for each scaler to csv files | Will be updated to binaries in the next version
-> RegressionMetrics for metric.mqh static class

    CColorGenerator clr;
    
    plt.Plot("kom", x, plotmatrix.Col(0), "map", "clusters","cluster"+string(1),CURVE_POINTS,clr.Next()); //plot the first cluster
    for (ulong i=1; i<plotmatrix.Cols(); i++) //start at the second column in the matrix | the second cluster
      {
        plt.AddPlot(plotmatrix.Col(i), "cluster"+string(i+1),clr.Next()); //Add the rest of clusters to the existing plot 
      }

-> fit() and fit_transform for all the prediction models and transformation models respectively implemented for all models

---

This discussion was created from the release MALE5-V3.0.0 .

[sebama94]

I think the best solution is to have some scripts example for each Module. For example I'm trying Linear Regression and Logistic Regression, but I can't get them work properly.
Thanks :)

[MegaJoctan]

Yeah I will consider that in the next release, but you may find the documentation for each model useful, I will attach a video explaining some of the challenges you might face and how to tackle them, Thank you

[sebama94]

I'm implementing the Logistic Regression, but I don't know how but signal is always 0.
Following your manual

   rsi_buff_v = matrix_utils.ArrayToVector(rsi_buff);
   xtrain.Row(rsi_buff_v, 0);
   pre_processing.fit_transform(xtrain);
   int signal = (int)Log_reg.predict(xtrain.Row(0));

Maybe I'm doing something wrong... I don't know how to fix it.
Thanks for your help and great job 🥇

[MegaJoctan]

It also seems that you are on version 2.0.0 of logistic regression, preprocessing and everything, you need to upgrade your library to the latest version 3.0.0

#include <MALE5\Linear Models\Logistic Regression.mqh>
#include <MALE5\preprocessing.mqh>

CLogisticRegression log_reg; //Load the logistic regression model
StandardizationScaler scaler; //from preprocessing import one among the available scalers

void some_function()
 {   
   x.Col(rsi_buffer, 0); //add the buffer to x matrix
   
   x = scaler.fit_transform(x); //Normalize x variable(s)   
   log_reg.fit(x, y);
   int signal = log_reg.predict(x.Row(0)); //obtain the signal
 }

[yumarca]

There were many compile errors at EA but I could fix them with chatgpt help. could you check if its ok ?
//+------------------------------------------------------------------+
//| Regressor Model Example.mq5 |
//| Copyright 2023, Omega Joctan |
//| https://www.mql5.com/en/users/omegajoctan |
//+------------------------------------------------------------------+
#property copyright "Copyright 2023, Omega Joctan"
#property link "https://www.mql5.com/en/users/omegajoctan"
#property version "1.00"

#include <MachineLearning\Decision Tree\tree.mqh>
#include <MachineLearning\preprocessing.mqh>
#include <MachineLearning\MatrixExtend.mqh>
#include <MachineLearning\metrics.mqh>
#include <OrderManager.mqh>

StandardizationScaler scaler;
CDecisionTreeRegressor *decision_tree;
MqlRates rates[];
COrderManager orderManager;

input double inLotSize = 0.1;
input double inStopLoss = 50; // in points
input double inTakeProfit = 100; // in points

double lotSize;
double stopLoss;
double takeProfit;

bool SaveModel(CDecisionTreeRegressor *model, string filename)
{
int file_handle = FileOpen(filename, FILE_WRITE | FILE_BIN);
if (file_handle == INVALID_HANDLE)
{
Print("Failed to open file for writing: ", filename);
return false;
}
model.Serialize(file_handle);
FileClose(file_handle);
Print("Model saved to ", filename);
return true;
}

bool LoadModel(CDecisionTreeRegressor *model, string filename)
{
int file_handle = FileOpen(filename, FILE_READ | FILE_BIN);
if (file_handle == INVALID_HANDLE)
{
Print("Failed to open file for reading: ", filename);
return false;
}
model.Deserialize(file_handle);
FileClose(file_handle);
Print("Model loaded from ", filename);
return true;
}

void SplitData(matrix &X, vector &y, double train_size, int random_state, matrix &X_train, vector &y_train, matrix &X_test, vector &y_test)
{
int total_rows = (int)X.Rows();
int train_rows = (int)(total_rows * train_size);

MathSrand(random_state);
for (int i = 0; i < total_rows; i++)
{
    int j = MathRand() % total_rows;
    X.SwapRows(i, j);
    double temp = y[i];
    y[i] = y[j];
    y[j] = temp;
}

X_train.Resize(train_rows, X.Cols());
y_train.Resize(train_rows);
X_test.Resize(total_rows - train_rows, X.Cols());
y_test.Resize(total_rows - train_rows);

for (int i = 0; i < train_rows; i++)
{
    for (int j = 0; j < (int)X.Cols(); j++)
    {
        X_train[i][j] = X[i][j];
    }
    y_train[i] = y[i];
}

for (int i = train_rows; i < total_rows; i++)
{
    for (int j = 0; j < (int)X.Cols(); j++)
    {
        X_test[i - train_rows][j] = X[i][j];
    }
    y_test[i - train_rows] = y[i];
}

}

int OnInit()
{
lotSize = inLotSize;
stopLoss = inStopLoss;
takeProfit = inTakeProfit;

decision_tree = new CDecisionTreeRegressor(2, 5);

double open[], close[];
int data_size = 1000;

int copied_open = CopyOpen(Symbol(), PERIOD_D1, 1, data_size, open);
int copied_close = CopyClose(Symbol(), PERIOD_D1, 1, data_size, close);

int min_copied = MathMin(copied_open, copied_close);
if (min_copied < 200)
{
    Print("Insufficient data copied. CopyOpen: ", copied_open, ", CopyClose: ", copied_close);
    return INIT_FAILED;
}

Print("Successfully copied rates. CopyOpen: ", copied_open, ", CopyClose: ", copied_close);

data_size = min_copied;
Print("Adjusted data size: ", data_size);

ArrayResize(open, data_size);
ArrayResize(close, data_size);

matrix X(data_size, 1);
vector open_vec, y_vec;
open_vec.Resize(data_size);
y_vec.Resize(data_size);

for (int i = 0; i < data_size; i++)
{
    open_vec[i] = open[i];
    y_vec[i] = close[i];
}

X.Col(open_vec, 0);

matrix X_train, X_test;
vector y_train, y_test;

double train_size = 0.7;
int random_state = 42;

SplitData(X, y_vec, train_size, random_state, X_train, y_train, X_test, y_test);

Print("Training data size: ", X_train.Rows(), "x", X_train.Cols(), ", y_train size: ", y_train.Size());
Print("Test data size: ", X_test.Rows(), "x", X_test.Cols(), ", y_test size: ", y_test.Size());

if (X_train.Rows() < 50 || X_test.Rows() < 20 || y_train.Size() < 50 || y_test.Size() < 20)
{
    Print("Insufficient data after splitting for training or testing.");
    return INIT_FAILED;
}

Print("Training data size before scaling: ", X_train.Rows(), "x", X_train.Cols());
X_train = scaler.fit_transform(X_train);
X_test = scaler.transform(X_test);
Print("Training data size after scaling: ", X_train.Rows(), "x", X_train.Cols());
Print("Test data size after scaling: ", X_test.Rows(), "x", X_test.Cols());

decision_tree.fit(X_train, y_train);

vector train_predictions = decision_tree.predict(X_train);
printf("Decision tree training r2_score = %.3f ", Metrics::RegressionMetric(y_train, train_predictions, METRIC_R_SQUARED));

vector test_predictions = decision_tree.predict(X_test);
printf("Decision tree out-of-sample r2_score = %.3f ", Metrics::RegressionMetric(y_test, test_predictions, METRIC_R_SQUARED));

SaveModel(decision_tree, "decision_tree_model.bin");

return (INIT_SUCCEEDED);

}

void OnDeinit(const int reason)
{
delete decision_tree;
}

void OnTick()
{
if (CopyRates(Symbol(), PERIOD_D1, 1, 3, rates) != 3)
{
Print("Error copying rates");
return;
}

matrix x(1, 1);
x[0][0] = rates[0].open;

Print("Transform input matrix size: [", x.Rows(), ", ", x.Cols(), "]");

matrix x_transformed = scaler.transform(x);

Print("Transformed input matrix size: [", x_transformed.Rows(), ", ", x_transformed.Cols(), "]");

vector prediction = decision_tree.predict(x_transformed);
double predicted_close_price = prediction[0];

Comment("Next closing price predicted is = ", predicted_close_price);

static double last_prediction = 0;
if (predicted_close_price > last_prediction)
{
    if (orderManager.OpenBuy(lotSize, stopLoss, takeProfit))
    {
        last_prediction = predicted_close_price;
    }
}
else if (predicted_close_price < last_prediction)
{
    if (orderManager.OpenSell(lotSize, stopLoss, takeProfit))
    {
        last_prediction = predicted_close_price;
    }
}

}