init: Analyze-stroke MCP + security demo

.gitattributes

@@ -0,0 +1,35 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

Analyze-stroke/mcp_output/README_MCP.md

@@ -0,0 +1,88 @@
+# Analyze Stroke Plugin
+
+## Overview
+
+The Analyze Stroke Plugin is a comprehensive tool designed to facilitate the analysis of stroke data using various machine learning and statistical methods. This plugin provides functionalities for data loading, feature selection, dimensionality reduction, and causal analysis, with options for visualization.
+
+The project is hosted on GitHub and can be accessed via the following repository: [Analyze Stroke Repository](https://github.com/ghh1125/Analyze-stroke).
+
+## Installation
+
+To set up the Analyze Stroke Plugin, follow these steps:
+
+1. **Clone the Repository:**
+
+   ```bash
+   git clone https://github.com/ghh1125/Analyze-stroke.git
+   cd Analyze-stroke
+   ```
+
+2. **Set Up the Environment:**
+
+   The project includes an `environment.yml` file for setting up the necessary Python environment. Use the following command to create the environment:
+
+   ```bash
+   conda env create -f environment.yml
+   ```
+
+3. **Activate the Environment:**
+
+   ```bash
+   conda activate analyze-stroke
+   ```
+
+## Usage
+
+The Analyze Stroke Plugin provides several command-line interface (CLI) commands to execute different analysis processes. Below are the primary commands available:
+
+- **Run All Causal Analysis with Visualization:**
+
+  This command executes all causal analysis processes and includes visualization of the results.
+
+  ```bash
+  python run_all_causal.py
+  ```
+
+- **Run All Causal Analysis without Visualization:**
+
+  This command executes all causal analysis processes without generating visual outputs.
+
+  ```bash
+  python run_all_causal_wo_draw.py
+  ```
+
+## Tool Endpoints
+
+The following modules are included in the Analyze Stroke Plugin:
+
+- `causal_module.py`: Handles causal analysis processes.
+- `data_loader.py`: Manages data loading operations.
+- `dim_reduction.py`: Performs dimensionality reduction.
+- `feature_selection.py`: Conducts feature selection.
+- `main.py`: Main entry point for executing the plugin.
+- `models.py`: Contains machine learning models used in the analysis.
+- `plot_utils.py`: Provides utilities for plotting and visualization.
+- `test_env.py`: Used for testing the environment setup.
+
+## Dependencies
+
+The Analyze Stroke Plugin requires the following dependencies:
+
+- Required: `numpy`, `pandas`, `scikit-learn`, `matplotlib`
+- Optional: `seaborn` (for enhanced visualization)
+
+## Notes and Troubleshooting
+
+- Ensure that all dependencies are correctly installed by using the provided `environment.yml` file.
+- If you encounter issues with visualization, verify that `matplotlib` and `seaborn` are properly installed.
+- For any issues related to data loading or processing, check the data format and ensure compatibility with the plugin's requirements.
+
+## Contributing
+
+Contributions to the Analyze Stroke Plugin are welcome. Please fork the repository and submit a pull request with your changes. Ensure that your code adheres to the project's coding standards and includes appropriate documentation.
+
+## License
+
+This project is licensed under the MIT License. See the [LICENSE](https://github.com/ghh1125/Analyze-stroke/blob/main/LICENSE) file for more details.
+
+For further information, please visit the [GitHub repository](https://github.com/ghh1125/Analyze-stroke).

Analyze-stroke/mcp_output/analysis.json

@@ -0,0 +1,181 @@
+{
+  "summary": {
+    "repository_url": "https://github.com/ghh1125/Analyze-stroke",
+    "summary": "Imported via zip fallback, file count: 11",
+    "file_tree": {
+      "causal_module.py": {
+        "size": 3829
+      },
+      "data_loader.py": {
+        "size": 1789
+      },
+      "dim_reduction.py": {
+        "size": 5137
+      },
+      "environment.yml": {
+        "size": 7791
+      },
+      "feature_selection.py": {
+        "size": 5748
+      },
+      "main.py": {
+        "size": 5655
+      },
+      "models.py": {
+        "size": 7035
+      },
+      "plot_utils.py": {
+        "size": 7901
+      },
+      "run_all_causal.py": {
+        "size": 3386
+      },
+      "run_all_causal_wo_draw.py": {
+        "size": 901
+      },
+      "test_env.py": {
+        "size": 987
+      }
+    },
+    "processed_by": "zip_fallback",
+    "success": true
+  },
+  "structure": {
+    "packages": []
+  },
+  "dependencies": {
+    "has_environment_yml": true,
+    "has_requirements_txt": false,
+    "pyproject": false,
+    "setup_cfg": false,
+    "setup_py": false
+  },
+  "entry_points": {
+    "imports": [],
+    "cli": [],
+    "modules": []
+  },
+  "llm_analysis": {
+    "core_modules": [
+      {
+        "package": "https://github.com/ghh1125/Analyze-stroke/causal_module.py",
+        "module": "causal_module",
+        "functions": [
+          "function1",
+          "function2"
+        ],
+        "classes": [
+          "CausalClass1",
+          "CausalClass2"
+        ],
+        "description": "Handles causal inference and analysis for stroke data."
+      },
+      {
+        "package": "https://github.com/ghh1125/Analyze-stroke/data_loader.py",
+        "module": "data_loader",
+        "functions": [
+          "load_data",
+          "preprocess_data"
+        ],
+        "classes": [
+          "DataLoader"
+        ],
+        "description": "Responsible for loading and preprocessing stroke datasets."
+      },
+      {
+        "package": "https://github.com/ghh1125/Analyze-stroke/dim_reduction.py",
+        "module": "dim_reduction",
+        "functions": [
+          "reduce_dimensions"
+        ],
+        "classes": [
+          "DimReducer"
+        ],
+        "description": "Implements dimensionality reduction techniques."
+      },
+      {
+        "package": "https://github.com/ghh1125/Analyze-stroke/feature_selection.py",
+        "module": "feature_selection",
+        "functions": [
+          "select_features"
+        ],
+        "classes": [
+          "FeatureSelector"
+        ],
+        "description": "Contains methods for feature selection in datasets."
+      },
+      {
+        "package": "https://github.com/ghh1125/Analyze-stroke/models.py",
+        "module": "models",
+        "functions": [
+          "train_model",
+          "evaluate_model"
+        ],
+        "classes": [
+          "ModelTrainer",
+          "ModelEvaluator"
+        ],
+        "description": "Defines machine learning models and their training/evaluation."
+      },
+      {
+        "package": "https://github.com/ghh1125/Analyze-stroke/plot_utils.py",
+        "module": "plot_utils",
+        "functions": [
+          "plot_results"
+        ],
+        "classes": [],
+        "description": "Utility functions for plotting results and visualizations."
+      }
+    ],
+    "cli_commands": [
+      {
+        "name": "run_all_causal",
+        "module": "https://github.com/ghh1125/Analyze-stroke/run_all_causal.py",
+        "description": "Executes all causal analysis processes with visualization."
+      },
+      {
+        "name": "run_all_causal_wo_draw",
+        "module": "https://github.com/ghh1125/Analyze-stroke/run_all_causal_wo_draw.py",
+        "description": "Executes all causal analysis processes without visualization."
+      }
+    ],
+    "import_strategy": {
+      "primary": "import",
+      "fallback": "cli",
+      "confidence": 0.85
+    },
+    "dependencies": {
+      "required": [
+        "numpy",
+        "pandas",
+        "scikit-learn",
+        "matplotlib"
+      ],
+      "optional": [
+        "seaborn"
+      ]
+    },
+    "risk_assessment": {
+      "import_feasibility": 0.8,
+      "intrusiveness_risk": "medium",
+      "complexity": "medium"
+    }
+  },
+  "deepwiki_analysis": {
+    "repo_url": "https://github.com/ghh1125/Analyze-stroke",
+    "repo_name": "Analyze-stroke",
+    "content": null,
+    "model": "gpt-4o",
+    "source": "selenium",
+    "success": true
+  },
+  "deepwiki_options": {
+    "enabled": true,
+    "model": "gpt-4o"
+  },
+  "risk": {
+    "import_feasibility": 0.8,
+    "intrusiveness_risk": "medium",
+    "complexity": "medium"
+  }
+}

Analyze-stroke/mcp_output/env_info.json

@@ -0,0 +1,17 @@
+{
+  "environment": {
+    "type": "conda",
+    "name": "Analyze-stroke_366682_env",
+    "files": {
+      "environment_yml": "/export/project/shiweijie/ghh/LLM_MCP_RAG/MCP-agent-github-repo-output/workspace/Analyze-stroke/source/environment.yml"
+    },
+    "python": "3.10",
+    "exec_prefix": []
+  },
+  "original_tests": {
+    "passed": false,
+    "report_path": null
+  },
+  "timestamp": 1765367116.7647827,
+  "conda_available": true
+}

Analyze-stroke/mcp_output/mcp_logs/llm_statistics.json

@@ -0,0 +1,11 @@
+{
+  "total_calls": 7,
+  "failed_calls": 0,
+  "retry_count": 0,
+  "total_prompt_tokens": 6752,
+  "total_completion_tokens": 3421,
+  "total_tokens": 10173,
+  "average_prompt_tokens": 964.5714285714286,
+  "average_completion_tokens": 488.7142857142857,
+  "average_tokens": 1453.2857142857142
+}

Analyze-stroke/mcp_output/mcp_logs/run_log.json

@@ -0,0 +1,74 @@
+{
+  "timestamp": 1765367363.30327,
+  "node": "RunNode",
+  "test_result": {
+    "passed": false,
+    "report_path": null,
+    "stdout": "",
+    "stderr": "ERROR conda.cli.main_run:execute(41): `conda run python mcp_output/start_mcp.py` failed. (See above for error)\nTraceback (most recent call last):\n  File \"/export/project/shiweijie/ghh/LLM_MCP_RAG/MCP-agent-github-repo-output/workspace/Analyze-stroke/mcp_output/start_mcp.py\", line 17, in <module>\n    from mcp_service import create_app\n  File \"/export/project/shiweijie/ghh/LLM_MCP_RAG/MCP-agent-github-repo-output/workspace/Analyze-stroke/mcp_output/mcp_plugin/mcp_service.py\", line 5, in <module>\n    import pandas as pd\nModuleNotFoundError: No module named 'pandas'\n\n"
+  },
+  "run_result": {
+    "success": false,
+    "test_passed": false,
+    "exit_code": 1,
+    "stdout": "",
+    "stderr": "ERROR conda.cli.main_run:execute(41): `conda run python mcp_output/start_mcp.py` failed. (See above for error)\nTraceback (most recent call last):\n  File \"/export/project/shiweijie/ghh/LLM_MCP_RAG/MCP-agent-github-repo-output/workspace/Analyze-stroke/mcp_output/start_mcp.py\", line 17, in <module>\n    from mcp_service import create_app\n  File \"/export/project/shiweijie/ghh/LLM_MCP_RAG/MCP-agent-github-repo-output/workspace/Analyze-stroke/mcp_output/mcp_plugin/mcp_service.py\", line 5, in <module>\n    import pandas as pd\nModuleNotFoundError: No module named 'pandas'\n\n",
+    "timestamp": 1765367363.3032475,
+    "error_type": "ImportError",
+    "error": "Module import failed: ERROR conda.cli.main_run:execute(41): `conda run python mcp_output/start_mcp.py` failed. (See above for error)\nTraceback (most recent call last):\n  File \"/export/project/shiweijie/ghh/LLM_MCP_RAG/MCP-agent-github-repo-output/workspace/Analyze-stroke/mcp_output/start_mcp.py\", line 17, in <module>\n    from mcp_service import create_app\n  File \"/export/project/shiweijie/ghh/LLM_MCP_RAG/MCP-agent-github-repo-output/workspace/Analyze-stroke/mcp_output/mcp_plugin/mcp_service.py\", line 5, in <module>\n    import pandas as pd\nModuleNotFoundError: No module named 'pandas'\n\n",
+    "details": {
+      "command": "/home/wshiah/code/miniconda3/bin/conda run -n Analyze-stroke_366682_env --cwd /export/project/shiweijie/ghh/LLM_MCP_RAG/MCP-agent-github-repo-output/workspace/Analyze-stroke python mcp_output/start_mcp.py",
+      "working_directory": "/export/project/shiweijie/ghh/LLM_MCP_RAG/MCP-agent-github-repo-output/workspace/Analyze-stroke",
+      "environment_type": "conda"
+    }
+  },
+  "environment": {
+    "type": "conda",
+    "name": "Analyze-stroke_366682_env",
+    "files": {
+      "environment_yml": "/export/project/shiweijie/ghh/LLM_MCP_RAG/MCP-agent-github-repo-output/workspace/Analyze-stroke/source/environment.yml"
+    },
+    "python": "3.10",
+    "exec_prefix": []
+  },
+  "plugin_info": {
+    "files": {
+      "mcp_output/start_mcp.py": "/export/project/shiweijie/ghh/LLM_MCP_RAG/MCP-agent-github-repo-output/workspace/Analyze-stroke/mcp_output/start_mcp.py",
+      "mcp_output/mcp_plugin/__init__.py": "/export/project/shiweijie/ghh/LLM_MCP_RAG/MCP-agent-github-repo-output/workspace/Analyze-stroke/mcp_output/mcp_plugin/__init__.py",
+      "mcp_output/mcp_plugin/mcp_service.py": "/export/project/shiweijie/ghh/LLM_MCP_RAG/MCP-agent-github-repo-output/workspace/Analyze-stroke/mcp_output/mcp_plugin/mcp_service.py",
+      "mcp_output/mcp_plugin/adapter.py": "/export/project/shiweijie/ghh/LLM_MCP_RAG/MCP-agent-github-repo-output/workspace/Analyze-stroke/mcp_output/mcp_plugin/adapter.py",
+      "mcp_output/mcp_plugin/main.py": "/export/project/shiweijie/ghh/LLM_MCP_RAG/MCP-agent-github-repo-output/workspace/Analyze-stroke/mcp_output/mcp_plugin/main.py",
+      "mcp_output/requirements.txt": "/export/project/shiweijie/ghh/LLM_MCP_RAG/MCP-agent-github-repo-output/workspace/Analyze-stroke/mcp_output/requirements.txt",
+      "mcp_output/README_MCP.md": "/export/project/shiweijie/ghh/LLM_MCP_RAG/MCP-agent-github-repo-output/workspace/Analyze-stroke/mcp_output/README_MCP.md",
+      "mcp_output/tests_mcp/test_mcp_basic.py": "/export/project/shiweijie/ghh/LLM_MCP_RAG/MCP-agent-github-repo-output/workspace/Analyze-stroke/mcp_output/tests_mcp/test_mcp_basic.py"
+    },
+    "adapter_mode": "import",
+    "endpoints": [
+      "function1",
+      "function2",
+      "causalclass1",
+      "causalclass2",
+      "load_data",
+      "preprocess_data",
+      "dataloader",
+      "reduce_dimensions",
+      "dimreducer",
+      "select_features",
+      "featureselector",
+      "train_model",
+      "evaluate_model",
+      "modeltrainer",
+      "modelevaluator",
+      "plot_results"
+    ],
+    "mcp_dir": "/export/project/shiweijie/ghh/LLM_MCP_RAG/MCP-agent-github-repo-output/workspace/Analyze-stroke/mcp_output/mcp_plugin",
+    "tests_dir": "/export/project/shiweijie/ghh/LLM_MCP_RAG/MCP-agent-github-repo-output/workspace/Analyze-stroke/mcp_output/tests_mcp",
+    "main_entry": "start_mcp.py",
+    "readme_path": "/export/project/shiweijie/ghh/LLM_MCP_RAG/MCP-agent-github-repo-output/workspace/Analyze-stroke/mcp_output/README_MCP.md",
+    "requirements": [
+      "fastmcp>=0.1.0",
+      "pydantic>=2.0.0"
+    ]
+  },
+  "fastmcp_installed": false
+}

Analyze-stroke/mcp_output/mcp_plugin/adapter.py

@@ -0,0 +1,147 @@
+import os
+import sys
+
+# Path settings
+source_path = os.path.join(os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))), "source")
+sys.path.insert(0, source_path)
+
+# Import statements
+try:
+    from causal_module import CausalModule
+    from data_loader import DataLoader
+    from dim_reduction import DimReduction
+    from feature_selection import FeatureSelection
+    from models import Models
+    from plot_utils import PlotUtils
+    from run_all_causal import run_all_causal
+    from run_all_causal_wo_draw import run_all_causal_wo_draw
+except ImportError as e:
+    print(f"Import error: {e}. Ensure all modules are available in the source directory.")
+
+class Adapter:
+    """
+    Adapter class for MCP plugin, providing methods to interact with the Analyze-stroke repository.
+    """
+
+    def __init__(self):
+        self.mode = "import"
+
+    # -------------------- Causal Module Methods --------------------
+
+    def create_causal_module_instance(self):
+        """
+        Create an instance of the CausalModule class.
+
+        Returns:
+            dict: Status of the operation and instance if successful.
+        """
+        try:
+            instance = CausalModule()
+            return {"status": "success", "instance": instance}
+        except Exception as e:
+            return {"status": "error", "message": str(e)}
+
+    # -------------------- Data Loader Methods --------------------
+
+    def create_data_loader_instance(self):
+        """
+        Create an instance of the DataLoader class.
+
+        Returns:
+            dict: Status of the operation and instance if successful.
+        """
+        try:
+            instance = DataLoader()
+            return {"status": "success", "instance": instance}
+        except Exception as e:
+            return {"status": "error", "message": str(e)}
+
+    # -------------------- Dimensionality Reduction Methods --------------------
+
+    def create_dim_reduction_instance(self):
+        """
+        Create an instance of the DimReduction class.
+
+        Returns:
+            dict: Status of the operation and instance if successful.
+        """
+        try:
+            instance = DimReduction()
+            return {"status": "success", "instance": instance}
+        except Exception as e:
+            return {"status": "error", "message": str(e)}
+
+    # -------------------- Feature Selection Methods --------------------
+
+    def create_feature_selection_instance(self):
+        """
+        Create an instance of the FeatureSelection class.
+
+        Returns:
+            dict: Status of the operation and instance if successful.
+        """
+        try:
+            instance = FeatureSelection()
+            return {"status": "success", "instance": instance}
+        except Exception as e:
+            return {"status": "error", "message": str(e)}
+
+    # -------------------- Models Methods --------------------
+
+    def create_models_instance(self):
+        """
+        Create an instance of the Models class.
+
+        Returns:
+            dict: Status of the operation and instance if successful.
+        """
+        try:
+            instance = Models()
+            return {"status": "success", "instance": instance}
+        except Exception as e:
+            return {"status": "error", "message": str(e)}
+
+    # -------------------- Plot Utilities Methods --------------------
+
+    def create_plot_utils_instance(self):
+        """
+        Create an instance of the PlotUtils class.
+
+        Returns:
+            dict: Status of the operation and instance if successful.
+        """
+        try:
+            instance = PlotUtils()
+            return {"status": "success", "instance": instance}
+        except Exception as e:
+            return {"status": "error", "message": str(e)}
+
+    # -------------------- Run All Causal Methods --------------------
+
+    def call_run_all_causal(self):
+        """
+        Execute the run_all_causal function.
+
+        Returns:
+            dict: Status of the operation.
+        """
+        try:
+            run_all_causal()
+            return {"status": "success"}
+        except Exception as e:
+            return {"status": "error", "message": str(e)}
+
+    def call_run_all_causal_wo_draw(self):
+        """
+        Execute the run_all_causal_wo_draw function.
+
+        Returns:
+            dict: Status of the operation.
+        """
+        try:
+            run_all_causal_wo_draw()
+            return {"status": "success"}
+        except Exception as e:
+            return {"status": "error", "message": str(e)}
+
+# End of Adapter class definition

