remove trend adjustment, hyperopt

TSPredict/TSPredict.py

@@ -161,10 +161,10 @@ class TSPredict(IStrategy):
 
 
 
-    use_rolling = False # True = rolling (slow but realistic), False = Jumping (much faster, less realistic)
+    use_rolling = True # True = rolling (slow but realistic), False = Jumping (much faster, less realistic)
     single_col_prediction = False # True = use only gain. False = use all columns (better, but much slower)
 
-    wavelet_type:Wavelets.WaveletType = Wavelets.WaveletType.MODWT
+    wavelet_type:Wavelets.WaveletType = Wavelets.WaveletType.DWTA
     wavelet = None
 
     forecaster_type:Forecasters.ForecasterType = Forecasters.ForecasterType.PA
@@ -176,10 +176,10 @@ class TSPredict(IStrategy):
     win_size = wavelet_size # this can vary
 
     train_min_len = wavelet_size # longer = slower
-    train_len = wavelet_size * 4 # longer = slower
+    train_len = min(128, wavelet_size * 4) # longer = slower
     # scale_len = wavelet_size // 2 # no. recent candles to use when scaling
     scale_len = min(8, wavelet_size//2) # no. recent candles to use when scaling
-    win_size = wavelet_size
+    win_size = min(32, wavelet_size)
     model_window = wavelet_size # longer = slower
 
     profit_nstd = 2.6
@@ -196,6 +196,7 @@ class TSPredict(IStrategy):
 
     norm_data = False # changing this requires new models
     detrend_data = False
+    scale_data = False
     # retrain_period = 12 # number of candles before retrining
     retrain_period = 2  # for testing only!
 
@@ -211,27 +212,26 @@ class TSPredict(IStrategy):
 
     # hyperparams
 
-
     # Buy hyperspace params:
     buy_params = {
-        "cexit_min_profit_th": 0.1,
-        "cexit_profit_nstd": 0.6,
-        "entry_bb_factor": 1.07,
-        "entry_bb_width": 0.021,
+        "cexit_min_profit_th": 0.5,
+        "cexit_profit_nstd": 0.1,
+        "entry_bb_factor": 1.13,
+        "entry_bb_width": 0.023,
         "entry_guard_metric": -0.2,
         "enable_entry_guards": True,  # value loaded from strategy
         "entry_enable_squeeze": True,  # value loaded from strategy
     }
 
     # Sell hyperspace params:
     sell_params = {
-        "cexit_loss_nstd": 1.5,
-        "cexit_metric_overbought": 0.67,
-        "cexit_metric_take_profit": 0.56,
-        "cexit_min_loss_th": -0.1,
-        "exit_bb_factor": 0.71,
-        "exit_enable_squeeze": False,
-        "exit_guard_metric": 0.1,
+        "cexit_loss_nstd": 0.4,
+        "cexit_metric_overbought": 0.91,
+        "cexit_metric_take_profit": 0.88,
+        "cexit_min_loss_th": -0.4,
+        "exit_bb_factor": 0.8,
+        "exit_enable_squeeze": True,
+        "exit_guard_metric": 0.4,
         "enable_exit_guards": True,  # value loaded from strategy
         "enable_exit_signal": True,  # value loaded from strategy
     }
@@ -372,6 +372,8 @@ def update_pairlist_data(self):
     def populate_indicators(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
         # NOTE: if you change the indicators, you need to regenerate the model
 
+        window_size = min(32, self.win_size)
+
         # Base pair dataframe timeframe indicators
         curr_pair = metadata["pair"]
 
@@ -403,7 +405,7 @@ def populate_indicators(self, dataframe: DataFrame, metadata: dict) -> DataFrame
         dataframe = self.update_gain_targets(dataframe)
 
         # Bollinger Bands
-        bollinger = qtpylib.bollinger_bands(dataframe['close'], window=self.win_size, stds=2)
+        bollinger = qtpylib.bollinger_bands(dataframe['close'], window=window_size, stds=2)
         dataframe['bb_lowerband'] = bollinger['lower']
         dataframe['bb_middleband'] = bollinger['mid']
         dataframe['bb_upperband'] = bollinger['upper']
@@ -413,11 +415,11 @@ def populate_indicators(self, dataframe: DataFrame, metadata: dict) -> DataFrame
 
 
         # RSI
-        dataframe["rsi"] = ta.RSI(dataframe, timeperiod=self.win_size)
+        dataframe["rsi"] = ta.RSI(dataframe, timeperiod=window_size)
 
         '''
         # Williams %R
-        dataframe["wr"] = 0.02 * (self.williams_r(dataframe, period=self.win_size) + 50.0)
+        dataframe["wr"] = 0.02 * (self.williams_r(dataframe, period=window_size) + 50.0)
 
         # Fisher RSI
         rsi = 0.1 * (dataframe["rsi"] - 50)
@@ -432,7 +434,7 @@ def populate_indicators(self, dataframe: DataFrame, metadata: dict) -> DataFrame
         dataframe["predicted_gain"] = 0.0
 
         # RMI: https://www.tradingview.com/script/kwIt9OgQ-Relative-Momentum-Index/
-        dataframe['rmi'] = cta.RMI(dataframe, length=self.win_size, mom=5)
+        dataframe['rmi'] = cta.RMI(dataframe, length=window_size, mom=5)
 
         # scaled version for use as guard metric
         dataframe['srmi'] = 2.0 * (dataframe['rmi'] - 50.0) / 100.0
@@ -699,10 +701,14 @@ def predict_data(self, forecaster:Forecasters.base_forecaster, data):
         # print(f'    data:{np.shape(data)} preds:{np.shape(preds)}')
 
         # de-norm
-        scaler = RobustScaler()
-        scaler.fit(self.gain_data.reshape(-1, 1))
-        denorm_preds = scaler.inverse_transform(preds.reshape(-1, 1)).squeeze()
-        # denorm_preds = scaler.inverse_transform(preds.reshape(-1, 1))
+        if self.scale_data:
+            scaler = RobustScaler()
+            scaler.fit(self.gain_data.reshape(-1, 1))
+            denorm_preds = scaler.inverse_transform(preds.reshape(-1, 1)).squeeze()
+            # denorm_preds = scaler.inverse_transform(preds.reshape(-1, 1))
+        else:
+            denorm_preds = preds
+
 
         denorm_preds = np.clip(denorm_preds, -3.0, 3.0)
         return denorm_preds
@@ -935,8 +941,10 @@ def add_latest_prediction(self, dataframe: DataFrame) -> DataFrame:
             dlen = len(dataframe["gain"])
             clen = min(plen, dlen)
 
-            self.training_data = data[-clen:].copy()
-            self.training_labels = future_gain_data[-clen:].copy()
+            # self.training_data = data[-clen:].copy()
+            # self.training_labels = future_gain_data[-clen:].copy()
+            self.training_data = data
+            self.training_labels = future_gain_data
 
             pred_array = np.zeros(clen, dtype=float)
 

TSPredict/TS_Wavelet.py

@@ -76,30 +76,6 @@
 
 class TS_Wavelet(TSPredict):
 
-   # Buy hyperspace params:
-    buy_params = {
-        "cexit_min_profit_th": 0.2,
-        "cexit_profit_nstd": 2.0,
-        "entry_bb_factor": 1.06,
-        "entry_bb_width": 0.02,
-        "entry_guard_metric": -0.1,
-        "enable_entry_guards": True,  # value loaded from strategy
-        "entry_enable_squeeze": True,  # value loaded from strategy
-    }
-
-    # Sell hyperspace params:
-    sell_params = {
-        "cexit_loss_nstd": 2.7,
-        "cexit_metric_overbought": 0.88,
-        "cexit_metric_take_profit": 0.84,
-        "cexit_min_loss_th": -0.2,
-        "exit_bb_factor": 0.79,
-        "exit_enable_squeeze": True,
-        "exit_guard_metric": 0.5,
-        "enable_exit_guards": True,  # value loaded from strategy
-        "enable_exit_signal": True,  # value loaded from strategy
-    }
-
     # ROI table:  # value loaded from strategy
     minimal_roi = {
         "0": 0.04,
@@ -126,24 +102,25 @@ class TS_Wavelet(TSPredict):
 
     norm_data = False # must be false for these strategies
     detrend_data = False
-    scale_results = True
+    scale_results = False
     single_col_prediction = False
     merge_indicators = False
     training_required = True
     expanding_window = False
     use_rolling = False
 
+    # NOTE: can only use longer lengths with FFT, too slow otherwise
     wavelet_size = 32  # Windowing should match this. Longer = better but slower with edge effects. Should be even
     model_window = wavelet_size # longer = slower
     # train_min_len = wavelet_size // 2 # longer = slower
     train_min_len = wavelet_size # longer = slower
-    train_max_len = wavelet_size * 4 # longer = slower
+    train_max_len = min(128, wavelet_size * 4) # longer = slower
     # train_max_len = wavelet_size * 2 # longer = slower
     # scale_len = wavelet_size // 4 # no. recent candles to use when scaling
     scale_len = min(16, wavelet_size//2) # no. recent candles to use when scaling
-    win_size = wavelet_size
+    win_size = min(32, wavelet_size)
 
-    wavelet_type:Wavelets.WaveletType = Wavelets.WaveletType.MODWT
+    wavelet_type:Wavelets.WaveletType = Wavelets.WaveletType.DWTA
     wavelet = None
 
     forecaster_type:Forecasters.ForecasterType = Forecasters.ForecasterType.PA
@@ -634,7 +611,7 @@ def add_jumping_predictions(self, dataframe: DataFrame) -> DataFrame:
     def add_latest_prediction(self, dataframe: DataFrame) -> DataFrame:
 
         df = dataframe
-        win_size = self.win_size
+        win_size = self.model_window
         nrows = np.shape(df)[0]
 
         try:

TSPredict/TS_Wavelet_roll.json

@@ -0,0 +1,44 @@
+{
+  "strategy_name": "TS_Wavelet_roll",
+  "params": {
+    "roi": {
+      "0": 0.04,
+      "100": 0.02
+    },
+    "stoploss": {
+      "stoploss": -0.1
+    },
+    "trailing": {
+      "trailing_stop": false,
+      "trailing_stop_positive": null,
+      "trailing_stop_positive_offset": 0.0,
+      "trailing_only_offset_is_reached": false
+    },
+    "max_open_trades": {
+      "max_open_trades": 5
+    },
+    "buy": {
+      "enable_entry_guards": true,
+      "entry_enable_squeeze": true,
+      "cexit_min_profit_th": 0.5,
+      "cexit_profit_nstd": 0.1,
+      "entry_bb_factor": 1.13,
+      "entry_bb_width": 0.023,
+      "entry_guard_metric": -0.2
+    },
+    "sell": {
+      "enable_exit_guards": true,
+      "enable_exit_signal": true,
+      "cexit_loss_nstd": 0.4,
+      "cexit_metric_overbought": 0.91,
+      "cexit_metric_take_profit": 0.88,
+      "cexit_min_loss_th": -0.4,
+      "exit_bb_factor": 0.8,
+      "exit_enable_squeeze": true,
+      "exit_guard_metric": 0.4
+    },
+    "protection": {}
+  },
+  "ft_stratparam_v": 1,
+  "export_time": "2024-01-15 21:01:53.780513+00:00"
+}

utils/Forecasters.py

@@ -928,15 +928,10 @@ def get_name(self):
     def create_model(self):
         if self.model is None:
             # self.model = PassiveAggressiveRegressor(warm_start=self.reuse_model)
-            # self.model = PassiveAggressiveRegressor(C=1.0, epsilon=0.1, loss='epsilon_insensitive', shuffle=False)
 
-            # self.model = PassiveAggressiveRegressor(C=1.0, epsilon=0.05, loss='epsilon_insensitive', shuffle=False)
+            self.model = PassiveAggressiveRegressor(C=1.5, epsilon=0.02, loss='epsilon_insensitive', shuffle=False)
 
-            # self.model = PassiveAggressiveRegressor(C=0.2, epsilon=0.05, loss='epsilon_insensitive', shuffle=False)
-            # self.model = PassiveAggressiveRegressor(C=0.2, epsilon=0.005, loss='epsilon_insensitive', shuffle=False)
-            # self.model = PassiveAggressiveRegressor(C=0.1, epsilon=0.005, loss='epsilon_insensitive', shuffle=False)
-            # self.model = PassiveAggressiveRegressor(C=0.05, epsilon=0.005, loss='epsilon_insensitive', shuffle=False)
-            self.model = PassiveAggressiveRegressor(C=0.05, epsilon=0.01, loss='epsilon_insensitive', shuffle=False)
+            # self.model = PassiveAggressiveRegressor(C=1.0, epsilon=0.01, loss='epsilon_insensitive', shuffle=False)
         return
 
     def train(self, train_data: np.array, results: np.array, incremental=True):

utils/Wavelets.py

@@ -30,7 +30,7 @@ class base_wavelet(ABC):
     coeff_shapes = None
     coeff_format = "wavedec"
     data_shape = None
-    detrend = True
+    detrend = False
     lookahead = 0
 
 
@@ -239,8 +239,10 @@ def get_coeffs(self, data: np.array) -> np.array:
 
 
         # set detailed coeffs to zero (they still need to be there though)
-        threshold = 0.0
-        coeffs[1:] = [pywt.threshold(c, value=threshold, mode='hard') for c in coeffs[1:]]
+        threshold = 0.001
+        # coeffs[1:] = [pywt.threshold(c, value=threshold, mode='hard') for c in coeffs[1:]]
+        # coeffs[1:] = [pywt.threshold(c, value=threshold, mode='soft') for c in coeffs[1:]]
+        coeffs[1:] = [pywt.threshold(c, value=threshold, mode='garotte') for c in coeffs[1:]]
 
         return coeffs
 

utils/test_wvpredict.py

@@ -67,7 +67,7 @@ class WaveletPredictor:
     curr_dataframe = None
 
     norm_data = False
-    scale_results = True
+    scale_results = False
     single_col_prediction = True
     merge_indicators = False
     training_required = True
@@ -519,13 +519,13 @@ def rolling_coeff_table(self):
 lookahead = 6
 
 wlist = [
-    Wavelets.WaveletType.MODWT,
+    # Wavelets.WaveletType.MODWT,
     # Wavelets.WaveletType.SWT,
     # Wavelets.WaveletType.WPT,
     # Wavelets.WaveletType.FFT,
     # Wavelets.WaveletType.HFFT,
     # Wavelets.WaveletType.DWT,
-    # Wavelets.WaveletType.DWTA,
+    Wavelets.WaveletType.DWTA,
     ]
 flist = [
     # Forecasters.ForecasterType.NULL, # use this to show effect of wavelet alone
@@ -552,7 +552,7 @@ def rolling_coeff_table(self):
 ]
 
 # llist = [ 16, 32, 36, 64 ]
-llist = [ 64 ]
+llist = [ 32 ]
 marker_list = [ '.', 'o', 'v', '^', '<', '>', 'p', '*', 'h', 'H', 'D', 'd', 'P', 'X' ]
 num_markers = len(marker_list)
 mkr_idx = 0