From e35ee0ed234e5c03bc34603d0bddebefd2513886 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?J=C3=A9r=C3=B4me=20Delacotte?= Date: Tue, 18 Nov 2025 20:24:30 +0100 Subject: [PATCH] TensorFlow --- Zeus_TensorFlow.py | 1453 ++------------------------------ Zeus_TensorFlow_1h.py | 1830 +++++++++++++++++++++++++++++++++++++++++ 2 files changed, 1900 insertions(+), 1383 deletions(-) create mode 100644 Zeus_TensorFlow_1h.py diff --git a/Zeus_TensorFlow.py b/Zeus_TensorFlow.py index 2ac2641..8a555a1 100644 --- a/Zeus_TensorFlow.py +++ b/Zeus_TensorFlow.py @@ -114,11 +114,11 @@ class Zeus_TensorFlow(IStrategy): # Machine Learning model = None model_indicators = [] - indicator_target = 'mid_smooth_5' + indicator_target = 'mid_smooth_12_deriv1' # Tensorflow - lookback = 60 - future_steps = 12 - y_no_scale = False + lookback = 20 + future_steps = 1 + y_no_scale = True path = f"user_data/plots/" @@ -506,37 +506,11 @@ class Zeus_TensorFlow(IStrategy): def informative_pairs(self): # get access to all pairs available in whitelist. pairs = self.dp.current_whitelist() - # informative_pairs = [(pair, '1d') for pair in pairs] + informative_pairs = [(pair, '1d') for pair in pairs] informative_pairs += [(pair, '1h') for pair in pairs] return informative_pairs - from typing import List - - def multi_step_interpolate(self, pct: float, thresholds: List[float], factors: List[float]) -> float: - if pct <= thresholds[0]: - return factors[0] - if pct >= thresholds[-1]: - return factors[-1] - - for i in range(1, len(thresholds)): - if pct <= thresholds[i]: - # interpolation linéaire entre thresholds[i-1] et thresholds[i] - return factors[i - 1] + (pct - thresholds[i - 1]) * (factors[i] - factors[i - 1]) / ( - thresholds[i] - thresholds[i - 1]) - - # Juste au cas où (devrait jamais arriver) - return factors[-1] - - # def interpolate_factor(self, pct: float, start_pct: float = 5, end_pct: float = 30, - # start_factor: float = 1.0, end_factor: float = 2.0) -> float: - # if pct <= start_pct: - # return start_factor - # if pct >= end_pct: - # return end_factor - # # interpolation linéaire - # return start_factor + (pct - start_pct) * (end_factor - start_factor) / (end_pct - start_pct) - def log_trade(self, action, pair, date, trade_type=None, rate=None, dispo=None, profit=None, buys=None, stake=None, last_candle=None): # Afficher les colonnes une seule fois @@ -646,52 +620,6 @@ class Zeus_TensorFlow(IStrategy): if not self.dp.runmode.value in ('hyperopt'): print(str) - def add_tendency_column(self, dataframe: pd.DataFrame, name: str, suffixe: str = '', eps: float = 1e-3, - d1_lim_inf: float = -0.01, d1_lim_sup: float = 0.01) -> pd.DataFrame: - """ - Ajoute une colonne 'tendency' basée sur les dérivées 1 et 2 lissées et normalisées. - eps permet de définir un seuil proche de zéro. - suffixe permet de gérer plusieurs indicateurs. - """ - - def tag_by_derivatives(row): - d1 = row[f"{name}{suffixe}_deriv1"] - d2 = row[f"{name}{suffixe}_deriv2"] - - # On considère les petites valeurs comme zéro - if abs(d1) < eps: - return 0 # Palier / neutre - if d1 > d1_lim_sup: - return 2 if d2 > eps else 1 # Acceleration Hausse / Ralentissement Hausse - if d1 < d1_lim_inf: - return -2 if d2 < -eps else -1 # Acceleration Baisse / Ralentissement Baisse - if abs(d1) < eps: - return 'DH' if d2 > eps else 'DB' # Depart Hausse / Depart Baisse - return 'Mid' - - print(f"{name}_tdc{suffixe}") - dataframe[f"{name}_tdc{suffixe}"] = dataframe.apply(tag_by_derivatives, axis=1) - return dataframe - - # def add_tendency_column(self, dataframe: pd.DataFrame, name, suffixe='') -> pd.DataFrame: - # def tag_by_derivatives(row): - # d1 = row[f"{name}{suffixe}_deriv1"] - # d2 = row[f"{name}{suffixe}_deriv2"] - # d1_lim_inf = -0.01 - # d1_lim_sup = 0.01 - # if d1 >= d1_lim_inf and d1 <= d1_lim_sup: # and d2 >= d2_lim_inf and d2 <= d2_lim_sup: - # return 0 # Palier - # if d1 == 0.0: - # return 'DH' if d2 > 0 else 'DB' # Depart Hausse / Départ Baisse - # if d1 > d1_lim_sup: - # return 2 if d2 > 0 else 1 # Acceleration Hausse / Ralentissement Hausse - # if d1 < d1_lim_inf: - # return -2 if d2 < 0 else -1 # Accéleration Baisse / Ralentissement Baisse - # return 'Mid' - # - # dataframe[f"tendency{suffixe}"] = dataframe.apply(tag_by_derivatives, axis=1) - # return dataframe - def populate_indicators(self, dataframe: DataFrame, metadata: dict) -> DataFrame: # Add all ta features pair = metadata['pair'] @@ -700,6 +628,12 @@ class Zeus_TensorFlow(IStrategy): dataframe = self.populateDataframe(dataframe, timeframe='5m') + # ################### INFORMATIVE 1d + informative = self.dp.get_pair_dataframe(pair=metadata['pair'], timeframe="1d") + informative = self.populateDataframe(informative, timeframe='1d') + # informative = self.calculateRegression(informative, 'mid', lookback=15) + dataframe = merge_informative_pair(dataframe, informative, self.timeframe, "1d", ffill=True) + ################### INFORMATIVE 1h informative = self.dp.get_pair_dataframe(pair=metadata['pair'], timeframe="1h") informative = self.populateDataframe(informative, timeframe='1h') @@ -708,9 +642,9 @@ class Zeus_TensorFlow(IStrategy): # # TENSOR FLOW # self.model_indicators = self.listUsableColumns(informative) # if self.dp.runmode.value in ('backtest'): - # self.trainTensorFlow(informative, future_steps = self.future_steps) + # self.tensorFlowTrain(informative, lookback=self.lookback, future_steps = self.future_steps) # - # self.predictTensorFlow(informative) + # self.tensorFlowPredict(informative) # # if self.dp.runmode.value in ('backtest'): # self.kerasGenerateGraphs(informative) @@ -736,12 +670,6 @@ class Zeus_TensorFlow(IStrategy): dataframe = merge_informative_pair(dataframe, informative, self.timeframe, "1h", ffill=True) - # ################### INFORMATIVE 1d - # informative = self.dp.get_pair_dataframe(pair=metadata['pair'], timeframe="1d") - # informative = self.populateDataframe(informative, timeframe='1d') - # # informative = self.calculateRegression(informative, 'mid', lookback=15) - # dataframe = merge_informative_pair(dataframe, informative, self.timeframe, "1d", ffill=True) - dataframe['last_price'] = dataframe['close'] dataframe['first_price'] = dataframe['close'] if self.dp: @@ -789,218 +717,30 @@ class Zeus_TensorFlow(IStrategy): dataframe = self.calculateRegression(dataframe, 'mid', lookback=10, future_steps=10, model_type="poly") dataframe = self.calculateRegression(dataframe, 'sma24', lookback=12, future_steps=12) - # dataframe["ms-10"] = dataframe[self.indicator_target].shift(10) - # dataframe["ms-5"] = dataframe[self.indicator_target].shift(5) - # dataframe["ms-4"] = dataframe[self.indicator_target].shift(4) - # dataframe["ms-3"] = dataframe[self.indicator_target].shift(3) - # dataframe["ms-2"] = dataframe[self.indicator_target].shift(2) - # dataframe["ms-1"] = dataframe[self.indicator_target].shift(1) - # dataframe["ms-0"] = dataframe[self.indicator_target] - # dataframe["ms+10"] = dataframe["mid_smooth_24"].shift(-11) + # self.model_indicators = self.listUsableColumns(dataframe) - self.model_indicators = self.listUsableColumns(dataframe) - - # # Quantile - # self.add_future_quantiles( - # dataframe, - # indic="mid", - # lookback=40, - # future_steps=5 - # ) - - # TENSOR FLOW - if self.dp.runmode.value in ('backtest'): - self.trainTensorFlow(dataframe, future_steps = self.future_steps) - - self.predictTensorFlow(dataframe) - - if self.dp.runmode.value in ('backtest'): - self.kerasGenerateGraphs(dataframe) - - # SKLEARN + # # TENSOR FLOW # if self.dp.runmode.value in ('backtest'): - # self.trainModel(dataframe, metadata) - - # short_pair = self.getShortName(pair) - # self.model = joblib.load(f"{short_pair}_rf_model.pkl") + # self.tensorFlowTrain(dataframe, future_steps = self.future_steps) # - # # Préparer les features pour la prédiction - # features = dataframe[self.model_indicators].fillna(0) + # self.tensorFlowPredict(dataframe) # - # # Prédiction : probabilité que le prix monte - # # probs = self.model.predict_proba(features)[:, 1] - # probs = self.model.predict(features) - # - # # Sauvegarder la probabilité pour l’analyse - # dataframe['ml_prob'] = probs - # - # self.inspect_model(self.model) + # if self.dp.runmode.value in ('backtest'): + # self.kerasGenerateGraphs(dataframe) return dataframe - def trainModel(self, dataframe: DataFrame, metadata: dict): - pair = self.getShortName(metadata['pair']) - pd.set_option('display.max_rows', None) - pd.set_option('display.max_columns', None) - pd.set_option("display.width", 200) - - os.makedirs(self.path, exist_ok=True) - - df = dataframe[self.model_indicators].copy() - - # Corrélations des colonnes - corr = df.corr(numeric_only=True) - print("Corrélation des colonnes") - print(corr) - - # 3️⃣ Créer la cible : 1 si le prix monte dans les prochaines bougies - # df['target'] = (df['sma24'].shift(-24) > df['sma24']).astype(int) - df['target'] = dataframe[self.indicator_target].shift(-24) # > df['sma24'] * 1.003).astype(int) - df['target'] = df['target'].fillna(0) #.astype(int) - - # Corrélations triées par importance avec une colonne cible - target_corr = df.corr(numeric_only=True)["target"].sort_values(ascending=False) - print("Corrélations triées par importance avec une colonne cible") - print(target_corr) - - # Corrélations triées par importance avec une colonne cible - corr = df.corr(numeric_only=True) - corr_unstacked = ( - corr.unstack() - .reset_index() - .rename(columns={"level_0": "col1", "level_1": "col2", 0: "corr"}) - ) - # Supprimer les doublons col1/col2 inversés et soi-même - corr_unstacked = corr_unstacked[corr_unstacked["col1"] < corr_unstacked["col2"]] - - # Trier par valeur absolue de corrélation - corr_sorted = corr_unstacked.reindex(corr_unstacked["corr"].abs().sort_values(ascending=False).index) - print("Trier par valeur absolue de corrélation") - print(corr_sorted.head(20)) - - # --- Calcul de la corrélation --- - corr = df.corr(numeric_only=True) # évite les colonnes non numériques - corr = corr * 100 # passage en pourcentage - - # --- Masque pour n’afficher que le triangle supérieur (optionnel) --- - mask = np.triu(np.ones_like(corr, dtype=bool)) - - # --- Création de la figure --- - fig, ax = plt.subplots(figsize=(96, 36)) - - # --- Heatmap avec un effet “température” --- - sns.heatmap( - corr, - mask=mask, - cmap="coolwarm", # palette bleu → rouge - center=0, # 0 au centre - annot=True, # affiche les valeurs dans chaque case - fmt=".0f", # format entier (pas de décimale) - cbar_kws={"label": "Corrélation (%)"}, # légende à droite - linewidths=0.5, # petites lignes entre les cases - ax=ax - ) - - # --- Personnalisation --- - ax.set_title("Matrice de corrélation (en %)", fontsize=20, pad=20) - plt.xticks(rotation=45, ha="right") - plt.yticks(rotation=0) - - # --- Sauvegarde --- - output_path = f"{self.path}/Matrice_de_correlation_temperature.png" - plt.savefig(output_path, bbox_inches="tight", dpi=150) - plt.close(fig) - - print(f"✅ Matrice enregistrée : {output_path}") - - # Nettoyage - df = df.dropna() - - X = df[self.model_indicators] - y = df['target'] # ta colonne cible binaire ou numérique - print(self.feature_auc_scores(X, y)) - - # 4️⃣ Split train/test - X = df[self.model_indicators] - y = df['target'] - # Séparation temporelle (train = 80 %, valid = 20 %) - X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, shuffle=False) - - print("NaN per column:") - print(X_train.isna().sum().sort_values(ascending=False).head(20)) - - # Nettoyage des valeurs invalides - - selector = VarianceThreshold(threshold=0.0001) - selector.fit(X_train) - selected = X_train.columns[selector.get_support()] - print("Colonnes conservées :", list(selected)) - - # 1️⃣ Entraîne ton modèle LGBM normal - - # train_model = LGBMRegressor( - # objective='regression', - # metric='rmse', # tu peux aussi tester 'mae' - # n_estimators=300, - # learning_rate=0.05, - # max_depth=7, - # subsample=0.8, - # colsample_bytree=0.8, - # random_state=42 - # ) - # train_model.fit(X_train, y_train) - - train_model, selected_features = self.optuna(self.path, X_train, X_test, y_train, y_test) - print("Features retenues :", list(selected_features)) - - # # 2️⃣ Sélection des features AVANT calibration - # sfm = SelectFromModel(train_model, threshold="median", prefit=True) - # selected_features = X_train.columns[sfm.get_support()] - # print(selected_features) - - train_model.fit(X_train, y_train) - - # Importances - importances = pd.DataFrame({ - "feature": train_model.feature_name_, - "importance": train_model.feature_importances_ - }).sort_values("importance", ascending=False) - print("\n===== 🔍 IMPORTANCE DES FEATURES =====") - - print(importances) - - # 6️⃣ Évaluer la précision (facultatif) - preds = train_model.predict(X_test) - - mse = mean_squared_error(y_test, preds) - rmse = np.sqrt(mse) - r2 = r2_score(y_test, preds) - - print(f"RMSE: {rmse:.5f} | R²: {r2:.3f}") - - # acc = accuracy_score(y_test, preds) - # print(f"Accuracy: {acc:.3f}") - - # 7️⃣ Sauvegarde du modèle - joblib.dump(train_model, f"{pair}_rf_model.pkl") - print(f"✅ Modèle sauvegardé sous {pair}_rf_model.pkl") - - # # Quantile - # dataframe = self.add_future_quantiles( - # df, - # indic="mid", - # lookback=40, - # future_steps=5 - # ) - - self.analyze_model(pair, train_model, X_train, X_test, y_train, y_test) - def listUsableColumns(self, dataframe): # Étape 1 : sélectionner numériques numeric_cols = dataframe.select_dtypes(include=['int64', 'float64']).columns # Étape 2 : enlever constantes + # usable_cols = [c for c in numeric_cols if dataframe[c].nunique() > 1 + # and (c.endswith("_deriv1") or not c.endswith("deriv1_1h")) + # and not c.endswith("_count") + # ] usable_cols = [c for c in numeric_cols if dataframe[c].nunique() > 1 - and not c.endswith("_state") and not c.endswith("_1d") + and not c.endswith("_state") + # and not c.endswith("_1d") # and not c.endswith("_1h") and not c.endswith("_count") # and not c.startswith("open") and not c.startswith("close") @@ -1011,328 +751,34 @@ class Zeus_TensorFlow(IStrategy): and not c.endswith("_class") and not c.endswith("_price") and not c.startswith('stop_buying')] # Étape 3 : remplacer inf et NaN par 0 + # usable_cols = [ + # 'hapercent', 'percent', 'percent3', 'percent12', + # 'percent24', + # 'sma5_dist', 'sma5_deriv1', 'sma12_dist', 'sma12_deriv1', + # 'sma24_dist', 'sma24_deriv1', 'sma48_dist', 'sma48_deriv1', 'sma60_dist', 'sma60_deriv1', 'sma60_deriv2', + # 'mid_smooth_3_deriv1', 'mid_smooth_5_dist', + # 'mid_smooth_5_deriv1', 'mid_smooth_12_dist', + # 'mid_smooth_12_deriv1', 'mid_smooth_24_dist', + # 'mid_smooth_24_deriv1', + # 'rsi', 'max_rsi_12', 'max_rsi_24', + # 'rsi_dist', 'rsi_deriv1', + # 'min_max_60', 'bb_percent', 'bb_width', + # 'macd', 'macdsignal', 'macdhist', 'slope', + # 'slope_smooth', 'atr', 'atr_norm', 'adx', 'obv', 'vol_24', + # 'rsi_slope', 'adx_change', 'volatility_ratio', 'rsi_diff', + # 'slope_ratio', 'volume_sma_deriv', 'volume_dist', 'volume_deriv1', + # 'slope_norm', + # # 'mid_smooth_1h_deriv1', + # # 'mid_smooth_5h_deriv1', 'mid_smooth_5h_deriv2', 'mid_future_pred_cons', + # # 'sma24_future_pred_cons' + # ] + dataframe[usable_cols] = dataframe[usable_cols].replace([np.inf, -np.inf], 0).fillna(0) print("Colonnes utilisables pour le modèle :") print(usable_cols) self.model_indicators = usable_cols - # self.model_indicators = [ - # 'volume', 'hapercent', 'mid', 'percent', 'percent3', 'percent12', - # 'percent24', - # 'sma5', 'sma5_dist', 'sma5_deriv1', 'sma5_deriv2', 'sma12', 'sma12_dist', - # 'sma12_deriv1', 'sma12_deriv2', 'sma24', 'sma24_dist', 'sma24_deriv1', 'sma24_deriv2', - # # 'sma48', 'sma48_dist', 'sma48_deriv1', 'sma48_deriv2', 'sma60', 'sma60_dist', - # # 'sma60_deriv1', 'sma60_deriv2', 'mid_smooth_3', 'mid_smooth_3_dist', - # # 'mid_smooth_3_deriv1', 'mid_smooth_3_deriv2', 'mid_smooth_5', 'mid_smooth_5_dist', - # # 'mid_smooth_5_deriv1', 'mid_smooth_5_deriv2', 'mid_smooth_12', 'mid_smooth_12_dist', - # # 'mid_smooth_12_deriv1', 'mid_smooth_12_deriv2', 'mid_smooth_24', 'mid_smooth_24_dist', - # # 'mid_smooth_24_deriv1', 'mid_smooth_24_deriv2', 'rsi', 'max_rsi_12', 'max_rsi_24', - # 'rsi_dist', 'rsi_deriv1', 'rsi_deriv2', 'max12', 'min12', 'max60', 'min60', - # 'min_max_60', 'bb_percent', 'bb_width', 'macd', 'macdsignal', 'macdhist', 'slope', - # 'slope_smooth', 'atr', 'atr_norm', 'adx', 'obv', 'vol_24', - # # 'down_count', 'up_count', - # # 'down_pct', 'up_pct', 'rsi_slope', 'adx_change', 'volatility_ratio', 'rsi_diff', - # # 'slope_ratio', 'volume_sma_deriv', 'volume_dist', 'volume_deriv1', 'volume_deriv2', - # # 'slope_norm', 'mid_smooth_1h_deriv1', 'mid_smooth_1h_deriv2', 'mid_smooth_5h', - # # 'mid_smooth_5h_deriv1', 'mid_smooth_5h_deriv2', 'mid_future_pred_cons', - # # 'sma24_future_pred_cons' - # ] return self.model_indicators - def inspect_model(self, model): - """ - Affiche les informations d'un modèle ML déjà entraîné. - Compatible avec scikit-learn, xgboost, lightgbm, catboost... - """ - - print("===== 🔍 INFORMATIONS DU MODÈLE =====") - - # Type de modèle - print(f"Type : {type(model).__name__}") - print(f"Module : {model.__class__.__module__}") - - # Hyperparamètres - if hasattr(model, "get_params"): - params = model.get_params() - print(f"\n===== ⚙️ HYPERPARAMÈTRES ({len(params)}) =====") - for k, v in params.items(): - print(f"{k}: {v}") - - # Nombre d’estimateurs - if hasattr(model, "n_estimators"): - print(f"\nNombre d’estimateurs : {model.n_estimators}") - - # Importance des features - if hasattr(model, "feature_importances_"): - print("\n===== 📊 IMPORTANCE DES FEATURES =====") - - # Correction ici : - feature_names = getattr(model, "feature_names_in_", None) - if isinstance(feature_names, np.ndarray): - feature_names = feature_names.tolist() - elif feature_names is None: - feature_names = [f"feature_{i}" for i in range(len(model.feature_importances_))] - - fi = pd.DataFrame({ - "feature": feature_names, - "importance": model.feature_importances_ - }).sort_values(by="importance", ascending=False) - - print(fi) - - # Coefficients (modèles linéaires) - if hasattr(model, "coef_"): - print("\n===== ➗ COEFFICIENTS =====") - coef = np.array(model.coef_) - if coef.ndim == 1: - for i, c in enumerate(coef): - print(f"Feature {i}: {c:.6f}") - else: - print(coef) - - # Intercept - if hasattr(model, "intercept_"): - print("\nIntercept :", model.intercept_) - - # Classes connues - if hasattr(model, "classes_"): - print("\n===== 🎯 CLASSES =====") - print(model.classes_) - - # Scores internes - for attr in ["best_score_", "best_iteration_", "best_ntree_limit", "score_"]: - if hasattr(model, attr): - print(f"\n{attr} = {getattr(model, attr)}") - - # Méthodes disponibles - print("\n===== 🧩 MÉTHODES DISPONIBLES =====") - methods = [m for m, _ in inspect.getmembers(model, predicate=inspect.ismethod)] - print(", ".join(methods[:15]) + ("..." if len(methods) > 15 else "")) - - print("\n===== ✅ FIN DE L’INSPECTION =====") - - def analyze_model(self, pair, model, X_train, X_test, y_train, y_test): - """ - Analyse complète d'un modèle ML supervisé (classification binaire). - Affiche performances, importance des features, matrices, seuils, etc. - """ - output_dir = f"user_data/plots/{pair}/" - os.makedirs(output_dir, exist_ok=True) - - # ---- Importance des features ---- - if hasattr(model, "feature_importances_"): - print("\n===== 🔍 IMPORTANCE DES FEATURES =====") - importance = pd.DataFrame({ - "feature": X_train.columns, - "importance": model.feature_importances_ - }).sort_values(by="importance", ascending=False) - print(importance) - top_n = 20 - importance = importance.head(top_n) - - # Crée une figure plus grande - fig, ax = plt.subplots(figsize=(24, 8)) # largeur=24 pouces, hauteur=8 pouces - - # Trace le bar plot sur cet axe - importance.plot.bar(x="feature", y="importance", legend=False, ax=ax) - - # Tourner les labels pour plus de lisibilité - ax.set_xticklabels(ax.get_xticklabels(), rotation=45, ha='right') - - plt.title("Importance des features") - # plt.show() - plt.savefig(os.path.join(output_dir, "Importance des features.png"), bbox_inches="tight") - plt.close() - - # ---- Arbre de décision (extrait) ---- - if hasattr(model, "estimators_"): - print("\n===== 🌳 EXTRAIT D’UN ARBRE =====") - print(export_text(model.estimators_[0], feature_names=list(X_train.columns))[:800]) - - # --- Après l'entraînement du modèle --- - preds = model.predict(X_test) - - # --- Évaluation --- - mse = mean_squared_error(y_test, preds) - rmse = np.sqrt(mse) - r2 = r2_score(y_test, preds) - - print(f"RMSE: {rmse:.5f} | R²: {r2:.3f}") - - # --- Création du dossier de sortie --- - os.makedirs(output_dir, exist_ok=True) - - # --- Graphique prédiction vs réel --- - plt.figure(figsize=(8, 8)) - plt.scatter(y_test, preds, alpha=0.4, s=15) - plt.xlabel("Valeurs réelles", fontsize=12) - plt.ylabel("Valeurs prédites", fontsize=12) - plt.title(f"LightGBM Régression — Prédiction vs Réel\nRMSE={rmse:.5f} | R²={r2:.3f}", fontsize=14) - plt.plot( - [y_test.min(), y_test.max()], - [y_test.min(), y_test.max()], - 'r--', - linewidth=1, - label="Ligne idéale" - ) - plt.legend() - - # --- Sauvegarde --- - plot_path = os.path.join(output_dir, "LightGBM_regression_pred_vs_real.png") - plt.savefig(plot_path, bbox_inches="tight", dpi=200) - plt.close() - - self.plot_pred_vs_real_filtered(model, X_test, y_test, preds, output_dir) - - - print(f"✅ Graphique sauvegardé : {plot_path}") - - # ax = lgb.plot_tree(model, tree_index=0, figsize=(30, 20), show_info=["split_gain", "internal_value", "internal_count"]) - # plt.title("Arbre de décision n°0") - # plt.savefig(os.path.join(output_dir, "lgbm_tree_0.png"), bbox_inches="tight") - # plt.close() - - for i in range(5): - ax = lgb.plot_tree(model, tree_index=i, figsize=(20, 12)) - plt.title(f"Arbre {i}") - plt.savefig(os.path.join(output_dir, f"lgbm_tree_{i}.png"), bbox_inches="tight") - plt.close() - - ax = lgb.plot_tree(model, figsize=(40, 20)) - plt.title("Vue globale du modèle LGBM") - plt.savefig(os.path.join(output_dir, "lgbm_all_trees.png"), bbox_inches="tight") - plt.close() - # X_test = np.linspace(0, 10, 1000).reshape(-1, 1) - y_pred = model.predict(X_test) - - self.graphFonctionApprise(output_dir, X_test, y_test, y_pred) - self.graphFonctionAppriseFeature(output_dir, X_test, y_test, y_pred) - - # ============================================================================== - - ax = lgb.plot_importance(model, max_num_features=30, figsize=(12, 6)) - plt.title("Importance des features - LGBM") - plt.savefig(os.path.join(output_dir, "lgbm_feature_importance.png"), bbox_inches="tight") - plt.close() - - corr = X_train.corr() * 100 # en pourcentage - - plt.figure(figsize=(20, 16)) - sns.heatmap(corr, cmap="coolwarm", center=0, annot=False, fmt=".1f", cbar_kws={'label': 'Corrélation (%)'}) - plt.title("Matrice de corrélation (%)") - plt.savefig(os.path.join(output_dir, "correlation_matrix.png"), bbox_inches="tight") - plt.close() - - plt.figure(figsize=(10, 6)) - plt.scatter(y_test, model.predict(X_test), alpha=0.5) - plt.xlabel("Valeurs réelles") - plt.ylabel("Prédictions du modèle") - plt.title("Comparaison y_test vs y_pred") - plt.savefig(os.path.join(output_dir, "ytest_vs_ypred.png"), bbox_inches="tight") - plt.close() - - print("\n===== ✅ FIN DE L’ANALYSE =====") - - def plot_pred_vs_real_filtered(self, model, X_test, y_test, preds, output_dir, top_n=5): - """ - Affiche le graphique prédiction vs réel pour les N features les plus importantes. - """ - # --- 1️⃣ Extraire les features les plus importantes --- - importance_df = pd.DataFrame({ - "feature": X_test.columns, - "importance": model.feature_importances_ - }).sort_values(by="importance", ascending=False) - - top_features = importance_df.head(top_n)["feature"].tolist() - print(f"Top {top_n} features: {top_features}") - - # --- 2️⃣ Créer un masque pour ne garder que les lignes où au moins une des top features varie fortement --- - X_top = X_test[top_features] - - # Optionnel : filtrer les points atypiques pour lisser le nuage - mask = np.all(np.abs((X_top - X_top.mean()) / X_top.std()) < 3, axis=1) - X_filtered = X_top[mask] - y_filtered = y_test[mask] - preds_filtered = preds[mask] - - # --- 3️⃣ Tracer --- - plt.figure(figsize=(8, 8)) - plt.scatter(y_filtered, preds_filtered, alpha=0.4, s=15, c='blue', label=f"Top {top_n} features") - plt.xlabel("Valeurs réelles", fontsize=12) - plt.ylabel("Valeurs prédites", fontsize=12) - plt.title(f"LightGBM Régression — Prédiction vs Réel (filtré sur top {top_n} features)", fontsize=14) - plt.plot( - [y_filtered.min(), y_filtered.max()], - [y_filtered.min(), y_filtered.max()], - 'r--', - linewidth=1, - label="Ligne idéale" - ) - plt.legend() - plt.grid(True) - - out_path = f"{output_dir}/lgbm_pred_vs_real_top{top_n}.png" - plt.savefig(out_path, bbox_inches="tight") - plt.close() - - def plot_threshold_analysis(self, y_true, y_proba, step=0.05, save_path=None): - """ - Affiche la précision, le rappel et le F1-score selon le seuil de décision. - y_true : labels réels (0 ou 1) - y_proba : probabilités prédites (P(hausse)) - step : pas entre les seuils testés - save_path : si renseigné, enregistre l'image au lieu d'afficher - """ - - # Le graphique généré affichera trois courbes : - # - # 🔵 Precision — la fiabilité de tes signaux haussiers. - # 🟢 Recall — la proportion de hausses que ton modèle détecte. - # 🟣 F1-score — le compromis optimal entre les deux. - - thresholds = np.arange(0, 1.01, step) - precisions, recalls, f1s = [], [], [] - - for thr in thresholds: - preds = (y_proba >= thr).astype(int) - precisions.append(precision_score(y_true, preds)) - recalls.append(recall_score(y_true, preds)) - f1s.append(f1_score(y_true, preds)) - - plt.figure(figsize=(10, 6)) - plt.plot(thresholds, precisions, label="Precision", linewidth=2) - plt.plot(thresholds, recalls, label="Recall", linewidth=2) - plt.plot(thresholds, f1s, label="F1-score", linewidth=2, linestyle="--") - plt.axvline(0.5, color='gray', linestyle=':', label="Seuil 0.5") - plt.title("📊 Performance selon le seuil de probabilité", fontsize=14) - plt.xlabel("Seuil de décision (threshold)") - plt.ylabel("Score") - plt.legend() - plt.grid(True, alpha=0.3) - - if save_path: - plt.savefig(save_path, bbox_inches='tight') - print(f"✅ Graphique enregistré : {save_path}") - else: - plt.show() - - # # ============================= - # # Exemple d’utilisation : - # # ============================= - # if __name__ == "__main__": - # # Exemple : chargement d’un modèle et test - # import joblib - # - # model = joblib.load("/media/Home/home/souti/freqtrade/user_data/strategies/tools/sklearn/model.pkl") - # data = np.load("/media/Home/home/souti/freqtrade/user_data/strategies/tools/sklearn/test_data.npz") - # X_test, y_test = data["X"], data["y"] - # - # y_proba = model.predict_proba(X_test)[:, 1] - # - # # Trace ou enregistre le graphique - # plot_threshold_analysis(y_test, y_proba, step=0.05, - # save_path="/media/Home/home/souti/freqtrade/user_data/strategies/tools/sklearn/threshold_analysis.png") - - def populateDataframe(self, dataframe, timeframe='5m'): dataframe = dataframe.copy() heikinashi = qtpylib.heikinashi(dataframe) @@ -1341,10 +787,10 @@ class Zeus_TensorFlow(IStrategy): dataframe['hapercent'] = (dataframe['haclose'] - dataframe['haopen']) / dataframe['haclose'] dataframe['mid'] = dataframe['haopen'] + (dataframe['haclose'] - dataframe['haopen']) / 2 - dataframe["percent"] = dataframe['close'].pct_change() - dataframe["percent3"] = dataframe['close'].pct_change(3).rolling(3).mean() - dataframe["percent12"] = dataframe['close'].pct_change(12).rolling(12).mean() - dataframe["percent24"] = dataframe['close'].pct_change(24).rolling(24).mean() + dataframe["percent"] = dataframe['mid'].pct_change() + dataframe["percent3"] = dataframe['mid'].pct_change(3).rolling(3).mean() + dataframe["percent12"] = dataframe['mid'].pct_change(12).rolling(12).mean() + dataframe["percent24"] = dataframe['mid'].pct_change(24).rolling(24).mean() # if self.dp.runmode.value in ('backtest'): # dataframe['futur_percent'] = 100 * (dataframe['close'].shift(-1) - dataframe['close']) / dataframe['close'] @@ -1365,15 +811,15 @@ class Zeus_TensorFlow(IStrategy): dataframe = self.calculateDerivation(dataframe, window=12, suffixe="_12",timeframe=timeframe) dataframe = self.calculateDerivation(dataframe, window=24, suffixe="_24", timeframe=timeframe) # print(metadata['pair']) - dataframe['rsi'] = talib.RSI(dataframe['close'], timeperiod=14) + dataframe['rsi'] = talib.RSI(dataframe['mid'], timeperiod=14) dataframe['max_rsi_12'] = talib.MAX(dataframe['rsi'], timeperiod=12) dataframe['max_rsi_24'] = talib.MAX(dataframe['rsi'], timeperiod=24) self.calculeDerivees(dataframe, 'rsi', timeframe=timeframe, ema_period=12) - dataframe['max12'] = talib.MAX(dataframe['close'], timeperiod=12) - dataframe['min12'] = talib.MIN(dataframe['close'], timeperiod=12) - dataframe['max60'] = talib.MAX(dataframe['close'], timeperiod=60) - dataframe['min60'] = talib.MIN(dataframe['close'], timeperiod=60) - dataframe['min_max_60'] = ((dataframe['max60'] - dataframe['close']) / dataframe['min60']) + dataframe['max12'] = talib.MAX(dataframe['mid'], timeperiod=12) + dataframe['min12'] = talib.MIN(dataframe['mid'], timeperiod=12) + dataframe['max60'] = talib.MAX(dataframe['mid'], timeperiod=60) + dataframe['min60'] = talib.MIN(dataframe['mid'], timeperiod=60) + dataframe['min_max_60'] = ((dataframe['max60'] - dataframe['mid']) / dataframe['min60']) # dataframe['min36'] = talib.MIN(dataframe['close'], timeperiod=36) # dataframe['max36'] = talib.MAX(dataframe['close'], timeperiod=36) # dataframe['pct36'] = 100 * (dataframe['max36'] - dataframe['min36']) / dataframe['min36'] @@ -1384,7 +830,7 @@ class Zeus_TensorFlow(IStrategy): dataframe['bb_middleband'] = bollinger['mid'] dataframe['bb_upperband'] = bollinger['upper'] dataframe["bb_percent"] = ( - (dataframe["close"] - dataframe["bb_lowerband"]) / + (dataframe["mid"] - dataframe["bb_lowerband"]) / (dataframe["bb_upperband"] - dataframe["bb_lowerband"]) ) dataframe["bb_width"] = (dataframe["bb_upperband"] - dataframe["bb_lowerband"]) / dataframe["sma5"] @@ -1395,7 +841,7 @@ class Zeus_TensorFlow(IStrategy): # Calcul MACD macd, macdsignal, macdhist = talib.MACD( - dataframe['close'], + dataframe['mid'], fastperiod=12, slowperiod=26, signalperiod=9 @@ -1447,9 +893,7 @@ class Zeus_TensorFlow(IStrategy): ).adx() # --- Volume directionnel (On Balance Volume) --- - dataframe['obv'] = ta.volume.OnBalanceVolumeIndicator( - close=dataframe['close'], volume=dataframe['volume'] - ).on_balance_volume() + dataframe['obv'] = ta.volume.OnBalanceVolumeIndicator(close=dataframe['mid'], volume=dataframe['volume']).on_balance_volume() # --- Volatilité récente (écart-type des rendements) --- dataframe['vol_24'] = dataframe['percent'].rolling(24).std() @@ -1593,167 +1037,10 @@ class Zeus_TensorFlow(IStrategy): self.trades = Trade.get_open_trades() return self.trades - def calculateProbabilite2Index(self, df, futur_cols, indic_1, indic_2): - # # Définition des tranches pour les dérivées - # bins_deriv = [-np.inf, -0.05, -0.01, 0.01, 0.05, np.inf] - # labels = ['forte baisse', 'légère baisse', 'neutre', 'légère hausse', 'forte hausse'] - # - # # Ajout des colonnes bin (catégorisation) - # df[f"{indic_1}_bin"] = pd.cut(df['mid_smooth_1h_deriv1'], bins=bins_deriv, labels=labels) - # df[f"{indic_2}_bin"] = pd.cut(df['mid_smooth_deriv1_1d'], bins=bins_deriv, labels=labels) - # - # # Colonnes de prix futur à analyser - # futur_cols = ['futur_percent_1h', 'futur_percent_2h', 'futur_percent_3h', 'futur_percent_4h', 'futur_percent_5h'] - # - # # Calcul des moyennes et des effectifs - # grouped = df.groupby([f"{indic_2}_bin", f"{indic_1}_bin"])[futur_cols].agg(['mean', 'count']) - # - # pd.set_option('display.width', 200) # largeur max affichage - # pd.set_option('display.max_columns', None) - pd.set_option('display.max_columns', None) - pd.set_option('display.width', 300) # largeur max affichage - - # nettoyage - # series = df[f"{indic_2}"].dropna() - # unique_vals = df[f"{indic_2}"].nunique() - # print(unique_vals) - # print(df[f"{indic_2}"]) - n = len(self.labels) - - df[f"{indic_1}_bin"], bins_1h = pd.qcut(df[f"{indic_1}"], q=n, labels=self.labels, retbins=True, - duplicates='drop') - df[f"{indic_2}_bin"], bins_1d = pd.qcut(df[f"{indic_2}"], q=n, labels=self.labels, retbins=True, - duplicates='drop') - # Affichage formaté pour code Python - print(f"Bornes des quantiles pour {indic_1} : [{', '.join([f'{b:.4f}' for b in bins_1h])}]") - print(f"Bornes des quantiles pour {indic_2} : [{', '.join([f'{b:.4f}' for b in bins_1d])}]") - # Agrégation - grouped = df.groupby([f"{indic_2}_bin", f"{indic_1}_bin"], observed=True)[futur_cols].agg(['mean', 'count']) - # Affichage - with pd.option_context('display.max_rows', None, 'display.max_columns', None): - print(grouped.round(4)) - # Ajout des probabilités de hausse - for col in futur_cols: - df[f"{col}_is_up"] = df[col] > 0 - - # Calcul de la proba de hausse - proba_up = df.groupby([f"{indic_2}_bin", f"{indic_1}_bin"], observed=True)[f"{col}_is_up"].mean().unstack() - - print(f"\nProbabilité de hausse pour {col} (en %):") - with pd.option_context('display.max_rows', None, 'display.max_columns', None): - print((proba_up * 100).round(1)) - - # Affichage formaté des valeurs comme tableau Python - with pd.option_context('display.max_rows', None, 'display.max_columns', None): - df_formatted = (proba_up * 100).round(1) - - print("data = {") - for index, row in df_formatted.iterrows(): - row_values = ", ".join([f"{val:.1f}" for val in row]) - print(f"'{index}': [{row_values}], ") - print("}") - - data = {} - for index, row in df_formatted.iterrows(): - # on convertit proprement avec arrondi comme dans ton print, mais en données réelles - data[index] = [ - None if (isinstance(val, float) and math.isnan(val)) else val - for val in row - ] - - # Niveaux unicode pour les barres verticales (style sparkline) - # spark_chars = "▁▂▃▄▅▆▇█" - - # print(data.values()) - # # Collecte globale min/max - # all_values = [] - # for vals in data.values(): - # all_values.extend(v for v in vals if not (isinstance(v, float) and math.isnan(v))) - # - # global_min = min(all_values) if all_values else 0 - # global_max = max(all_values) if all_values else 1 - # global_span = (global_max - global_min) if global_max != global_min else 1 - # - # def sparkline_global(values): - # if all(isinstance(v, float) and math.isnan(v) for v in values): - # return "(no data)" - # out = "" - # for v in values: - # if isinstance(v, float) and math.isnan(v): - # out += " " - # else: - # idx = int((v - global_min) / global_span * (len(spark_chars) - 1)) - # out += spark_chars[idx] - # return out - # - # for key, values in data.items(): - # print(f"{key:>3} : {sparkline_global(values)}") - - # Palette ANSI 256 couleurs pour heatmap - def get_ansi_color(val): - """ - Échelle fixe 0→100 : - 0-20 : bleu (21) - 20-40 : cyan (51) - 40-60 : vert/jaune (46 / 226) - 60-80 : orange (208) - 80-100 : rouge (196) - """ - if val is None: - return "" - if val < 0: - val = 0 - elif val > 100: - val = 100 - - if val <= 20: - code = 21 - elif val <= 40: - code = 51 - elif val <= 60: - code = 226 - elif val <= 80: - code = 208 - else: - code = 196 - return f"\033[38;5;{code}m" - - RESET = "\033[0m" - - # Affichage - columns = ['B3', 'B2', 'B1', 'N0', 'H1', 'H2', 'H3'] - header = " " + " ".join([f"{col:>6}" for col in columns]) - print(header) - print("-" * len(header)) - - for key, values in data.items(): - line = f"{key:>3} |" - for v in values: - if v is None: - line += f" {' '} " # vide pour NaN / None - else: - color = get_ansi_color(v) - line += f" {color}{v:5.1f}{RESET} " - print(line) - def populate_buy_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame: dataframe.loc[ ( - ( - ( - (dataframe['mid_future_pred_cons'].shift(2) > dataframe['mid_future_pred_cons'].shift(1)) - & (dataframe['mid_future_pred_cons'].shift(1) < dataframe['mid_future_pred_cons']) - & (dataframe['percent12'] < -0.0005) - ) - | ( - (dataframe['mid_future_pred_cons'] < dataframe['min12']) - ) - ) - & - ( - ((dataframe['mid_smooth_12_deriv1'] > 0) | (dataframe['mid_smooth_5_deriv1'] > 0)) - ) - + (dataframe['lstm_pred'] > 0) ), ['enter_long', 'enter_tag']] = (1, f"future") dataframe['test'] = np.where(dataframe['enter_long'] == 1, dataframe['close'] * 1.01, np.nan) @@ -1767,14 +1054,7 @@ class Zeus_TensorFlow(IStrategy): # dataframe.loc[ # ( - # ( - # ( - # (dataframe['ml_prob'].shift(2) < dataframe['ml_prob'].shift(1)) - # & (dataframe['ml_prob'].shift(1) > dataframe['ml_prob']) - # ) - # | (dataframe['ml_prob'] < 0) - # ) - # & (dataframe['hapercent'] < 0) + # (dataframe['lstm_pred'] < 0) & (dataframe['hapercent'] < 0) # ), ['exit_long', 'exit_tag']] = (1, f"sma60_future") # dataframe.loc[ @@ -2222,175 +1502,6 @@ class Zeus_TensorFlow(IStrategy): else: return True - def select_uncorrelated_features(self, df, target, top_n=20, corr_threshold=0.7): - """ - Sélectionne les features les plus corrélées avec target, - tout en supprimant celles trop corrélées entre elles. - """ - # 1️⃣ Calcul des corrélations absolues avec la cible - corr = df.corr(numeric_only=True) - corr_target = corr[target].abs().sort_values(ascending=False) - - # 2️⃣ Prend les N features les plus corrélées avec la cible (hors target) - features = corr_target.drop(target).head(top_n).index.tolist() - - # 3️⃣ Évite les features trop corrélées entre elles - selected = [] - for feat in features: - too_correlated = False - for sel in selected: - if abs(corr.loc[feat, sel]) > corr_threshold: - too_correlated = True - break - if not too_correlated: - selected.append(feat) - - # 4️⃣ Retourne un DataFrame propre avec les valeurs de corrélation - selected_corr = pd.DataFrame({ - "feature": selected, - "corr_with_target": [corr.loc[f, target] for f in selected] - }).sort_values(by="corr_with_target", key=np.abs, ascending=False) - - return selected_corr - - def graphFonctionApprise(self, path, X_test, y_test, y_pred): - # Exemple : trier les valeurs de X_test et les prédictions - x_sorted = np.argsort(X_test.iloc[:, 0]) - x = X_test.iloc[:, 0].iloc[x_sorted] - y_true = y_test.iloc[x_sorted] - y_pred = y_pred[x_sorted] - - plt.figure(figsize=(12, 6)) - plt.plot(x, y_true, label="Réel", color="blue", alpha=0.7) - plt.plot(x, y_pred, label="Prédit (LGBM)", color="red", alpha=0.7) - - plt.title("Fonction apprise par LGBMRegressor") - plt.xlabel("Feature principale") - plt.ylabel("Valeur prédite") - plt.legend() - plt.grid(True) - - out_path = f"{self.path}/lgbm_function.png" - plt.savefig(out_path, bbox_inches="tight") - plt.close() - - print(f"Graphique sauvegardé : {out_path}") - - def graphFonctionAppriseFeature(self, path, X_test, y_test, y_pred): - plt.figure(figsize=(14, 8)) - colors = sns.color_palette("coolwarm", n_colors=X_test.shape[1]) - - # Conversion en DataFrame pour manip plus simple - df = X_test.copy() - df["y_pred"] = y_pred - - # --- filtrage sur y_pred (ou sur chaque feature si tu veux) - mean = df["y_pred"].mean() - std = df["y_pred"].std() - - df = df[(df["y_pred"] >= mean - 2 * std) & (df["y_pred"] <= mean + 2 * std)] - - # --- tracé - for i, col in enumerate(X_test.columns): - plt.plot(df[col], df["y_pred"], '.', color=colors[i], alpha=0.4, label=col) - - plt.title("Fonction apprise par LGBMRegressor (filtrée à ±2σ)") - plt.xlabel("Valeur feature") - plt.ylabel("Valeur prédite") - plt.legend(loc="right") - plt.grid(True) - - out_path = f"{self.path}/lgbm_features.png" - plt.savefig(out_path, bbox_inches="tight") - plt.close() - - print(f"Graphique sauvegardé : {out_path}") - - def optuna(self, path, X_train, X_test, y_train, y_test): - # Suppose que X_train, y_train sont déjà définis - # ou sinon : - # X_train, X_valid, y_train, y_valid = train_test_split(X, y, test_size=0.2, random_state=42) - - print("Description") - print(X_train.describe().T.sort_values("std")) - def objective(trial): - params = { - 'objective': 'regression', - 'metric': 'rmse', - 'n_estimators': trial.suggest_int('n_estimators', 100, 1000), - 'learning_rate': trial.suggest_float('learning_rate', 0.005, 0.2, log=True), - 'max_depth': trial.suggest_int('max_depth', 3, 15), - 'num_leaves': trial.suggest_int('num_leaves', 20, 300), - 'subsample': trial.suggest_float('subsample', 0.5, 1.0), - 'colsample_bytree': trial.suggest_float('colsample_bytree', 0.5, 1.0), - 'reg_alpha': trial.suggest_float('reg_alpha', 0.0, 10.0), - 'reg_lambda': trial.suggest_float('reg_lambda', 0.0, 10.0), - 'random_state': 42, - } - - model = LGBMRegressor(**params) - model.fit(X_train, y_train) - - # On peut aussi valider sur un split interne - preds = model.predict(X_test) - rmse = np.sqrt(mean_squared_error(y_test, preds)) - return rmse - - # Crée une étude Optuna - study = optuna.create_study(direction="minimize") # on veut minimiser l'erreur - study.optimize(objective, n_trials=50, show_progress_bar=True) - - # 🔹 Afficher les meilleurs résultats - print("✅ Meilleurs hyperparamètres trouvés :") - print(study.best_params) - print(f"Meilleur RMSE : {study.best_value:.4f}") - - # 🔹 Sauvegarder les résultats - optuna_path = f"{self.path}/optuna_lgbm_results.txt" - with open(optuna_path, "w") as f: - f.write(f"Best params:\n{study.best_params}\n") - f.write(f"Best RMSE: {study.best_value:.4f}\n") - - print(f"Résultats sauvegardés dans : {optuna_path}") - - # 🔹 Créer le modèle final avec les meilleurs paramètres - print("🚀 Entraînement du modèle LightGBM...") - - # -- Appliquer le filtrage -- - X_train_filtered = self.filter_features(X_train, y_train) - best_model = LGBMRegressor(**study.best_params) - best_model.fit(X_train_filtered, y_train) - - # fig1 = vis.plot_optimization_history(study) - # fig1.write_image("/home/souti/freqtrade/user_data/plots/optuna_history.png") - # - # fig2 = vis.plot_param_importances(study) - # fig2.write_image("/home/souti/freqtrade/user_data/plots/optuna_importance.png") - - return best_model, X_train_filtered - - def filter_features(self, X: pd.DataFrame, y: pd.Series, corr_threshold: float = 0.95): - """Filtre les colonnes peu utiles ou redondantes""" - print("🔍 Filtrage automatique des features...") - - # 1️⃣ Supprimer les colonnes constantes - vt = VarianceThreshold(threshold=1e-5) - X_var = pd.DataFrame(vt.fit_transform(X), columns=X.columns[vt.get_support()]) - print(f" - {len(X.columns) - X_var.shape[1]} colonnes supprimées (variance faible)") - - # 2️⃣ Supprimer les colonnes très corrélées entre elles - corr = X_var.corr().abs() - upper = corr.where(np.triu(np.ones(corr.shape), k=1).astype(bool)) - drop_cols = [column for column in upper.columns if any(upper[column] > corr_threshold)] - X_corr = X_var.drop(columns=drop_cols, errors='ignore') - print(f" - {len(drop_cols)} colonnes supprimées (corrélation > {corr_threshold})") - - # 3️⃣ Facultatif : supprimer les colonnes entièrement NaN - X_clean = X_corr.dropna(axis=1, how='all') - - print(f"✅ {X_clean.shape[1]} colonnes conservées après filtrage.\n") - return X_clean - def setTrends(self, dataframe: DataFrame): SMOOTH_WIN=10 df = dataframe.copy() @@ -2415,13 +1526,6 @@ class Zeus_TensorFlow(IStrategy): df['slope_norm'] = df['slope_norm'].fillna(0) dataframe['slope_norm'] = df['slope_norm'] - - try: - from lightgbm import LGBMRegressor - _HAS_LGBM = True - except Exception: - _HAS_LGBM = False - def make_model(self, model_type="linear", degree=2, random_state=0): model_type = model_type.lower() if model_type == "linear": @@ -2588,382 +1692,6 @@ class Zeus_TensorFlow(IStrategy): return df - # def calculateRegression(self, - # df, - # indic, - # lookback=30, - # future_steps=5, - # model_type="linear", - # degree=2, - # random_state=0, - # weight_mode="exp", # "exp", "linear" ou None - # weight_strength=0.2, # plus c’est grand, plus les dernières bougies comptent - # ): - # """ - # Ajoute une régression glissante qui prévoit la valeur future à horizon 'future_steps', - # avec pondération des dernières valeurs si weight_mode != None. - # """ - # df = df.copy() - # colname = f"{indic}_future_pred_{model_type}" - # df[colname] = np.nan - # - # values = df[indic].values - # n = len(values) - # X_window = np.arange(lookback).reshape(-1, 1) - # - # # génération du schéma de pondération - # if weight_mode == "exp": - # # exponentiel → les derniers points pèsent beaucoup plus - # weights = np.exp(np.linspace(-weight_strength, weight_strength, lookback)) - # elif weight_mode == "linear": - # # poids linéaire → 1..lookback - # weights = np.linspace(0.5, 1.0, lookback) - # else: - # weights = np.ones(lookback) - # - # for i in range(lookback, n - future_steps): - # y_window = values[i - lookback:i] - # if np.isnan(y_window).any(): - # continue - # - # model = self.make_model(model_type=model_type, degree=degree, random_state=random_state) - # - # try: - # model.fit(X_window, y_window, sample_weight=weights) - # except TypeError: - # # certains modèles (RF) ne supportent pas sample_weight dans ce contexte - # model.fit(X_window, y_window) - # except Exception: - # continue - # - # X_pred = np.array([[lookback + future_steps - 1]]) - # try: - # pred = model.predict(X_pred)[0] - # except Exception: - # continue - # - # df.iloc[i, df.columns.get_loc(colname)] = pred - # - # return df - - # def calculateRegression(self, df, indic, lookback=30, future_steps=5): - # """ - # Ajoute un indicateur {indic}_future_pred qui contient, - # pour chaque bougie n, la valeur attendue à n + future_steps - # selon une régression linéaire sur les lookback dernières bougies. - # """ - # df = df.copy() - # df[f"{indic}_future_pred"] = np.nan - # - # values = df[indic].values - # n = len(values) - # - # model = LinearRegression() - # - # for i in range(lookback, n - future_steps): - # # Fenêtre d’apprentissage - # X = np.arange(lookback).reshape(-1, 1) - # y = values[i - lookback:i] - # - # model.fit(X, y) - # - # # Prédiction future - # next_X = np.array([[lookback + future_steps - 1]]) - # future_pred = model.predict(next_X)[0] - # - # # On insère la prédiction à la position actuelle (n) - # df.iloc[i, df.columns.get_loc(f"{indic}_future_pred")] = future_pred - # - # return df - - def add_future_quantiles(self, dataframe, indic, lookback=30, future_steps=5, quantiles=[0.1, 0.5, 0.9]): - - working_columns = self.listUsableColumns(dataframe) - - df = dataframe[self.model_indicators].copy() - n = len(df) - target = self.indicator_target + "_future" - - df[target] = dataframe[self.indicator_target].shift(-24) # > df['sma24'] * 1.003).astype(int) - df[target] = df[target].fillna(0) #.astype(int) - - # Créer les colonnes pour chaque quantile - for q in quantiles: - df[f"{indic}_future_q{int(q * 100)}"] = np.nan - - # Préparer toutes les fenêtres X - X = np.array([df[indic].iloc[i - lookback:i].values for i in range(lookback, n - future_steps)]) - y_idx = np.arange(lookback, n - future_steps) + future_steps # index des valeurs futures - - # Imputer les NaN - imputer = SimpleImputer(strategy='median') - X_imputed = imputer.fit_transform(X) - - # Pour chaque quantile, créer un modèle et prédire - for q in quantiles: - model = HistGradientBoostingRegressor(loss='quantile', quantile=q, max_iter=100) - # Entrainer chaque ligne X_imputed à prédire la dernière valeur de la fenêtre + future_steps - # Ici, comme on prédit delta future par fenêtre, on peut utiliser la valeur cible correspondante - y = df[indic].iloc[y_idx].values - model.fit(X_imputed, y) - y_pred = model.predict(X_imputed) - - # Écrire les prédictions dans le dataframe - df.iloc[lookback:n - future_steps, df.columns.get_loc(f"{indic}_future_q{int(q * 100)}")] = y_pred - - df_plot = df.iloc[lookback:-future_steps] - self.plot_future_quantiles_band(df_plot, indic=self.indicator_target, quantiles=[0.1, 0.5, 0.9]) - # self.compute_quantile_confidence(df_plot, indic=self.indicator_target, quantiles=[0.1, 0.5, 0.9]) - - # fig, ax = plt.subplots(figsize=(20, 20)) - # for q in quantiles: - # plt.plot(stats.index.astype(str), stats[q], marker='o', label=f"Q{int(q * 100)}") - # plt.xticks(rotation=45) - # plt.xlabel(f"{indic} bins") - # plt.ylabel(f"Quantiles") - # plt.title(f"Distribution quantile de {indic}") - # plt.legend() - # plt.grid(True) - # plt.tight_layout() - # # plt.show() - # # --- Sauvegarde --- - # output_path = f"{path}/Distribution_quantile.png" - # plt.savefig(output_path, bbox_inches="tight", dpi=150) - # plt.close(fig) - # - # target = "future_return" - quantiles = [0.1, 0.25, 0.5, 0.75, 0.9] - for indicator in working_columns: - df["bin"] = pd.qcut(df[indicator], q=20, duplicates="drop") - stats = df.groupby("bin")[target].quantile(quantiles).unstack() - - fig, ax = plt.subplots(figsize=(10, 10)) - # plt.figure(figsize=(12, 6)) - for q in stats.columns: - plt.plot(stats.index.astype(str), stats[q], marker='o', label=f"Q{int(q * 100)}") - - plt.xticks(rotation=45) - plt.xlabel(f"{indicator} bins") - plt.ylabel(f"Quantiles of {target}") - plt.title(f"Distribution quantile de {target} selon {indicator}") - plt.legend() - plt.grid(True) - plt.tight_layout() - # --- Sauvegarde --- - output_path = f"{self.path}/Distribution_{indicator}.png" - plt.savefig(output_path, bbox_inches="tight", dpi=150) - plt.close(fig) - # plt.show() - - return df - - def plot_future_quantiles_band(self, df, indic, quantiles=[0.1, 0.5, 0.9], lookback=30, future_steps=5): - """ - df: DataFrame contenant la colonne réelle et les colonnes de quantiles - indic: nom de la colonne cible (ex: 'mid') - quantiles: liste des quantiles prédits - """ - # plt.figure(figsize=(16, 6)) - fig, ax = plt.subplots(figsize=(96, 30)) - - # Série réelle - plt.plot(df[indic], label=f"{indic} réel", color='black', linewidth=1.2) - - # Récupérer les colonnes de quantiles - cols_q = [f"{indic}_future_q{int(q * 100)}" for q in quantiles] - - # Vérifier que tous les quantiles existent - cols_q = [c for c in cols_q if c in df.columns] - - if len(cols_q) < 2: - print("Au moins deux quantiles sont nécessaires pour afficher les bandes") - return - - # Ordre : q_min, q_median, q_max - df_plot = df[cols_q] - - # Couleur pour la bande - color = sns.color_palette("coolwarm", n_colors=1)[0] - - # Tracer la bande entre min et max quantiles - plt.fill_between(df.index, - df_plot.iloc[:, 0], # quantile bas (ex: 10%) - df_plot.iloc[:, -1], # quantile haut (ex: 90%) - color=color, - alpha=0.3, - label=f"Intervalle {quantiles[0] * 100}-{quantiles[-1] * 100}%") - - # Tracer la médiane - if len(cols_q) >= 3: - plt.plot(df_plot.iloc[:, 1], color=color, linestyle='--', linewidth=1, label="Quantile médian") - - plt.title(f"Prédiction futures valeurs de {indic} avec intervalle de quantiles") - plt.xlabel("Index / Bougies") - plt.ylabel(indic) - plt.legend() - plt.grid(True) - # plt.show() - # --- Sauvegarde --- - output_path = f"{self.path}/Prédiction futures valeurs de {indic}.png" - plt.savefig(output_path, bbox_inches="tight", dpi=150) - plt.close(fig) - - def compute_quantile_confidence(self, df, indic, quantiles=[0.1, 0.5, 0.9]): - """ - df: DataFrame contenant les colonnes des quantiles - indic: nom de la colonne réelle - quantiles: liste des quantiles prédits - Retourne une série score [-1,1], positif = au-dessus de la médiane, négatif = en dessous - """ - - # df['quantile_conf'] = compute_quantile_confidence(df_plot, indic='mid') - # - # # Exemple de signal simple - # df['buy_signal'] = df['quantile_conf'] < -0.5 # valeur sous la médiane + bande étroite - # df['sell_signal'] = df['quantile_conf'] > 0.5 # valeur au-dessus de la médiane + bande étroite - - col_low = f"{indic}_future_q{int(quantiles[0] * 100)}" - col_med = f"{indic}_future_q{int(quantiles[1] * 100)}" - col_high = f"{indic}_future_q{int(quantiles[2] * 100)}" - - # largeur de bande (incertitude) - band_width = df[col_high] - df[col_low] + 1e-9 # éviter division par 0 - - # distance normalisée à la médiane - score = (df[indic] - df[col_med]) / band_width - - # clipper le score dans [-1,1] pour éviter les valeurs extrêmes - score = np.clip(score, -1, 1) - - # plt.figure(figsize=(16, 6)) - fig, ax = plt.subplots(figsize=(16, 6)) - plt.plot(df[indic], color='black', label='Valeur réelle') - plt.fill_between(df.index, - df[f"{indic}_future_q10"], - df[f"{indic}_future_q90"], - alpha=0.3, color='blue', label='Intervalle 10%-90%') - plt.plot(df[f"{indic}_future_q50"], linestyle='--', color='blue', label='Médiane') - - # Ajouter le score comme couleur de fond - plt.scatter(df.index, df[indic], c=df['quantile_conf'], cmap='coolwarm', s=20) - plt.colorbar(label='Score de confiance') - plt.title("Prédiction + score de confiance quantile") - plt.legend() - plt.grid(True) - # plt.show() - # --- Sauvegarde --- - output_path = f"{self.path}/Prédiction score confiance de {indic}.png" - plt.savefig(output_path, bbox_inches="tight", dpi=150) - plt.close(fig) - - return score - - # def loadTensorFlow(self, dataframe, metadata, lookback=50, future_steps=1): - # self.model = load_model(f"{self.path}/lstm_model.keras", compile=False) - # - # # features = toutes les colonnes sauf la cible - # feature_columns = self.model_indicators #[col for col in dataframe.columns if col != self.indicator_target] - # X_values = dataframe[feature_columns].values - # - # # normalisation avec le même scaler que l'entraînement - # scaler_X = MinMaxScaler() - # scaler_X.fit(X_values) # ou charger les paramètres si sauvegardés - # X_scaled = scaler_X.transform(X_values) - # - # # création des fenêtres glissantes - # X = np.lib.stride_tricks.sliding_window_view(X_scaled, window_shape=(self.lookback, X_scaled.shape[1])) - # # np.lib.stride_tricks.sliding_window_view ne supporte pas directement 2D → il vaut mieux utiliser une boucle : - # X_seq = [] - # for i in range(len(X_scaled) - self.lookback): - # X_seq.append(X_scaled[i:i + self.lookback]) - # X_seq = np.array(X_seq) - # - # # prédiction - # y_pred = self.model.predict(X_seq, verbose=0).flatten() - # - # # alignement avec les données - # preds = [np.nan] * len(dataframe) - # start = self.lookback - # end = start + len(y_pred) - # preds[start:end] = y_pred[:end - start] - # - # dataframe["lstm_pred"] = preds - # - # def trainTensorFlow(self, dataframe, metadata, lookback=50, future_steps=1): - # # 1) définir la cible - # y_values = dataframe[self.indicator_target].values.reshape(-1, 1) - # - # # 2) définir les features (toutes les colonnes sauf la cible) - # feature_columns = self.model_indicators #[col for col in dataframe.columns if col != self.indicator_target] - # X_values = dataframe[feature_columns].values - # - # # 3) normalisation - # scaler_X = MinMaxScaler() - # X_scaled = scaler_X.fit_transform(X_values) - # - # scaler_y = MinMaxScaler() - # y_scaled = scaler_y.fit_transform(y_values) - # - # # 4) création des fenêtres glissantes - # X = [] - # y = [] - # for i in range(len(X_scaled) - lookback - future_steps): - # X.append(X_scaled[i:i + lookback]) - # y.append(y_scaled[i + lookback + future_steps]) - # - # X = np.array(X) - # y = np.array(y) - # - # # 5) définition du modèle LSTM - # model = Sequential([ - # LSTM(64, return_sequences=False, input_shape=(lookback, X.shape[2])), - # Dense(32, activation="relu"), - # Dense(1) - # ]) - # - # model.compile(loss="mse", optimizer="adam") - # model.fit(X, y, epochs=20, batch_size=32, verbose=1) - # - # # 6) sauvegarde - # model.save(f"{self.path}/lstm_model.keras") - # np.save(f"{self.path}/lstm_scaler_X.npy", scaler_X.data_max_) - # np.save(f"{self.path}/lstm_scaler_y.npy", scaler_y.data_max_) - # # pour restaurer - # - # # df = dataframe[self.model_indicators].copy() - # # - # # # Construction dataset X / y - # # X = [] - # # y = [] - # # - # # prices = df[self.indicator_target].values - # # - # # for i in range(lookback, len(prices) - future_steps): - # # X.append(prices[i - lookback:i]) - # # y.append(prices[i + future_steps]) - # # - # # X = np.array(X).reshape(-1, lookback, 1) - # # y = np.array(y) - # # - # # # --- Définition du modèle --- - # # model = models.Sequential([ - # # layers.Input((lookback, 1)), - # # layers.LSTM(64), - # # layers.Dense(32, activation="relu"), - # # layers.Dense(1) - # # ]) - # # - # # model.compile(optimizer="adam", loss="mse") - # # model.summary() - # # - # # # --- Entraînement --- - # # model.fit(X, y, epochs=20, batch_size=32, verbose=1) - # # - # # # --- Sauvegarde --- - # # model.save(f"{self.path}/lstm_model.keras", include_optimizer=False) - # # - # print("Modèle entraîné et sauvegardé → lstm_model.h5") - def kerasGenerateGraphs(self, dataframe): model = self.model self.kerasGenerateGraphModel(model) @@ -3025,7 +1753,7 @@ class Zeus_TensorFlow(IStrategy): # ------------------- # Entraînement # ------------------- - def trainTensorFlow(self, dataframe, future_steps=1, lookback=50, epochs=40, batch_size=32): + def tensorFlowTrain(self, dataframe, future_steps=1, lookback=50, epochs=40, batch_size=32): X_seq, y_seq = self.tensorFlowPrepareDataFrame(dataframe, future_steps, lookback) # 6) Modèle LSTM @@ -3040,8 +1768,8 @@ class Zeus_TensorFlow(IStrategy): # 7) Sauvegarde self.model.save(f"{self.path}/lstm_model.keras") - # np.save(f"{self.path}/lstm_scaler_X.npy", self.scaler_X.data_max_) - # np.save(f"{self.path}/lstm_scaler_y.npy", self.scaler_y.data_max_) + # joblib.dump(self.scaler_X, f"{self.path}/lstm_scaler_X.pkl") + # joblib.dump(self.scaler_y, f"{self.path}/lstm_scaler_y.pkl") def tensorFlowPrepareDataFrame(self, dataframe, future_steps, lookback): target = self.indicator_target @@ -3087,61 +1815,20 @@ class Zeus_TensorFlow(IStrategy): # ------------------- # Prédiction # ------------------- - def predictTensorFlow(self, dataframe, future_steps=1, lookback=50): + def tensorFlowPredict(self, dataframe, future_steps=1, lookback=50): feature_columns = self.model_indicators #[col for col in dataframe.columns if col != self.indicator_target] # charger le modèle si pas déjà chargé if self.model is None: self.model = load_model(f"{self.path}/lstm_model.keras", compile=False) + # self.scaler_X = joblib.load(f"{self.path}/lstm_scaler_X.pkl") + # self.scaler_y = joblib.load(f"{self.path}/lstm_scaler_y.pkl") + X_seq, y_seq = self.tensorFlowPrepareDataFrame(dataframe, future_steps, lookback) preds = self.tensorFlowGeneratePredictions(dataframe, lookback, self.model) - # # features = toutes les colonnes sauf la cible - # feature_columns = self.model_indicators #[col for col in dataframe.columns if col != self.indicator_target] - # X_values = dataframe[feature_columns].values - # - # # normalisation (avec le scaler utilisé à l'entraînement) - # X_scaled = self.scaler_X.transform(X_values) - # - # # créer les séquences glissantes - # X_seq = [] - # for i in range(len(X_scaled) - self.lookback): - # X_seq.append(X_scaled[i:i + self.lookback]) - # X_seq = np.array(X_seq) - # - # # prédictions - # y_pred_scaled = self.model.predict(X_seq, verbose=0).flatten() - # y_pred = self.scaler_y.inverse_transform(y_pred_scaled.reshape(-1, 1)).flatten() - # - # # alignement avec les données - # preds = [np.nan] * len(dataframe) - # start = self.lookback - # end = start + len(y_pred) - # # preds[start:end] = y_pred[:end - start] - # preds[start:start + len(y_pred)] = y_pred - # - # # # features - # # X_values = dataframe[feature_columns].values - # # X_scaled = self.scaler_X.transform(X_values) - # # - # # # création des fenêtres - # # X_seq = [] - # # for i in range(len(X_scaled) - self.lookback): - # # X_seq.append(X_scaled[i:i + self.lookback]) - # # X_seq = np.array(X_seq) - # # - # # # prédiction - # # y_pred_scaled = self.model.predict(X_seq, verbose=0).flatten() - # # y_pred = self.scaler_y.inverse_transform(y_pred_scaled.reshape(-1, 1)).flatten() - # # - # # # alignement avec le dataframe - # # preds = [np.nan] * len(dataframe) - # # start = self.lookback - # # end = start + len(y_pred) - # # preds[start:end] = y_pred[:end-start] - # # # preds[start:start + len(y_pred)] = y_pred - dataframe["lstm_pred"] = preds + dataframe["lstm_pred_deriv1"] = dataframe["lstm_pred"].diff() return dataframe def tensorFlowGeneratePredictions(self, dataframe, lookback, model): diff --git a/Zeus_TensorFlow_1h.py b/Zeus_TensorFlow_1h.py new file mode 100644 index 0000000..7bfe2cf --- /dev/null +++ b/Zeus_TensorFlow_1h.py @@ -0,0 +1,1830 @@ +# Zeus Strategy: First Generation of GodStra Strategy with maximum +# AVG/MID profit in USDT +# Author: @Mablue (Masoud Azizi) +# github: https://github.com/mablue/ +# IMPORTANT: INSTALL TA BEFOUR RUN(pip install ta) +# freqtrade hyperopt --hyperopt-loss SharpeHyperOptLoss --spaces buy sell roi --strategy Zeus +# --- Do not remove these libs --- +from datetime import timedelta, datetime +from freqtrade.persistence import Trade +from freqtrade.strategy import (BooleanParameter, CategoricalParameter, DecimalParameter, stoploss_from_open, + IntParameter, IStrategy, merge_informative_pair, informative, stoploss_from_absolute) +import pandas as pd +import numpy as np +import os +import json +from pandas import DataFrame +from typing import Optional, Union, Tuple +import math +import logging +from pathlib import Path + +# -------------------------------- + +# Add your lib to import here test git +import ta +import talib.abstract as talib +import freqtrade.vendor.qtpylib.indicators as qtpylib +from datetime import timezone, timedelta + +logger = logging.getLogger(__name__) + +# Machine Learning +from sklearn.model_selection import train_test_split +import joblib +import matplotlib.pyplot as plt +from sklearn.metrics import ( + classification_report, + confusion_matrix, + accuracy_score, + roc_auc_score, + roc_curve, + precision_score, recall_score, precision_recall_curve, + f1_score, mean_squared_error, r2_score +) +from sklearn.tree import export_text +import inspect +from sklearn.feature_selection import SelectFromModel +from tabulate import tabulate +from sklearn.feature_selection import VarianceThreshold +import seaborn as sns +import lightgbm as lgb +from sklearn.model_selection import cross_val_score +import optuna.visualization as vis +import optuna +from lightgbm import LGBMRegressor +from sklearn.metrics import mean_squared_error +from sklearn.model_selection import train_test_split +from sklearn.linear_model import LinearRegression, Ridge, HuberRegressor +from sklearn.preprocessing import StandardScaler, PolynomialFeatures +from sklearn.pipeline import make_pipeline +from sklearn.svm import SVR +from sklearn.ensemble import RandomForestRegressor +from sklearn.ensemble import GradientBoostingRegressor +from sklearn.preprocessing import StandardScaler +from sklearn.ensemble import HistGradientBoostingRegressor +from sklearn.impute import SimpleImputer +from sklearn.pipeline import Pipeline + +# Tensorflow +import pandas as pd +import numpy as np +import tensorflow as tf +from tensorflow.keras import layers, models +from tensorflow.keras.models import load_model +from keras.utils import plot_model +from keras.models import Sequential +from keras.layers import LSTM, Dense +from sklearn.preprocessing import MinMaxScaler +from tensorflow.keras.models import Sequential +from tensorflow.keras.layers import LSTM, Dense +from tensorflow.keras.optimizers import Adam + +os.environ["CUDA_VISIBLE_DEVICES"] = "-1" # désactive complètement le GPU +os.environ["TF_XLA_FLAGS"] = "--tf_xla_enable_xla_devices=false" + + +# Couleurs ANSI de base +RED = "\033[31m" +GREEN = "\033[32m" +YELLOW = "\033[33m" +BLUE = "\033[34m" +MAGENTA = "\033[35m" +CYAN = "\033[36m" +RESET = "\033[0m" + +import warnings +warnings.filterwarnings( + "ignore", + message=r".*No further splits with positive gain.*" +) + +def pprint_df(dframe): + print(tabulate(dframe, headers='keys', tablefmt='psql', showindex=False)) + + +def normalize(df): + df = (df - df.min()) / (df.max() - df.min()) + return df + + +class Zeus_TensorFlow_1h(IStrategy): + startup_candle_count = 60 * 24 + + # Machine Learning + model = None + model_indicators = [] + indicator_target = 'sma5' + # Tensorflow + lookback = 72 + future_steps = 12 + y_no_scale = False + epochs = 120 + + path = f"user_data/plots/" + + # ROI table: + minimal_roi = { + "0": 0.564, + "567": 0.273, + "2814": 0.12, + "7675": 0 + } + + # Stoploss: + stoploss = -1 # 0.256 + # Custom stoploss + use_custom_stoploss = False + + trailing_stop = True + trailing_stop_positive = 0.15 + trailing_stop_positive_offset = 0.20 + trailing_only_offset_is_reached = True + + # Buy hypers + timeframe = '1h' + + max_open_trades = 5 + max_amount = 40 + + parameters = {} + # DCA config + position_adjustment_enable = True + + plot_config = { + "main_plot": { + "sma24": { + "color": "pink" + }, + "sma5_1d": { + "color": "blue" + }, + # "sma24": { + # "color": "yellow" + # }, + "sma60": { + "color": "green" + }, + "bb_lowerband": { + "color": "#da59a6"}, + "bb_upperband": { + "color": "#da59a6", + }, + # "sma12": { + # "color": "blue" + # }, + "mid_smooth_3": { + "color": "blue" + } + }, + "subplots": { + "Rsi": { + "max_rsi_24": { + "color": "blue" + }, + "max_rsi_24": { + "color": "pink" + }, + # "rsi": { + # "color": "red" + # }, + # "rsi_1d": { + # "color": "blue" + # } + }, + "Rsi_deriv1": { + "sma24_deriv1": { + "color": "pink" + }, + "sma24_deriv1": { + "color": "yellow" + }, + "sma5_deriv1_1d": { + "color": "blue" + }, + "sma60_deriv1": { + "color": "green" + } + }, + "Rsi_deriv2": { + "sma24_deriv2": { + "color": "pink" + }, + "sma24_deriv2": { + "color": "yellow" + }, + "sma5_deriv2_1d": { + "color": "blue" + }, + "sma60_deriv2": { + "color": "green" + } + }, + 'Macd': { + "macd_rel_1d": { + "color": "cyan" + }, + "macdsignal_rel_1d": { + "color": "pink" + }, + "macdhist_rel_1d": { + "color": "yellow" + } + } + } + } + columns_logged = False + pairs = { + pair: { + "first_buy": 0, + "last_buy": 0.0, + "last_min": 999999999999999.5, + "last_max": 0, + "trade_info": {}, + "max_touch": 0.0, + "last_sell": 0.0, + 'count_of_buys': 0, + 'current_profit': 0, + 'expected_profit': 0, + 'previous_profit': 0, + "last_candle": {}, + "last_count_of_buys": 0, + 'base_stake_amount': 0, + 'stop_buy': False, + 'last_date': 0, + 'stop': False, + 'max_profit': 0, + 'total_amount': 0, + 'has_gain': 0, + 'force_sell': False, + 'force_buy': False + } + for pair in ["BTC/USDC", "ETH/USDC", "DOGE/USDC", "XRP/USDC", "SOL/USDC", + "BTC/USDT", "ETH/USDT", "DOGE/USDT", "XRP/USDT", "SOL/USDT"] + } + # 20 20 40 60 100 160 260 420 + # 50 50 100 300 500 + # fibo = [1, 1, 2, 3, 5, 8, 13, 21] + # my fibo + # 50 50 50 100 100 150 200 250 350 450 600 1050 + fibo = [1, 1, 1, 2, 2, 3, 4, 5, 7, 9, 12, 16, 21] + baisse = [1, 2, 3, 5, 7, 10, 14, 19, 26, 35, 47, 63, 84] + # Ma suite 1 1 1 2 2 3 4 5 7 9 12 16 21 + # Mise 50 50 50 100 100 150 200 250 350 450 600 800 1050 + # Somme Mises 50 100 150 250 350 500 700 950 1300 1750 2350 3150 4200 + # baisse 1 2 3 5 7 10 14 19 26 35 47 63 84 + + # factors = [1, 1.1, 1.25, 1.5, 2.0, 3] + # thresholds = [2, 5, 10, 20, 30, 50] + + factors = [0.5, 0.75, 1, 1.25, 1.5, 2] + thresholds = [0, 2, 5, 10, 30, 45] + + trades = list() + max_profit_pairs = {} + + mise_factor_buy = DecimalParameter(0.01, 0.1, default=0.05, decimals=2, space='buy', optimize=True, load=True) + + indicators = {'sma5', 'sma12', 'sma24', 'sma60'} + indicators_percent = {'percent', 'percent3', 'percent12', 'percent24', 'percent_1d', 'percent3_1h', 'percent12_1d', 'percent24_1d'} + + mises = IntParameter(1, 50, default=5, space='buy', optimize=True, load=True) + + ml_prob_buy = DecimalParameter(-0.5, 0.5, default=0.0, decimals=2, space='buy', optimize=True, load=True) + ml_prob_sell = DecimalParameter(-0.5, 0.5, default=0.0, decimals=2, space='sell', optimize=True, load=True) + + pct = DecimalParameter(0.005, 0.05, default=0.012, decimals=3, space='buy', optimize=True, load=True) + pct_inc = DecimalParameter(0.0001, 0.003, default=0.0022, decimals=4, space='buy', optimize=True, load=True) + + rsi_deb_protect = IntParameter(50, 90, default=70, space='protection', optimize=True, load=True) + rsi_end_protect = IntParameter(20, 60, default=55, space='protection', optimize=True, load=True) + + sma24_deriv1_deb_protect = DecimalParameter(-4, 4, default=-2, decimals=1, space='protection', optimize=True, load=True) + sma24_deriv1_end_protect = DecimalParameter(-4, 4, default=0, decimals=1, space='protection', optimize=True, load=True) + + # ========================================================================= + should_enter_trade_count = 0 + + def confirm_trade_entry(self, pair: str, order_type: str, amount: float, rate: float, time_in_force: str, + current_time: datetime, entry_tag: Optional[str], **kwargs) -> bool: + + minutes = 0 + if self.pairs[pair]['last_date'] != 0: + minutes = round(int((current_time - self.pairs[pair]['last_date']).total_seconds() / 60)) + + dataframe, _ = self.dp.get_analyzed_dataframe(pair, self.timeframe) + last_candle = dataframe.iloc[-1].squeeze() + last_candle_2 = dataframe.iloc[-2].squeeze() + last_candle_3 = dataframe.iloc[-3].squeeze() + + condition = True #(last_candle[f"{indic_5m}_deriv1"] >= indic_deriv1_5m) and (last_candle[f"{indic_5m}_deriv2"] >= indic_deriv2_5m) + + allow_to_buy = True #(condition and not self.pairs[pair]['stop']) | (entry_tag == 'force_entry') + + if allow_to_buy: + self.trades = list() + self.pairs[pair]['first_buy'] = rate + self.pairs[pair]['last_buy'] = rate + self.pairs[pair]['max_touch'] = last_candle['close'] + self.pairs[pair]['last_candle'] = last_candle + self.pairs[pair]['count_of_buys'] = 1 + self.pairs[pair]['current_profit'] = 0 + self.pairs[pair]['last_max'] = max(last_candle['close'], self.pairs[pair]['last_max']) + self.pairs[pair]['last_min'] = min(last_candle['close'], self.pairs[pair]['last_min']) + + dispo = round(self.wallets.get_available_stake_amount()) + self.printLineLog() + + stake_amount = self.adjust_stake_amount(pair, last_candle) + + self.pairs[pair]['total_amount'] = stake_amount + + self.log_trade( + last_candle=last_candle, + date=current_time, + action=("🟩Buy" if allow_to_buy else "Canceled") + " " + str(minutes), + pair=pair, + rate=rate, + dispo=dispo, + profit=0, + trade_type=entry_tag, + buys=1, + stake=round(stake_amount, 2) + ) + + return allow_to_buy + + def confirm_trade_exit(self, pair: str, trade: Trade, order_type: str, amount: float, rate: float, + time_in_force: str, + exit_reason: str, current_time, **kwargs, ) -> bool: + + # allow_to_sell = (minutes > 30) + dataframe, _ = self.dp.get_analyzed_dataframe(pair, self.timeframe) + last_candle = dataframe.iloc[-1].squeeze() + + minutes = int(round((current_time - trade.open_date_utc).seconds / 60, 0)) + profit =trade.calc_profit(rate) + force = self.pairs[pair]['force_sell'] + allow_to_sell = minutes > 30 and (last_candle['hapercent'] < 0 ) or force or (exit_reason == 'force_exit') or (exit_reason == 'stop_loss') + + if allow_to_sell: + self.trades = list() + self.pairs[pair]['last_count_of_buys'] = trade.nr_of_successful_entries # self.pairs[pair]['count_of_buys'] + self.pairs[pair]['last_sell'] = rate + self.pairs[pair]['last_candle'] = last_candle + self.pairs[pair]['max_profit'] = 0 + self.pairs[pair]['previous_profit'] = 0 + self.trades = list() + dispo = round(self.wallets.get_available_stake_amount()) + # print(f"Sell {pair} {current_time} {exit_reason} dispo={dispo} amount={amount} rate={rate} open_rate={trade.open_rate}") + self.log_trade( + last_candle=last_candle, + date=current_time, + action="🟥Sell " + str(minutes), + pair=pair, + trade_type=exit_reason, + rate=last_candle['close'], + dispo=dispo, + profit=round(profit, 2) + ) + self.pairs[pair]['force_sell'] = False + self.pairs[pair]['has_gain'] = 0 + self.pairs[pair]['current_profit'] = 0 + self.pairs[pair]['total_amount'] = 0 + self.pairs[pair]['count_of_buys'] = 0 + self.pairs[pair]['max_touch'] = 0 + self.pairs[pair]['last_buy'] = 0 + self.pairs[pair]['last_date'] = current_time + self.pairs[pair]['current_trade'] = None + # else: + # self.printLog(f"{current_time} SELL triggered for {pair} ({exit_reason} profit={profit} minutes={minutes} percent={last_candle['hapercent']}) but condition blocked") + return (allow_to_sell) | (exit_reason == 'force_exit') | (exit_reason == 'stop_loss') + + def custom_stake_amount(self, pair: str, current_time: datetime, current_rate: float, + proposed_stake: float, min_stake: float, max_stake: float, + **kwargs) -> float: + + dataframe, _ = self.dp.get_analyzed_dataframe(pair=pair, timeframe=self.timeframe) + current_candle = dataframe.iloc[-1].squeeze() + adjusted_stake_amount = self.adjust_stake_amount(pair, current_candle) + + # print(f"{pair} adjusted_stake_amount{adjusted_stake_amount}") + + # Use default stake amount. + return adjusted_stake_amount + + def custom_exit(self, pair: str, trade: Trade, current_time, current_rate, current_profit, **kwargs): + + dataframe, _ = self.dp.get_analyzed_dataframe(pair, self.timeframe) + last_candle = dataframe.iloc[-1].squeeze() + last_candle_1h = dataframe.iloc[-13].squeeze() + before_last_candle = dataframe.iloc[-2].squeeze() + before_last_candle_2 = dataframe.iloc[-3].squeeze() + before_last_candle_12 = dataframe.iloc[-13].squeeze() + + expected_profit = self.expectedProfit(pair, last_candle) + # print(f"current_time={current_time} current_profit={current_profit} expected_profit={expected_profit}") + + max_touch_before = self.pairs[pair]['max_touch'] + self.pairs[pair]['last_max'] = max(last_candle['close'], self.pairs[pair]['last_max']) + self.pairs[pair]['last_min'] = min(last_candle['close'], self.pairs[pair]['last_min']) + self.pairs[pair]['current_trade'] = trade + + count_of_buys = trade.nr_of_successful_entries + + profit = trade.calc_profit(current_rate) #round(current_profit * trade.stake_amount, 1) + self.pairs[pair]['max_profit'] = max(self.pairs[pair]['max_profit'], profit) + max_profit = self.pairs[pair]['max_profit'] + baisse = 0 + if profit > 0: + baisse = 1 - (profit / max_profit) + mx = max_profit / 5 + self.pairs[pair]['count_of_buys'] = count_of_buys + self.pairs[pair]['current_profit'] = profit + + dispo = round(self.wallets.get_available_stake_amount()) + hours_since_first_buy = (current_time - trade.open_date_utc).seconds / 3600.0 + days_since_first_buy = (current_time - trade.open_date_utc).days + hours = (current_time - trade.date_last_filled_utc).total_seconds() / 3600.0 + + if hours % 4 == 0: + self.log_trade( + last_candle=last_candle, + date=current_time, + action="🔴 CURRENT" if self.pairs[pair]['stop'] or last_candle['stop_buying'] else "🟢 CURRENT", + dispo=dispo, + pair=pair, + rate=last_candle['close'], + trade_type='', + profit=round(profit, 2), + buys=count_of_buys, + stake=0 + ) + + pair_name = self.getShortName(pair) + if last_candle['max_rsi_24'] > 85 and profit > max(5, expected_profit) and (last_candle['hapercent'] < 0) and last_candle['sma60_deriv1'] < 0.05: + self.pairs[pair]['force_sell'] = False + self.pairs[pair]['force_buy'] = False #(self.pairs[pair]['count_of_buys'] - self.pairs[pair]['has_gain'] > 3) + return str(count_of_buys) + '_' + 'Rsi85_' + pair_name + '_' + str(self.pairs[pair]['has_gain']) + + if self.pairs[pair]['force_sell']: + self.pairs[pair]['force_sell'] = False + self.pairs[pair]['force_buy'] = (self.pairs[pair]['count_of_buys'] - self.pairs[pair]['has_gain'] > 3) + return str(count_of_buys) + '_' + 'Frc_' + pair_name + '_' + str(self.pairs[pair]['has_gain']) + + if profit > 0 and baisse > 0.30: + self.pairs[pair]['force_sell'] = False + self.pairs[pair]['force_buy'] = (self.pairs[pair]['count_of_buys'] - self.pairs[pair]['has_gain'] > 3) + return str(count_of_buys) + '_' + 'B30_' + pair_name + '_' + str(self.pairs[pair]['has_gain']) + + # if max_profit > 0.5 * count_of_buys and baisse > 0.15: + # self.pairs[pair]['force_sell'] = False + # self.pairs[pair]['force_buy'] = (self.pairs[pair]['count_of_buys'] - self.pairs[pair]['has_gain'] > 3) + # return str(count_of_buys) + '_' + 'B15_' + pair_name + '_' + str(self.pairs[pair]['has_gain']) + + if (last_candle['sma5'] - before_last_candle_12['sma5']) / last_candle['sma5'] > 0.0002: + return None + + factor = 1 + if (self.getShortName(pair) == 'BTC'): + factor = 0.5 + # if baisse > 2 and baisse > factor * self.pairs[pair]['total_amount'] / 100: + # self.pairs[pair]['force_sell'] = False + # self.pairs[pair]['force_buy'] = (self.pairs[pair]['count_of_buys'] - self.pairs[pair]['has_gain'] > 3) + # return 'Baisse_' + pair_name + '_' + str(count_of_buys) + '_' + str(self.pairs[pair]['has_gain']) + # + # if 1 <= count_of_buys <= 3: + if last_candle['max_rsi_24'] > 75 and profit > expected_profit and (last_candle['hapercent'] < 0) and last_candle['sma60_deriv1'] < 0: + self.pairs[pair]['force_sell'] = False + return str(count_of_buys) + '_' + 'Rsi75_' + pair_name + '_' + str(self.pairs[pair]['has_gain']) + + + self.pairs[pair]['max_touch'] = max(last_candle['close'], self.pairs[pair]['max_touch']) + + def getShortName(self, pair): + return pair.replace("/USDT", '').replace("/USDC", '').replace("_USDC", '').replace("_USDT", '') + + def informative_pairs(self): + # get access to all pairs available in whitelist. + pairs = self.dp.current_whitelist() + informative_pairs = [(pair, '1d') for pair in pairs] + # informative_pairs += [(pair, '1h') for pair in pairs] + + return informative_pairs + + def log_trade(self, action, pair, date, trade_type=None, rate=None, dispo=None, profit=None, buys=None, stake=None, + last_candle=None): + # Afficher les colonnes une seule fois + if self.config.get('runmode') == 'hyperopt' or self.dp.runmode.value in ('hyperopt'): + return + if self.columns_logged % 10 == 0: + self.printLog( + f"| {'Date':<16} | {'Action':<10} |{'Pair':<5}| {'Trade Type':<18} |{'Rate':>8} | {'Dispo':>6} | {'Profit':>8} " + f"| {'Pct':>6} | {'max_touch':>11} | {'last_lost':>12} | {'last_max':>7}| {'last_max':>7}|{'Buys':>5}| {'Stake':>5} |" + f"{'rsi':>6}|Distmax|s201d|s5_1d|s5_2d|s51h|s52h|smt1h|smt2h|tdc1d|tdc1h" + ) + self.printLineLog() + df = pd.DataFrame.from_dict(self.pairs, orient='index') + colonnes_a_exclure = ['last_candle', + 'trade_info', 'last_date', 'last_count_of_buys', 'base_stake_amount', 'stop_buy'] + df_filtered = df[df['count_of_buys'] > 0].drop(columns=colonnes_a_exclure) + # df_filtered = df_filtered["first_buy", "last_max", "max_touch", "last_sell","last_buy", 'count_of_buys', 'current_profit'] + + print(df_filtered) + + self.columns_logged += 1 + date = str(date)[:16] if date else "-" + limit = None + # if buys is not None: + # limit = round(last_rate * (1 - self.fibo[buys] / 100), 4) + + rsi = '' + rsi_pct = '' + sma5_1d = '' + sma5_1h = '' + + sma5 = str(sma5_1d) + ' ' + str(sma5_1h) + + last_lost = self.getLastLost(last_candle, pair) + + if buys is None: + buys = '' + + max_touch = '' + pct_max = self.getPctFirstBuy(pair, last_candle) + + total_counts = str(buys) + '/' + str(sum(pair_data['count_of_buys'] for pair_data in self.pairs.values())) + + dist_max = '' + + color = GREEN if profit > 0 else RED + color_sma24 = GREEN if last_candle['sma24_deriv1'] > 0 else RED + color_sma24_2 = GREEN if last_candle['sma24_deriv2'] > 0 else RED + color_sma5 = GREEN if last_candle['mid_smooth_5_deriv1'] > 0 else RED + color_sma5_2 = GREEN if last_candle['mid_smooth_5_deriv2'] > 0 else RED + color_sma5 = GREEN if last_candle['sma60_deriv1'] > 0 else RED + color_sma5_2h = GREEN if last_candle['sma60_deriv2'] > 0 else RED + color_smooth = GREEN if last_candle['mid_smooth_deriv1'] > 0 else RED + color_smooth2 = GREEN if last_candle['mid_smooth_deriv2'] > 0 else RED + + last_max = int(self.pairs[pair]['last_max']) if self.pairs[pair]['last_max'] > 1 else round( + self.pairs[pair]['last_max'], 3) + last_min = int(self.pairs[pair]['last_min']) if self.pairs[pair]['last_min'] > 1 else round( + self.pairs[pair]['last_min'], 3) + + profit = str(profit) + '/' + str(round(self.pairs[pair]['max_profit'], 2)) + + # 🟢 Dérivée 1 > 0 et dérivée 2 > 0: tendance haussière qui s’accélère. + # 🟡 Dérivée 1 > 0 et dérivée 2 < 0: tendance haussière qui ralentit → essoufflement potentiel. + # 🔴 Dérivée 1 < 0 et dérivée 2 < 0: tendance baissière qui s’accélère. + # 🟠 Dérivée 1 < 0 et dérivée 2 > 0: tendance baissière qui ralentit → possible bottom. + self.printLog( + f"| {date:<16} |{action:<10} | {pair[0:3]:<3} | {trade_type or '-':<18} |{rate or '-':>9}| {dispo or '-':>6} " + f"|{color}{profit or '-':>10}{RESET}| {pct_max or '-':>6} | {round(self.pairs[pair]['max_touch'], 2) or '-':>11} | {last_lost or '-':>12} " + f"| {last_max or '-':>7} | {last_min or '-':>7} |{total_counts or '-':>5}|{stake or '-':>7}" + # f"|{round(last_candle['mid_smooth_24_deriv1'],3) or '-':>6}|{round(last_candle['mid_smooth_deriv1'],3) or '-':>6}|{round(last_candle['mid_smooth_deriv1_1d'],3) or '-' :>6}|" + # f"{round(last_candle['mid_smooth_24_deriv2'],3) or '-' :>6}|{round(last_candle['mid_smooth_deriv2'],3) or '-':>6}|{round(last_candle['mid_smooth_deriv2_1d'],3) or '-':>6}|" + f"{round(last_candle['max_rsi_24'], 1) or '-' :>6}|" + f"{dist_max:>7}|{color_sma24}{round(last_candle['sma24_deriv1'], 2):>5}{RESET}" + f"|{color_sma5}{round(last_candle['mid_smooth_5_deriv1'], 2):>5}{RESET}|{color_sma5_2}{round(last_candle['mid_smooth_5_deriv2'], 2):>5}{RESET}" + f"|{color_sma5}{round(last_candle['sma60_deriv1'], 2):>5}{RESET}|{color_sma5_2h}{round(last_candle['sma60_deriv2'], 2):>5}{RESET}" + f"|{color_smooth}{round(last_candle['mid_smooth_deriv1'], 2):>5}{RESET}|{color_smooth2}{round(last_candle['mid_smooth_deriv2'], 2):>5}{RESET}" + ) + + def getLastLost(self, last_candle, pair): + last_lost = round((last_candle['close'] - self.pairs[pair]['max_touch']) / self.pairs[pair]['max_touch'], 3) + return last_lost + + def printLineLog(self): + # f"sum1h|sum1d|Tdc|Tdh|Tdd| drv1 |drv|drv_1d|" + self.printLog( + f"+{'-' * 18}+{'-' * 12}+{'-' * 5}+{'-' * 20}+{'-' * 9}+{'-' * 8}+{'-' * 12}+{'-' * 8}+{'-' * 13}+{'-' * 14}+{'-' * 9}{'-' * 9}+{'-' * 5}+{'-' * 7}+" + f"+{'-' * 6}+{'-' * 7}+{'-' * 5}+{'-' * 5}+{'-' * 5}+{'-' * 5}+{'-' * 5}+{'-' * 5}+" + ) + + def printLog(self, str): + if self.config.get('runmode') == 'hyperopt' or self.dp.runmode.value in ('hyperopt'): + return; + if not self.dp.runmode.value in ('backtest', 'hyperopt', 'lookahead-analysis'): + logger.info(str) + else: + if not self.dp.runmode.value in ('hyperopt'): + print(str) + + def populate_indicators(self, dataframe: DataFrame, metadata: dict) -> DataFrame: + # Add all ta features + pair = metadata['pair'] + short_pair = self.getShortName(pair) + self.path = f"user_data/plots/{short_pair}/" + + dataframe = self.populateDataframe(dataframe, timeframe='1h') + + # ################### INFORMATIVE 1d + informative = self.dp.get_pair_dataframe(pair=metadata['pair'], timeframe="1d") + informative = self.populateDataframe(informative, timeframe='1d') + # informative = self.calculateRegression(informative, 'mid', lookback=15) + dataframe = merge_informative_pair(dataframe, informative, self.timeframe, "1d", ffill=True) + + + dataframe['last_price'] = dataframe['close'] + dataframe['first_price'] = dataframe['close'] + if self.dp: + if self.dp.runmode.value in ('live', 'dry_run'): + self.getOpenTrades() + + for trade in self.trades: + if trade.pair != pair: + continue + filled_buys = trade.select_filled_orders('buy') + count = 0 + amount = 0 + for buy in filled_buys: + if count == 0: + dataframe['first_price'] = buy.price + self.pairs[pair]['first_buy'] = buy.price + self.pairs[pair]['first_amount'] = buy.price * buy.filled + # dataframe['close01'] = buy.price * 1.01 + + # Order(id=2396, trade=1019, order_id=29870026652, side=buy, filled=0.00078, price=63921.01, + # status=closed, date=2024-08-26 02:20:11) + dataframe['last_price'] = buy.price + self.pairs[pair]['last_buy'] = buy.price + count = count + 1 + amount += buy.price * buy.filled + # dataframe['mid_price'] = (dataframe['last_price'] + dataframe['first_price']) / 2 + count_buys = count + # dataframe['limit'] = dataframe['last_price'] * (1 - self.baisse[count] / 100) + self.pairs[pair]['total_amount'] = amount + + # dataframe['mid_smooth_tag'] = qtpylib.crossed_below(dataframe['mid_smooth_24_deriv1'], dataframe['mid_smooth_deriv2_24']) + + # =============================== + # lissage des valeurs horaires + dataframe['mid_smooth'] = dataframe['mid'].rolling(window=6).mean() + dataframe["mid_smooth_deriv1"] = 100 * dataframe["mid_smooth"].diff().rolling(window=6).mean() / \ + dataframe['mid_smooth'] + dataframe["mid_smooth_deriv2"] = 100 * dataframe["mid_smooth_deriv1"].diff().rolling(window=6).mean() + + # dataframe['mid_smooth_5h'] = talib.EMA(dataframe, timeperiod=60) # dataframe['mid'].rolling(window=60).mean() + # dataframe["mid_smooth_5h_deriv1"] = 100 * dataframe["mid_smooth_5h"].diff().rolling(window=60).mean() / \ + # dataframe['mid_smooth_5h'] + # dataframe["mid_smooth_5h_deriv2"] = 100 * dataframe["mid_smooth_5h_deriv1"].diff().rolling(window=60).mean() + + dataframe['stop_buying_deb'] = ((dataframe['max_rsi_24'] > self.rsi_deb_protect.value) + & (dataframe['sma24_deriv1'] < self.sma24_deriv1_deb_protect.value) + ) + dataframe['stop_buying_end'] = ((dataframe['max_rsi_24'] < self.rsi_end_protect.value) + & (dataframe['sma24_deriv1'] > self.sma24_deriv1_end_protect.value) + ) + + latched = np.zeros(len(dataframe), dtype=bool) + + for i in range(1, len(dataframe)): + if dataframe['stop_buying_deb'].iloc[i]: + latched[i] = True + elif dataframe['stop_buying_end'].iloc[i]: + latched[i] = False + else: + latched[i] = latched[i - 1] + + dataframe['stop_buying'] = latched + + dataframe = self.calculateRegression(dataframe, 'mid', lookback=10, future_steps=10, model_type="poly") + dataframe = self.calculateRegression(dataframe, 'sma24', lookback=12, future_steps=12) + + self.model_indicators = self.listUsableColumns(dataframe) + + # TENSOR FLOW + if False and self.dp.runmode.value in ('backtest'): + self.tensorFlowTrain(dataframe, future_steps = self.future_steps) + + self.tensorFlowPredict(dataframe) + + if False and self.dp.runmode.value in ('backtest'): + self.kerasGenerateGraphs(dataframe) + + return dataframe + + def listUsableColumns(self, dataframe): + # Étape 1 : sélectionner numériques + numeric_cols = dataframe.select_dtypes(include=['int64', 'float64']).columns + # Étape 2 : enlever constantes + # usable_cols = [c for c in numeric_cols if dataframe[c].nunique() > 1 + # and (c.endswith("_deriv1") or not c.endswith("deriv1")) + # and not c.endswith("_count") + # ] + usable_cols = [c for c in numeric_cols if dataframe[c].nunique() > 1 + and not c.endswith("_state") + # and not c.endswith("_1d") + # and not c.endswith("") + and not c.endswith("_count") + # and not c.startswith("open") and not c.startswith("close") + # and not c.startswith("low") and not c.startswith("high") + # and not c.startswith("haopen") and not c.startswith("haclose") + # and not c.startswith("bb_lower") and not c.startswith("bb_upper") + # and not c.startswith("bb_middle") + and not c.endswith("_class") and not c.endswith("_price") + and not c.startswith('stop_buying')] + # Étape 3 : remplacer inf et NaN par 0 + # usable_cols = [ + # 'hapercent', 'percent', 'percent3', 'percent12', + # 'percent24', + # 'sma5_dist', 'sma5_deriv1', 'sma12_dist', 'sma12_deriv1', + # 'sma24_dist', 'sma24_deriv1', 'sma48_dist', 'sma48_deriv1', 'sma60_dist', 'sma60_deriv1', 'sma60_deriv2', + # 'mid_smooth_3_deriv1', 'mid_smooth_5_dist', + # 'mid_smooth_5_deriv1', 'mid_smooth_12_dist', + # 'mid_smooth_12_deriv1', 'mid_smooth_24_dist', + # 'mid_smooth_24_deriv1', + # 'rsi', 'max_rsi_12', 'max_rsi_24', + # 'rsi_dist', 'rsi_deriv1', + # 'min_max_60', 'bb_percent', 'bb_width', + # 'macd', 'macdsignal', 'macdhist', 'slope', + # 'slope_smooth', 'atr', 'atr_norm', 'adx', 'obv', 'vol_24', + # 'rsi_slope', 'adx_change', 'volatility_ratio', 'rsi_diff', + # 'slope_ratio', 'volume_sma_deriv', 'volume_dist', 'volume_deriv1', + # 'slope_norm', + # # 'mid_smooth_deriv1', + # # 'mid_smooth_5h_deriv1', 'mid_smooth_5h_deriv2', 'mid_future_pred_cons', + # # 'sma24_future_pred_cons' + # ] + + dataframe[usable_cols] = dataframe[usable_cols].replace([np.inf, -np.inf], 0).fillna(0) + print("Colonnes utilisables pour le modèle :") + print(usable_cols) + self.model_indicators = usable_cols + return self.model_indicators + + def populateDataframe(self, dataframe, timeframe='5m'): + dataframe = dataframe.copy() + heikinashi = qtpylib.heikinashi(dataframe) + dataframe['haopen'] = heikinashi['open'] + dataframe['haclose'] = heikinashi['close'] + dataframe['hapercent'] = (dataframe['haclose'] - dataframe['haopen']) / dataframe['haclose'] + dataframe['mid'] = dataframe['haopen'] + (dataframe['haclose'] - dataframe['haopen']) / 2 + + dataframe["percent"] = dataframe['mid'].pct_change() + dataframe["percent3"] = dataframe['mid'].pct_change(3).rolling(3).mean() + dataframe["percent12"] = dataframe['mid'].pct_change(12).rolling(12).mean() + dataframe["percent24"] = dataframe['mid'].pct_change(24).rolling(24).mean() + + # if self.dp.runmode.value in ('backtest'): + # dataframe['futur_percent'] = 100 * (dataframe['close'].shift(-1) - dataframe['close']) / dataframe['close'] + + dataframe['sma5'] = dataframe['mid'].ewm(span=5, adjust=False).mean() #dataframe["mid"].rolling(window=5).mean() + self.calculeDerivees(dataframe, 'sma5', timeframe=timeframe, ema_period=5) + dataframe['sma12'] = dataframe['mid'].ewm(span=12, adjust=False).mean() #dataframe["mid"].rolling(window=12).mean() + self.calculeDerivees(dataframe, 'sma12', timeframe=timeframe, ema_period=12) + dataframe['sma24'] = dataframe['mid'].ewm(span=24, adjust=False).mean() #dataframe["mid"].rolling(window=24).mean() + self.calculeDerivees(dataframe, 'sma24', timeframe=timeframe, ema_period=24) + dataframe['sma48'] = dataframe['mid'].ewm(span=48, adjust=False).mean() #dataframe["mid"].rolling(window=48).mean() + self.calculeDerivees(dataframe, 'sma48', timeframe=timeframe, ema_period=48) + dataframe['sma60'] = dataframe['mid'].ewm(span=60, adjust=False).mean() #dataframe["mid"].rolling(window=60).mean() + self.calculeDerivees(dataframe, 'sma60', timeframe=timeframe, ema_period=60) + + dataframe = self.calculateDerivation(dataframe, window=3, suffixe="_3",timeframe=timeframe) + dataframe = self.calculateDerivation(dataframe, window=5, suffixe="_5",timeframe=timeframe) + dataframe = self.calculateDerivation(dataframe, window=12, suffixe="_12",timeframe=timeframe) + dataframe = self.calculateDerivation(dataframe, window=24, suffixe="_24", timeframe=timeframe) + # print(metadata['pair']) + dataframe['rsi'] = talib.RSI(dataframe['mid'], timeperiod=14) + dataframe['max_rsi_12'] = talib.MAX(dataframe['rsi'], timeperiod=12) + dataframe['max_rsi_24'] = talib.MAX(dataframe['rsi'], timeperiod=24) + self.calculeDerivees(dataframe, 'rsi', timeframe=timeframe, ema_period=12) + dataframe['max12'] = talib.MAX(dataframe['mid'], timeperiod=12) + dataframe['min12'] = talib.MIN(dataframe['mid'], timeperiod=12) + dataframe['max60'] = talib.MAX(dataframe['mid'], timeperiod=60) + dataframe['min60'] = talib.MIN(dataframe['mid'], timeperiod=60) + dataframe['min_max_60'] = ((dataframe['max60'] - dataframe['mid']) / dataframe['min60']) + # dataframe['min36'] = talib.MIN(dataframe['close'], timeperiod=36) + # dataframe['max36'] = talib.MAX(dataframe['close'], timeperiod=36) + # dataframe['pct36'] = 100 * (dataframe['max36'] - dataframe['min36']) / dataframe['min36'] + # dataframe['maxpct36'] = talib.MAX(dataframe['pct36'], timeperiod=36) + # Bollinger Bands + bollinger = qtpylib.bollinger_bands(qtpylib.typical_price(dataframe), window=20, stds=2) + dataframe['bb_lowerband'] = bollinger['lower'] + dataframe['bb_middleband'] = bollinger['mid'] + dataframe['bb_upperband'] = bollinger['upper'] + dataframe["bb_percent"] = ( + (dataframe["mid"] - dataframe["bb_lowerband"]) / + (dataframe["bb_upperband"] - dataframe["bb_lowerband"]) + ) + dataframe["bb_width"] = (dataframe["bb_upperband"] - dataframe["bb_lowerband"]) / dataframe["sma5"] + + # dataframe["bb_width"] = ( + # (dataframe["bb_upperband"] - dataframe["bb_lowerband"]) / dataframe["bb_middleband"] + # ) + + # Calcul MACD + macd, macdsignal, macdhist = talib.MACD( + dataframe['mid'], + fastperiod=12, + slowperiod=26, + signalperiod=9 + ) + + # | Nom | Formule / définition | Signification | + # | ---------------------------- | ------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | + # | **MACD** (`macd`) | `EMA_fast - EMA_slow` (ex : 12-26 périodes) | Montre l’écart entre la moyenne courte et la moyenne longue.
- Positive → tendance haussière
- Négative → tendance baissière | + # | **Signal** (`macdsignal`) | `EMA_9(MACD)` | Sert de ligne de **signal de déclenchement**.
- Croisement du MACD au-dessus → signal d’achat
- Croisement du MACD en dessous → signal de vente | + # | **Histogramme** (`macdhist`) | `MACD - Signal` | Montre la **force et l’accélération** de la tendance.
- Positif et croissant → tendance haussière qui s’accélère
- Positif mais décroissant → ralentissement de la hausse
- Négatif et décroissant → baisse qui s’accélère
- Négatif mais croissant → ralentissement de la baisse | + + # Ajouter dans le dataframe + dataframe['macd'] = macd + dataframe['macdsignal'] = macdsignal + dataframe['macdhist'] = macdhist + + # Regarde dans le futur + # # --- Rendre relatif sur chaque série (-1 → 1) --- + # for col in ['macd', 'macdsignal', 'macdhist']: + # series = dataframe[col] + # valid = series[~np.isnan(series)] # ignorer NaN + # min_val = valid.min() + # max_val = valid.max() + # span = max_val - min_val if max_val != min_val else 1 + # dataframe[f'{col}_rel'] = 2 * ((series - min_val) / span) - 1 + # + # dataframe['tdc_macd'] = self.macd_tendance_int( + # dataframe, + # macd_col='macd_rel', + # signal_col='macdsignal_rel', + # hist_col='macdhist_rel' + # ) + + # --- pente brute --- + dataframe['slope'] = dataframe['sma24'].diff() + + # --- lissage EMA --- + dataframe['slope_smooth'] = dataframe['slope'].ewm(span=10, adjust=False).mean() + + # --- Volatilité normalisée --- + dataframe['atr'] = ta.volatility.AverageTrueRange( + high=dataframe['high'], low=dataframe['low'], close=dataframe['close'], window=14 + ).average_true_range() + dataframe['atr_norm'] = dataframe['atr'] / dataframe['close'] + + # --- Force de tendance --- + dataframe['adx'] = ta.trend.ADXIndicator( + high=dataframe['high'], low=dataframe['low'], close=dataframe['close'], window=14 + ).adx() + + # --- Volume directionnel (On Balance Volume) --- + dataframe['obv'] = ta.volume.OnBalanceVolumeIndicator(close=dataframe['mid'], volume=dataframe['volume']).on_balance_volume() + + # --- Volatilité récente (écart-type des rendements) --- + dataframe['vol_24'] = dataframe['percent'].rolling(24).std() + + # Compter les baisses / hausses consécutives + self.calculateDownAndUp(dataframe, limit=0.0001) + + # --- Filtrage des NaN initiaux --- + # dataframe = dataframe.dropna() + + dataframe['rsi_slope'] = dataframe['rsi'].diff(3) / 3 # vitesse moyenne du RSI + dataframe['adx_change'] = dataframe['adx'] - dataframe['adx'].shift(12) # évolution de la tendance + dataframe['volatility_ratio'] = dataframe['atr_norm'] / dataframe['bb_width'] + + dataframe["rsi_diff"] = dataframe["rsi"] - dataframe["rsi"].shift(3) + dataframe["slope_ratio"] = dataframe["sma5_deriv1"] / (dataframe["sma60_deriv1"] + 1e-9) + dataframe["divergence"] = (dataframe["rsi_deriv1"] * dataframe["sma5_deriv1"]) < 0 + + ########################### + + dataframe['volume_sma_deriv'] = dataframe['volume'] * dataframe['sma5_deriv1'] / (dataframe['volume'].rolling(5).mean()) + self.calculeDerivees(dataframe, 'volume', timeframe=timeframe, ema_period=12) + + self.setTrends(dataframe) + + return dataframe + + def feature_auc_scores(self, X, y): + aucs = {} + for col in X.columns: + try: + aucs[col] = roc_auc_score(y, X[col].ffill().fillna(0)) + except Exception: + aucs[col] = np.nan + return pd.Series(aucs).sort_values(ascending=False) + + def macd_tendance_int(self, dataframe: pd.DataFrame, + macd_col='macd', + signal_col='macdsignal', + hist_col='macdhist', + eps=0.0) -> pd.Series: + """ + Renvoie la tendance MACD sous forme d'entiers. + 2 : Haussier + 1 : Ralentissement hausse + 0 : Neutre + -1 : Ralentissement baisse + -2 : Baissier + """ + + # | Nom | Formule / définition | Signification | + # | ---------------------------- | ------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | + # | **MACD** (`macd`) | `EMA_fast - EMA_slow` (ex : 12-26 périodes) | Montre l’écart entre la moyenne courte et la moyenne longue.
- Positive → tendance haussière
- Négative → tendance baissière | + # | **Signal** (`macdsignal`) | `EMA_9(MACD)` | Sert de ligne de **signal de déclenchement**.
- Croisement du MACD au-dessus → signal d’achat
- Croisement du MACD en dessous → signal de vente | + # | **Histogramme** (`macdhist`) | `MACD - Signal` | Montre la **force et l’accélération** de la tendance.
- Positif et croissant → tendance haussière qui s’accélère
- Positif mais décroissant → ralentissement de la hausse
- Négatif et décroissant → baisse qui s’accélère
- Négatif mais croissant → ralentissement de la baisse | + + # | Situation | MACD | Signal | Hist | Interprétation | + # | -------------------------- | ---------- | --------- | -------- | ------------------------------------------ | + # | MACD > 0, Hist croissant | au-dessus | croissant | Haussier | Momentum fort → tendance haussière | + # | MACD > 0, Hist décroissant | au-dessus | en baisse | Momentum | La hausse ralentit, prudence | + # | MACD < 0, Hist décroissant | en dessous | en baisse | Baissier | Momentum fort → tendance baissière | + # | MACD < 0, Hist croissant | en dessous | en hausse | Rebond ? | La baisse ralentit → possible retournement | + + # Créer une série de 0 par défaut + tendance = pd.Series(0, index=dataframe.index) + + # Cas MACD > signal + mask_up = dataframe[macd_col] > dataframe[signal_col] + eps + mask_up_hist_pos = mask_up & (dataframe[hist_col] > 0) + mask_up_hist_neg = mask_up & (dataframe[hist_col] <= 0) + + tendance[mask_up_hist_pos] = 2 # Haussier + tendance[mask_up_hist_neg] = 1 # Ralentissement hausse + + # Cas MACD < signal + mask_down = dataframe[macd_col] < dataframe[signal_col] - eps + mask_down_hist_neg = mask_down & (dataframe[hist_col] < 0) + mask_down_hist_pos = mask_down & (dataframe[hist_col] >= 0) + + tendance[mask_down_hist_neg] = -2 # Baissier + tendance[mask_down_hist_pos] = -1 # Ralentissement baisse + + # Les NaN deviennent neutre + tendance[dataframe[[macd_col, signal_col, hist_col]].isna().any(axis=1)] = 0 + + return tendance + + def calculateDownAndUp(self, dataframe, limit=0.0001): + dataframe['down'] = dataframe['hapercent'] <= limit + dataframe['up'] = dataframe['hapercent'] >= limit + dataframe['down_count'] = - dataframe['down'].astype(int) * ( + dataframe['down'].groupby((dataframe['down'] != dataframe['down'].shift()).cumsum()).cumcount() + 1) + dataframe['up_count'] = dataframe['up'].astype(int) * ( + dataframe['up'].groupby((dataframe['up'] != dataframe['up'].shift()).cumsum()).cumcount() + 1) + # Créer une colonne vide + dataframe['down_pct'] = self.calculateUpDownPct(dataframe, 'down_count') + dataframe['up_pct'] = self.calculateUpDownPct(dataframe, 'up_count') + + def calculateDerivation(self, dataframe, window=12, suffixe='', timeframe='5m'): + dataframe[f"mid_smooth{suffixe}"] = dataframe['mid'].rolling(window).mean() + dataframe = self.calculeDerivees(dataframe, f"mid_smooth{suffixe}", timeframe=timeframe, ema_period=window) + return dataframe + + def calculeDerivees( + self, + dataframe: pd.DataFrame, + name: str, + suffixe: str = '', + window: int = 100, + coef: float = 0.15, + ema_period: int = 10, + verbose: bool = True, + timeframe: str = '5m' + ) -> pd.DataFrame: + """ + Calcule deriv1/deriv2 (relative simple), applique EMA, calcule tendency + avec epsilon adaptatif basé sur rolling percentiles. + """ + + d1_col = f"{name}{suffixe}_deriv1" + d2_col = f"{name}{suffixe}_deriv2" + factor1 = 100 * (ema_period / 5) + factor2 = 10 * (ema_period / 5) + + dataframe[f"{name}{suffixe}_inv"] = (dataframe[f"{name}{suffixe}"].shift(2) >= dataframe[f"{name}{suffixe}"].shift(1)) \ + & (dataframe[f"{name}{suffixe}"].shift(1) <= dataframe[f"{name}{suffixe}"]) + # --- Distance à la moyenne mobile --- + dataframe[f"{name}{suffixe}_dist"] = (dataframe['close'] - dataframe[f"{name}{suffixe}"]) / dataframe[f"{name}{suffixe}"] + + # dérivée relative simple + dataframe[d1_col] = 1000 * (dataframe[name] - dataframe[name].shift(1)) / dataframe[name].shift(1) + dataframe[d2_col] = dataframe[d1_col] - dataframe[d1_col].shift(1) + return dataframe + + def getOpenTrades(self): + # if len(self.trades) == 0: + self.trades = Trade.get_open_trades() + return self.trades + + def populate_buy_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame: + dataframe.loc[ + ( + (dataframe['lstm_pred'] > dataframe['mid']) + ), ['enter_long', 'enter_tag']] = (1, f"future") + + dataframe['test'] = np.where(dataframe['enter_long'] == 1, dataframe['close'] * 1.01, np.nan) + + if self.dp.runmode.value in ('backtest'): + dataframe.to_feather(f"user_data/backtest_results/{metadata['pair'].replace('/', '_')}_df.feather") + + return dataframe + + def populate_sell_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame: + + # dataframe.loc[ + # ( + # (dataframe['lstm_pred'] < 0) & (dataframe['hapercent'] < 0) + # ), ['exit_long', 'exit_tag']] = (1, f"sma60_future") + + # dataframe.loc[ + # ( + # ( + # ( + # (dataframe['mid_future_pred_cons'].shift(2) < dataframe['mid_future_pred_cons'].shift(1)) + # & (dataframe['mid_future_pred_cons'].shift(1) > dataframe['mid_future_pred_cons']) + # ) + # # | (dataframe['mid_smooth_12_deriv1'] < 0) + # ) + # & (dataframe['sma60_future_pred_cons'] < dataframe['sma60_future_pred_cons'].shift(1)) + # & (dataframe['hapercent'] < 0) + # ), ['exit_long', 'exit_tag']] = (1, f"sma60_future") + + # + # dataframe.loc[ + # ( + # ( + # (dataframe['mid_future_pred_cons'].shift(2) < dataframe['mid_future_pred_cons'].shift(1)) + # & (dataframe['mid_future_pred_cons'].shift(1) > dataframe['mid_future_pred_cons']) + # + # ) + # # & (dataframe['mid_future_pred_cons'] > dataframe['max12']) + # & (dataframe['hapercent'] < 0) + # + # ), ['exit_long', 'exit_tag']] = (1, f"max12") + + return dataframe + + def adjust_trade_position(self, trade: Trade, current_time: datetime, + current_rate: float, current_profit: float, min_stake: float, + max_stake: float, **kwargs): + # ne rien faire si ordre deja en cours + if trade.has_open_orders: + # print("skip open orders") + return None + if (self.wallets.get_available_stake_amount() < 10): # or trade.stake_amount >= max_stake: + return 0 + + dataframe, _ = self.dp.get_analyzed_dataframe(trade.pair, self.timeframe) + last_candle = dataframe.iloc[-1].squeeze() + before_last_candle = dataframe.iloc[-2].squeeze() + # prépare les données + current_time = current_time.astimezone(timezone.utc) + open_date = trade.open_date.astimezone(timezone.utc) + dispo = round(self.wallets.get_available_stake_amount()) + hours_since_first_buy = (current_time - trade.open_date_utc).seconds / 3600.0 + days_since_first_buy = (current_time - trade.open_date_utc).days + hours = (current_time - trade.date_last_filled_utc).total_seconds() / 3600.0 + count_of_buys = trade.nr_of_successful_entries + current_time_utc = current_time.astimezone(timezone.utc) + open_date = trade.open_date.astimezone(timezone.utc) + days_since_open = (current_time_utc - open_date).days + pair = trade.pair + profit = trade.calc_profit(current_rate) #round(current_profit * trade.stake_amount, 1) + last_lost = self.getLastLost(last_candle, pair) + pct_first = 0 + + total_counts = sum( + pair_data['count_of_buys'] for pair_data in self.pairs.values() if not self.getShortName(pair) == 'BTC') + + if self.pairs[pair]['first_buy']: + pct_first = self.getPctFirstBuy(pair, last_candle) + + pct = self.pct.value + if count_of_buys == 1: + pct_max = current_profit + else: + if self.pairs[trade.pair]['last_buy']: + pct_max = self.getPctLastBuy(pair, last_candle) + else: + pct_max = - pct + + if (self.getShortName(pair) == 'BTC') or count_of_buys <= 2: + lim = - pct - (count_of_buys * self.pct_inc.value) + else: + pct = 0.05 + lim = - pct - (count_of_buys * 0.0025) + + if (len(dataframe) < 1): + # print("skip dataframe") + return None + + if not self.should_enter_trade(pair, last_candle, current_time): + return None + + condition = (last_candle['enter_long'] and last_candle['stop_buying'] == False and last_candle['hapercent'] > 0) + # and last_candle['sma60_deriv1'] > 0 + # or last_candle['enter_tag'] == 'pct3' \ + # or last_candle['enter_tag'] == 'pct3' + + # if (self.getShortName(pair) != 'BTC' and count_of_buys > 3): + # condition = before_last_candle_24['mid_smooth_3'] > before_last_candle_12['mid_smooth_3'] and before_last_candle_12['mid_smooth_3'] < last_candle['mid_smooth_3'] #and last_candle['mid_smooth_3_deriv1'] < -1.5 + + limit_buy = 40 + if (count_of_buys < limit_buy) and condition and (pct_max < lim): + try: + + if self.pairs[pair]['has_gain'] and profit > 0: + self.pairs[pair]['force_sell'] = True + return None + + max_amount = self.config.get('stake_amount') * 2.5 + stake_amount = min(min(max_amount, self.wallets.get_available_stake_amount()), + self.adjust_stake_amount(pair, last_candle) * abs(last_lost / self.mise_factor_buy.value)) + + if stake_amount > 0: + trade_type = "Loss " + (last_candle['enter_tag'] if last_candle['enter_long'] == 1 else '') + self.pairs[trade.pair]['count_of_buys'] += 1 + self.pairs[pair]['total_amount'] += stake_amount + self.log_trade( + last_candle=last_candle, + date=current_time, + action="🟧 Loss -", + dispo=dispo, + pair=trade.pair, + rate=current_rate, + trade_type=trade_type, + profit=round(profit, 1), + buys=trade.nr_of_successful_entries + 1, + stake=round(stake_amount, 2) + ) + + self.pairs[trade.pair]['last_buy'] = current_rate + self.pairs[trade.pair]['max_touch'] = last_candle['close'] + self.pairs[trade.pair]['last_candle'] = last_candle + + # df = pd.DataFrame.from_dict(self.pairs, orient='index') + # colonnes_a_exclure = ['last_candle', 'stop', + # 'trade_info', 'last_date', 'expected_profit', 'last_count_of_buys', 'base_stake_amount', 'stop_buy'] + # df_filtered = df[df['count_of_buys'] > 0].drop(columns=colonnes_a_exclure) + # # df_filtered = df_filtered["first_buy", "last_max", "max_touch", "last_sell","last_buy", 'count_of_buys', 'current_profit'] + # + # print(df_filtered) + + return stake_amount + return None + except Exception as exception: + print(exception) + return None + + if (profit > self.pairs[pair]['previous_profit'] and profit > self.pairs[pair]['expected_profit'] and hours > 6 + # and last_candle['sma60_deriv1'] > 0 + and last_candle['max_rsi_12'] < 75 + # and last_candle['rsi_1d'] < 58 + # and last_candle['stop_buying'] == False + # and last_candle['mid_smooth_5_deriv1_1d'] > 0 + and self.wallets.get_available_stake_amount() > 0 + ): + try: + self.pairs[pair]['previous_profit'] = profit + stake_amount = min(self.wallets.get_available_stake_amount(), self.pairs[pair]['first_amount']) + if stake_amount > 0: + self.pairs[pair]['has_gain'] += 1 + + trade_type = 'Gain +' + (last_candle['enter_tag'] if last_candle['enter_long'] == 1 else '') + self.pairs[trade.pair]['count_of_buys'] += 1 + self.pairs[pair]['total_amount'] += stake_amount + self.log_trade( + last_candle=last_candle, + date=current_time, + action="🟡 Gain +", + dispo=dispo, + pair=trade.pair, + rate=current_rate, + trade_type=str(round(pct_max, 4)), + profit=round(profit, 1), + buys=trade.nr_of_successful_entries + 1, + stake=round(stake_amount, 2) + ) + self.pairs[trade.pair]['last_buy'] = current_rate + self.pairs[trade.pair]['max_touch'] = last_candle['close'] + self.pairs[trade.pair]['last_candle'] = last_candle + return stake_amount + return None + except Exception as exception: + print(exception) + return None + + return None + + def getPctFirstBuy(self, pair, last_candle): + return round((last_candle['close'] - self.pairs[pair]['first_buy']) / self.pairs[pair]['first_buy'], 3) + + def getPctLastBuy(self, pair, last_candle): + return round((last_candle['close'] - self.pairs[pair]['last_buy']) / self.pairs[pair]['last_buy'], 4) + + def adjust_stake_amount(self, pair: str, last_candle: DataFrame): + # Calculer le minimum des 14 derniers jours + nb_pairs = len(self.dp.current_whitelist()) + + base_stake_amount = self.config.get('stake_amount') / (self.mises.value) # * nb_pairs) # Montant de base configuré + + # factors = [1, 1.2, 1.3, 1.4] + if self.pairs[pair]['count_of_buys'] == 0: + factor = 1 #65 / min(65, last_candle['rsi_1d']) + if last_candle['open'] < last_candle['sma5'] and last_candle['mid_smooth_12_deriv1'] > 0: + factor = 2 + + adjusted_stake_amount = max(base_stake_amount / 5, base_stake_amount * factor) + else: + adjusted_stake_amount = self.pairs[pair]['first_amount'] + + if self.pairs[pair]['count_of_buys'] == 0: + self.pairs[pair]['first_amount'] = adjusted_stake_amount + + return adjusted_stake_amount + + def expectedProfit(self, pair: str, last_candle: DataFrame): + lim = 0.01 + pct = 0.002 + if (self.getShortName(pair) == 'BTC'): + lim = 0.005 + pct = 0.001 + pct_to_max = lim + pct * self.pairs[pair]['count_of_buys'] + expected_profit = lim * self.pairs[pair]['total_amount'] # min(3 * lim, max(lim, pct_to_max)) # 0.004 + 0.002 * self.pairs[pair]['count_of_buys'] #min(0.01, first_max) + + self.pairs[pair]['expected_profit'] = expected_profit + + return expected_profit + + def calculateUpDownPct(self, dataframe, key): + down_pct_values = np.full(len(dataframe), np.nan) + # Remplir la colonne avec les bons calculs + for i in range(len(dataframe)): + shift_value = abs(int(dataframe[key].iloc[i])) # Récupérer le shift actuel + if i - shift_value > 1: # Vérifier que le shift ne dépasse pas l'index + down_pct_values[i] = 100 * (dataframe['close'].iloc[i] - dataframe['close'].iloc[i - shift_value]) / \ + dataframe['close'].iloc[i - shift_value] + return down_pct_values + + @property + def protections(self): + return [ + { + "method": "CooldownPeriod", + "stop_duration_candles": 12 + } + # { + # "method": "MaxDrawdown", + # "lookback_period_candles": self.lookback.value, + # "trade_limit": self.trade_limit.value, + # "stop_duration_candles": self.protection_stop.value, + # "max_allowed_drawdown": self.protection_max_allowed_dd.value, + # "only_per_pair": False + # }, + # { + # "method": "StoplossGuard", + # "lookback_period_candles": 24, + # "trade_limit": 4, + # "stop_duration_candles": self.protection_stoploss_stop.value, + # "only_per_pair": False + # }, + # { + # "method": "StoplossGuard", + # "lookback_period_candles": 24, + # "trade_limit": 4, + # "stop_duration_candles": 2, + # "only_per_pair": False + # }, + # { + # "method": "LowProfitPairs", + # "lookback_period_candles": 6, + # "trade_limit": 2, + # "stop_duration_candles": 60, + # "required_profit": 0.02 + # }, + # { + # "method": "LowProfitPairs", + # "lookback_period_candles": 24, + # "trade_limit": 4, + # "stop_duration_candles": 2, + # "required_profit": 0.01 + # } + ] + + def get_stake_from_drawdown(self, pct: float, base_stake: float = 100.0, step: float = 0.04, growth: float = 1.15, + max_stake: float = 1000.0) -> float: + """ + Calcule la mise à allouer en fonction du drawdown. + + :param pct: Drawdown en pourcentage (ex: -0.12 pour -12%) + :param base_stake: Mise de base (niveau 0) + :param step: Espacement entre paliers (ex: tous les -4%) + :param growth: Facteur de croissance par palier (ex: 1.15 pour +15%) + :param max_stake: Mise maximale à ne pas dépasser + :return: Montant à miser + """ + if pct >= 0: + return base_stake + + level = int(abs(pct) / step) + stake = base_stake * (growth ** level) + return min(stake, max_stake) + + def polynomial_forecast(self, series: pd.Series, window: int = 20, degree: int = 2, steps=[12, 24, 36]): + """ + Calcule une régression polynomiale sur les `window` dernières valeurs de la série, + puis prédit les `n_future` prochaines valeurs. + + :param series: Série pandas (ex: dataframe['close']) + :param window: Nombre de valeurs récentes utilisées pour ajuster le polynôme + :param degree: Degré du polynôme (ex: 2 pour quadratique) + :param n_future: Nombre de valeurs futures à prédire + :return: tuple (poly_function, x_vals, y_pred), où y_pred contient les prédictions futures + """ + if len(series) < window: + raise ValueError("La série est trop courte pour la fenêtre spécifiée.") + + recent_y = series.iloc[-window:].values + x = np.arange(window) + + coeffs = np.polyfit(x, recent_y, degree) + poly = np.poly1d(coeffs) + + x_future = np.arange(window, window + len(steps)) + y_future = poly(x_future) + + # Affichage de la fonction + # print("Fonction polynomiale trouvée :") + # print(poly) + + current = series.iloc[-1] + count = 0 + for future_step in steps: # range(1, n_future + 1) + future_x = window - 1 + future_step + prediction = poly(future_x) + # series.loc[series.index[future_x], f'poly_pred_t+{future_step}'] = prediction + + # ➕ Afficher les prédictions + # print(f"{current} → t+{future_step}: x={future_x}, y={prediction:.2f}") + if prediction > 0: # current: + count += 1 + + return poly, x_future, y_future, count + + def should_enter_trade(self, pair: str, last_candle, current_time) -> bool: + limit = 3 + + # if self.pairs[pair]['stop'] and last_candle['max_rsi_12'] <= 60 and last_candle['trend_class'] == -1: + # dispo = round(self.wallets.get_available_stake_amount()) + # self.pairs[pair]['stop'] = False + # self.log_trade( + # last_candle=last_candle, + # date=current_time, + # action="🟢RESTART", + # dispo=dispo, + # pair=pair, + # rate=last_candle['close'], + # trade_type='', + # profit=0, + # buys=self.pairs[pair]['count_of_buys'], + # stake=0 + # ) + + # 🟢 Dérivée 1 > 0 et dérivée 2 > 0: tendance haussière qui s’accélère. + # 🟡 Dérivée 1 > 0 et dérivée 2 < 0: tendance haussière qui ralentit → essoufflement potentiel. + # 🔴 Dérivée 1 < 0 et dérivée 2 < 0: tendance baissière qui s’accélère. + # 🟠 Dérivée 1 < 0 et dérivée 2 > 0: tendance baissière qui ralentit → possible bottom. + + # if not pair.startswith('BTC'): + dispo = round(self.wallets.get_available_stake_amount()) + + # if self.pairs[pair]['stop'] \ + # and last_candle[f"{self.indic_1d_p.value}_deriv1"] >= self.indic_deriv1_1d_p_start.value \ + # and last_candle[f"{self.indic_1d_p.value}_deriv2"] >= self.indic_deriv2_1d_p_start.value: + # self.pairs[pair]['stop'] = False + # self.log_trade( + # last_candle=last_candle, + # date=current_time, + # action="🟢RESTART", + # dispo=dispo, + # pair=pair, + # rate=last_candle['close'], + # trade_type='', + # profit=0, + # buys=self.pairs[pair]['count_of_buys'], + # stake=0 + # ) + # else: + # if self.pairs[pair]['stop'] == False \ + # and last_candle[f"{self.indic_1d_p.value}_deriv1"] <= self.indic_deriv1_1d_p_stop.value \ + # and last_candle[f"{self.indic_1d_p.value}_deriv2"] <= self.indic_deriv2_1d_p_stop.value: + # self.pairs[pair]['stop'] = True + # # if self.pairs[pair]['current_profit'] > 0: + # # self.pairs[pair]['force_sell'] = True + # self.log_trade( + # last_candle=last_candle, + # date=current_time, + # action="🔴STOP", + # dispo=dispo, + # pair=pair, + # rate=last_candle['close'], + # trade_type='', + # profit=self.pairs[pair]['current_profit'], + # buys=self.pairs[pair]['count_of_buys'], + # stake=0 + # ) + # return False + # if self.pairs[pair]['stop']: + # return False + + return True + + # Filtrer les paires non-BTC + non_btc_pairs = [p for p in self.pairs if not p.startswith('BTC')] + + # Compter les positions actives sur les paires non-BTC + max_nb_trades = 0 + total_non_btc = 0 + max_pair = '' + limit_amount = 250 + max_amount = 0 + for p in non_btc_pairs: + max_nb_trades = max(max_nb_trades, self.pairs[p]['count_of_buys']) + max_amount = max(max_amount, self.pairs[p]['total_amount']) + + for p in non_btc_pairs: + if (max_nb_trades == self.pairs[p]['count_of_buys'] and max_nb_trades > limit): + # if (max_amount == self.pairs[p]['total_amount'] and max_amount > limit_amount): + max_pair = p + total_non_btc += self.pairs[p]['count_of_buys'] + + pct_max = self.getPctFirstBuy(pair, last_candle) # self.getPctLastBuy(pair, last_candle) + + if last_candle['mid_smooth_deriv1'] < -0.02: # and last_candle['mid_smooth_deriv2'] > 0): + return False + + self.should_enter_trade_count = 0 + + # if max_pair != pair and self.pairs[pair]['total_amount'] > 300: + # return False + + if (max_pair != '') & (self.pairs[pair]['count_of_buys'] >= limit): + trade = self.pairs[max_pair]['current_trade'] + current_time = current_time.astimezone(timezone.utc) + open_date = trade.open_date.astimezone(timezone.utc) + current_time_utc = current_time.astimezone(timezone.utc) + days_since_open = (current_time_utc - open_date).days + pct_max_max = self.getPctFirstBuy(max_pair, last_candle) + # print(f"days_since_open {days_since_open} max_pair={max_pair} pair={pair}") + return max_pair == pair or pct_max < - 0.25 or ( + pct_max_max < - 0.15 and max_pair != pair and days_since_open > 30) + else: + return True + + def setTrends(self, dataframe: DataFrame): + SMOOTH_WIN=10 + df = dataframe.copy() + + # # --- charger les données --- + # df['timestamp'] = pd.to_datetime(df['timestamp'], errors='coerce') + + # --- calcul SMA14 --- + # df['sma'] = talib.SMA(df, timeperiod=20) # ta.trend.sma_indicator(df['close'], 14) + + # --- pente brute --- + df['slope'] = df['sma12'].diff() + + # --- lissage EMA --- + df['slope_smooth'] = df['slope'].ewm(span=SMOOTH_WIN, adjust=False).mean() + + # df["slope_smooth"] = savgol_filter(df["slope_smooth"], window_length=21, polyorder=3) + + # --- normalisation relative --- + df['slope_norm'] = 10000 * df['slope_smooth'] / df['close'] + # df['slope_norm'].fillna(0, inplace=True) + df['slope_norm'] = df['slope_norm'].fillna(0) + dataframe['slope_norm'] = df['slope_norm'] + + def make_model(self, model_type="linear", degree=2, random_state=0): + model_type = model_type.lower() + if model_type == "linear": + return LinearRegression() + if model_type == "poly": + return make_pipeline(StandardScaler(), PolynomialFeatures(degree=degree, include_bias=False), + LinearRegression()) + if model_type == "svr": + return make_pipeline(StandardScaler(), SVR(kernel="rbf", C=1.0, epsilon=0.1)) + if model_type == "rf": + return RandomForestRegressor(n_estimators=100, random_state=random_state, n_jobs=1) + if model_type == "lgbm": + if not _HAS_LGBM: + raise RuntimeError("lightgbm n'est pas installé") + return LGBMRegressor(n_estimators=100, random_state=random_state) + raise ValueError(f"model_type inconnu: {model_type}") + + def calculateRegressionNew(self, df, indic, lookback=20, future_steps=5, model_type="linear"): + df = df.copy() + pred_col = f"{indic}_future_pred_cons" + df[pred_col] = np.nan + + X_idx = np.arange(lookback).reshape(-1, 1) + + values = df[indic].values + n = len(values) + + model = LinearRegression() + + for i in range(lookback, n - future_steps): + window = values[i - lookback:i] + + # cible = vraie valeur future + y_target = values[i + future_steps] + + if np.isnan(window).any() or np.isnan(y_target): + continue + + # entraînement + model.fit(X_idx, window) + + # prédiction de la valeur future + future_x = np.array([[lookback + future_steps - 1]]) + pred_future = model.predict(future_x)[0] + + # la prédiction concerne i + future_steps + df.iloc[i + future_steps, df.columns.get_loc(pred_col)] = pred_future + + return df + + # ========================================================== + # NOUVELLE VERSION : calcule AUSSI les dernières valeurs ! + # ========================================================== + def calculateRegression( + self, + df, + indic, + lookback=30, + future_steps=5, + model_type="linear", + degree=2, + weight_mode="exp", + weight_strength=2, + clip_k=2.0, + blend_alpha=0.7, + ): + + values = df[indic].values.astype(float) + n = len(values) + colname = f"{indic}_future_pred_cons" + + df[colname] = np.nan + + # pré-calcul des fenêtres + windows = np.lib.stride_tricks.sliding_window_view(values, lookback) + # windows[k] = valeurs de [k .. k+lookback-1] + + # indices valides d’entraînement + trainable_end = n - future_steps + + # créer une fois le modèle + model = self.make_model(model_type=model_type, degree=degree) + + # ================ + # BOUCLE TRAINING + # ================ + for i in range(lookback, trainable_end): + + window = values[i - lookback:i] + if np.isnan(window).any(): + continue + + # delta future réelle + y_target = values[i + future_steps] - values[i] + + # features = positions dans la fenêtre : 0..lookback-1 + X_window = np.arange(lookback).reshape(-1, 1) + + # sample weights + if weight_mode == "exp": + weights = np.linspace(0.1, 1, lookback) ** weight_strength + else: + weights = None + + # entraînement + try: + model.fit(X_window, window, sample_weight=weights) + except Exception: + model.fit(X_window, window) + + # prédiction de la valeur future (position lookback+future_steps-1) + y_pred_value = model.predict( + np.array([[lookback + future_steps - 1]]) + )[0] + + pred_delta = y_pred_value - values[i] + + # clipping par volatilité locale + local_std = np.std(window) + max_change = clip_k * (local_std if local_std > 0 else 1e-9) + pred_delta = np.clip(pred_delta, -max_change, max_change) + + # blend + final_pred_value = ( + blend_alpha * (values[i] + pred_delta) + + (1 - blend_alpha) * values[i] + ) + + df.iloc[i, df.columns.get_loc(colname)] = final_pred_value + + # ========================================================== + # 🔥 CALCUL DES DERNIÈRES VALEURS MANQUANTES 🔥 + # ========================================================== + + # Il reste les indices : [n - future_steps … n - 1] + for i in range(trainable_end, n): + + # fenêtre glissante de fin + if i - lookback < 0: + continue + + window = values[i - lookback:i] + if np.isnan(window).any(): + continue + + # features + X_window = np.arange(lookback).reshape(-1, 1) + + try: + model.fit(X_window, window) + except: + continue + + # prédiction d’une continuation locale : future_steps = 1 en fin + y_pred_value = model.predict(np.array([[lookback]]))[0] + pred_delta = y_pred_value - values[i - 1] + + final_pred_value = ( + blend_alpha * (values[i - 1] + pred_delta) + + (1 - blend_alpha) * values[i - 1] + ) + + df.iloc[i, df.columns.get_loc(colname)] = final_pred_value + + return df + + def kerasGenerateGraphs(self, dataframe): + model = self.model + self.kerasGenerateGraphModel(model) + self.kerasGenerateGraphPredictions(model, dataframe, self.lookback) + self.kerasGenerateGraphPoids(model) + + def kerasGenerateGraphModel(self, model): + plot_model( + model, + to_file=f"{self.path}/lstm_model.png", + show_shapes=True, + show_layer_names=True + ) + + def kerasGenerateGraphPredictions(self, model, dataframe, lookback): + preds = self.tensorFlowGeneratePredictions(dataframe, lookback, model) + + # plot + plt.figure(figsize=(36, 8)) + plt.plot(dataframe[self.indicator_target].values, label=self.indicator_target) + plt.plot(preds, label="lstm_pred") + plt.legend() + plt.savefig(f"{self.path}/lstm_predictions.png") + plt.close() + + def kerasGenerateGraphPoids(self, model): + for i, layer in enumerate(model.layers): + weights = layer.get_weights() # liste de tableaux numpy + + # Sauvegarde SAFE : tableau d’objets + np.save( + f"{self.path}/layer_{i}_weights.npy", + np.array(weights, dtype=object) + ) + + # Exemple lecture et heatmap + weights_layer0 = np.load( + f"{self.path}/layer_{i}_weights.npy", + allow_pickle=True + ) + + # Choisir un poids 2D + W = None + for w in weights_layer0: + if isinstance(w, np.ndarray) and w.ndim == 2: + W = w + break + + if W is None: + print(f"Aucune matrice 2D dans layer {i} (rien à afficher).") + return + + plt.figure(figsize=(8, 6)) + sns.heatmap(W, cmap="viridis") + plt.title(f"Poids 2D du layer {i}") + plt.savefig(f"{self.path}/layer{i}_weights.png") + plt.close() + + # ------------------- + # Entraînement + # ------------------- + def tensorFlowTrain(self, dataframe, future_steps=1, lookback=50, batch_size=32): + X_seq, y_seq = self.tensorFlowPrepareDataFrame(dataframe, future_steps, lookback) + + # 6) Modèle LSTM + self.model = Sequential([ + LSTM(64, return_sequences=False, input_shape=(lookback, X_seq.shape[2])), + Dense(32, activation="relu"), + Dense(1) + ]) + + self.model.compile(loss='mse', optimizer=Adam(learning_rate=1e-4)) + self.model.fit(X_seq, y_seq, epochs=self.epochs, batch_size=batch_size, verbose=1) + + # 7) Sauvegarde + self.model.save(f"{self.path}/lstm_model.keras") + # joblib.dump(self.scaler_X, f"{self.path}/lstm_scaler_X.pkl") + # joblib.dump(self.scaler_y, f"{self.path}/lstm_scaler_y.pkl") + + def tensorFlowPrepareDataFrame(self, dataframe, future_steps, lookback): + target = self.indicator_target + # 1) Détecter NaN / Inf et nettoyer + feature_columns = self.model_indicators # [col for col in dataframe.columns if col != target] + df = dataframe.copy() + df.replace([np.inf, -np.inf], np.nan, inplace=True) + df.dropna(subset=feature_columns + [target], inplace=True) + # 2) Séparer features et cible + X_values = df[feature_columns].values + y_values = df[target].values.reshape(-1, 1) + # 3) Gestion colonnes constantes (éviter division par zéro) + for i in range(X_values.shape[1]): + if X_values[:, i].max() == X_values[:, i].min(): + X_values[:, i] = 0.0 + if y_values.max() == y_values.min(): + y_values[:] = 0.0 + # 4) Normalisation + self.scaler_X = MinMaxScaler() + X_scaled = self.scaler_X.fit_transform(X_values) + + if self.y_no_scale: + y_scaled = y_values + else: + self.scaler_y = MinMaxScaler() + y_scaled = self.scaler_y.fit_transform(y_values) + + # 5) Création des fenêtres glissantes + X_seq = [] + y_seq = [] + for i in range(len(X_scaled) - lookback - future_steps): + X_seq.append(X_scaled[i:i + lookback]) + y_seq.append(y_scaled[i + lookback + future_steps]) + X_seq = np.array(X_seq) + y_seq = np.array(y_seq) + # Vérification finale + if np.isnan(X_seq).any() or np.isnan(y_seq).any(): + raise ValueError("X_seq ou y_seq contient encore des NaN") + if np.isinf(X_seq).any() or np.isinf(y_seq).any(): + raise ValueError("X_seq ou y_seq contient encore des Inf") + return X_seq, y_seq + + # ------------------- + # Prédiction + # ------------------- + def tensorFlowPredict(self, dataframe, future_steps=1, lookback=50): + feature_columns = self.model_indicators #[col for col in dataframe.columns if col != self.indicator_target] + # charger le modèle si pas déjà chargé + if self.model is None: + self.model = load_model(f"{self.path}/lstm_model.keras", compile=False) + # self.scaler_X = joblib.load(f"{self.path}/lstm_scaler_X.pkl") + # self.scaler_y = joblib.load(f"{self.path}/lstm_scaler_y.pkl") + + X_seq, y_seq = self.tensorFlowPrepareDataFrame(dataframe, future_steps, lookback) + + preds = self.tensorFlowGeneratePredictions(dataframe, lookback, self.model) + + dataframe["lstm_pred"] = preds + dataframe["lstm_pred_deriv1"] = dataframe["lstm_pred"].diff() + return dataframe + + def tensorFlowGeneratePredictions(self, dataframe, lookback, model): + # features = toutes les colonnes sauf la cible + feature_columns = self.model_indicators # [col for col in dataframe.columns if col != self.indicator_target] + X_values = dataframe[feature_columns].values + + # normalisation (avec le scaler utilisé à l'entraînement) + X_scaled = self.scaler_X.transform(X_values) + # créer les séquences glissantes + X_seq = [] + for i in range(len(X_scaled) - lookback): + X_seq.append(X_scaled[i:i + lookback]) + X_seq = np.array(X_seq) + + # prédictions + y_pred_scaled = model.predict(X_seq, verbose=0).flatten() + if self.y_no_scale: + y_pred = y_pred_scaled + else: + y_pred = self.scaler_y.inverse_transform(y_pred_scaled.reshape(-1, 1)).flatten() + # alignement avec les données + preds = [np.nan] * len(dataframe) + start = lookback + end = start + len(y_pred) + # preds[start:end] = y_pred[:end - start] + preds[start:start + len(y_pred)] = y_pred + return preds \ No newline at end of file