PipeGraphPy 2.0.23__py3-none-win_amd64.whl → 3.0.4__py3-none-win_amd64.whl

PipeGraphPy/__init__.py

@@ -1,10 +1,23 @@
 # coding:utf-8
 
-__version__ = "2.0.23"
+__version__ = "3.0.4"
 
-from PipeGraphPy.core.graph import Graph, graph_predict, graph_evaluate, online_graph_evaluate, online_graph_predict, graph_run, graph_backtest
+from PipeGraphPy.core.graph import (
+    Graph,
+    graph_predict,
+    graph_evaluate,
+    graph_run,
+    graph_backtest,
+)
 from PipeGraphPy.core.module import Module
 from PipeGraphPy.core.node import Node
 
-__all__ = ['Node', 'Module', 'Graph', 'graph_predict', 'graph_evaluate',
-        'online_graph_evaluate', 'online_graph_predict', 'graph_run', 'graph_backtest']
+__all__ = [
+    "Node",
+    "Module",
+    "Graph",
+    "graph_predict",
+    "graph_evaluate",
+    "graph_run",
+    "graph_backtest",
+]

PipeGraphPy/__main__.py

@@ -0,0 +1,430 @@
+import argparse
+import json
+import os
+import sys
+import traceback
+
+import pandas as pd
+
+from PipeGraphPy import Graph
+from PipeGraphPy.config import settings
+from PipeGraphPy.core.graph import graph_evaluate
+from PipeGraphPy.logger import log
+from PipeGraphPy.storage import store
+from PipeGraphPy.utils.format import parse_params
+
+# 任务执行结果
+EXECUTE_SUCCESS = 1
+EXECUTE_FAIL = 0
+# result_file内容标记: 1成功, 0失败
+RESULT_FILE_SUCCESS = "1"
+RESULT_FILE_FAIL = "0"
+
+# 模型保存路径配置
+HOME = os.getcwd()
+RUN_MODEL_SAVE_PATH = (
+    os.environ.get("PGP_RUN_MODEL_SAVE_PATH")
+    or os.environ.get("PGP_MODEL_SAVE_PATH")
+    or ""
+)
+SDK_MODEL_SAVE_PATH = os.environ.get("PGP_SDK_MODEL_SAVE_PATH", "")
+PREDICT_MODEL_SAVE_PATH = os.environ.get("PGP_PREDICT_MODEL_SAVE_PATH", "")
+MODULES_CACHE_PATH = os.environ.get("PGP_MODULES_CACHE_PATH", "")
+settings.RUN_MODEL_SAVE_PATH = RUN_MODEL_SAVE_PATH or os.path.join(HOME, "models")
+settings.SDK_MODEL_SAVE_PATH = SDK_MODEL_SAVE_PATH or RUN_MODEL_SAVE_PATH
+settings.PREDICT_MODEL_SAVE_PATH = PREDICT_MODEL_SAVE_PATH or RUN_MODEL_SAVE_PATH
+settings.MODULES_CACHE_PATH = MODULES_CACHE_PATH or os.path.join(HOME, "modules")
+
+# 数据库配置
+USE_DB = os.environ.get("PGP_USE_DB") == "1"
+DB_DATABASE = os.environ.get("PGP_DB_DATABASE")
+DB_HOST = os.environ.get("PGP_DB_HOST")
+DB_PORT = int(os.environ.get("PGP_DB_PORT") or 0)
+DB_USER = os.environ.get("PGP_DB_USER")
+DB_PWD = os.environ.get("PGP_DB_PWD")
+DB_POOL_NAME = os.environ.get("PGP_DB_POOL_NAME", "mlf")
+
+log.init(pgp_handlers=["console"])
+
+if USE_DB:
+    import psycopg2
+
+    if not (DB_DATABASE and DB_HOST and DB_PORT and DB_USER and DB_PWD):
+        raise Exception("连接数据的配置不全")
+    settings.DATABASES_POOL = {
+        DB_POOL_NAME: {
+            "engine": psycopg2,
+            "dbtype": "postgresql",
+            "database": DB_DATABASE,
+            "host": DB_HOST,
+            "port": DB_PORT,
+            "user": DB_USER,
+            "password": DB_PWD,
+            "mincached": 0,
+            "maxconnections": 10,
+        },
+    }
+    settings.DATABASE_NAME = DB_POOL_NAME
+    from PipeGraphPy.db.models import db_init
+
+    db_init()
+
+def read_jsonfile(jsonfile_path):
+    """读取json内容
+    Args:
+        jsonfile_path: json文件路径
+    """
+    if not os.path.isfile(jsonfile_path):
+        raise Exception("模型json文件不存在: %s" % jsonfile_path)
+    if not str(jsonfile_path).endswith(".json"):
+        raise Exception("%s不是json文件" % jsonfile_path)
+    try:
+        with open(jsonfile_path, "r", encoding="utf-8") as f:
+            return json.load(f)
+    except Exception:
+        raise Exception("载入json文件报错: \n%s" % traceback.format_exc())
+
+
+def json_default(obj):
+    """json序列化兜底: numpy/pandas等类型转Python基础类型"""
+    for attr in ("item", "tolist"):
+        if hasattr(obj, attr):
+            try:
+                return getattr(obj, attr)()
+            except Exception:
+                pass
+    return str(obj)
+
+
+def save_output(output, filepath, index=True):
+    """保存output文件"""
+    if not isinstance(output, pd.DataFrame):
+        raise Exception("输出结果必须是DataFrame")
+    try:
+        output.to_csv(filepath, encoding="utf-8", index=index)
+    except Exception:
+        raise Exception("输出数据保存失败: \n%s" % traceback.format_exc())
+
+
+def write_result(result, result_file=None):
+    """写入运行结果(成功标记为1, 失败标记为0)"""
+    if result_file:
+        with open(result_file, "w", encoding="utf-8") as f:
+            f.write(str(result))
+
+
+class ModelExecutor:
+    all_jobs = ["run", "predict", "evaluate", "backtest"]
+    # 运行器级参数, 不传给模型执行
+    run_kw_skip_keys = ("evaluate_module", "load_ready_model", "is_backtest", "use_db")
+    default_evaluate_module = "CommonEvaluate"
+
+    def __init__(self, model_json, **kw):
+        self.params = kw
+        self.model_json_path = model_json
+        self.model_info = self.load_model_json()
+        self.run_kw = {}
+        self.result_path = kw.get("result_path")
+        self.output_path = kw.get("output_path")
+        self.log_path = kw.get("log_path")
+        self.init_params()
+
+    def load_model_json(self):
+        try:
+            model_json = read_jsonfile(self.model_json_path)
+            if not isinstance(model_json, dict):
+                raise Exception("model_json内的内容格式错误, 必须为json对象")
+            return model_json
+        except Exception as e:
+            raise Exception("model_json内的内容格式错误:\n%s" % e)
+
+    @staticmethod
+    def _to_score_df(score):
+        """把日评分统一转成DataFrame(dict/Series/DataFrame)"""
+        if isinstance(score, pd.DataFrame):
+            return score
+        if isinstance(score, pd.Series):
+            return score.to_frame("score")
+        if isinstance(score, dict):
+            return pd.DataFrame(
+                list(score.items()), columns=["time", "score"]
+            ).set_index("time")
+        return None
+
+    def update_model_score(self, score):
+        """把评估分数更新到模型json的score字段(其余内容不变)"""
+        self.model_info["score"] = score
+        tmp_path = "%s.tmp.%s" % (self.model_json_path, os.getpid())
+        try:
+            with open(tmp_path, "w", encoding="utf-8") as f:
+                json.dump(
+                    self.model_info,
+                    f,
+                    ensure_ascii=False,
+                    indent=4,
+                    default=json_default,
+                )
+            os.replace(tmp_path, self.model_json_path)
+        except Exception:
+            if os.path.isfile(tmp_path):
+                os.remove(tmp_path)
+            raise Exception("模型json的score更新失败: \n%s" % traceback.format_exc())
+
+    def init_params(self):
+        for path in (self.result_path, self.output_path, self.log_path):
+            if path and not os.path.exists(path):
+                os.makedirs(path, exist_ok=True)
+        if self.output_path and os.path.isdir(self.output_path):
+            settings.PREDICT_RESULT_SAVE_PATH = self.output_path
+
+        # params解析, params应传json格式的字符串
+        try:
+            params_str = self.params.get("params")
+            self.run_kw = json.loads(params_str) if params_str else {}
+        except Exception:
+            raise Exception("params传值不是json格式")
+
+        if self.model_info.get("params") and isinstance(self.model_info["params"], dict):
+            self.run_kw.update(self.model_info["params"])
+
+        self._parse_biz_info(self.model_info)
+
+        # 处理params_file
+        if self.params.get("params_file"):
+            try:
+                file_params = read_jsonfile(self.params["params_file"])
+                if not isinstance(file_params, dict):
+                    raise Exception("params_file内的内容格式错误")
+            except Exception as e:
+                raise Exception("params_file内的内容格式错误:\n%s" % e)
+            if file_params:
+                if file_params.get("biz_info"):
+                    self.model_info["biz_info"] = file_params.pop("biz_info")
+                    self._parse_biz_info(self.model_info)
+                if file_params.get("nodes") and isinstance(file_params["nodes"], list):
+                    self.model_info["nodes"] = file_params.pop("nodes")
+                if file_params.get("edges") and isinstance(file_params["edges"], list):
+                    self.model_info["edges"] = file_params.pop("edges")
+                self.run_kw.update(file_params)
+        self.run_kw = parse_params(self.run_kw)
+        # 模型json/params_file 中的 biz_info, 供预测/评估载入已训练模型时覆盖使用
+        self.biz_info = self.model_info.get("biz_info")
+
+    @staticmethod
+    def _parse_biz_info(model_info):
+        """从biz_info中取出biz_id"""
+        biz_info = model_info.get("biz_info")
+        if biz_info and biz_info.get("id"):
+            model_info["biz_id"] = biz_info["id"]
+
+    @classmethod
+    def _clean_run_kw(cls, run_kw):
+        """剔除运行器级参数, 避免透传给模型执行"""
+        return {k: v for k, v in run_kw.items() if k not in cls.run_kw_skip_keys}
+
+    def get_file_path(self, job, model_id):
+        """获取预测结果保存路径"""
+        filename = f"{job}_{model_id}"
+        output_file = result_file = None
+        if self.output_path:
+            if os.path.isfile(self.output_path):
+                output_file = self.output_path
+            elif os.path.isdir(self.output_path):
+                output_file = os.path.join(self.output_path, filename + ".csv")
+        if self.result_path:
+            if os.path.isfile(self.result_path):
+                result_file = self.result_path
+            elif os.path.isdir(self.result_path):
+                result_file = os.path.join(self.result_path, filename + ".txt")
+        return output_file, result_file
+
+    def get_score_file(self, job, model_id):
+        """获取评估分数保存路径, 优先output目录, 其次result目录"""
+        for base in (self.output_path, self.result_path):
+            if base and os.path.isdir(base):
+                return os.path.join(base, f"{job}_score_{model_id}.csv")
+        return None
+
+    def get_log_path(self, model_id):
+        """获取日志保存路径"""
+        log_file = None
+        if self.log_path:
+            if os.path.isfile(self.log_path):
+                log_file = self.log_path
+            elif os.path.isdir(self.log_path):
+                log_file = os.path.join(self.log_path, f"{model_id}.log")
+        return log_file
+
+    def init_log_file(self, model_id):
+        log_file = self.get_log_path(model_id)
+        if log_file:
+            log.init(
+                pgp_handlers=["console", "file"],
+                pgp_logfile=log_file,
+                replace_logger=True,
+            )
+
+    def run(self):
+        """执行训练"""
+        model_id = self.model_info["id"]
+        self.init_log_file(model_id)
+        log.info(">>训练开始<<")
+        result_file = None
+        try:
+            _, result_file = self.get_file_path("run", model_id)
+            model = Graph.create_by_dict(self.model_info)
+            log.info("@@开始训练:模型id:%s@@" % model.id)
+            # biz_info 优先取 -p 传入, 其次取模型json/params_file 中的
+            run_kw = dict(self.run_kw)
+            biz_info = run_kw.pop("biz_info", None) or self.biz_info
+            model.run(biz_info=biz_info, **self._clean_run_kw(run_kw))
+            store.save_graph(model)
+            if result_file:
+                write_result(RESULT_FILE_SUCCESS, result_file)
+            log.info("@@结束训练:模型id:%s@@" % model.id)
+            log.info(">>训练执行成功<<")
+            return EXECUTE_SUCCESS
+        except Exception:
+            log.error(traceback.format_exc())
+            if result_file:
+                write_result(RESULT_FILE_FAIL, result_file)
+            log.error("@@训练报错:模型id:%s@@" % model_id)
+            log.error(">>训练执行失败<<")
+            return EXECUTE_FAIL
+
+    def predict(self):
+        """执行预测"""
+        model_id = self.model_info["id"]
+        self.init_log_file(model_id)
+        log.info(">>预测开始<<")
+        result_file = None
+        try:
+            output_file, result_file = self.get_file_path("predict", model_id)
+            log.info("@@开始预测:模型id:%s@@" % model_id)
+            graph_model = store.load_graph(model_id)
+            # biz_info 优先取 -p 传入, 其次取模型json/params_file 中的
+            run_kw = dict(self.run_kw)
+            biz_info = run_kw.pop("biz_info", None) or self.biz_info
+            predict_res = graph_model.predict(
+                biz_info=biz_info, **self._clean_run_kw(run_kw)
+            )
+            if result_file:
+                write_result(RESULT_FILE_SUCCESS, result_file)
+            if output_file:
+                log.info("保存输出结果:%s" % model_id)
+                save_output(predict_res, output_file)
+            log.info("@@结束预测:模型id:%s@@" % model_id)
+            log.info(">>预测执行成功<<")
+            return EXECUTE_SUCCESS
+        except Exception:
+            log.error(traceback.format_exc())
+            if result_file:
+                write_result(RESULT_FILE_FAIL, result_file)
+            log.error("@@预测报错:模型id:%s@@" % model_id)
+            log.error(">>预测执行失败<<")
+            return EXECUTE_FAIL
+
+    def evaluate(self, is_backtest=False):
+        """执行评估/回测"""
+        job_type = "回测" if is_backtest else "评估"
+        job = "backtest" if is_backtest else "evaluate"
+        model_id = self.model_info["id"]
+        # 使用数据库时日志由评估组件记录, 不额外写文件日志
+        if not USE_DB:
+            self.init_log_file(model_id)
+        log.info(f">>{job_type}开始<<")
+        result_file = None
+        try:
+            output_file, result_file = self.get_file_path(job, model_id)
+            score_file = self.get_score_file(job, model_id)
+            log.info("@@开始%s:模型id:%s@@" % (job_type, model_id))
+            # 评估参数
+            run_kw = dict(self.run_kw)
+            evaluate_module_cls = run_kw.pop("evaluate_module", None) or self.default_evaluate_module
+            # 是否训练, 默认需要训练
+            load_ready_model = run_kw.pop("load_ready_model", True) if run_kw.get("load_ready_model") is not None else True
+            # biz_info 优先取 -p 传入, 其次取模型json/params_file 中的
+            biz_info = run_kw.pop("biz_info", None) or self.biz_info
+            # 剔除is_backtest/use_db等运行器级参数, 避免重复传参
+            run_kw = self._clean_run_kw(run_kw)
+            if not load_ready_model:
+                model = Graph.create_by_dict(self.model_info)
+            else:
+                try:
+                    model = store.load_graph(model_id)
+                except Exception as e:
+                    raise Exception("载入建模对象的模型错误\n%s" % e)
+
+            evaluate_res = graph_evaluate(
+                model_id,
+                model,
+                is_backtest=is_backtest,
+                use_db=USE_DB,
+                biz_info=biz_info,
+                evaluate_module_cls=evaluate_module_cls,
+                **run_kw,
+            )
+            daily_score = None
+            if len(evaluate_res) == 3:
+                evaluate_data, evaluate_score, daily_score = evaluate_res
+            else:
+                evaluate_data, evaluate_score = evaluate_res
+            score_df = self._to_score_df(daily_score)
+            if score_file and score_df is not None:
+                log.info("保存评估分数:%s" % model_id)
+                save_output(score_df, score_file)
+            elif not USE_DB:
+                log.warning("未配置可写的output_path/result_path或日评分为空, 评估分数未落盘:%s" % model_id)
+            if output_file:
+                log.info("保存评估数据:%s" % model_id)
+                save_output(evaluate_data, output_file)
+            # 评估分数回写模型json(仅更新score字段)
+            if not is_backtest:
+                self.update_model_score(evaluate_score)
+                log.info("更新模型json分数:%s" % model_id)
+            if result_file:
+                write_result(RESULT_FILE_SUCCESS, result_file)
+            log.info("@@结束%s:模型id:%s@@" % (job_type, model_id))
+            log.info(f">>{job_type}执行成功<<")
+            return EXECUTE_SUCCESS
+        except Exception:
+            log.error(traceback.format_exc())
+            if result_file:
+                write_result(RESULT_FILE_FAIL, result_file)
+            log.error("@@%s报错:模型id:%s@@" % (job_type, model_id))
+            log.error(f">>{job_type}执行失败<<")
+            return EXECUTE_FAIL
+
+    def backtest(self):
+        return self.evaluate(is_backtest=True)
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("-j", "--jobs", required=True, help="任务类型:run,predict,evaluate,backtest执行多个需要-分割")
+    parser.add_argument("-m", "--model", required=True, help="模型json文件，要执行的model路径")
+    parser.add_argument("-o", "--output_path", required=False, help="输出数据文件路径, csv文件")
+    parser.add_argument("-r", "--result_path", required=False, help="模型运行结果文件路径")
+    parser.add_argument("-l", "--log_path", required=False, help="日志文件路径")
+    parser.add_argument("-p", "--params", required=False, help="额外参数, json格式的字符串")
+    parser.add_argument("-pf", "--params_file", required=False, help="额外参数, json文件的路径")
+    args = parser.parse_args()
+    job_flow = args.jobs.split("-")
+    not_exist_jobs = set(job_flow) - set(ModelExecutor.all_jobs)
+    if not_exist_jobs:
+        raise Exception(f"不存在这些任务:{not_exist_jobs}")
+    ins = ModelExecutor(
+        args.model,
+        output_path=args.output_path,
+        result_path=args.result_path,
+        log_path=args.log_path,
+        params=args.params,
+        params_file=args.params_file,
+    )
+    failed = False
+    for job in job_flow:
+        func = getattr(ins, job)
+        if func() != EXECUTE_SUCCESS:
+            failed = True
+            break
+    sys.exit(1 if failed else 0)

