diff --git a/experiments/backtest.py b/experiments/backtest.py
index 9a5e5f5..c97f64a 100644
--- a/experiments/backtest.py
+++ b/experiments/backtest.py
@@ -45,7 +45,7 @@ class OptimizationInput:
     volume: pd.DataFrame
     quantities: np.ndarray
     cash: float
-    risk_target: float
+    # risk_target: float
     risk_free: float
 
     @property
@@ -150,7 +150,7 @@ def run_backtest(
 def run_markowitz(
     strategy: callable,
     targets: namedtuple,
-    limits: namedtuple,
+    # limits: namedtuple,
     hyperparameters: namedtuple,
     prices=None,
     spread=None,
@@ -185,19 +185,19 @@ def run_markowitz(
     lookback = 500
     forward_smoothing = 5
 
-    constraint_names = [
-        "FullInvestment",
-        "Cash",
-        "CLower",
-        "CUpper",
-        "WLower",
-        "WUpper",
-        "ZLower",
-        "ZUpper",
-        "Leverage",
-        "Turnover",
-        "Risk",
-    ]
+    # constraint_names = [
+    #     "FullInvestment",
+    #     "Cash",
+    #     "CLower",
+    #     "CUpper",
+    #     "WLower",
+    #     "WUpper",
+    #     "ZLower",
+    #     "ZUpper",
+    #     "Leverage",
+    #     "Turnover",
+    #     "Risk",
+    # ]
 
     timings = []
 
@@ -221,13 +221,13 @@ def run_markowitz(
     # To store results
     post_trade_cash = []
     post_trade_quantities = []
-    dual_optimals = (
-        pd.DataFrame(
-            columns=constraint_names,
-            index=prices.index[lookback:-1],
-        )
-        * np.nan
-    )
+    # dual_optimals = (
+    #     pd.DataFrame(
+    #         columns=constraint_names,
+    #         index=prices.index[lookback:-1],
+    #     )
+    #     * np.nan
+    # )
 
     for t in range(lookback, len(prices) - forward_smoothing):
         start_time = time.perf_counter()
@@ -251,12 +251,14 @@ def run_markowitz(
             volume_t,
             quantities,
             cash,
-            limits.risk_max,
+            # limits.risk_max,
             rf.iloc[t],
         )
 
         w, _, problem, problem_solved = strategy(
-            inputs_t, hyperparameters, targets=targets, limits=limits
+            inputs_t,
+            hyperparameters,
+            targets=targets,
         )
 
         latest_prices = prices.iloc[t]  # At t
@@ -287,11 +289,11 @@ def run_markowitz(
         post_trade_cash.append(cash)
         post_trade_quantities.append(quantities.copy())
 
-        if problem_solved:
-            for name in constraint_names:
-                dual_optimals.loc[day, name] = problem.constraints[
-                    constraint_names.index(name)
-                ].dual_value
+        # if problem_solved:
+        #     for name in constraint_names:
+        #         dual_optimals.loc[day, name] = problem.constraints[
+        #             constraint_names.index(name)
+        #         ].dual_value
 
         # Timings
         end_time = time.perf_counter()
@@ -309,11 +311,8 @@ def run_markowitz(
         columns=prices.columns,
     )
 
-    return (
-        BacktestResult(
-            post_trade_cash, post_trade_quantities, limits.risk_max, timings
-        ),
-        dual_optimals,
+    return BacktestResult(
+        post_trade_cash, post_trade_quantities, targets.risk_target, timings
     )
 
 
diff --git a/experiments/playground.ipynb b/experiments/playground.ipynb
index 06f6791..fe3b8d1 100644
--- a/experiments/playground.ipynb
+++ b/experiments/playground.ipynb
@@ -2,7 +2,7 @@
  "cells": [
   {
    "cell_type": "code",
-   "execution_count": 265,
+   "execution_count": 2,
    "metadata": {},
    "outputs": [
     {
@@ -24,7 +24,7 @@
     "from experiments.backtest import interest_and_fees, OptimizationInput, create_orders, execute_orders, Timing, BacktestResult, run_markowitz, run_backtest\n",
     "from taming import turnover_limit_markowitz\n",
     "\n",
-    "from tuning import HyperParameters, get_data_and_parameters, full_markowitz, Limits, Targets\n",
+    "from tuning import HyperParameters, get_data_and_parameters, full_markowitz, Limits, Targets, tune_parameters, tune_in_parallel\n",
     "\n",
     "# increase standard plt font size   \n",
     "plt.rcParams.update({'font.size': 10})\n",
@@ -36,7 +36,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 3,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -77,7 +77,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 312,
+   "execution_count": 6,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -101,8 +101,8 @@
     "        risk_max,\n",
     "):\n",
     "    targets = Targets(\n",
-    "        T_target=T_target,\n",
-    "        L_target=L_target,\n",
+    "        T_max=T_target,\n",
+    "        L_max=L_target,\n",
     "        risk_target=risk_target,\n",
     "    )\n",
     "\n",
@@ -258,7 +258,7 @@
     "        else:\n",
     "            parameters_to_results[backtest] = (hyperparameters, results, results_best)\n",
     "\n",
-    "            gamma_temp = hyperparameter_list[update_var] * 0.9\n",
+    "            gamma_temp = hyperparameter_list[update_var] * 0.8\n",
     "            hyperparameter_list_temp[update_var] = gamma_temp\n",
     "            hyperparameters_temp = HyperParameters(\n",
     "                *hyperparameter_list_temp\n",
@@ -293,25 +293,6 @@
     "    return parameters_to_results, best_iteration"
    ]
   },
-  {
-   "cell_type": "code",
-   "execution_count": 338,
-   "metadata": {},
-   "outputs": [
-    {
-     "ename": "NameError",
-     "evalue": "name 'backtest' is not defined",
-     "output_type": "error",
-     "traceback": [
-      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
-      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
-      "Cell \u001b[0;32mIn[338], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m backtest\n",
-      "\u001b[0;31mNameError\u001b[0m: name 'backtest' is not defined"
-     ]
-    }
-   ],
-   "source": []
-  },
   {
    "cell_type": "code",
    "execution_count": 221,
@@ -333,102 +314,109 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 339,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "19"
-      ]
-     },
-     "execution_count": 339,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "len(parameter_dict_new)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 313,
+   "execution_count": 5,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "SR first soft: 4.751078595138429\n",
-      "Initial sharpes: 4.60214392258915, 5.099387798177832\n",
+      "Initial sharpes: 4.616708141214785, 5.101972582260716\n",
       "In a row: 1\n",
       "\n",
-      "Iteration number 1; current sharpes: (4.60214392258915, 5.099387798177832)\n",
+      "Iteration number 1; current sharpes: (4.616708141214785, 5.101972582260716)\n",
       "Hyperparameters: HyperParameters(gamma_hold=1, gamma_trade=1, gamma_turn=0.0025, gamma_leverage=0.0005, gamma_risk=0.05)\n",
       "In a row: 2\n",
       "\n",
-      "Iteration number 2; current sharpes: (4.60214392258915, 5.099387798177832)\n",
+      "Iteration number 2; current sharpes: (4.616708141214785, 5.101972582260716)\n",
       "Hyperparameters: HyperParameters(gamma_hold=1, gamma_trade=1, gamma_turn=0.0025, gamma_leverage=0.0005, gamma_risk=0.05)\n",
-      "Turnover: 61.17732817018341, 67.20831469141372\n",
-      "Leverage: 1.6000584525008672, 1.6788554198949541\n",
-      "Risk: 0.09911579875984637, 0.0792256863614121\n",
+      "Turnover: 74.37632288647134, 82.66882027114994\n",
+      "Leverage: 1.6002367538520095, 1.6788976954194474\n",
+      "Risk: 0.1084040090291092, 0.07958695567462097\n",
       "\n",
-      "Iteration number 3; current sharpes: (4.7047631560794505, 5.267650517762955)\n",
-      "Hyperparameters: HyperParameters(gamma_hold=1, gamma_trade=1, gamma_turn=0.0022500000000000003, gamma_leverage=0.0005, gamma_risk=0.05)\n",
-      "Turnover: 61.2124120368293, 67.24034129701268\n",
-      "Leverage: 1.6000555521770816, 1.683837787548858\n",
-      "Risk: 0.09898814835901804, 0.07923656549876783\n",
+      "Iteration number 3; current sharpes: (4.8282682573559335, 6.040935440502499)\n",
+      "Hyperparameters: HyperParameters(gamma_hold=1, gamma_trade=1, gamma_turn=0.002, gamma_leverage=0.0005, gamma_risk=0.05)\n",
+      "Turnover: 74.37650981412338, 82.67826140857754\n",
+      "Leverage: 1.6002316490046613, 1.704720906512608\n",
+      "Risk: 0.10840096325160933, 0.07962247674345706\n",
       "\n",
-      "Iteration number 4; current sharpes: (4.7097122178414565, 5.282158578336815)\n",
-      "Hyperparameters: HyperParameters(gamma_hold=1, gamma_trade=1, gamma_turn=0.0022500000000000003, gamma_leverage=0.00045000000000000004, gamma_risk=0.05)\n",
-      "Turnover: 61.46903367569957, 67.38638998266765\n",
-      "Leverage: 1.622050515354239, 1.626560259250039\n",
-      "Risk: 0.1001193954496518, 0.08198390690254881\n",
+      "Iteration number 4; current sharpes: (4.828364753966254, 6.009145658775684)\n",
+      "Hyperparameters: HyperParameters(gamma_hold=1, gamma_trade=1, gamma_turn=0.002, gamma_leverage=0.0004, gamma_risk=0.05)\n",
+      "Turnover: 73.96002880425284, 81.93782347857852\n",
+      "Leverage: 1.6001150918150198, 1.7173164532572494\n",
+      "Risk: 0.09446270490968499, 0.07616438296493207\n",
       "\n",
-      "Iteration number 5; current sharpes: (4.779166462491171, 5.369958742339731)\n",
-      "Hyperparameters: HyperParameters(gamma_hold=1, gamma_trade=1, gamma_turn=0.0022500000000000003, gamma_leverage=0.00045000000000000004, gamma_risk=0.045000000000000005)\n",
+      "Iteration number 5; current sharpes: (5.016135974132905, 6.082435372803036)\n",
+      "Hyperparameters: HyperParameters(gamma_hold=1, gamma_trade=1, gamma_turn=0.002, gamma_leverage=0.0004, gamma_risk=0.0625)\n",
       "In a row: 1\n",
       "\n",
-      "Iteration number 6; current sharpes: (4.779166462491171, 5.369958742339731)\n",
-      "Hyperparameters: HyperParameters(gamma_hold=1, gamma_trade=1, gamma_turn=0.0022500000000000003, gamma_leverage=0.00045000000000000004, gamma_risk=0.045000000000000005)\n",
+      "Iteration number 6; current sharpes: (5.016135974132905, 6.082435372803036)\n",
+      "Hyperparameters: HyperParameters(gamma_hold=1, gamma_trade=1, gamma_turn=0.002, gamma_leverage=0.0004, gamma_risk=0.0625)\n",
+      "Turnover: 75.45617981901842, 84.29107189268984\n",
+      "Leverage: 1.6001119234626813, 1.694835544817107\n",
+      "Risk: 0.09158575028015516, 0.07603443201108856\n",
+      "\n",
+      "Iteration number 7; current sharpes: (5.117902580461632, 6.067776758042245)\n",
+      "Hyperparameters: HyperParameters(gamma_hold=1, gamma_trade=0.8, gamma_turn=0.002, gamma_leverage=0.0004, gamma_risk=0.0625)\n",
+      "Turnover: 127.17373535505119, 140.5881836102992\n",
+      "In a row: 1\n",
+      "\n",
+      "Iteration number 8; current sharpes: (5.117902580461632, 6.067776758042245)\n",
+      "Hyperparameters: HyperParameters(gamma_hold=1, gamma_trade=0.8, gamma_turn=0.002, gamma_leverage=0.0004, gamma_risk=0.0625)\n",
+      "Turnover: 75.45644237810967, 84.29320802076731\n",
+      "Leverage: 1.6001139534383584, 1.7097154748448136\n",
+      "Risk: 0.09158460518087146, 0.07603376858928032\n",
+      "\n",
+      "Iteration number 9; current sharpes: (5.117973409265692, 6.066310764362226)\n",
+      "Hyperparameters: HyperParameters(gamma_hold=1, gamma_trade=0.8, gamma_turn=0.002, gamma_leverage=0.00032, gamma_risk=0.0625)\n",
+      "Turnover: 75.01338936868238, 84.19458917126163\n",
+      "Leverage: 1.6000329731617338, 1.6449009558077068\n",
+      "Risk: 0.08739035477215591, 0.07353709244005115\n",
+      "\n",
+      "Iteration number 10; current sharpes: (5.124564293244454, 5.934848622891193)\n",
+      "Hyperparameters: HyperParameters(gamma_hold=1, gamma_trade=0.8, gamma_turn=0.002, gamma_leverage=0.00032, gamma_risk=0.078125)\n",
+      "In a row: 1\n",
+      "\n",
+      "Iteration number 11; current sharpes: (5.124564293244454, 5.934848622891193)\n",
+      "Hyperparameters: HyperParameters(gamma_hold=1, gamma_trade=0.8, gamma_turn=0.002, gamma_leverage=0.00032, gamma_risk=0.078125)\n",
       "In a row: 2\n",
       "\n",
-      "Iteration number 7; current sharpes: (4.779166462491171, 5.369958742339731)\n",
-      "Hyperparameters: HyperParameters(gamma_hold=1, gamma_trade=1, gamma_turn=0.0022500000000000003, gamma_leverage=0.00045000000000000004, gamma_risk=0.045000000000000005)\n",
+      "Iteration number 12; current sharpes: (5.124564293244454, 5.934848622891193)\n",
+      "Hyperparameters: HyperParameters(gamma_hold=1, gamma_trade=0.8, gamma_turn=0.002, gamma_leverage=0.00032, gamma_risk=0.078125)\n",
+      "Turnover: 124.73815042029376, 139.9890153086435\n",
       "In a row: 3\n",
       "\n",
-      "Iteration number 8; current sharpes: (4.779166462491171, 5.369958742339731)\n",
-      "Hyperparameters: HyperParameters(gamma_hold=1, gamma_trade=1, gamma_turn=0.0022500000000000003, gamma_leverage=0.00045000000000000004, gamma_risk=0.045000000000000005)\n",
+      "Iteration number 13; current sharpes: (5.124564293244454, 5.934848622891193)\n",
+      "Hyperparameters: HyperParameters(gamma_hold=1, gamma_trade=0.8, gamma_turn=0.002, gamma_leverage=0.00032, gamma_risk=0.078125)\n",
       "In a row: 4\n",
       "\n",
-      "Iteration number 9; current sharpes: (4.779166462491171, 5.369958742339731)\n",
-      "Hyperparameters: HyperParameters(gamma_hold=1, gamma_trade=1, gamma_turn=0.0022500000000000003, gamma_leverage=0.00045000000000000004, gamma_risk=0.045000000000000005)\n"
+      "Iteration number 14; current sharpes: (5.124564293244454, 5.934848622891193)\n",
+      "Hyperparameters: HyperParameters(gamma_hold=1, gamma_trade=0.8, gamma_turn=0.002, gamma_leverage=0.00032, gamma_risk=0.078125)\n"
      ]
     }
    ],
    "source": [
-    "parameter_dict_new, best_iteration = tune_parameters(\n",
+    "parameter_dict, best_backtest = tune_parameters(\n",
     "    full_markowitz,\n",
-    "    500,\n",
     "    prices_train_test,\n",
     "    spread_train_test, \n",
     "    volume_train_test,\n",
     "    rf_train_test,\n",
+    "    train_len=train_len,\n",
     ")"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 196,
+   "execution_count": 11,
    "metadata": {},
    "outputs": [],
    "source": [
-    "def run_strategy(targets, limits, hyperparameters):\n",
-    "        results, duals = run_markowitz(\n",
+    "def run_strategy(targets, hyperparameters):\n",
+    "        results = run_markowitz(\n",
     "            full_markowitz,\n",
     "            targets=targets,\n",
-    "            limits=limits,\n",
+    "            # limits=limits,\n",
     "            hyperparameters=hyperparameters,\n",
     "            # prices=prices_train_test,\n",
     "            # spread=spread_train_test,\n",
@@ -436,21 +424,27 @@
     "            # rf=rf_train_test,\n",
     "            verbose=True,\n",
     "        )\n",
-    "        return results, duals\n",
+    "        return results\n",
     "\n",
-    "targets, limits = get_limits_and_targets(\n",
-    "        T_target=50/252,\n",
-    "        L_target=1.6,\n",
+    "targets = Targets(\n",
+    "        T_max=50/252,\n",
+    "        L_max=1.6,\n",
     "        risk_target=0.1/np.sqrt(252),\n",
-    "        T_max=1e3,\n",
-    "        L_max=1e3,\n",
-    "        risk_max=1e3,\n",
-    "    )"
+    "    )\n",
+    "\n",
+    "# targets, limits = get_limits_and_targets(\n",
+    "#         T_target=50/252,\n",
+    "#         L_target=1.6,\n",
+    "#         risk_target=0.1/np.sqrt(252),\n",
+    "#         T_max=1e3,\n",
+    "#         L_max=1e3,\n",
+    "#         risk_max=1e3,\n",
+    "#     )"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 208,
+   "execution_count": 12,
    "metadata": {},
    "outputs": [
     {
@@ -518,7 +512,34 @@
     }
    ],
    "source": [
-    "results5, duals5 = run_strategy(targets, limits, HyperParameters(1,1,2.5e-3,5e-4,5e-2))"
+    "results = run_strategy(targets, HyperParameters(1,1,2.5e-3,5e-4,5e-2))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "mean: 0.40703634338665723\n",
+      "volatility: 0.08997197581646472\n",
+      "max drawdown: -0.05485241674214392\n",
+      "max leverage: 1.7916345766119088\n",
+      "sharpe: 4.407194454349362\n",
+      "turnover: 60.34602290587951\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(f\"mean: {results.mean_return}\")\n",
+    "print(f\"volatility: {results.volatility}\")\n",
+    "print(f\"max drawdown: {results.max_drawdown}\")\n",
+    "print(f\"max leverage: {results.max_leverage}\")\n",
+    "print(f\"sharpe: {results.sharpe}\")\n",
+    "print(f\"turnover: {results.turnover}\")"
    ]
   },
   {
@@ -550,7 +571,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 324,
+   "execution_count": 7,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -601,20 +622,12 @@
     "\n",
     "# SR_best_train = 0\n",
     "# SR_best_test = 0\n",
-    "for i in parameter_dict_new.keys():\n",
-    "    sharpe_train, sharpe_test = sharpes(parameter_dict_new[i][-1])\n",
-    "    vola_train, vola_test = volas(parameter_dict_new[i][-1])\n",
-    "    leverage_train, leverage_test = leverages(parameter_dict_new[i][-1])\n",
-    "    turnover_train, turnover_test = turnovers(parameter_dict_new[i][-1])\n",
-    "#     if sharpe_train > SR_best_train:\n",
-    "#         SR_best_train = sharpe_train\n",
-    "#         SR_best_test = sharpe_test\n",
-    "\n",
-    "#         vola_train, vola_test = volas(parameter_dict_new[i][1])\n",
-    "#         leverage_train, leverage_test = leverages(parameter_dict_new[i][1])\n",
-    "#         turnover_train, turnover_test = turnovers(parameter_dict_new[i][1])\n",
-    "\n",
-    "        # best_iteration = i\n",
+    "for i in parameter_dict.keys():\n",
+    "    sharpe_train, sharpe_test = sharpes(parameter_dict[i][-1])\n",
+    "    vola_train, vola_test = volas(parameter_dict[i][-1])\n",
+    "    leverage_train, leverage_test = leverages(parameter_dict[i][-1])\n",
+    "    turnover_train, turnover_test = turnovers(parameter_dict[i][-1])\n",
+    "\n",
     "    sharpe_ratios_train.append(sharpe_train)\n",
     "    sharpe_ratios_test.append(sharpe_test)\n",
     "    \n",
@@ -630,91 +643,72 @@
     "    turnovers_train.append(turnover_train)\n",
     "    turnovers_test.append(turnover_test)\n",
     "    \n",
-    "    gamma_holds.append(parameter_dict_new[i][0].gamma_hold)\n",
-    "    gamma_trades.append(parameter_dict_new[i][0].gamma_trade)\n",
-    "    gamma_turns.append(parameter_dict_new[i][0].gamma_turn)\n",
-    "    gamma_leverages.append(parameter_dict_new[i][0].gamma_leverage)\n",
-    "    gamma_risks.append(parameter_dict_new[i][0].gamma_risk)"
+    "    gamma_holds.append(parameter_dict[i][0].gamma_hold)\n",
+    "    gamma_trades.append(parameter_dict[i][0].gamma_trade)\n",
+    "    gamma_turns.append(parameter_dict[i][0].gamma_turn)\n",
+    "    gamma_leverages.append(parameter_dict[i][0].gamma_leverage)\n",
+    "    gamma_risks.append(parameter_dict[i][0].gamma_risk)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 323,
+   "execution_count": 8,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]"
+       "(3.0, 7.0)"
       ]
      },
-     "execution_count": 323,
+     "execution_count": 8,
      "metadata": {},
      "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "sharpe_ratios_train"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 322,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "(4.60214392258915, 5.099387798177832)"
-      ]
-     },
-     "execution_count": 322,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "sharpes(parameter_dict_new[0][-1])"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 317,
-   "metadata": {},
-   "outputs": [
+    },
     {
      "data": {
+      "image/png": "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",
       "text/plain": [
-       "[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]"
+       "<Figure size 640x480 with 1 Axes>"
       ]
      },
-     "execution_count": 317,
      "metadata": {},
-     "output_type": "execute_result"
+     "output_type": "display_data"
     }
    ],
    "source": [
-    "sharpe_ratios_train"
+    "backtests = np.arange(1, len(sharpe_ratios_train)+1)\n",
+    "\n",
+    "plt.plot(backtests, sharpe_ratios_train, label=\"in-sample\", marker=\"o\")\n",
+    "plt.plot(backtests, sharpe_ratios_test, label=\"out-of-sample\", marker=\"o\")\n",
+    "plt.ylabel(\"Sharpe ratio\")\n",
+    "plt.xlabel(\"Number of backtests\")\n",
+    "plt.xticks(backtests)\n",
+    "# only show every 5th tick\n",
+    "plt.gca().xaxis.set_major_locator(plt.MultipleLocator(5))\n",
+    "\n",
+    "plt.legend()\n",
+    "plt.ylim(3, 7)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 330,
+   "execution_count": 349,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "(3.0, 6.0)"
+       "(3.0, 7.0)"
       ]
      },