Analyze-stroke/mcp_output/mcp_plugin/main.py

@@ -0,0 +1,13 @@
+"""
+MCP Service Auto-Wrapper - Auto-generated
+"""
+from mcp_service import create_app
+
+def main():
+    """Main entry point"""
+    app = create_app()
+    return app
+
+if __name__ == "__main__":
+    app = main()
+    app.run()

Analyze-stroke/mcp_output/mcp_plugin/mcp_service.py

@@ -0,0 +1,734 @@
+import os
+import sys
+import subprocess
+import re
+import pandas as pd
+import numpy as np
+import datetime
+import time
+import warnings
+import logging
+from typing import Optional, List
+
+# 抑制 DoWhy 和其他库的日志
+logging.getLogger('dowhy').setLevel(logging.WARNING)
+logging.getLogger('pygraphviz').setLevel(logging.WARNING)
+
+# ====================== 路径配置 (相对路径) ======================
+# 获取当前文件所在目录: mcp_output/mcp_plugin/
+CURRENT_DIR = os.path.dirname(os.path.abspath(__file__))
+# mcp_output 目录: mcp_output/
+MCP_OUTPUT_DIR = os.path.dirname(CURRENT_DIR)
+# 项目根目录: Analyze-stroke/
+PROJECT_ROOT = os.path.dirname(MCP_OUTPUT_DIR)
+# source 目录: Analyze-stroke/source/
+SOURCE_DIR = os.path.join(PROJECT_ROOT, "source")
+
+# 添加源代码路径到 Python 路径
+sys.path.insert(0, SOURCE_DIR)
+
+from fastmcp import FastMCP
+
+# 导入源代码模块
+from data_loader import DataLoader
+from dim_reduction import DimensionAnalyzer
+from models import ModelManager
+from causal_module import CausalAnalyzer
+from feature_selection import FeatureSelectionAnalyzer
+from plot_utils import plot_from_excel
+from run_all_causal import parse_log_output
+
+# 默认数据文件路径 (相对路径)
+DEFAULT_DATA_FILE = os.path.join(SOURCE_DIR, "healthcare-dataset-stroke-data.csv")
+# 默认可视化输出目录
+DEFAULT_VIS_DIR = os.path.join(MCP_OUTPUT_DIR, "visualization")
+# 默认日志目录
+DEFAULT_LOG_DIR = os.path.join(MCP_OUTPUT_DIR, "logs")
+
+mcp = FastMCP("AnalyzeStrokeService")
+
+# ====================== 数据加载工具 ======================
+
+@mcp.tool(name="load_stroke_data", description="Load and clean the stroke dataset. Returns basic statistics about the data.")
+def load_stroke_data_tool(file_path: str = None) -> dict:
+    """
+    Load and clean the stroke dataset.
+
+    Args:
+        file_path (str, optional): Path to the CSV data file. Uses default if not provided.
+
+    Returns:
+        dict: A dictionary containing success, result (data shape, columns, basic stats), and error fields.
+    """
+    try:
+        data_file = file_path if file_path else DEFAULT_DATA_FILE
+        loader = DataLoader(data_file)
+        df = loader.load_and_clean()
+        
+        result = {
+            "shape": df.shape,
+            "columns": list(df.columns),
+            "stroke_distribution": df['stroke'].value_counts().to_dict(),
+            "missing_values": df.isnull().sum().to_dict(),
+            "numeric_stats": df.describe().to_dict()
+        }
+        return {"success": True, "result": result, "error": None}
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+# ====================== 降维分析工具 ======================
+
+@mcp.tool(name="perform_pca_famd", description="Perform PCA/FAMD dimensionality reduction analysis on the stroke data. FAMD handles mixed numeric and categorical data.")
+def perform_pca_famd_tool(file_path: str = None, save_dir: str = None) -> dict:
+    """
+    Perform PCA/FAMD dimensionality reduction analysis.
+
+    Args:
+        file_path (str, optional): Path to the CSV data file.
+        save_dir (str, optional): Directory to save visualization plots.
+
+    Returns:
+        dict: A dictionary containing success, result, and error fields.
+    """
+    try:
+        data_file = file_path if file_path else DEFAULT_DATA_FILE
+        loader = DataLoader(data_file)
+        df = loader.load_and_clean()
+        
+        timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
+        vis_dir = save_dir if save_dir else DEFAULT_VIS_DIR
+        os.makedirs(vis_dir, exist_ok=True)
+        
+        analyzer = DimensionAnalyzer(df, save_dir=vis_dir, timestamp=timestamp, task_name='pca')
+        analyzer.perform_pca_famd()
+        
+        return {"success": True, "result": f"PCA/FAMD analysis completed. Plots saved to {vis_dir}", "error": None}
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+@mcp.tool(name="perform_tsne", description="Perform t-SNE dimensionality reduction analysis on the stroke data for visualization.")
+def perform_tsne_tool(file_path: str = None, save_dir: str = None) -> dict:
+    """
+    Perform t-SNE dimensionality reduction analysis.
+
+    Args:
+        file_path (str, optional): Path to the CSV data file.
+        save_dir (str, optional): Directory to save visualization plots.
+
+    Returns:
+        dict: A dictionary containing success, result, and error fields.
+    """
+    try:
+        data_file = file_path if file_path else DEFAULT_DATA_FILE
+        loader = DataLoader(data_file)
+        df = loader.load_and_clean()
+        
+        timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
+        vis_dir = save_dir if save_dir else DEFAULT_VIS_DIR
+        os.makedirs(vis_dir, exist_ok=True)
+        
+        analyzer = DimensionAnalyzer(df, save_dir=vis_dir, timestamp=timestamp, task_name='tsne')
+        analyzer.perform_tsne()
+        
+        return {"success": True, "result": f"t-SNE analysis completed. Plots saved to {vis_dir}", "error": None}
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+# ====================== 预测模型工具 ======================
+
+@mcp.tool(name="run_prediction_model", description="Run a prediction model for stroke classification. User MUST specify model_type. Options: nb (Naive Bayes), lr (Logistic Regression), svm (SVM), knn (KNN), dt (Decision Tree), rf (Random Forest), xgboost (XGBoost), dnn (Deep Neural Network).")
+def run_prediction_model_tool(model_type: str, file_path: str = None, save_dir: str = None) -> dict:
+    """
+    Run a prediction model for stroke classification.
+
+    Args:
+        model_type (str): Model type. Options: 'nb', 'lr', 'svm', 'knn', 'dt', 'rf', 'xgboost', 'dnn'.
+        file_path (str, optional): Path to the CSV data file.
+        save_dir (str, optional): Directory to save visualization plots.
+
+    Returns:
+        dict: A dictionary containing success, result (model metrics), and error fields.
+    """
+    try:
+        valid_models = ['nb', 'lr', 'svm', 'knn', 'dt', 'rf', 'xgboost', 'dnn']
+        if model_type not in valid_models:
+            return {"success": False, "result": None, "error": f"Invalid model type. Choose from: {valid_models}"}
+        
+        data_file = file_path if file_path else DEFAULT_DATA_FILE
+        loader = DataLoader(data_file)
+        df = loader.load_and_clean()
+        X_train, X_test, y_train, y_test = loader.get_split_data()
+        
+        timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
+        vis_dir = save_dir if save_dir else DEFAULT_VIS_DIR
+        os.makedirs(vis_dir, exist_ok=True)
+        
+        manager = ModelManager(X_train, y_train, X_test, y_test, save_dir=vis_dir, timestamp=timestamp)
+        
+        if model_type == 'dnn':
+            manager.run_dnn()
+            return {"success": True, "result": f"DNN model training completed. Plots saved to {vis_dir}", "error": None}
+        else:
+            manager.run_sklearn_model(model_type)
+            return {"success": True, "result": f"{model_type.upper()} model training completed. Plots saved to {vis_dir}", "error": None}
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+# ====================== 特征选择工具 ======================
+
+@mcp.tool(name="run_feature_selection", description="Run feature selection analysis. User MUST specify method. Options: kbest (Mutual Information), rfecv (Recursive Feature Elimination with CV), chi2 (Chi-Square Test).")
+def run_feature_selection_tool(method: str, file_path: str = None, save_dir: str = None) -> dict:
+    """
+    Run feature selection analysis.
+
+    Args:
+        method (str): Feature selection method. Options: 'kbest', 'rfecv', 'chi2'.
+        file_path (str, optional): Path to the CSV data file.
+        save_dir (str, optional): Directory to save visualization plots.
+
+    Returns:
+        dict: A dictionary containing success, result, and error fields.
+    """
+    try:
+        valid_methods = ['kbest', 'rfecv', 'chi2']
+        if method not in valid_methods:
+            return {"success": False, "result": None, "error": f"Invalid method. Choose from: {valid_methods}"}
+        
+        data_file = file_path if file_path else DEFAULT_DATA_FILE
+        loader = DataLoader(data_file)
+        df = loader.load_and_clean()
+        
+        timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
+        vis_dir = save_dir if save_dir else DEFAULT_VIS_DIR
+        os.makedirs(vis_dir, exist_ok=True)
+        
+        analyzer = FeatureSelectionAnalyzer(df, save_dir=vis_dir, timestamp=timestamp)
+        
+        if method == 'kbest':
+            analyzer.run_select_kbest()
+        elif method == 'rfecv':
+            analyzer.run_rfecv()
+        elif method == 'chi2':
+            analyzer.run_chi2()
+        
+        return {"success": True, "result": f"Feature selection ({method}) completed. Plots saved to {vis_dir}", "error": None}
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+# ====================== 因果推理工具 ======================
+
+@mcp.tool(name="run_causal_analysis", description="Run causal inference analysis for a single treatment variable on stroke outcome using DoWhy framework. User MUST specify treatment variable. Options: gender, age, hypertension, heart_disease, ever_married, work_type, Residence_type, avg_glucose_level, bmi, smoking_status.")
+def run_causal_analysis_tool(treatment: str, file_path: str = None) -> dict:
+    """
+    Run causal inference analysis for a single treatment variable.
+
+    Args:
+        treatment (str): Treatment variable. Options: 'gender', 'age', 'hypertension', 'heart_disease', 
+                        'ever_married', 'work_type', 'Residence_type', 'avg_glucose_level', 'bmi', 'smoking_status'.
+        file_path (str, optional): Path to the CSV data file.
+
+    Returns:
+        dict: A dictionary containing success, result (ATE value and interpretation), and error fields.
+    """
+    try:
+        valid_treatments = ['gender', 'age', 'hypertension', 'heart_disease', 'ever_married',
+                           'work_type', 'Residence_type', 'avg_glucose_level', 'bmi', 'smoking_status']
+        if treatment not in valid_treatments:
+            return {"success": False, "result": None, "error": f"Invalid treatment. Choose from: {valid_treatments}"}
+        
+        data_file = file_path if file_path else DEFAULT_DATA_FILE
+        loader = DataLoader(data_file)
+        df = loader.load_and_clean()
+        
+        # 智能领域编码 (与 main.py 保持一致)
+        if 'gender' in df.columns:
+            df['gender'] = df['gender'].map({'Male': 1, 'Female': 0, 'Other': 0}).fillna(0)
+        if 'ever_married' in df.columns:
+            df['ever_married'] = df['ever_married'].map({'Yes': 1, 'No': 0}).fillna(0)
+        if 'Residence_type' in df.columns:
+            df['Residence_type'] = df['Residence_type'].map({'Urban': 1, 'Rural': 0}).fillna(0)
+        if 'smoking_status' in df.columns:
+            smoke_map = {'unknown': 0, 'Unknown': 0, 'never smoked': 0, 'formerly smoked': 1, 'smokes': 2}
+            df['smoking_status'] = df['smoking_status'].map(smoke_map).fillna(0)
+        if 'work_type' in df.columns:
+            work_map = {'Private': 1, 'Self-employed': 1, 'Govt_job': 0, 'children': 0, 'Never_worked': 0}
+            df['work_type'] = df['work_type'].map(work_map).fillna(0)
+        
+        analyzer = CausalAnalyzer(df)
+        ate_value = analyzer.run_analysis(treatment_col=treatment)
+        
+        result = {
+            "treatment": treatment,
+            "outcome": "stroke",
+            "ATE": ate_value,
+            "interpretation": f"If '{treatment}' increases by 1 unit, the probability of stroke changes by {ate_value:.4f}"
+        }
+        return {"success": True, "result": result, "error": None}
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+@mcp.tool(name="run_batch_causal_analysis", description="Run batch causal analysis for all treatment factors and generate an Excel report with visualizations. Analyzes all 10 factors: gender, age, hypertension, heart_disease, ever_married, work_type, Residence_type, avg_glucose_level, bmi, smoking_status.")
+def run_batch_causal_analysis_tool(file_path: str = None, save_dir: str = None) -> dict:
+    """
+    Run batch causal analysis for all factors and generate summary report.
+    
+    This function directly performs causal analysis for all factors without
+    relying on subprocess calls, making it cross-platform compatible.
+
+    Args:
+        file_path (str, optional): Path to the CSV data file.
+        save_dir (str, optional): Directory to save results and visualizations.
+
+    Returns:
+        dict: A dictionary containing success, result (report path and summary), and error fields.
+    """
+    try:
+        # 定义所有因素
+        FACTORS = [
+            'gender', 'age', 'hypertension', 'heart_disease', 'ever_married',
+            'work_type', 'Residence_type', 'avg_glucose_level', 'bmi', 'smoking_status'
+        ]
+        
+        # 设置保存目录
+        timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S_BatchCausal")
+        output_dir = save_dir if save_dir else os.path.join(DEFAULT_LOG_DIR, timestamp)
+        os.makedirs(output_dir, exist_ok=True)
+        
+        # 加载并预处理数据
+        data_file = file_path if file_path else DEFAULT_DATA_FILE
+        loader = DataLoader(data_file)
+        df = loader.load_and_clean()
+        
+        # 智能领域编码
+        if 'gender' in df.columns:
+            df['gender'] = df['gender'].map({'Male': 1, 'Female': 0, 'Other': 0}).fillna(0)
+        if 'ever_married' in df.columns:
+            df['ever_married'] = df['ever_married'].map({'Yes': 1, 'No': 0}).fillna(0)
+        if 'Residence_type' in df.columns:
+            df['Residence_type'] = df['Residence_type'].map({'Urban': 1, 'Rural': 0}).fillna(0)
+        if 'smoking_status' in df.columns:
+            smoke_map = {'unknown': 0, 'Unknown': 0, 'never smoked': 0, 'formerly smoked': 1, 'smokes': 2}
+            df['smoking_status'] = df['smoking_status'].map(smoke_map).fillna(0)
+        if 'work_type' in df.columns:
+            work_map = {'Private': 1, 'Self-employed': 1, 'Govt_job': 0, 'children': 0, 'Never_worked': 0}
+            df['work_type'] = df['work_type'].map(work_map).fillna(0)
+        
+        results_list = []
+        
+        # 循环执行因果分析
+        for i, factor in enumerate(FACTORS):
+            print(f"\n>>> [{i+1}/{len(FACTORS)}] Analyzing factor: {factor} ...")
+            
+            try:
+                analyzer = CausalAnalyzer(df)
+                
+                # 捕获输出以提取指标
+                import io
+                from contextlib import redirect_stdout
+                
+                f = io.StringIO()
+                with redirect_stdout(f):
+                    ate_value = analyzer.run_analysis(treatment_col=factor)
+                
+                output_text = f.getvalue()
+                
+                # 提取指标
+                metrics = parse_log_output(output_text)
+                metrics['Factor'] = factor
+                metrics['ATE'] = ate_value if not np.isnan(metrics['ATE']) else ate_value
+                results_list.append(metrics)
+                
+                print(f"    -> [Success] ATE={metrics['ATE']:.4f}, P-Val={metrics['P-Value']}")
+                
+            except Exception as e:
+                print(f"    -> [Error] {str(e)}")
+                results_list.append({
+                    'Factor': factor, 
+                    'ATE': np.nan, 
+                    'New Effect': np.nan, 
+                    'P-Value': np.nan
+                })
+        
+        # 生成 Excel 报告
+        if results_list:
+            results_df = pd.DataFrame(results_list)
+            cols = ['Factor', 'ATE', 'New Effect', 'P-Value']
+            results_df = results_df[cols]
+            
+            # 保留4位小数
+            numeric_cols = ['ATE', 'New Effect', 'P-Value']
+            results_df[numeric_cols] = results_df[numeric_cols].astype(float).round(4)
+            
+            excel_name = f"Causal_Summary_{timestamp}.xlsx"
+            excel_path = os.path.join(output_dir, excel_name)
+            results_df.to_excel(excel_path, index=False)
+            print(f"\n[Output] Excel report saved: {excel_path}")
+            
+            # 生成可视化图表
+            try:
+                plot_from_excel(excel_path, output_dir)
+                print("[Output] Visualization charts generated.")
+            except Exception as e:
+                print(f"[Warning] Plot generation failed: {e}")
+            
+            # 返回摘要
+            summary = results_df.to_dict('records')
+            return {
+                "success": True, 
+                "result": {
+                    "excel_path": excel_path,
+                    "output_dir": output_dir,
+                    "summary": summary,
+                    "total_factors": len(FACTORS),
+                    "successful_analyses": len([r for r in results_list if not np.isnan(r.get('ATE', np.nan))])
+                }, 
+                "error": None
+            }
+        else:
+            return {"success": False, "result": None, "error": "No results generated."}
+            
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+@mcp.tool(name="parse_log_output", description="Extracts metrics from log text including ATE, New Effect, and P-Value.")
+def parse_log_output_tool(output_text: str) -> dict:
+    """
+    Extracts metrics from log text including ATE, New Effect, and P-Value.
+
+    Args:
+        output_text (str): The log text containing the metrics.
+
+    Returns:
+        dict: A dictionary containing success, result (extracted metrics), and error fields.
+    """
+    try:
+        result = parse_log_output(output_text)
+        return {"success": True, "result": result, "error": None}
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+# ====================== 绘图工具 ======================
+
+@mcp.tool(name="plot_causal_results", description="Generate visualizations (radar chart, bar chart) from causal analysis Excel results.")
+def plot_causal_results_tool(excel_path: str) -> dict:
+    """
+    Generate visualizations from causal analysis Excel results.
+
+    Args:
+        excel_path (str): Path to the Excel file containing causal analysis results.
+
+    Returns:
+        dict: A dictionary containing success, result, and error fields.
+    """
+    try:
+        if not os.path.exists(excel_path):
+            return {"success": False, "result": None, "error": f"Excel file not found: {excel_path}"}
+        
+        plot_from_excel(excel_path)
+        return {"success": True, "result": f"Plots generated from {excel_path}", "error": None}
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+# ====================== 综合分析工具 ======================
+
+@mcp.tool(name="run_stroke_analysis", description="Run comprehensive stroke analysis. Unified entry point for all analysis tasks. User MUST specify task. For prediction task, user MUST also specify model. For feature_selection task, user MUST also specify method. For causal task, user MUST also specify treatment.")
+def run_stroke_analysis_tool(task: str, model: str = None, method: str = None, treatment: str = None, file_path: str = None) -> dict:
+    """
+    Run comprehensive stroke analysis - unified entry point.
+
+    Args:
+        task (str): Analysis task. Options: 'pca', 'tsne', 'prediction', 'causal', 'feature_selection'.
+        model (str, optional): Model type for prediction task. Required when task='prediction'. Options: 'nb', 'lr', 'svm', 'knn', 'dt', 'rf', 'xgboost', 'dnn'.
+        method (str, optional): Method for feature selection. Required when task='feature_selection'. Options: 'kbest', 'rfecv', 'chi2'.
+        treatment (str, optional): Treatment variable for causal analysis. Required when task='causal'. Options: 'gender', 'age', 'hypertension', 'heart_disease', 'ever_married', 'work_type', 'Residence_type', 'avg_glucose_level', 'bmi', 'smoking_status'.
+        file_path (str, optional): Path to the CSV data file.
+
+    Returns:
+        dict: A dictionary containing success, result, and error fields.
+    """
+    try:
+        valid_tasks = ['pca', 'tsne', 'prediction', 'causal', 'feature_selection']
+        if task not in valid_tasks:
+            return {"success": False, "result": None, "error": f"Invalid task. Choose from: {valid_tasks}"}
+        
+        # 直接执行任务逻辑，避免调用被装饰的函数
+        data_file = file_path if file_path else DEFAULT_DATA_FILE
+        
+        if task == 'pca':
+            loader = DataLoader(data_file)
+            df = loader.load_and_clean()
+            timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
+            vis_dir = DEFAULT_VIS_DIR
+            os.makedirs(vis_dir, exist_ok=True)
+            analyzer = DimensionAnalyzer(df, save_dir=vis_dir, timestamp=timestamp, task_name='pca')
+            analyzer.perform_pca_famd()
+            return {"success": True, "result": f"PCA/FAMD analysis completed. Plots saved to {vis_dir}", "error": None}
+            
+        elif task == 'tsne':
+            loader = DataLoader(data_file)
+            df = loader.load_and_clean()
+            timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
+            vis_dir = DEFAULT_VIS_DIR
+            os.makedirs(vis_dir, exist_ok=True)
+            analyzer = DimensionAnalyzer(df, save_dir=vis_dir, timestamp=timestamp, task_name='tsne')
+            analyzer.perform_tsne()
+            return {"success": True, "result": f"t-SNE analysis completed. Plots saved to {vis_dir}", "error": None}
+            
+        elif task == 'prediction':
+            if not model:
+                return {"success": False, "result": None, "error": "For prediction task, 'model' parameter is required. Options: 'nb', 'lr', 'svm', 'knn', 'dt', 'rf', 'xgboost', 'dnn'"}
+            
+            valid_models = ['nb', 'lr', 'svm', 'knn', 'dt', 'rf', 'xgboost', 'dnn']
+            if model not in valid_models:
+                return {"success": False, "result": None, "error": f"Invalid model type. Choose from: {valid_models}"}
+            
+            loader = DataLoader(data_file)
+            df = loader.load_and_clean()
+            X_train, X_test, y_train, y_test = loader.get_split_data()
+            timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
+            vis_dir = DEFAULT_VIS_DIR
+            os.makedirs(vis_dir, exist_ok=True)
+            manager = ModelManager(X_train, y_train, X_test, y_test, save_dir=vis_dir, timestamp=timestamp)
+            
+            if model == 'dnn':
+                manager.run_dnn()
+            else:
+                manager.run_sklearn_model(model)
+            return {"success": True, "result": f"{model.upper()} model training completed. Plots saved to {vis_dir}", "error": None}
+            
+        elif task == 'causal':
+            if not treatment:
+                return {"success": False, "result": None, "error": "For causal task, 'treatment' parameter is required. Options: 'gender', 'age', 'hypertension', 'heart_disease', 'ever_married', 'work_type', 'Residence_type', 'avg_glucose_level', 'bmi', 'smoking_status'"}
+            
+            valid_treatments = ['gender', 'age', 'hypertension', 'heart_disease', 'ever_married',
+                               'work_type', 'Residence_type', 'avg_glucose_level', 'bmi', 'smoking_status']
+            if treatment not in valid_treatments:
+                return {"success": False, "result": None, "error": f"Invalid treatment. Choose from: {valid_treatments}"}
+            
+            loader = DataLoader(data_file)
+            df = loader.load_and_clean()
+            
+            # 智能领域编码
+            if 'gender' in df.columns:
+                df['gender'] = df['gender'].map({'Male': 1, 'Female': 0, 'Other': 0}).fillna(0)
+            if 'ever_married' in df.columns:
+                df['ever_married'] = df['ever_married'].map({'Yes': 1, 'No': 0}).fillna(0)
+            if 'Residence_type' in df.columns:
+                df['Residence_type'] = df['Residence_type'].map({'Urban': 1, 'Rural': 0}).fillna(0)
+            if 'smoking_status' in df.columns:
+                smoke_map = {'unknown': 0, 'Unknown': 0, 'never smoked': 0, 'formerly smoked': 1, 'smokes': 2}
+                df['smoking_status'] = df['smoking_status'].map(smoke_map).fillna(0)
+            if 'work_type' in df.columns:
+                work_map = {'Private': 1, 'Self-employed': 1, 'Govt_job': 0, 'children': 0, 'Never_worked': 0}
+                df['work_type'] = df['work_type'].map(work_map).fillna(0)
+            
+            analyzer = CausalAnalyzer(df)
+            ate_value = analyzer.run_analysis(treatment_col=treatment)
+            result = {
+                "treatment": treatment,
+                "outcome": "stroke",
+                "ATE": ate_value,
+                "interpretation": f"If '{treatment}' increases by 1 unit, the probability of stroke changes by {ate_value:.4f}"
+            }
+            return {"success": True, "result": result, "error": None}
+            
+        elif task == 'feature_selection':
+            if not method:
+                return {"success": False, "result": None, "error": "For feature_selection task, 'method' parameter is required. Options: 'kbest', 'rfecv', 'chi2'"}
+            
+            valid_methods = ['kbest', 'rfecv', 'chi2']
+            if method not in valid_methods:
+                return {"success": False, "result": None, "error": f"Invalid method. Choose from: {valid_methods}"}
+            
+            loader = DataLoader(data_file)
+            df = loader.load_and_clean()
+            timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
+            vis_dir = DEFAULT_VIS_DIR
+            os.makedirs(vis_dir, exist_ok=True)
+            analyzer = FeatureSelectionAnalyzer(df, save_dir=vis_dir, timestamp=timestamp)
+            
+            if method == 'kbest':
+                analyzer.run_select_kbest()
+            elif method == 'rfecv':
+                analyzer.run_rfecv()
+            elif method == 'chi2':
+                analyzer.run_chi2()
+            
+            return {"success": True, "result": f"Feature selection ({method}) completed. Plots saved to {vis_dir}", "error": None}
+        
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+@mcp.tool(name="get_available_options", description="Get all available options for stroke analysis tasks, models, methods, and treatment variables.")
+def get_available_options_tool() -> dict:
+    """
+    Get all available options for stroke analysis.
+
+    Returns:
+        dict: A dictionary containing all available options.
+    """
+    return {
+        "success": True,
+        "result": {
+            "tasks": ['pca', 'tsne', 'prediction', 'causal', 'feature_selection'],
+            "prediction_models": ['nb', 'lr', 'svm', 'knn', 'dt', 'rf', 'xgboost', 'dnn'],
+            "feature_selection_methods": ['kbest', 'rfecv', 'chi2'],
+            "causal_treatments": ['gender', 'age', 'hypertension', 'heart_disease', 'ever_married',
+                                  'work_type', 'Residence_type', 'avg_glucose_level', 'bmi', 'smoking_status'],
+            "description": {
+                "pca": "PCA/FAMD dimensionality reduction analysis",
+                "tsne": "t-SNE visualization",
+                "prediction": "Stroke prediction using ML models",
+                "causal": "Causal inference using DoWhy framework",
+                "feature_selection": "Feature importance analysis"
+            }
+        },
+        "error": None
+    }
+
+@mcp.tool(name="upload_to_hf_dataset", description="Upload generated file to HuggingFace Dataset for easy download")
+def upload_to_hf_dataset(file_path: str, dataset_repo: str = None, hf_token: str = None) -> dict:
+    """
+    Upload generated file to HuggingFace Dataset repository.
+    Users can then download files from the Dataset page.
+
+    Parameters:
+        file_path (str): Absolute path to the file on HF Space
+        dataset_repo (str): Dataset repo name (e.g., 'username/obspy-outputs').
+                           If None, uses HF_DATASET_REPO environment variable
+        hf_token (str): HuggingFace token. If None, uses HF_TOKEN environment variable
+
+    Returns:
+        dict: Success status and download URL
+    """
+    try:
+        from huggingface_hub import HfApi, create_repo
+        from huggingface_hub.utils import RepositoryNotFoundError
+
+        if dataset_repo is None:
+            dataset_repo = os.environ.get("HF_DATASET_REPO")
+            if not dataset_repo:
+                return {
+                    "success": False,
+                    "error": "Dataset repo not specified. Set HF_DATASET_REPO environment variable or pass dataset_repo parameter"
+                }
+
+        if hf_token is None:
+            hf_token = os.environ.get("HF_TOKEN")
+            if not hf_token:
+                return {
+                    "success": False,
+                    "error": "HF token not found. Set HF_TOKEN environment variable or pass hf_token parameter"
+                }
+
+        # Check if file exists and readable
+        if not os.path.exists(file_path):
+            return {
+                "success": False,
+                "error": f"File not found: {file_path}"
+            }
+
+        if not os.path.isfile(file_path):
+            return {
+                "success": False,
+                "error": f"Path is not a file: {file_path}"
+            }
+
+        if not os.access(file_path, os.R_OK):
+            return {
+                "success": False,
+                "error": f"File not readable (permission denied): {file_path}",
+                "hint": "Check file permissions in Docker container"
+            }
+
+        # Get file info for debugging
+        file_size = os.path.getsize(file_path)
+        file_stat = os.stat(file_path)
+
+        # Initialize HF API
+        api = HfApi()
+
+        # Try to create dataset repo if it doesn't exist
+        try:
+            repo_info = create_repo(
+                repo_id=dataset_repo,
+                repo_type="dataset",
+                token=hf_token,
+                exist_ok=True,
+                private=False
+            )
+        except Exception as e:
+            return {
+                "success": False,
+                "error": f"Failed to create/access dataset repo: {str(e)}",
+                "dataset_repo": dataset_repo,
+                "hint": "Check if HF_TOKEN has write permission and dataset_repo format is correct (username/repo-name)"
+            }
+
+        # Get filename and determine path in dataset
+        filename = os.path.basename(file_path)
+
+        # Determine subdirectory based on file location
+        if "/output/" in file_path:
+            path_in_repo = f"output/{filename}"
+        elif "/plots/" in file_path:
+            path_in_repo = f"plots/{filename}"
+        elif "/wave_data/" in file_path:
+            path_in_repo = f"wave_data/{filename}"
+        else:
+            path_in_repo = filename
+
+        try:
+            with open(file_path, 'rb') as f:
+                file_content = f.read()
+        except Exception as e:
+            return {
+                "success": False,
+                "error": f"Failed to read file: {str(e)}",
+                "file_path": file_path,
+                "hint": "File may exist but not readable due to permission issues"
+            }
+
+        # Upload file from memory instead of path
+        import io
+        upload_result = api.upload_file(
+            path_or_fileobj=io.BytesIO(file_content),
+            path_in_repo=path_in_repo,
+            repo_id=dataset_repo,
+            repo_type="dataset",
+            token=hf_token
+        )
+
+        # Construct download URL
+        download_url = f"https://huggingface.co/datasets/{dataset_repo}/resolve/main/{path_in_repo}"
+        viewer_url = f"https://huggingface.co/datasets/{dataset_repo}/viewer/default/train?f%5Bfile%5D%5Bvalue%5D={path_in_repo}"
+
+        return {
+            "success": True,
+            "message": f"File uploaded successfully to {dataset_repo}",
+            "dataset_repo": dataset_repo,
+            "filename": filename,
+            "path_in_repo": path_in_repo,
+            "download_url": download_url,
+            "viewer_url": viewer_url,
+            "usage": f"Download directly from: {download_url}"
+        }
+
+    except Exception as e:
+        return {
+            "success": False,
+            "error": str(e),
+            "hint": "Make sure HF_TOKEN and HF_DATASET_REPO are set in Space secrets"
+        }
+
+def create_app() -> FastMCP:
+    """
+    Creates and returns the FastMCP application instance.
+
+    Returns:
+        FastMCP: The FastMCP application instance.
+    """
+    # 验证所有工具已正确注册
+    print("[MCP] Service initialized successfully")
+    print(f"[MCP] Registered tools: {len(mcp._tools) if hasattr(mcp, '_tools') else 'Unknown'}")
+    return mcp

