1
# 数据集规模统计
2
import pandas as pd
3

4
# 读取元数据文件
5
metadata = pd.read_csv('dev_split_Depression_AVEC2017.csv')
6

7
# 统计基本信息
8
total_participants = len(metadata)
9
depressed_count = sum(metadata['PHQ8_Score'] >= 10)
10
normal_count = total_participants - depressed_count
11

12
print(f"总参与者数: {total_participants}")
13
print(f"抑郁患者数: {depressed_count} ({depressed_count/total_participants*100:.1f}%)")
14
print(f"正常人数: {normal_count} ({normal_count/total_participants*100:.1f}%)")
15
print(f"PHQ-8分数范围: {metadata['PHQ8_Score'].min()} - {metadata['PHQ8_Score'].max()}")

1
def load_metadata(root_dir):
2
    """
3
    加载DAIC-WOZ数据集的元数据
4

5
    参数:
6
        root_dir: 数据集根目录
7

8
    返回:
9
        metadata: 包含所有参与者信息的DataFrame
10
    """
11
    # 定义元数据文件优先级
12
    metadata_files = [
13
        "dev_split_Depression_AVEC2017.csv",
14
        "train_split_Depression_AVEC2017.csv",
15
        "train_split_Depression.csv",
16
        "train_split.csv"
17
    ]
18

19
    # 查找可用的元数据文件
20
    metadata_path = None
21
    for file in metadata_files:
22
        path = os.path.join(root_dir, file)
23
        if os.path.exists(path):
24
            metadata_path = path
25
            print(f"✅ 找到元数据文件: {file}")
26
            break
27

28
    if not metadata_path:
29
        raise FileNotFoundError("未找到任何元数据文件")
30

31
    # 读取元数据
32
    metadata = pd.read_csv(metadata_path)
33

34
    # 验证必要列
35
    required_columns = ['PHQ8_Score', 'Participant_ID']
36
    missing_columns = [col for col in required_columns if col not in metadata.columns]
37
    if missing_columns:
38
        raise ValueError(f"元数据文件缺少必要列: {missing_columns}")
39

40
    return metadata

1
def validate_data_integrity(metadata, data_dir):
2
    """
3
    验证数据完整性
4

5
    参数:
6
        metadata: 元数据DataFrame
7
        data_dir: 数据目录
8

9
    返回:
10
        valid_participants: 数据完整的参与者列表
11
    """
12
    valid_participants = []
13

14
    for idx, row in metadata.iterrows():
15
        participant_id = str(row['Participant_ID'])
16
        participant_folder = f"{participant_id}_P"
17
        folder_path = os.path.join(data_dir, participant_folder)
18

19
        # 检查目录是否存在
20
        if not os.path.exists(folder_path):
21
            print(f"⚠️ 参与者目录不存在: {folder_path}")
22
            continue
23

24
        # 检查音频文件
25
        audio_file = os.path.join(folder_path, f"{participant_id}_AUDIO.wav")
26
        if not os.path.exists(audio_file):
27
            print(f"⚠️ 音频文件缺失: {audio_file}")
28
            continue
29

30
        # 检查视频特征文件
31
        feature_file = os.path.join(folder_path, f"{participant_id}_CLNF_features.txt")
32
        if not os.path.exists(feature_file):
33
            print(f"⚠️ 视频特征文件缺失: {feature_file}")
34
            continue
35

36
        valid_participants.append(participant_id)
37

38
    print(f"\n✅ 数据完整性检查完成")
39
    print(f"   总参与者数: {len(metadata)}")
40
    print(f"   数据完整的参与者数: {len(valid_participants)}")
41
    print(f"   数据完整率: {len(valid_participants)/len(metadata)*100:.1f}%")
42

43
    return valid_participants

1
def extract_mfcc_features(audio_file, n_mfcc=35, sample_rate=16000):
2
    """
3
    提取音频的MFCC特征
4

5
    参数:
6
        audio_file: 音频文件路径
7
        n_mfcc: MFCC系数数量
8
        sample_rate: 采样率
9

10
    返回:
11
        mfcc_features: 平均MFCC特征向量
12
    """
13
    try:
14
        # 读取音频文件
15
        y, sr = librosa.load(audio_file, sr=sample_rate)
16

17
        # 提取MFCC特征