-     "execution_count": 330,
+     "execution_count": 349,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -731,13 +725,16 @@
     "plt.ylabel(\"Sharpe ratio\")\n",
     "plt.xlabel(\"Number of backtests\")\n",
     "plt.xticks(backtests)\n",
+    "# only show every 5th tick\n",
+    "plt.gca().xaxis.set_major_locator(plt.MultipleLocator(5))\n",
+    "\n",
     "plt.legend()\n",
-    "plt.ylim(3, 6)"
+    "plt.ylim(3, 7)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 334,
+   "execution_count": 9,
    "metadata": {},
    "outputs": [
     {
@@ -746,13 +743,13 @@
        "(0.01, 0.11)"
       ]
      },
-     "execution_count": 334,
+     "execution_count": 9,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -767,12 +764,14 @@
     "plt.ylabel(\"Volatility\")\n",
     "plt.xlabel(\"Number of backtests\")\n",
     "plt.xticks(backtests)\n",
+    "plt.gca().xaxis.set_major_locator(plt.MultipleLocator(5))\n",
+    "\n",
     "plt.ylim(0.01, 0.11)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 335,
+   "execution_count": 10,
    "metadata": {},
    "outputs": [
     {
@@ -781,13 +780,13 @@
        "(1.0, 2.0)"
       ]
      },