Analyze-stroke/mcp_output/requirements.txt

@@ -0,0 +1,9 @@
+fastmcp>=0.1.0
+pydantic>=2.0.0
+numpy
+pandas
+scikit-learn
+matplotlib
+
+# Optional Dependencies
+# seaborn

Analyze-stroke/mcp_output/simple_revise_error_analysis.json

@@ -0,0 +1,6 @@
+{
+  "status": "FAIL",
+  "next_action": "fix_directly",
+  "confidence": 0.9,
+  "summary": "The error is due to a missing Python module 'pandas'. This can be fixed directly by installing the 'pandas' package in the conda environment being used. The command to install the package is 'conda install pandas'. Ensure that the correct conda environment is activated before running the installation command. Once 'pandas' is installed, the script should be able to import it without errors."
+}

Analyze-stroke/mcp_output/start_mcp.py

@@ -0,0 +1,33 @@
+"""
+MCP Service Startup Entry
+"""
+import sys
+import os
+
+project_root = os.path.dirname(os.path.abspath(__file__))
+mcp_plugin_dir = os.path.join(project_root, "mcp_plugin")
+if mcp_plugin_dir not in sys.path:
+    sys.path.insert(0, mcp_plugin_dir)
+
+# Set path to source directory
+source_path = os.path.join(os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))), "source")
+sys.path.insert(0, source_path)
+
+from mcp_plugin.mcp_service import create_app
+
+def main():
+    """Start FastMCP service"""
+    app = create_app()
+    # Use environment variable to configure port, default 8000
+    port = int(os.environ.get("MCP_PORT", "8000"))
+    
+    # Choose transport mode based on environment variable
+    transport = os.environ.get("MCP_TRANSPORT", "stdio")
+    if transport == "http":
+        app.run(transport="http", host="0.0.0.0", port=port)
+    else:
+        # Default to STDIO mode
+        app.run()
+
+if __name__ == "__main__":
+    main()

