| # API参考文档 |
|
|
| 本文档详细介绍了情绪与生理状态变化预测模型的所有API接口、类和函数。 |
|
|
| ## 目录 |
|
|
| 1. [模型类](#模型类) |
| 2. [数据处理类](#数据处理类) |
| 3. [工具类](#工具类) |
| 4. [损失函数](#损失函数) |
| 5. [评估指标](#评估指标) |
| 6. [工厂函数](#工厂函数) |
| 7. [命令行接口](#命令行接口) |
|
|
| ## 模型类 |
|
|
| ### `PADPredictor` |
|
|
| 基于多层感知机的情绪与生理状态变化预测器。 |
|
|
| ```python |
| class PADPredictor(nn.Module): |
| def __init__(self, |
| input_dim: int = 7, |
| output_dim: int = 3, |
| hidden_dims: list = [512, 256, 128], |
| dropout_rate: float = 0.3, |
| weight_init: str = "xavier_uniform", |
| bias_init: str = "zeros") |
| ``` |
|
|
| #### 参数 |
|
|
| - `input_dim` (int): 输入维度，默认为7（用户PAD 3维 + Vitality 1维 + AI当前PAD 3维） |
| - `output_dim` (int): 输出维度，默认为3（ΔPAD 3维，压力通过公式动态计算） |
| - `hidden_dims` (list): 隐藏层维度列表，默认为[512, 256, 128] |
| - `dropout_rate` (float): Dropout概率，默认为0.3 |
| - `weight_init` (str): 权重初始化方法，默认为"xavier_uniform" |
| - `bias_init` (str): 偏置初始化方法，默认为"zeros" |
|
|
| #### 方法 |
|
|
| ##### `forward(self, x: torch.Tensor) -> torch.Tensor` |
|
|
| 前向传播。 |
|
|
| **参数:** |
| - `x` (torch.Tensor): 输入张量，形状为 (batch_size, input_dim) |
|
|
| **返回:** |
| - `torch.Tensor`: 输出张量，形状为 (batch_size, output_dim) |
|
|
| **示例:** |
| ```python |
| import torch |
| from src.models.pad_predictor import PADPredictor |
| |
| model = PADPredictor() |
| input_data = torch.randn(4, 7) # batch_size=4, input_dim=7 |
| output = model(input_data) |
| print(f"Output shape: {output.shape}") # torch.Size([4, 3]) |
| ``` |
|
|
| ##### `predict_components(self, x: torch.Tensor) -> Dict[str, torch.Tensor]` |
| |
| 预测并分解输出组件。 |
| |
| **参数:** |
| - `x` (torch.Tensor): 输入张量 |
| |
| **返回:** |
| - `Dict[str, torch.Tensor]`: 包含各组件的字典 |
| - `'delta_pad'`: ΔPAD (3维) |
| - `'delta_pressure'`: ΔPressure (1维，动态计算) |
| - `'confidence'`: Confidence (1维，可选) |
|
|
| **示例:** |
| ```python |
| components = model.predict_components(input_data) |
| print(f"ΔPAD shape: {components['delta_pad'].shape}") # torch.Size([4, 3]) |
| print(f"ΔPressure shape: {components['delta_pressure'].shape}") # torch.Size([4, 1]) |
| print(f"Confidence shape: {components['confidence'].shape}") # torch.Size([4, 1]) |
| ``` |
|
|
| ##### `get_model_info(self) -> Dict[str, Any]` |
|
|
| 获取模型信息。 |
|
|
| **返回:** |
| - `Dict[str, Any]`: 包含模型信息的字典 |
|
|
| **示例:** |
| ```python |
| info = model.get_model_info() |
| print(f"Model type: {info['model_type']}") |
| print(f"Total parameters: {info['total_parameters']}") |
| print(f"Trainable parameters: {info['trainable_parameters']}") |
| ``` |
|
|
| ##### `save_model(self, filepath: str, include_optimizer: bool = False, optimizer: Optional[torch.optim.Optimizer] = None)` |
|
|
| 保存模型到文件。 |
|
|
| **参数:** |
| - `filepath` (str): 保存路径 |
| - `include_optimizer` (bool): 是否包含优化器状态，默认为False |
| - `optimizer` (Optional[torch.optim.Optimizer]): 优化器对象 |
|
|
| **示例:** |
| ```python |
| model.save_model("model.pth", include_optimizer=True, optimizer=optimizer) |
| ``` |
|
|
| ##### `load_model(cls, filepath: str, device: str = 'cpu') -> 'PADPredictor'` |
| |
| 从文件加载模型。 |
| |
| **参数:** |
| - `filepath` (str): 模型文件路径 |
| - `device` (str): 设备类型，默认为'cpu' |
| |
| **返回:** |
| - `PADPredictor`: 加载的模型实例 |
| |
| **示例:** |
| ```python |
| loaded_model = PADPredictor.load_model("model.pth", device='cuda') |
| ``` |
| |
| ##### `freeze_layers(self, layer_names: list = None)` |
| |
| 冻结指定层的参数。 |
| |
| **参数:** |
| - `layer_names` (list): 要冻结的层名称列表，如果为None则冻结所有层 |
|
|
| **示例:** |
| ```python |
| # 冻结所有层 |
| model.freeze_layers() |
| |
| # 冻结特定层 |
| model.freeze_layers(['network.0.weight', 'network.2.weight']) |
| ``` |
|
|
| ##### `unfreeze_layers(self, layer_names: list = None)` |
|
|
| 解冻指定层的参数。 |
|
|
| **参数:** |
| - `layer_names` (list): 要解冻的层名称列表，如果为None则解冻所有层 |
|
|
| ## 数据处理类 |
|
|
| ### `DataPreprocessor` |
|
|
| 数据预处理器，负责特征标准化和标签处理。 |
|
|
| ```python |
| class DataPreprocessor: |
| def __init__(self, |
| feature_scaler: str = "standard", |
| label_scaler: str = "standard", |
| feature_range: tuple = None, |
| label_range: tuple = None) |
| ``` |
|
|
| #### 参数 |
|
|
| - `feature_scaler` (str): 特征标准化方法，默认为"standard" |
| - `label_scaler` (str): 标签标准化方法，默认为"standard" |
| - `feature_range` (tuple): 特征范围，用于MinMax缩放 |
| - `label_range` (tuple): 标签范围，用于MinMax缩放 |
|
|
| #### 方法 |
|
|
| ##### `fit(self, features: np.ndarray, labels: np.ndarray) -> 'DataPreprocessor'` |
|
|
| 拟合预处理器参数。 |
|
|
| **参数:** |
| - `features` (np.ndarray): 训练特征数据 |
| - `labels` (np.ndarray): 训练标签数据 |
|
|
| **返回:** |
| - `DataPreprocessor`: 自身实例 |
|
|
| ##### `transform(self, features: np.ndarray, labels: np.ndarray = None) -> tuple` |
|
|
| 转换数据。 |
|
|
| **参数:** |
| - `features` (np.ndarray): 输入特征数据 |
| - `labels` (np.ndarray, optional): 输入标签数据 |
|
|
| **返回:** |
| - `tuple`: (转换后的特征, 转换后的标签) |
|
|
| ##### `fit_transform(self, features: np.ndarray, labels: np.ndarray = None) -> tuple` |
| |
| 拟合并转换数据。 |
| |
| ##### `inverse_transform(self, features: np.ndarray, labels: np.ndarray = None) -> tuple` |
|
|
| 逆转换数据。 |
|
|
| ##### `save(self, filepath: str)` |
|
|
| 保存预处理器到文件。 |
|
|
| ##### `load(cls, filepath: str) -> 'DataPreprocessor'` |
|
|
| 从文件加载预处理器。 |
|
|
| **示例:** |
| ```python |
| from src.data.preprocessor import DataPreprocessor |
| |
| # 创建预处理器 |
| preprocessor = DataPreprocessor( |
| feature_scaler="standard", |
| label_scaler="standard" |
| ) |
| |
| # 拟合和转换数据 |
| processed_features, processed_labels = preprocessor.fit_transform(train_features, train_labels) |
| |
| # 保存预处理器 |
| preprocessor.save("preprocessor.pkl") |
| |
| # 加载预处理器 |
| loaded_preprocessor = DataPreprocessor.load("preprocessor.pkl") |
| ``` |
|
|
| ### `SyntheticDataGenerator` |
|
|
| 合成数据生成器，用于生成训练和测试数据。 |
|
|
| ```python |
| class SyntheticDataGenerator: |
| def __init__(self, |
| num_samples: int = 1000, |
| seed: int = 42, |
| noise_level: float = 0.1, |
| correlation_strength: float = 0.5) |
| ``` |
|
|
| #### 参数 |
|
|
| - `num_samples` (int): 生成的样本数量，默认为1000 |
| - `seed` (int): 随机种子，默认为42 |
| - `noise_level` (float): 噪声水平，默认为0.1 |
| - `correlation_strength` (float): 相关性强度，默认为0.5 |
|
|
| #### 方法 |
|
|
| ##### `generate_data(self) -> tuple` |
| |
| 生成合成数据。 |
| |
| **返回:** |
| - `tuple`: (特征数据, 标签数据) |
| |
| ##### `save_data(self, features: np.ndarray, labels: np.ndarray, filepath: str, format: str = 'csv')` |
|
|
| 保存数据到文件。 |
|
|
| **示例:** |
| ```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, "synthetic_data.csv", format='csv') |
| ``` |
|
|
| ### `EmotionDataset` |
|
|
| PyTorch数据集类，用于情绪预测任务。 |
|
|
| ```python |
| class EmotionDataset(Dataset): |
| def __init__(self, |
| features: np.ndarray, |
| labels: np.ndarray, |
| transform: callable = None) |
| ``` |
|
|
| #### 参数 |
|
|
| - `features` (np.ndarray): 特征数据 |
| - `labels` (np.ndarray): 标签数据 |
| - `transform` (callable): 数据变换函数 |
|
|
| ## 工具类 |
|
|
| ### `InferenceEngine` |
|
|
| 推理引擎，提供高性能的模型推理功能。 |
|
|
| ```python |
| class InferenceEngine: |
| def __init__(self, |
| model: nn.Module, |
| preprocessor: DataPreprocessor = None, |
| device: str = 'auto') |
| ``` |
|
|
| #### 方法 |
|
|
| ##### `predict(self, input_data: Union[list, np.ndarray]) -> Dict[str, Any]` |
| |
| 单样本预测。 |
| |
| **参数:** |
| - `input_data`: 输入数据，可以是列表或NumPy数组 |
|
|
| **返回:** |
| - `Dict[str, Any]`: 预测结果字典 |
|
|
| **示例:** |
| ```python |
| from src.utils.inference_engine import create_inference_engine |
| |
| # 创建推理引擎 |
| engine = create_inference_engine( |
| model_path="model.pth", |
| preprocessor_path="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"Confidence: {result['confidence']}") |
| ``` |
|
|
| ##### `predict_batch(self, input_batch: Union[list, np.ndarray]) -> List[Dict[str, Any]]` |
|
|
| 批量预测。 |
|
|
| ##### `benchmark(self, num_samples: int = 1000, batch_size: int = 32) -> Dict[str, float]` |
|
|
| 性能基准测试。 |
|
|
| **返回:** |
| - `Dict[str, float]`: 性能统计信息 |
|
|
| **示例:** |
| ```python |
| # 性能基准测试 |
| 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") |
| ``` |
|
|
| ### `ModelTrainer` |
|
|
| 模型训练器，提供完整的训练流程管理。 |
|
|
| ```python |
| class ModelTrainer: |
| def __init__(self, |
| model: nn.Module, |
| preprocessor: DataPreprocessor = None, |
| device: str = 'auto') |
| ``` |
|
|
| #### 方法 |
|
|
| ##### `train(self, train_loader: DataLoader, val_loader: DataLoader, config: Dict[str, Any]) -> Dict[str, Any]` |
|
|
| 训练模型。 |
|
|
| **参数:** |
| - `train_loader` (DataLoader): 训练数据加载器 |
| - `val_loader` (DataLoader): 验证数据加载器 |
| - `config` (Dict[str, Any]): 训练配置 |
|
|
| **返回:** |
| - `Dict[str, Any]`: 训练历史记录 |
|
|
| **示例:** |
| ```python |
| from src.utils.trainer import ModelTrainer |
| |
| # 创建训练器 |
| 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) |
| ``` |
|
|
| ##### `evaluate(self, test_loader: DataLoader) -> Dict[str, float]` |
| |
| 评估模型。 |
| |
| ## 损失函数 |
| |
| ### `WeightedMSELoss` |
| |
| 加权均方误差损失函数。 |
| |
| ```python |
| class WeightedMSELoss(nn.Module): |
| def __init__(self, |
| delta_pad_weight: float = 1.0, |
| delta_pressure_weight: float = 1.0, |
| confidence_weight: float = 0.5, |
| reduction: str = 'mean') |
| ``` |
| |
| #### 参数 |
|
|
| - `delta_pad_weight` (float): ΔPAD损失权重，默认为1.0 |
| - `delta_pressure_weight` (float): ΔPressure损失权重，默认为1.0 |
| - `confidence_weight` (float): 置信度损失权重，默认为0.5 |
| - `reduction` (str): 损失缩减方式，默认为'mean' |
|
|
| **示例:** |
| ```python |
| from src.models.loss_functions import WeightedMSELoss |
| |
| criterion = WeightedMSELoss( |
| delta_pad_weight=1.0, |
| delta_pressure_weight=1.0, |
| confidence_weight=0.5 |
| ) |
| |
| loss = criterion(predictions, targets) |
| ``` |
|
|
| ### `ConfidenceLoss` |
|
|
| 置信度损失函数。 |
|
|
| ```python |
| class ConfidenceLoss(nn.Module): |
| def __init__(self, reduction: str = 'mean') |
| ``` |
|
|
| ## 评估指标 |
|
|
| ### `RegressionMetrics` |
|
|
| 回归评估指标计算器。 |
|
|
| ```python |
| class RegressionMetrics: |
| def __init__(self) |
| ``` |
|
|
| #### 方法 |
|
|
| ##### `calculate_all_metrics(self, y_true: np.ndarray, y_pred: np.ndarray) -> Dict[str, float]` |
|
|
| 计算所有回归指标。 |
|
|
| **参数:** |
| - `y_true` (np.ndarray): 真实值 |
| - `y_pred` (np.ndarray): 预测值 |
|
|
| **返回:** |
| - `Dict[str, float]`: 包含所有指标的字典 |
|
|
| **示例:** |
| ```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}") |
| ``` |
|
|
| ### `PADMetrics` |
|
|
| PAD专用评估指标。 |
|
|
| ```python |
| class PADMetrics: |
| def __init__(self) |
| ``` |
|
|
| #### 方法 |
|
|
| ##### `evaluate_predictions(self, predictions: np.ndarray, targets: np.ndarray) -> Dict[str, Any]` |
| |
| 评估PAD预测结果。 |
| |
| ## 工厂函数 |
| |
| ### `create_pad_predictor(config: Optional[Dict[str, Any]] = None) -> PADPredictor` |
| |
| 创建PAD预测器的工厂函数。 |
| |
| **参数:** |
| - `config` (Dict[str, Any], optional): 配置字典 |
| |
| **返回:** |
| - `PADPredictor`: PAD预测器实例 |
| |
| **示例:** |
| ```python |
| from src.models.pad_predictor import create_pad_predictor |
|
|
| # 使用默认配置 |
| model = create_pad_predictor() |
|
|
| # 使用自定义配置 |
| config = { |
| 'dimensions': { |
| 'input_dim': 7, |
| 'output_dim': 4或3 |
| }, |
| 'architecture': { |
| 'hidden_layers': [ |
| {'size': 256, 'activation': 'ReLU', 'dropout': 0.3}, |
| {'size': 128, 'activation': 'ReLU', 'dropout': 0.2} |
| ] |
| } |
| } |
| model = create_pad_predictor(config) |
| ``` |
| |
| ### `create_inference_engine(model_path: str, preprocessor_path: str = None, device: str = 'auto') -> InferenceEngine` |
|
|
| 创建推理引擎的工厂函数。 |
|
|
| **参数:** |
| - `model_path` (str): 模型文件路径 |
| - `preprocessor_path` (str, optional): 预处理器文件路径 |
| - `device` (str): 设备类型 |
|
|
| **返回:** |
| - `InferenceEngine`: 推理引擎实例 |
|
|
| ### `create_training_setup(config: Dict[str, Any]) -> tuple` |
|
|
| 创建训练设置的工厂函数。 |
|
|
| **参数:** |
| - `config` (Dict[str, Any]): 训练配置 |
|
|
| **返回:** |
| - `tuple`: (模型, 训练器, 数据加载器) |
|
|
| ## 命令行接口 |
|
|
| ### 主CLI工具 |
|
|
| 项目提供了统一的命令行接口，支持多种操作： |
|
|
| ```bash |
| emotion-prediction <command> [options] |
| ``` |
|
|
| #### 可用命令 |
|
|
| - `train`: 训练模型 |
| - `predict`: 进行预测 |
| - `evaluate`: 评估模型 |
| - `inference`: 推理脚本 |
| - `benchmark`: 性能基准测试 |
|
|
| #### 训练命令 |
|
|
| ```bash |
| emotion-prediction train --config CONFIG_FILE [OPTIONS] |
| ``` |
|
|
| **参数:** |
| - `--config, -c`: 训练配置文件路径（必需） |
| - `--output-dir, -o`: 输出目录（默认: ./outputs） |
| - `--device`: 计算设备（auto/cpu/cuda，默认: auto） |
| - `--resume`: 从检查点恢复训练 |
| - `--epochs`: 覆盖训练轮数 |
| - `--batch-size`: 覆盖批次大小 |
| - `--learning-rate`: 覆盖学习率 |
| - `--seed`: 随机种子（默认: 42） |
| - `--verbose, -v`: 详细输出 |
| - `--log-level`: 日志级别（DEBUG/INFO/WARNING/ERROR） |
|
|
| **示例:** |
| ```bash |
| # 基础训练 |
| emotion-prediction train --config configs/training_config.yaml |
| |
| # GPU训练 |
| emotion-prediction train --config configs/training_config.yaml --device cuda |
| |
| # 从检查点恢复 |
| emotion-prediction train --config configs/training_config.yaml --resume checkpoint.pth |
| ``` |
|
|
| #### 预测命令 |
|
|
| ```bash |
| emotion-prediction predict --model MODEL_FILE [OPTIONS] |
| ``` |
|
|
| **参数:** |
| - `--model, -m`: 模型文件路径（必需） |
| - `--preprocessor, -p`: 预处理器文件路径 |
| - `--interactive, -i`: 交互式模式 |
| - `--quick`: 快速预测模式（7个数值） |
| - `--batch`: 批量预测模式（输入文件） |
| - `--output, -o`: 输出文件路径 |
| - `--device`: 计算设备 |
| - `--verbose, -v`: 详细输出 |
| - `--log-level`: 日志级别 |
|
|
| **示例:** |
| ```bash |
| # 交互式预测 |
| emotion-prediction predict --model model.pth --interactive |
| |
| # 快速预测 |
| emotion-prediction predict --model model.pth --quick 0.5 0.3 -0.2 75.0 0.1 0.4 -0.1 |
| |
| # 批量预测 |
| emotion-prediction predict --model model.pth --batch input.csv --output results.csv |
| ``` |
|
|
| #### 评估命令 |
|
|
| ```bash |
| emotion-prediction evaluate --model MODEL_FILE --data DATA_FILE [OPTIONS] |
| ``` |
|
|
| **参数:** |
| - `--model, -m`: 模型文件路径（必需） |
| - `--data, -d`: 测试数据文件路径（必需） |
| - `--preprocessor, -p`: 预处理器文件路径 |
| - `--output, -o`: 评估结果输出路径 |
| - `--report`: 生成详细报告文件路径 |
| - `--metrics`: 评估指标列表（默认: mse mae r2） |
| - `--batch-size`: 批次大小（默认: 32） |
| - `--device`: 计算设备 |
| - `--verbose, -v`: 详细输出 |
| - `--log-level`: 日志级别 |
|
|
| **示例:** |
| ```bash |
| # 基础评估 |
| emotion-prediction evaluate --model model.pth --data test_data.csv |
| |
| # 生成详细报告 |
| emotion-prediction evaluate --model model.pth --data test_data.csv --report report.html |
| ``` |
|
|
| #### 基准测试命令 |
|
|
| ```bash |
| emotion-prediction benchmark --model MODEL_FILE [OPTIONS] |
| ``` |
|
|
| **参数:** |
| - `--model, -m`: 模型文件路径（必需） |
| - `--preprocessor, -p`: 预处理器文件路径 |
| - `--num-samples`: 测试样本数量（默认: 1000） |
| - `--batch-size`: 批次大小（默认: 32） |
| - `--device`: 计算设备 |
| - `--report`: 生成性能报告文件路径 |
| - `--warmup`: 预热轮数（默认: 10） |
| - `--verbose, -v`: 详细输出 |
| - `--log-level`: 日志级别 |
|
|
| **示例:** |
| ```bash |
| # 标准基准测试 |
| emotion-prediction benchmark --model model.pth |
| |
| # 自定义测试 |
| emotion-prediction benchmark --model model.pth --num-samples 5000 --batch-size 64 |
| ``` |
|
|
| ## 配置文件API |
|
|
| ### 模型配置 |
|
|
| 模型配置文件使用YAML格式，支持以下参数： |
|
|
| ```yaml |
| # 模型基本信息 |
| model_info: |
| name: str # 模型名称 |
| type: str # 模型类型 |
| version: str # 模型版本 |
| |
| # 输入输出维度 |
| dimensions: |
| input_dim: int # 输入维度 |
| output_dim: int # 输出维度 |
| |
| # 网络架构 |
| architecture: |
| hidden_layers: |
| - size: int # 层大小 |
| activation: str # 激活函数 |
| dropout: float # Dropout率 |
| output_layer: |
| activation: str # 输出激活函数 |
| use_batch_norm: bool # 是否使用批归一化 |
| use_layer_norm: bool # 是否使用层归一化 |
| |
| # 初始化参数 |
| initialization: |
| weight_init: str # 权重初始化方法 |
| bias_init: str # 偏置初始化方法 |
| |
| # 正则化 |
| regularization: |
| weight_decay: float # L2正则化系数 |
| dropout_config: |
| type: str # Dropout类型 |
| rate: float # Dropout率 |
| ``` |
|
|
| ### 训练配置 |
|
|
| 训练配置文件支持以下参数： |
|
|
| ```yaml |
| # 训练信息 |
| training_info: |
| experiment_name: str # 实验名称 |
| description: str # 实验描述 |
| seed: int # 随机种子 |
| |
| # 训练超参数 |
| training: |
| optimizer: |
| type: str # 优化器类型 |
| learning_rate: float # 学习率 |
| weight_decay: float # 权重衰减 |
| scheduler: |
| type: str # 调度器类型 |
| epochs: int # 训练轮数 |
| early_stopping: |
| enabled: bool # 是否启用早停 |
| patience: int # 耐心值 |
| min_delta: float # 最小改善 |
| ``` |
|
|
| ## 异常处理 |
|
|
| 项目定义了以下自定义异常： |
|
|
| ### `ModelLoadError` |
|
|
| 模型加载错误。 |
|
|
| ### `DataPreprocessingError` |
|
|
| 数据预处理错误。 |
|
|
| ### `InferenceError` |
|
|
| 推理过程错误。 |
|
|
| ### `ConfigurationError` |
|
|
| 配置文件错误。 |
|
|
| **示例:** |
| ```python |
| from src.utils.exceptions import ModelLoadError, InferenceError |
| |
| try: |
| model = PADPredictor.load_model("invalid_model.pth") |
| except ModelLoadError as e: |
| print(f"模型加载失败: {e}") |
| |
| try: |
| result = engine.predict(invalid_input) |
| except InferenceError as e: |
| print(f"推理失败: {e}") |
| ``` |
|
|
| ## 日志系统 |
|
|
| 项目使用结构化日志系统： |
|
|
| ```python |
| from src.utils.logger import setup_logger |
| import logging |
| |
| # 设置日志 |
| setup_logger(level='INFO', log_file='training.log') |
| logger = logging.getLogger(__name__) |
| |
| # 使用日志 |
| logger.info("训练开始") |
| logger.debug(f"批次大小: {batch_size}") |
| logger.warning("检测到潜在的过拟合") |
| logger.error("训练过程中发生错误") |
| ``` |
|
|
| ## 类型提示 |
|
|
| 项目完全支持类型提示，所有公共API都有详细的类型注解： |
|
|
| ```python |
| from typing import Dict, List, Optional, Union, Tuple |
| import numpy as np |
| import torch |
| |
| def predict_emotion( |
| input_data: Union[List[float], np.ndarray], |
| model_path: str, |
| preprocessor_path: Optional[str] = None, |
| device: str = 'auto' |
| ) -> Dict[str, Any]: |
| """ |
| 预测情绪变化 |
| |
| Args: |
| input_data: 输入数据，7维向量 |
| model_path: 模型文件路径 |
| preprocessor_path: 预处理器文件路径 |
| device: 计算设备 |
| |
| Returns: |
| 包含预测结果的字典 |
| |
| Raises: |
| InferenceError: 推理失败时抛出 |
| """ |
| pass |
| ``` |
|
|
| --- |
|
|
| 更多详细信息请参考源代码和示例文件。如有问题，请查看[故障排除指南](TUTORIAL.md#故障排除)或提交Issue。 |
