| # 情绪与生理状态变化预测模型 - 完整使用教程 |
|
|
| ## 目录 |
|
|
| 1. [项目概述](#项目概述) |
| 2. [安装指南](#安装指南) |
| 3. [快速开始](#快速开始) |
| 4. [数据准备](#数据准备) |
| 5. [模型训练](#模型训练) |
| 6. [模型推理](#模型推理) |
| 7. [配置文件](#配置文件) |
| 8. [命令行工具](#命令行工具) |
| 9. [常见问题](#常见问题) |
| 10. [故障排除](#故障排除) |
|
|
| ## 项目概述 |
|
|
| 本项目是一个基于深度学习的情绪与生理状态变化预测模型，使用多层感知机(MLP)来预测用户情绪和生理状态的变化。 |
|
|
| ### 核心功能 |
| - **输入**: 7维特征（User PAD 3维 + Vitality 1维 + Current PAD 3维） |
| - **输出**: 3维预测（ΔPAD：ΔPleasure, ΔArousal, ΔDominance） |
| - **模型**: 多层感知机(MLP)架构 |
| - **支持**: 训练、推理、评估、性能基准测试 |
|
|
| ### 技术栈 |
| - **深度学习框架**: PyTorch |
| - **数据处理**: NumPy, Pandas |
| - **可视化**: Matplotlib, Seaborn |
| - **配置管理**: YAML |
| - **命令行界面**: argparse |
|
|
| ## 安装指南 |
|
|
| ### 系统要求 |
| - Python 3.8 或更高版本 |
| - CUDA支持（可选，用于GPU加速） |
|
|
| ### 安装步骤 |
|
|
| 1. **克隆项目** |
| ```bash |
| git clone <repository-url> |
| cd ann-playground |
| ``` |
|
|
| 2. **创建虚拟环境** |
| ```bash |
| python -m venv venv |
| source venv/bin/activate # Linux/Mac |
| # 或 |
| venv\Scripts\activate # Windows |
| ``` |
|
|
| 3. **安装依赖** |
| ```bash |
| pip install -r requirements.txt |
| ``` |
|
|
| 4. **验证安装** |
| ```bash |
| python -c "import torch; print('PyTorch version:', torch.__version__)" |
| python -c "from src.models.pad_predictor import PADPredictor; print('Model import successful')" |
| ``` |
|
|
| ### 依赖包说明 |
|
|
| 核心依赖： |
| - `torch`: 深度学习框架 |
| - `numpy`: 数值计算 |
| - `pandas`: 数据处理 |
| - `matplotlib`, `seaborn`: 数据可视化 |
| - `scikit-learn`: 机器学习工具 |
| - `loguru`: 日志记录 |
| - `pyyaml`: 配置文件解析 |
| - `scipy`: 科学计算 |
|
|
| ## 快速开始 |
|
|
| ### 1. 运行快速开始教程 |
|
|
| 最简单的方式是运行快速开始教程： |
|
|
| ```bash |
| cd examples |
| python quick_start.py |
| ``` |
|
|
| 这将自动完成： |
| - 生成合成训练数据 |
| - 训练一个基础模型 |
| - 进行推理预测 |
| - 解释预测结果 |
|
|
| ### 2. 使用预训练模型 |
|
|
| 如果你有预训练的模型文件，可以直接进行推理： |
|
|
| ```python |
| from src.utils.inference_engine import create_inference_engine |
| |
| # 创建推理引擎 |
| engine = create_inference_engine( |
| model_path="path/to/model.pth", |
| preprocessor_path="path/to/preprocessor.pkl" |
| ) |
| |
| # 进行预测 |
| input_data = [0.5, 0.3, -0.2, 75.0, 0.1, 0.4, -0.1] |
| result = engine.predict(input_data) |
| print(result) |
| ``` |
|
|
| ### 3. 使用命令行工具 |
|
|
| 项目提供了完整的命令行工具： |
|
|
| ```bash |
| # 训练模型 |
| python -m src.cli.main train --config configs/training_config.yaml |
| |
| # 进行预测 |
| python -m src.cli.main predict --model model.pth --quick 0.5 0.3 -0.2 75.0 0.1 0.4 -0.1 |
| |
| # 评估模型 |
| python -m src.cli.main evaluate --model model.pth --data test_data.csv |
| |
| # 推理脚本 |
| python -m src.cli.main inference --model model.pth --input-cli 0.5 0.3 -0.2 75.0 0.1 0.4 -0.1 |
| |
| # 性能基准测试 |
| python -m src.cli.main benchmark --model model.pth --num-samples 1000 |
| ``` |
|
|
| ## 数据准备 |
|
|
| ### 数据格式 |
|
|
| #### 输入特征（7维） |
| | 特征名 | 类型 | 范围 | 说明 | |
| |--------|------|------|------| |
| | user_pleasure | float | [-1, 1] | 用户快乐度 | |
| | user_arousal | float | [-1, 1] | 用户激活度 | |
| | user_dominance | float | [-1, 1] | 用户支配度 | |
| | vitality | float | [0, 100] | 活力水平 | |
| | current_pleasure | float | [-1, 1] | 当前快乐度 | |
| | current_arousal | float | [-1, 1] | 当前激活度 | |
| | current_dominance | float | [-1, 1] | 当前支配度 | |
|
|
| #### 输出标签（3维） |
| | 标签名 | 类型 | 范围 | 说明 | |
| |--------|------|------|------| |
| | delta_pleasure | float | [-0.5, 0.5] | 快乐度变化量 | |
| | delta_arousal | float | [-0.5, 0.5] | 激活度变化量 | |
| | delta_dominance | float | [-0.5, 0.5] | 支配度变化量 | |
| | delta_pressure | float | [-0.3, 0.3] | 压力变化量 | |
| | confidence | float | [0, 1] | 预测置信度 | |
|
|
| ### 数据文件格式 |
|
|
| #### CSV格式 |
| ```csv |
| user_pleasure,user_arousal,user_dominance,vitality,current_pleasure,current_arousal,current_dominance,delta_pleasure,delta_arousal,delta_dominance,delta_pressure,confidence |
| 0.5,0.3,-0.2,80.0,0.1,0.4,-0.1,-0.05,0.02,0.03,-0.02,0.85 |
| -0.3,0.6,0.2,45.0,-0.1,0.7,0.1,0.08,-0.03,-0.01,0.05,0.72 |
| ... |
| ``` |
|
|
| #### JSON格式 |
| ```json |
| [ |
| { |
| "user_pleasure": 0.5, |
| "user_arousal": 0.3, |
| "user_dominance": -0.2, |
| "vitality": 80.0, |
| "current_pleasure": 0.1, |
| "current_arousal": 0.4, |
| "current_dominance": -0.1, |
| "delta_pleasure": -0.05, |
| "delta_arousal": 0.02, |
| "delta_dominance": 0.03, |
| "delta_pressure": -0.02, |
| "confidence": 0.85 |
| }, |
| ... |
| ] |
| ``` |
|
|
| ### 合成数据生成 |
|
|
| 项目提供了合成数据生成器： |
|
|
| ```python |
| from src.data.synthetic_generator import SyntheticDataGenerator |
| |
| # 创建数据生成器 |
| generator = SyntheticDataGenerator(num_samples=1000, seed=42) |
| |
| # 生成数据 |
| features, labels = generator.generate_data() |
| |
| # 保存数据 |
| generator.save_data(features, labels, "output_data.csv", format='csv') |
| ``` |
|
|
| ### 数据预处理 |
|
|
| ```python |
| from src.data.preprocessor import DataPreprocessor |
| |
| # 创建预处理器 |
| preprocessor = DataPreprocessor() |
| |
| # 拟合预处理器 |
| preprocessor.fit(train_features, train_labels) |
| |
| # 转换数据 |
| processed_features, processed_labels = preprocessor.transform(features, labels) |
| |
| # 保存预处理器 |
| preprocessor.save("preprocessor.pkl") |
| ``` |
|
|
| ## 模型训练 |
|
|
| ### 基础训练 |
|
|
| ```python |
| from src.models.pad_predictor import PADPredictor |
| from src.utils.trainer import ModelTrainer |
| from torch.utils.data import DataLoader, TensorDataset |
| |
| # 创建模型 |
| model = PADPredictor( |
| input_dim=7, |
| output_dim=3, |
| hidden_dims=[128, 64, 32], |
| dropout_rate=0.3 |
| ) |
| |
| # 创建数据加载器 |
| dataset = TensorDataset( |
| torch.FloatTensor(processed_features), |
| torch.FloatTensor(processed_labels) |
| ) |
| train_loader = DataLoader(dataset, batch_size=32, shuffle=True) |
| |
| # 创建训练器 |
| trainer = ModelTrainer(model, preprocessor) |
| |
| # 训练配置 |
| config = { |
| 'epochs': 100, |
| 'learning_rate': 0.001, |
| 'weight_decay': 1e-4, |
| 'patience': 10, |
| 'save_dir': './models' |
| } |
| |
| # 开始训练 |
| history = trainer.train(train_loader, val_loader, config) |
| ``` |
|
|
| ### 使用配置文件训练 |
|
|
| 创建训练配置文件 `my_training_config.yaml`： |
|
|
| ```yaml |
| training: |
| epochs: 100 |
| learning_rate: 0.001 |
| weight_decay: 0.0001 |
| batch_size: 32 |
| |
| optimizer: |
| type: "Adam" |
| lr: 0.001 |
| weight_decay: 0.0001 |
| |
| scheduler: |
| type: "ReduceLROnPlateau" |
| patience: 5 |
| factor: 0.5 |
| |
| early_stopping: |
| patience: 10 |
| min_delta: 0.001 |
| |
| data: |
| train_ratio: 0.8 |
| val_ratio: 0.1 |
| test_ratio: 0.1 |
| shuffle: True |
| seed: 42 |
| ``` |
|
|
| 运行训练： |
|
|
| ```bash |
| python -m src.cli.main train --config my_training_config.yaml |
| ``` |
|
|
| ### 训练监控 |
|
|
| 训练过程中会自动保存： |
| - 最佳模型检查点 |
| - 训练历史记录 |
| - 验证指标 |
| - 学习率变化 |
|
|
| 可视化训练过程： |
|
|
| ```python |
| import matplotlib.pyplot as plt |
| |
| # 绘制损失曲线 |
| plt.figure(figsize=(10, 6)) |
| plt.plot(history['train_loss'], label='Training Loss') |
| plt.plot(history['val_loss'], label='Validation Loss') |
| plt.xlabel('Epoch') |
| plt.ylabel('Loss') |
| plt.legend() |
| plt.show() |
| ``` |
|
|
| ### 模型评估 |
|
|
| ```python |
| from src.models.metrics import RegressionMetrics |
| |
| # 创建指标计算器 |
| metrics_calculator = RegressionMetrics() |
| |
| # 计算指标 |
| metrics = metrics_calculator.calculate_all_metrics( |
| true_labels, predictions |
| ) |
| |
| print(f"MSE: {metrics['mse']:.4f}") |
| print(f"MAE: {metrics['mae']:.4f}") |
| print(f"R²: {metrics['r2']:.4f}") |
| ``` |
|
|
| ## 模型推理 |
|
|
| ### 单样本推理 |
|
|
| ```python |
| from src.utils.inference_engine import create_inference_engine |
| |
| # 创建推理引擎 |
| engine = create_inference_engine( |
| model_path="models/best_model.pth", |
| preprocessor_path="models/preprocessor.pkl" |
| ) |
| |
| # 单样本预测 |
| input_data = [0.5, 0.3, -0.2, 75.0, 0.1, 0.4, -0.1] |
| result = engine.predict(input_data) |
| |
| print(f"ΔPAD: {result['delta_pad']}") |
| print(f"ΔPressure: {result['delta_pressure']}") |
| print(f"Confidence: {result['confidence']}") |
| ``` |
|
|
| ### 批量推理 |
|
|
| ```python |
| # 批量预测 |
| batch_inputs = [ |
| [0.5, 0.3, -0.2, 75.0, 0.1, 0.4, -0.1], |
| [-0.3, 0.6, 0.2, 45.0, -0.1, 0.7, 0.1], |
| [0.8, -0.4, 0.6, 90.0, 0.7, -0.3, 0.5] |
| ] |
| |
| batch_results = engine.predict_batch(batch_inputs) |
| |
| for i, result in enumerate(batch_results): |
| print(f"Sample {i+1}: {result}") |
| ``` |
|
|
| ### 从文件推理 |
|
|
| ```python |
| import pandas as pd |
| |
| # 从CSV文件读取输入 |
| input_df = pd.read_csv('input_data.csv') |
| results = engine.predict_batch(input_df.values.tolist()) |
| |
| # 保存结果 |
| output_df = pd.DataFrame(results) |
| output_df.to_csv('output_results.csv', index=False) |
| ``` |
|
|
| ### 性能优化 |
|
|
| ```python |
| # 预热模型（提高首次推理速度） |
| for _ in range(5): |
| engine.predict([0.5, 0.3, -0.2, 75.0, 0.1, 0.4, -0.1]) |
| |
| # 性能基准测试 |
| stats = engine.benchmark(num_samples=1000, batch_size=32) |
| print(f"Throughput: {stats['throughput']:.2f} samples/sec") |
| print(f"Average latency: {stats['avg_latency']:.2f}ms") |
| ``` |
|
|
| ## 配置文件 |
|
|
| ### 模型配置 (`configs/model_config.yaml`) |
| |
| ```yaml |
| # 模型基本信息 |
| model_info: |
| name: "MLP_Emotion_Predictor" |
| type: "MLP" |
| version: "1.0" |
|
|
| # 输入输出维度 |
| dimensions: |
| input_dim: 7 |
| output_dim: 3 |
|
|
| # 网络架构参数 |
| architecture: |
| hidden_layers: |
| - size: 128 |
| activation: "ReLU" |
| dropout: 0.2 |
| - size: 64 |
| activation: "ReLU" |
| dropout: 0.2 |
| - size: 32 |
| activation: "ReLU" |
| dropout: 0.1 |
| |
| output_layer: |
| activation: "Linear" |
| |
| # 初始化参数 |
| initialization: |
| weight_init: "xavier_uniform" |
| bias_init: "zeros" |
| |
| # 正则化参数 |
| regularization: |
| weight_decay: 0.0001 |
| dropout_config: |
| type: "standard" |
| rate: 0.2 |
| ``` |
| |
| ### 训练配置 (`configs/training_config.yaml`) |
|
|
| ```yaml |
| # 训练参数 |
| training: |
| epochs: 100 |
| learning_rate: 0.001 |
| weight_decay: 0.0001 |
| batch_size: 32 |
| seed: 42 |
| |
| # 优化器配置 |
| optimizer: |
| type: "Adam" |
| lr: 0.001 |
| weight_decay: 0.0001 |
| betas: [0.9, 0.999] |
| |
| # 学习率调度器 |
| scheduler: |
| type: "ReduceLROnPlateau" |
| patience: 5 |
| factor: 0.5 |
| min_lr: 1e-6 |
| |
| # 早停配置 |
| early_stopping: |
| patience: 10 |
| min_delta: 0.001 |
| monitor: "val_loss" |
| |
| # 数据配置 |
| data: |
| train_ratio: 0.8 |
| val_ratio: 0.1 |
| test_ratio: 0.1 |
| shuffle: True |
| num_workers: 4 |
| |
| # 保存配置 |
| saving: |
| save_dir: "./outputs" |
| save_best_only: True |
| checkpoint_interval: 10 |
| ``` |
|
|
| ### 数据配置 (`configs/data_config.yaml`) |
| |
| ```yaml |
| # 数据路径配置 |
| paths: |
| train_data: "data/train.csv" |
| val_data: "data/val.csv" |
| test_data: "data/test.csv" |
|
|
| # 数据预处理配置 |
| preprocessing: |
| normalize_features: True |
| normalize_labels: True |
| feature_scaler: "standard" # standard, minmax, robust |
| label_scaler: "standard" |
|
|
| # 数据增强配置 |
| augmentation: |
| enabled: False |
| noise_std: 0.01 |
| augmentation_factor: 2 |
|
|
| # 合成数据配置 |
| synthetic_data: |
| num_samples: 1000 |
| seed: 42 |
| add_noise: True |
| add_correlations: True |
| ``` |
| |
| ## 命令行工具 |
| |
| ### 训练命令 |
| |
| ```bash |
| # 基础训练 |
| python -m src.cli.main train --config configs/training_config.yaml |
| |
| # 指定输出目录 |
| python -m src.cli.main train --config configs/training_config.yaml --output-dir ./my_models |
| |
| # 使用GPU训练 |
| python -m src.cli.main train --config configs/training_config.yaml --device cuda |
|
|
| # 从检查点恢复训练 |
| python -m src.cli.main train --config configs/training_config.yaml --resume checkpoints/epoch_50.pth |
|
|
| # 覆盖配置参数 |
| python -m src.cli.main train --config configs/training_config.yaml --epochs 200 --batch-size 64 --learning-rate 0.0005 |
| ``` |
| |
| ### 预测命令 |
| |
| ```bash |
| # 交互式预测 |
| python -m src.cli.main predict --model model.pth --interactive |
| |
| # 快速预测 |
| python -m src.cli.main predict --model model.pth --quick 0.5 0.3 -0.2 75.0 0.1 0.4 -0.1 |
| |
| # 批量预测 |
| python -m src.cli.main predict --model model.pth --batch input.csv --output results.csv |
| |
| # 指定预处理器 |
| python -m src.cli.main predict --model model.pth --preprocessor preprocessor.pkl --quick 0.5 0.3 -0.2 75.0 0.1 0.4 -0.1 |
| ``` |
| |
| ### 评估命令 |
| |
| ```bash |
| # 基础评估 |
| python -m src.cli.main evaluate --model model.pth --data test_data.csv |
|
|
| # 生成详细报告 |
| python -m src.cli.main evaluate --model model.pth --data test_data.csv --report evaluation_report.html |
|
|
| # 指定评估指标 |
| python -m src.cli.main evaluate --model model.pth --data test_data.csv --metrics mse mae r2 |
| |
| # 自定义批次大小 |
| python -m src.cli.main evaluate --model model.pth --data test_data.csv --batch-size 64 |
| ``` |
| |
| ### 推理命令 |
| |
| ```bash |
| # 命令行输入推理 |
| python -m src.cli.main inference --model model.pth --input-cli 0.5 0.3 -0.2 75.0 0.1 0.4 -0.1 |
|
|
| # JSON文件推理 |
| python -m src.cli.main inference --model model.pth --input-json input.json --output-json output.json |
|
|
| # CSV文件推理 |
| python -m src.cli.main inference --model model.pth --input-csv input.csv --output-csv output.csv |
|
|
| # 基准测试 |
| python -m src.cli.main inference --model model.pth --benchmark --num-samples 1000 |
|
|
| # 静默模式 |
| python -m src.cli.main inference --model model.pth --input-cli 0.5 0.3 -0.2 75.0 0.1 0.4 -0.1 --quiet |
| ``` |
| |
| ### 基准测试命令 |
| |
| ```bash |
| # 标准基准测试 |
| python -m src.cli.main benchmark --model model.pth |
|
|
| # 自定义测试参数 |
| python -m src.cli.main benchmark --model model.pth --num-samples 5000 --batch-size 64 |
|
|
| # 生成性能报告 |
| python -m src.cli.main benchmark --model model.pth --report performance_report.json |
| |
| # 详细输出 |
| python -m src.cli.main benchmark --model model.pth --verbose |
| ``` |
| |
| ## 常见问题 |
| |
| ### Q1: 如何处理缺失值？ |
| A: 项目目前不支持缺失值处理。请在数据预处理阶段使用以下方法： |
| ```python |
| # 删除包含缺失值的行 |
| df = df.dropna() |
| |
| # 或填充缺失值 |
| df = df.fillna(df.mean()) # 用均值填充 |
| df = df.fillna(0) # 用0填充 |
| ``` |
| |
| ### Q2: 如何自定义模型架构？ |
| A: 有两种方式自定义模型架构： |
| |
| **方式1：修改配置文件** |
| ```yaml |
| # 在 model_config.yaml 中修改 |
| architecture: |
| hidden_layers: |
| - size: 256 # 增加神经元数量 |
| activation: "ReLU" |
| dropout: 0.3 |
| - size: 128 |
| activation: "ReLU" |
| dropout: 0.2 |
| - size: 64 |
| activation: "ReLU" |
| dropout: 0.1 |
| ``` |
| |
| **方式2：直接创建模型** |
| ```python |
| from src.models.pad_predictor import PADPredictor |
|
|
| model = PADPredictor( |
| input_dim=7, |
| output_dim=3, |
| hidden_dims=[256, 128, 64, 32], # 自定义隐藏层 |
| dropout_rate=0.3 |
| ) |
| ``` |
| |
| ### Q3: 如何处理类别特征？ |
| A: 当前版本只支持数值特征。如果有类别特征，需要先进行编码： |
| ```python |
| # One-Hot编码 |
| df_encoded = pd.get_dummies(df, columns=['category_column']) |
| |
| # 或标签编码 |
| from sklearn.preprocessing import LabelEncoder |
| le = LabelEncoder() |
| df['category_encoded'] = le.fit_transform(df['category_column']) |
| ``` |
|
|
| ### Q4: 如何提高模型性能？ |
| A: 尝试以下方法： |
| 1. **增加训练数据量** |
| 2. **调整模型架构**（增加层数或神经元数量） |
| 3. **优化超参数**（学习率、批次大小等） |
| 4. **数据增强**（添加噪声或合成数据） |
| 5. **正则化**（调整dropout、weight_decay） |
| 6. **早停**（防止过拟合） |
| |
| ### Q5: 如何部署模型到生产环境？ |
| A: 推荐的部署方式： |
| 1. **保存模型和预处理器** |
| 2. **创建推理服务** |
| 3. **使用FastAPI或Flask封装** |
| 4. **容器化部署** |
| |
| 示例： |
| ```python |
| from fastapi import FastAPI |
| from src.utils.inference_engine import create_inference_engine |
|
|
| app = FastAPI() |
| engine = create_inference_engine("model.pth", "preprocessor.pkl") |
|
|
| @app.post("/predict") |
| async def predict(input_data: list): |
| result = engine.predict(input_data) |
| return result |
| ``` |
| |
| ### Q6: 如何处理大规模数据？ |
| A: 对于大规模数据： |
| 1. **使用数据生成器**（DataGenerator） |
| 2. **分批处理** |
| 3. **使用多进程数据加载** |
| 4. **考虑使用分布式训练** |
|
|
| ```python |
| # 使用多进程数据加载 |
| train_loader = DataLoader( |
| dataset, |
| batch_size=32, |
| shuffle=True, |
| num_workers=4, # 多进程 |
| pin_memory=True # GPU内存优化 |
| ) |
| ``` |
|
|
| ### Q7: 如何可视化预测结果？ |
| A: 项目提供了多种可视化方法： |
| ```python |
| import matplotlib.pyplot as plt |
| import seaborn as sns |
| |
| # 预测值vs真实值散点图 |
| plt.scatter(true_labels, predictions, alpha=0.6) |
| plt.plot([min_val, max_val], [min_val, max_val], 'r--') |
| plt.xlabel('True Values') |
| plt.ylabel('Predictions') |
| plt.show() |
| |
| # 残差图 |
| residuals = true_labels - predictions |
| plt.hist(residuals, bins=30) |
| plt.xlabel('Residuals') |
| plt.ylabel('Frequency') |
| plt.show() |
| ``` |
|
|
| ### Q8: 如何进行模型版本管理？ |
| A: 建议的版本管理策略： |
| 1. **使用语义化版本号** |
| 2. **保存训练配置和超参数** |
| 3. **记录模型性能指标** |
| 4. **使用模型注册表** |
|
|
| ```python |
| # 保存模型信息 |
| model_info = { |
| 'version': '1.2.0', |
| 'architecture': str(model), |
| 'training_config': config, |
| 'performance': metrics, |
| 'created_at': datetime.now().isoformat() |
| } |
| |
| torch.save({ |
| 'model_state_dict': model.state_dict(), |
| 'model_info': model_info |
| }, f'model_v{model_info["version"]}.pth') |
| ``` |
|
|
| ## 故障排除 |
|
|
| ### 常见错误及解决方案 |
|
|
| #### 1. CUDA内存不足 |
| ``` |
| RuntimeError: CUDA out of memory |
| ``` |
| **解决方案**： |
| - 减小批次大小 |
| - 使用CPU训练：`--device cpu` |
| - 清理GPU缓存：`torch.cuda.empty_cache()` |
|
|
| #### 2. 模型加载失败 |
| ``` |
| FileNotFoundError: [Errno 2] No such file or directory: 'model.pth' |
| ``` |
| **解决方案**： |
| - 检查文件路径是否正确 |
| - 确保模型文件存在 |
| - 检查文件权限 |
|
|
| #### 3. 数据维度不匹配 |
| ``` |
| RuntimeError: mat1 and mat2 shapes cannot be multiplied |
| ``` |
| **解决方案**： |
| - 检查输入数据维度（应为7维） |
| - 确保数据预处理正确 |
| - 验证模型配置 |
|
|
| #### 4. 导入错误 |
| ``` |
| ModuleNotFoundError: No module named 'src.xxx' |
| ``` |
| **解决方案**： |
| - 检查Python路径设置 |
| - 确保在项目根目录运行 |
| - 重新安装依赖包 |
|
|
| #### 5. 配置文件错误 |
| ``` |
| yaml.scanner.ScannerError: while scanning for the next token |
| ``` |
| **解决方案**： |
| - 检查YAML文件语法 |
| - 确保缩进正确 |
| - 使用YAML验证工具 |
|
|
| ### 调试技巧 |
|
|
| #### 1. 启用详细日志 |
| ```bash |
| python -m src.cli.main train --config configs/training_config.yaml --verbose --log-level DEBUG |
| ``` |
|
|
| #### 2. 使用小数据集测试 |
| ```python |
| # 使用少量数据快速测试 |
| generator = SyntheticDataGenerator(num_samples=100, seed=42) |
| features, labels = generator.generate_data() |
| ``` |
|
|
| #### 3. 检查模型输出 |
| ```python |
| # 检查模型输出形状 |
| model.eval() |
| with torch.no_grad(): |
| sample_input = torch.randn(1, 7) |
| output = model(sample_input) |
| print(f"Output shape: {output.shape}") |
| print(f"Output range: [{output.min():.3f}, {output.max():.3f}]") |
| ``` |
|
|
| #### 4. 验证数据预处理 |
| ```python |
| # 检查预处理后的数据 |
| print(f"Features mean: {processed_features.mean(axis=0)}") |
| print(f"Features std: {processed_features.std(axis=0)}") |
| print(f"Labels mean: {processed_labels.mean(axis=0)}") |
| print(f"Labels std: {processed_labels.std(axis=0)}") |
| ``` |
|
|
| ### 性能优化建议 |
|
|
| #### 1. 训练优化 |
| - 使用合适的批次大小 |
| - 启用混合精度训练（AMP） |
| - 使用学习率调度器 |
| - 实施早停机制 |
|
|
| #### 2. 推理优化 |
| - 模型预热 |
| - 批量推理 |
| - 模型量化 |
| - 使用ONNX格式 |
|
|
| #### 3. 内存优化 |
| - 使用数据生成器 |
| - 及时释放不需要的变量 |
| - 使用梯度累积 |
|
|
| --- |
|
|
| ## 联系方式 |
|
|
| 如有其他问题或需要帮助，请通过以下方式联系： |
| - 项目仓库: [GitHub仓库链接] |
| - 问题反馈: [Issues链接] |
| - 文档: [文档链接] |
| - 邮箱: [联系邮箱] |
|
|
| --- |
|
|
| **注意**: 本教程基于项目当前版本编写，随着项目更新，部分内容可能会有变化。请及时查看最新文档。 |