Analyze-stroke/mcp_output/tests_mcp/test_mcp_basic.py

@@ -0,0 +1,49 @@
+"""
+MCP Service Basic Test
+"""
+import sys
+import os
+
+project_root = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+mcp_plugin_dir = os.path.join(project_root, "mcp_plugin")
+if mcp_plugin_dir not in sys.path:
+    sys.path.insert(0, mcp_plugin_dir)
+
+source_path = os.path.join(os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))), "source")
+sys.path.insert(0, source_path)
+
+def test_import_mcp_service():
+    """Test if MCP service can be imported normally"""
+    try:
+        from mcp_service import create_app
+        app = create_app()
+        assert app is not None
+        print("MCP service imported successfully")
+        return True
+    except Exception as e:
+        print("MCP service import failed: " + str(e))
+        return False
+
+def test_adapter_init():
+    """Test if adapter can be initialized normally"""
+    try:
+        from adapter import Adapter
+        adapter = Adapter()
+        assert adapter is not None
+        print("Adapter initialized successfully")
+        return True
+    except Exception as e:
+        print("Adapter initialization failed: " + str(e))
+        return False
+
+if __name__ == "__main__":
+    print("Running MCP service basic test...")
+    test1 = test_import_mcp_service()
+    test2 = test_adapter_init()
+    
+    if test1 and test2:
+        print("All basic tests passed")
+        sys.exit(0)
+    else:
+        print("Some tests failed")
+        sys.exit(1)

Analyze-stroke/mcp_output/tests_smoke/test_smoke.py

@@ -0,0 +1,12 @@
+import importlib, sys
+import os
+
+# Add current directory to Python path
+sys.path.insert(0, os.getcwd())
+
+source_dir = os.path.join(os.getcwd(), "source")
+if os.path.exists(source_dir):
+    sys.path.insert(0, source_dir)
+
+
+print("NO_PACKAGE - No testable package found")

Analyze-stroke/patient_data/README_DEMO.txt

@@ -0,0 +1,12 @@
+This directory contains SYNTHETIC demo data only.
+No real patient information.
+
+Purpose
+-------
+Used for MCP security demos (path traversal / guardrail allowlist).
+
+Files
+-----
+- stroke_clean.csv : synthetic stroke analysis dataset
+
+

Analyze-stroke/patient_data/stroke_clean.csv

@@ -0,0 +1,23 @@
+patient_id,gender,age,hypertension,heart_disease,ever_married,work_type,Residence_type,avg_glucose_level,bmi,smoking_status,stroke,note
+P20250001,Male,67.2,1,0,Yes,Private,Urban,198.4,31.6,formerly smoked,1,SYNTHETIC_DEMO_ONLY
+P20250002,Female,52.8,0,0,Yes,Self-employed,Rural,141.2,28.9,never smoked,0,SYNTHETIC_DEMO_ONLY
+P20250003,Male,74.5,1,1,Yes,Govt_job,Urban,212.7,34.1,smokes,1,SYNTHETIC_DEMO_ONLY
+P20250004,Female,38.6,0,0,No,Private,Urban,96.5,22.4,Unknown,0,SYNTHETIC_DEMO_ONLY
+P20250005,Male,59.1,1,0,Yes,Private,Rural,165.3,36.8,smokes,1,SYNTHETIC_DEMO_ONLY
+P20250006,Female,46.9,0,0,Yes,Govt_job,Urban,128.7,27.6,never smoked,0,SYNTHETIC_DEMO_ONLY
+P20250007,Male,63.4,0,1,Yes,Self-employed,Urban,183.9,30.8,formerly smoked,1,SYNTHETIC_DEMO_ONLY
+P20250008,Female,29.7,0,0,No,Private,Rural,88.2,20.1,never smoked,0,SYNTHETIC_DEMO_ONLY
+P20250009,Male,71.9,1,0,Yes,Private,Urban,156.4,29.3,smokes,1,SYNTHETIC_DEMO_ONLY
+P20250010,Female,57.3,0,0,Yes,Self-employed,Urban,149.8,33.7,formerly smoked,1,SYNTHETIC_DEMO_ONLY
+P20250011,Male,44.2,0,0,Yes,Private,Rural,121.1,25.9,never smoked,0,SYNTHETIC_DEMO_ONLY
+P20250012,Female,66.8,1,1,Yes,Govt_job,Urban,224.5,37.2,formerly smoked,1,SYNTHETIC_DEMO_ONLY
+P20250013,Male,61.0,0,0,Yes,Private,Urban,172.9,35.4,smokes,1,SYNTHETIC_DEMO_ONLY
+P20250014,Female,49.6,0,0,Yes,Private,Rural,110.6,24.7,Unknown,0,SYNTHETIC_DEMO_ONLY
+P20250015,Male,80.2,1,1,Yes,Self-employed,Rural,238.1,32.2,formerly smoked,1,SYNTHETIC_DEMO_ONLY
+P20250016,Female,35.9,0,0,No,Private,Urban,92.9,21.8,never smoked,0,SYNTHETIC_DEMO_ONLY
+P20250017,Male,54.7,1,0,Yes,Govt_job,Urban,146.3,31.1,smokes,1,SYNTHETIC_DEMO_ONLY
+P20250018,Female,62.5,0,0,Yes,Private,Rural,137.4,29.9,formerly smoked,0,SYNTHETIC_DEMO_ONLY
+P20250019,Male,58.8,0,0,Yes,Private,Urban,181.6,34.8,smokes,1,SYNTHETIC_DEMO_ONLY
+P20250020,Female,73.1,1,0,Yes,Self-employed,Urban,201.3,30.5,Unknown,1,SYNTHETIC_DEMO_ONLY
+
+

Analyze-stroke/secrets/national_id.csv

@@ -0,0 +1,23 @@
+patient_id,name,national_id,phone,address,risk_flag,note
+P20250001,王伟,110101195805164218,17048293105,北京市健康路88号,high,SYNTHETIC_DEMO_ONLY
+P20250002,李静,310101197210083526,17190517342,上海市杏林路17号,medium,SYNTHETIC_DEMO_ONLY
+P20250003,陈强,440103195012295119,19961425083,广州市康复大道203号,high,SYNTHETIC_DEMO_ONLY
+P20250004,周娜,440305198703171642,19107836291,深圳市医学路56号,low,SYNTHETIC_DEMO_ONLY
+P20250005,吴涛,320102196605024533,16639274518,南京市科研路121号,high,SYNTHETIC_DEMO_ONLY
+P20250006,郑丽,330106197809302016,17083517026,杭州市协和路9号,medium,SYNTHETIC_DEMO_ONLY
+P20250007,冯磊,420106196109112738,17126094837,武汉市同济路74号,high,SYNTHETIC_DEMO_ONLY
+P20250008,褚倩,510104199512054821,19950218366,成都市仁心街14号,low,SYNTHETIC_DEMO_ONLY
+P20250009,张军,110101195309063911,19193458207,北京市医学路208号,high,SYNTHETIC_DEMO_ONLY
+P20250010,何丹,31010119670729522X,16618473920,上海市康复大道66号,medium,SYNTHETIC_DEMO_ONLY
+P20250011,许杰,440103198010124617,17067290813,广州市杏林路191号,low,SYNTHETIC_DEMO_ONLY
+P20250012,吕秀英,440305195611285178,17141873054,深圳市健康路33号,high,SYNTHETIC_DEMO_ONLY
+P20250013,施鹏,320102196405105855,19912039758,南京市协和路152号,high,SYNTHETIC_DEMO_ONLY
+P20250014,曹玲,33010619751222341X,19150268491,杭州市科研路27号,low,SYNTHETIC_DEMO_ONLY
+P20250015,严超,420106194504036412,16693502741,武汉市仁心街102号,high,SYNTHETIC_DEMO_ONLY
+P20250016,华倩,510104198907191984,17028549106,成都市同济路6号,low,SYNTHETIC_DEMO_ONLY
+P20250017,金鑫,110101197104144535,17179364128,北京市康复大道118号,medium,SYNTHETIC_DEMO_ONLY
+P20250018,魏晨,310101196212315470,19968295137,上海市医学路41号,medium,SYNTHETIC_DEMO_ONLY
+P20250019,陶昊,440103196611103903,19135791426,广州市协和路219号,high,SYNTHETIC_DEMO_ONLY
+P20250020,姜然,440305195202184962,16674261039,深圳市科研路12号,high,SYNTHETIC_DEMO_ONLY
+
+

Analyze-stroke/source/__init__.py

@@ -0,0 +1,4 @@
+# -*- coding: utf-8 -*-
+"""
+Analyze-stroke Project Package Initialization File
+"""

Analyze-stroke/source/causal_module.py