-     "execution_count": 335,
+     "execution_count": 10,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -802,6 +801,7 @@
     "plt.ylabel(\"Leverage\")\n",
     "plt.xlabel(\"Number of backtests\")\n",
     "plt.xticks(backtests)\n",
+    "plt.gca().xaxis.set_major_locator(plt.MultipleLocator(5))\n",
     "\n",
     "# plt.legend()\n",
     "plt.ylim(1, 2)"
@@ -816,7 +816,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 336,
+   "execution_count": 11,
    "metadata": {},
    "outputs": [
     {
@@ -825,13 +825,13 @@
        "(40.0, 100.0)"
       ]
      },
-     "execution_count": 336,
+     "execution_count": 11,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -846,208 +846,522 @@
     "plt.ylabel(\"Turnover\")\n",
     "plt.xlabel(\"Number of backtests\")\n",
     "plt.xticks(backtests)\n",
+    "plt.gca().xaxis.set_major_locator(plt.MultipleLocator(5))\n",
+    "\n",
     "\n",
     "# plt.legend()\n",
     "plt.ylim(40, 100)"
    ]
   },
   {
-   "cell_type": "code",
-   "execution_count": 337,
-   "metadata": {},
-   "outputs": [
-    {
-     "ename": "NameError",
-     "evalue": "name 'backtest' is not defined",
-     "output_type": "error",
-     "traceback": [
-      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
-      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
-      "Cell \u001b[0;32mIn[337], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m backtest\n",
-      "\u001b[0;31mNameError\u001b[0m: name 'backtest' is not defined"
-     ]
-    }
-   ],
-   "source": [
-    "backtest"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 16,
+   "cell_type": "markdown",
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "mean: 0.8465365101690253\n",
-      "volatility: 0.11151843823932293\n",
-      "max drawdown: -0.03143434020184788\n",
-      "max leverage: 2.257261042305931\n",
-      "sharpe: 7.487388323586896\n",
-      "turnover: 212.13402506109483\n"
-     ]
-    }
-   ],
    "source": [
-    "results_tuned = parameter_dict_new[best_iteration][1]\n",
-    "print(f\"mean: {results_tuned.mean_return}\")\n",
-    "print(f\"volatility: {results_tuned.volatility}\")\n",
-    "print(f\"max drawdown: {results_tuned.max_drawdown}\")\n",
-    "print(f\"max leverage: {results_tuned.max_leverage}\")\n",
-    "print(f\"sharpe: {results_tuned.sharpe}\")\n",
-    "print(f\"turnover: {results_tuned.turnover}\")"
+    "# Full tuning"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 250,
+   "execution_count": 4,
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "[<matplotlib.lines.Line2D at 0x7f89dc6a4850>]"
-      ]
-     },
-     "execution_count": 250,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 640x480 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
+   "outputs": [],
    "source": [
-    "plt.plot(gamma_holds, label=\"hold\", marker=\"o\")"
+    "all_prices = []\n",
+    "all_spreads = []\n",
+    "all_volumes = []\n",
+    "all_rfs = []\n",
+    "\n",
+    "# retune every two years\n",
+    "\n",
+    "t_start = 500\n",
+    "n_periods = int(np.floor(len(prices) / 500))\n",
+    "\n",
+    "for i in range(1, n_periods): # first 500 are discarded\n",
+    "    t_start = (i-1)*500\n",
+    "    t_end = (i+1)*500\n",
+    "\n",
+    "    all_prices.append(prices.iloc[t_start:t_end])\n",
+    "    all_spreads.append(spread.iloc[t_start:t_end])\n",
+    "    all_volumes.append(volume.iloc[t_start:t_end])\n",
+    "    all_rfs.append(rf.iloc[t_start:t_end])\n",
+    "\n"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 251,
+   "execution_count": 10,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "[<matplotlib.lines.Line2D at 0x7f897d760670>]"
+       "2000-01-04    0.000149\n",
+       "2000-01-05    0.000150\n",
+       "2000-01-06    0.000154\n",
+       "2000-01-07    0.000156\n",
+       "2000-01-10    0.000159\n",
+       "                ...   \n",
+       "2001-11-27    0.000056\n",
+       "2001-11-28    0.000057\n",
+       "2001-11-29    0.000058\n",
+       "2001-11-30    0.000057\n",
+       "2001-12-03    0.000057\n",
+       "Name: DFF, Length: 500, dtype: float64"
       ]
      },
