Contents
Audioclassificatie met torchaudio en ClearML
Audiosignalen zijn overal om ons heen. Als zodanig is er een toenemende interesse in audioclassificatie voor verschillende scenario's, van brandalarmdetectie voor slechthorenden, via motorgeluidanalyse voor onderhoudsdoeleinden tot babybewaking. Hoewel audiosignalen tijdelijk van aard zijn, is het in veel gevallen mogelijk om gebruik te maken van recente ontwikkelingen op het gebied van beeldclassificatie en populaire hoogwaardige convolutionele neurale netwerken te gebruiken voor audioclassificatie. In deze blogpost zullen we een dergelijk voorbeeld demonstreren door gebruik te maken van de populaire methode om het audiosignaal om te zetten in het frequentiedomein.
Deze blogpost is een derde van een serie over hoe u gebruik kunt maken van de ecosysteemtools van PyTorch om uw ML/DL-project eenvoudig een vliegende start te geven. De vorige blogposts waren gericht op beeldclassificatie en optimalisatie van hyperparameters. In deze blogpost laten we zien hoe het gebruik van Torchaudio en ClearML eenvoudige en efficiënte audioclassificatie mogelijk maakt.
Audioclassificatie met convolutionele neurale netwerken
In de afgelopen jaren hebben Convolutional Neural Networks (CNN's) bewezen zeer effectief te zijn in beeldclassificatietaken, die aanleiding gaven tot het ontwerp van verschillende architecturen, zoals Inception, ResNet, ResNext, Mobilenet en meer. Deze CNN's behalen state-of-the-art resultaten op het gebied van beeldclassificatietaken en bieden een verscheidenheid aan kant-en-klare, vooraf getrainde backbones. Als we dus in staat zullen zijn om audioclassificatietaken over te dragen naar het beelddomein, kunnen we deze rijke verscheidenheid aan backbones voor onze behoeften benutten.
Zoals eerder vermeld, in plaats van rechtstreeks het geluid te gebruiken bestand als een amplitude versus tijdsignaal willen we het audiosignaal omzetten in een afbeelding. De volgende voorbewerking is gedaan met behulp van dit script op de JaNee-gegevensset die is opgenomen in de ingebouwde gegevenssets van torchaudio.
Als eerste fase van voorbewerking zullen we:
- Lees het audiobestand – gebruik torchaudio
- Sample het audiosignaal opnieuw naar een vaste samplefrequentie – Dit zorgt ervoor dat alle signalen die we gaan gebruiken dezelfde samplefrequentie hebben. Theoretisch is de maximale frequentie die kan worden weergegeven door een gesampled signaal iets minder dan de helft van de samplefrequentie (bekend als de Nyquist-frequentie). Aangezien 20 kHz de hoogste frequentie is die over het algemeen door mensen hoorbaar is, wordt de bemonsteringsfrequentie van 44100 Hz als de meest populaire keuze beschouwd. In veel gevallen wordt het verwijderen van de hogere frequenties echter plausibel geacht om de hoeveelheid data per audiobestand te verminderen. Als zodanig is de bemonsteringsfrequentie van 20050 Hz redelijk populair voor MP3-bestanden met een lage bitrate. In ons voorbeeld gebruiken we deze samplefrequentie.
- Maak een mono-audiosignaal – Voor de eenvoud zorgen we ervoor dat alle signalen die we gebruiken hetzelfde aantal kanalen hebben.< /li>
De code voor een dergelijke voorbewerking ziet er als volgt uit:
yesno_data = torchaudio.datasets.YESNO('./data', download=True) number_of_samples = 3 fixed_sample_rate = 22050 voor n in range(number_of_smaples): audio, sample_rate, labels = yesno_data[n] resample_transform = torchaudio.transforms.Resample( orig_freq=sample_rate, new_freq=fixed_sample_rate) audio_mono = torch.mean(resample_transform(audio), dim=0, keepdim=True) plt.figure() plt.plot(audio_mono[0,:])
De resulterende matplotlib-plots zien er als volgt uit:
Audiosignaaltijdreeksen uit de YESNO-dataset
Nu is het tijd om dit tijdreekssignaal om te zetten in het beelddomein. We zullen dat doen door het om te zetten in een spectogram, wat een visuele weergave is van het spectrum van frequenties van een signaal zoals het in de tijd varieert. Voor dat doel gebruiken we een log-geschaald mel-spectrogram. Een mel-spectrogram is een spectrogram waarbij de frequenties worden omgezet naar de mel-schaal, waarbij rekening wordt gehouden met het feit dat mensen beter zijn in het detecteren van verschillen in lagere frequenties dan in hogere frequenties. De mel-schaal zet de frequenties om zodat gelijke afstanden in toonhoogte voor een menselijke luisteraar even ver weg klonken.
Dus laten we torchaudio-transformaties gebruiken en de volgende regels aan ons fragment toevoegen:
melspectogram_transform = torchaudio.transforms.MelSpectrogram( sample_rate=fixed_sample_rate, n_mels=128) melspectogram_db_transform = torchaudio.transforms.AmplitudeToDB() melspectogram = melspectogram_transform(audio_mono) plt.figure() plt.imshowque). cmap='hot') melspectogram_db=melspectogram_db_transform(melspectogram) plt.figure() plt.imshow(melspectogram_db.squeeze().numpy(), cmap='hot')
Nu wordt het audiobestand weergegeven als een tweedimensionaal spectrogrambeeld:
Mel-spectrogram (bovenste afbeelding) en zijn versie op logschaal (onderste afbeelding)
Dat is precies wat we wilden bereiken. Het audioclassificatieprobleem is nu omgevormd tot een beeldclassificatieprobleem.
ClearML, torchaudio en torchvision gebruiken voor audioclassificatie
Het ecosysteem van Pytorch omvat een verscheidenheid aan open source-tools die ons audioclassificatieproject een vliegende start kunnen geven en ons helpen het te beheren en te ondersteunen. In deze blog zullen we drie van deze tools gebruiken:
- ClearML is een open-source machine learning en deep learning experimentmanager en MLOps-oplossing. Het verhoogt de effectiviteit en productiviteit van AI-teams, evenals het gebruik van GPU's op locatie en in de cloud. ClearML helpt onderzoekers en ontwikkelaars om complexe machine learning-projecten te beheren zonder enige integratie-inspanning.
- Torchaudio is een pakket dat bestaat uit een I/O-functie, populaire datasets en veelvoorkomende audiotransformaties.
- Torchvision is dat een pakket dat bestaat uit populaire datasets, modelarchitecturen en algemene beeldtransformaties voor computervisie.
Ter vereenvoudiging leggen we in deze blog niet uit hoe je een ClearML-server installeert. Daarom wordt het experiment geregistreerd op de ClearML-demoserver. Zie de ClearML-documentatie voor meer informatie over het implementeren van een zelf-gehoste ClearML-server.
Voor deze blog gebruiken we de UrbanSound8K-dataset die 8732 gelabelde geluidsfragmenten (<=4s) bevat. van stadsgeluiden uit 10 lessen, waaronder hondengeblaf, sirene en straatmuziek. We zullen een vooraf getraind ResNet-model gebruiken om deze audiobestanden te classificeren.
We beginnen met het initialiseren van ClearML om alles wat we doen bij te houden:
van ClearML import Task task = Task.init(project_name='Audio Classification', task_name='UrbanSound8K classificatievoorbeeld')
Vervolgens zullen we ervoor zorgen dat er geen “magische getallen” in de code verborgen zijn en dat alle scriptparameters worden weergegeven in de experimentmanager-webapp. Wanneer u een python-script schrijft, kunt u het populaire argparse-pakket gebruiken en ClearML zal het automatisch oppikken. Terwijl we een Jupyter-notebookvoorbeeld schrijven, zullen we een configuratiewoordenboek definiëren en dit verbinden met het ClearML-taakobject:
configuration_dict = {'number_of_epochs': 6, 'batch_size': 8, 'dropout': 0.25, 'base_lr': 0.005, 'number_of_mel_filters': 64, 'resample_freq': 22050} configuration_dict = task.connect(configuration_dict)
Nu is het tijd om ons PyTorch Dataset-object te definiëren. Dit object moet zowel het laden van gegevens als de voorverwerking van gegevens bevatten. Het laden van de metadata van de dataset gebeurt in de constructor van de klasse en is geconfigureerd op basis van de UrbanSound8K-datasetstructuur. Daarom ziet het er als volgt uit:
class UrbanSoundDataset(Dataset): def __init__(self, csv_path, file_path, folderList, resample_freq=0): self.file_path = file_path self.file_names = [] self.labels = [] self.folders = [] self.n_mels = configuration_dict .get(number_of_mel_filters, 64) self.resample = resample_freq #loop door de csv-bestanden en voeg alleen die toe uit de mappenlijst csvData = pd.read_csv(csv_path) for i in range(0,len(csvData)): if csvData. iloc[i, 5] in folderList: self.file_names.append(csvData.iloc[i, 0]) self.labels.append(csvData.iloc[i, 6]) self.folders.append(csvData.iloc[i , 5])
Het volgende dat we gaan doen, is de methode __getitem__ van de klasse Dataset definiëren. Zoals eerder uitgelegd, willen we dat dit onderdeel verschillende voorbewerkingsstappen uitvoert:
- Laad het audiobestand
- Resample het naar een vooraf geconfigureerde sample rate – Merk op dat dit hier voor de eenvoud wordt gedaan. Het opnieuw samplen van een audiobestand is een tijdrovende functie die de training aanzienlijk zal vertragen en zal resulteren in een lager GPU-gebruik. Het is raadzaam om deze voorbewerkingsfunctie voor alle bestanden uit te voeren voorafgaand aan de trainingscycli.
- Zet het om in een eenkanaals audiosignaal
- Zet het om in een Mel-spectrogramsignaal
Naast het bovenstaande willen we dat alle getransformeerde signalen dezelfde vorm hebben. Daarom zullen we alle Mel-spectrogrammen knippen tot een vooraf geconfigureerde lengte en nulpad-spectrogrammen korter dan deze lengte. Het resultaat zou er als volgt uit moeten zien:
def __getitem__(self, index): #format het bestandspad en laad het bestandspad = self.file_path/(“fold” + str(self.folders[index]))/self.file_names[index] soundData, sample_rate = torchaudio .load(path, out = None, normalization = True) if self.resample > 0: resample_transform = torchaudio.transforms.Resample(orig_freq=sample_rate, new_freq=self.resample) soundData = resample_transform(soundData) # Dit converteert audiobestanden met twee kanalen naar één soundData = torch.mean(soundData, dim=0, keepdim =True) # Converteer audio naar logschaal Mel-spectrogram melspectrogram_transform = torchaudio.transforms.MelSpectrogram( sample_rate=self.resample, n_mels=self.n_mels) melspectrogram = melspectrogram_transform(soundData) melspectogram_db =(Amplaudio.transforms.) #Zorg ervoor dat alle spectrogrammen dezelfde grootte hebben fixed_length = 3 * (self.resample//200) als melspectogram_db.shape[2] < fixed_length: melspectogram_db = torch.nn.functional.pad(melspectogram_db, (0, fixed_length – melspectogram_db.shape[2])) else: melspectogram_db = melspectogram_db[:, :, :fixed_length] return soundData, self.resample, melspectogram_db, self.resample, melspectogram_db .labels[index]
Nu komt het beste deel. Omdat we het probleem hebben omgezet van het audiodomein naar het beelddomein, hoeven we ons geen zorgen te maken over het definiëren van een model. We kunnen een van de ingebouwde modellen gebruiken die bij Torchvision worden geleverd. We hebben gekozen voor het effectieve en robuuste ResNet-model. Omdat de dataset klein is en we het risico op overfitting willen verkleinen, zullen we het kleine maar effectieve ResNet18-model gebruiken. Naast deze geweldige snelkoppeling die we zojuist hebben genomen, stelt Torchvision ons in staat om een vooraf getraind model op Imagenet te laden, zodat de training korter en effectiever zal zijn.
Het enige wat we hoeven te doen is de invoerlaag en uitvoerlaag van de model naar onze gegevens. Dit kan eenvoudig als volgt worden gedaan:
model = models.resnet18(pretrained=True) model.conv1=nn.Conv2d(1, model.conv1.out_channels, kernel_size=model.conv1.kernel_size[0], stride=model.conv1.stride[0], padding= model.conv1.padding[0]) num_ftrs = model.fc.in_features model.fc = nn.Linear(num_ftrs, len(classes))
Dat is het! We kunnen beginnen met het trainen van ons model. In deze blog gaan we niet in op de opbouw van de trainings- en evaluatieloops. Ze zijn vrij eenvoudig en duidelijk – je kunt ze opzoeken in het volledige notitieboek. We zullen alleen opmerken dat we tijdens de training en evaluatie ervoor zorgen dat we de audiosignalen, de scalairen (verlies, nauwkeurigheid) en de spectrogrammen rapporteren aan de ingebouwde TensorBoard-klasse van PyTorch, voor foutopsporingsdoeleinden. ClearML haalt automatisch alle rapporten op die naar TensorBoard zijn verzonden en logt ze onder uw experiment in de web-app.
Het enige dat we nog moeten doen, is onze Jupyter-notebook uitvoeren, lokaal of op een externe machine met ClearML Agent en bekijk de voortgang van onze training op de ClearML-webapp.
Momentopnamen van de scalaire rapporten in ClearML-webapp
Omdat we ervoor hebben gezorgd dat we om de paar iteraties foutopsporingsgegevens rapporteren, kunnen we de sectie met voorbeelden van foutopsporing in de ClearML-webapp bekijken en zorg ervoor dat de gegevens die in het model worden ingevoerd, logisch zijn. We kunnen naar de originele audiosignalen luisteren of de spectrogrammen bekijken:
Momentopnamen van de foutopsporingsrapporten van de Mel-spectrogrammen
Momentopnamen van de voorbeelden van audiofoutopsporing
Samenvatting
Automatische audioclassificatie is een groeiend onderzoeksgebied dat velden omvat zoals spraak, muziek en omgevingsgeluiden. Dit groeiende veld kan enorm profiteren van de rijke ervaring en verschillende tools die zijn ontwikkeld voor computervisietaken. Als zodanig kan het gebruik van de open source-tools van het PyTorch-ecosysteem uw machine learning-project voor audioclassificatie een boost geven. U kunt niet alleen genieten van een reeks gratis open source productiviteitstools, u kunt ook gebruikmaken van de robuuste en beproefde reeks vooraf getrainde computervisiemodellen, door uw signalen te transformeren van het tijdsdomein naar het frequentiedomein.
In deze tutorial hebben we het gebruik van Tochaudio, Torchvision en ClearML gedemonstreerd voor een eenvoudige en effectieve audioclassificatietaak. Zonder integratie-inspanningen en zonder kosten, krijgt u een veelzijdig trainings- en evaluatiescript. Raadpleeg voor meer informatie de ClearML-documentatie, torchaudio-documentatie en torchvision-documentatie.
Dan Malowany
Hoofd Deep Learning Research, Allegro AI (ClearML)
