使用Pytorch框架，训练ESC-50数据集

已于 2024-04-14 20:49:47 修改
阅读量333 收藏 6
点赞数 4
分类专栏： 音频特征提取 文章标签： pytorch 人工智能 深度学习 音频 python
于 2024-01-26 22:25:24 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_57540674/article/details/135873544
版权

        本文主要介绍在Pytorch框架下，利用K折交叉验证来训练ESC-50数据集，并保存最优模型。由于只有2000个样本音频，样本数量较少，故把训练集划分为训练集、测试集，且采用5折交叉验证法，同时加深网络层数。使得最终的准确率达到要求

语言：python

框架和设备：pytorch，CPU

关键词：ESC-50数据集、Dataset和Dataloader的编写、网络模型搭建、5折交叉验证、平均准确率、记录训练时间

一、ESC-50数据集介绍

ESC-50（Environmental Sound Classification）是一个用于环境音分类的音频数据集。该数据集由50个带标签的音频分类组成，每个音频片段长度为5秒，采样率为44.1kHz。这些音频片段都是从Freesound.org免费音频库中选取的。

该数据集主要用于环境声音的分类和识别，是机器学习和深度学习研究中经常使用的数据集之一。

ESC-50数据集可以从以下链接下载：

https://github.com/karolpiczak/ESC-50#download

可以下载压缩包并解压到本地，也可以使用Python的wget库下载，示例代码如下：

import wget

url = 'https://github.com/karolpiczak/ESC-50/archive/master.zip'
filename = wget.download(url)

这个代码片段会下载ESC-50数据集的压缩文件，并保存到当前工作目录下。下载完成后，需要将其解压缩，使用命令行或文件管理器即可完成。

二、编写ESC-50数据集的Dataset和Dataloader

        ESC-50数据集下载完成后，找到audio文件夹（存放的是所有音频）、meta中的csv文件（存放的是所有音频的信息）。

代码如下：

#定义dataset
import os
import pandas as pd
import torchaudio
from torch.utils.data import Dataset
from torchaudio.transforms import MelSpectrogram,AmplitudeToDB

class ESC50Dataset(Dataset):
    def __init__(self, base_path, csv_path, folds):
        """
        自定义的ESC-50数据集类
        :param base_path: 存储音频文件的基本路径
        :param csv_path: 包含元数据的CSV文件路径
        :param folds: 一个列表，包含要包括在数据集中的折叠编号
        """
        self.base_path = base_path
        self.csv_data = pd.read_csv(csv_path)#读取csv文件里的所有信息
        self.folds = folds#表示音频的类别，共把ESC50数据集分为了5大类
        self.data = self.csv_data[self.csv_data.fold.isin(folds)]#可以得到一个长度与csv_data相同的布尔类型Series（Series是Pandas中的一种数据类型，类似于数组），
                                                                 #该Series的每个元素表示该行数据所在的fold是否在folds列表中。
        self.amplitude_to_db = AmplitudeToDB()#幅度值转为db刻度

        #转为梅尔谱
        self.to_mel_spectrogram = MelSpectrogram(
            sample_rate=44100,
            n_fft=2048,
            hop_length=512,
            n_mels=64
        )

    def __getitem__(self, index):
        # 选择指定索引的条目
        row = self.data.iloc[index]
        # 读取音频文件
        file_path = os.path.join(self.base_path, row['filename'])
        waveform, sample_rate = torchaudio.load(file_path)
        mel_spectrogram = self.to_mel_spectrogram(waveform)
        # 转换到对数刻度（也就是db刻度）
        mel_spec_db = self.amplitude_to_db(mel_spectrogram)
        # 归一化
        mel_spec_norm = (mel_spec_db - mel_spec_db.mean()) / mel_spec_db.std()
        # 获取标签
        label = row['target']
        return mel_spec_norm, label#返回梅尔谱和对应的标签

    def __len__(self):
        return len(self.data)

# 基本路径和元数据文件路径
base_path = '/home/yc/vs_code/pytorch_audio/ESC-50/ESC-50-master/audio'  # 更新为音频文件存储的真实路径
csv_path = 'ESC-50/ESC-50-master/meta/esc50.csv'  # 更新为CSV文件存储的真实路径

# 创建一个数据集实例，包括1-5,因为csv文件里已经分为了5大类，所以不用自己划分数据集
esc_dataset = ESC50Dataset(base_path=base_path, csv_path=csv_path, folds=[1, 2, 3, 4, 5])

三、搭建网络模型

import torch
from torch import nn
from torch.nn import ReLU,Linear,Flatten,Sequential

#搭建网络模型
class Yangc(nn.Module):
    def __init__(self):
        super(Yangc,self).__init__()
        self.model=Sequential(
            nn.Conv2d(in_channels=1, out_channels=3, kernel_size=3, padding=2),
            ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=2, stride=2),

            nn.Conv2d(in_channels=3, out_channels=8, kernel_size=3, padding=2),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=2, stride=2),  
   
            nn.Conv2d(in_channels=8, out_channels=16, kernel_size=3, padding=2),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=2, stride=2),

            nn.Conv2d(in_channels=16, out_channels=32, kernel_size=3, padding=2),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=2, stride=2),

            nn.Conv2d(in_channels=32, out_channels=48, kernel_size=3, padding=2),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=2, stride=2),

            nn.Conv2d(in_channels=48, out_channels=64, kernel_size=3, padding=2),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=2, stride=2),

            Flatten(),
            Linear(1024,512),
            nn.Dropout(),

            Linear(512,64),
            nn.Dropout(),

            Linear(64,50)
        )

    def forward(self,x):
        x=self.model(x)
        return x
    
