# 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。