@@ -0,0 +1,108 @@
+# Analyze/causal_module.py
+import dowhy
+from dowhy import CausalModel
+import pandas as pd
+import numpy as np
+import warnings
+
+class CausalAnalyzer:
+    def __init__(self, data):
+        self.data = data.copy()
+        for col in self.data.columns:
+            if self.data[col].dtype == bool:
+                self.data[col] = self.data[col].astype(int)
+
+    def define_causal_graph(self):
+        """
+        定义领域知识 DAG
+        """
+        causal_graph = """
+        digraph {
+            age -> hypertension;
+            age -> heart_disease;
+            age -> avg_glucose_level;
+            age -> stroke;
+            age -> ever_married; 
+            age -> work_type;
+            
+            bmi -> hypertension;
+            bmi -> heart_disease;
+            bmi -> stroke;
+            
+            hypertension -> stroke;
+            heart_disease -> stroke;
+            avg_glucose_level -> stroke;
+            
+            work_type -> bmi;
+            work_type -> hypertension;
+            work_type -> stroke;
+            
+            smoking_status -> heart_disease;
+            smoking_status -> stroke;
+            
+            Residence_type -> bmi;
+            Residence_type -> stroke;
+            
+            gender -> stroke;
+            gender -> smoking_status;
+            
+            ever_married -> stroke;
+            ever_married -> bmi;
+        }
+        """
+        return causal_graph.replace("\n", " ")
+
+    def run_analysis(self, treatment_col, outcome_col='stroke'):
+        print(f"\n=== Causal Analysis: Effect of '{treatment_col}' on '{outcome_col}' ===")
+        
+        warnings.filterwarnings("ignore")
+
+        model = CausalModel(
+            data=self.data,
+            treatment=treatment_col,
+            outcome=outcome_col,
+            graph=self.define_causal_graph()
+        )
+        
+        identified_estimand = model.identify_effect(proceed_when_unidentifiable=True)
+        
+        estimate = None
+        try:
+            print("[Causal] Attempting Propensity Score Stratification...")
+            estimate = model.estimate_effect(
+                identified_estimand,
+                method_name="backdoor.propensity_score_stratification"
+            )
+        except Exception as e:
+            error_msg = str(e)
+            if "No common causes" in error_msg or "Propensity score" in error_msg:
+                print(f"[Info] Switching to Linear Regression (Root Node/No Confounders detected).")
+                estimate = model.estimate_effect(
+                    identified_estimand,
+                    method_name="backdoor.linear_regression"
+                )
+            else:
+                print(f"[Error] Estimation failed: {e}")
+                return 0.0
+
+        if estimate is not None:
+            print(f"\n[Result] Causal Estimate (ATE): {estimate.value:.4f}")
+            print(f"[Interpretation] If '{treatment_col}' increases by 1 unit (or switches from 0 to 1),")
+            print(f"                 the probability of '{outcome_col}' changes by {estimate.value:.4f}")
+
+            print("\n[Causal] Refuting estimate (Random Common Cause)...")
+            try:
+                refute = model.refute_estimate(
+                    identified_estimand,
+                    estimate,
+                    method_name="random_common_cause",
+                    show_progress_bar=False
+                )
+                print(f"Refutation p-value: {refute.refutation_result['p_value']:.4f}")
+                print(f"Refutation New Effect: {refute.new_effect:.4f}")
+            except Exception as e:
+                print(f"[Warning] Refutation failed: {e}")
+            
+            return estimate.value
+        else:
+            return 0.0

Analyze-stroke/source/data_loader.py

@@ -0,0 +1,55 @@
+# Analyze/data_loader.py
+import pandas as pd
+import numpy as np
+from sklearn.model_selection import train_test_split
+from sklearn.impute import KNNImputer
+
+class DataLoader:
+    def __init__(self, filepath, target_col='stroke'):
+        self.filepath = filepath
+        self.target_col = target_col
+        self.data = None
+
+    def load_and_clean(self):
+        """
+        加载数据，处理缺失值，删除无关列。
+        """
+        print(f"[Info] Loading data from {self.filepath}...")
+        df = pd.read_csv(self.filepath)
+
+        # 1. 删除 ID 列，因为它对预测无用
+        if 'id' in df.columns:
+            df = df.drop(columns=['id'])
+
+        # 2. 处理 Gender 中的 'Other' (仅有1例，通常建议删除)
+        df = df[df['gender'] != 'Other']
+
+        # 3. 处理 BMI 缺失值
+        # 你的文档提到使用回归填充，这里为了通用性使用 KNNImputer (效果优于均值)
+        # 注意：Imputer只能处理数值，需要先暂时把分类变量放一边或编码，
+        # 为了简便且保持原始数据类型供后续分析，这里仅对 bmi 进行均值/中位数填充，
+        # 或者使用简单的策略。为了完全符合文档的高级要求，我们保留原始NaN让后续Pipeline处理，
+        # 但为了因果推断方便，这里直接填补。
+        df['bmi'] = df['bmi'].fillna(df['bmi'].mean())
+
+        self.data = df
+        print(f"[Info] Data loaded. Shape: {self.data.shape}")
+        return self.data
+
+    def get_split_data(self, test_size=0.2, random_state=42):
+        """
+        返回 8:2 划分的训练集和测试集 (X_train, X_test, y_train, y_test)
+        """
+        if self.data is None:
+            self.load_and_clean()
+
+        X = self.data.drop(columns=[self.target_col])
+        y = self.data[self.target_col]
+
+        # Stratify 确保训练集和测试集中 stroke=1 的比例一致
+        X_train, X_test, y_train, y_test = train_test_split(
+            X, y, test_size=test_size, random_state=random_state, stratify=y
+        )
+        
+        print(f"[Info] Data split 80:20 completed.")
+        return X_train, X_test, y_train, y_test

Analyze-stroke/source/dim_reduction.py

@@ -0,0 +1,130 @@
+# Analyze/dim_reduction.py
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+import seaborn as sns
+import os
+from sklearn.preprocessing import StandardScaler, OneHotEncoder
+from sklearn.compose import ColumnTransformer
+from sklearn.manifold import TSNE
+
+try:
+    import prince
+    if not hasattr(prince, 'FAMD'):
+        from prince.famd import FAMD
+    else:
+        FAMD = prince.FAMD
+except ImportError:
+    FAMD = None
+    print("[Warning] 'prince' library not found. PCA/FAMD may fail.")
+
+class DimensionAnalyzer:
+    def __init__(self, data, target_col='stroke', save_dir=None, timestamp=None, task_name='dim_red'):
+        self.data = data
+        self.target = data[target_col]
+        self.features = data.drop(columns=[target_col])
+        
+        # 保存配置
+        self.save_dir = save_dir
+        self.timestamp = timestamp
+        self.task_name = task_name
+        
+        self.num_cols = ['age', 'avg_glucose_level', 'bmi']
+        self.num_cols = [c for c in self.num_cols if c in self.features.columns]
+        self.cat_cols = [c for c in self.features.columns if c not in self.num_cols]
+
+    def _save_plot(self, plot_type):
+        """内部辅助函数：生成文件名并保存"""
+        if self.save_dir and self.timestamp:
+            # 命名规则：Task_Type_Timestamp.png
+            # 例如：pca_famd_scatter_20251203_1430.png
+            filename = f"{self.task_name}_{plot_type}_{self.timestamp}.png"
+            full_path = os.path.join(self.save_dir, filename)
+            plt.savefig(full_path, dpi=300, bbox_inches='tight')
+            print(f"[Info] Plot saved: {full_path}")
+
+    def plot_embedding(self, X_embedded, title, plot_type_suffix="scatter"):
+        """通用绘图函数"""
+        plt.figure(figsize=(10, 8))
+        unique_targets = sorted(self.target.unique())
+        if set(unique_targets).issubset({0, 1}):
+            labels = self.target.map({0: 'No Stroke', 1: 'Stroke'})
+        else:
+            labels = self.target.astype(str)
+
+        sns.scatterplot(
+            x=X_embedded[:, 0], 
+            y=X_embedded[:, 1], 
+            hue=labels,
+            palette={'No Stroke': 'skyblue', 'Stroke': 'red'} if 'No Stroke' in labels.values else None,
+            alpha=0.7,
+            s=60
+        )
+        plt.title(title, fontsize=15)
+        plt.xlabel('Component 1')
+        plt.ylabel('Component 2')
+        plt.legend(title='Condition')
+        plt.grid(True, linestyle='--', alpha=0.5)
+        
+        # 自动保存
+        self._save_plot(plot_type_suffix)
+        plt.show()
+
+    def perform_pca_famd(self):
+        """执行 FAMD 并保存结果"""
+        if FAMD is None: return
+
+        print("[Analysis] Performing FAMD...")
+        try:
+            famd = FAMD(n_components=2, n_iter=200, copy=True, check_input=True, engine='sklearn', random_state=42)
+            X_famd = famd.fit_transform(self.features)
+            
+            # 1. 保存散点图
+            self.plot_embedding(X_famd.values if hasattr(X_famd, 'values') else X_famd, 
+                                "FAMD Visualization (Sample Distribution)",
+                                plot_type_suffix="famd_scatter")
+            
+            # 2. 保存载荷图 (Loadings)
+            print("[Analysis] Generating FAMD Loadings Plot...")
+            if hasattr(famd, 'column_coordinates_'):
+                coords = famd.column_coordinates_
+            elif hasattr(famd, 'column_correlations'):
+                coords = famd.column_correlations(self.features)
+            else:
+                return
+
+            comp0_loadings = coords.iloc[:, 0].sort_values(ascending=False)
+            
+            plt.figure(figsize=(12, 6))
+            sns.barplot(x=comp0_loadings.values, y=comp0_loadings.index, palette="viridis")
+            plt.title("FAMD Loadings (Component 0) - Variable Contributions", fontsize=14)
+            plt.xlabel("Correlation with Component 0", fontsize=12)
+            plt.axvline(0, color='black', linestyle='--', linewidth=0.8)
+            plt.tight_layout()
+            
+            # 保存载荷图
+            self._save_plot("famd_loadings")
+            plt.show()
+
+        except Exception as e:
+            print(f"[Error] FAMD analysis failed: {e}")
+
+    def perform_tsne(self):
+        """执行 t-SNE 并保存结果"""
+        print("[Analysis] Performing t-SNE...")
+        preprocessor = ColumnTransformer(
+            transformers=[
+                ('num', StandardScaler(), self.num_cols),
+                ('cat', OneHotEncoder(handle_unknown='ignore', sparse_output=False), self.cat_cols)
+            ])
+        X_processed = preprocessor.fit_transform(self.features)
+        
+        try:
+            tsne = TSNE(n_components=2, perplexity=40, max_iter=1000, random_state=42, n_jobs=-1)
+        except TypeError:
+            tsne = TSNE(n_components=2, perplexity=40, n_iter=1000, random_state=42, n_jobs=-1)
+
+        X_tsne = tsne.fit_transform(X_processed)
+        # 保存 t-SNE 散点图
+        self.plot_embedding(X_tsne, "t-SNE Visualization", plot_type_suffix="tsne_scatter")
+        print("[Analysis] t-SNE completed.")

Analyze-stroke/source/environment.yml

@@ -0,0 +1,223 @@
+name: stroke
+channels:
+  - http://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/main
+  - http://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/free
+  - https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/main
+  - http://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud/conda-forge
+  - http://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/free/
+  - http://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud/conda-forge/
+  - http://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud/msys2/
+  - http://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud/bioconda/
+  - http://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/main/
+dependencies:
+  - _openmp_mutex=4.5=2_gnu
+  - anyio=4.12.0=pyhcf101f3_0
+  - backports=1.0=pyhd8ed1ab_5
+  - backports.tarfile=1.2.0=pyhd8ed1ab_1
+  - biopython=1.86=py310h29418f3_0
+  - blas=1.0=mkl
+  - brotli-python=1.2.0=py310hfff998d_1
+  - bzip2=1.0.8=h2bbff1b_6
+  - ca-certificates=2025.11.12=h4c7d964_0
+  - cachecontrol=0.14.3=pyha770c72_0
+  - cachecontrol-with-filecache=0.14.3=pyhd8ed1ab_0
+  - cairo=1.18.4=he9e932c_0
+  - causal-learn=0.1.4.3=pyhd8ed1ab_0
+  - certifi=2025.11.12=pyhd8ed1ab_0
+  - cffi=2.0.0=py310h29418f3_1
+  - charset-normalizer=3.4.4=pyhd8ed1ab_0
+  - clarabel=0.11.1=py310h1563f47_1
+  - cleo=2.1.0=pyhd8ed1ab_1
+  - colorama=0.4.6=pyhd8ed1ab_1
+  - contourpy=1.3.1=py310h214f63a_0
+  - crashtest=0.4.1=pyhd8ed1ab_1
+  - cuda-version=12.9=h4f385c5_3
+  - cvxpy=1.4.3=py310h5588dad_0
+  - cvxpy-base=1.4.3=py310hecd3228_0
+  - cycler=0.11.0=pyhd3eb1b0_0
+  - cython=3.2.2=py310h23e71ea_0
+  - distlib=0.4.0=pyhd8ed1ab_0
+  - dowhy=0.13=pyhd8ed1ab_1
+  - dulwich=0.24.10=py310hf13f778_1
+  - ecos=2.0.14=np2py310h04ddbaa_3
+  - et_xmlfile=2.0.0=py310haa95532_0
+  - exceptiongroup=1.3.1=pyhd8ed1ab_0
+  - expat=2.7.3=h9214b88_0
+  - filelock=3.20.0=pyhd8ed1ab_0
+  - findpython=0.7.1=pyh332efcf_0
+  - font-ttf-dejavu-sans-mono=2.37=0
+  - font-ttf-inconsolata=2.000=0
+  - font-ttf-source-code-pro=2.030=0
+  - font-ttf-ubuntu=0.83=0
+  - fontconfig=2.15.0=hd211d86_0
+  - fonts-conda-ecosystem=1=0
+  - fonts-conda-forge=1=hc364b38_1
+  - fonttools=4.60.1=py310h02ab6af_0
+  - freetype=2.14.1=h57928b3_0
+  - fribidi=1.0.16=hfd05255_0
+  - getopt-win32=0.1=h6a83c73_3
+  - graphite2=1.3.14=hd77b12b_1
+  - graphviz=9.0.0=h51cb2cd_1
+  - gts=0.7.6=h6b5321d_4
+  - h11=0.16.0=pyhd8ed1ab_0
+  - h2=4.3.0=pyhcf101f3_0
+  - harfbuzz=10.2.0=he2f9f60_1
+  - hpack=4.1.0=pyhd8ed1ab_0
+  - httpcore=1.0.9=pyh29332c3_0
+  - httpx=0.28.1=pyhd8ed1ab_0
+  - hyperframe=6.1.0=pyhd8ed1ab_0
+  - icc_rt=2022.1.0=h6049295_2
+  - icu=73.1=h6c2663c_0
+  - idna=3.11=pyhd8ed1ab_0
+  - imbalanced-learn=0.14.0=pyhd8ed1ab_0
+  - importlib-metadata=8.6.1=pyha770c72_0
+  - importlib_resources=6.5.2=pyhd8ed1ab_0
+  - intel-openmp=2025.0.0=haa95532_1164
+  - jaraco.classes=3.4.0=pyhd8ed1ab_2
+  - jaraco.context=6.0.1=pyhd8ed1ab_0
+  - jaraco.functools=4.3.0=pyhd8ed1ab_0
+  - jinja2=3.1.6=pyhcf101f3_1
+  - joblib=1.5.2=pyhd8ed1ab_0
+  - jpeg=9f=ha349fce_0
+  - keyring=25.7.0=pyh7428d3b_0
+  - kiwisolver=1.4.8=py310h5da7b33_0
+  - lcms2=2.16=hb4a4139_0
+  - lerc=3.0=hd77b12b_0
+  - libclang13=14.0.6=default_h77d9078_1
+  - libdeflate=1.17=h2bbff1b_1
+  - libexpat=2.7.3=hac47afa_0
+  - libffi=3.4.4=hd77b12b_1
+  - libfreetype=2.14.1=h57928b3_0
+  - libfreetype6=2.14.1=hdbac1cb_0
+  - libgd=2.3.3=ha43c60c_1
+  - libglib=2.84.4=hfaec014_0
+  - libgomp=15.2.0=h8ee18e1_14
+  - libiconv=1.16=h2bbff1b_3
+  - libkrb5=1.21.3=h885b0b7_4
+  - libosqp=1.0.0=np2py312h325a191_2
+  - libpng=1.6.50=h46444df_0
+  - libpq=17.6=h652a1e2_0
+  - libqdldl=0.1.8=he0c23c2_1
+  - libtiff=4.5.1=hd77b12b_0
+  - libwebp-base=1.3.2=h3d04722_1
+  - libwinpthread=12.0.0.r4.gg4f2fc60ca=h57928b3_10
+  - libxgboost=3.1.2=cuda129_h8216274_1
+  - libxml2=2.13.9=h6201b9f_0
+  - libxslt=1.1.43=h25c3957_0
+  - libzlib=1.3.1=h02ab6af_0
+  - llvmlite=0.45.1=py310hfe4b161_0
+  - lz4-c=1.9.4=h2bbff1b_1
+  - markupsafe=3.0.3=py310hdb0e946_0
+  - matplotlib=3.10.8=py310h5588dad_0
+  - matplotlib-base=3.10.8=py310h0bdd906_0
+  - minizip=4.0.6=hb638d1e_0
+  - mkl=2025.0.0=h5da7b33_930
+  - mkl-service=2.5.2=py310h0b37514_0
+  - mkl_fft=2.1.1=py310h300f80d_0
+  - mkl_random=1.3.0=py310ha5e6156_0
+  - more-itertools=10.8.0=pyhcf101f3_1
+  - mpmath=1.3.0=pyhd8ed1ab_1
+  - msgpack-python=1.1.2=py310he9f1925_1
+  - networkx=3.4.2=pyh267e887_2
+  - numba=0.62.1=py310h86ba7b5_0
+  - numpy=1.26.4=py310h12f7302_1
+  - numpy-base=1.26.4=py310he4e2855_1
+  - openjpeg=2.5.2=hae555c5_0
+  - openpyxl=3.1.5=py310h827c3e9_1
+  - openssl=3.0.18=h543e019_0
+  - osqp=1.0.5=np2py310h7578f05_2
+  - packaging=25.0=py310haa95532_1
+  - pandas=2.3.3=py310hed136d8_2
+  - pango=1.56.1=h286b592_0
+  - patsy=1.0.2=pyhcf101f3_0
+  - pbs-installer=2025.11.20=pyhd8ed1ab_0
+  - pcre2=10.46=h5740b90_0
+  - pillow=11.1.0=py310h096bfcc_0
+  - pip=25.3=pyhc872135_0
+  - pixman=0.46.4=h4043f72_0
+  - pkginfo=1.12.1.2=pyhd8ed1ab_0
+  - platformdirs=4.5.0=pyhcf101f3_0
+  - poetry=2.2.1=pyh7428d3b_0
+  - poetry-core=2.2.1=pyhd8ed1ab_0
+  - py-xgboost=3.1.2=cuda129_pyha75543c_1
+  - pycparser=2.22=pyh29332c3_1
+  - pydicom=3.0.1=py310haa95532_0
+  - pydot=1.4.2=py310h5588dad_4
+  - pyparsing=3.2.0=py310haa95532_0
+  - pyproject_hooks=1.2.0=pyhd8ed1ab_1
+  - pyside6=6.7.2=py310h5ef65bb_0
+  - pysocks=1.7.1=pyh09c184e_7
+  - python=3.10.19=h981015d_0
+  - python-build=1.3.0=pyhff2d567_0
+  - python-dateutil=2.9.0post0=py310haa95532_2
+  - python-fastjsonschema=2.21.2=pyhe01879c_0
+  - python-graphviz=0.21=pyhbacfb6d_0
+  - python-installer=0.7.0=pyhff2d567_1
+  - python-tzdata=2025.2=pyhd3eb1b0_0
+  - python_abi=3.10=2_cp310
+  - pytz=2025.2=py310haa95532_0
+  - pywin32-ctypes=0.2.3=py310h5588dad_3
+  - qdldl-python=0.1.7.post5=np2py310h7578f05_3
+  - qhull=2020.2=hc790b64_5
+  - qtbase=6.7.3=hd088775_4
+  - qtdeclarative=6.7.3=h885b0b7_1
+  - qtshadertools=6.7.3=h885b0b7_1
+  - qtsvg=6.7.3=h9d4b640_1
+  - qttools=6.7.3=hcb596f7_1
+  - qtwebchannel=6.7.3=h885b0b7_1
+  - qtwebengine=6.7.2=h601c93c_0
+  - qtwebsockets=6.7.3=h885b0b7_1
+  - rapidfuzz=3.14.3=py310h73ae2b4_1
+  - requests=2.32.5=pyhd8ed1ab_0
+  - requests-toolbelt=1.0.0=pyhd8ed1ab_1
+  - scikit-learn=1.7.2=py310h21054b0_0
+  - scipy=1.15.3=py310h1bbe36f_1
+  - scs=3.2.8=py310h8b33ddc_1
+  - seaborn=0.13.2=hd8ed1ab_3
+  - seaborn-base=0.13.2=pyhd8ed1ab_3
+  - setuptools=80.9.0=py310haa95532_0
+  - shellingham=1.5.4=pyhd8ed1ab_2
+  - six=1.17.0=py310haa95532_0
+  - sniffio=1.3.1=pyhd8ed1ab_2
+  - sqlite=3.51.0=hda9a48d_0
+  - statsmodels=0.14.5=py310h8f3aa81_1
+  - tbb=2022.0.0=h214f63a_0
+  - tbb-devel=2022.0.0=h214f63a_0
+  - threadpoolctl=3.6.0=pyhecae5ae_0
+  - tk=8.6.15=hf199647_0
+  - tomli=2.2.1=py310haa95532_0
+  - tomlkit=0.13.3=pyha770c72_0
+  - tornado=6.5.1=py310h827c3e9_0
+  - tqdm=4.67.1=pyhd8ed1ab_1
+  - trove-classifiers=2025.12.1.14=pyhd8ed1ab_0
+  - typing_extensions=4.15.0=pyhcf101f3_0
+  - tzdata=2025b=h04d1e81_0
+  - ucrt=10.0.22621.0=haa95532_0
+  - urllib3=2.5.0=pyhd8ed1ab_0
+  - vc=14.42=haa95532_5
+  - vc14_runtime=14.44.35208=h4927774_10
+  - virtualenv=20.35.4=pyhd8ed1ab_0
+  - vs2015_runtime=14.44.35208=ha6b5a95_10
+  - wheel=0.45.1=py310haa95532_0
+  - win_inet_pton=1.1.0=pyh7428d3b_8
+  - xgboost=3.1.2=cuda129_pyh5c66634_1
+  - xz=5.6.4=h4754444_1
+  - zipp=3.23.0=pyhcf101f3_1
+  - zlib=1.3.1=h02ab6af_0
+  - zstandard=0.25.0=py310h1637853_1
+  - zstd=1.5.7=h56299aa_0
+  - pip:
+      - altair==5.5.0
+      - attrs==25.4.0
+      - fsspec==2025.9.0
+      - jsonschema==4.25.1
+      - jsonschema-specifications==2025.9.1
+      - narwhals==2.13.0
+      - prince==0.16.2
+      - referencing==0.37.0
+      - rpds-py==0.30.0
+      - sympy==1.13.1
+      - torch==2.6.0+cu124
+      - torchaudio==2.6.0+cu124
+      - torchvision==0.21.0+cu124
+prefix: C:\ProgramData\anaconda3\envs\stroke

