使用PyTorch对音频进行分类

D:\DL\ZEROTOGANS\06-URBAN8K-CLASSIFICATION\DATA\URBANSOUND8K
├───audio
│   ├───fold1
│   ├───fold10
│   ├───fold2
│   ├───fold3
│   ├───fold4
│   ├───fold5
│   ├───fold6
│   ├───fold7
│   ├───fold8
│   └───fold9
└───metadata

import torch
import pandas as pd
import librosa
import numpy as np
from torch.utils.data import TensorDataset, DataLoader, random_split
import librosa.display
import matplotlib.pyplot as plt
import tarfile
import torch.nn as nn
import torch.nn.functional as F

classes=list(df["class"].unique())
df=pd.read_csv("data/UrbanSound8K/metadata/UrbanSound8K.csv")
paths=dict()
for i in range(len(classes)):
    temp_df=df[df["class"]==classes[i]].reset_index()
    fold=temp_df["fold"].iloc[0]    # The fold of the first audio sample for the specific class
    sample_name=temp_df["slice_file_name"].iloc[0]
    path="data/UrbanSound8K/audio/fold{0}/{1}".format(fold, sample_name)
paths[classes[i]]=path

for i, label in enumerate(classes):
    sample=paths[label]
    plt.clf()
    plt.title(label)
    data, sample_rate=librosa.load(sample)
    librosa.display.waveplot(data, sr=sample_rate)
plt.show()

# Helper function to generate mfccs
def extract_mfcc(path):
    audio, sr=librosa.load(path)
    mfccs=librosa.feature.mfcc(audio, sr, n_mfcc=40)
    return np.mean(mfccs.T, axis=0)
features=[]
labels=[]
folds=[]
for i in range(len(df)):
    fold=df["fold"].iloc[i]
    filename=df["slice_file_name"].iloc[i]
    path="data/UrbanSound8K/audio/fold{0}/{1}".format(fold, filename)
    mfccs=extract_mfcc(path)
    features.append(mfccs)
    folds.append(fold)
    labels.append(df["classID"].iloc[i])
features=torch.tensor(features)
labels=torch.tensor(labels)
folds=torch.tensor(folds)
# Saving the dataset to disk to prevent re-Loading
torch.save(features, "data/features_mfccs.pt")
torch.save(labels, "data/labels.pt")
torch.save(folds, "data/folds.pt")

class AudioClassificationBase(nn.Module):
    def training_step(self, batch):
        images, labels = batch
        out = self(images)               
        loss = F.cross_entropy(out, labels)
        return loss
def validation_step(self, batch):
        images, labels = batch
        out = self(images)                    
        loss = F.cross_entropy(out, labels)   
        acc = accuracy(out, labels)           
        return {'val_loss': loss.detach(), 'val_acc': acc}
def validation_epoch_end(self, outputs):
        batch_losses = [x['val_loss'] for x in outputs]
        epoch_loss = torch.stack(batch_losses).mean()   
        batch_accs = [x['val_acc'] for x in outputs]
        epoch_acc = torch.stack(batch_accs).mean()     
        return {'val_loss': epoch_loss.item(), 'val_acc': epoch_acc.item()}

# Model 1
class UrbanSound8KModel(AudioClassificationBase):
    def __init__(self):
        super().__init__()
        self.network=nn.Sequential(
            nn.Linear(input_size,128),
            nn.ReLU(),
            nn.Linear(128, 64),
            nn.ReLU(),
            nn.Linear(64,output_size),
            nn.Sigmoid()
        )
def forward(self, x_batch):
        return self.network(x_batch)
# Model 2
class UrbanSound8KModel2(AudioClassificationBase):
    def __init__(self):
        super().__init__()
        self.network=nn.Sequential(
            nn.Linear(input_size,128),
            nn.ReLU(),
            nn.Linear(128, 256),
            nn.ReLU(),
            nn.Linear(256, 512),
            nn.ReLU(),
            nn.Linear(512,64),
            nn.ReLU(),
            nn.Linear(64,output_size),
            nn.Tanh()
        )
def forward(self, xb):
        return self.network(xb)
model=UrbanSound8KModel()
model2=UrbanSound8KModel2()

def get_default_device():
    if torch.cuda.is_available():
        return torch.device("cuda")
    return torch.device("cpu")
device=get_default_device()
device
# Function to move data to the chosen default device
def to_device(data, device):
    if isinstance(data, (list,tuple)):
        return [to_device(x, device) for x in data]
    return data.to(device, non_blocking=True)
# Defining an instance that moves all the tensors (DataLoaders) into the default device
class DeviceDataLoader():
    def __init__(self, dl, device):
        self.dl = dl
        self.device = device
def __iter__(self):
        for b in self.dl:
            yield to_device(b, self.device)
def __len__(self):
        return len(self.dl)

UrbanSound8KModel(
  (network): Sequential(
    (0): Linear(in_features=40, out_features=128, bias=True)
    (1): ReLU()
    (2): Linear(in_features=128, out_features=64, bias=True)
    (3): ReLU()
    (4): Linear(in_features=64, out_features=10, bias=True)
    (5): Sigmoid()
  )
)
UrbanSound8KModel2(
  (network): Sequential(
    (0): Linear(in_features=40, out_features=128, bias=True)
    (1): ReLU()
    (2): Linear(in_features=128, out_features=256, bias=True)
    (3): ReLU()
    (4): Linear(in_features=256, out_features=512, bias=True)
    (5): ReLU()
    (6): Linear(in_features=512, out_features=64, bias=True)
    (7): ReLU()
    (8): Linear(in_features=64, out_features=10, bias=True)
    (9): Tanh()
  )
)

Model 1
Validation loss -> 1.7691158056259155, Validation accuracy -> 0.5827487111091614
Model 2
Validation loss -> 1.4253952503204346, Validation accuracy -> 0.6507228016853333

torch.save(model.state_dict(), "outputs/model1.pth")
torch.save(model2.state_dict(), "outputs/model2.pth")

model.load_state_dict(torch.load("outputs/model.pth"))
model2.load_state_dict(torch.load("outputs/model2.pth"))