18
        mfccs = librosa.feature.mfcc(
19
            y=y,
20
            sr=sr,
21
            n_mfcc=n_mfcc,
22
            n_fft=512,          # FFT窗口大小
23
            hop_length=256,     # 帧移
24
            win_length=512,     # 窗口长度
25
            window='hann',      # 窗函数
26
            center=True,        # 中心化
27
            pad_mode='reflect'  # 填充模式
28
        )
29

30
        # 计算时间维度上的均值作为特征向量
31
        mfcc_features = np.mean(mfccs, axis=1)
32

33
        return mfcc_features
34

35
    except Exception as e:
36
        print(f"⚠️ 音频特征提取错误 ({audio_file}): {str(e)}")
37
        return None

1
def extract_comprehensive_audio_features(audio_file):
2
    """
3
    提取综合音频特征
4

5
    参数:
6
        audio_file: 音频文件路径
7

8
    返回:
9
        features: 综合特征向量
10
    """
11
    try:
12
        y, sr = librosa.load(audio_file, sr=16000)
13

14
        # 提取MFCC特征
15
        mfccs = librosa.feature.mfcc(y=y, sr=sr, n_mfcc=35)
16
        mfcc_mean = np.mean(mfccs, axis=1)
17
        mfcc_std = np.std(mfccs, axis=1)
18

19
        # 提取频谱特征
20
        spectral_centroid = librosa.feature.spectral_centroid(y=y, sr=sr)
21
        spectral_bandwidth = librosa.feature.spectral_bandwidth(y=y, sr=sr)
22
        spectral_rolloff = librosa.feature.spectral_rolloff(y=y, sr=sr)
23

24
        # 提取能量特征
25
        rms = librosa.feature.rms(y=y)
26

27
        # 提取零交叉率
28
        zcr = librosa.feature.zero_crossing_rate(y)
29

30
        # 提取基频特征（使用parselmouth）
31
        import parselmouth
32
        sound = parselmouth.Sound(audio_file)
33
        pitch = sound.to_pitch()
34
        pitch_values = pitch.selected_array['frequency']
35
        pitch_mean = np.mean(pitch_values[pitch_values > 0]) if any(pitch_values > 0) else 0
36
        pitch_std = np.std(pitch_values[pitch_values > 0]) if any(pitch_values > 0) else 0
37

38
        # 组合所有特征
39
        features = np.concatenate([
40
            mfcc_mean,
41
            mfcc_std,
42
            [np.mean(spectral_centroid)],
43
            [np.mean(spectral_bandwidth)],
44
            [np.mean(spectral_rolloff)],
45
            [np.mean(rms)],
46
            [np.mean(zcr)],
47
            [pitch_mean],
48
            [pitch_std]
49
        ])
50

51
        return features
52

53
    except Exception as e:
54
        print(f"⚠️ 综合特征提取错误: {str(e)}")
55
        return None

1
def extract_video_features(participant_id, data_dir):
2
    """
3
    从CLNF_features.txt提取视频特征
4

5
    参数:
6
        participant_id: 参与者ID
7
        data_dir: 数据目录
8

9
    返回:
10
        video_features: 140维视频特征向量
11
    """
12
    # 构建特征文件路径
13
    features_file = os.path.join(
14
        data_dir,
15
        f"{participant_id}_P",
16
        f"{participant_id}_CLNF_features.txt"
17
    )
18

19
    # 检查文件是否存在
20
    if not os.path.exists(features_file):
21
        print(f"⚠️ 视频特征文件不存在: {features_file}")
22
        return np.random.rand(140)
23

24
    try:
25
        # 读取文件并提取特征（跳过第一行标题）
26
        with open(features_file, 'r') as f:
27
            lines = f.readlines()[1:]  # 跳过标题行
28

29
        if not lines:
30
            print(f"⚠️ 视频特征文件为空: {features_file}")
31
            return np.random.rand(140)
32

33
        # 提取所有时间点的特征
34
        features = []
35
        for line in lines:
36
            if not line.strip():
37
                continue
38
            nums = [float(x) for x in line.split(',')]
39
            if len(nums) >= 140:
40
                features.append(nums[:140])
41

42
        if not features:
43
            print(f"⚠️ 无有效视频特征: {features_file}")
44
            return np.random.rand(140)
45

46
        # 计算时间维度上的平均值
47
        features_avg = np.mean(features, axis=0)
48
        return features_avg[:140]
49

50
    except Exception as e:
51
        print(f"⚠️ 视频特征提取错误 ({features_file}): {str(e)}")
52
        return np.random.rand(140)

