使用数据加载器准备一批数据
现在已经定义了我们需要将数据输入到模型中的所有函数。
我们使用自定义数据集从Pandas中加载特征和标签，然后以80:20的比例将数据随机分为训练和验证集。然后，我们使用它们来创建我们的训练和验证数据加载器。
fromtorch.utils.dataimportrandom_splitmyds=SoundDS(df, data_path) #Randomsplitof80:20betweentrainingandvalidationnum_items=len(myds) num_train=round(num_items*0.8) num_val=num_items-num_traintrain_ds, val_ds=random_split(myds, [num_train, num_val]) #Createtrainingandvalidationdataloaderstrain_dl=torch.utils.data.DataLoader(train_ds, batch_size=16, shuffle=True) val_dl=torch.utils.data.DataLoader(val_ds, batch_size=16, shuffle=False)
当我们开始训练时，将随机获取一批包含音频文件名列表的输入，并在每个音频文件上运行预处理音频转换。它还将获取一批包含类ID的相应目标Label。因此，它将一次输出一批训练数据，这些数据可以直接作为输入提供给我们的深度学习模型。
让我们从音频文件开始，逐步完成数据转换的各个步骤：
文件中的音频被加载到Numpy的数组中（num_channels，num_samples）。大部分音频以44.1kHz采样，持续时间约为4秒，从而产生44,100 * 4 = 176,400个采样。如果音频具有1个通道，则阵列的形状将为（1、176,400）。同样，具有2个通道的4秒钟持续时间且以48kHz采样的音频将具有192,000个采样，形状为（2，192,000）。
每种音频的通道和采样率不同，因此接下来的两次转换会将音频重新采样为标准的44.1kHz和标准的2个通道。
某些音频片段可能大于或小于4秒，因此我们还将音频持续时间标准化为固定的4秒长度。现在，所有项目的数组都具有相同的形状（2，176,400）
时移数据扩充功能会随机将每个音频样本向前或向后移动。形状不变。
扩充后的音频将转换为梅尔频谱图，其形状为（num_channels，Mel freq_bands，time_steps）=（2，64，344）
SpecAugment数据扩充功能将时间和频率掩码随机应用于梅尔频谱图。形状不变。
最后我们每批得到了两个张量，一个用于包含梅尔频谱图的X特征数据，另一个用于包含数字类ID的y目标标签。从每个训练轮次的训练数据中随机选择批次。
每个批次的形状为（batch_sz，num_channels，Mel freq_bands，time_steps）
我们可以将批次中的一项可视化。我们看到带有垂直和水平条纹的梅尔频谱图显示了频率和时间屏蔽数据的扩充。
建立模型
我们刚刚执行的数据处理步骤是我们音频分类问题中最独特的方面。从这里开始，模型和训练过程与标准图像分类问题中常用的模型和训练过程非常相似，并且不特定于音频深度学习。
由于我们的数据现在由光谱图图像组成，因此我们建立了CNN分类架构来对其进行处理。它具有生成特征图的四个卷积块。然后将数据重新整形为我们需要的格式，以便可以将其输入到线性分类器层，该层最终输出针对10个分类的预测。
模型信息：
色彩图像以形状（batch_sz，num_channels，Mel freq_bands，time_steps）输入模型。（16，2，64，344）。
每个CNN层都应用其滤镜以提高图像深度，即通道数。（16、64、4、22）。
将其合并并展平为（16，64）的形状，然后输入到“线性”层。
线性层为每个类别输出一个预测分数，即（16、10）
importtorch.nn.functionalasFfromtorch.nnimportinit#----------------------------#AudioClassificationModel#----------------------------classAudioClassifier (nn.Module): #----------------------------#Buildthemodelarchitecture#----------------------------def__init__(self): super().__init__() conv_layers= [] #FirstConvolutionBlockwithReluandBatchNorm. UseKaimingInitializationself.conv1=nn.Conv2d(2, 8, kernel_size=(5, 5), stride=(2, 2), padding=(2, 2)) self.relu1=nn.ReLU() self.bn1=nn.BatchNorm2d(8) init.kaiming_normal_(self.conv1.weight, a=0.1) self.conv1.bias.data.zero_() conv_layers+= [self.conv1, self.relu1, self.bn1] #SecondConvolutionBlockself.conv2=nn.Conv2d(8, 16, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1)) self.relu2=nn.ReLU() self.bn2=nn.BatchNorm2d(16) init.kaiming_normal_(self.conv2.weight, a=0.1) self.conv2.bias.data.zero_() conv_layers+= [self.conv2, self.relu2, self.bn2] #SecondConvolutionBlockself.conv3=nn.Conv2d(16, 32, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1)) self.relu3=nn.ReLU() self.bn3=nn.BatchNorm2d(32) init.kaiming_normal_(self.conv3.weight, a=0.1) self.conv3.bias.data.zero_() conv_layers+= [self.conv3, self.relu3, self.bn3] #SecondConvolutionBlockself.conv4=nn.Conv2d(32, 64, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1)) self.relu4=nn.ReLU() self.bn4=nn.BatchNorm2d(64) init.kaiming_normal_(self.conv4.weight, a=0.1) self.conv4.bias.data.zero_() conv_layers+= [self.conv4, self.relu4, self.bn4] #LinearClassifierself.ap=nn.AdaptiveAvgPool2d(output_size=1) self.lin=nn.Linear(in_features=64, out_features=10) #WraptheConvolutionalBlocksself.conv=nn.Sequential(*conv_layers) #----------------------------#Forwardpasscomputations#----------------------------defforward(self, x): #Runtheconvolutionalblocksx=self.conv(x) #Adaptivepoolandflattenforinputtolinearlayerx=self.ap(x) x=x.view(x.shape[0], -1) #Linearlayerx=self.lin(x) #Finaloutputreturnx#CreatethemodelandputitontheGPUifavailablemyModel=AudioClassifier() device=torch.device("cuda:0"iftorch.cuda.is_available() else"cpu") myModel=myModel.to(device) #CheckthatitisonCudanext(myModel.parameters()).device
训练
现在，我们准备创建训练循环来训练模型。
我们定义了优化器，损失函数和学习率的调度计划的函数，以便随着训练的进行而动态地改变我们的学习率，这样可以使模型收敛的更快。
在每轮训练完成后。我们跟踪一个简单的准确性指标，该指标衡量正确预测的百分比。
#----------------------------#TrainingLoop#----------------------------deftraining(model, train_dl, num_epochs): #LossFunction, OptimizerandSchedulercriterion=nn.CrossEntropyLoss() optimizer=torch.optim.Adam(model.parameters(),lr=0.001) scheduler=torch.optim.lr_scheduler.OneCycleLR(optimizer, max_lr=0.001, steps_per_epoch=int(len(train_dl)), epochs=num_epochs, anneal_strategy='linear') #Repeatforeachepochforepochinrange(num_epochs): running_loss=0.0correct_prediction=0total_prediction=0#Repeatforeachbatchinthetrainingsetfori, datainenumerate(train_dl): #Gettheinputfeaturesandtargetlabels, andputthemontheGPUinputs, labels=data[0].to(device), data[1].to(device) #Normalizetheinputsinputs_m, inputs_s=inputs.mean(), inputs.std() inputs= (inputs-inputs_m) /inputs_s#Zerotheparametergradientsoptimizer.zero_grad() #forward+backward+optimizeoutputs=model(inputs) loss=criterion(outputs, labels) loss.backward() optimizer.step() scheduler.step() #KeepstatsforLossandAccuracyrunning_loss+=loss.item() #Getthepredictedclasswiththehighestscore_, prediction=torch.max(outputs,1) #Countofpredictionsthatmatchedthetargetlabelcorrect_prediction+= (prediction==labels).sum().item() total_prediction+=prediction.shape[0] #ifi%10==0: #printevery10mini-batches#print('[%d, %5d] loss: %.3f'% (epoch+1, i+1, running_loss/10)) #Printstatsattheendoftheepochnum_batches=len(train_dl) avg_loss=running_loss/num_batchesacc=correct_prediction/total_predictionprint(f'Epoch: {epoch}, Loss: {avg_loss:.2f}, Accuracy: {acc:.2f}') print('Finished Training') num_epochs=2#Justfordemo, adjustthishigher. training(myModel, train_dl, num_epochs)
推理
作为训练循环的一部分，我们还将根据验证数据评估指标。所以我们会对原始数据中保留测试数据集（被当作是训练时看不见的数据）进行推理。出于本演示的目的，我们将为此目的使用验证数据。
我们禁用梯度更新并运行一个推理循环。与模型一起执行前向传播以获取预测，但是我们不需要反向传播和优化。
#----------------------------#Inference#----------------------------definference (model, val_dl): correct_prediction=0total_prediction=0#Disablegradientupdateswithtorch.no_grad(): fordatainval_dl: #Gettheinputfeaturesandtargetlabels, andputthemontheGPUinputs, labels=data[0].to(device), data[1].to(device) #Normalizetheinputsinputs_m, inputs_s=inputs.mean(), inputs.std() inputs= (inputs-inputs_m) /inputs_s#Getpredictionsoutputs=model(inputs) #Getthepredictedclasswiththehighestscore_, prediction=torch.max(outputs,1) #Countofpredictionsthatmatchedthetargetlabelcorrect_prediction+= (prediction==labels).sum().item() total_prediction+=prediction.shape[0] acc=correct_prediction/total_predictionprint(f'Accuracy: {acc:.2f}, Total items: {total_prediction}') #Runinferenceontrainedmodelwiththevalidationsetinference(myModel, val_dl)
结论
现在我们已经看到了声音分类的端到端示例，它是音频深度学习中最基础的问题之一。这不仅可以用于广泛的应用中，而且我们在此介绍的许多概念和技术都将与更复杂的音频问题相关，例如自动语音识别，其中我们从人类语音入手，了解人们在说什么，以及将其转换为文本。
最后，如果您喜欢这篇文章，给个赞吧。