PipeGraphPy/common.py

@@ -1,4 +1,5 @@
 # 本文件存储通用变量或全局变量
 
-
+# 全局图注册表: {graph_id: Graph}, 供 Anchor/tools 等按图id反查图对象。
+# 注意: 图对象会常驻内存, 生命周期与进程一致。
 multi_graph = dict()

PipeGraphPy/config/__init__.py

@@ -16,7 +16,7 @@ from PipeGraphPy.config import default_settings
 from PipeGraphPy.utils.functional import LazyObject, empty
 from dbpoolpy import settings as dbsettings
 
-os.environ['PGP_SETTINGS_MODULE'] = 'PipeGraphPy.config.custom'
+os.environ.setdefault('PGP_SETTINGS_MODULE', 'PipeGraphPy.config.custom')
 
 ENVIRONMENT_VARIABLE = "PGP_SETTINGS_MODULE"
 
@@ -67,7 +67,7 @@ class LazySettings(LazyObject):
                 "or call settings.configure() before accessing settings."
                 % (desc, ENVIRONMENT_VARIABLE))
 
-        # self._wrapped = Settings(settings_module)
+        self._wrapped = Settings(settings_module)
 
     def __repr__(self):
         # Hardcode the class name as otherwise it yields 'Settings'.
@@ -273,4 +273,4 @@ class UserSettingsHolder:
         }
 
 
