1
class ConfigManager:
2
    """统一的配置管理类"""
3

4
    def __init__(self, config_file='config.json'):
5
        self.config_file = config_file
6
        self.config = self._load_config()
7

8
    def _load_config(self):
9
        """加载配置文件"""
10
        try:
11
            with open(self.config_file, 'r', encoding='utf-8') as f:
12
                return json.load(f)
13
        except FileNotFoundError:
14
            return self._get_default_config()
15

16
    def _get_default_config(self):
17
        """获取默认配置"""
18
        return {
19
            'dataset': {
20
                'root_dir': r"E:\DAIC-WOZ",
21
                'metadata_files': [
22
                    "dev_split_Depression_AVEC2017.csv",
23
                    "train_split_Depression_AVEC2017.csv"
24
                ]
25
            },
26
            'model': {
27
                'audio_feature_dim': 35,
28
                'visual_feature_dim': 140,
29
                'random_state': 42
30
            },
31
            'paths': {
32
                'openface': r"D:\OpenFace_2.2.0_win_x64\FeatureExtraction.exe",
33
                'output': r"E:\DAIC-WOZ\项目执行新文件"
34
            }
35
        }
36

37
    def get(self, key, default=None):
38
        """获取配置值"""
39
        keys = key.split('.')
40
        value = self.config
41

42
        try:
43
            for k in keys:
44
                value = value[k]
45
            return value
46
        except (KeyError, TypeError):
47
            return default
48

49
    def update(self, key, value):
50
        """更新配置值"""
51
        keys = key.split('.')
52
        config = self.config
53

54
        for k in keys[:-1]:
55
            if k not in config:
56
                config[k] = {}
57
            config = config[k]
58

59
        config[keys[-1]] = value
60
        self._save_config()
61

62
    def _save_config(self):
63
        """保存配置到文件"""
64
        with open(self.config_file, 'w', encoding='utf-8') as f:
65
            json.dump(self.config, f, indent=2, ensure_ascii=False)

1
from abc import ABC, abstractmethod
2
import librosa
3
import numpy as np
4

5
class FeatureExtractor(ABC):
6
    """特征提取器基类"""
7

8
    @abstractmethod
9
    def extract(self, file_path):
10
        """提取特征的抽象方法"""
11
        pass
12

13
    @abstractmethod
14
    def get_feature_names(self):
15
        """获取特征名称"""
16
        pass
17

18

19
class AudioFeatureExtractor(FeatureExtractor):
20
    """音频特征提取器"""
21

22
    def __init__(self, sample_rate=16000, n_mfcc=35):
23
        self.sample_rate = sample_rate
24
        self.n_mfcc = n_mfcc
25

26
    def extract(self, file_path):
27
        """提取音频特征"""
28
        try:
29
            y, sr = librosa.load(file_path, sr=self.sample_rate)
30

31
            # 提取MFCC特征
32
            mfccs = librosa.feature.mfcc(y=y, sr=sr, n_mfcc=self.n_mfcc)
33
            mfcc_mean = np.mean(mfccs, axis=1)
34

35
            # 提取其他音频特征
36
            spectral_centroid = np.mean(librosa.feature.spectral_centroid(y=y, sr=sr))
37
            spectral_bandwidth = np.mean(librosa.feature.spectral_bandwidth(y=y, sr=sr))
38
            rms = np.mean(librosa.feature.rms(y=y))
39
            zcr = np.mean(librosa.feature.zero_crossing_rate(y))
40

41
            features = np.concatenate([
42
                mfcc_mean,
43
                [spectral_centroid, spectral_bandwidth, rms, zcr]
44
            ])
45

46
            return features
47

48
        except Exception as e:
49
            print(f"音频特征提取错误: {e}")
50
            return None
51

52
    def get_feature_names(self):
53
        """获取特征名称"""
54
        mfcc_names = [f'aud_mfcc_{i}' for i in range(self.n_mfcc)]
55
        other_names = ['aud_spectral_centroid', 'aud_spectral_bandwidth', 'aud_rms', 'aud_zcr']
56
        return mfcc_names + other_names
57

58

59
class VisualFeatureExtractor(FeatureExtractor):
60
    """视频特征提取器"""