if __name__ == '__main__':#写主函数，是为了检验神经网络模型是否搭建正确
    yangc=Yangc()
    input=torch.ones(64,1,64,431)
    output=yangc(input)
    print(output.shape)

输出：

torch.Size([64, 50])

四、开始交叉验证，并保存最优模型

import torch
import os
import pandas as pd
import torchaudio
from torch.utils.data import DataLoader,Dataset
from torchaudio.transforms import MelSpectrogram,AmplitudeToDB
import time#用于计时
from model import Yangc#导入模型

from torch.utils.data import DataLoader, SubsetRandomSampler
from sklearn.model_selection import KFold

# 参数设置
batch_size = 64
k_folds = 5
num_epochs = 50#训练总轮数
learning_rate = 0.001#学习率

# K折交叉验证模型
kf = KFold(n_splits=k_folds, shuffle=True)

#最终结果
results = []

min_acc = 0.#保存最好模型的参考值
# 外层循环遍历每一折
for fold, (train_ids, test_ids) in enumerate(kf.split(esc_dataset)):
    print(f'FOLD {fold}')
    print('--------------------------------')

    # 采样器
    train_subsampler = SubsetRandomSampler(train_ids)
    test_subsampler = SubsetRandomSampler(test_ids)

    # 数据加载器
    train_loader = DataLoader(esc_dataset, batch_size=batch_size, sampler=train_subsampler, num_workers = 5)
    test_loader = DataLoader(esc_dataset, batch_size=batch_size, sampler=test_subsampler, num_workers = 5)

    # 初始化模型
    model = Yangc() # 音频分类模型
    optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)#选择Adam优化器
    loss_fn = torch.nn.CrossEntropyLoss()

    best_vacc = 0.0#每一个fold中最高的准确率
    best_epoch = 0#保存最好模型对应的轮数
    best_fold = 0#保存最好模型对应的类别

    # 训练
    start_time=time.time()#训练开始计时
    for epoch in range(num_epochs):
        model.train()
        for i,(X,targets) in enumerate(train_loader):
            outputs = model(X)
            optimizer.zero_grad()
            loss = loss_fn(outputs, targets)

            # 优化器优化模型
            loss.backward()
            optimizer.step()
            
        model.eval()
        corrects,num = 0.0,0.0
        total_loss = 0.0
        with torch.no_grad():
            for i,(X,targets) in enumerate(test_loader):
                outputs = model(X)
                loss = loss_fn(outputs,targets)

                corrects += (outputs.argmax(1)  == targets).sum().item()
                num += X.shape[0]

        vacc = corrects/num#计算准确率
        accuracy=vacc*100

        if accuracy > best_vacc:
            best_vacc = accuracy
            best_epoch = epoch+1
            best_fold = fold+1
        print(f'Epoch [{epoch+1}/{num_epochs}], Fold [{fold+1}/{k_folds}], Accuracy: {accuracy:.2f}%')
    
    print(f'best_acc: {best_vacc:.2f}%')

    # 保存最好的模型权重
    if best_vacc > min_acc:
        min_acc = best_vacc
        print(f'保存最好的模型,并打印Epoch和folds')
        print(f'Epoch: {best_epoch}, Fold: {best_fold}')
            
        torch.save(model.state_dict(), 'save_model/best_model.pth')

    fold_accuracy = best_vacc
    results.append(fold_accuracy)

    end_time=time.time()
    print("耗费时间:{}".format(end_time-start_time))


# 计算平均性能
average_performance = sum(results) / len(results)
print(f"平均准确率: {average_performance}")

输出：