-settings = default_settings
+settings = LazySettings()

PipeGraphPy/config/default_settings.py

@@ -18,12 +18,15 @@ class PGP_ENV:
     NONE = "none"   # 非执行训练和预测环境
 
 
+MODEL_LOG_SAVE_TYPE = os.environ.get("PGP_MODEL_LOG_SAVE_TYPE", 'file') # file, db
+MODEL_LOG_SAVE_PATH = os.environ.get("PGP_MODEL_LOG_SAVE_PATH", '')
 DEBUG = False if str(os.environ.get("PGP_NOT_DEBUG")) == "1" else True
 ISDEV = False if str(os.environ.get("PGP_NOT_DEV")) == "1" else True
 ISJUPYTER = True if str(os.environ.get("PGP_JUPYTER")) == "1" else False
-RUN_MODEL_SAVE_PATH = os.environ.get("PGP_RUN_MODEL_SAVE_PATH", "")
-SDK_MODEL_SAVE_PATH = os.environ.get("PGP_SDK_MODEL_SAVE_PATH", "")
-PREDICT_MODEL_SAVE_PATH = os.environ.get("PGP_PREDICT_MODEL_SAVE_PATH", '')
+RUN_PERMISSION = True if str(os.environ.get("PGP_RUN_PERMISSION")) == "1" else False
+RUN_MODEL_SAVE_PATH = os.environ.get("PGP_RUN_MODEL_SAVE_PATH") or os.environ.get("PGP_MODEL_SAVE_PATH")
+SDK_MODEL_SAVE_PATH = os.environ.get("PGP_SDK_MODEL_SAVE_PATH") or os.environ.get("PGP_MODEL_SAVE_PATH")
+PREDICT_MODEL_SAVE_PATH = os.environ.get("PGP_PREDICT_MODEL_SAVE_PATH") or os.environ.get("PGP_MODEL_SAVE_PATH")
 PREDICT_RESULT_SAVE_PATH = os.environ.get("PGP_PREDICT_RESULT_SAVE_PATH", '')
 BACKTEST_RESULT_SAVE_PATH = os.environ.get("PGP_BACKTEST_RESULT_SAVE_PATH", '')
 RUN_RESULT_SAVE_PATH = os.environ.get("PGP_RUN_RESULT_SAVE_PATH", '')