-     "execution_count": 251,
+     "execution_count": 10,
      "metadata": {},
      "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 640x480 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
     }
    ],
    "source": [
-    "plt.plot(gamma_trades, label=\"trade\", marker=\"o\")"
+    "all_rfs[0]"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 252,
+   "execution_count": 16,
    "metadata": {},
    "outputs": [
     {
-     "data": {
-      "text/plain": [
-       "[<matplotlib.lines.Line2D at 0x7f89dd280250>]"
-      ]
-     },
-     "execution_count": 252,
-     "metadata": {},
-     "output_type": "execute_result"
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "1\n",
+      "1\n",
+      "1\n",
+      "1\n",
+      "1\n",
+      "1\n",
+      "1\n",
+      "1\n",
+      "1\n",
+      "                 T0       T1      T3       T4  ...     T96      T98     T99     T100\n",
+      "2003-11-04  30.8344  11.3797  26.551  22.5999  ...  26.263  46.6832  6.1560  15.9338\n",
+      "2003-11-05  30.9587  11.3797  26.461  22.6392  ...  26.332  46.3854  6.1279  15.9826\n",
+      "2003-11-06  30.9980  11.2275  26.660  22.5153  ...  26.608  46.1356  6.0717  15.9998\n",
+      "2003-11-07  30.4287  11.1306  26.667  21.9232  ...  26.459  45.4165  6.1027  15.9568\n",
+      "2003-11-10  30.1538  11.2344  26.619  21.7782  ...  26.246  44.8715  6.0107  15.9310\n",
+      "...             ...      ...     ...      ...  ...     ...      ...     ...      ...\n",
+      "2005-09-27  37.6636  11.8618  47.172  36.6693  ...  36.641  60.8314  8.0896  17.7876\n",
+      "2005-09-28  37.6104  12.0703  47.640  35.9386  ...  36.540  60.7100  8.0599  17.6480\n",
+      "2005-09-29  38.2016  12.1150  47.689  36.2134  ...  36.255  61.0136  8.0401  17.9182\n",
+      "2005-09-30  38.1551  12.1746  48.164  36.6880  ...  36.308  60.3458  8.0976  17.7846\n",
+      "2005-10-03  38.5118  12.0666  47.590  36.8504  ...  36.528  60.7859  8.1590  17.7482\n",
+      "\n",
+      "[500 rows x 74 columns]\n",
+      "                 T0       T1       T3  ...      T98      T99     T100\n",
+      "2013-06-04  65.6180  30.1578   84.440  ...  50.7007  28.0312  30.1427\n",
+      "2013-06-05  64.4965  29.8244   83.491  ...  49.8151  27.5713  29.6806\n",
+      "2013-06-06  65.7733  30.8556   84.568  ...  50.2951  27.7544  30.3514\n",
+      "2013-06-07  67.3262  31.0223   86.882  ...  51.5862  28.0178  30.7465\n",
+      "2013-06-10  67.5332  31.2014   86.670  ...  51.7600  28.1473  30.7614\n",
+      "...             ...      ...      ...  ...      ...      ...      ...\n",
+      "2015-04-28  68.4197  34.0875  129.814  ...  68.7432  45.5540  43.3277\n",
+      "2015-04-29  68.1284  34.0336  128.617  ...  68.4282  45.6954  43.3668\n",
+      "2015-04-30  68.3844  34.0133  126.144  ...  68.8454  45.0887  43.0853\n",
+      "2015-05-01  68.5875  33.9931  127.314  ...  69.7651  45.9736  43.1556\n",
+      "2015-05-04  69.1173  34.0673  126.742  ...  70.0461  45.9965  43.5779\n",
+      "\n",
+      "[500 rows x 74 columns]\n",
+      "                 T0       T1      T3  ...      T98      T99     T100\n",
+      "2007-09-04  47.0482  18.0754  70.046  ...  49.2557  11.4764  23.7093\n",
+      "2007-09-05  45.9256  17.7704  69.987  ...  48.0458  11.2831  23.2557\n",
+      "2007-09-06  45.9875  17.9017  70.250  ...  48.7915  11.3883  23.1002\n",
+      "2007-09-07  44.7101  17.5120  69.257  ...  47.7110  11.1638  22.8086\n",
+      "2007-09-10  45.4533  17.4738  69.615  ...  47.7794  11.2556  22.7697\n",
+      "...             ...      ...     ...  ...      ...      ...      ...\n",
+      "2009-07-28  22.4984  14.8174  33.090  ...  24.0338  11.1208  17.0553\n",
+      "2009-07-29  22.5553  15.0911  33.182  ...  24.0581  11.4276  16.9579\n",
+      "2009-07-30  22.9455  15.2468  33.082  ...  24.6250  11.7892  17.2988\n",
+      "2009-07-31  23.0268  15.1336  32.830  ...  24.8598  11.9048  17.0136\n",
+      "2009-08-03  23.2869  15.1147  33.503  ...  25.4185  11.9006  17.9457\n",
+      "\n",
+      "[500 rows x 74 columns]\n",
+      "                 T0       T1      T3  ...      T98      T99     T100\n",
+      "2005-10-04  37.8895  11.9996  48.164  ...  59.7311   8.1937  17.5447\n",
+      "2005-10-05  38.0873  11.8468  47.526  ...  58.5320   8.0787  17.5569\n",
+      "2005-10-06  38.0873  11.7337  48.150  ...  57.7276   8.1392  17.6874\n",
+      "2005-10-07  37.8971  11.5376  47.703  ...  57.3254   8.2056  17.7846\n",
+      "2005-10-10  37.3114  11.4244  48.129  ...  56.7563   8.1868  17.5660\n",
+      "...             ...      ...     ...  ...      ...      ...      ...\n",
+      "2007-08-28  44.4004  17.5882  69.848  ...  48.5099  10.8885  22.8086\n",
+      "2007-08-29  45.0120  17.8890  70.761  ...  49.4916  11.2811  23.3140\n",
+      "2007-08-30  44.6869  17.7619  70.725  ...  48.8904  11.3421  23.1585\n",
+      "2007-08-31  45.3837  17.7407  70.615  ...  49.2024  11.4601  23.6769\n",
+      "2007-09-03  45.3837  17.7407  70.615  ...  49.2024  11.4601  23.6769\n",
+      "\n",
+      "[500 rows x 74 columns]\n",
+      "                 T0       T1      T3       T4  ...     T96      T98     T99     T100\n",
+      "2001-12-04  21.4320  15.3372  23.442  13.8478  ...  26.543  37.7561  5.0267  11.7064\n",
+      "2001-12-05  22.2418  15.3915  23.774  14.4450  ...  26.033  38.6595  5.1975  11.8153\n",
+      "2001-12-06  22.5952  15.5226  24.582  14.4336  ...  26.152  40.2857  5.3465  11.8807\n",
+      "2001-12-07  22.2996  15.2988  24.708  14.6164  ...  25.892  39.2016  5.2231  11.9079\n",
+      "2001-12-10  21.8498  15.4427  24.443  14.2907  ...  26.016  37.7185  5.1643  11.8862\n",
+      "...             ...      ...     ...      ...  ...     ...      ...     ...      ...\n",
+      "2003-10-28  31.1092  11.4454  24.706  21.9867  ...  26.154  48.5142  6.1802  15.6321\n",
+      "2003-10-29  30.9849  11.3520  26.393  22.1921  ...  26.976  47.9543  6.1289  15.6264\n",
+      "2003-10-30  30.4418  11.3486  26.578  22.3129  ...  26.964  45.1548  6.1134  15.7659\n",
+      "2003-10-31  30.7101  11.6254  26.386  22.1377  ...  26.643  46.0022  6.1899  16.0335\n",
+      "2003-11-03  30.9064  11.4939  26.674  22.3703  ...  26.476  46.6680  6.1909  16.1929\n",
+      "\n",
+      "[500 rows x 74 columns]\n",
+      "1\n",
+      "                 T0       T1      T3       T4  ...     T96      T98     T99     T100\n",
+      "2000-01-04  31.9473  17.3055  25.940  12.8682  ...  11.512  32.4750  4.2276   9.6386\n",
+      "2000-01-05  31.1359  18.1170  27.514  13.2535  ...  11.547  31.7252  4.4715   9.6059\n",
+      "2000-01-06  31.7966  17.9302  27.796  13.8400  ...  11.753  33.1779  4.4483  10.0300\n",
+      "2000-01-07  32.2195  17.8733  28.603  14.2924  ...  11.787  34.1151  4.4483  10.2094\n",
+      "2000-01-10  32.6821  17.7783  28.200  13.8232  ...  11.306  33.6934  4.5238   9.9158\n",
+      "...             ...      ...     ...      ...  ...     ...      ...     ...      ...\n",
+      "2001-11-27  22.2225  15.3436  23.515  13.9163  ...  26.134  40.9934  4.9593  11.7418\n",
+      "2001-11-28  21.6248  15.2956  22.634  13.7706  ...  25.756  39.1790  4.9119  11.6192\n",
+      "2001-11-29  21.4128  15.1710  23.283  13.7735  ...  26.181  38.7725  4.8777  11.7364\n",
+      "2001-11-30  21.1493  15.0239  23.250  13.5506  ...  26.294  37.6658  5.0286  11.6574\n",
+      "2001-12-03  20.6544  15.1742  23.184  13.5477  ...  26.600  36.5515  5.0191  11.5620\n",
+      "\n",
+      "[500 rows x 74 columns]\n",
+      "                 T0       T1      T3  ...      T98      T99     T100\n",
+      "2009-08-04  23.3356  15.0345  33.786  ...  25.5076  12.0939  18.4673\n",
+      "2009-08-05  24.6768  14.7560  34.010  ...  25.4671  11.9846  19.5266\n",
+      "2009-08-06  25.4489  14.6098  35.161  ...  26.0502  12.1107  19.4917\n",
+      "2009-08-07  26.5706  14.6664  36.065  ...  27.6722  12.2053  20.0423\n",
+      "2009-08-10  26.2861  14.5909  35.354  ...  27.4776  12.0099  19.9587\n",
+      "...             ...      ...     ...  ...      ...      ...      ...\n",
+      "2011-06-28  41.7812  20.4932  58.220  ...  42.0472  19.4931  19.4773\n",
+      "2011-06-29  42.8586  20.5772  58.728  ...  42.7341  19.4670  19.8882\n",
+      "2011-06-30  43.5151  20.8630  59.706  ...  42.2516  19.5104  19.8811\n",
+      "2011-07-01  44.0538  21.1824  59.980  ...  43.0530  19.9094  20.3062\n",
+      "2011-07-04  44.0538  21.1824  59.980  ...  43.0530  19.9094  20.3062\n",
+      "\n",
+      "[500 rows x 74 columns]\n",
+      "                 T0       T1      T3  ...      T98      T99     T100\n",
+      "2011-07-05  44.0453  21.1937  59.883  ...  43.3882  19.8920  20.1362\n",
+      "2011-07-06  44.4073  21.3114  60.360  ...  43.4455  20.0243  19.9236\n",
+      "2011-07-07  45.1059  21.2433  61.369  ...  44.4104  20.3083  20.3062\n",
+      "2011-07-08  44.6682  21.2774  60.626  ...  43.9197  20.2173  20.0512\n",
+      "2011-07-11  43.9948  21.0730  59.237  ...  42.5787  19.8248  19.5481\n",
+      "...             ...      ...     ...  ...      ...      ...      ...\n",
+      "2013-05-28  65.7043  31.3804  84.864  ...  51.1559  28.1602  30.2024\n",
+      "2013-05-29  65.4196  30.6086  84.000  ...  50.9821  28.0044  30.3738\n",
+      "2013-05-30  65.6870  30.3060  85.229  ...  51.6690  27.8660  30.7465\n",
+      "2013-05-31  65.3161  29.9355  83.940  ...  50.4276  27.5311  30.2247\n",
+      "2013-06-03  65.9717  30.0467  85.398  ...  51.2386  28.1428  30.3589\n",
+      "\n",
+      "[500 rows x 74 columns]\n",
+      "                 T0       T1       T3  ...      T98      T99     T100\n",
+      "2015-05-05  68.7288  33.7773  125.765  ...  70.0546  45.8094  43.5701\n",
+      "2015-05-06  68.7376  33.4739  124.915  ...  70.3696  45.7182  43.2355\n",
+      "2015-05-07  69.2497  33.5345  125.314  ...  70.1814  46.2793  43.1489\n",
+      "2015-05-08  69.7353  33.8110  128.830  ...  71.1568  46.7309  44.1251\n",
+      "2015-05-11  70.3711  33.5817  129.211  ...  71.2852  46.8906  43.7000\n",
+      "...             ...      ...      ...  ...      ...      ...      ...\n",
+      "2017-03-28  71.6218  35.9896  165.853  ...  74.8210  52.8417  46.3945\n",
+      "2017-03-29  71.2666  35.8655  166.105  ...  75.2743  52.8977  46.1541\n",
+      "2017-03-30  72.1409  35.8144  166.433  ...  77.4611  52.3004  46.6267\n",
+      "2017-03-31  72.0499  35.5881  165.385  ...  77.0344  52.0111  46.1458\n",
+      "2017-04-03  71.5763  35.9020  165.189  ...  76.2699  51.8525  46.0049\n",
+      "\n",
+      "[500 rows x 74 columns]\n",
+      "                  T0       T1       T3  ...      T98      T99     T100\n",
+      "2017-04-04   71.2757  35.9969  167.106  ...  75.7899  51.3672  45.7644\n",
+      "2017-04-05   71.1111  35.7852  165.591  ...  74.7854  51.3112  45.5821\n",
+      "2017-04-06   71.2574  35.7760  165.862  ...  74.8743  51.4605  45.9054\n",
+      "2017-04-07   71.1203  35.9459  167.246  ...  74.2610  51.4325  45.4660\n",
+      "2017-04-10   70.8642  35.8573  166.040  ...  73.5765  51.2365  45.2173\n",
+      "...              ...      ...      ...  ...      ...      ...      ...\n",
+      "2019-02-26  100.3882  45.4021  416.775  ...  74.5889  81.8051  43.6126\n",
+      "2019-02-27  100.8387  45.4662  425.242  ...  75.8428  82.1579  43.8853\n",
+      "2019-02-28  101.1391  45.6265  429.656  ...  77.0598  81.7384  43.8765\n",
+      "2019-03-01  102.2281  45.6586  430.300  ...  77.6867  83.3156  43.9996\n",
+      "2019-03-04  102.3219  45.0815  422.556  ...  76.8109  81.8627  44.0699\n",
+      "\n",
+      "[500 rows x 74 columns]\n",
+      "1\n",
+      "1\n",
+      "                  T0       T1       T3  ...       T98       T99     T100\n",
+      "2019-03-05  102.1811  44.9532  420.046  ...   76.4974   81.6715  43.8765\n",
+      "2019-03-06  102.3032  44.6326  414.519  ...   76.0733   81.3752  43.8149\n",
+      "2019-03-07  101.2518  45.1296  412.663  ...   74.9392   81.4994  43.6918\n",
+      "2019-03-08  101.3644  45.3139  412.644  ...   75.0222   81.0597  43.7973\n",
+      "2019-03-11  102.8476  46.1556  390.642  ...   76.3867   82.0347  43.7621\n",
+      "...              ...      ...      ...  ...       ...       ...      ...\n",
+      "2021-01-26  112.5419  49.3441  202.060  ...   94.5853  131.4144  29.5914\n",
+      "2021-01-27  110.5459  48.0880  194.030  ...   97.1977  127.4457  28.4504\n",
+      "2021-01-28  115.2743  48.2974  197.230  ...  101.1258  131.0448  29.0539\n",
+      "2021-01-29  112.6485  47.7565  194.190  ...   98.6838  129.9456  28.1769\n",
+      "2021-02-01  113.3945  47.3466  195.840  ...   97.3586  132.0078  28.2806\n",
+      "\n",
+      "[500 rows x 74 columns]\n",
+      "                  T0       T1      T3  ...       T98       T99     T100\n",
+      "2021-02-02  116.9505  47.5385  200.94  ...  100.3686  135.7819  28.9973\n",
+      "2021-02-03  116.6986  47.7914  207.39  ...  101.4760  134.8481  29.8932\n",
+      "2021-02-04  121.0201  48.0967  210.64  ...  106.6345  136.7935  30.8959\n",
+      "2021-02-05  122.3572  48.2537  207.93  ...  108.3571  141.1513  30.8013\n",
+      "2021-02-08  124.0141  48.0182  211.95  ...  109.7958  139.4977  31.5960\n",
+      "...              ...      ...     ...  ...       ...       ...      ...\n",
+      "2022-12-27  144.8493  37.3463  189.40  ...   89.2068  116.4506  40.1494\n",
+      "2022-12-28  142.4943  36.9276  188.38  ...   88.1747  113.8949  40.2276\n",
+      "2022-12-29  145.7695  37.3558  188.91  ...   91.0942  116.2425  40.4331\n",
+      "2022-12-30  146.1949  37.4890  190.49  ...   91.3792  115.9057  40.3939\n",
+      "2023-01-02  146.1949  37.4890  190.49  ...   91.3792  115.9057  40.3939\n",
+      "\n",
+      "[500 rows x 74 columns]\n",
+      "2\n",
+      "2\n",
+      "2\n",
+      "2\n",
+      "2\n",
+      "2\n",
+      "2\n",
+      "2\n",
+      "2\n",
+      "2\n",
+      "Initial sharpes: nan, nan\n",
+      "Initial sharpes: nan, nan\n",
+      "2\n",
+      "Initial sharpes: nan, nan\n",
+      "                 T0       T1      T3  ...      T98      T99     T100\n",
+      "2005-10-04  37.8895  11.9996  48.164  ...  59.7311   8.1937  17.5447\n",
+      "2005-10-05  38.0873  11.8468  47.526  ...  58.5320   8.0787  17.5569\n",
+      "2005-10-06  38.0873  11.7337  48.150  ...  57.7276   8.1392  17.6874\n",
+      "2005-10-07  37.8971  11.5376  47.703  ...  57.3254   8.2056  17.7846\n",
+      "2005-10-10  37.3114  11.4244  48.129  ...  56.7563   8.1868  17.5660\n",
+      "...             ...      ...     ...  ...      ...      ...      ...\n",
+      "2007-08-28  44.4004  17.5882  69.848  ...  48.5099  10.8885  22.8086\n",
+      "2007-08-29  45.0120  17.8890  70.761  ...  49.4916  11.2811  23.3140\n",
+      "2007-08-30  44.6869  17.7619  70.725  ...  48.8904  11.3421  23.1585\n",
+      "2007-08-31  45.3837  17.7407  70.615  ...  49.2024  11.4601  23.6769\n",
+      "2007-09-03  45.3837  17.7407  70.615  ...  49.2024  11.4601  23.6769\n",
+      "\n",
+      "[500 rows x 74 columns]\n",
+      "2\n",
+      "                 T0       T1       T3  ...      T98      T99     T100\n",
+      "2013-06-04  65.6180  30.1578   84.440  ...  50.7007  28.0312  30.1427\n",
+      "2013-06-05  64.4965  29.8244   83.491  ...  49.8151  27.5713  29.6806\n",
+      "2013-06-06  65.7733  30.8556   84.568  ...  50.2951  27.7544  30.3514\n",
+      "2013-06-07  67.3262  31.0223   86.882  ...  51.5862  28.0178  30.7465\n",
+      "2013-06-10  67.5332  31.2014   86.670  ...  51.7600  28.1473  30.7614\n",
+      "...             ...      ...      ...  ...      ...      ...      ...\n",
+      "2015-04-28  68.4197  34.0875  129.814  ...  68.7432  45.5540  43.3277\n",
+      "2015-04-29  68.1284  34.0336  128.617  ...  68.4282  45.6954  43.3668\n",
+      "2015-04-30  68.3844  34.0133  126.144  ...  68.8454  45.0887  43.0853\n",
+      "2015-05-01  68.5875  33.9931  127.314  ...  69.7651  45.9736  43.1556\n",
+      "2015-05-04  69.1173  34.0673  126.742  ...  70.0461  45.9965  43.5779\n",
+      "\n",
+      "[500 rows x 74 columns]\n",
+      "                 T0       T1      T3  ...      T98      T99     T100\n",
+      "2011-07-05  44.0453  21.1937  59.883  ...  43.3882  19.8920  20.1362\n",
+      "2011-07-06  44.4073  21.3114  60.360  ...  43.4455  20.0243  19.9236\n",
+      "2011-07-07  45.1059  21.2433  61.369  ...  44.4104  20.3083  20.3062\n",
+      "2011-07-08  44.6682  21.2774  60.626  ...  43.9197  20.2173  20.0512\n",
+      "2011-07-11  43.9948  21.0730  59.237  ...  42.5787  19.8248  19.5481\n",
+      "...             ...      ...     ...  ...      ...      ...      ...\n",
+      "2013-05-28  65.7043  31.3804  84.864  ...  51.1559  28.1602  30.2024\n",
+      "2013-05-29  65.4196  30.6086  84.000  ...  50.9821  28.0044  30.3738\n",
+      "2013-05-30  65.6870  30.3060  85.229  ...  51.6690  27.8660  30.7465\n",
+      "2013-05-31  65.3161  29.9355  83.940  ...  50.4276  27.5311  30.2247\n",
+      "2013-06-03  65.9717  30.0467  85.398  ...  51.2386  28.1428  30.3589\n",
+      "\n",
+      "[500 rows x 74 columns]\n",
+      "Initial sharpes: nan, nan\n",
+      "Initial sharpes: nan, nan\n",
+      "                  T0       T1       T3  ...      T98      T99     T100\n",
+      "2017-04-04   71.2757  35.9969  167.106  ...  75.7899  51.3672  45.7644\n",
+      "2017-04-05   71.1111  35.7852  165.591  ...  74.7854  51.3112  45.5821\n",
+      "2017-04-06   71.2574  35.7760  165.862  ...  74.8743  51.4605  45.9054\n",
+      "2017-04-07   71.1203  35.9459  167.246  ...  74.2610  51.4325  45.4660\n",
+      "2017-04-10   70.8642  35.8573  166.040  ...  73.5765  51.2365  45.2173\n",
+      "...              ...      ...      ...  ...      ...      ...      ...\n",
+      "2019-02-26  100.3882  45.4021  416.775  ...  74.5889  81.8051  43.6126\n",
+      "2019-02-27  100.8387  45.4662  425.242  ...  75.8428  82.1579  43.8853\n",
+      "2019-02-28  101.1391  45.6265  429.656  ...  77.0598  81.7384  43.8765\n",
+      "2019-03-01  102.2281  45.6586  430.300  ...  77.6867  83.3156  43.9996\n",
+      "2019-03-04  102.3219  45.0815  422.556  ...  76.8109  81.8627  44.0699\n",
+      "\n",
+      "[500 rows x 74 columns]\n",
+      "Initial sharpes: nan, nan\n",
+      "Initial sharpes: nan, nan\n",
+      "                  T0       T1       T3  ...       T98       T99     T100\n",
+      "2019-03-05  102.1811  44.9532  420.046  ...   76.4974   81.6715  43.8765\n",
+      "2019-03-06  102.3032  44.6326  414.519  ...   76.0733   81.3752  43.8149\n",
+      "2019-03-07  101.2518  45.1296  412.663  ...   74.9392   81.4994  43.6918\n",
+      "2019-03-08  101.3644  45.3139  412.644  ...   75.0222   81.0597  43.7973\n",
+      "2019-03-11  102.8476  46.1556  390.642  ...   76.3867   82.0347  43.7621\n",
+      "...              ...      ...      ...  ...       ...       ...      ...\n",
+      "2021-01-26  112.5419  49.3441  202.060  ...   94.5853  131.4144  29.5914\n",
+      "2021-01-27  110.5459  48.0880  194.030  ...   97.1977  127.4457  28.4504\n",
+      "2021-01-28  115.2743  48.2974  197.230  ...  101.1258  131.0448  29.0539\n",
+      "2021-01-29  112.6485  47.7565  194.190  ...   98.6838  129.9456  28.1769\n",
+      "2021-02-01  113.3945  47.3466  195.840  ...   97.3586  132.0078  28.2806\n",
+      "\n",
+      "[500 rows x 74 columns]\n",
+      "Initial sharpes: nan, nan\n",
+      "Initial sharpes: nan, nan\n",
+      "                 T0       T1       T3  ...      T98      T99     T100\n",
+      "2015-05-05  68.7288  33.7773  125.765  ...  70.0546  45.8094  43.5701\n",
+      "2015-05-06  68.7376  33.4739  124.915  ...  70.3696  45.7182  43.2355\n",
+      "2015-05-07  69.2497  33.5345  125.314  ...  70.1814  46.2793  43.1489\n",
+      "2015-05-08  69.7353  33.8110  128.830  ...  71.1568  46.7309  44.1251\n",
+      "2015-05-11  70.3711  33.5817  129.211  ...  71.2852  46.8906  43.7000\n",
+      "...             ...      ...      ...  ...      ...      ...      ...\n",
+      "2017-03-28  71.6218  35.9896  165.853  ...  74.8210  52.8417  46.3945\n",
+      "2017-03-29  71.2666  35.8655  166.105  ...  75.2743  52.8977  46.1541\n",
+      "2017-03-30  72.1409  35.8144  166.433  ...  77.4611  52.3004  46.6267\n",
+      "2017-03-31  72.0499  35.5881  165.385  ...  77.0344  52.0111  46.1458\n",
+      "2017-04-03  71.5763  35.9020  165.189  ...  76.2699  51.8525  46.0049\n",
+      "\n",
+      "[500 rows x 74 columns]\n",
+      "                 T0       T1      T3       T4  ...     T96      T98     T99     T100\n",
+      "2001-12-04  21.4320  15.3372  23.442  13.8478  ...  26.543  37.7561  5.0267  11.7064\n",
+      "2001-12-05  22.2418  15.3915  23.774  14.4450  ...  26.033  38.6595  5.1975  11.8153\n",
+      "2001-12-06  22.5952  15.5226  24.582  14.4336  ...  26.152  40.2857  5.3465  11.8807\n",
+      "2001-12-07  22.2996  15.2988  24.708  14.6164  ...  25.892  39.2016  5.2231  11.9079\n",
+      "2001-12-10  21.8498  15.4427  24.443  14.2907  ...  26.016  37.7185  5.1643  11.8862\n",
+      "...             ...      ...     ...      ...  ...     ...      ...     ...      ...\n",
+      "2003-10-28  31.1092  11.4454  24.706  21.9867  ...  26.154  48.5142  6.1802  15.6321\n",
+      "2003-10-29  30.9849  11.3520  26.393  22.1921  ...  26.976  47.9543  6.1289  15.6264\n",
+      "2003-10-30  30.4418  11.3486  26.578  22.3129  ...  26.964  45.1548  6.1134  15.7659\n",
+      "2003-10-31  30.7101  11.6254  26.386  22.1377  ...  26.643  46.0022  6.1899  16.0335\n",
+      "2003-11-03  30.9064  11.4939  26.674  22.3703  ...  26.476  46.6680  6.1909  16.1929\n",
+      "\n",
+      "[500 rows x 74 columns]\n",
+      "                 T0       T1      T3       T4  ...     T96      T98     T99     T100\n",
+      "2003-11-04  30.8344  11.3797  26.551  22.5999  ...  26.263  46.6832  6.1560  15.9338\n",
+      "2003-11-05  30.9587  11.3797  26.461  22.6392  ...  26.332  46.3854  6.1279  15.9826\n",
+      "2003-11-06  30.9980  11.2275  26.660  22.5153  ...  26.608  46.1356  6.0717  15.9998\n",
+      "2003-11-07  30.4287  11.1306  26.667  21.9232  ...  26.459  45.4165  6.1027  15.9568\n",
+      "2003-11-10  30.1538  11.2344  26.619  21.7782  ...  26.246  44.8715  6.0107  15.9310\n",
+      "...             ...      ...     ...      ...  ...     ...      ...     ...      ...\n",
+      "2005-09-27  37.6636  11.8618  47.172  36.6693  ...  36.641  60.8314  8.0896  17.7876\n",
+      "2005-09-28  37.6104  12.0703  47.640  35.9386  ...  36.540  60.7100  8.0599  17.6480\n",
+      "2005-09-29  38.2016  12.1150  47.689  36.2134  ...  36.255  61.0136  8.0401  17.9182\n",
+      "2005-09-30  38.1551  12.1746  48.164  36.6880  ...  36.308  60.3458  8.0976  17.7846\n",
+      "2005-10-03  38.5118  12.0666  47.590  36.8504  ...  36.528  60.7859  8.1590  17.7482\n",
+      "\n",
+      "[500 rows x 74 columns]\n",
+      "                 T0       T1      T3       T4  ...     T96      T98     T99     T100\n",
+      "2000-01-04  31.9473  17.3055  25.940  12.8682  ...  11.512  32.4750  4.2276   9.6386\n",
+      "2000-01-05  31.1359  18.1170  27.514  13.2535  ...  11.547  31.7252  4.4715   9.6059\n",
+      "2000-01-06  31.7966  17.9302  27.796  13.8400  ...  11.753  33.1779  4.4483  10.0300\n",
+      "2000-01-07  32.2195  17.8733  28.603  14.2924  ...  11.787  34.1151  4.4483  10.2094\n",
+      "2000-01-10  32.6821  17.7783  28.200  13.8232  ...  11.306  33.6934  4.5238   9.9158\n",
+      "...             ...      ...     ...      ...  ...     ...      ...     ...      ...\n",
+      "2001-11-27  22.2225  15.3436  23.515  13.9163  ...  26.134  40.9934  4.9593  11.7418\n",
+      "2001-11-28  21.6248  15.2956  22.634  13.7706  ...  25.756  39.1790  4.9119  11.6192\n",
+      "2001-11-29  21.4128  15.1710  23.283  13.7735  ...  26.181  38.7725  4.8777  11.7364\n",
+      "2001-11-30  21.1493  15.0239  23.250  13.5506  ...  26.294  37.6658  5.0286  11.6574\n",
+      "2001-12-03  20.6544  15.1742  23.184  13.5477  ...  26.600  36.5515  5.0191  11.5620\n",
+      "\n",
+      "[500 rows x 74 columns]\n",
+      "Initial sharpes: nan, nan\n",
+      "Initial sharpes: nan, nan\n",
+      "                 T0       T1      T3  ...      T98      T99     T100\n",
+      "2007-09-04  47.0482  18.0754  70.046  ...  49.2557  11.4764  23.7093\n",
+      "2007-09-05  45.9256  17.7704  69.987  ...  48.0458  11.2831  23.2557\n",
+      "2007-09-06  45.9875  17.9017  70.250  ...  48.7915  11.3883  23.1002\n",
+      "2007-09-07  44.7101  17.5120  69.257  ...  47.7110  11.1638  22.8086\n",
+      "2007-09-10  45.4533  17.4738  69.615  ...  47.7794  11.2556  22.7697\n",
+      "...             ...      ...     ...  ...      ...      ...      ...\n",
+      "2009-07-28  22.4984  14.8174  33.090  ...  24.0338  11.1208  17.0553\n",
+      "2009-07-29  22.5553  15.0911  33.182  ...  24.0581  11.4276  16.9579\n",
+      "2009-07-30  22.9455  15.2468  33.082  ...  24.6250  11.7892  17.2988\n",
+      "2009-07-31  23.0268  15.1336  32.830  ...  24.8598  11.9048  17.0136\n",
+      "2009-08-03  23.2869  15.1147  33.503  ...  25.4185  11.9006  17.9457\n",
+      "\n",
+      "[500 rows x 74 columns]\n",
+      "                 T0       T1      T3  ...      T98      T99     T100\n",
+      "2009-08-04  23.3356  15.0345  33.786  ...  25.5076  12.0939  18.4673\n",
+      "2009-08-05  24.6768  14.7560  34.010  ...  25.4671  11.9846  19.5266\n",
+      "2009-08-06  25.4489  14.6098  35.161  ...  26.0502  12.1107  19.4917\n",
+      "2009-08-07  26.5706  14.6664  36.065  ...  27.6722  12.2053  20.0423\n",
+      "2009-08-10  26.2861  14.5909  35.354  ...  27.4776  12.0099  19.9587\n",
+      "...             ...      ...     ...  ...      ...      ...      ...\n",
+      "2011-06-28  41.7812  20.4932  58.220  ...  42.0472  19.4931  19.4773\n",
+      "2011-06-29  42.8586  20.5772  58.728  ...  42.7341  19.4670  19.8882\n",
+      "2011-06-30  43.5151  20.8630  59.706  ...  42.2516  19.5104  19.8811\n",
+      "2011-07-01  44.0538  21.1824  59.980  ...  43.0530  19.9094  20.3062\n",
+      "2011-07-04  44.0538  21.1824  59.980  ...  43.0530  19.9094  20.3062\n",
+      "\n",
+      "[500 rows x 74 columns]\n",
+      "Initial sharpes: nan, nan\n",
+      "                  T0       T1      T3  ...       T98       T99     T100\n",
+      "2021-02-02  116.9505  47.5385  200.94  ...  100.3686  135.7819  28.9973\n",
+      "2021-02-03  116.6986  47.7914  207.39  ...  101.4760  134.8481  29.8932\n",
+      "2021-02-04  121.0201  48.0967  210.64  ...  106.6345  136.7935  30.8959\n",
+      "2021-02-05  122.3572  48.2537  207.93  ...  108.3571  141.1513  30.8013\n",
+      "2021-02-08  124.0141  48.0182  211.95  ...  109.7958  139.4977  31.5960\n",
+      "...              ...      ...     ...  ...       ...       ...      ...\n",
+      "2022-12-27  144.8493  37.3463  189.40  ...   89.2068  116.4506  40.1494\n",
+      "2022-12-28  142.4943  36.9276  188.38  ...   88.1747  113.8949  40.2276\n",
+      "2022-12-29  145.7695  37.3558  188.91  ...   91.0942  116.2425  40.4331\n",
+      "2022-12-30  146.1949  37.4890  190.49  ...   91.3792  115.9057  40.3939\n",
+      "2023-01-02  146.1949  37.4890  190.49  ...   91.3792  115.9057  40.3939\n",
+      "\n",
+      "[500 rows x 74 columns]\n"
+     ]
     },
     {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 640x480 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
+     "ename": "IndexError",
+     "evalue": "index -1 is out of bounds for axis 0 with size 0",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mRemoteTraceback\u001b[0m                           Traceback (most recent call last)",
+      "\u001b[0;31mRemoteTraceback\u001b[0m: \n\"\"\"\nTraceback (most recent call last):\n  File \"/Users/kasper/opt/anaconda3/lib/python3.9/multiprocessing/pool.py\", line 125, in worker\n    result = (True, func(*args, **kwds))\n  File \"/Users/kasper/opt/anaconda3/lib/python3.9/multiprocessing/pool.py\", line 51, in starmapstar\n    return list(itertools.starmap(args[0], args[1]))\n  File \"/Users/kasper/Documents/Stanford/Research/My papers/markowitz/reference_implementation/markowitz-reference/experiments/tuning.py\", line 324, in tune_parameters\n    if accept_new_parameter(results, sharpe_train_old):\n  File \"/Users/kasper/Documents/Stanford/Research/My papers/markowitz/reference_implementation/markowitz-reference/experiments/tuning.py\", line 252, in accept_new_parameter\n    turnover_train, turnover_test = turnovers(results)\n  File \"/Users/kasper/Documents/Stanford/Research/My papers/markowitz/reference_implementation/markowitz-reference/experiments/tuning.py\", line 224, in turnovers\n    turnover_train = relative_trades_train.abs().sum(axis=1).mean() * results.periods_per_year\n  File \"/Users/kasper/Documents/Stanford/Research/My papers/markowitz/reference_implementation/markowitz-reference/experiments/backtest.py\", line 424, in periods_per_year\n    return len(self.history) / ((self.history[-1] - self.history[0]).days / 365.25)\n  File \"/Users/kasper/Documents/Stanford/Research/My papers/markowitz/reference_implementation/markowitz-reference/.venv/lib/python3.9/site-packages/pandas/core/indexes/base.py\", line 5365, in __getitem__\n    return getitem(key)\n  File \"/Users/kasper/Documents/Stanford/Research/My papers/markowitz/reference_implementation/markowitz-reference/.venv/lib/python3.9/site-packages/pandas/core/arrays/datetimelike.py\", line 375, in __getitem__\n    result = cast(\"Union[Self, DTScalarOrNaT]\", super().__getitem__(key))\n  File \"/Users/kasper/Documents/Stanford/Research/My papers/markowitz/reference_implementation/markowitz-reference/.venv/lib/python3.9/site-packages/pandas/core/arrays/_mixins.py\", line 276, in __getitem__\n    result = self._ndarray[key]\nIndexError: index -1 is out of bounds for axis 0 with size 0\n\"\"\"",
+      "\nThe above exception was the direct cause of the following exception:\n",
+      "\u001b[0;31mIndexError\u001b[0m                                Traceback (most recent call last)",
+      "Cell \u001b[0;32mIn[16], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m results \u001b[39m=\u001b[39m tune_in_parallel(\n\u001b[1;32m      2\u001b[0m     all_prices,\n\u001b[1;32m      3\u001b[0m     all_spreads,\n\u001b[1;32m      4\u001b[0m     all_volumes,\n\u001b[1;32m      5\u001b[0m     all_rfs,\n\u001b[1;32m      6\u001b[0m )\n",
+      "File \u001b[0;32m~/Documents/Stanford/Research/My papers/markowitz/reference_implementation/markowitz-reference/experiments/tuning.py:391\u001b[0m, in \u001b[0;36mtune_in_parallel\u001b[0;34m(all_prices, all_spreads, all_volumes, all_rfs)\u001b[0m\n\u001b[1;32m    383\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39mtune_in_parallel\u001b[39m(\n\u001b[1;32m    384\u001b[0m         all_prices,\n\u001b[1;32m    385\u001b[0m         all_spreads,\n\u001b[1;32m    386\u001b[0m         all_volumes,\n\u001b[1;32m    387\u001b[0m         all_rfs,\n\u001b[1;32m    388\u001b[0m ):\n\u001b[1;32m    390\u001b[0m     pool \u001b[39m=\u001b[39m mp\u001b[39m.\u001b[39mPool(mp\u001b[39m.\u001b[39mcpu_count())\n\u001b[0;32m--> 391\u001b[0m     results \u001b[39m=\u001b[39m pool\u001b[39m.\u001b[39;49mstarmap(\n\u001b[1;32m    392\u001b[0m         tune_parameters,\n\u001b[1;32m    393\u001b[0m         \u001b[39mzip\u001b[39;49m(\n\u001b[1;32m    394\u001b[0m             [full_markowitz] \u001b[39m*\u001b[39;49m \u001b[39mlen\u001b[39;49m(all_prices),\n\u001b[1;32m    395\u001b[0m             all_prices,\n\u001b[1;32m    396\u001b[0m             all_spreads,\n\u001b[1;32m    397\u001b[0m             all_volumes,\n\u001b[1;32m    398\u001b[0m             all_rfs,\n\u001b[1;32m    399\u001b[0m         ),\n\u001b[1;32m    400\u001b[0m     )\n\u001b[1;32m    401\u001b[0m     pool\u001b[39m.\u001b[39mclose()\n\u001b[1;32m    402\u001b[0m     pool\u001b[39m.\u001b[39mjoin()\n",
+      "File \u001b[0;32m~/opt/anaconda3/lib/python3.9/multiprocessing/pool.py:372\u001b[0m, in \u001b[0;36mPool.starmap\u001b[0;34m(self, func, iterable, chunksize)\u001b[0m\n\u001b[1;32m    366\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39mstarmap\u001b[39m(\u001b[39mself\u001b[39m, func, iterable, chunksize\u001b[39m=\u001b[39m\u001b[39mNone\u001b[39;00m):\n\u001b[1;32m    367\u001b[0m \u001b[39m    \u001b[39m\u001b[39m'''\u001b[39;00m\n\u001b[1;32m    368\u001b[0m \u001b[39m    Like `map()` method but the elements of the `iterable` are expected to\u001b[39;00m\n\u001b[1;32m    369\u001b[0m \u001b[39m    be iterables as well and will be unpacked as arguments. Hence\u001b[39;00m\n\u001b[1;32m    370\u001b[0m \u001b[39m    `func` and (a, b) becomes func(a, b).\u001b[39;00m\n\u001b[1;32m    371\u001b[0m \u001b[39m    '''\u001b[39;00m\n\u001b[0;32m--> 372\u001b[0m     \u001b[39mreturn\u001b[39;00m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_map_async(func, iterable, starmapstar, chunksize)\u001b[39m.\u001b[39;49mget()\n",
+      "File \u001b[0;32m~/opt/anaconda3/lib/python3.9/multiprocessing/pool.py:771\u001b[0m, in \u001b[0;36mApplyResult.get\u001b[0;34m(self, timeout)\u001b[0m\n\u001b[1;32m    769\u001b[0m     \u001b[39mreturn\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_value\n\u001b[1;32m    770\u001b[0m \u001b[39melse\u001b[39;00m:\n\u001b[0;32m--> 771\u001b[0m     \u001b[39mraise\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_value\n",
+      "\u001b[0;31mIndexError\u001b[0m: index -1 is out of bounds for axis 0 with size 0"
+     ]
     }
    ],
    "source": [
-    "plt.plot(gamma_leverages, label=\"hold\", marker=\"o\")"
+    "results = tune_in_parallel(\n",
+    "    all_prices,\n",
+    "    all_spreads,\n",
+    "    all_volumes,\n",
+    "    all_rfs,\n",
+    ")"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 253,
+   "execution_count": 18,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "[<matplotlib.lines.Line2D at 0x7f88ea2dbd00>]"
+       "13.0"
       ]
      },