FOLD 0
--------------------------------
Epoch [1/50], Fold [1/5], Accuracy: 3.00%
Epoch [2/50], Fold [1/5], Accuracy: 1.00%
Epoch [3/50], Fold [1/5], Accuracy: 4.00%
Epoch [4/50], Fold [1/5], Accuracy: 9.75%
Epoch [5/50], Fold [1/5], Accuracy: 11.00%
Epoch [6/50], Fold [1/5], Accuracy: 13.25%
Epoch [7/50], Fold [1/5], Accuracy: 17.75%
Epoch [8/50], Fold [1/5], Accuracy: 19.00%
Epoch [9/50], Fold [1/5], Accuracy: 22.50%
Epoch [10/50], Fold [1/5], Accuracy: 27.50%
Epoch [11/50], Fold [1/5], Accuracy: 29.25%
Epoch [12/50], Fold [1/5], Accuracy: 27.50%
Epoch [13/50], Fold [1/5], Accuracy: 31.75%
Epoch [14/50], Fold [1/5], Accuracy: 35.00%
Epoch [15/50], Fold [1/5], Accuracy: 35.25%
Epoch [16/50], Fold [1/5], Accuracy: 37.75%
Epoch [17/50], Fold [1/5], Accuracy: 40.50%
Epoch [18/50], Fold [1/5], Accuracy: 37.50%
Epoch [19/50], Fold [1/5], Accuracy: 41.25%
Epoch [20/50], Fold [1/5], Accuracy: 39.75%
Epoch [21/50], Fold [1/5], Accuracy: 39.50%
Epoch [22/50], Fold [1/5], Accuracy: 42.50%
Epoch [23/50], Fold [1/5], Accuracy: 43.00%
Epoch [24/50], Fold [1/5], Accuracy: 41.75%
Epoch [25/50], Fold [1/5], Accuracy: 42.25%
Epoch [26/50], Fold [1/5], Accuracy: 44.00%
Epoch [27/50], Fold [1/5], Accuracy: 43.50%
Epoch [28/50], Fold [1/5], Accuracy: 42.00%
Epoch [29/50], Fold [1/5], Accuracy: 42.00%
Epoch [30/50], Fold [1/5], Accuracy: 45.50%
Epoch [31/50], Fold [1/5], Accuracy: 47.25%
Epoch [32/50], Fold [1/5], Accuracy: 46.50%
Epoch [33/50], Fold [1/5], Accuracy: 45.00%
Epoch [34/50], Fold [1/5], Accuracy: 47.50%
Epoch [35/50], Fold [1/5], Accuracy: 46.00%
Epoch [36/50], Fold [1/5], Accuracy: 47.00%
Epoch [37/50], Fold [1/5], Accuracy: 48.25%
Epoch [38/50], Fold [1/5], Accuracy: 46.00%
Epoch [39/50], Fold [1/5], Accuracy: 45.25%
Epoch [40/50], Fold [1/5], Accuracy: 47.50%
Epoch [41/50], Fold [1/5], Accuracy: 46.50%
Epoch [42/50], Fold [1/5], Accuracy: 49.75%
Epoch [43/50], Fold [1/5], Accuracy: 47.25%
Epoch [44/50], Fold [1/5], Accuracy: 47.50%
Epoch [45/50], Fold [1/5], Accuracy: 49.00%
Epoch [46/50], Fold [1/5], Accuracy: 47.25%
Epoch [47/50], Fold [1/5], Accuracy: 48.50%
Epoch [48/50], Fold [1/5], Accuracy: 47.50%
Epoch [49/50], Fold [1/5], Accuracy: 47.00%
Epoch [50/50], Fold [1/5], Accuracy: 48.25%
best_acc: 49.75%
保存最好的模型,并打印Epoch和folds
Epoch 50, Fold 1
耗费时间:460.83227133750916
FOLD 1
--------------------------------
Epoch [1/50], Fold [2/5], Accuracy: 1.25%
Epoch [2/50], Fold [2/5], Accuracy: 1.50%
Epoch [3/50], Fold [2/5], Accuracy: 3.75%
Epoch [4/50], Fold [2/5], Accuracy: 9.50%
Epoch [5/50], Fold [2/5], Accuracy: 10.25%
Epoch [6/50], Fold [2/5], Accuracy: 17.00%
Epoch [7/50], Fold [2/5], Accuracy: 18.50%
Epoch [8/50], Fold [2/5], Accuracy: 26.50%
Epoch [9/50], Fold [2/5], Accuracy: 29.25%
Epoch [10/50], Fold [2/5], Accuracy: 28.00%
Epoch [11/50], Fold [2/5], Accuracy: 31.75%
Epoch [12/50], Fold [2/5], Accuracy: 32.75%
Epoch [13/50], Fold [2/5], Accuracy: 35.75%
Epoch [14/50], Fold [2/5], Accuracy: 34.25%
Epoch [15/50], Fold [2/5], Accuracy: 37.50%
Epoch [16/50], Fold [2/5], Accuracy: 39.75%
Epoch [17/50], Fold [2/5], Accuracy: 44.00%
Epoch [18/50], Fold [2/5], Accuracy: 39.00%
Epoch [19/50], Fold [2/5], Accuracy: 41.50%
Epoch [20/50], Fold [2/5], Accuracy: 45.50%
Epoch [21/50], Fold [2/5], Accuracy: 47.00%
Epoch [22/50], Fold [2/5], Accuracy: 47.25%
Epoch [23/50], Fold [2/5], Accuracy: 52.00%
Epoch [24/50], Fold [2/5], Accuracy: 52.75%
Epoch [25/50], Fold [2/5], Accuracy: 51.75%
Epoch [26/50], Fold [2/5], Accuracy: 48.75%
Epoch [27/50], Fold [2/5], Accuracy: 51.50%
Epoch [28/50], Fold [2/5], Accuracy: 48.25%
Epoch [29/50], Fold [2/5], Accuracy: 51.25%
Epoch [30/50], Fold [2/5], Accuracy: 51.50%
Epoch [31/50], Fold [2/5], Accuracy: 51.75%
Epoch [32/50], Fold [2/5], Accuracy: 53.25%
Epoch [33/50], Fold [2/5], Accuracy: 53.25%
Epoch [34/50], Fold [2/5], Accuracy: 54.00%
Epoch [35/50], Fold [2/5], Accuracy: 55.00%
Epoch [36/50], Fold [2/5], Accuracy: 53.00%
Epoch [37/50], Fold [2/5], Accuracy: 53.50%
Epoch [38/50], Fold [2/5], Accuracy: 52.00%
Epoch [39/50], Fold [2/5], Accuracy: 54.50%
Epoch [40/50], Fold [2/5], Accuracy: 53.50%
Epoch [41/50], Fold [2/5], Accuracy: 53.75%
Epoch [42/50], Fold [2/5], Accuracy: 57.75%
Epoch [43/50], Fold [2/5], Accuracy: 55.25%
Epoch [44/50], Fold [2/5], Accuracy: 52.50%
Epoch [45/50], Fold [2/5], Accuracy: 51.50%
Epoch [46/50], Fold [2/5], Accuracy: 53.75%
Epoch [47/50], Fold [2/5], Accuracy: 52.50%
Epoch [48/50], Fold [2/5], Accuracy: 55.00%
Epoch [49/50], Fold [2/5], Accuracy: 53.25%
Epoch [50/50], Fold [2/5], Accuracy: 52.50%
best_acc: 57.75%
保存最好的模型,并打印Epoch和folds
Epoch 50, Fold 2
耗费时间:427.56484937667847
FOLD 2
--------------------------------
Epoch [1/50], Fold [3/5], Accuracy: 2.50%
Epoch [2/50], Fold [3/5], Accuracy: 5.25%
Epoch [3/50], Fold [3/5], Accuracy: 7.00%
Epoch [4/50], Fold [3/5], Accuracy: 10.00%
Epoch [5/50], Fold [3/5], Accuracy: 13.75%
Epoch [6/50], Fold [3/5], Accuracy: 18.25%
Epoch [7/50], Fold [3/5], Accuracy: 20.25%
Epoch [8/50], Fold [3/5], Accuracy: 22.00%
Epoch [9/50], Fold [3/5], Accuracy: 25.00%
Epoch [10/50], Fold [3/5], Accuracy: 28.25%
Epoch [11/50], Fold [3/5], Accuracy: 27.50%
Epoch [12/50], Fold [3/5], Accuracy: 30.75%
Epoch [13/50], Fold [3/5], Accuracy: 29.50%
Epoch [14/50], Fold [3/5], Accuracy: 34.25%
Epoch [15/50], Fold [3/5], Accuracy: 34.75%
Epoch [16/50], Fold [3/5], Accuracy: 37.50%
Epoch [17/50], Fold [3/5], Accuracy: 40.50%
Epoch [18/50], Fold [3/5], Accuracy: 38.75%
Epoch [19/50], Fold [3/5], Accuracy: 38.75%
Epoch [20/50], Fold [3/5], Accuracy: 38.75%
Epoch [21/50], Fold [3/5], Accuracy: 38.75%
Epoch [22/50], Fold [3/5], Accuracy: 40.50%
Epoch [23/50], Fold [3/5], Accuracy: 39.50%
Epoch [24/50], Fold [3/5], Accuracy: 42.50%
Epoch [25/50], Fold [3/5], Accuracy: 41.50%
Epoch [26/50], Fold [3/5], Accuracy: 42.75%
Epoch [27/50], Fold [3/5], Accuracy: 45.75%
Epoch [28/50], Fold [3/5], Accuracy: 44.50%
Epoch [29/50], Fold [3/5], Accuracy: 46.25%
Epoch [30/50], Fold [3/5], Accuracy: 43.75%
Epoch [31/50], Fold [3/5], Accuracy: 45.50%
Epoch [32/50], Fold [3/5], Accuracy: 48.25%
Epoch [33/50], Fold [3/5], Accuracy: 47.75%
Epoch [34/50], Fold [3/5], Accuracy: 48.75%
Epoch [35/50], Fold [3/5], Accuracy: 51.75%
Epoch [36/50], Fold [3/5], Accuracy: 51.75%
Epoch [37/50], Fold [3/5], Accuracy: 51.25%
Epoch [38/50], Fold [3/5], Accuracy: 52.25%
Epoch [39/50], Fold [3/5], Accuracy: 52.25%
Epoch [40/50], Fold [3/5], Accuracy: 49.75%
Epoch [41/50], Fold [3/5], Accuracy: 53.00%
Epoch [42/50], Fold [3/5], Accuracy: 53.25%
Epoch [43/50], Fold [3/5], Accuracy: 51.25%
Epoch [44/50], Fold [3/5], Accuracy: 52.25%
Epoch [45/50], Fold [3/5], Accuracy: 53.25%
Epoch [46/50], Fold [3/5], Accuracy: 51.25%
Epoch [47/50], Fold [3/5], Accuracy: 54.25%
Epoch [48/50], Fold [3/5], Accuracy: 55.00%
Epoch [49/50], Fold [3/5], Accuracy: 53.25%
Epoch [50/50], Fold [3/5], Accuracy: 52.00%
best_acc: 55.00%
耗费时间:425.57921600341797
FOLD 3
--------------------------------
Epoch [1/50], Fold [4/5], Accuracy: 0.75%
Epoch [2/50], Fold [4/5], Accuracy: 2.75%
Epoch [3/50], Fold [4/5], Accuracy: 5.75%
Epoch [4/50], Fold [4/5], Accuracy: 9.00%
Epoch [5/50], Fold [4/5], Accuracy: 10.50%
Epoch [6/50], Fold [4/5], Accuracy: 13.00%
Epoch [7/50], Fold [4/5], Accuracy: 20.00%
Epoch [8/50], Fold [4/5], Accuracy: 21.75%
Epoch [9/50], Fold [4/5], Accuracy: 21.75%
Epoch [10/50], Fold [4/5], Accuracy: 24.25%
Epoch [11/50], Fold [4/5], Accuracy: 27.25%
Epoch [12/50], Fold [4/5], Accuracy: 27.50%
Epoch [13/50], Fold [4/5], Accuracy: 26.25%
Epoch [14/50], Fold [4/5], Accuracy: 30.00%
Epoch [15/50], Fold [4/5], Accuracy: 32.00%
Epoch [16/50], Fold [4/5], Accuracy: 35.00%
Epoch [17/50], Fold [4/5], Accuracy: 34.75%
Epoch [18/50], Fold [4/5], Accuracy: 38.25%
Epoch [19/50], Fold [4/5], Accuracy: 38.50%
Epoch [20/50], Fold [4/5], Accuracy: 37.50%
Epoch [21/50], Fold [4/5], Accuracy: 36.00%
Epoch [22/50], Fold [4/5], Accuracy: 38.25%
Epoch [23/50], Fold [4/5], Accuracy: 37.50%
Epoch [24/50], Fold [4/5], Accuracy: 38.75%
Epoch [25/50], Fold [4/5], Accuracy: 42.75%
Epoch [26/50], Fold [4/5], Accuracy: 44.50%
Epoch [27/50], Fold [4/5], Accuracy: 41.00%
Epoch [28/50], Fold [4/5], Accuracy: 45.50%
Epoch [29/50], Fold [4/5], Accuracy: 47.25%
Epoch [30/50], Fold [4/5], Accuracy: 49.00%
Epoch [31/50], Fold [4/5], Accuracy: 47.75%
Epoch [32/50], Fold [4/5], Accuracy: 48.50%
Epoch [33/50], Fold [4/5], Accuracy: 47.25%
Epoch [34/50], Fold [4/5], Accuracy: 47.50%
Epoch [35/50], Fold [4/5], Accuracy: 47.75%
Epoch [36/50], Fold [4/5], Accuracy: 44.50%
Epoch [37/50], Fold [4/5], Accuracy: 45.25%
Epoch [38/50], Fold [4/5], Accuracy: 49.00%
Epoch [39/50], Fold [4/5], Accuracy: 47.50%
Epoch [40/50], Fold [4/5], Accuracy: 50.75%
Epoch [41/50], Fold [4/5], Accuracy: 50.75%
Epoch [42/50], Fold [4/5], Accuracy: 49.75%
Epoch [43/50], Fold [4/5], Accuracy: 48.50%
Epoch [44/50], Fold [4/5], Accuracy: 49.00%
Epoch [45/50], Fold [4/5], Accuracy: 51.25%
Epoch [46/50], Fold [4/5], Accuracy: 49.25%
Epoch [47/50], Fold [4/5], Accuracy: 48.75%
Epoch [48/50], Fold [4/5], Accuracy: 52.50%
Epoch [49/50], Fold [4/5], Accuracy: 52.50%
Epoch [50/50], Fold [4/5], Accuracy: 51.00%
best_acc: 52.50%
耗费时间:427.9511728286743
FOLD 4
--------------------------------
Epoch [1/50], Fold [5/5], Accuracy: 2.50%
Epoch [2/50], Fold [5/5], Accuracy: 7.75%
Epoch [3/50], Fold [5/5], Accuracy: 7.00%
Epoch [4/50], Fold [5/5], Accuracy: 14.00%
Epoch [5/50], Fold [5/5], Accuracy: 17.50%
Epoch [6/50], Fold [5/5], Accuracy: 22.00%
Epoch [7/50], Fold [5/5], Accuracy: 21.00%
Epoch [8/50], Fold [5/5], Accuracy: 25.00%
Epoch [9/50], Fold [5/5], Accuracy: 28.75%
Epoch [10/50], Fold [5/5], Accuracy: 30.25%
Epoch [11/50], Fold [5/5], Accuracy: 31.25%
Epoch [12/50], Fold [5/5], Accuracy: 31.50%
Epoch [13/50], Fold [5/5], Accuracy: 34.00%
Epoch [14/50], Fold [5/5], Accuracy: 36.25%
Epoch [15/50], Fold [5/5], Accuracy: 41.25%
Epoch [16/50], Fold [5/5], Accuracy: 38.50%
Epoch [17/50], Fold [5/5], Accuracy: 41.50%
Epoch [18/50], Fold [5/5], Accuracy: 42.25%
Epoch [19/50], Fold [5/5], Accuracy: 40.00%
Epoch [20/50], Fold [5/5], Accuracy: 43.75%
Epoch [21/50], Fold [5/5], Accuracy: 41.75%
Epoch [22/50], Fold [5/5], Accuracy: 43.00%
Epoch [23/50], Fold [5/5], Accuracy: 48.00%
Epoch [24/50], Fold [5/5], Accuracy: 41.50%
Epoch [25/50], Fold [5/5], Accuracy: 45.50%
Epoch [26/50], Fold [5/5], Accuracy: 46.25%
Epoch [27/50], Fold [5/5], Accuracy: 47.25%
Epoch [28/50], Fold [5/5], Accuracy: 47.75%
Epoch [29/50], Fold [5/5], Accuracy: 46.75%
Epoch [30/50], Fold [5/5], Accuracy: 47.75%
Epoch [31/50], Fold [5/5], Accuracy: 49.00%
Epoch [32/50], Fold [5/5], Accuracy: 49.50%
Epoch [33/50], Fold [5/5], Accuracy: 52.00%
Epoch [34/50], Fold [5/5], Accuracy: 48.25%
Epoch [35/50], Fold [5/5], Accuracy: 49.00%
Epoch [36/50], Fold [5/5], Accuracy: 43.75%
Epoch [37/50], Fold [5/5], Accuracy: 49.00%
Epoch [38/50], Fold [5/5], Accuracy: 48.75%
Epoch [39/50], Fold [5/5], Accuracy: 49.25%
Epoch [40/50], Fold [5/5], Accuracy: 51.00%
Epoch [41/50], Fold [5/5], Accuracy: 47.50%
Epoch [42/50], Fold [5/5], Accuracy: 49.50%
Epoch [43/50], Fold [5/5], Accuracy: 49.00%
Epoch [44/50], Fold [5/5], Accuracy: 48.25%
Epoch [45/50], Fold [5/5], Accuracy: 48.00%
Epoch [46/50], Fold [5/5], Accuracy: 51.25%
Epoch [47/50], Fold [5/5], Accuracy: 49.75%
Epoch [48/50], Fold [5/5], Accuracy: 47.75%
Epoch [49/50], Fold [5/5], Accuracy: 51.50%
Epoch [50/50], Fold [5/5], Accuracy: 48.75%
best_acc: 52.00%
耗费时间:439.0925712585449
平均准确率: 53.4

