comp4971c.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WBVo8PgUPGBl"
      },
      "source": [
        "Multiple Model-based Binary Classification for Forex Trading\n",
        "\n",
        "...\n",
        "\n",
        "Author -  Leung Cheuk Hei, Victor\n",
        "\n",
        "...\n",
        "\n",
        "Copyright© 2020. myworldbox.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "__iR8svoDO06"
      },
      "source": [
        "Meun\n",
        "\n",
        "Use asset_report(, True) to see the detailed report\n",
        "\n",
        "The current ranking is just based on accuracy to minimize testing time\n",
        "\n",
        "<a name=\"nav-meun\"></a>\n",
        "\n",
        "This data inherits the previous date's price impact.\n",
        "\n",
        "[(Report 1) Swing Trading Batch Classification Report](#swing-trading-data-report)\n",
        "\n",
        "[(Report 2) Day Trading Batch Classification Report](#day-trading-data-report)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sEKoQiJxzPcZ"
      },
      "source": [
        "Overview"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LTqnAYz-b6sp"
      },
      "source": [
        "A winning strategy may or may not show a directly proportional relationship between accuracy and profit.\n",
        "\n",
        "This trading report presents two trading styles - swing trading and day trading.\n",
        "\n",
        "My strategy is to use all of the models from [ sklearn ] to predict the decision columns.\n",
        "\n",
        "Next, swing trading and day trading strategies are derived from the same decision columns.\n",
        "\n",
        "I have modularized assets, models, and metrics into arrays to study their collective impacts on the dataset. I have included an additional dataset from yahoo finance and applied the same concept to data with a different shape.\n",
        "\n",
        "For Yahoo finance data, I try to make the problem of trading a binary classification problem.\n",
        "\n",
        "My models analyze the closing price of the historical market.\n",
        "\n",
        "If the previous closing price is lower than the current closing price, it is classified as a buying opportunity and vice versa.\n",
        "\n",
        "To minimize spreads, I only try assets with the top 10 market capitalization.\n",
        "\n",
        "Only high liquidity markets are being tested."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "m9vUr7Q_zRd0"
      },
      "source": [
        "1. Description of the dataset and any preprocessing\n",
        "\n",
        "`After obtaining the data frame from yahoo finance, the data is processed to yield two new data frames (Volatility column, and Decision column). To associate trading with classification, trading behaviors, and profit (Action column, and Profit column) are created from the classification results. The trading rules for swing trading and day trading are derived from the same classification results (Decision column). Their only difference would be their final interpretation. No scaling would be used as the future prices of assets are unpredictable. To reduce complexity, no technical indicators will be employed in this study. All positions will be closed on the last day.\n",
        "`\n",
        "\n",
        "2. Description of the machine learning task(s) performed on the dataset\n",
        "\n",
        "`I have used models from Probability Calibration, Dummy estimators, Ensemble Methods, Gaussian Processes, Linear classifiers, Classical linear regressors, Regressors with variable selection, Bayesian regressors, Outlier-robust regressors, Generalized linear models (GLM) for regression, Miscellaneous, Naive Bayes, Nearest Neighbors, Neural network models, Semi-Supervised Learning, Support Vector Machines, and Decision Trees to compare their effectiveness.`\n",
        "\n",
        "3. Description of the hardware and software computing environment, machine learning meth\u0002ods, and parameter settings\n",
        "\n",
        "`For both hardware and software, I use TPU/GPU from Colab to conduct machine learning. All parameters in models are left to default to avoid extra complexity.`\n",
        "\n",
        "4. Description of the experiments\n",
        "\n",
        "`I feed assets, models, and metrics into the array to evaluate their independent impacts. You can observe that simple classifiers already perform well on the datasets. It may be overkill to use complex models like CNN with customized layers. Generally, my script can be applied to both regression and classification problems with slight modification as most models are modulized into arrays.`\n",
        "\n",
        "5. Visualization and discussion of the results obtained\n",
        "\n",
        "`The results are listed in the Meun section below. My implementation also allows the use of regressors on classification objects. I rounded the regression results up or down to obtain either 1 or 0. Regression is performing similar to classifiers. Moreover, the great performance of DummyRegressor and DummyClassifier also outlined the concept of \"successful bad trades\".`"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "9l1UZT6BUdH4"
      },
      "outputs": [],
      "source": [
        "!pip install yfinance"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Python libraries"
      ],
      "metadata": {
        "id": "JpfVGHbHTem0"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "16nGwoLRT1X6"
      },
      "outputs": [],
      "source": [
        "import math\n",
        "import numpy as np\n",
        "import pandas as pd\n",
        "import yfinance as yf\n",
        "import warnings\n",
        "import statistics\n",
        "import matplotlib.pyplot as plt"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from IPython.display import display, HTML\n",
        "from scipy.stats import skew, kurtosis\n",
        "from google.colab import drive"
      ],
      "metadata": {
        "id": "W_kHYLp2TKl4"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Sklearn libraries"
      ],
      "metadata": {
        "id": "FU_BMM-dTSlS"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from sklearn.base import is_classifier, is_regressor\n",
        "from sklearn.model_selection import train_test_split\n",
        "from sklearn import feature_selection"
      ],
      "metadata": {
        "id": "-OlSq6PUS40o"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Sklearn libraries - scalers"
      ],
      "metadata": {
        "id": "Vofd6ASYTwee"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from sklearn.preprocessing import MinMaxScaler, StandardScaler"
      ],
      "metadata": {
        "id": "-kBVBAk6Tv0n"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Sklearn libraries - machine-learning models"
      ],
      "metadata": {
        "id": "R22MEWNnTkhx"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "ZIYGujdAKhTI"
      },
      "outputs": [],
      "source": [
        "from sklearn import calibration\n",
        "from sklearn import dummy\n",
        "from sklearn import cluster\n",
        "from sklearn import ensemble\n",
        "from sklearn import gaussian_process\n",
        "from sklearn import isotonic\n",
        "from sklearn import kernel_approximation\n",
        "from sklearn import kernel_ridge\n",
        "from sklearn import linear_model\n",
        "from sklearn import manifold\n",
        "from sklearn import naive_bayes\n",
        "from sklearn import neighbors\n",
        "from sklearn import neural_network\n",
        "from sklearn import semi_supervised\n",
        "from sklearn import svm\n",
        "from sklearn import tree"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Sklearn libraries - classification metrics"
      ],
      "metadata": {
        "id": "qSUq5qiqT7YK"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "uLIq-rygLBa5"
      },
      "outputs": [],
      "source": [
        "from sklearn import metrics"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "bGNbBADYVh4Q"
      },
      "outputs": [],
      "source": [
        "warnings.filterwarnings('ignore')\n",
        "\n",
        "# drive.mount('/content/drive')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "nz8YnmSHdKLW"
      },
      "outputs": [],
      "source": [
        "pd.set_option('max_colwidth', 500)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "5lOOVlMHFdgw"
      },
      "outputs": [],
      "source": [
        "color = \"white\""
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "kJRFvzGKwwu3"
      },
      "outputs": [],
      "source": [
        "plt.style.use('seaborn-darkgrid')\n",
        "%matplotlib inline"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Color definition"
      ],
      "metadata": {
        "id": "KmU6jZZMUDNI"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "-Zkj8TE28lMz"
      },
      "outputs": [],
      "source": [
        "def zeroColor(score):\n",
        "  if (score == 0):\n",
        "    return f\"background-color: #140326;\"\n",
        "\n",
        "def negativeColor(score):\n",
        "  if (score < 0):\n",
        "    return f\"background-color: #d822ff;\"\n",
        "\n",
        "def reportColor(score):\n",
        "  return f\"background-color: #274e13;\"\n",
        "\n",
        "def swingColor(score):\n",
        "  return f\"background-color: #3e03a3;\"\n",
        "\n",
        "def dayColor(score):\n",
        "  return f\"background-color: #ff7300;\"\n",
        "\n",
        "def actionColor(action):\n",
        "  if (action == \"No Action\"):\n",
        "    return f\"background-color: #000000;\"\n",
        "  if (action == \"Sell\"):\n",
        "    return f\"background-color: #ff0000;\"\n",
        "  if (action == \"Buy\"):\n",
        "    return f\"background-color: #0011ff;\"\n",
        "  if (action == \"Buy & Sell\"):\n",
        "    return f\"background-color: #12014d;\""
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "70sl4Rw4B3VZ"
      },
      "outputs": [],
      "source": [
        "scaler = [MinMaxScaler(feature_range=(0, 100)), StandardScaler()]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "29UGTR61J5-A"
      },
      "outputs": [],
      "source": [
        "model = [\n",
        "    # Probability Calibration\n",
        "    calibration.CalibratedClassifierCV(),\n",
        "    # calibration.calibration_curve(),\n",
        "\n",
        "    # Dummy estimators\n",
        "    dummy.DummyClassifier(),\n",
        "    dummy.DummyRegressor(),\n",
        "\n",
        "    # Clustering\n",
        "    # cluster.AffinityPropagation(),\n",
        "    # cluster.AgglomerativeClustering(),\n",
        "    # cluster.Birch(),\n",
        "    # cluster.DBSCAN(),\n",
        "    # cluster.FeatureAgglomeration(),\n",
        "    # cluster.KMeans(),\n",
        "    # cluster.BisectingKMeans(),\n",
        "    # cluster.MiniBatchKMeans(),\n",
        "    # cluster.MeanShift(),\n",
        "    # cluster.OPTICS(),\n",
        "    # cluster.SpectralClustering(),\n",
        "    # cluster.SpectralBiclustering(),\n",
        "    # cluster.SpectralCoclustering(),\n",
        "\n",
        "    # Ensemble Methods\n",
        "    ensemble.AdaBoostClassifier(),\n",
        "    ensemble.AdaBoostRegressor(),\n",
        "    ensemble.BaggingClassifier(),\n",
        "    ensemble.BaggingRegressor(),\n",
        "    ensemble.ExtraTreesClassifier(),\n",
        "    ensemble.ExtraTreesRegressor(),\n",
        "    ensemble.GradientBoostingClassifier(),\n",
        "    ensemble.GradientBoostingRegressor(),\n",
        "    ensemble.IsolationForest(),\n",
        "    ensemble.RandomForestClassifier(),\n",
        "    ensemble.RandomForestRegressor(),\n",
        "    # ensemble.RandomTreesEmbedding(),\n",
        "    # ensemble.StackingClassifier(),\n",
        "    # ensemble.StackingRegressor(),\n",
        "    # ensemble.VotingClassifier(),\n",
        "    # ensemble.VotingRegressor(),\n",
        "    ensemble.HistGradientBoostingRegressor(),\n",
        "    ensemble.HistGradientBoostingClassifier(),\n",
        "\n",
        "    # Gaussian Processes\n",
        "    gaussian_process.GaussianProcessClassifier(),\n",
        "    gaussian_process.GaussianProcessRegressor(),\n",
        "\n",
        "    # Isotonic regression\n",
        "    # isotonic.IsotonicRegression(),\n",
        "    # isotonic.check_increasing(),\n",
        "    # isotonic.isotonic_regression(),\n",
        "\n",
        "    # Kernel Approximation\n",
        "    # kernel_approximation.AdditiveChi2Sampler(),\n",
        "    # kernel_approximation.Nystroem(),\n",
        "    # kernel_approximation.PolynomialCountSketch(),\n",
        "    # kernel_approximation.RBFSampler(),\n",
        "    # kernel_approximation.SkewedChi2Sampler(),\n",
        "\n",
        "    # Linear classifiers\n",
        "    linear_model.LogisticRegression(),\n",
        "    linear_model.LogisticRegressionCV(),\n",
        "    linear_model.PassiveAggressiveClassifier(),\n",
        "    linear_model.Perceptron(),\n",
        "    linear_model.RidgeClassifier(),\n",
        "    linear_model.RidgeClassifierCV(),\n",
        "    linear_model.SGDClassifier(),\n",
        "    linear_model.SGDOneClassSVM(),\n",
        "\n",
        "    # Classical linear regressors\n",
        "    linear_model.LinearRegression(),\n",
        "    linear_model.Ridge(),\n",
        "    linear_model.RidgeCV(),\n",
        "    linear_model.SGDRegressor(),\n",
        "\n",
        "    # Regressors with variable selection\n",
        "    linear_model.ElasticNet(),\n",
        "    linear_model.ElasticNetCV(),\n",
        "    linear_model.Lars(),\n",
        "    linear_model.LarsCV(),\n",
        "    linear_model.Lasso(),\n",
        "    linear_model.LassoCV(),\n",
        "    linear_model.LassoLars(),\n",
        "    linear_model.LassoLarsCV(),\n",
        "    linear_model.LassoLarsIC(),\n",
        "    linear_model.OrthogonalMatchingPursuit(),\n",
        "    linear_model.OrthogonalMatchingPursuitCV(),\n",
        "\n",
        "    # Bayesian regressors\n",
        "    linear_model.ARDRegression(),\n",
        "    linear_model.BayesianRidge(),\n",
        "\n",
        "    # Multi-task linear regressors with variable selection\n",
        "    # linear_model.MultiTaskElasticNet(),\n",
        "    # linear_model.MultiTaskElasticNetCV(),\n",
        "    # linear_model.MultiTaskLasso(),\n",
        "    # linear_model.MultiTaskLassoCV(),\n",
        "\n",
        "    # Outlier-robust regressors\n",
        "    linear_model.HuberRegressor(),\n",
        "    # linear_model.QuantileRegressor(),\n",
        "    # linear_model.RANSACRegressor(),\n",
        "    linear_model.TheilSenRegressor(),\n",
        "\n",
        "    # Generalized linear models (GLM) for regression\n",
        "    linear_model.PoissonRegressor(),\n",
        "    linear_model.TweedieRegressor(),\n",
        "    # linear_model.GammaRegressor(),\n",
        "\n",
        "    # Miscellaneous\n",
        "    linear_model.PassiveAggressiveRegressor(),\n",
        "    # linear_model.enet_path(),\n",
        "    # linear_model.lars_path(),\n",
        "    # linear_model.lars_path_gram(),\n",
        "    # linear_model.lasso_path(),\n",
        "    # linear_model.orthogonal_mp(),\n",
        "    # linear_model.orthogonal_mp_gram(),\n",
        "    # linear_model.ridge_regression(),\n",
        "\n",
        "    # Manifold Learning\n",
        "    # manifold.Isomap(),\n",
        "    # manifold.LocallyLinearEmbedding(),\n",
        "    # manifold.MDS(),\n",
        "    # manifold.SpectralEmbedding(),\n",
        "    # manifold.TSNE(),\n",
        "    # manifold.locally_linear_embedding(),\n",
        "    # manifold.smacof(),\n",
        "    # manifold.spectral_embedding(),\n",
        "    # manifold.trustworthiness(),\n",
        "\n",
        "    # Naive Bayes\n",
        "    naive_bayes.BernoulliNB(),\n",
        "    # naive_bayes.CategoricalNB(),\n",
        "    # naive_bayes.ComplementNB(),\n",
        "    naive_bayes.GaussianNB(),\n",
        "    # naive_bayes.MultinomialNB(),\n",
        "\n",
        "    # Nearest Neighbors\n",
        "    # neighbors.BallTree(),\n",
        "    # neighbors.KDTree(),\n",
        "    # neighbors.KernelDensity(),\n",
        "    neighbors.KNeighborsClassifier(),\n",
        "    neighbors.KNeighborsRegressor(),\n",
        "    # neighbors.KNeighborsTransformer(),\n",
        "    # neighbors.LocalOutlierFactor(),\n",
        "    # neighbors.RadiusNeighborsClassifier(),\n",
        "    neighbors.RadiusNeighborsRegressor(),\n",
        "    # neighbors.RadiusNeighborsTransformer(),\n",
        "    neighbors.NearestCentroid(),\n",
        "    # neighbors.NearestNeighbors(),\n",
        "    # neighbors.NeighborhoodComponentsAnalysis(),\n",
        "    # neighbors.kneighbors_graph(),\n",
        "    # neighbors.radius_neighbors_graph(),\n",
        "    # neighbors.sort_graph_by_row_values(),\n",
        "\n",
        "    # Neural network models\n",
        "    # neural_network.BernoulliRBM(),\n",
        "    neural_network.MLPClassifier(),\n",
        "    neural_network.MLPRegressor(),\n",
        "\n",
        "    # Semi-Supervised Learning\n",
        "    semi_supervised.LabelPropagation(),\n",
        "    semi_supervised.LabelSpreading(),\n",
        "    # semi_supervised.SelfTrainingClassifier(),\n",
        "\n",
        "    # Support Vector Machines\n",
        "    svm.LinearSVC(),\n",
        "    svm.LinearSVR(),\n",
        "    # svm.NuSVC(),\n",
        "    svm.NuSVR(),\n",
        "    svm.OneClassSVM(),\n",
        "    svm.SVC(),\n",
        "    svm.SVR(),\n",
        "\n",
        "    # Decision Trees\n",
        "    tree.DecisionTreeClassifier(),\n",
        "    tree.DecisionTreeRegressor(),\n",
        "    tree.ExtraTreeClassifier(),\n",
        "    tree.ExtraTreeRegressor(),\n",
        "    # tree.export_graphviz(),\n",
        "    # tree.export_text(),\n",
        "    ]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "deO6LNudK-S2"
      },
      "outputs": [],
      "source": [
        "classification_metric = [\n",
        "    # Classification metrics\n",
        "    metrics.accuracy_score,\n",
        "    metrics.auc,\n",
        "    metrics.average_precision_score,\n",
        "    metrics.balanced_accuracy_score,\n",
        "    metrics.brier_score_loss,\n",
        "    metrics.classification_report,\n",
        "    metrics.cohen_kappa_score,\n",
        "    metrics.confusion_matrix,\n",
        "    metrics.dcg_score,\n",
        "    metrics.det_curve,\n",
        "    metrics.f1_score,\n",
        "    metrics.fbeta_score,\n",
        "    metrics.hamming_loss,\n",
        "    metrics.hinge_loss,\n",
        "    metrics.jaccard_score,\n",
        "    metrics.log_loss,\n",
        "    metrics.matthews_corrcoef,\n",
        "    metrics.multilabel_confusion_matrix,\n",
        "    metrics.ndcg_score,\n",
        "    metrics.precision_recall_curve,\n",
        "    metrics.precision_recall_fscore_support,\n",
        "    metrics.precision_score,\n",
        "    metrics.recall_score,\n",
        "    metrics.roc_auc_score,\n",
        "    metrics.roc_curve,\n",
        "    metrics.top_k_accuracy_score,\n",
        "    metrics.zero_one_loss,\n",
        "]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Q2GOyEWB-bDk"
      },
      "outputs": [],
      "source": [
        "regression_metric = [\n",
        "    # Regression metrics\n",
        "    metrics.explained_variance_score,\n",
        "    metrics.max_error,\n",
        "    metrics.mean_absolute_error,\n",
        "    metrics.mean_squared_error,\n",
        "    metrics.mean_squared_log_error,\n",
        "    metrics.median_absolute_error,\n",
        "    metrics.r2_score,\n",
        "    metrics.mean_poisson_deviance,\n",
        "    metrics.mean_gamma_deviance,\n",
        "    metrics.mean_tweedie_deviance,\n",
        "    metrics.d2_tweedie_score,\n",
        "    metrics.mean_pinball_loss,\n",
        "    # metrics.d2_pinball_score,\n",
        "    # metrics.d2_absolute_error_score\n",
        "]"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5_vZmIEMMXqg"
      },
      "source": [
        "\n",
        "\n",
        "Account Setting"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "KrN-A2OGMd99"
      },
      "outputs": [],
      "source": [
        "money = 10000"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "QLNsF_FjSmFG"
      },
      "outputs": [],
      "source": [
        "invest_ratio = 0.5"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "rFs02dvtubtG"
      },
      "outputs": [],
      "source": [
        "train_size = 0.5"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "r5N2js_TICAt"
      },
      "outputs": [],
      "source": [
        "trading_day = 252\n",
        "risk_free_rate = 0.02"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Frames obtained from yfinance"
      ],
      "metadata": {
        "id": "WjFTtqLmUSGl"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "bZWOOJsYBTzr"
      },
      "outputs": [],
      "source": [
        "start_year = 2000\n",
        "trade_year = 20"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "oAR0nTgdXCyA"
      },
      "outputs": [],
      "source": [
        "start_period = str(start_year) + '-01-01'\n",
        "end_period = str(start_year + trade_year) + '-01-01'"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Stocks"
      ],
      "metadata": {
        "id": "UpTYPGA7UYuI"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "6UwIA9NcMcJi"
      },
      "outputs": [],
      "source": [
        "major_stock = [\n",
        "    'BAC', # Bank of America\n",
        "    'C', # Citigroup\n",
        "    'F', # Ford Motor Company\n",
        "    'GE', # General Electric\n",
        "    'CSCO', # Cisco Systems\n",
        "\n",
        "    'PFE', # Pfizer Inc.\n",
        "    'MSFT', # Microsoft Corporation\n",
        "    'AA', # Alcoa Inc.\n",
        "    'T', # AT&T Inc.\n",
        "    'INTC' # Intel Corporation\n",
        "]"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Commodities"
      ],
      "metadata": {
        "id": "uLnVOvC-UaGh"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "_jFF441Tx261"
      },
      "outputs": [],
      "source": [
        "major_commodity = [\n",
        "    'CL=F', # Crude oil\n",
        "    'GC=F', # Gold\n",
        "    'NG=F', # Natural gas\n",
        "    'ZC=F', # Corn\n",
        "    'HO=F', # Heating Oil\n",
        "\n",
        "    'BZ=F', # Brent Oil\n",
        "    'SI=F', # Silver\n",
        "    'ZS=F', # Soybeans\n",
        "    'HG=F', # Copper\n",
        "    'ZW=F', # Wheat\n",
        "]"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Forexes"
      ],
      "metadata": {
        "id": "dEk14PSvUcnE"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "9rN1nF9BEnF_"
      },
      "outputs": [],
      "source": [
        "major_forex = [\n",
        "'USDJPY=X', # US Dollar/Japanese Yen\n",
        "'EURUSD=X', # Euro/US Dollar\n",
        "'GBPUSD=X', # British Pound/US Dollar\n",
        "'AUDUSD=X', # Australian Dollar/US Dollar\n",
        "'USDCHF=X', # US Dollar/Swiss Franc\n",
        "\n",
        "'USDCAD=X', # US Dollar/Canadian Dollar\n",
        "'EURJPY=X', # Euro/Japanese Yen\n",
        "'GBPJPY=X', # British Pound/Japanese Yen\n",
        "'EURCHF=X', # Euro/Swiss Franc\n",
        "'NZDUSD=X', # New Zealand Dollar/US Dollar\n",
        "]"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Asset classes"
      ],
      "metadata": {
        "id": "607z-kGhUef0"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "sqMdGTHyEkuA"
      },
      "outputs": [],
      "source": [
        "asset = [\n",
        "    # major_stock,\n",
        "    # major_commodity,\n",
        "    major_forex\n",
        "]"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "asset_data = []"
      ],
      "metadata": {
        "id": "Tt_UkDmVX-fF"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Data download with NA data removal"
      ],
      "metadata": {
        "id": "eZoy7q4-Ulfm"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "for x, i in enumerate(asset):\n",
        "\n",
        "  each_data = []\n",
        "  for y, j in enumerate(i):\n",
        "\n",
        "    data = yf.download(tickers=j, start=start_period, end=end_period, period='1d', group_by='ticker')\n",
        "    data.index = pd.to_datetime(data.index)\n",
        "    no_na = data.dropna()\n",
        "\n",
        "    r, c = no_na.shape\n",
        "\n",
        "    print(\"\\n[\", x, \",\", y, \"] ---> \", asset[x][y], \" ---> \", r/365, \" years\")\n",
        "    display(pd.DataFrame(no_na))\n",
        "\n",
        "    each_data.append(no_na)\n",
        "\n",
        "  asset_data.append(each_data)"
      ],
      "metadata": {
        "id": "S7UPILGpe_Uu"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nTF3M9RoMzCl"
      },
      "source": [
        "Data Processing\n",
        "\n",
        "1. Decision column implies the relatioinship of previous day and today\n",
        "\n",
        "2. It needs to be shifted down by one row"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "mza8B46Q9jjJ"
      },
      "outputs": [],
      "source": [
        "def swing_sell_action(swing_current_lot, main, swing_max, swing_gain, swing_profit, i, open, swing_sell_price):\n",
        "\n",
        "  swing_profit += swing_current_lot * main['Open'][i]\n",
        "  open = False\n",
        "\n",
        "  # print(i, \" - Sell [\", swing_current_lot, \"] at [\", main['Open'][i], \"] - money = [\", swing_profit, \"]\")\n",
        "\n",
        "  if(swing_profit - swing_sell_price[-1] > 0 and swing_profit - swing_sell_price[-1] > swing_max[0]): # max profit\n",
        "    # print(\"\\n>>> max profit [ sell:(\", swing_profit, \") - buy:(\", swing_sell_price[-1] ,\") ] ---> \", swing_profit - swing_sell_price[-1], \"\\n\")\n",
        "    swing_max[0] = swing_profit - swing_sell_price[-1]\n",
        "  if(swing_profit - swing_sell_price[-1] < 0 and swing_profit - swing_sell_price[-1] < swing_max[1]): # max loss\n",
        "    # print(\"\\n>>> max lose [ sell:(\", swing_profit, \") - buy:(\", swing_sell_price[-1] ,\") ] ---> \", swing_profit - swing_sell_price[-1], \"\\n\")\n",
        "    swing_max[1] = swing_profit - swing_sell_price[-1]\n",
        "  if not math.isnan(swing_profit):\n",
        "    swing_sell_price.append(swing_profit)\n",
        "\n",
        "  return swing_profit, swing_max, open"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "Decision to Action for two strategies\n",
        "1. Swing Trading\n",
        "2. Day Trading"
      ],
      "metadata": {
        "id": "kQZEHuwRVlVG"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "q9vRRiO9kvKA"
      },
      "outputs": [],
      "source": [
        "def decision_to_action(main, target, volatility, swing_step, day_step, swing_gain, day_gain):\n",
        "\n",
        "  print(len(main), len(target))\n",
        "\n",
        "  swing_profit = money\n",
        "  day_profit = money\n",
        "\n",
        "  swing_action = \"\"\n",
        "  day_action = \"\"\n",
        "\n",
        "  swing_current_lot = 0\n",
        "  day_current_lot = 0\n",
        "\n",
        "  swing_max = [\n",
        "      0, # 0 - profit\n",
        "      0, # 1 - loss\n",
        "      0, # 2 - holding period\n",
        "  ]\n",
        "\n",
        "  day_max = [\n",
        "      0, # 0 - profit\n",
        "      0, # 1 - loss\n",
        "      0, # 2 - holding period\n",
        "  ]\n",
        "\n",
        "  swing_sell_price = [\n",
        "      money\n",
        "      ]\n",
        "\n",
        "\n",
        "  day_sell_price = [\n",
        "      money\n",
        "      ]\n",
        "\n",
        "  open = False\n",
        "\n",
        "  for i, d in enumerate(target):\n",
        "\n",
        "    try:\n",
        "\n",
        "      if(i == len(target) - 1 and (swing_step[i - 1] == 'Buy' or swing_step[i - 1] == 'Retain')): # close all\n",
        "\n",
        "        swing_action = \"Sell\"\n",
        "\n",
        "        if(open == True and swing_current_lot >= 0): swing_profit, swing_max, open = swing_sell_action(swing_current_lot, main, swing_max, swing_gain, swing_profit, i, open, swing_sell_price)\n",
        "\n",
        "      elif(i == 0 and target[i - 1] == 1 or target[i - 2] == 0 and target[i - 1] == 1 and i != len(target) - 1):\n",
        "\n",
        "        swing_action = \"Buy\"\n",
        "\n",
        "        if(swing_current_lot >= 0 and open == False and swing_profit > 0):\n",
        "          open = True\n",
        "          swing_current_lot = int((swing_profit*invest_ratio)/main['Open'][i])\n",
        "          if(swing_current_lot > 0):\n",
        "            swing_profit -= swing_current_lot * main['Open'][i]\n",
        "            # print(i, \" - Buy [\", swing_current_lot, \"] at [\", main['Open'][i], \"] - money = [\", swing_profit, \"]\")\n",
        "\n",
        "      elif(target[i - 1] == 1 and target[i - 2] == 1):\n",
        "\n",
        "        swing_action = \"Retain\"\n",
        "\n",
        "      elif(target[i - 1] == 0 and target[i - 2] == 1 and swing_step[i - 1] != 'Sell'):\n",
        "\n",
        "        swing_action = \"Sell\"\n",
        "\n",
        "        if(open == True and swing_current_lot >= 0): swing_profit, swing_max, open = swing_sell_action(swing_current_lot, main, swing_max, swing_gain, swing_profit, i, open, swing_sell_price)\n",
        "\n",
        "      else:\n",
        "        swing_action = 'No Action'\n",
        "\n",
        "    except:\n",
        "      swing_action = 'No Action'\n",
        "\n",
        "    try:\n",
        "\n",
        "      if(target[i - 1] == 1):\n",
        "        day_current_lot = int((day_profit/invest_ratio)/main['Open'][i])\n",
        "        day_profit += day_current_lot * (main['Close'][i] - main['Open'][i])\n",
        "\n",
        "        # print(i, \" - Buy & Sell [\", day_current_lot, \"] at [\", main['Open'][i], \"] - money = [\", day_profit, \"]\")\n",
        "\n",
        "        day_action = \"Buy & Sell\"\n",
        "\n",
        "        if(day_profit - day_sell_price[-1] > 0 and day_profit - day_sell_price[-1] > day_max[0]): # max profit\n",
        "          day_max[0] = day_profit - day_sell_price[-1]\n",
        "        if(day_profit - day_sell_price[-1] < 0 and day_profit - day_sell_price[-1] < day_max[1]): # max loss\n",
        "          day_max[1] = day_profit - day_sell_price[-1]\n",
        "\n",
        "        if not math.isnan(day_profit):\n",
        "          day_sell_price.append(day_profit)\n",
        "\n",
        "      else:\n",
        "        day_action = \"No Action\"\n",
        "\n",
        "    except:\n",
        "      day_action = \"No Action\"\n",
        "\n",
        "    swing_step.append(swing_action)\n",
        "    day_step.append(day_action)\n",
        "\n",
        "    swing_gain.append(swing_profit)\n",
        "    day_gain.append(day_profit)\n",
        "\n",
        "    try:\n",
        "      volatility.append((main['Close'][i] - main['Close'][i - 1])/main['Close'][i - 1])\n",
        "\n",
        "    except:\n",
        "      volatility.append(0)\n",
        "\n",
        "  volatility[0] = 0\n",
        "  fluctuation = pd.DataFrame(volatility, columns = ['Volatility'])\n",
        "\n",
        "  swing_trade = pd.DataFrame(swing_step, columns = ['Swing Action'])\n",
        "  swing_earn = pd.DataFrame(swing_gain, columns = ['Swing Profit'])\n",
        "\n",
        "  day_trade = pd.DataFrame(day_step, columns = ['Day Action'])\n",
        "  day_earn = pd.DataFrame(day_gain, columns = ['Day Profit'])\n",
        "\n",
        "  return fluctuation, swing_trade, day_trade, swing_earn, day_earn, swing_max, day_max, swing_sell_price, day_sell_price"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "1. Scaling data\n",
        "2. Price to Decision and Action"
      ],
      "metadata": {
        "id": "2O825V90JV4J"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "loop_1 = []\n",
        "for x, i in enumerate(asset_data):\n",
        "\n",
        "  loop_2 = []\n",
        "  for y, j in enumerate(i):\n",
        "\n",
        "    loop_3 = []\n",
        "    for z, k in enumerate(scaler):\n",
        "\n",
        "      try:\n",
        "\n",
        "        print(\"[\",x,\",\",y,\",\",z,\"]\")\n",
        "        r, c = j.shape\n",
        "\n",
        "        decision = []\n",
        "\n",
        "        for row in range(0, r):\n",
        "\n",
        "          if(j['Open'][row] < j['Close'][row]):\n",
        "            decision.append(1) # buy\n",
        "          else:\n",
        "            decision.append(0) # sell\n",
        "\n",
        "        idea = pd.DataFrame(decision, columns = ['Decision'])\n",
        "        idea['Decision'] = idea['Decision'].shift(-1) # shifting Decision column one row up\n",
        "        idea.at[idea.index[0], 'Decision'] = 0.0 # no action on day 1\n",
        "        idea.at[idea.index[-1], 'Decision'] = 0.0 # close all\n",
        "\n",
        "        fluctuation, swing_action, day_action, swing_profit, day_profit, swing_snapshot, day_snapshot, swing_sell_price, day_sell_price = decision_to_action(j, idea['Decision'],[], [], [], [], [])\n",
        "\n",
        "        current_frame = pd.concat([j.reset_index(), fluctuation['Volatility'], idea['Decision'], swing_action['Swing Action'], swing_profit['Swing Profit'], day_action['Day Action'], day_profit['Day Profit']], axis=1)\n",
        "\n",
        "        color_frame = current_frame.style.applymap(actionColor)\n",
        "        display(color_frame.applymap(reportColor, subset=['Date',\t'Open',\t'High',\t'Low',\t'Close',\t'Adj Close',\t'Volume',\t'Volatility']))\n",
        "\n",
        "        result = idea['Decision'].value_counts()\n",
        "\n",
        "        loop_3.append(current_frame)\n",
        "      except:\n",
        "        pass\n",
        "\n",
        "    loop_2.append(loop_3)\n",
        "  loop_1.append(loop_2)"
      ],
      "metadata": {
        "id": "zRaJr0mhc98N"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "processed_data = loop_1"
      ],
      "metadata": {
        "id": "WHcenGxoKEQ-"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "for x, i in enumerate(processed_data): # 2\n",
        "\n",
        "  for y, j in enumerate(i): # 10\n",
        "\n",
        "    fig, axes = plt.subplots(2, 5, figsize=(30, 10))\n",
        "    for z, k in enumerate(j): # 2\n",
        "\n",
        "      print(\"[\",x,\",\",y,\",\",z,\"]\")\n",
        "      for a, ax in enumerate(axes.flat):\n",
        "\n",
        "        if(x == 0):\n",
        "          ax.set_facecolor('xkcd:black')\n",
        "        ax.plot(k['Close'])\n",
        "\n",
        "        # Set the title and axis labels\n",
        "        ax.set_title(' VS ', fontsize=10)\n",
        "\n",
        "        ax.set_xlabel('Year-Month', fontsize=15)\n",
        "        ax.set_ylabel('Close Prices', fontsize=15)\n",
        "\n",
        "        ax.tick_params(axis='both', labelsize=15)\n",
        "\n",
        "        h1, l1  = ax.get_legend_handles_labels()\n",
        "\n",
        "    plt.show()"
      ],
      "metadata": {
        "id": "ovh1hNTEPXVC"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "PtwLdWJDrMQV"
      },
      "outputs": [],
      "source": [
        "def slicing(list, begin, to):\n",
        "  return list[int(len(list) * begin) : int(len(list) * to)]"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3bm2OreWcnkf"
      },
      "source": [
        "Splitting training and testing datasets"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "loop_1 = []\n",
        "for x, i in enumerate(processed_data): # 2\n",
        "\n",
        "  loop_2 = []\n",
        "  for y, j in enumerate(i): # 10\n",
        "\n",
        "    loop_3 = []\n",
        "    for z, k in enumerate(j): # 2\n",
        "\n",
        "      print(\"[\",x,\",\",y,\",\",z,\"]\")\n",
        "\n",
        "      X = k.copy()\n",
        "      for j in ['Date', 'Decision', 'Swing Action', 'Swing Profit', 'Day Action', 'Day Profit']:\n",
        "        X = X.drop([j], axis='columns').copy()\n",
        "      Y = k.Decision\n",
        "\n",
        "      x_train, x_validation, y_train, y_validation = train_test_split(X, Y, test_size=train_size, shuffle=False )\n",
        "\n",
        "      print(len(x_train), len(x_validation) , len(y_train), len(y_validation))\n",
        "\n",
        "      x_train = slicing(X, 0, 1 - train_size)\n",
        "      x_validation = slicing(X, 1 - train_size, 1)\n",
        "\n",
        "      y_train = slicing(Y, 0, 1 - train_size)\n",
        "      y_validation = slicing(Y, 1 - train_size, 1)\n",
        "\n",
        "      print(len(x_train), len(x_validation) , len(y_train), len(y_validation))\n",
        "\n",
        "      loop_3.append([x_train, x_validation, y_train, y_validation])\n",
        "\n",
        "    loop_2.append(loop_3)\n",
        "\n",
        "  loop_1.append(loop_2)"
      ],
      "metadata": {
        "id": "SwTPMuJ9Zqtf"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "train_test_data = loop_1"
      ],
      "metadata": {
        "id": "d72Q-WZea7oH"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Trading metrics"
      ],
      "metadata": {
        "id": "zENlTnuaWEmt"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "PvqJ_LkKxqk4"
      },
      "outputs": [],
      "source": [
        "def max_drawdown(prices):\n",
        "    max_so_far = prices[0]\n",
        "    max_drawdown = 0\n",
        "    for price in prices:\n",
        "        if price > max_so_far:\n",
        "            max_so_far = price\n",
        "        else:\n",
        "            drawdown = 1 - price / max_so_far\n",
        "            if drawdown > max_drawdown:\n",
        "                max_drawdown = drawdown\n",
        "    return max_drawdown"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "yZbtH82_0L3S"
      },
      "outputs": [],
      "source": [
        "def recovery_rate(prices, max_drawdown):\n",
        "    max_so_far = prices[0]\n",
        "    for price in prices:\n",
        "        if price > max_so_far:\n",
        "            max_so_far = price\n",
        "        else:\n",
        "            drawdown = 1 - price / max_so_far\n",
        "            if drawdown > max_drawdown:\n",
        "                max_drawdown = drawdown\n",
        "    recovery_rate = 1 - max_drawdown\n",
        "    return recovery_rate"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "90RKuGXh0V4P"
      },
      "outputs": [],
      "source": [
        "def sharpe_ratio(money_change, num_years, risk_free_rate):\n",
        "    \"\"\"\n",
        "    Calculates the Sharpe Ratio for a given array of money changes,\n",
        "    assuming that the changes represent the results of a trading algorithm\n",
        "    over a certain period of time.\n",
        "    \"\"\"\n",
        "    # Calculate the trade returns\n",
        "    trade_returns = []\n",
        "    for i in range(len(money_change) - 1):\n",
        "        trade_returns.append((money_change[i+1] - money_change[i]) / money_change[i])\n",
        "\n",
        "    # Calculate the total return over the trading period\n",
        "    total_return = np.prod([1 + r for r in trade_returns]) - 1\n",
        "\n",
        "    # Calculate the annualized mean return and standard deviation of returns\n",
        "    num_trades = len(trade_returns)\n",
        "    annualized_return = (1 + total_return) ** (1 / num_years) - 1\n",
        "    annualized_std_dev = np.std(trade_returns) * np.sqrt(num_trades / num_years)\n",
        "\n",
        "    # Calculate the Sharpe Ratio\n",
        "    sharpe = (annualized_return - risk_free_rate) / annualized_std_dev\n",
        "\n",
        "    # Ensure Sharpe Ratio is not infinity or negative infinity\n",
        "    if sharpe == np.inf or sharpe == -np.inf:\n",
        "        sharpe = np.nan\n",
        "\n",
        "    # Return Sharpe Ratio\n",
        "    return sharpe"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def sortino_ratio(money_change, num_years, risk_free_rate):\n",
        "    \"\"\"\n",
        "    Calculates the Sortino Ratio for a given array of money changes,\n",
        "    assuming that the changes represent the results of a trading algorithm\n",
        "    over a certain period of time.\n",
        "    \"\"\"\n",
        "    # Calculate the trade returns\n",
        "    trade_returns = []\n",
        "    for i in range(len(money_change) - 1):\n",
        "        trade_returns.append((money_change[i+1] - money_change[i]) / money_change[i])\n",
        "\n",
        "    # Calculate the total return over the trading period\n",
        "    total_return = np.prod([1 + r for r in trade_returns]) - 1\n",
        "\n",
        "    # Calculate the downside deviation\n",
        "    downside_returns = [r for r in trade_returns if r < 0]\n",
        "    downside_deviation = np.std(downside_returns) * np.sqrt(len(trade_returns) / num_years)\n",
        "\n",
        "    # Calculate the annualized mean return and Sortino Ratio\n",
        "    num_trades = len(trade_returns)\n",
        "    annualized_return = (1 + total_return) ** (1 / num_years) - 1\n",
        "    sortino = (annualized_return - risk_free_rate) / downside_deviation\n",
        "\n",
        "    # Ensure Sortino Ratio is not infinity or negative infinity\n",
        "    if sortino == np.inf or sortino == -np.inf:\n",
        "        sortino = np.nan\n",
        "\n",
        "    # Return Sortino Ratio\n",
        "    return sortino"
      ],
      "metadata": {
        "id": "vNtKN9cS1HfT"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "4At8HeyR0tUb"
      },
      "outputs": [],
      "source": [
        "def cagr(account_money, years):\n",
        "\n",
        "  initial_value = account_money[0]\n",
        "  final_value = account_money[-1]\n",
        "\n",
        "  cagr = (final_value / initial_value) ** (1 / years) - 1\n",
        "\n",
        "  return cagr"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def sterling_ratio(money_change, num_years, risk_free_rate):\n",
        "    \"\"\"\n",
        "    Calculates the Sterling Ratio for a given array of money changes,\n",
        "    assuming that the changes represent the results of a trading algorithm\n",
        "    over a certain period of time.\n",
        "    \"\"\"\n",
        "    # Calculate the trade returns\n",
        "    trade_returns = []\n",
        "    for i in range(len(money_change) - 1):\n",
        "        trade_returns.append((money_change[i+1] - money_change[i]) / money_change[i])\n",
        "\n",
        "    # Calculate the total return over the trading period\n",
        "    total_return = np.prod([1 + r for r in trade_returns]) - 1\n",
        "\n",
        "    # Calculate the skewness and kurtosis of the returns\n",
        "    returns_skewness = skew(trade_returns)\n",
        "    returns_kurtosis = kurtosis(trade_returns)\n",
        "\n",
        "    # Calculate the annualized mean return and standard deviation of returns\n",
        "    num_trades = len(trade_returns)\n",
        "    annualized_return = (1 + total_return) ** (1 / num_years) - 1\n",
        "    annualized_std_dev = np.std(trade_returns) * np.sqrt(num_trades / num_years)\n",
        "\n",
        "    # Calculate the Sterling Ratio\n",
        "    sterling = (annualized_return - risk_free_rate) / (annualized_std_dev * (1 + 0.25 * returns_skewness + 0.025 * returns_kurtosis))\n",
        "\n",
        "    # Ensure Sterling Ratio is not infinity or negative infinity\n",
        "    if sterling == np.inf or sterling == -np.inf:\n",
        "        sterling = np.nan\n",
        "\n",
        "    # Return Sterling Ratio\n",
        "    return sterling"
      ],
      "metadata": {
        "id": "Cz9LSJfS5udc"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def modified_sharpe_ratio(money_change, num_years, risk_free_rate):\n",
        "    \"\"\"\n",
        "    Calculates the Modified Sharpe Ratio for a given array of money changes,\n",
        "    assuming that the changes represent the results of a trading algorithm\n",
        "    over a certain period of time.\n",
        "    \"\"\"\n",
        "    # Calculate the trade returns\n",
        "    trade_returns = []\n",
        "    for i in range(len(money_change) - 1):\n",
        "        trade_returns.append((money_change[i+1] - money_change[i]) / money_change[i])\n",
        "\n",
        "    # Calculate the total return over the trading period\n",
        "    total_return = np.prod([1 + r for r in trade_returns]) - 1\n",
        "\n",
        "    # Calculate the annualized mean return and standard deviation of returns\n",
        "    num_trades = len(trade_returns)\n",
        "    annualized_return = (1 + total_return) ** (1 / num_years) - 1\n",
        "    annualized_std_dev = np.std(trade_returns) * np.sqrt(num_trades / num_years)\n",
        "\n",
        "    # Calculate the Modified Sharpe Ratio\n",
        "    modified_sharpe = (annualized_return - risk_free_rate) / (annualized_std_dev + np.abs(annualized_return - risk_free_rate))\n",
        "\n",
        "    # Ensure Modified Sharpe Ratio is not infinity or negative infinity\n",
        "    if modified_sharpe == np.inf or modified_sharpe == -np.inf:\n",
        "        modified_sharpe = np.nan\n",
        "\n",
        "    # Return Modified Sharpe Ratio\n",
        "    return modified_sharpe"
      ],
      "metadata": {
        "id": "w91ub9UIDL39"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Report generator"
      ],
      "metadata": {
        "id": "BpFys_sOWJIR"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "detail = False\n",
        "\n",
        "ranking = [\n",
        "  # common parameters\n",
        "  [], # 0 - asset\n",
        "  [], # 1 - model\n",
        "  [], # 2 - scaler\n",
        "  [], # 3 - duration\n",
        "\n",
        "  [], # 4 - accuracy\n",
        "\n",
        "  # strategy - 0 - buy and hold\n",
        "  [], # 5 - profit threshold\n",
        "\n",
        "  # strategy - 1 - swing trading\n",
        "  [], # 6 - capital history\n",
        "  [], # 7 - profit\n",
        "  [], # 8 - cagr\n",
        "  [], # 9 - sharpe ratio\n",
        "  [], # 10 - sortino_ratio\n",
        "  [], # 11 - sterling_ratio\n",
        "  [], # 12 - modified sharpe ratio\n",
        "  [], # 13 - max dropdown\n",
        "  [], # 14 - recovery rate\n",
        "  [], # 15 - max profit\n",
        "  [], # 16 - max loss\n",
        "  [], # 17 - total trade\n",
        "\n",
        "  # strategy - 2 - day trading\n",
        "  [], # 18 - capital history\n",
        "  [], # 19 - profit\n",
        "  [], # 20 - cagr\n",
        "  [], # 21 - sharpe ratio\n",
        "  [], # 22 - sortino_ratio\n",
        "  [], # 23 - sterling_ratio\n",
        "  [], # 24 - modified sharpe ratio\n",
        "  [], # 25 - max dropdown\n",
        "  [], # 26 - recovery rate\n",
        "  [], # 27 - max profit\n",
        "  [], # 28 - max loss\n",
        "  [], # 29 - total trade\n",
        "]\n",
        "\n",
        "loop_1 = []\n",
        "for x, i in enumerate(train_test_data): # 2\n",
        "\n",
        "  loop_2 = []\n",
        "  for y, j in enumerate(i): # 10\n",
        "\n",
        "    loop_3 = []\n",
        "    for z, k in enumerate(j): # 2\n",
        "\n",
        "      loop_4 = []\n",
        "      for a, l in enumerate(model):\n",
        "\n",
        "        print(\"[\",x,\",\",y,\",\",z, \",\",a,\"]\")\n",
        "\n",
        "        try:\n",
        "\n",
        "          l.fit(k[0], [round(_) for _ in k[2]])\n",
        "\n",
        "          # m.save(path + \"result_\" + id * x * y * z + \".h5\", save_format=\"h5\")\n",
        "\n",
        "          prediction = l.predict(k[1])\n",
        "\n",
        "          trade_year = len(prediction)/365\n",
        "\n",
        "          rounded_prediction = np.interp(prediction, [min(prediction), max(prediction)], [0, 1])\n",
        "          rounded_prediction = [round(_) for _ in rounded_prediction]\n",
        "\n",
        "          rounded_truth = np.array([round(_) for _ in k[3]])\n",
        "\n",
        "          # inverted_prediction = [1-x for x in rounded_prediction]\n",
        "\n",
        "          score = classification_metric[0](rounded_truth, rounded_prediction)\n",
        "          # m.score(rounded_truth.reshape(-1, 1), rounded_prediction)\n",
        "\n",
        "          if(z % 2 == 0):\n",
        "            color = \"yellow\"\n",
        "\n",
        "          else:\n",
        "            color = \"lightblue\"\n",
        "\n",
        "          display(HTML('''<span style=\"color: ''' + color + '''\"><<---------------(start ['''+ str(a) + '''])--------------->></span>'''))\n",
        "\n",
        "          if(detail):\n",
        "            for i in classification_metric:\n",
        "              display(HTML('''<span style=\"color:LightGoldenRodYellow\"><br>[ '''+  i.__name__ + ''' ]<br></span>'''))\n",
        "\n",
        "              print(i(rounded_truth, rounded_prediction))\n",
        "\n",
        "          idea = pd.DataFrame(rounded_prediction, columns = ['Decision'])\n",
        "          idea['Decision'] = idea['Decision'].shift(-1) # shifting Decision column one row up (position is opened at Close)\n",
        "          idea.at[idea.index[0], 'Decision'] = 0.0 # no action on day 1\n",
        "          idea.at[idea.index[-1], 'Decision'] = 0.0 # close all\n",
        "\n",
        "          sliced_data = slicing(asset_data[x][y], 1 - train_size, 1)\n",
        "          fluctuation, swing_action, day_action, swing_profit, day_profit, swing_snapshot, day_snapshot, swing_sell_price, day_sell_price = decision_to_action(sliced_data, idea['Decision'], [], [], [], [], [])\n",
        "\n",
        "          swing_cagr = cagr(swing_sell_price, trade_year) # (swing_profit['Swing Profit'].iloc[-1]/money) ** (1/trade_year) - 1\n",
        "          day_cagr = cagr(day_sell_price, trade_year) # (day_profit['Day Profit'].iloc[-1]/money) ** (1/trade_year) - 1\n",
        "          # cagr = (sliced_data['Close'][len(sliced_data) - 1]/sliced_data['Close'][0]) ** (1/trade_year) - 1\n",
        "          # std = statistics.stdev(sliced_data['Close']) * (trading_day**(1/2))\n",
        "\n",
        "          # print(swing_sell_price)\n",
        "          # print(day_sell_price)\n",
        "\n",
        "          swing_sharpe_ratio = sharpe_ratio(swing_sell_price, trade_year, risk_free_rate) # (swing_cagr - risk_free_rate)/std\n",
        "          day_sharpe_ratio = sharpe_ratio(day_sell_price, trade_year, risk_free_rate) # (day_cagr - risk_free_rate)/std\n",
        "\n",
        "          # print(swing_sharpe_ratio, day_sharpe_ratio)\n",
        "\n",
        "          swing_sortino_ratio = sortino_ratio(swing_sell_price, trade_year, risk_free_rate)\n",
        "          day_sortino_ratio = sortino_ratio(day_sell_price, trade_year, risk_free_rate)\n",
        "\n",
        "          swing_sterling_ratio = sterling_ratio(swing_sell_price, trade_year, risk_free_rate)\n",
        "          day_sterling_ratio = sterling_ratio(day_sell_price, trade_year, risk_free_rate)\n",
        "\n",
        "          swing_modified_sharpe_ratio = sharpe_ratio(swing_sell_price, trade_year, risk_free_rate) # (swing_cagr - risk_free_rate)/std\n",
        "          day_modified_sharpe_ratio = sharpe_ratio(day_sell_price, trade_year, risk_free_rate) # (day_cagr - risk_free_rate)/std\n",
        "\n",
        "          # print(swing_sharpe_ratio, day_sharpe_ratio)\n",
        "          # print(swing_sortino_ratio, day_sortino_ratio)\n",
        "          # print(swing_sterling_ratio, day_sterling_ratio)\n",
        "          # print(swing_modified_sharpe_ratio, day_modified_sharpe_ratio)\n",
        "\n",
        "          swing_mdd = max_drawdown(swing_sell_price)\n",
        "          day_mdd = max_drawdown(day_sell_price)\n",
        "\n",
        "          swing_rr = recovery_rate(swing_sell_price, swing_mdd) # (swing_sell_price[-1]-min(swing_sell_price))/(max(swing_sell_price)-min(swing_sell_price))\n",
        "          day_rr = recovery_rate(day_sell_price, day_mdd) # (day_sell_price[-1]-min(day_sell_price))/(max(day_sell_price)-min(day_sell_price))\n",
        "\n",
        "          # current_frame = pd.concat([sliced_data.reset_index(), fluctuation['Volatility'], idea['Decision'], swing_action['Swing Action'], swing_profit['Swing Profit'], day_action['Day Action'], day_profit['Day Profit']], axis=1)\n",
        "          # display(current_frame.style.applymap(actionColor))\n",
        "\n",
        "          print(\"\\n(\", a, \") \", l.__class__.__name__ ,\"\\n\")\n",
        "          print(\"(\", z, \") \", scaler[z], \"\\n\")\n",
        "\n",
        "          ranking[0].append(asset[x][y]) # asset\n",
        "          ranking[1].append(l.__class__.__name__) # model\n",
        "          ranking[2].append(scaler[z]) # scaler\n",
        "          ranking[3].append(trade_year) # duration\n",
        "          ranking[4].append(score) # accuracy\n",
        "\n",
        "          # strategy - 0 - buy and hold\n",
        "          ranking[5].append(money+(sliced_data['Open'].iloc[-1]-sliced_data['Open'].iloc[0])*int(money/sliced_data['Open'].iloc[0]) - money) # profit threshold\n",
        "\n",
        "          # strategy - 1 - swing trading\n",
        "          ranking[6].append(swing_sell_price) # capital history\n",
        "          ranking[7].append(swing_sell_price[-1] - money) # net profit\n",
        "          ranking[8].append(swing_cagr) # compound annual growth rate\n",
        "          ranking[9].append(swing_sharpe_ratio) # sharpe ratio\n",
        "          ranking[10].append(swing_sortino_ratio) # sortino_ratio\n",
        "          ranking[11].append(swing_sterling_ratio) # sterling_ratio\n",
        "          ranking[12].append(swing_modified_sharpe_ratio) # modified sharpe ratio\n",
        "          ranking[13].append(swing_mdd) # max drawdown\n",
        "          ranking[14].append(swing_rr) # recovery rate\n",
        "          ranking[15].append(swing_snapshot[0]) # max profit\n",
        "          ranking[16].append(swing_snapshot[1]) # max loss\n",
        "          ranking[17].append(len(swing_sell_price) - 1) # total trade\n",
        "\n",
        "          ranking[18].append(day_sell_price) # capital history\n",
        "          ranking[19].append(day_sell_price[-1] - money) # net profit\n",
        "          ranking[20].append(day_cagr) # compound annual growth rate\n",
        "          ranking[21].append(day_sharpe_ratio) # sharpe ratio\n",
        "          ranking[22].append(day_sortino_ratio) # sortino_ratio\n",
        "          ranking[23].append(day_sterling_ratio) # sterling_ratio\n",
        "          ranking[24].append(day_modified_sharpe_ratio) # modified sharpe ratio\n",
        "          ranking[25].append(day_mdd) # max drawdown\n",
        "          ranking[26].append(day_rr) # recovery rate\n",
        "          ranking[27].append(day_snapshot[0]) # max profit\n",
        "          ranking[28].append(day_snapshot[1]) # max loss\n",
        "          ranking[29].append(len(day_sell_price) - 1) # total trade\n",
        "\n",
        "          # print([last for *_, last in ranking])\n",
        "\n",
        "          display(HTML('''<br><span style=\"color: ''' + color + '''\"><<---------------(end ['''+ str(a) + '''])--------------->></span>'''))\n",
        "\n",
        "        except:\n",
        "\n",
        "          pass\n",
        "\n",
        "        loop_4.append(ranking)\n",
        "\n",
        "      loop_3.append(loop_4)\n",
        "\n",
        "    loop_2.append(loop_3)\n",
        "\n",
        "  loop_1.append(loop_2)"
      ],
      "metadata": {
        "id": "nuTFyehZ2CdV"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Scaling for Sharpe Ratio"
      ],
      "metadata": {
        "id": "jK_pmg9fRfL8"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "adjusted_range = [-3, 3]\n",
        "\n",
        "for i in [9, 21]:\n",
        "  if(min(ranking[i]) < adjusted_range[0] or max(ranking[i]) > adjusted_range[1]):\n",
        "    ranking[i] = np.interp(ranking[i], [min(ranking[i]), max(ranking[i])], adjusted_range)"
      ],
      "metadata": {
        "id": "eI--xTxxxuEd"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "ranking_x = loop_1"
      ],
      "metadata": {
        "id": "JXFVdJXpIVOK"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def drop_duplicate_rows(arr):\n",
        "    unique_rows = []\n",
        "\n",
        "    for row in arr:\n",
        "        if not any(np.array_equal(row, unique_row) for unique_row in unique_rows):\n",
        "            unique_rows.append(row)\n",
        "\n",
        "    unique_arr = np.array(unique_rows, dtype=object)\n",
        "\n",
        "    return unique_arr"
      ],
      "metadata": {
        "id": "zBFcDpxFfved"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def drop_duplicate_columns(arr):\n",
        "    # Convert NaN values to string representation\n",
        "    arr[np.isnan(arr)] = 'np.nan'\n",
        "\n",
        "    # Convert array elements to strings\n",
        "    arr_strings = np.array([str(row) for row in arr])\n",
        "\n",
        "    # Find unique strings\n",
        "    unique_strings = np.unique(arr_strings, axis=0)\n",
        "\n",
        "    # Convert strings back to array\n",
        "    unique_arr = np.array([eval(row.replace('nan', 'np.nan')) for row in unique_strings])\n",
        "\n",
        "    return unique_arr"
      ],
      "metadata": {
        "id": "TFbRo5uEjKzU"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# ranking_only = drop_duplicate_columns(ranking)"
      ],
      "metadata": {
        "id": "Fthj6qLEgfph"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def drop_element(arr):\n",
        "    n = min(len(row) for row in arr)  # Number of columns\n",
        "\n",
        "    for i in range(len(arr)):\n",
        "        if len(arr[i]) > n:\n",
        "            arr[i] = arr[i][:n]\n",
        "\n",
        "    return arr"
      ],
      "metadata": {
        "id": "MY-R7sHg-M4e"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "ranking_only = drop_element(ranking)"
      ],
      "metadata": {
        "id": "suRGXMXp-OuF"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "len(ranking)"
      ],
      "metadata": {
        "id": "pYS1HtM0iyqc"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "len(ranking_only)"
      ],
      "metadata": {
        "id": "90HA8w11rBV8"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "len(ranking[0])"
      ],
      "metadata": {
        "id": "yIQnPDoIitTy"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "len(ranking_only[0])"
      ],
      "metadata": {
        "id": "KvvaT48qrESa"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "pd.DataFrame(ranking_x[0][0][0][0])"
      ],
      "metadata": {
        "id": "sftEKDqAscEz"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Last frame for the multi-dimensional array"
      ],
      "metadata": {
        "id": "yPQHglCdR1lR"
      }
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yHBPT-_aNx82"
      },
      "source": [
        "Report Section"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "5riWQjIH8PYo"
      },
      "outputs": [],
      "source": [
        "parameter = [\n",
        "    'duration',\n",
        "    'accuracy',\n",
        "    'profit threshold',\n",
        "    'net profit',\n",
        "    'cagr',\n",
        "    'sharpe ratio',\n",
        "    # 'sortino ratio',\n",
        "    # 'sterling ratio',\n",
        "    # 'modified sharpe ratio',\n",
        "    'max drawdown',\n",
        "    'recovery rate',\n",
        "    'max profit',\n",
        "    'max loss',\n",
        "    'total trade'\n",
        "    ]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "QPVGInXA8SGs"
      },
      "outputs": [],
      "source": [
        "true_false = [True, False]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "i4ltlSFVkUUa"
      },
      "outputs": [],
      "source": [
        "show_result = 10"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pgByt8n5CuuV"
      },
      "source": [
        "(Report 1) Swing Trading Batch Classification Report\n",
        "<a name=\"swing-trading-data-report\"></a>\n",
        "\n",
        "[Meun](#nav-meun)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "3H25nDCSvf0T"
      },
      "outputs": [],
      "source": [
        "for state in true_false:\n",
        "\n",
        "  for rank in parameter:\n",
        "\n",
        "    swing_chart = pd.DataFrame(data = {\n",
        "                                    'asset': ranking_only[0],\n",
        "                                    'model': ranking_only[1],\n",
        "                                    'duration': ranking_only[3],\n",
        "\n",
        "                                    'accuracy': ranking_only[4],\n",
        "\n",
        "                                    'profit threshold': ranking_only[5],\n",
        "\n",
        "                                    'profit history': ranking_only[6],\n",
        "                                    'net profit': ranking_only[7],\n",
        "                                    'cagr': ranking_only[8],\n",
        "                                    'sharpe ratio': ranking_only[9],\n",
        "                                    # 'sortino ratio': ranking_only[10],\n",
        "                                    # 'sterling ratio': ranking_only[11],\n",
        "                                    # 'modified sharpe ratio': ranking_only[12],\n",
        "                                    'max drawdown': ranking_only[13],\n",
        "                                    'recovery rate': ranking_only[14],\n",
        "                                    'max profit': ranking_only[15],\n",
        "                                    'max loss': ranking_only[16],\n",
        "                                    'total trade': ranking_only[17]\n",
        "                                    }).sort_values(by=rank, ascending=state, inplace=False).dropna()\n",
        "\n",
        "    swing_report = swing_chart.drop(columns=['profit history'], axis=1)\n",
        "\n",
        "    word = ''\n",
        "\n",
        "    if(state):\n",
        "      word = 'Fewest'\n",
        "    else:\n",
        "      word = 'Greatest'\n",
        "\n",
        "    chart = swing_chart.head(show_result)\n",
        "    swing_chart = swing_report.head(show_result)\n",
        "\n",
        "    print(\"\\n(\" + word +\") \" + str(show_result) +\" swing trading models [\"+ rank + \"]:\")\n",
        "    color_frame = swing_chart.style.applymap(reportColor, subset=['asset', 'model'])\n",
        "    color_frame = color_frame.applymap(swingColor, subset=[rank])\n",
        "    display(color_frame)\n",
        "\n",
        "    fig, axes = plt.subplots(int(show_result/5), 5, figsize=(30, show_result))\n",
        "    fig.subplots_adjust(hspace=0.5)\n",
        "    ax = axes.flat\n",
        "\n",
        "    for i, flow in enumerate(chart['profit history']):\n",
        "\n",
        "      color = ''\n",
        "      if(flow[0] < flow[-1]):\n",
        "        ax[i].set_facecolor('xkcd:light green')\n",
        "        color = 'black'\n",
        "      else:\n",
        "        ax[i].set_facecolor('xkcd:deep red')\n",
        "        color = 'white'\n",
        "\n",
        "      ax[i].plot(flow, color=color)\n",
        "\n",
        "      ax[i].set_title(word + ' - [' + str(i + 1)+ ']\\n\\n' + str(rank) + ':' + str(swing_chart[rank][swing_chart.index.values[i]]) + '\\n\\n[' +  swing_chart['asset'][swing_chart.index.values[i]] + ' ' + swing_chart['model'][swing_chart.index.values[i]] + ']', fontsize=10)\n",
        "\n",
        "      ax[i].set_xlabel('Trade', fontsize=15)\n",
        "      ax[i].set_ylabel('Profit History', fontsize=15)\n",
        "\n",
        "      ax[i].tick_params(axis='both', labelsize=15)\n",
        "\n",
        "      h1, l1  = ax[i].get_legend_handles_labels()"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "(Swing Trading) - Dummy investiment in all models"
      ],
      "metadata": {
        "id": "4dPxNJ2YSe9Y"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "diversify_investiment = swing_report['net profit'].sum() - money * len(swing_report['net profit'])\n",
        "\n",
        "print(\"Gain of diversify investment in swing trading:\\n\\nnet profit --->\", diversify_investiment, \"(\", diversify_investiment / (money * len(swing_report['net profit'])),\"% )\")"
      ],
      "metadata": {
        "id": "OpZQ0IwBpHBg"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "(Report 2) Day Trading Batch Classification Report\n",
        "<a name=\"day-trading-data-report\"></a>\n",
        "\n",
        "[Meun](#nav-meun)"
      ],
      "metadata": {
        "id": "rZuiabXgNLhR"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "for state in true_false:\n",
        "\n",
        "  for rank in parameter:\n",
        "\n",
        "    day_chart = pd.DataFrame(data = {\n",
        "                                    'asset': ranking_only[0],\n",
        "                                    'model': ranking_only[1],\n",
        "                                    'duration': ranking_only[3],\n",
        "\n",
        "                                    'accuracy': ranking_only[4],\n",
        "\n",
        "                                    'profit threshold': ranking_only[5],\n",
        "\n",
        "                                    'profit history': ranking_only[18],\n",
        "                                    'net profit': ranking_only[19],\n",
        "                                    'cagr': ranking_only[20],\n",
        "                                    'sharpe ratio': ranking_only[21],\n",
        "                                    # 'sortino ratio': ranking_only[22],\n",
        "                                    # 'sterling ratio': ranking_only[23],\n",
        "                                    # 'modified sharpe ratio': ranking_only[24],\n",
        "                                    'max drawdown': ranking_only[25],\n",
        "                                    'recovery rate': ranking_only[26],\n",
        "                                    'max profit': ranking_only[27],\n",
        "                                    'max loss': ranking_only[28],\n",
        "                                    'total trade': ranking_only[29]\n",
        "                                    }).sort_values(by=rank, ascending=state, inplace=False).dropna()\n",
        "\n",
        "    day_report = day_chart.drop(columns=['profit history'], axis=1)\n",
        "\n",
        "    word = ''\n",
        "\n",
        "    if(state):\n",
        "      word = 'Fewest'\n",
        "    else:\n",
        "      word = 'Greatest'\n",
        "\n",
        "    chart = day_chart.head(10)\n",
        "    day_chart = day_report.head(10)\n",
        "\n",
        "    print(\"\\n(\" + word +\") 10 day trading models [\"+ rank + \"]:\")\n",
        "    color_frame = day_chart.style.applymap(reportColor, subset=['asset', 'model'])\n",
        "    color_frame = color_frame.applymap(dayColor, subset=[rank])\n",
        "    display(color_frame)\n",
        "\n",
        "    fig, axes = plt.subplots(int(show_result/5), 5, figsize=(30, show_result))\n",
        "    fig.subplots_adjust(hspace=0.5)\n",
        "    ax = axes.flat\n",
        "\n",
        "    for i, flow in enumerate(chart['profit history']):\n",
        "\n",
        "      color = ''\n",
        "      if(flow[0] < flow[-1]):\n",
        "        ax[i].set_facecolor('xkcd:light green')\n",
        "        color = 'black'\n",
        "      else:\n",
        "        ax[i].set_facecolor('xkcd:deep red')\n",
        "        color = 'white'\n",
        "\n",
        "      ax[i].plot(flow, color=color)\n",
        "\n",
        "      ax[i].set_title(word + ' - [' + str(i + 1)+ ']\\n\\n' + str(rank) + ':' + str(day_chart[rank][day_chart.index.values[i]]) + '\\n\\n[' +  day_chart['asset'][day_chart.index.values[i]] + ' ' + day_chart['model'][day_chart.index.values[i]] + ']', fontsize=10)\n",
        "\n",
        "      ax[i].set_xlabel('Trade', fontsize=15)\n",
        "      ax[i].set_ylabel('Profit History', fontsize=15)\n",
        "\n",
        "      ax[i].tick_params(axis='both', labelsize=15)\n",
        "\n",
        "      h1, l1  = ax[i].get_legend_handles_labels()"
      ],
      "metadata": {
        "id": "ILP6mUWLpKvv"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "(Day Trading) - Dummy investiment in all models"
      ],
      "metadata": {
        "id": "bcsvIA3GSTMZ"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "LaTlZURjgIbJ"
      },
      "outputs": [],
      "source": [
        "diversify_investiment = day_report['net profit'].sum() - money * len(day_report['net profit'])\n",
        "\n",
        "print(\"Gain of diversify investment in day trading:\\n\\nnet profit --->\", diversify_investiment, \"(\", diversify_investiment / (money * len(day_report['net profit'])),\"% )\")"
      ]
    }
  ],
  "metadata": {
    "accelerator": "TPU",
    "colab": {
      "machine_shape": "hm",
      "provenance": [],
      "gpuClass": "premium",
      "private_outputs": true
    },
    "gpuClass": "premium",
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}