帮我在pytorch下写提取音频信号的mel语谱图特征然后用cnn-lstm- attention进行四分类

好的，首先你需要安装几个Python包：librosa、numpy、torch、torchvision。

然后，你可以按照以下代码来提取音频信号的mel语谱图特征：

import librosa
import numpy as np

def extract_mel_spectrogram(file_path, n_mels=128, n_fft=2048, hop_length=512):
    # 读取音频文件
    y, sr = librosa.load(file_path, sr=22050)
    # 计算mel语谱图
    S = librosa.feature.melspectrogram(y=y, sr=sr, n_fft=n_fft, hop_length=hop_length, n_mels=n_mels)
    # 将幅度转换为对数刻度
    log_S = librosa.power_to_db(S, ref=np.max)
    # 归一化特征
    norm_S = (log_S - np.mean(log_S)) / np.std(log_S)
    return norm_S

这个函数将返回一个大小为 (n_mels, T) 的ndarray，其中n_mels是要提取的mel滤波器的数量，T是时间步数。

接下来，你可以按照以下代码来构建CNN-LSTM-Attention模型：

import torch.nn as nn

class Model(nn.Module):
    def __init__(self, n_mels=128, n_classes=4):
        super(Model, self).__init__()
        # CNN
        self.conv = nn.Sequential(
            nn.Conv2d(1, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)),
            nn.BatchNorm2d(32),
            nn.ReLU(),
            nn.MaxPool2d(kernel_size=(2, 2)),
            nn.Conv2d(32, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)),
            nn.BatchNorm2d(64),
            nn.ReLU(),
            nn.MaxPool2d(kernel_size=(2, 2)),
        )
        # LSTM
        self.lstm = nn.LSTM(input_size=n_mels//4 * 64, hidden_size=128, bidirectional=True, batch_first=True)
        # Attention
        self.attention = nn.Sequential(
            nn.Linear(128 * 2, 64),
            nn.Tanh(),
            nn.Linear(64, 1),
            nn.Softmax(dim=1)
        )
        # 分类器
        self.classifier = nn.Linear(128 * 2, n_classes)
        
    def forward(self, x):
        # CNN
        x = x.unsqueeze(1)
        x = self.conv(x)
        x = x.view(x.size(0), -1, x.size(3))
        # LSTM
        x, _ = self.lstm(x)
        # Attention
        alpha = self.attention(x).transpose(1, 2)
        x = alpha @ x
        x = x.squeeze(1)
        # 分类器
        x = self.classifier(x)
        return x

这个模型有三个部分：CNN、LSTM和Attention。首先，CNN用于提取特征，LSTM用于处理时序信息，Attention用于对不同时间步的特征进行加权平均。最后，分类器用于进行分类。

最后，你可以按照以下代码来训练和测试模型：

import torch
import torch.optim as optim
from torch.utils.data import DataLoader, Dataset

# 数据集
class MyDataset(Dataset):
    def __init__(self, file_paths, labels):
        self.file_paths = file_paths
        self.labels = labels
    
    def __getitem__(self, index):
        file_path = self.file_paths[index]
        label = self.labels[index]
        x = extract_mel_spectrogram(file_path)
        x = torch.from_numpy(x).float()
        y = torch.tensor(label)
        return x, y
    
    def __len__(self):
        return len(self.file_paths)

# 训练集和测试集
train_file_paths = [...] # 训练集音频文件路径列表
train_labels = [...] # 训练集标签列表
train_dataset = MyDataset(train_file_paths, train_labels)
train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True)

test_file_paths = [...] # 测试集音频文件路径列表
test_labels = [...] # 测试集标签列表
test_dataset = MyDataset(test_file_paths, test_labels)
test_loader = DataLoader(test_dataset, batch_size=32, shuffle=False)

# 模型和优化器
model = Model()
optimizer = optim.Adam(model.parameters(), lr=1e-3)

# 训练
n_epochs = 10
for epoch in range(n_epochs):
    for i, (x, y) in enumerate(train_loader):
        optimizer.zero_grad()
        outputs = model(x)
        loss = nn.CrossEntropyLoss()(outputs, y)
        loss.backward()
        optimizer.step()
        if i % 100 == 0:
            acc = (outputs.argmax(1) == y).float().mean().item()
            print(f"Epoch {epoch}, batch {i}, train loss: {loss.item():.4f}, train acc: {acc:.4f}")
    # 测试
    model.eval()
    with torch.no_grad():
        test_loss = 0.
        test_acc = 0.
        for x, y in test_loader:
            outputs = model(x)
            test_loss += nn.CrossEntropyLoss()(outputs, y).item() * x.size(0)
            test_acc += (outputs.argmax(1) == y).float().sum().item()
        test_loss /= len(test_dataset)
        test_acc /= len(test_dataset)
        print(f"Epoch {epoch}, test loss: {test_loss:.4f}, test acc: {test_acc:.4f}")
    model.train()

这个训练循环会训练模型10个epoch，每个epoch会先用训练集训练模型，然后用测试集测试模型。在每个epoch结束后，会输出训练集和测试集的平均损失和准确率。