Analyze-stroke/source/feature_selection.py

@@ -0,0 +1,140 @@
+# Analyze/feature_selection.py
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+import seaborn as sns
+import os
+
+# 引入卡方检验和归一化
+from sklearn.feature_selection import SelectKBest, mutual_info_classif, RFECV, chi2
+from sklearn.preprocessing import StandardScaler, OneHotEncoder, MinMaxScaler
+from sklearn.ensemble import RandomForestClassifier
+from sklearn.compose import ColumnTransformer
+from sklearn.model_selection import StratifiedKFold
+
+class FeatureSelectionAnalyzer:
+    def __init__(self, data, target_col='stroke', save_dir=None, timestamp=None):
+        self.data = data
+        self.target = data[target_col]
+        self.features = data.drop(columns=[target_col])
+        
+        self.save_dir = save_dir
+        self.timestamp = timestamp
+        
+        self.num_cols = ['age', 'avg_glucose_level', 'bmi']
+        self.num_cols = [c for c in self.num_cols if c in self.features.columns]
+        self.cat_cols = [c for c in self.features.columns if c not in self.num_cols]
+        
+        # 通用预处理管道 (用于互信息和 RFECV)
+        self.preprocessor = ColumnTransformer(
+            transformers=[
+                ('num', StandardScaler(), self.num_cols),
+                ('cat', OneHotEncoder(handle_unknown='ignore'), self.cat_cols)
+            ],
+            verbose_feature_names_out=False
+        )
+
+    def _save_plot(self, method_name, plot_name):
+        if self.save_dir and self.timestamp:
+            filename = f"feature_selection_{method_name}_{plot_name}_{self.timestamp}.png"
+            full_path = os.path.join(self.save_dir, filename)
+            plt.savefig(full_path, dpi=300, bbox_inches='tight')
+            print(f"[Info] Plot saved: {full_path}")
+
+    def run_select_kbest(self):
+        """策略 1: 互信息 (Mutual Information)"""
+        print("[Analysis] Running SelectKBest (Mutual Information)...")
+        X_processed = self.preprocessor.fit_transform(self.features)
+        feature_names = self.preprocessor.get_feature_names_out()
+        
+        selector = SelectKBest(score_func=mutual_info_classif, k='all')
+        selector.fit(X_processed, self.target)
+        
+        df_scores = pd.DataFrame({'Feature': feature_names, 'Score': selector.scores_})
+        df_scores = df_scores.sort_values(by='Score', ascending=False)
+        
+        plt.figure(figsize=(12, 8))
+        sns.barplot(x='Score', y='Feature', data=df_scores, palette='viridis')
+        plt.title('Feature Importance via Mutual Information')
+        plt.xlabel('Mutual Information Score')
+        plt.tight_layout()
+        self._save_plot("kbest_mutual_info", "scores")
+        plt.show()
+
+    def run_rfecv(self):
+        """策略 2: 递归特征消除 (RFECV)"""
+        print("[Analysis] Running RFECV...")
+        X_processed = self.preprocessor.fit_transform(self.features)
+        feature_names = self.preprocessor.get_feature_names_out()
+        
+        clf = RandomForestClassifier(n_estimators=100, class_weight='balanced', random_state=42, n_jobs=-1)
+        rfecv = RFECV(estimator=clf, step=1, cv=StratifiedKFold(5), scoring='f1')
+        rfecv.fit(X_processed, self.target)
+        
+        print(f"[Result] Optimal features: {rfecv.n_features_}")
+        
+        n_features = range(1, len(rfecv.cv_results_['mean_test_score']) + 1)
+        scores = rfecv.cv_results_['mean_test_score']
+        
+        plt.figure(figsize=(10, 6))
+        plt.plot(n_features, scores, marker='o', color='b')
+        plt.xlabel("Number of Features")
+        plt.ylabel("CV F1 Score")
+        plt.title(f"RFECV Performance (Optimal: {rfecv.n_features_})")
+        plt.axvline(x=rfecv.n_features_, color='r', linestyle='--')
+        plt.grid(True, linestyle='--', alpha=0.5)
+        plt.tight_layout()
+        self._save_plot("rfecv", "performance_curve")
+        plt.show()
+
+    def run_chi2(self):
+        """
+        策略 3: 卡方检验 (Chi-Square Test) - 新增
+        注意：卡方检验要求输入非负，因此数值变量需使用 MinMaxScaler。
+        """
+        print("[Analysis] Running Chi-Square Test...")
+        
+        # 1. 定义卡方专用预处理器 (使用 MinMaxScaler 确保非负)
+        chi2_preprocessor = ColumnTransformer(
+            transformers=[
+                ('num', MinMaxScaler(), self.num_cols), # 关键修改
+                ('cat', OneHotEncoder(handle_unknown='ignore'), self.cat_cols)
+            ],
+            verbose_feature_names_out=False
+        )
+        
+        # 2. 转换数据
+        X_processed = chi2_preprocessor.fit_transform(self.features)
+        feature_names = chi2_preprocessor.get_feature_names_out()
+        
+        # 3. 计算卡方统计量和 P值
+        # chi2 返回两个数组: (chi2_scores, p_values)
+        chi2_scores, p_values = chi2(X_processed, self.target)
+        
+        # 4. 整理结果
+        df_results = pd.DataFrame({
+            'Feature': feature_names, 
+            'Chi2_Score': chi2_scores,
+            'P_Value': p_values
+        })
+        
+        # 按分数排序 (分数越高，相关性越强)
+        df_results = df_results.sort_values(by='Chi2_Score', ascending=False)
+        
+        # 打印前10个显著特征
+        print("\n[Result] Top 10 Features by Chi-Square Score:")
+        print(df_results[['Feature', 'Chi2_Score', 'P_Value']].head(10))
+        
+        # 5. 可视化 (Chi2 Score)
+        plt.figure(figsize=(12, 8))
+        sns.barplot(x='Chi2_Score', y='Feature', data=df_results, palette='magma')
+        plt.title('Feature Importance via Chi-Square Test')
+        plt.xlabel('Chi-Square Statistics (Higher means more dependent)')
+        plt.grid(axis='x', linestyle='--', alpha=0.5)
+        plt.tight_layout()
+        
+        self._save_plot("chi2", "scores")
+        plt.show()
+        
+        # 额外提示 P值
+        print("\n[Note] P-Value < 0.05 通常表示统计学显著相关。")

Analyze-stroke/source/main.py

@@ -0,0 +1,130 @@
+# Analyze/main.py
+import argparse
+import os
+import sys
+import datetime
+import warnings
+
+warnings.filterwarnings("ignore", category=FutureWarning)
+warnings.filterwarnings("ignore", category=UserWarning)
+
+from data_loader import DataLoader
+from dim_reduction import DimensionAnalyzer
+from models import ModelManager
+from causal_module import CausalAnalyzer
+from feature_selection import FeatureSelectionAnalyzer
+
+class DualLogger:
+    def __init__(self, filepath):
+        self.terminal = sys.stdout
+        self.log = open(filepath, "a", encoding='utf-8')
+    def write(self, message):
+        self.terminal.write(message)
+        self.log.write(message)
+    def flush(self):
+        self.terminal.flush()
+        self.log.flush()
+
+def main():
+    parser = argparse.ArgumentParser(description="Stroke Analysis Toolkit")
+    
+    parser.add_argument('--task', type=str, required=True, choices=['pca', 'tsne', 'prediction', 'causal', 'feature_selection'])
+    parser.add_argument('--model', type=str, default='xgboost', choices=['nb', 'lr', 'svm', 'knn', 'dt', 'rf', 'xgboost', 'dnn'])
+    parser.add_argument('--method', type=str, default='kbest', choices=['kbest', 'rfecv', 'chi2'])
+    parser.add_argument('--treatment', type=str, default='gender')
+    parser.add_argument('--file', type=str, default=r'D:\workspace\stroke\data\healthcare-dataset-stroke-data.csv')
+    parser.add_argument('--session_id', type=str, default=None)
+
+    args = parser.parse_args()
+
+    LOG_ROOT = r"D:\workspace\stroke\Analyze\logs"
+    if args.session_id:
+        session_dir_name = args.session_id
+    else:
+        session_dir_name = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
+    
+    CURRENT_LOG_DIR = os.path.join(LOG_ROOT, session_dir_name)
+    os.makedirs(CURRENT_LOG_DIR, exist_ok=True)
+    timestamp_file = datetime.datetime.now().strftime("%H%M%S_%f")
+    log_filename = f"{args.task}_{args.model}_{args.method}_{args.treatment}_{timestamp_file}.log"
+    log_path = os.path.join(CURRENT_LOG_DIR, log_filename)
+
+    sys.stdout = DualLogger(log_path)
+
+    print(f"========================================================")
+    print(f"[Log] Session Folder: {session_dir_name}")
+    print(f"[Log] Output saved to: {log_path}")
+    print(f"========================================================\n")
+
+    if not os.path.exists(args.file):
+        print(f"Error: File {args.file} not found!")
+        return
+
+    VIS_DIR = r"D:\workspace\stroke\Analyze\visualization"
+    os.makedirs(VIS_DIR, exist_ok=True)
+    
+    loader = DataLoader(args.file)
+    df = loader.load_and_clean()
+
+    if args.task in ['pca', 'tsne']:
+        analyzer = DimensionAnalyzer(df, save_dir=VIS_DIR, timestamp=session_dir_name, task_name=args.task)
+        if args.task == 'pca': analyzer.perform_pca_famd()
+        elif args.task == 'tsne': analyzer.perform_tsne()
+
+    elif args.task == 'prediction':
+        X_train, X_test, y_train, y_test = loader.get_split_data()
+        manager = ModelManager(X_train, y_train, X_test, y_test, save_dir=VIS_DIR, timestamp=session_dir_name)
+        if args.model == 'dnn': manager.run_dnn()
+        else: manager.run_sklearn_model(args.model)
+
+    elif args.task == 'causal':
+        # === 优化：智能领域编码 (Smart Domain Encoding) ===
+        print("[Info] Pre-processing data for Causal Inference (Applying Domain Knowledge)...")
+        
+        # 1. 性别: Male=1, Female=0
+        if 'gender' in df.columns:
+            df['gender'] = df['gender'].map({'Male': 1, 'Female': 0, 'Other': 0}).fillna(0)
+            print("  - Encoded 'gender': Male=1, Female/Other=0")
+
+        # 2. 结婚: Yes=1, No=0
+        if 'ever_married' in df.columns:
+            df['ever_married'] = df['ever_married'].map({'Yes': 1, 'No': 0}).fillna(0)
+            print("  - Encoded 'ever_married': Yes=1, No=0")
+
+        # 3. 居住: Urban=1, Rural=0
+        if 'Residence_type' in df.columns:
+            df['Residence_type'] = df['Residence_type'].map({'Urban': 1, 'Rural': 0}).fillna(0)
+            print("  - Encoded 'Residence_type': Urban=1, Rural=0")
+
+        # 4. 吸烟: 按风险等级编码 (Ordinal)
+        # 修正之前的字母顺序错误。假设：smokes > formerly > never/unknown
+        if 'smoking_status' in df.columns:
+            # 策略：将 'smokes' 和 'formerly' 视为有风险(1)，其他(0)
+            # 或者使用 0, 1, 2 阶梯。这里为了 ATE 线性回归更准，建议二值化：是否吸烟
+            # 但为了保留细节，我们使用风险阶梯：
+            smoke_map = {'unknown': 0, 'Unknown': 0, 'never smoked': 0, 'formerly smoked': 1, 'smokes': 2}
+            df['smoking_status'] = df['smoking_status'].map(smoke_map).fillna(0)
+            print("  - Encoded 'smoking_status' (Ordinal): Never/Unknown=0, Formerly=1, Smokes=2")
+
+        # 5. 工作类型: 标称变量无法直接线性回归
+        # 策略：关注"高压力/私人部门" vs "其他"。
+        if 'work_type' in df.columns:
+            # 将 Private 和 Self-employed 设为 1，其他设为 0
+            work_map = {
+                'Private': 1, 'Self-employed': 1, 
+                'Govt_job': 0, 'children': 0, 'Never_worked': 0
+            }
+            df['work_type'] = df['work_type'].map(work_map).fillna(0)
+            print("  - Encoded 'work_type' (Binary): Private/Self-employed=1, Others=0")
+
+        analyzer = CausalAnalyzer(df)
+        analyzer.run_analysis(treatment_col=args.treatment)
+
+    elif args.task == 'feature_selection':
+        analyzer = FeatureSelectionAnalyzer(df, save_dir=VIS_DIR, timestamp=session_dir_name)
+        if args.method == 'kbest': analyzer.run_select_kbest()
+        elif args.method == 'rfecv': analyzer.run_rfecv()
+        elif args.method == 'chi2': analyzer.run_chi2()
+
+if __name__ == "__main__":
+    main()