@@ -34,7 +37,7 @@ REDIS_HOST = os.environ.get("REDIS_HOST", '39.105.185.60')
 REDIS_PORT = int(os.environ.get("REDIS_PORT", '6371'))
 PGP_DB_HOST = os.environ.get("PGP_DB_HOST", '39.105.185.60')
 PGP_DB_PORT = int(os.environ.get("PGP_DB_PORT", '33061'))
-AMQP_URL = os.environ.get("PGP_AMQP_URL", 'amqp://mlf:mlfadmin@172.18.59.136:32662/mlf_vhost')
+AMQP_URL = os.environ.get("PGP_AMQP_URL", 'amqp://mlf:mlfadmin@47.94.251.175:6296/mlf_vhost')
 RUN_TIMEOUT = int(os.environ.get("RUN_TIMEOUT", 60 * 60 * 6))   # 训练超时2小时
 PREDICT_TIMEOUT = int(os.environ.get("PREDICT_TIMEOUT", 60 * 10))   # 预测超时5分钟
 RT_DB_CONNECTOR = os.environ.get("RT_DB_CONNECTOR", '')
@@ -43,19 +46,18 @@ DEPLOYMENT_ENV = os.environ.get("PGP_DEPLOYMENT_ENV", "none")
 RUN_ENV = os.environ.get("PGP_RUN_ENV", 'test')    # 运行环境, test, online, dev, sdk, image
 DBPOOL_SERVER_NAME = os.environ.get("PGP_DBPOOL_SERVER_NAME", 'mlf')
 PGP_PDB_PORT = int(os.environ.get("PGP_PDB_PORT", '6688'))