1
def process_video_features(raw_features):
2
    """
3
    处理原始视频特征，提取更有意义的统计特征
4

5
    参数:
6
        raw_features: 原始特征列表（每个时间点的特征）
7

8
    返回:
9
        processed_features: 处理后的统计特征
10
    """
11
    if not raw_features:
12
        return np.zeros(280)
13

14
    # 转换为numpy数组
15
    features_array = np.array(raw_features)
16

17
    # 计算基本统计特征
18
    mean_features = np.mean(features_array, axis=0)
19
    std_features = np.std(features_array, axis=0)
20
    max_features = np.max(features_array, axis=0)
21
    min_features = np.min(features_array, axis=0)
22

23
    # 计算动态特征（变化率）
24
    if len(raw_features) > 1:
25
        diff_features = np.diff(features_array, axis=0)
26
        mean_diff = np.mean(diff_features, axis=0)
27
        std_diff = np.std(diff_features, axis=0)
28
    else:
29
        mean_diff = np.zeros_like(mean_features)
30
        std_diff = np.zeros_like(std_features)
31

32
    # 组合所有特征
33
    processed_features = np.concatenate([
34
        mean_features,
35
        std_features,
36
        max_features,
37
        min_features,
38
        mean_diff,
39
        std_diff
40
    ])
41

42
    return processed_features

1
def save_processed_data(audio_features, video_features, labels, participant_ids, output_dir):
2
    """
3
    保存处理后的数据
4

5
    参数:
6
        audio_features: 音频特征数组
7
        video_features: 视频特征数组
8
        labels: 标签数组
9
        participant_ids: 参与者ID列表
10
        output_dir: 输出目录
11
    """
12
    # 确保输出目录存在
13
    os.makedirs(output_dir, exist_ok=True)
14

15
    # 保存特征和标签
16
    np.save(os.path.join(output_dir, "audio_features.npy"), audio_features)
17
    np.save(os.path.join(output_dir, "video_features.npy"), video_features)
18
    np.save(os.path.join(output_dir, "labels.npy"), labels)
19
    np.save(os.path.join(output_dir, "participant_ids.npy"), participant_ids)
20

21
    # 保存元数据
22
    metadata = {
23
        'num_samples': len(audio_features),
24
        'audio_feature_dim': audio_features.shape[1],
25
        'video_feature_dim': video_features.shape[1],
26
        'depression_count': int(np.sum(labels)),
27
        'normal_count': int(len(labels) - np.sum(labels))
28
    }
29

30
    with open(os.path.join(output_dir, "metadata.json"), 'w', encoding='utf-8') as f:
31
        json.dump(metadata, f, indent=2, ensure_ascii=False)
32

33
    print(f"\n✅ 数据已保存到: {output_dir}")
34
    print(f"音频特征: {audio_features.shape}")
35
    print(f"视频特征: {video_features.shape}")
36
    print(f"标签分布: 抑郁={metadata['depression_count']}, 正常={metadata['normal_count']}")

1
def load_processed_data(output_dir):
2
    """
3
    加载处理后的数据
4

5
    参数:
6
        output_dir: 输出目录
7

8
    返回:
9
        audio_features, video_features, labels, participant_ids
10
    """
11
    try:
12
        # 加载特征和标签
13
        audio_features = np.load(os.path.join(output_dir, "audio_features.npy"))
14
        video_features = np.load(os.path.join(output_dir, "video_features.npy"))
15
        labels = np.load(os.path.join(output_dir, "labels.npy"))
16
        participant_ids = np.load(os.path.join(output_dir, "participant_ids.npy"))
17

18
        # 加载元数据
19
        with open(os.path.join(output_dir, "metadata.json"), 'r', encoding='utf-8') as f:
20
            metadata = json.load(f)
21

22
        # 验证数据一致性
23
        assert len(audio_features) == len(video_features) == len(labels) == len(participant_ids)
24
        assert audio_features.shape[1] == metadata['audio_feature_dim']
25
        assert video_features.shape[1] == metadata['video_feature_dim']
26

27
        print(f"✅ 数据加载成功")
28
        print(f"样本数量: {len(audio_features)}")
29
        print(f"音频特征维度: {audio_features.shape[1]}")
30
        print(f"视频特征维度: {video_features.shape[1]}")
31
        print(f"标签分布: 抑郁={metadata['depression_count']}, 正常={metadata['normal_count']}")
32

33
        return audio_features, video_features, labels, participant_ids
34

35
    except Exception as e:
36
        print(f"❌ 数据加载失败: {str(e)}")
37
        return None, None, None, None