PyTorch乐器声音音频识别应用

新书速览|PyTorch深度学习与企业级项目实战-CSDN博客

乐器声音音频识别对实现自动化乐理分析、音乐信息检索和音频内容识别等应用具有重要意义。乐器声音音频识别是指通过对乐器演奏或录制的音频进行分析，自动判断出音频中所使用的乐器种类。这对于音乐家、音乐学者以及音频应用开发者来说都具有很大的价值。传统的乐器声音识别方法主要依靠特征提取和分类器的组合，但对于复杂多变的乐器声音，识别效果有限。本项目将介绍如何使用PyTorch训练一个网络模型来进行语音识别，由于语音属于时序信息，因此本项目主要使用循环神经网络LSTM来进行建模，我们将建立一个用现代算法来分类一个曲调是大和弦还是小和弦的语音识别模型。

LSTM是一种循环神经网络的变体，能够在处理长序列数据时更好地捕捉时间依赖关系。在乐器声音音频识别中，我们可以将音频信号转换为时域或频域的特征序列，然后通过LSTM对这些序列进行建模。

1. 收集数据

首先，我们需要收集并准备乐器声音音频数据集。这个数据集应包含各种乐器演奏的音频样本，并标注乐器类别。

2. 特征提取

将音频信号转换为时域或频域的特征序列，这是乐器声音音频识别的关键步骤。常用的特征提取方法包括短时傅里叶变换（Shbyt-Time Fourier Transform，STFT）、梅尔频率倒谱系数（Mel-Frequency Cepstral Coefficients，MFCC）等。这些特征能够反映音频的频谱信息和能量分布。

3. 模型构建

使用LSTM来构建乐器声音音频识别模型。LSTM的输入为特征序列，输出为乐器类别。可以选择使用单层或多层LSTM结构，并结合其他神经网络层来提高模型的表达能力。

4. 模型训练与调优

将准备好的数据集划分为训练集和测试集，通过优化算法（如Adam）对模型进行训练。在训练过程中，监控模型在测试集上的性能指标（如准确率、F1值），并根据模型的表现对超参数进行调优。

5. 模型评估与应用

使用测试集评估训练好的模型的性能，计算准确率、召回率、F1值等指标。对于乐器声音音频识别来说，可以使用交叉验证（Cross Validation）等方法进行更全面的评估。在实际应用中，可以将该模型嵌入音频处理软件或移动应用中，实现实时的乐器声音识别功能。

本项目所使用的数据集包含吉他和钢琴两种乐器的音频文件。由于我们的音频数据不可以直接用于神经网络中直接进行学习，因此需要将其解码形成数值编码。源程序代码如下：

###############audio_demo.py#######
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
from torchnet import meter
import matplotlib.pyplot as plt
import IPython.display as ipd
from tqdm import tqdm
import librosa
import glob
import numpy as np
import pandas as pd

data_path = './audio_data/*/*'  # 数据集路径
epochs = 10  		# 迭代轮数
lr = 0.001  		# 学习率
batch_size = 32  	# 批次大小
hidden_dim = 64
num_layers = 2
save_path = './audio_model.pkl'  # 模型保存路径
device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')  # 设备

# 将音频数据转成numpy格式数据
def audio_preprocessing(filepath):
    audio, sr = librosa.load(filepath, duration=5)
    pad_len = 110250 - len(audio)
    audio = np.pad(audio, (0, pad_len))
    return audio

# 处理数据
audio_list = []
for i in tqdm(glob.glob(data_path)):
    audio = audio_preprocessing(i)
    audio_list.append(audio)

# 绘制音频信号
plt.plot(audio_list[0])

train = pd.DataFrame({'path': glob.glob(data_path)})
train['label'] = train['path'].apply(lambda x: x.split('\\')[1]).replace({'Major': 1, 'Minor': 0})

# 859, 2205, 50
x_train = np.array(audio_list).reshape(859, -1, 50)
y_train = train['label'].values

# 形成训练集
train_dataset = torch.utils.data.TensorDataset(
    torch.tensor(x_train),
    torch.tensor(y_train))

# 形成迭代器
train_loader = torch.utils.data.DataLoader(train_dataset,
                                           batch_size,
                                           True)

print('using {} data for training.'.format(len(train_dataset)))