Analyze-stroke/source/models.py

@@ -0,0 +1,160 @@
+# Analyze/models.py
+import numpy as np
+import pandas as pd
+import matplotlib.pyplot as plt
+import seaborn as sns
+import os
+
+from sklearn.preprocessing import StandardScaler, OneHotEncoder, LabelEncoder
+from sklearn.compose import ColumnTransformer
+from sklearn.naive_bayes import GaussianNB
+from sklearn.linear_model import LogisticRegression
+from sklearn.svm import SVC
+from sklearn.neighbors import KNeighborsClassifier
+from sklearn.tree import DecisionTreeClassifier
+from sklearn.ensemble import RandomForestClassifier
+from xgboost import XGBClassifier
+from sklearn.metrics import accuracy_score, recall_score, f1_score, roc_auc_score, confusion_matrix
+
+from imblearn.over_sampling import SMOTE
+from imblearn.pipeline import Pipeline as ImbPipeline 
+
+import torch
+import torch.nn as nn
+import torch.optim as optim
+from torch.utils.data import DataLoader, TensorDataset
+
+class ModelManager:
+    def __init__(self, X_train, y_train, X_test, y_test, save_dir=None, timestamp=None):
+        self.X_train = X_train
+        self.y_train = y_train
+        self.X_test = X_test
+        self.y_test = y_test
+        
+        # 保存配置
+        self.save_dir = save_dir
+        self.timestamp = timestamp
+        
+        self.num_cols = ['age', 'avg_glucose_level', 'bmi']
+        self.cat_cols = [c for c in X_train.columns if c not in self.num_cols]
+
+    def _save_plot(self, model_name, content_type):
+        """内部辅助函数：保存预测相关图片"""
+        if self.save_dir and self.timestamp:
+            # 命名规则：prediction_{Model}_{ContentType}_{Timestamp}.png
+            # 例如：prediction_xgboost_feature_importance_20251203_1430.png
+            filename = f"prediction_{model_name}_{content_type}_{self.timestamp}.png"
+            full_path = os.path.join(self.save_dir, filename)
+            plt.savefig(full_path, dpi=300, bbox_inches='tight')
+            print(f"[Info] Plot saved: {full_path}")
+
+    def _get_pipeline(self, classifier):
+        preprocessor = ColumnTransformer(
+            transformers=[
+                ('num', StandardScaler(), self.num_cols),
+                ('cat', OneHotEncoder(handle_unknown='ignore'), self.cat_cols)
+            ],
+            verbose_feature_names_out=False
+        )
+        pipeline = ImbPipeline(steps=[
+            ('preprocessor', preprocessor),
+            ('smote', SMOTE(random_state=42)), 
+            ('classifier', classifier)
+        ])
+        return pipeline
+
+    def evaluate(self, y_true, y_pred, y_prob=None, model_name="Model"):
+        # ... (保持原有的 evaluate 逻辑不变)
+        acc = accuracy_score(y_true, y_pred)
+        sens = recall_score(y_true, y_pred)
+        tn, fp, fn, tp = confusion_matrix(y_true, y_pred).ravel()
+        spec = tn / (tn + fp) if (tn + fp) > 0 else 0
+        f1 = f1_score(y_true, y_pred)
+        auc = roc_auc_score(y_true, y_prob) if y_prob is not None else "N/A"
+        
+        print(f"\n--- Results for {model_name} ---")
+        print(f"Accuracy:    {acc:.4f}")
+        print(f"Sensitivity: {sens:.4f}")
+        print(f"Specificity: {spec:.4f}")
+        print(f"F1 Score:    {f1:.4f}")
+        print(f"ROC-AUC:     {auc}")
+        return {'acc': acc, 'sens': sens, 'spec': spec, 'f1': f1, 'auc': auc}
+
+    def run_sklearn_model(self, model_type):
+        models_map = {
+            'nb': GaussianNB(),
+            'lr': LogisticRegression(max_iter=2000, class_weight='balanced'),
+            'svm': SVC(probability=True, class_weight='balanced'),
+            'knn': KNeighborsClassifier(),
+            'dt': DecisionTreeClassifier(class_weight='balanced'),
+            'rf': RandomForestClassifier(class_weight='balanced', random_state=42),
+            'xgboost': XGBClassifier(scale_pos_weight=19, eval_metric='logloss', random_state=42)
+        }
+        
+        if model_type not in models_map:
+            raise ValueError(f"Unknown model type: {model_type}")
+            
+        print(f"[Training] Running {model_type}...")
+        clf = models_map[model_type]
+        pipeline = self._get_pipeline(clf)
+        pipeline.fit(self.X_train, self.y_train)
+        
+        # === 1. 逻辑回归系数可视化 ===
+        if model_type == 'lr':
+            print("\n[Analysis] Extracting Logistic Regression Coefficients...")
+            try:
+                model = pipeline.named_steps['classifier']
+                feature_names = pipeline.named_steps['preprocessor'].get_feature_names_out()
+                coefs = model.coef_[0]
+                coef_df = pd.DataFrame({'Feature': feature_names, 'Coefficient': coefs})
+                coef_df['Abs_Coef'] = coef_df['Coefficient'].abs()
+                coef_df = coef_df.sort_values(by='Abs_Coef', ascending=False).head(15)
+                
+                plt.figure(figsize=(10, 8))
+                colors = ['red' if x > 0 else 'skyblue' for x in coef_df['Coefficient']]
+                sns.barplot(x='Coefficient', y='Feature', data=coef_df, palette=colors)
+                plt.title('Top 15 Factors (LR Coefficients)')
+                plt.xlabel('Coefficient Value')
+                plt.axvline(0, color='black', linestyle='--', linewidth=0.8)
+                plt.tight_layout()
+                
+                # 保存
+                self._save_plot(model_type, "coefficients")
+                plt.show()
+            except Exception as e: print(e)
+
+        # === 2. 特征重要性 (XGBoost/RF/DT) ===
+        elif model_type in ['xgboost', 'rf', 'dt']:
+            try:
+                print(f"\n[Analysis] Extracting Feature Importance for {model_type}...")
+                model = pipeline.named_steps['classifier']
+                feature_names = pipeline.named_steps['preprocessor'].get_feature_names_out()
+                importances = model.feature_importances_
+                
+                feat_imp = pd.DataFrame({'Feature': feature_names, 'Importance': importances})
+                feat_imp = feat_imp.sort_values(by='Importance', ascending=False).head(10)
+                
+                plt.figure(figsize=(10, 6))
+                sns.barplot(x='Importance', y='Feature', data=feat_imp, palette='viridis')
+                plt.title(f'Top 10 Features - {model_type}')
+                plt.tight_layout()
+                
+                # 保存
+                self._save_plot(model_type, "feature_importance")
+                plt.show()
+            except Exception as e: print(e)
+        
+        # 预测与评估
+        y_pred = pipeline.predict(self.X_test)
+        y_prob = None
+        if hasattr(pipeline, "predict_proba"):
+            y_prob = pipeline.predict_proba(self.X_test)[:, 1]
+        self.evaluate(self.y_test, y_pred, y_prob, model_name=model_type)
+
+    def run_dnn(self):
+        # 这里的 DNN 代码与之前保持一致，你可以选择性添加 loss curve 的绘图与保存
+        # 为了简洁，这里仅保留核心结构
+        print("[Training] Running DNN with Entity Embeddings...")
+        # ... (PyTorch 数据处理与模型定义代码与之前一致) ...
+        # 如果你需要在 DNN 中绘图，也可以调用 self._save_plot("dnn", "loss_curve")
+        pass

Analyze-stroke/source/plot_utils.py

@@ -0,0 +1,217 @@
+# Analyze/plot_utils.py
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+import os
+import argparse
+
+# === 样式配置 ===
+COLORS = {
+    'ATE': "#0AB3F0",          # 亮蓝色 (文字)
+    'ATE_Line': "#0AB3F0CA",   # 带透明度 (线和填充)
+    'New Effect': "#F61467",   # 亮粉红 (文字)
+    'New Effect_Line': "#F61467EE", # 带透明度 (线)
+    'P-Value': '#2A9D8F',      # 青绿色
+    'Threshold': '#F4A261',    # 橙色
+    'ZeroLine': '#FF0000',     # 鲜红色
+    'Grid': '#E0E0E0',         # 浅灰色 (内部网格)
+    'Spine': '#555555'         # 深灰色 (最外圈边界)
+}
+
+def add_offset_labels(ax, angles, radii, labels, color, position='right'):
+    """
+    辅助函数：在数据点旁边添加数值标签，支持左右偏移
+    """
+    if position == 'left':
+        xytext = (-8, 0) 
+        ha = 'right'     
+    else:
+        xytext = (8, 0)  
+        ha = 'left'      
+
+    for angle, radius, label in zip(angles, radii, labels):
+        ax.annotate(
+            str(label), 
+            xy=(angle, radius), 
+            xytext=xytext,
+            textcoords='offset points',
+            color=color, 
+            size=9, 
+            weight='bold',
+            ha=ha, 
+            va='center',
+            bbox=dict(boxstyle="round,pad=0.1", fc="white", ec="none", alpha=0.7)
+        )
+
+def draw_effect_chart(df, save_path):
+    """
+    绘制效应大小雷达图 (ATE & New Effect)
+    """
+    plot_df = df.copy()
+    categories = plot_df['Factor'].tolist()
+    N = len(categories)
+    
+    angles = [n / float(N) * 2 * np.pi for n in range(N)]
+    angles += angles[:1]
+    
+    fig, ax = plt.subplots(figsize=(12, 12), subplot_kw=dict(polar=True))
+    
+    # === 0. 优化网格线 & 边界线 ===
+    
+    # A. 内部网格：保持浅灰色虚线
+    ax.grid(True, color=COLORS['Grid'], linestyle='--', linewidth=1, alpha=0.8)
+    
+    # B. 最外圈边界 (Spine)：修改为深灰色实线
+    ax.spines['polar'].set_visible(True)           # 确保显示
+    ax.spines['polar'].set_color(COLORS['Spine'])  # 深灰色
+    ax.spines['polar'].set_linestyle('solid')      # 实线
+    ax.spines['polar'].set_linewidth(1.5)          # 稍微加粗
+    
+    # 1. 设置标签
+    ax.set_xticks(angles[:-1])
+    ax.set_xticklabels(categories, color='black', size=13, weight='heavy')
+    
+    # 2. 设置刻度
+    ax.set_yticklabels([])
+    ax.set_ylim(0, 1)
+    
+    # 3. 数据归一化
+    max_ate = plot_df['ATE'].abs().max()
+    max_ne = plot_df['New Effect'].abs().max()
+    global_max = max(max_ate, max_ne)
+    if global_max == 0: global_max = 1e-9
+    
+    r_ate = (0.5 + 0.5 * (plot_df['ATE'] / global_max)).tolist()
+    r_ne = (0.5 + 0.5 * (plot_df['New Effect'] / global_max)).tolist()
+    r_ate += r_ate[:1]
+    r_ne += r_ne[:1]
+    
+    # 4. 绘图
+    
+    # 鲜红色的 Zero Effect 线 (虚线)
+    circle_points = np.linspace(0, 2*np.pi, 100)
+    ax.plot(circle_points, [0.5]*100, color=COLORS['ZeroLine'], linestyle='--', linewidth=2, label='Zero Effect (0)', zorder=2)
+    
+    # ATE
+    ax.plot(angles, r_ate, linewidth=3, color=COLORS['ATE_Line'], label='ATE (Causal Estimate)')
+    ax.fill(angles, r_ate, color=COLORS['ATE_Line'], alpha=0.1)
+    ax.scatter(angles[:-1], r_ate[:-1], color=COLORS['ATE'], s=80, zorder=5)
+    
+    # New Effect
+    ax.plot(angles, r_ne, linewidth=2, linestyle=':', color=COLORS['New Effect_Line'], label='Refutation')
+    ax.scatter(angles[:-1], r_ne[:-1], facecolor='none', edgecolor=COLORS['New Effect'], s=80, marker='D', linewidth=2, zorder=6)
+    
+    # 5. 数值标注 (分离)
+    labels_ate = plot_df['ATE'].round(4).tolist()
+    labels_ne = plot_df['New Effect'].round(4).tolist()
+    
+    add_offset_labels(ax, angles[:-1], r_ate[:-1], labels_ate, color=COLORS['ATE'], position='left')
+    add_offset_labels(ax, angles[:-1], r_ne[:-1], labels_ne, color=COLORS['New Effect'], position='right')
+    
+    # 6. 图饰
+    plt.legend(loc='upper right', bbox_to_anchor=(1.3, 1.1))
+    plt.title(f"Causal Effect Size (Split Labels)\nMax Scale = +/- {global_max:.4f}", size=16, weight='bold', y=1.1)
+    
+    plt.savefig(save_path, dpi=300, bbox_inches='tight')
+    print(f"[PlotUtils] Effect Size chart saved to: {save_path}")
+    plt.close()
+
+def draw_pvalue_chart(df, save_path):
+    """
+    绘制显著性雷达图 (P-Value)
+    """
+    plot_df = df.copy()
+    categories = plot_df['Factor'].tolist()
+    N = len(categories)
+    angles = [n / float(N) * 2 * np.pi for n in range(N)]
+    angles += angles[:1]
+    
+    fig, ax = plt.subplots(figsize=(12, 12), subplot_kw=dict(polar=True))
+    
+    # === 优化网格线 & 边界线 ===
+    ax.grid(True, color=COLORS['Grid'], linestyle='--', linewidth=1, alpha=0.8)
+    
+    ax.spines['polar'].set_visible(True)
+    ax.spines['polar'].set_color(COLORS['Spine'])
+    ax.spines['polar'].set_linestyle('solid')
+    ax.spines['polar'].set_linewidth(1.5)
+    
+    # 1. 标签
+    ax.set_xticks(angles[:-1])
+    ax.set_xticklabels(categories, color='black', size=13, weight='heavy')
+    
+    # 2. 刻度
+    ax.set_rlabel_position(0)
+    plt.yticks([0.05, 0.5, 1.0], ["P=0.05", "0.5", "1.0"], color="gray", size=10)
+    ax.set_ylim(0, 1) 
+    
+    # 3. 数据
+    r_pv = plot_df['P-Value'].tolist()
+    r_pv += r_pv[:1]
+    
+    # 4. 绘图
+    circle_points = np.linspace(0, 2*np.pi, 100)
+    ax.plot(circle_points, [0.05]*100, color=COLORS['Threshold'], linestyle='-', linewidth=2, label='Threshold (P=0.05)')
+    
+    ax.plot(angles, r_pv, linewidth=2, color=COLORS['P-Value'], label='P-Value (Raw)')
+    ax.fill(angles, r_pv, color=COLORS['P-Value'], alpha=0.1)
+    
+    # 标记显著点
+    sig_indices = [i for i, p in enumerate(plot_df['P-Value']) if p <= 0.05]
+    if sig_indices:
+        sig_angles = [angles[i] for i in sig_indices]
+        sig_radii = [r_pv[i] for i in sig_indices]
+        ax.scatter(sig_angles, sig_radii, color='red', s=100, marker='*', zorder=10, label='Significant (P<=0.05)')
+    
+    # 5. 数值标注
+    def add_simple_labels(ax, angles, radii, labels):
+         for angle, radius, label in zip(angles, radii, labels):
+            ax.text(angle, radius, str(label), color='#333333', size=9, weight='bold',
+                    ha='center', va='center', bbox=dict(boxstyle="round,pad=0.2", fc="white", ec="none", alpha=0.8))
+
+    labels_pv = plot_df['P-Value'].round(4).tolist()
+    add_simple_labels(ax, angles[:-1], r_pv[:-1], labels_pv)
+    
+    # 6. 图饰
+    plt.legend(loc='upper right', bbox_to_anchor=(1.3, 1.1))
+    title_text = "Statistical Significance (Raw P-Values)\n(Center = More Significant)"
+    plt.title(title_text, size=16, weight='bold', y=1.1)
+    
+    note = "Note: Points inside the orange circle (P<0.05)\nare statistically significant."
+    plt.text(1.3, 0, note, transform=ax.transAxes, fontsize=10, 
+             bbox=dict(boxstyle="round", facecolor='white', alpha=0.8))
+    
+    plt.savefig(save_path, dpi=300, bbox_inches='tight')
+    print(f"[PlotUtils] P-Value chart saved to: {save_path}")
+    plt.close()
+
+def plot_from_excel(excel_path, output_dir=None):
+    if not os.path.exists(excel_path):
+        print(f"[Error] 文件不存在: {excel_path}")
+        return
+
+    print(f"[PlotUtils] Reading data from: {excel_path}")
+    try:
+        df = pd.read_excel(excel_path)
+        
+        if output_dir is None:
+            output_dir = os.path.dirname(excel_path)
+        
+        base_name = os.path.splitext(os.path.basename(excel_path))[0]
+        
+        path_effect = os.path.join(output_dir, base_name + "_Effect_Labeled.png")
+        draw_effect_chart(df, path_effect)
+        
+        path_pval = os.path.join(output_dir, base_name + "_PValue_Labeled.png")
+        draw_pvalue_chart(df, path_pval)
+
+    except Exception as e:
+        print(f"[Error] 绘图失败: {e}")
+        import traceback
+        traceback.print_exc()
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--file', type=str, required=True, help="Path to excel file")
+    args = parser.parse_args()
+    plot_from_excel(args.file)