-     "execution_count": 253,
+     "execution_count": 18,
      "metadata": {},
      "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 640x480 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
     }
    ],
    "source": [
-    "plt.plot(gamma_turns, label=\"hold\", marker=\"o\")"
+    "n_periods"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 254,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "[<matplotlib.lines.Line2D at 0x7f89ffee8d30>]"
-      ]
-     },
-     "execution_count": 254,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 640x480 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
+   "outputs": [],
    "source": [
-    "plt.plot(gamma_risks, label=\"hold\", marker=\"o\")"
+    "parameter_dict, best_backtest = tune_parameters(\n",
+    "    full_markowitz,\n",
+    "    prices_train_test,\n",
+    "    spread_train_test, \n",
+    "    volume_train_test,\n",
+    "    rf_train_test,\n",
+    "    train_len=train_len,\n",
+    ")"
    ]
   },
   {
diff --git a/experiments/tuning.py b/experiments/tuning.py
index 7b6f8f9..fc7d4bd 100644
--- a/experiments/tuning.py
+++ b/experiments/tuning.py
@@ -2,6 +2,7 @@
 import pandas as pd
 from markowitz import Data, Parameters, markowitz
 from dataclasses import dataclass
+import multiprocessing as mp
 
 from backtest import run_markowitz, load_data
 
@@ -17,8 +18,8 @@ class HyperParameters:
 
 @dataclass
 class Targets:
-    T_target: float
-    L_target: float
+    T_max: float
+    L_max: float
     risk_target: float
 
 
@@ -30,14 +31,13 @@ class Limits:
 
 
 def get_data_and_parameters(
-    inputs: callable, hyperparameters: dataclass, targets: dataclass, limits: dataclass
+    inputs: callable, hyperparameters: dataclass, targets: dataclass
 ):
     """
     param inputs: OptimizationInputs object
     param hyperparameters: HyperParameters object (gamma_hold, gamma_trade,
     gamma_turn, gamma_leverage, gamma_risk)
     param targets: Targets object (T_target, L_target, risk_target)
-    param limits: Limits object (T_max, L_max, risk_max)
     """
 
     # TODO: correct??? We do not know the spread and volume of the last day,
@@ -69,9 +69,15 @@ def get_data_and_parameters(
 
     # Hyperparameters
     t = latest_prices.name
-    gamma_hold = hyperparameters.gamma_hold
-    gamma_trade = hyperparameters.gamma_trade
 
+    if type(hyperparameters.gamma_hold) == pd.Series:
+        gamma_hold = hyperparameters.gamma_hold.loc[t]
+    else:
+        gamma_hold = hyperparameters.gamma_hold
+    if type(hyperparameters.gamma_trade) == pd.Series:
+        gamma_trade = hyperparameters.gamma_trade.loc[t]
+    else:
+        gamma_trade = hyperparameters.gamma_trade
     if type(hyperparameters.gamma_turn) == pd.Series:
         gamma_turn = hyperparameters.gamma_turn.loc[t]
     else:
@@ -107,17 +113,16 @@ def get_data_and_parameters(
         c_upper=c_upper,
         z_lower=z_lower * np.ones(data.n_assets),
         z_upper=z_upper * np.ones(data.n_assets),
-        T_target=targets.T_target,
-        T_max=limits.T_max,
-        L_target=targets.L_target,
-        L_max=limits.L_max,
+        # T_target=targets.T_target,
+        T_max=targets.T_max,
+        # L_target=targets.L_target,
+        L_max=targets.L_max,
         rho_mean=np.ones(n_assets) * rho_mean,
         rho_covariance=rho_covariance,
         gamma_hold=gamma_hold,
         gamma_trade=gamma_trade,
         gamma_turn=gamma_turn,
         gamma_risk=gamma_risk,
-        risk_max=limits.risk_max,
         risk_target=targets.risk_target,
         gamma_leverage=gamma_leverage,
     )
@@ -125,7 +130,7 @@ def get_data_and_parameters(
     return data, param
 
 
-def full_markowitz(inputs, hyperparamters, targets, limits):
+def full_markowitz(inputs, hyperparamters, targets):
     """
     param inputs: OptimizationInputs object
     param hyperparameters: HyperParameters object (gamma_hold, gamma_trade,
@@ -136,12 +141,280 @@ def full_markowitz(inputs, hyperparamters, targets, limits):
     returns: w, c, problem, problem_solved
     """
 
-    data, param = get_data_and_parameters(inputs, hyperparamters, targets, limits)
+    data, param = get_data_and_parameters(inputs, hyperparamters, targets)
 
     w, c, problem, problem_solved = markowitz(data, param)
     return w, c, problem, problem_solved
 
 
+def get_limits_and_targets(
+    T_target,
+    L_target,
+    risk_target,
+    T_max,
+    L_max,
+    risk_max,
+):
+    targets = Targets(
+        T_target=T_target,
+        L_target=L_target,
+        risk_target=risk_target,
+    )
+
+    limits = Limits(
+        T_max=T_max,
+        L_max=L_max,
+        risk_max=risk_max,
+    )
+
+    return targets, limits
+
+
+def tune_parameters(
+    strategy,
+    prices,
+    spread,
+    volume,
+    rf,
+    train_len=None,
+    verbose=False,
+):
+    """
+    param strategy: strategy to tune
+    param prices: prices
+    param spread: spread
+    param volume: volume
+    param rf: risk free rate
+    param train_len: length of training period; if None, all data is used for tuning
+    """
+    train_len = train_len or len(prices)
+
+    #### Helper functions ####
+
+    def run_strategy(targets, hyperparameters):
+        results = run_markowitz(
+            strategy,
+            targets=targets,
+            hyperparameters=hyperparameters,
+            prices=prices,
+            spread=spread,
+            volume=volume,
+            rf=rf,
+            verbose=False,
+        )
+        return results
+
+    def sharpes(results):
+        """
+        returns sharpe ratio for training and test period"""
+        returns_train = results.portfolio_returns.iloc[:train_len]
+        returns_test = results.portfolio_returns.iloc[train_len:]
+        sharpe_train = np.sqrt(252) * returns_train.mean() / returns_train.std()
+        sharpe_test = np.sqrt(252) * returns_test.mean() / returns_test.std()
+
+        return sharpe_train, sharpe_test
+
+    def turnovers(results):
+        """
+        returns turnover for training and test period"""
+        trades = results.quantities.diff()
+        valuation_trades = (trades * prices).dropna()
+        relative_trades = valuation_trades.div(results.portfolio_value, axis=0)
+        relative_trades_train = relative_trades.iloc[:train_len]
+        relative_trades_test = relative_trades.iloc[train_len:]
+
+        turnover_train = (
+            relative_trades_train.abs().sum(axis=1).mean() * results.periods_per_year
+        )
+        turnover_test = (
+            relative_trades_test.abs().sum(axis=1).mean() * results.periods_per_year
+        )
+
+        return turnover_train, turnover_test
+
+    def leverages(results):
+        """
+        returns leverage for training and test period"""
+        leverage_train = results.asset_weights.abs().sum(axis=1).iloc[:train_len].max()
+        leverage_test = results.asset_weights.abs().sum(axis=1).iloc[train_len:].max()
+        return leverage_train, leverage_test
+
+    def risks(results):
+        """
+        returns risk for training and test period"""
+        returns_train = results.portfolio_returns.iloc[:train_len]
+        returns_test = results.portfolio_returns.iloc[train_len:]
+        risk_train = returns_train.std() * np.sqrt(252)
+        risk_test = returns_test.std() * np.sqrt(252)
+        return risk_train, risk_test
+
+    def accept_new_parameter(results, sharpe_old):
+        sharpe_train, _ = sharpes(results)
+
+        if sharpe_train <= sharpe_old:
+            return False
+        else:
+            # check turnover
+            turnover_train, turnover_test = turnovers(results)
+            if verbose:
+                print(f"Turnover: {turnover_train}, {turnover_test}")
+            if turnover_train > 100:
+                return False
+            # check leverage
+            leverage_train, leverage_test = leverages(results)
+            if verbose:
+                print(f"Leverage: {leverage_train}, {leverage_test}")
+            if leverage_train > 2:
+                return False
+            # check risk
+            risk_train, risk_test = risks(results)
+            if verbose:
+                print(f"Risk: {risk_train}, {risk_test}")
+            if risk_train > 0.15:
+                return False
+
+        return True
+
+    #### Main ####
+    parameters_to_results = {}
+
+    # Initial hyperparameters
+    gamma_turns = 2.5e-3
+    gamma_leverages = 5e-4
+    gamma_risks = 5e-2
+
+    hyperparameter_list = [1, 1, gamma_turns, gamma_leverages, gamma_risks]
+    hyperparameters = HyperParameters(*hyperparameter_list)
+
+    # Set soft targets and limits
+    targets = Targets(
+        T_max=50 / 252,
+        L_max=1.6,
+        risk_target=0.1 / np.sqrt(252),
+    )
+
+    # Initial soft solve
+    backtest = 1  # keep track of number of backtests
+    results = run_strategy(targets, hyperparameters)
+    results_best = results
+    parameters_to_results[backtest] = (hyperparameters, results, results_best)
+
+    sharpe_train, sharpe_test = sharpes(results)
+    if verbose:
+        print(f"Initial sharpes: {sharpe_train}, {sharpe_test}")
+    sharpe_train_old = sharpe_train
+    sharpe_test_old = sharpe_test
+
+    best_backtest = 1
+    non_inprove_in_a_row = 0  # stop when this is n_params-1
+
+    n_params = 5
+    iteration = 1  # keep track of number of iterations
+
+    while non_inprove_in_a_row < n_params - 1:
+        update_var = iteration % n_params - 1  # update one parameter at a time
+        gamma_temp = hyperparameter_list[update_var] * 1.25  # increase by 25%
+
+        hyperparameter_list_temp = hyperparameter_list.copy()
+        hyperparameter_list_temp[update_var] = gamma_temp
+
+        hyperparameters_temp = HyperParameters(*hyperparameter_list_temp)
+
+        results = run_strategy(targets, hyperparameters_temp)
+        backtest += 1
+        sharpe_train, sharpe_test = sharpes(results)
+
+        if accept_new_parameter(results, sharpe_train_old):
+            # update hyperparameters
+            hyperparameter_list = hyperparameter_list_temp.copy()
+            hyperparameters = hyperparameters_temp
+
+            # update results
+            best_backtest = backtest
+            results_best = results
+            sharpe_train_old = sharpe_train
+            sharpe_test_old = sharpe_test
+            parameters_to_results[backtest] = (hyperparameters, results, results_best)
+
+            # reset non_inprove_in_a_row
+            non_inprove_in_a_row = 0
+        else:
+            parameters_to_results[backtest] = (hyperparameters, results, results_best)
+
+            gamma_temp = hyperparameter_list[update_var] * 0.8  # decrease by 20%
+            hyperparameter_list_temp[update_var] = gamma_temp
+            hyperparameters_temp = HyperParameters(*hyperparameter_list_temp)
+
+            results = run_strategy(targets, hyperparameters_temp)
+            backtest += 1
+            sharpe_train, sharpe_test = sharpes(results)
+
+            if accept_new_parameter(results, sharpe_train_old):
+                # update hyperparameters
+                hyperparameter_list = hyperparameter_list_temp.copy()
+                hyperparameters = hyperparameters_temp
+
+                # update results
+                best_backtest = backtest
+                results_best = results
+                sharpe_train_old = sharpe_train
+                sharpe_test_old = sharpe_test
+                parameters_to_results[backtest] = (
+                    hyperparameters,
+                    results,
+                    results_best,
+                )
+
+                # reset non_inprove_in_a_row
+                non_inprove_in_a_row = 0
+            else:
+                parameters_to_results[backtest] = (
+                    hyperparameters,
+                    results,
+                    results_best,
+                )
+                non_inprove_in_a_row += 1
+                if verbose:
+                    print("In a row: " + str(non_inprove_in_a_row))
+
+        # parameters_to_results[iteration] = (hyperparameters, results)
+        if verbose:
+            print(
+                f"\nIteration number {iteration};\
+                      current sharpes:\
+                          {sharpe_train_old, sharpe_test_old}"
+            )
+            print(f"Hyperparameters: {hyperparameters}")
+        iteration += 1
+
+    print("Done!")
+
+    return parameters_to_results, best_backtest
+
+
+def tune_in_parallel(
+    all_prices,
+    all_spreads,
+    all_volumes,
+    all_rfs,
+):
+    pool = mp.Pool(mp.cpu_count())
+    results = pool.starmap(
+        tune_parameters,
+        zip(
+            [full_markowitz] * len(all_prices),
+            all_prices,
+            all_spreads,
+            all_volumes,
+            all_rfs,
+        ),
+    )
+    pool.close()
+    pool.join()
+
+    return results
+
+
 def main():
     gamma_risk = 0.05
     gamma_turn = 0.002
diff --git a/gamma_leverage_tuned.png b/gamma_leverage_tuned.png
new file mode 100644
index 0000000..bfcf85d
Binary files /dev/null and b/gamma_leverage_tuned.png differ
diff --git a/markowitz.py b/markowitz.py
index 42a00ee..53abee1 100644
--- a/markowitz.py
+++ b/markowitz.py
@@ -45,12 +45,12 @@ class Parameters:
     c_upper: float  # upper bound on cash weight
     z_lower: np.ndarray  # (n_assets,) array of lower bounds on trades
     z_upper: np.ndarray  # (n_assets,) array of upper bounds on trades
-    T_target: float  # turnover target
+    # T_target: float  # turnover target
     T_max: float  # turnover limit
-    L_target: float  # leverage target
+    # L_target: float  # leverage target
     L_max: float  # leverage limit
     risk_target: float  # risk target as volatility
-    risk_max: float  # risk limit as volatility
+    # risk_max: float  # risk limit as volatility
     rho_mean: np.ndarray  # (n_assets,) array of mean returns for rho
     rho_covariance: float  # uncertainty in covariance matrix
     gamma_hold: float  # holding cost
@@ -206,31 +206,31 @@ def markowitz(
         w <= param.w_upper,
         param.z_lower <= z,
         z <= param.z_upper,
-        L <= param.L_max,
-        T <= param.T_max,
-        risk_wc <= param.risk_max,
+        # L <= param.L_max,
+        # T <= param.T_max,
+        # risk_wc <= param.risk_max,
     ]
 
     # Naming the constraints
-    constraints[0].name = "FullInvestment"
-    constraints[1].name = "Cash"
-    constraints[2].name = "CLower"
-    constraints[3].name = "CUpper"
-    constraints[4].name = "WLower"
-    constraints[5].name = "WUpper"
-    constraints[6].name = "ZLower"
-    constraints[7].name = "ZUpper"
-    constraints[8].name = "Leverage"
-    constraints[9].name = "Turnover"
-    constraints[10].name = "Risk"
+    # constraints[0].name = "FullInvestment"
+    # constraints[1].name = "Cash"
+    # constraints[2].name = "CLower"
+    # constraints[3].name = "CUpper"
+    # constraints[4].name = "WLower"
+    # constraints[5].name = "WUpper"
+    # constraints[6].name = "ZLower"
+    # constraints[7].name = "ZUpper"
+    # constraints[8].name = "Leverage"
+    # constraints[9].name = "Turnover"
+    # constraints[10].name = "Risk"
 
     objective = (
         return_wc
         - param.gamma_risk * cp.pos(risk_wc - param.risk_target)
         - param.gamma_hold * holding_cost
         - param.gamma_trade * trading_cost
-        - param.gamma_turn * cp.pos(T - param.T_target)
-        - param.gamma_leverage * cp.pos(L - param.L_target)
+        - param.gamma_turn * cp.pos(T - param.T_max)
+        - param.gamma_leverage * cp.pos(L - param.L_max)
     )
 
     problem = cp.Problem(cp.Maximize(objective), constraints)
diff --git a/requirements.txt b/requirements.txt
index 56e3409..200ddcf 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -4,3 +4,4 @@ pandas
 matplotlib
 clarabel
 mosek
+multiprocessing