-PREDICT_OUTPUT_EXCHANGE = os.environ.get("PGP_PREDICT_OUTPUT_EXCHANGE", "PipeGraphPy_predict_output_e")
-PREDICT_OUTPUT_ROUTING_KEY = os.environ.get("PGP_PREDICT_OUTPUT_ROUTING_KEY", "PipeGraphPy_predict_output_k")
-PREDICT_OUTPUT_QUEUE = os.environ.get("PGP_PREDICT_OUTPUT_QUEUE", "PipeGraphPy_predict_output_q")
 
 # 模型保存配置
 if DEPLOYMENT_ENV == PGP_ENV.SDK:
-    HOME_CACHE_PATH = os.path.join(os.path.expanduser('~'), '.cache', 'PipeGraphPy','sdk')
+    HOME_CACHE_PATH = os.path.expanduser('~/.cache/PipeGraphPy/sdk/')
     if not SDK_MODEL_SAVE_PATH:
         SDK_MODEL_SAVE_PATH = os.path.join(HOME_CACHE_PATH, "sdk")
     if not os.path.exists(SDK_MODEL_SAVE_PATH):
         os.makedirs(SDK_MODEL_SAVE_PATH)
 else:
-    HOME_CACHE_PATH = os.path.join(os.path.expanduser('~'), '.cache', 'PipeGraphPy')
+    HOME_CACHE_PATH = os.path.expanduser('~/.cache/PipeGraphPy/')
+if not MODEL_LOG_SAVE_PATH:
+    MODEL_LOG_SAVE_PATH = os.path.join(HOME_CACHE_PATH, "logs")
 if not RUN_MODEL_SAVE_PATH:
     RUN_MODEL_SAVE_PATH = os.path.join(HOME_CACHE_PATH, "models")
 if not PREDICT_MODEL_SAVE_PATH:
@@ -78,7 +80,24 @@ if not os.path.exists(MODULES_CACHE_PATH):
     with open(_init_file, "w") as f:
         f.write("#")
 sys.path.append(os.path.dirname(MODULES_CACHE_PATH))
-MODEL_SAVE_NAME = "graph_model_{graph_id}_{object_id}"
+
+# 确保所有目录存在
+_dir_vars = [
+    MODEL_LOG_SAVE_PATH,
+    RUN_MODEL_SAVE_PATH,
+    SDK_MODEL_SAVE_PATH,
+    PREDICT_MODEL_SAVE_PATH,
+    PREDICT_RESULT_SAVE_PATH,
+    BACKTEST_RESULT_SAVE_PATH,
+    RUN_RESULT_SAVE_PATH,
+    EVALUATE_RESULT_SAVE_PATH,
+    TEMP_SAVE_PATH,
+]
+for _dir in _dir_vars:
+    if _dir and not os.path.exists(_dir):
+        os.makedirs(_dir)
+
+MODEL_SAVE_NAME = "graph_model_{graph_id}"
 ALGO_MODEL_SAVE_NAME = "algo_model_{graph_id}_{node_id}_{algo_mod_type}_{idx}"
 
 # 运行模式 1: 包引用 2：grpc
@@ -123,5 +142,5 @@ DATABASE_DB_NAME = None
 
 
 # SDK是否显示log日志
-SDK_CLOSE_LOG = True
+SDK_SHOW_LOG = False