尝试解决hyperopt报错问题

freqtrade/templates/freqaiprimer.py

@@ -149,52 +149,35 @@ class FreqaiPrimer(IStrategy):
 
     def __init__(self, config: dict, *args, **kwargs):
         super().__init__(config, *args, **kwargs)
-        # 读取 Redis 配置
+        # 读取 Redis 配置（不存储客户端实例，避免序列化问题）
         self.redis_url = config.get('redis', {}).get('url', None)
         self.stats_logged = False
-
-        # 初始化 Redis 客户端（可选，失败时降级为本地缓存）
-        self.redis_client = None
+        
+        # 验证Redis配置但不创建持久化客户端
         if self.redis_url:
-            logger.info(f"尝试初始化 Redis 客户端，URL={self.redis_url}")
-            try:
-                import redis
-                self.redis_client = redis.from_url(self.redis_url)
-                logger.info(f"✅ 成功初始化 Redis 客户端，URL={self.redis_url}")
-
-                # 测试 Redis 连接
-                logger.debug("正在测试 Redis 连接...")
-                try:
-                    ping_result = self.redis_client.ping()
-                    if ping_result:
-                        logger.info("✅ Redis 连接测试成功: 收到 PONG 响应")
-                    else:
-                        logger.warning("⚠️ Redis 连接测试失败: 未收到 PONG 响应，降级为本地缓存")
-                        self.redis_client = None
-                except redis.exceptions.RedisError as e:
-                    logger.warning(f"⚠️ Redis PING 测试失败，错误: {e}，降级为本地缓存")
-                    self.redis_client = None
-
-            except redis.exceptions.ConnectionError as e:
-                logger.warning(f"⚠️ 无法连接到 Redis，URL={self.redis_url}, 错误: {e}，降级为本地缓存")
-                self.redis_client = None
-            except Exception as e:
-                logger.warning(f"⚠️ Redis 初始化失败，未知错误: {e}，降级为本地缓存")
-                self.redis_client = None
+            logger.info(f"Redis 配置已启用: {self.redis_url}")
         else:
             logger.info("ℹ️ 未找到 Redis 配置，使用本地缓存模式")
-        # 配置日志格式，包含时间戳
-        logging.basicConfig(
-            format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
-            level=logging.info,
-            datefmt='%Y-%m-%d %H:%M:%S,%f'[:-3]  # 毫秒精度
-        )
-        logger.info("✅ 策略已初始化，日志级别设置为 DEBUG")
+        
         self.trailing_stop_enabled = False
         self.pair_stats = {}
         self.fit_live_predictions_candles = self.freqai_info.get("fit_live_predictions_candles", 100)
         self.last_entry_time = {}  # 记录每个币种的最后入场时间
 
+    def _get_redis_client(self):
+        """延迟初始化Redis客户端，避免序列化问题"""
+        if not self.redis_url:
+            return None
+        
+        try:
+            import redis
+            client = redis.from_url(self.redis_url)
+            # 快速测试连接
+            client.ping()
+            return client
+        except Exception:
+            return None
+
     def feature_engineering_expand_all(self, dataframe: DataFrame, period: int, metadata: dict, **kwargs) -> DataFrame:
         dataframe["%-rsi-period"] = ta.RSI(dataframe, timeperiod=period)
         dataframe["%-sma-period"] = ta.SMA(dataframe, timeperiod=period)
@@ -1164,10 +1147,11 @@ class FreqaiPrimer(IStrategy):
         logger.debug(f"[{pair}] 本地缓存未命中：key={cache_key}")
 
         # 🎯 二级缓存：Redis检查
-        if self.redis_client:
+        redis_client = self._get_redis_client()
+        if redis_client:
             logger.debug(f"[{pair}] 尝试从 Redis 查询趋势得分，key={cache_key}")
             try:
-                cached_score = self.redis_client.get(cache_key)
+                cached_score = redis_client.get(cache_key)
                 if cached_score is not None:
                     score = float(cached_score)
                     # 同时写入本地缓存，加速后续访问
@@ -1177,10 +1161,9 @@ class FreqaiPrimer(IStrategy):
                     return score
                 else:
                     logger.info(f"[{pair}] 🔴 Redis 缓存未命中：key={cache_key}")
-            except redis.exceptions.RedisError as e:
+            except Exception as e:
                 logger.error(f"[{pair}] Redis 查询失败，key={cache_key}, 错误: {e}")
                 # Redis 失败时继续运行，降级为本地缓存
-                self.redis_client = None
 
         # 🎯 三级缓存：实时计算
         logger.info(f"[{pair}] 开始计算趋势得分 (时间戳: {timestamp})")
@@ -1191,12 +1174,13 @@ class FreqaiPrimer(IStrategy):
         # 将结果写入两级缓存
         self._local_cache[cache_key] = trend_score
         
-        if self.redis_client:
+        redis_client = self._get_redis_client()
+        if redis_client:
             logger.debug(f"[{pair}] 尝试将趋势得分写入 Redis，key={cache_key}, value={trend_score:.2f}")
             try:
-                self.redis_client.setex(cache_key, 86400, trend_score)
+                redis_client.setex(cache_key, 86400, trend_score)
                 logger.info(f"[{pair}] ✅ 成功将趋势得分存储到 Redis，key={cache_key}, value={trend_score:.2f}")
-            except redis.exceptions.RedisError as e:
+            except Exception as e:
                 logger.error(f"[{pair}] Redis 写入失败，key={cache_key}, 错误: {e}")
                 # Redis 失败时继续运行
 
@@ -1301,13 +1285,7 @@ class FreqaiPrimer(IStrategy):
                            f"计算次数: {stats['computes']}, "
                            f"总命中率: {stats['overall_hit_rate']:.1f}%")
         
-        # 清理Redis连接
-        if hasattr(self, 'redis_client') and self.redis_client:
-            try:
-                self.redis_client.close()
-                logger.info("✅ Redis连接已关闭")
-            except Exception as e:
-                logger.error(f"❌ 关闭Redis连接失败: {e}")
+        # 注意：由于使用延迟初始化，无需关闭持久化的Redis连接
 
     def detect_trend_status(self, dataframe: DataFrame, metadata: dict) -> str:
         """