如何在1D CNN架构中实现MMD以完成音频域适配？附代码需求

以下是基于PyTorch的实现，参考了你提到的1D CNN结构，仅使用MMD进行域适配，无对抗模块：

核心组件实现 #

1. 1D CNN特征提取器 #

参考HAR任务的结构设计，适配音频序列输入：

import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import Dataset, DataLoader
import numpy as np

class CNNFeatureExtractor(nn.Module):
    def __init__(self, input_channels=1):
        super().__init__()
        self.conv_layers = nn.Sequential(
            nn.Conv1d(input_channels, 64, kernel_size=3, padding=1),
            nn.ReLU(),
            nn.MaxPool1d(kernel_size=2),
            nn.Conv1d(64, 128, kernel_size=3, padding=1),
            nn.ReLU(),
            nn.MaxPool1d(kernel_size=2),
            nn.Conv1d(128, 256, kernel_size=3, padding=1),
            nn.ReLU(),
            nn.MaxPool1d(kernel_size=2)
        )
        # 假设输入序列长度为128，可根据实际音频数据调整
        self.fc_input_dim = 256 * (128 // (2**3))

    def forward(self, x):
        # 输入shape: [batch_size, channels, seq_len]
        features = self.conv_layers(x)
        return features.view(features.size(0), -1)

2. 分类器模块 #

基于提取的特征完成分类任务：

class Classifier(nn.Module):
    def __init__(self, feature_dim, num_classes=10):
        super().__init__()
        self.fc_layers = nn.Sequential(
            nn.Linear(feature_dim, 128),
            nn.ReLU(),
            nn.Linear(128, num_classes)
        )
    
    def forward(self, features):
        return self.fc_layers(features)

3. MMD损失函数实现 #

采用常用的高斯核计算源域与目标域特征的分布差异：

def mmd_loss(source_feat, target_feat, sigma=1.0):
    # 计算高斯核矩阵
    def gaussian_kernel(a, b):
        dist = torch.cdist(a, b, p=2)**2
        return torch.exp(-dist / (2 * sigma**2))
    
    kernel_source = gaussian_kernel(source_feat, source_feat)
    kernel_target = gaussian_kernel(target_feat, target_feat)
    kernel_cross = gaussian_kernel(source_feat, target_feat)
    
    return torch.mean(kernel_source) + torch.mean(kernel_target) - 2 * torch.mean(kernel_cross)

4. 完整适配模型 #

整合特征提取器与分类器：

class MMDAdaptationCNN(nn.Module):
    def __init__(self, input_channels=1, num_classes=10):
        super().__init__()
        self.feature_extractor = CNNFeatureExtractor(input_channels)
        self.classifier = Classifier(self.feature_extractor.fc_input_dim, num_classes)
    
    def forward(self, x):
        features = self.feature_extractor(x)
        logits = self.classifier(features)
        return features, logits

训练流程示例 #

数据集定义（需根据实际音频数据修改） #

class AudioDataset(Dataset):
    def __init__(self, data, labels=None, is_source=True):
        self.data = torch.tensor(data, dtype=torch.float32)  # shape: [samples, channels, seq_len]
        self.labels = torch.tensor(labels, dtype=torch.long) if labels else None
        self.is_source = is_source
    
    def __len__(self):
        return len(self.data)
    
    def __getitem__(self, idx):
        if self.is_source:
            return self.data[idx], self.labels[idx]
        return self.data[idx]

训练循环 #

# 假设已加载预处理后的源域/目标域音频数据
# source_data: [num_source_samples, channels, seq_len], source_labels: [num_source_samples]
# target_data: [num_target_samples, channels, seq_len]

source_dataset = AudioDataset(source_data, source_labels)
target_dataset = AudioDataset(target_data, is_source=False)

source_loader = DataLoader(source_dataset, batch_size=32, shuffle=True)
target_loader = DataLoader(target_dataset, batch_size=32, shuffle=True)

# 初始化模型与训练组件
model = MMDAdaptationCNN(input_channels=1, num_classes=10)
cls_criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=1e-4)

# 训练参数
num_epochs = 50
lambda_mmd = 1.0  # 平衡分类损失与MMD损失的权重，需调参

model.train()
for epoch in range(num_epochs):
    total_loss, total_cls_loss, total_mmd_loss = 0.0, 0.0, 0.0
    batch_count = len(source_loader)

    for (source_x, source_y), target_x in zip(source_loader, target_loader):
        optimizer.zero_grad()

        # 源域前向传播，计算分类损失
        source_feat, source_logits = model(source_x)
        cls_loss = cls_criterion(source_logits, source_y)

        # 目标域特征提取
        target_feat, _ = model(target_x)

        # 计算MMD损失
        mmd = mmd_loss(source_feat, target_feat)

        # 总损失计算
        loss = cls_loss + lambda_mmd * mmd

        # 反向传播与优化
        loss.backward()
        optimizer.step()

        total_loss += loss.item()
        total_cls_loss += cls_loss.item()
        total_mmd_loss += mmd.item()

    # 打印训练状态
    print(f"Epoch {epoch+1}/{num_epochs}")
    print(f"Total Loss: {total_loss/batch_count:.4f} | Cls Loss: {total_cls_loss/batch_count:.4f} | MMD Loss: {total_mmd_loss/batch_count:.4f}")

关键调参与注意事项 #

• 输入维度适配：根据你的音频数据类型（波形/梅尔频谱）调整input_channels和序列长度，确保输入shape为[batch, channels, seq_len]。
• MMD核参数：可尝试多尺度高斯核（多个sigma值的核加权）提升分布对齐效果；若计算效率优先，可改用线性核（直接计算特征均值的L2距离）。
• 损失权重lambda_mmd：若分类精度不足，降低该值；若域对齐效果差，增大该值。
• 音频预处理：推荐将音频转换为梅尔频谱（降维同时保留关键特征），或对原始波形做归一化处理。

内容的提问来源于stack exchange，提问作者techlove