# 定义一维卷积模块
class CNN(nn.Module):
    def __init__(self, hidden_dim, num_layers, output_dim):
        super(CNN, self).__init__()
        self.lstm = nn.LSTM(50, hidden_dim, num_layers, batch_first=True)
        self.fc = nn.Linear(hidden_dim, output_dim)

    def forward(self, x):
        x, _ = self.lstm(x)  # torch.Size([32, 2205, 64]) 批次，序列长度，特征长度

        x = x[:, -1, :]  # torch.Size([32, 64])

        x = self.fc(x)  # torch.Size([32, 2])

        return x

# 模型训练
model = CNN(hidden_dim, num_layers, output_dim=2)

optimizer = optim.Adam(model.parameters(), lr=lr)  # 优化器
criterion = nn.CrossEntropyLoss()  # 多分类损失函数

model.to(device)
loss_meter = meter.AverageValueMeter()

best_acc = 0  			# 保存最好的准确率
best_model = None  		# 保存对应最好的准确率的模型参数
for epoch in range(epochs):
    model.train()  		# 开启训练模式
    epoch_acc = 0  		# 每个epoch的准确率
    epoch_acc_count = 0 	# 每个epoch训练的样本数
    train_count = 0  	# 用于计算总的样本数，方便求准确率
    loss_meter.reset()

    train_bar = tqdm(train_loader)  # 形成进度条
    for data in train_bar:
        x_input, label = data  # 解包迭代器中的X和Y

        optimizer.zero_grad()

        # 形成预测结果
        output_ = model(x_input.to(device))

        # 计算损失
        loss = criterion(output_, label.view(-1))
        loss.backward()
        optimizer.step()

        loss_meter.add(loss.item())

        # 计算每个epoch正确的个数
        epoch_acc_count += (output_.argmax(axis=1) == label.view(-1)).sum()
        train_count += len(x_input)

    # 每个epoch对应的准确率
    epoch_acc = epoch_acc_count / train_count

    # 打印信息
    print("【EPOCH: 】%s" % str(epoch + 1))
    print("训练损失为%s" % (str(loss_meter.mean)))
    print("训练精度为%s" % (str(epoch_acc.item() * 100)[:5]) + '%')

    # 保存模型及相关信息
    if epoch_acc > best_acc:
        best_acc = epoch_acc
        best_model = model.state_dict()

    # 在训练结束保存最优的模型参数
    if epoch == epochs - 1:
        # 保存模型
        torch.save(best_model, './audio_best_model.pkl')

print('Finished Training')

运行结果如下：

100%|██████████| 859/859 [00:11<00:00, 72.31it/s] 
using 859 data for training.
100%|██████████| 27/27 [01:01<00:00,  2.27s/it]
【EPOCH: 】1
训练损失为0.6803049952895551
训练精度为58.44%
100%|██████████| 27/27 [01:13<00:00,  2.73s/it]
  0%|          | 0/27 [00:00<?, ?it/s]【EPOCH: 】2
训练损失为0.6797413362397087
训练精度为58.44%
100%|██████████| 27/27 [01:17<00:00,  2.88s/it]
  0%|          | 0/27 [00:00<?, ?it/s]【EPOCH: 】3
训练损失为0.6791554225815667
训练精度为58.44%
100%|██████████| 27/27 [01:12<00:00,  2.67s/it]
  0%|          | 0/27 [00:00<?, ?it/s]【EPOCH: 】4
训练损失为0.6791852536024868
训练精度为58.44%
100%|██████████| 27/27 [01:04<00:00,  2.38s/it]
【EPOCH: 】5
训练损失为0.6792585010881778
训练精度为58.44%
100%|██████████| 27/27 [01:07<00:00,  2.50s/it]
【EPOCH: 】6
训练损失为0.6790655829288341
训练精度为58.44%
100%|██████████| 27/27 [01:05<00:00,  2.41s/it]
【EPOCH: 】7
训练损失为0.6797297067112392
训练精度为58.44%
100%|██████████| 27/27 [01:01<00:00,  2.27s/it]
  0%|          | 0/27 [00:00<?, ?it/s]【EPOCH: 】8
训练损失为0.679986419501128
训练精度为58.44%
100%|██████████| 27/27 [01:04<00:00,  2.39s/it]
【EPOCH: 】9
训练损失为0.679186458940859
训练精度为58.44%
100%|██████████| 27/27 [01:04<00:00,  2.39s/it]
【EPOCH: 】10
训练损失为0.6789051713766875
训练精度为58.44%
Finished Training

这里只训练了10轮，训练的数据样本也偏小，后续可以增加训练轮次和训练的数据样本，最终可以达到比较高的识别准确率。

《PyTorch深度学习与企业级项目实战（人工智能技术丛书）》(宋立桓，宋立林)【摘要 书评 试读】- 京东图书 (jd.com)