61

62
    def __init__(self, feature_dim=140):
63
        self.feature_dim = feature_dim
64

65
    def extract(self, file_path):
66
        """提取视频特征"""
67
        # 视频特征提取逻辑
68
        pass
69

70
    def get_feature_names(self):
71
        """获取特征名称"""
72
        return [f'vis_feature_{i}' for i in range(self.feature_dim)]

1
import joblib
2
import os
3
from abc import ABC, abstractmethod
4

5
class ModelManager:
6
    """模型管理器"""
7

8
    def __init__(self, model_dir='models'):
9
        self.model_dir = model_dir
10
        self.models = {}
11

12
    def load_model(self, model_name):
13
        """加载模型"""
14
        if model_name not in self.models:
15
            model_path = os.path.join(self.model_dir, f"{model_name}.pkl")
16
            if os.path.exists(model_path):
17
                self.models[model_name] = joblib.load(model_path)
18
            else:
19
                raise FileNotFoundError(f"模型文件不存在: {model_path}")
20
        return self.models[model_name]
21

22
    def save_model(self, model, model_name):
23
        """保存模型"""
24
        model_path = os.path.join(self.model_dir, f"{model_name}.pkl")
25
        joblib.dump(model, model_path)
26
        self.models[model_name] = model
27

28
    def get_model(self, model_name):
29
        """获取模型（如果未加载则自动加载）"""
30
        return self.load_model(model_name)
31

32

33
class BaseModel(ABC):
34
    """模型基类"""
35

36
    @abstractmethod
37
    def train(self, X, y):
38
        """训练模型"""
39
        pass
40

41
    @abstractmethod
42
    def predict(self, X):
43
        """预测"""
44
        pass
45

46
    @abstractmethod
47
    def predict_proba(self, X):
48
        """预测概率"""
49
        pass
50

51

52
class ClassificationModel(BaseModel):
53
    """分类模型"""
54

55
    def __init__(self, model_type='logistic_regression'):
56
        self.model_type = model_type
57
        self.model = None
58

59
    def train(self, X, y):
60
        """训练分类模型"""
61
        if self.model_type == 'logistic_regression':
62
            from sklearn.linear_model import LogisticRegression
63
            self.model = LogisticRegression(
64
                penalty='l1',
65
                solver='liblinear',
66
                class_weight='balanced',
67
                random_state=42
68
            )
69
        else:
70
            raise ValueError(f"不支持的模型类型: {self.model_type}")
71

72
        self.model.fit(X, y)
73
        return self.model
74

75
    def predict(self, X):
76
        """预测类别"""
77
        return self.model.predict(X)
78

79
    def predict_proba(self, X):
80
        """预测概率"""
81
        return self.model.predict_proba(X)

1
import threading
2
from concurrent.futures import ThreadPoolExecutor
3

4
class ThreadManager:
5
    """线程管理器"""
6

7
    def __init__(self, max_workers=None):
8
        self.executor = ThreadPoolExecutor(max_workers=max_workers)
9

10
    def submit(self, func, *args, **kwargs):
11
        """提交任务到线程池"""
12
        return self.executor.submit(func, *args, **kwargs)
13

14
    def map(self, func, iterable):
15
        """映射函数到可迭代对象"""
16
        return self.executor.map(func, iterable)
17

18
    def shutdown(self, wait=True):
19
        """关闭线程池"""
20
        self.executor.shutdown(wait=wait)
21

22

23
def parallel_feature_extraction(file_paths, extractor, max_workers=4):
24
    """并行特征提取"""
25
    thread_manager = ThreadManager(max_workers=max_workers)
26

27
    # 提交所有任务
28
    futures = [thread_manager.submit(extractor.extract, file_path)
29
               for file_path in file_paths]
30

31
    # 收集结果
32
    features = [future.result() for future in futures]
33

34
    thread_manager.shutdown()
35
    return features

1
import os
2
import pickle
3
import hashlib
4

5
class CacheManager:
6
    """缓存管理器"""
7

8
    def __init__(self, cache_dir='cache'):
9
        self.cache_dir = cache_dir