说明：每一折取最好的准确率，5折之后得到5个准确率，再求平均值，即可得到平均准确率53.4%

由此可见，测试效果良好。

五、完整代码

import torch
import os
import pandas as pd
import torchaudio
from torch.utils.data import DataLoader,Dataset
from torchaudio.transforms import MelSpectrogram,AmplitudeToDB
import time#用于计时
from model import Yangc#导入模型

from torch.utils.data import DataLoader, SubsetRandomSampler
from sklearn.model_selection import KFold

#定义dataset
class ESC50Dataset(Dataset):
    def __init__(self, base_path, csv_path, folds):
        """
        自定义的ESC-50数据集类
        :param base_path: 存储音频文件的基本路径
        :param csv_path: 包含元数据的CSV文件路径
        :param folds: 一个列表，包含要包括在数据集中的折叠编号
        """
        self.base_path = base_path
        self.csv_data = pd.read_csv(csv_path)
        self.folds = folds
        self.data = self.csv_data[self.csv_data.fold.isin(folds)]
        self.amplitude_to_db = AmplitudeToDB()

        #转为梅尔谱
        self.to_mel_spectrogram = MelSpectrogram(
            sample_rate=44100,
            n_fft=2048,
            hop_length=512,
            n_mels=64
        )

    def __getitem__(self, index):
        # 选择指定索引的条目
        row = self.data.iloc[index]
        # 读取音频文件
        file_path = os.path.join(self.base_path, row['filename'])
        waveform, sample_rate = torchaudio.load(file_path)
        mel_spectrogram = self.to_mel_spectrogram(waveform)
        # 转换到对数刻度
        mel_spec_db = self.amplitude_to_db(mel_spectrogram)
        # 归一化
        mel_spec_norm = (mel_spec_db - mel_spec_db.mean()) / mel_spec_db.std()
        # 获取标签
        label = row['target']
        return mel_spec_norm, label

    def __len__(self):
        return len(self.data)