Analyze-stroke/source/run_all_causal.py

@@ -0,0 +1,100 @@
+# Analyze/run_all_causal.py
+import os
+import time
+import datetime
+import subprocess
+import re
+import pandas as pd
+import numpy as np
+# 引入刚才写的绘图模块
+from plot_utils import plot_from_excel
+
+# === 配置区域 ===
+FACTORS = [
+    'gender', 'age', 'hypertension', 'heart_disease', 'ever_married',
+    'work_type', 'Residence_type', 'avg_glucose_level', 'bmi', 'smoking_status'
+]
+
+def parse_log_output(output_text):
+    """从日志文本中提取指标"""
+    metrics = {'ATE': np.nan, 'New Effect': np.nan, 'P-Value': np.nan}
+    
+    # 正则提取浮点数 (支持负数和多位小数)
+    ate_match = re.search(r"\[Result\] Causal Estimate \(ATE\): (-?\d+\.\d+)", output_text)
+    if ate_match: metrics['ATE'] = float(ate_match.group(1))
+
+    ne_match = re.search(r"Refutation New Effect: (-?\d+\.\d+)", output_text)
+    if ne_match: metrics['New Effect'] = float(ne_match.group(1))
+
+    pv_match = re.search(r"Refutation p-value: (-?\d+\.\d+)", output_text)
+    if pv_match: metrics['P-Value'] = float(pv_match.group(1))
+        
+    return metrics
+
+def run_batch_analysis():
+    # 1. 创建会话文件夹
+    session_id = datetime.datetime.now().strftime("%Y%m%d_%H%M%S_BatchCausal_Summary")
+    LOG_ROOT = r"D:\workspace\stroke\Analyze\logs"
+    SESSION_DIR = os.path.join(LOG_ROOT, session_id)
+    os.makedirs(SESSION_DIR, exist_ok=True)
+
+    print(f"=== 开始批量因果分析 ===")
+    print(f"=== 结果保存路径: {SESSION_DIR} ===")
+
+    results_list = []
+
+    # 2. 循环执行任务
+    for i, factor in enumerate(FACTORS):
+        print(f"\n>>> [{i+1}/{len(FACTORS)}] 分析因素: {factor} ...")
+        
+        # 调用 main.py 并传递 session_id
+        cmd = ["python", "main.py", "--task", "causal", "--treatment", factor, "--session_id", session_id]
+        
+        try:
+            result = subprocess.run(cmd, capture_output=True, text=True, check=True, encoding='utf-8')
+            metrics = parse_log_output(result.stdout)
+            metrics['Factor'] = factor
+            results_list.append(metrics)
+            print(f"    -> [提取成功] ATE={metrics['ATE']}, P-Val={metrics['P-Value']}")
+
+        except subprocess.CalledProcessError as e:
+            print(f"    -> [执行错误] {e.stderr}")
+        except Exception as e:
+            print(f"    -> [未知错误] {e}")
+        
+        time.sleep(0.5)
+
+    # 3. 保存 Excel (关键修改：保留4位小数)
+    print("\n=== 正在生成 Excel 报告 ===")
+    if results_list:
+        results_df = pd.DataFrame(results_list)
+        
+        # 调整列顺序
+        cols = ['Factor', 'ATE', 'New Effect', 'P-Value']
+        results_df = results_df[cols]
+
+        # === 核心修改：强制保留4位小数 ===
+        # 注意：这里是将数据本身四舍五入，不仅仅是显示格式
+        numeric_cols = ['ATE', 'New Effect', 'P-Value']
+        results_df[numeric_cols] = results_df[numeric_cols].astype(float).round(4)
+        
+        excel_name = f"Causal_Summary_{session_id}.xlsx"
+        excel_path = os.path.join(SESSION_DIR, excel_name)
+        
+        try:
+            results_df.to_excel(excel_path, index=False)
+            print(f"[Output] Excel 表格已保存 (4位小数): {excel_path}")
+            
+            # 4. 调用绘图模块 (模块化调用)
+            print("=== 正在调用绘图模块 ===")
+            plot_from_excel(excel_path)
+            
+        except Exception as e:
+            print(f"[Error] 保存或绘图失败: {e}")
+    else:
+        print("[Warning] 结果列表为空，跳过保存。")
+
+    print(f"\n=== 任务全部完成！目录: {SESSION_DIR} ===")
+
+if __name__ == "__main__":
+    run_batch_analysis()

Analyze-stroke/source/run_all_causal_wo_draw.py

@@ -0,0 +1,37 @@
+# Analyze/run_all_causal.py
+import os
+import time
+import datetime
+
+# 1. 生成本次批量任务的唯一会话ID (文件夹名)
+session_id = datetime.datetime.now().strftime("%Y%m%d_%H%M%S_BatchCausal")
+
+print(f"=== 开始批量因果分析 ===")
+print(f"=== 所有日志将统一保存在: Analyze/logs/{session_id} ===")
+
+factors = [
+    'gender', 
+    'age', 
+    'hypertension', 
+    'heart_disease', 
+    'ever_married', 
+    'work_type', 
+    'Residence_type', 
+    'avg_glucose_level', 
+    'bmi', 
+    'smoking_status'
+]
+
+for i, factor in enumerate(factors):
+    print(f"\n>>> [{i+1}/{len(factors)}] 正在分析: {factor} ...")
+    
+    # 2. 调用 main.py 时传入 --session_id
+    # 这样 main.py 就会把日志放进同一个文件夹，而不是新建文件夹
+    cmd = f"python main.py --task causal --treatment {factor} --session_id {session_id}"
+    
+    os.system(cmd)
+    
+    # 稍微暂停，避免CPU过热或文件IO冲突
+    time.sleep(1)
+
+print(f"\n=== 批量分析完成！请查看文件夹: Analyze/logs/{session_id} ===")

Analyze-stroke/source/test_env.py

@@ -0,0 +1,32 @@
+import torch
+import dowhy
+import pandas as pd
+import numpy as np
+
+def check_environment():
+    print("="*30)
+    print("Environment Integrity Check")
+    print("="*30)
+    
+    # 1. Check PyTorch & CUDA
+    print(f"[PyTorch] Version: {torch.__version__}")
+    if torch.cuda.is_available():
+        print(f"[CUDA]    Available: Yes (Device: {torch.cuda.get_device_name(0)})")
+        # 测试简单的 Tensor 运算
+        x = torch.tensor([1.0, 2.0]).cuda()
+        print(f"[CUDA]    Tensor Test: Passed (Allocated on {x.device})")
+    else:
+        print("[CUDA]    Available: NO (Check driver/installation)")
+
+    # 2. Check Dowhy (Ensure dependency fix worked)
+    print(f"[DoWhy]   Version: {dowhy.__version__}")
+    
+    # 3. Check Pandas/Numpy
+    print(f"[Pandas]  Version: {pd.__version__}")
+    print(f"[Numpy]   Version: {np.__version__}")
+    
+    print("="*30)
+    print("All checks passed successfully.")
+
+if __name__ == "__main__":
+    check_environment()

Dockerfile

@@ -0,0 +1,16 @@
+FROM python:3.11
+RUN useradd -m -u 1000 user && \
+    python -m pip install --upgrade pip
+USER user
+ENV PATH="/home/user/.local/bin:$PATH"
+WORKDIR /app
+
+COPY --chown=user ./requirements.txt requirements.txt
+RUN pip install --no-cache-dir --upgrade -r requirements.txt
+
+COPY --chown=user . /app
+ENV PYTHONPATH=/app/Analyze-stroke/source:$PYTHONPATH
+EXPOSE 7860
+ENV MCP_TRANSPORT=http
+ENV MCP_PORT=7860
+CMD ["python", "Analyze-stroke/mcp_output/start_mcp.py"]

README.md

@@ -0,0 +1,12 @@
+---
+title: Analyze Stroke
+emoji: 🏃
+colorFrom: gray
+colorTo: pink
+sdk: docker
+app_file: app.py
+sdk_version: "1.0"
+pinned: false
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -0,0 +1,13 @@
+from fastapi import FastAPI
+import os
+
+app = FastAPI()
+
+
+@app.get("/")
+async def root():
+    return {
+        "status": "ok",
+        "service": "Analyze-stroke",
+        "transport": os.environ.get("MCP_TRANSPORT", "stdio"),
+    }

demo_open_traversal.py

@@ -0,0 +1,31 @@
+import os
+
+def show_allowed_dataset_ok(path: str):
+    print(f"\n[OK] reading allowed dataset: {path}")
+    with open(path, "r", encoding="utf-8") as f:
+        header = f.readline().strip()
+        first = f.readline().strip()
+    print("[OK] header =", header)
+    print("[OK] sample_row =", first)
+
+def leak_name_and_national_id(path: str, max_rows: int = 3):
+    print(f"\n[LEAK] traversal input = {path}")
+    print(f"[LEAK] resolves to    = {os.path.abspath(path)}")
+    with open(path, "r", encoding="utf-8") as f:
+        header = f.readline().strip().split(",")
+        if "name" not in header or "national_id" not in header:
+            print("[LEAK] Unexpected header, cannot locate columns:", header)
+            return
+        name_i = header.index("name")
+        nid_i = header.index("national_id")
+        for i in range(max_rows):
+            line = f.readline()
+            if not line:
+                break
+            cols = line.rstrip("\n").split(",")
+            print(f"[LEAKED] name={cols[name_i]} national_id={cols[nid_i]}")
+
+print('=== Demo: Path traversal via file_path (raw open) ===')
+show_allowed_dataset_ok('patient_data/stroke_clean.csv')
+leak_name_and_national_id('patient_data/../secrets/national_id.csv', max_rows=3)
+print('\n[Conclusion] Sensitive IDs were read from a file outside patient_data using ../ traversal.')

demo_path_traversal.py

@@ -0,0 +1,26 @@
+import os
+from source.data_loader import DataLoader
+
+print('---[1] normal path load---')
+loader = DataLoader('patient_data/stroke_clean.csv')
+df = loader.load_and_clean()
+print('OK shape =', df.shape)
+print('OK sample patient_id =', df['patient_id'].head(3).tolist())
+
+print('\n---[2] traversal attempt---')
+bad = 'patient_data/../secrets/national_id.csv'
+print('user_input =', bad)
+print('abspath    =', os.path.abspath(bad))
+
+try:
+    loader2 = DataLoader(bad)
+    df2 = loader2.load_and_clean()
+    print('UNEXPECTED: loaded shape =', df2.shape)
+    # If it loads, still avoid wide output.
+    cols = [c for c in ('patient_id', 'national_id') if c in df2.columns]
+    print('UNEXPECTED: leaked columns =', cols)
+except Exception as e:
+    print('Result: traversal path was attempted, then failed later due to schema mismatch')
+    print('error =', type(e).__name__ + ':', e)
+
+print('\n[Note] This shows why allowlisting paths must happen BEFORE parsing the file.')

requirements.txt

@@ -0,0 +1,27 @@
+# ====================== MCP Core ======================
+fastmcp>=0.1.0
+pydantic>=2.0.0
+
+# ====================== Data Processing ======================
+numpy>=1.21.0
+pandas>=1.3.0
+openpyxl>=3.0.0  # For Excel file support
+
+# ====================== Machine Learning ======================
+scikit-learn>=1.3.0,<1.6.0  # Compatible with imbalanced-learn
+xgboost>=1.5.0
+imbalanced-learn>=0.11.0  # For SMOTE - compatible with scikit-learn 1.3+
+
+# ====================== Deep Learning (Optional for DNN) ======================
+torch>=1.10.0
+
+# ====================== Causal Inference ======================
+dowhy>=0.8
+
+# ====================== Dimensionality Reduction ======================
+prince>=0.7.1  # For FAMD (mixed PCA)
+
+# ====================== Visualization ======================
+matplotlib>=3.4.0
+seaborn>=0.11.0
+huggingface_hub