10
        os.makedirs(cache_dir, exist_ok=True)
11

12
    def _get_cache_key(self, data):
13
        """生成缓存键"""
14
        if isinstance(data, str):
15
            return hashlib.md5(data.encode()).hexdigest()
16
        else:
17
            return hashlib.md5(pickle.dumps(data)).hexdigest()
18

19
    def get(self, key, func=None, *args, **kwargs):
20
        """获取缓存，如果不存在则计算并缓存"""
21
        cache_key = self._get_cache_key(key)
22
        cache_path = os.path.join(self.cache_dir, f"{cache_key}.pkl")
23

24
        # 检查缓存是否存在
25
        if os.path.exists(cache_path):
26
            try:
27
                with open(cache_path, 'rb') as f:
28
                    return pickle.load(f)
29
            except Exception as e:
30
                print(f"缓存读取失败: {e}")
31

32
        # 如果提供了函数，则计算并缓存
33
        if func is not None:
34
            result = func(*args, **kwargs)
35
            try:
36
                with open(cache_path, 'wb') as f:
37
                    pickle.dump(result, f)
38
            except Exception as e:
39
                print(f"缓存写入失败: {e}")
40
            return result
41

42
        return None
43

44
    def clear(self):
45
        """清除所有缓存"""
46
        for file in os.listdir(self.cache_dir):
47
            file_path = os.path.join(self.cache_dir, file)
48
            if os.path.isfile(file_path):
49
                os.remove(file_path)

1
import numpy as np
2
import pandas as pd
3

4
def optimize_memory_usage(df):
5
    """优化DataFrame的内存使用"""
6
    optimized_df = df.copy()
7

8
    # 优化数值类型
9
    for col in optimized_df.select_dtypes(include=['int64']).columns:
10
        max_val = optimized_df[col].max()
11
        min_val = optimized_df[col].min()
12

13
        if min_val >= 0:
14
            if max_val <= 255:
15
                optimized_df[col] = optimized_df[col].astype('uint8')
16
            elif max_val <= 65535:
17
                optimized_df[col] = optimized_df[col].astype('uint16')
18
            elif max_val <= 4294967295:
19
                optimized_df[col] = optimized_df[col].astype('uint32')
20
            else:
21
                optimized_df[col] = optimized_df[col].astype('uint64')
22
        else:
23
            if min_val >= -128 and max_val <= 127:
24
                optimized_df[col] = optimized_df[col].astype('int8')
25
            elif min_val >= -32768 and max_val <= 32767:
26
                optimized_df[col] = optimized_df[col].astype('int16')
27
            elif min_val >= -2147483648 and max_val <= 2147483647:
28
                optimized_df[col] = optimized_df[col].astype('int32')
29

30
    # 优化浮点类型
31
    for col in optimized_df.select_dtypes(include=['float64']).columns:
32
        optimized_df[col] = optimized_df[col].astype('float32')
33

34
    # 优化对象类型
35
    for col in optimized_df.select_dtypes(include=['object']).columns:
36
        if optimized_df[col].nunique() < len(optimized_df) * 0.5:
37
            optimized_df[col] = optimized_df[col].astype('category')
38

39
    return optimized_df
40

41

42
def batch_process(func, data, batch_size=1000):
43
    """批量处理数据，减少内存使用"""
44
    results = []
45

46
    for i in range(0, len(data), batch_size):
47
        batch = data[i:i + batch_size]
48
        batch_results = func(batch)
49
        results.extend(batch_results)
50

51
    return results

1
class DepressionDetectionError(Exception):
2
    """抑郁检测系统基础异常类"""
3
    pass
4

5

6
class ConfigurationError(DepressionDetectionError):
7
    """配置错误"""
8
    pass
9

10

11
class DataError(DepressionDetectionError):
12
    """数据错误"""
13
    pass
14

15

16
class ModelError(DepressionDetectionError):
17
    """模型错误"""
18
    pass
19

20

21
class FeatureExtractionError(DepressionDetectionError):
22
    """特征提取错误"""
23
    pass
24

25

26
class PredictionError(DepressionDetectionError):
27
    """预测错误"""
28
    pass
29

30