# 基本路径和元数据文件路径
base_path = '/home/yc/vs_code/pytorch_audio/ESC-50/ESC-50-master/audio'  # 更新为音频文件存储的真实路径
csv_path = 'ESC-50/ESC-50-master/meta/esc50.csv'  # 更新为CSV文件存储的真实路径

# 创建一个数据集实例，包括1-5,因为csv文件里已经分为了5大类，所以不要自己划分数据集，要按照1,2,3,4训练集，5做测试集来划分
esc_dataset = ESC50Dataset(base_path=base_path, csv_path=csv_path, folds=[1, 2, 3, 4, 5])

# 参数设置
batch_size = 64
k_folds = 5
num_epochs = 50#训练总轮数
learning_rate = 0.001#学习率

# K折交叉验证模型
kf = KFold(n_splits=k_folds, shuffle=True)

#最终结果
results = []

min_acc = 0.#保存最好模型的参考值

#sampler说明:https://blog.csdn.net/qq_41971355/article/details/125616331?ops_request_misc=&request_id=&biz_id=102&utm_term=DataLoader%E4%B8%AD%E7%9A%84sample&utm_medium=distribute.pc_search_result.none-task-blog-2~all~sobaiduweb~default-5-125616331.142^v99^pc_search_result_base3&spm=1018.2226.3001.4187
#https://blog.csdn.net/kuxingseng123/article/details/128501104?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522170540980316800215035507%2522%252C%2522scm%2522%253A%252220140713.130102334..%2522%257D&request_id=170540980316800215035507&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~all~top_positive~default-1-128501104-null-null.142^v99^pc_search_result_base3&utm_term=SubsetRandomSampler&spm=1018.2226.3001.4187
# 外层循环遍历每一折
for fold, (train_ids, test_ids) in enumerate(kf.split(esc_dataset)):
    print(f'FOLD {fold}')
    print('--------------------------------')

    # 采样器
    train_subsampler = SubsetRandomSampler(train_ids)
    test_subsampler = SubsetRandomSampler(test_ids)

    # 数据加载器
    train_loader = DataLoader(esc_dataset, batch_size=batch_size, sampler=train_subsampler, num_workers = 5)
    test_loader = DataLoader(esc_dataset, batch_size=batch_size, sampler=test_subsampler, num_workers = 5)

    # 初始化模型
    model = Yangc() # 音频分类模型
    optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)#选择Adam优化器
    loss_fn = torch.nn.CrossEntropyLoss()

    best_vacc = 0.0#每一个fold中最高的准确率
    best_epoch = 0#保存最好模型对应的轮数
    best_fold = 0#保存最好模型对应的类别

    # 训练
    start_time=time.time()#训练开始计时
    for epoch in range(num_epochs):
        model.train()
        for i,(X,targets) in enumerate(train_loader):
            outputs = model(X)
            optimizer.zero_grad()
            loss = loss_fn(outputs, targets)

            # 优化器优化模型
            loss.backward()
            optimizer.step()
            
        model.eval()
        corrects,num = 0.0,0.0
        total_loss = 0.0
        with torch.no_grad():
            for i,(X,targets) in enumerate(test_loader):
                outputs = model(X)
                loss = loss_fn(outputs,targets)
                # total_loss += loss.item()

                corrects += (outputs.argmax(1)  == targets).sum().item()
                num += X.shape[0]

        vacc = corrects/num#计算准确率
        accuracy=vacc*100

        if accuracy > best_vacc:
            best_vacc = accuracy
            best_epoch = epoch+1
            best_fold = fold+1
        print(f'Epoch [{epoch+1}/{num_epochs}], Fold [{fold+1}/{k_folds}], Accuracy: {accuracy:.2f}%')
    
    print(f'best_acc: {best_vacc:.2f}%')

    # 保存最好的模型权重
    if best_vacc > min_acc:
        min_acc = best_vacc
        print(f'保存最好的模型,并打印Epoch和folds')
        print(f'Epoch: {best_epoch}, Fold: {best_fold}')
            
        torch.save(model.state_dict(), 'save_model/best_model.pth')

    fold_accuracy = best_vacc
    results.append(fold_accuracy)

    end_time=time.time()
    print("耗费时间:{}".format(end_time-start_time))


# 计算平均性能
average_performance = sum(results) / len(results)
print(f"平均准确率: {average_performance}")
难得北窗高卧
关注
  • 4
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
利用pytorch实现对CIFAR-10数据集的分类
09-18
今天小编就为大家分享一篇利用pytorch实现对CIFAR-10数据集的分类，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
通过python-pytorch训练识别服装-含数据集.zip
06-01
本代码是基于python pytorch环境安装的。 下载本代码后，有个requirement.txt文本，里面介绍了如何安装环境，...运行02深度学习模型训练.py就会将txt文本中记录的训练集和验证集进行读取训练，训练好后会保存模型在本地
基于pytorch框架的Faster-RCNN模型python源码+项目说明+数据集.zip
04-12
基于pytorch框架的Faster-RCNN模型python源码+项目说明+数据集.zip 基于pytorch框架的Faster-RCNN模型python源码+项目说明+数据集.zip 基于pytorch框架的Faster-RCNN模型python源码+项目说明+数据集.zip 基于pytorch...
通过pytorch训练蔬菜识别-含图片数据集.zip
05-29
运行02深度学习模型训练.py就会将txt文本中记录的训练集和验证集进行读取训练，训练好后会保存模型在本地 训练完成之后会有log日志保存本地，里面记录了每个epoch的验证集损失值和准确率。 运行03
ResNet-50 PyTorch Pretrained-数据集
03-18
数据集可用语在ImageNet上预训练的PyTorch模型，用于转移学习。如果将此数据集作为附加数据添加，则可以用作基础模型，可以使用转移学习针对特定任务对其进行微调。 ResNet-50 PyTorch Pretrained_datasets.txt ...
Torch-Pruning 库入门级使用介绍
a486259的博客
07-15 1124
项目地址：https://github.com/VainF/Torch-PruningTorch-Pruning 是一个专用于torch的模型剪枝库，其基于DepGraph 技术分析出模型layer中的依赖关系。DepGraph 与现有的修剪方法（如 Magnitude Pruning 或 Taylor Pruning）相结合可以达到良好的剪枝效果。本博文结合项目官网案例，对信息进行结构话，抽离出剪枝技术说明、剪枝模型保存与加载、剪枝技术的基本使用，剪枝技术的具体使用案例。
重学PyTorch，粗略笔记（一）
ziggybowie的博客
07-14 633
很久之前学PyTorch记的笔记，顺手整理一下。
解决RuntimeError: Couldn‘t load custom C++ ops. This can happen if your PyTorch
DZY的博客
07-15 500
刚下好yolov8的代码，想测一下能否成果，果然没成功，报错如下简单来说就是torchvision和torch不匹配，就很离谱，我照着版本对应关系pip install的啊，怎么会不匹配建议先看看你的版本我是下图红框这个首先确定自己torch没问题，因为我的3090这个卡目前cuda版本是11.1，这个whl是早就下好的，一般1-2G，有问题重新下就麻烦了然后我pip install了很多次torchvision==0.11.3，都没啥用。想试着改改版本，结果要下其他的torch版本，就更不可能了。
1.6.丢弃法
shiki217_的博客
07-15 1118
一个好的模型需要对输入数据的扰动足够健壮，丢弃法就是在层之间加入噪音。也可以在数据中使用噪音，等价与。
CV11_模型部署pytorch转ONNX
https://github.com/foxpup11?tab=repositories
07-15 1182
https://www.bilibili.com/video/BV1cM4y187Xc/?spm_id_from=333.337.search-card.all.click&vd_source=7dace3632125a1ef7fd32c285eb2fbac
early-stopping pytorch refs
Sarah ~
07-15 362
1)https://github.com/Bjarten/early-stopping-pytorch/blob/master/MNIST_Early_Stopping_example.ipynb 2)https://machinelearningmastery.com/managing-a-pytorch-training-process-with-checkpoints-and-early-stopping/ 3)https://pytorch.org/ignite/generated/ignite.h
PyTorch构建一个肺部CT图像分类模型来分辨肺癌
controller_Lw的博客
07-14 589
通过以上步骤，你可以使用PyTorch构建、训练和评估一个基于肺部CT图像的肺癌分类模型。记得根据实际情况调整超参数、模型架构和数据处理流程，以优化模型的性能。首先，确保你的数据集被正确分为训练集、验证集和测试集，并且每个图像都有相应的标签（例如0表示正常，1表示肺癌）。使用PyTorch的Dataset和DataLoader类加载和预处理数据。
【Week-G4】手势图像生成（CGAN）- PyTorch【使用生成好的生成器生成指定手势】
最新发布
qq_40724911的博客
07-18 452
本文环境：系统环境：语言：Python3.7.8编译器：VSCode深度学习框架：torch 1.13.1是否GPU训练：CPU本周代码基本和G3周一致，个别地方有修改：（2）绘制Loss图（3）选择训练好的epoch=300时的生成器模型来生成手势（4）数据集可视化部分选择显示第一个批次的图片训练持续时间：7.17日23:00-7月18日08:12，耗时9h12min。
PyTorch 深度学习实践-加载数据集
m0_52695557的博客
07-18 903
在深度学习时用min-batch来平衡训练时间和性能上的需求，之后训练周期要写成两层嵌套循环。epoch：所有训练样本进行完一次前向和反向传播，batch-size：训练的时候的样本数量，Iteration：总训练数据/训练样本数集成了dataset之后编写的类就可以用dataset的功能了训练的代码要用main包装起来解释：数据集，批数据大小，是否打乱，构成batch读取数据的时候是不是要用多线程，几个并行的线程1、需要mini_batch 就需要import DataSet和DataLoader。
【PyTorch快速入门教程】01 Pytorch安装及配置
Bedoom的博客
07-16 973
PyTorch教程第一节，最为保姆级的Pytorch安装博客。帮你从 0 开始配置好一个PyTorch环境。
PyTorch 深度学习实践-基于SoftMax的多分类
m0_52695557的博客
07-18 920
比如说0-9分类问题，如果y = torch.LongTensor([3])，对应的one-hot是[0,0,0,1,0,0,0,0,0,0].(这里要注意，如果使用了one-hot，标签y的类型是LongTensor，糖尿病数据集中的target的类型是FloatTensor)知识点：SoftMax激活函数，多分类交叉熵CrossEntropyLoss，图像transform预处理，训练测试单独封装，Y是经过独热编码后的值，只有一个概率最大的为1，计算损失只要计算Y为1的Y_hat的损失。
PyTorch 深度学习实践-卷积神经网络高级篇
m0_52695557的博客
07-18 901
而中间先经过一个1 * 1的卷积再经过一个5 * 5的卷积得到 32 * 28 * 28的输出运算为：1^2 * 28^2 * 192 * 16 + 5^2 + 28^2 * 16 * 32 = 12433648。跳连接：将H(x)的输入再加一个x，求导的时候x`=1，那么就算梯度很小也是将近于1，多个这样的数相乘梯度还是不为0，能解决梯度消失的情况，其中F(x)和x应该尺寸相同。3.复现经典工作：先读代码，训练架构，测试架构，数据读取架构，损失函数怎么构建的，根据论文讲的东西自己去写。
PyTorch 深度学习实践-循环神经网络基础篇
m0_52695557的博客
07-18 787
嵌入层的主要作用是将离散的词汇映射到连续的向量空间中，从而为RNN提供密集的、低维的输入表示，这比直接使用稀疏的one-hot编码更为高效。，但是这个线性层是共享的，如下图，每次把hi和xi+1计算得到的hi+1传送到下一层进行计算，同时xi+1还需要通过某种运算融合xi的信息（比如求和、求乘积等）h0是先验知识，比如对于图像生成文本，可以先通过cnn+fc生成h0，也可以把h0设成和h1等统一维度的向量，值都设成0。多头注意力机制是自注意力的扩展，它通过多个注意力头（head）来捕获不同的特征子空间。
PyTorch 深度学习实践-逻辑斯蒂回归
m0_52695557的博客
07-18 217
sigmod的函数是一个在生物学中常见的S型函数，也称为S型生长曲线。在信息科学中，由于其单增以及反函数单增等性质，常被用作神经网络的激活函数，将变量映射到0,1之间。-------------摘自《百度百科》sigmod函数也叫作Logistic函数，用于隐层神经单元输出，取值范围为（0,1），它可以将一个实数映射到（0,1）的区间，可以用来做二分类。在特征相差比较复杂或者相差不是特别大的时候效果比较好。说明：1、 逻辑斯蒂回归和线性模型的明显区别是在线性模型的后面，添加了激活函数(非线性变换)
使用BPG+LDPC训练并测试数据集，pytorch框架
05-14
首先，BPG（Binary Product Graph）是一种图像压缩算法，LDPC（Low-Density Parity-Check）是一种纠错编码算法。在使用BPG+LDPC对数据集进行训练和测试时，我们可以按照以下步骤进行： 1. 准备数据集：首先需要准备训练和测试数据集。可以使用PyTorch的Dataset和DataLoader类来加载数据集、处理数据以及生成批次数据。 2. 实现模型：可以使用PyTorch框架搭建BPG+LDPC模型。具体来说，可以使用PyTorch的nn.Module类来定义模型，使用nn.Conv2d和nn.Linear等函数来定义卷积层和全连接层等操作。 3. 设置优化器和损失函数：可以选择使用PyTorch中的Adam等优化器和MSELoss等损失函数。 4. 进行训练：通过迭代训练数据集，不断调整网络参数，以最小化损失函数。可以使用PyTorch的autograd自动计算梯度，使用optim库来进行优化器的操作。 5. 进行测试：使用测试集来评估模型的性能。可以计算模型的准确率、召回率、F1得分等指标来评估模型效果。 这些步骤中，最具挑战性的是实现BPG+LDPC模型。可以参考相关的论文和代码，也可以自行设计实现。在实现过程中，可以使用PyTorch的常用函数和工具，如nn.Module、nn.Conv2d、nn.Linear、optim等，来简化代码实现过程。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值