31
# error_handler.py
32
import logging
33
import traceback
34

35
class ErrorHandler:
36
    """错误处理器"""
37

38
    def __init__(self, log_file='error.log'):
39
        # 配置日志
40
        logging.basicConfig(
41
            level=logging.ERROR,
42
            format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
43
            filename=log_file,
44
            filemode='a'
45
        )
46
        self.logger = logging.getLogger(__name__)
47

48
    def handle_error(self, error, context=None):
49
        """处理错误"""
50
        error_msg = str(error)
51

52
        if context:
53
            error_msg = f"{context}: {error_msg}"
54

55
        # 记录日志
56
        self.logger.error(error_msg, exc_info=True)
57

58
        # 根据错误类型提供不同的处理策略
59
        if isinstance(error, ConfigurationError):
60
            return self._handle_config_error(error)
61
        elif isinstance(error, DataError):
62
            return self._handle_data_error(error)
63
        elif isinstance(error, ModelError):
64
            return self._handle_model_error(error)
65
        elif isinstance(error, FeatureExtractionError):
66
            return self._handle_feature_error(error)
67
        else:
68
            return self._handle_general_error(error)
69

70
    def _handle_config_error(self, error):
71
        """处理配置错误"""
72
        return {
73
            'error_type': 'config',
74
            'message': f"配置错误: {error}",
75
            'recommendation': '请检查配置文件和环境变量'
76
        }
77

78
    def _handle_data_error(self, error):
79
        """处理数据错误"""
80
        return {
81
            'error_type': 'data',
82
            'message': f"数据错误: {error}",
83
            'recommendation': '请检查数据文件和路径'
84
        }
85

86
    def _handle_model_error(self, error):
87
        """处理模型错误"""
88
        return {
89
            'error_type': 'model',
90
            'message': f"模型错误: {error}",
91
            'recommendation': '请检查模型文件和版本'
92
        }
93

94
    def _handle_feature_error(self, error):
95
        """处理特征提取错误"""
96
        return {
97
            'error_type': 'feature',
98
            'message': f"特征提取错误: {error}",
99
            'recommendation': '请检查输入文件格式'
100
        }
101

102
    def _handle_general_error(self, error):
103
        """处理通用错误"""
104
        return {
105
            'error_type': 'general',
106
            'message': f"发生错误: {error}",
107
            'recommendation': '请查看详细日志'
108
        }

1
import os
2
import re
3
import numpy as np
4
from typing import Any, Dict, List, Union
5

6
class InputValidator:
7
    """输入验证器"""
8

9
    @staticmethod
10
    def validate_file_path(file_path: str, extensions: List[str] = None) -> bool:
11
        """验证文件路径"""
12
        # 检查路径是否为空
13
        if not file_path:
14
            raise ValueError("文件路径不能为空")
15

16
        # 检查文件是否存在
17
        if not os.path.exists(file_path):
18
            raise FileNotFoundError(f"文件不存在: {file_path}")
19

20
        # 检查文件扩展名
21
        if extensions:
22
            ext = os.path.splitext(file_path)[1].lower()
23
            if ext not in extensions:
24
                raise ValueError(f"不支持的文件类型: {ext}，支持的类型: {extensions}")
25

26
        return True
27

28
    @staticmethod
29
    def validate_directory(directory: str) -> bool:
30
        """验证目录"""
31
        if not directory:
32
            raise ValueError("目录路径不能为空")
33

34
        if not os.path.exists(directory):
35
            raise FileNotFoundError(f"目录不存在: {directory}")
36

37
        if not os.path.isdir(directory):
38
            raise ValueError(f"不是目录: {directory}")
39

40
        return True
41

42
    @staticmethod
43
    def validate_features(features: np.ndarray, expected_dim: int = None) -> bool:
44
        """验证特征数据"""
45
        if features is None:
46
            raise ValueError("特征数据不能为空")
47

48
        if not isinstance(features, np.ndarray):
49
            raise TypeError("特征数据必须是numpy数组")
50

51
        if features.ndim != 2:
52
            raise ValueError(f"特征数据必须是二维数组，当前维度: {features.ndim}")
53

54
        if expected_dim and features.shape[1] != expected_dim:
55
            raise ValueError(f"特征维度不匹配，期望: {expected_dim}，实际: {features.shape[1]}")
56

57
        if np.isnan(features).any():
58
            raise ValueError("特征数据包含NaN值")
59

60
        if np.isinf(features).any():
61
            raise ValueError("特征数据包含无穷大值")
62

63
        return True
64

65
    @staticmethod
66
    def validate_user_info(user_info: Dict[str, Any]) -> bool:
67
        """验证用户信息"""
68
        required_fields = ['name', 'gender', 'age']
69

70
        for field in required_fields:
71
            if field not in user_info:
72
                raise ValueError(f"缺少必要字段: {field}")
73

74
        # 验证姓名
75
        name = user_info['name']
76
        if not name or not isinstance(name, str):
77
            raise ValueError("姓名必须是非空字符串")
78

79
        # 验证性别
80
        gender = user_info['gender']
81
        if gender not in ['男', '女']:
82
            raise ValueError("性别必须是'男'或'女'")
83

84
        # 验证年龄
85
        age = user_info['age']
86
        if not age:
87
            raise ValueError("年龄不能为空")
88

89
        try:
90
            age_int = int(age)
91
            if age_int < 0 or age_int > 120:
92
                raise ValueError("年龄必须在0-120之间")
93
        except ValueError:
94
            raise ValueError("年龄必须是有效的数字")
95

96
        return True
97

98
    @staticmethod
99
    def validate_threshold(threshold: float) -> bool:
100
        """验证阈值"""
101
        if not isinstance(threshold, (int, float)):
102
            raise TypeError("阈值必须是数字")
103

104
        if threshold < 0 or threshold > 1:
105
            raise ValueError("阈值必须在0-1之间")
106

107
        return True

1
import logging
2
import os
3
import sys
4
from logging.handlers import RotatingFileHandler
5

6
class Logger:
7
    """日志管理器"""
8

9
    def __init__(self, name='depression_detection', log_dir='logs', level=logging.INFO):
10
        self.name = name
11
        self.log_dir = log_dir
12
        self.level = level
13

14
        # 创建日志目录
15
        os.makedirs(log_dir, exist_ok=True)
16

17
        # 创建日志记录器
18
        self.logger = logging.getLogger(name)
19
        self.logger.setLevel(level)
20

21
        # 清除现有处理器
22
        self.logger.handlers.clear()
23

24
        # 设置日志格式
25
        formatter = logging.Formatter(
26
            '%(asctime)s - %(name)s - %(levelname)s - %(filename)s:%(lineno)d - %(message)s'
27
        )
28

29
        # 添加控制台处理器
30
        console_handler = logging.StreamHandler(sys.stdout)
31
        console_handler.setLevel(logging.INFO)
32
        console_handler.setFormatter(formatter)
33
        self.logger.addHandler(console_handler)
34

35
        # 添加文件处理器（带轮转）
36
        log_file = os.path.join(log_dir, f"{name}.log")
37
        file_handler = RotatingFileHandler(
38
            log_file,
39
            maxBytes=10*1024*1024,  # 10MB
40
            backupCount=5,           # 保留5个备份
41
            encoding='utf-8'
42
        )
43
        file_handler.setLevel(logging.DEBUG)
44
        file_handler.setFormatter(formatter)
45
        self.logger.addHandler(file_handler)
46

47
    def debug(self, message, **kwargs):
48
        """记录调试信息"""
49
        self.logger.debug(message, **kwargs)
50

51
    def info(self, message, **kwargs):
52
        """记录信息"""
53
        self.logger.info(message, **kwargs)
54

55
    def warning(self, message, **kwargs):
56
        """记录警告"""
57
        self.logger.warning(message, **kwargs)
58

59
    def error(self, message, exc_info=False, **kwargs):
60
        """记录错误"""
61
        self.logger.error(message, exc_info=exc_info, **kwargs)
62

63
    def critical(self, message, exc_info=False, **kwargs):
64
        """记录严重错误"""
65
        self.logger.critical(message, exc_info=exc_info, **kwargs)
66

67

68
# 创建全局日志实例
69
logger = Logger()