Dit artikel is gepubliceerd als onderdeel van het Data Science-blogathon.

In dit artikel zullen we kennis opdoen over het werken met audiodata. We zullen audiogegevens gebruiken om een ​​zeer kritisch en reëel probleem op te lossen. Laten we, voordat we dieper ingaan, opsommen wat er in dit artikel wordt behandeld.

• Wat is een audiosignaal?
• Basisprincipes van audiogegevens en audiosignalen
  • Amplitude
  • Cyclus
  • Frequentie
• Soorten audiosignalen
  • Digital
  • Analoog
• Analoog naar digitaal conversie
• Manieren om het audiosignaal weer te geven
  • Tijd domein
  • Spectrogram
• Het audioclassificatieprobleem begrijpen
  • Probleemstelling
  • Oplossingsaanpak:
• Data voorbereiding
• Audioclassificatie met behulp van Time Domain-functies
• Audioclassificatie met behulp van Spectrogram-functies
• Conclusie
• Over de auteur

Laten we beginnen…

Wat is een audiosignaal?

Elk object dat trilt, produceert een geluidsgolf.

Bijvoorbeeld: - Een stemvork produceert een karakteristiek geluid wanneer deze trilt. Deze trillingen hebben geluid, dus wanneer een object trilt, oscilleren de luchtmoleculen heen en weer vanuit hun rustpositie en vertalen hun energie naar de naburige moleculen. Dit resulteert in energietransmissie van het ene molecuul naar het andere, waardoor een geluidsgolf wordt geproduceerd.

Een audiosignaal is dus niets anders dan de weergave van een geluidsgolf, en een audiosignaal heeft een paar kritische parameters. Het is essentieel om een ​​basiskennis van deze parameters te hebben om ons te helpen ons model te bouwen en de p . op te lossen

Parameters van een audiosignaal

1) Amplitude:-

2) Cyclus:-

Audiogolven reizen in cycli. Een cyclus is een opwaartse en neerwaartse golfbeweging rond zijn hoofdpositie.

Bron:- https://courses.analyticsvidhya.com/courses/take/fundamentals-of-deep-learning/lessons/11373581-introduction-to-audio-data

3) Frequentie:-

Dit verwijst naar hoe snel een signaal gedurende een bepaalde tijd verandert.

Met andere woorden, het kan worden gedefinieerd als het aantal cycli per seconde, zoals weergegeven in deze afbeelding.

Het eerste signaal is een voorbeeld van hoge frequentie, terwijl het tweede signaal een voorbeeld is van lage frequentie.

Bron: https://courses.analyticsvidhya.com/courses/take/fundamentals-of-deep-learning/lessons/11373581-introduction-to-audio-data

Laten we nu verschillende soorten audiosignalen bespreken.

Soorten audiosignalen

Er zijn grofweg twee verschillende soorten signalen, in ons dagelijks leven,

• Digital

• Analoog.

1) Digitaal signaal: -

Een digitaal signaal is een discrete weergave van een signaal over een bepaalde tijd. Hier bestaat een eindig aantal waarden tussen twee opeenvolgende tijdinstanties.

                                           Bron:- Auteur

In deze afbeelding is er bijvoorbeeld maar één waarde die dit signaal op dit moment kan hebben, nul of één. Je kunt ook zeggen dat het een discrete golf is die informatie in binaire vorm draagt.

2) Analoog Signaal:-

Een analoog signaal is een continue golf die in de loop van de tijd verandert. In een analoog signaal bestaat een oneindig aantal monsters tussen twee opeenvolgende tijdsinstanties. Om analoge signalen te kunnen bewerken en verwerken, moeten we deze omzetten naar digitale signalen. Laten we eens kijken hoe het wordt gedaan.

                                 Bron:- Auteur

 Analoog naar digitaal conversie

Dit kan met behulp van steekproeven.

1) Bemonstering

Bron:- https://courses.analyticsvidhya.com/courses/take/fundamentals-of-deep-learning/lessons/11373581-introduction-to-audio-data

In deze afbeelding is de blauwe golf een analoog signaal en deze rode cirkels zijn typepunten die zijn gesampled uit deze curve.

Bij bemonstering wordt na een vast tijdsinterval de waarde van het analoge signaal gemeten en met behulp van een drempelwaarde omgezet in digitaal signaal. Dit bemonsterde signaal kan later worden gebruikt om het oorspronkelijke continue signaal te reconstrueren.

2) Bemonsteringsfrequentie:

Het gemiddelde aantal samples dat in één seconde wordt vastgelegd, wordt de samplefrequentie genoemd, hoe hoger de samplefrequentie, hoe beter de geluidskwaliteit.

Bron: https://musictech.com/guides/essential-guide/science-of-signal-sampling/

Een hoge bemonsteringsfrequentie gaat echter ten koste van meer geheugenruimte.

Even ter informatie aan de telefoon: de samplefrequentie is 8000 samples per seconde of 8000 hertz.

Laten we nu verder gaan met de weergave van het audiosignaal.

Manieren om het audiosignaal weer te geven

1) Tijdsdomein

In het tijdsdomein wordt het audiosignaal weergegeven door de amplitude als functie van de tijd. Het betekent dat de amplitude met verschillende tijdsintervallen wordt geregistreerd.

In eenvoudige bewoordingen is het een 2D-plot tussen amplitude en tijd. De X-as vertegenwoordigt de tijd en de Y-as vertegenwoordigt de amplitude. De onbewerkte audio is al beschikbaar in het tijdsdomein, dus we kunnen het direct verwerken en ermee aan de slag gaan.

2) Spectrogram

Het tweede type weergave van audiogegevens is het spectrogram. Het is een 2D-plot tussen tijd en frequentie. Elk punt in de plot vertegenwoordigt ook de amplitude van een bepaalde frequentie op een bepaald moment in termen van intensiteitskleuren. In eenvoudige bewoordingen is het spectrogram een ​​spectrum van frequenties omdat het met de tijd varieert. De X-as vertegenwoordigt de tijd, terwijl de Y-as de frequentie vertegenwoordigt en de waarde op een bepaald punt de amplitude van die frequentie op dat specifieke tijdstip. De lage intensiteit vertegenwoordigt een lagere amplitude en vice versa. Dus we zullen de audiogegevens eerst naar een spectrogram converteren en het spectrogram doorgeven als invoer voor het model.

Bron: https://courses.analyticsvidhya.com/courses/take/fundamentals-of-deep-learning/lessons/11373581-introduction-to-audio-data

In de volgende sectie zullen we het probleem begrijpen en hoe het kan worden opgelost met behulp van deep learning.

Het probleem van audioclassificatie begrijpen

Probleemstelling:- Volgens het National Crime Records Bureau sterven elke dag bijna 24000 mensen als gevolg van een vertraging bij het verkrijgen van medische hulp. Elk slachtoffer van een ongeval wacht op hulp ter plaatse en een vertraging bij het bereiken van de bestemming kost hen het leven. Een van de grootste redenen voor deze vertraging is het vast komen te zitten in een file.

Oplossingsaanpak:

Het creëren van een automatisch detectiesysteem voor voertuigen van hulpdiensten, dat de voertuigen van de hulpdiensten op voldoende afstand detecteert en de verkeerslichten dienovereenkomstig aanpast.

Doelstelling:-

Vanuit het perspectief van datawetenschap kan het worden opgelost als een audioclassificatieprobleem. We zullen een model bouwen dat onderscheid kan maken tussen het geluid van de sirenes, de voertuigen van de hulpdiensten en het geluid van de andere voertuigen.

Bron: https://courses.analyticsvidhya.com/courses/take/fundamentals-of-deep-learning/lessons/11373593-understanding-the-audio-classification-problem

In dit volgende gedeelte zullen we de code doornemen en de audiogegevens verkennen en voorbewerken.

Data voorbereiding

#Audio Processing Bibliotheken importeren librosa van scipy importsignaal #Voor afspelen van audio importeer IPython.display als ipd #Array Processing importeer numpy als np #Gegevensvisualisatie importeer matplotlib.pyplot als plt

Hier in deze sectie zullen we de bovengenoemde bibliotheken gebruiken om audiofuncties te creëren. We zullen het Ipython-scherm gebruiken om een ​​paar voorbeeldaudioclips af te spelen. e zal gebruiken numpy voor arrayverwerking en matplotlib voor datavisualisatie. Nu ik op de datawetenschap kom, zal ik de dataset ophalen uit het bestand audio.zip, de gegevens waarmee we zullen werken. U kunt het downloaden via de link onder deze link.

Dataset-link:- https://drive.google.com/file/d/14ZCIdME9M1CN7Bu7MAbZ5qY9X0HWr0nC/view

Het bevat twee bestanden, één het geluid van het hulpverleningsvoertuig en het andere niet-hulpvoertuiggeluid. deze twee bestanden bevatten meerdere audioclips, opgenomen op verschillende plaatsen. We zullen deze audioclips laden met behulp van de laadfunctie van bibliotheek.

path='audio/emergency.wav' emergency,sample_rate = librosa.load(path, sr = 16000) path='audio/non emergency.wav' non_emergency,sample_rate= librosa.load(path, sr =16000)

Deze parameter sr is de bemonsteringssnelheid, het aantal monsters per seconde. We hebben een bemonsteringsfrequentie van 16000 gebruikt om deze twee audioclips te lezen en de duur van deze audioclips is ongeveer 23 minuten en 27 minuten. Kortom, we bereiden een dataset van audio-chunks voor om een ​​deep learning-model te trainen om audioclassificatie uit te voeren.

duration1 = librosa.get_duration(emergency,sr=16000) duration2 = librosa.get_duration(non_emergency,sr=16000) print("Duur van een noodgeval en niet-noodgeval (in min):",duration1/60,duration2/60)

Gegevens voorbereiden

Ik zal je laten zien hoe we deze brokken gaan bereiden. Laten we aannemen dat we aan deze audioclip werken. Elke cel hier is één seconde audio, deze audioclip heeft zeven cellen, dus het is een cel van zeven seconden. Het is dus zeven seconden aan audiogegevens.

                                             Bron: auteur

Nu zullen we deze audioclip opsplitsen in audioblokken van elk twee seconden. Dit is het eerste audioblok. Om de andere chunk te extraheren, zullen we het venster één stap naar de tweede tijdstempel schuiven, zoals deze.

                                                        Bron: auteur

Dus van een audiosequentie van zeven seconden, krijgen we maar liefst zes sequenties met een lengte van elk twee seconden.

                                     Bron: auteur

Om nu dezelfde taak uit te voeren, hebben we een paar regels code om gegevens voor te bereiden.

Het splitst de audioclips in audioblokken van twee seconden of 32000 samples. Dus je kunt hier zien dat deze functie hem drie argumenten geeft. De audiogegevens die een array zijn, zijn het aantal samples dat is ingesteld op 32000 en de samplefrequentie die is ingesteld op 16000.

De onderstaande code bereidt de vereiste audio-chunks voor zoals hierboven vermeld. Bij elke iteratie gebruiken we offset om de begin- en eindposities van de chunk in te stellen.

def prepare_data(samples, num_of_samples=32000, num_of_common=16000): data=[] for offset in range(0, len(samples), num_of_common): start = offset end = offset + num_of_samples chunk = samples[start:end] if (len(chunk)==32000): data.append(chunk) retourneer gegevens

Eindelijk, deze lijst met de naam gegevens zou alle geëxtraheerde monsters bevatten. We zullen de bovenstaande functie gebruiken om afzonderlijke sets audiokanalen voor te bereiden, één voor voertuigen van hulpdiensten en de andere voor niet-hulpverleningsvoertuigen.

emergency = prepare_data(noodgeval) non_emergency = prepare_data(non_emergency)

Dus zoals je hier kunt zien, hebben we meer dan 1300 audioblokken voor hulpdiensten en ongeveer 1600 audioblokken voor niet-noodvoertuigen.

print("Aantal Chunks of Emergency en Non Emergency:",len(emergency),len(non_emergency))

Laten we een paar van deze brokken visualiseren.

De audiogegevens visualiseren

Hier gebruiken we matplotlib om audioblok één te plotten voor elk van de hulpverleningsvoertuigen en niet-hulpvoertuigen.

plt.figure(figsize=(14,4)) plt.plot(np.linspace(0, 2, num=32000),emergency[103]) plt.title('Emergency') plt.xlabel('Time') plt.ylabel('Amplitude') plt.figure(figsize=(14,4)) plt.plot(np.linspace(0, 2, num=32000),non_emergency[102]) plt.title('Non Emergency' ) plt.xlabel('Tijd') plt.ylabel('Amplitude')

                                      Bron: auteur

Het eerste perceel is voor hulpverleningsvoertuigen en het tweede perceel is voor niet-hulpverleningsvoertuigen. Nu gaan we van deze audio-brokken de trainings- en validatiegegevens voorbereiden. We zullen de audio-chunks van hulpdiensten behandelen als één klasse en de audio-chunks van niet-noodvoertuigen als de andere klasse. Het wordt dus een binair classificatieprobleem.

De eerste stap hier is om ze te combineren in twee categorieën audio-chunks en labels van deze brokken nul toe te wijzen voor brokken van hulpdiensten en één voor de brokken van niet-noodvoertuigen.

audio = np.concatenate([emergency,non_emergency]) labels1 = np.zeros(len(nood)) labels2 = np.ones(len(non_emergency)) labels = np.concatenate([labels1,labels2]) print(audio. vorm geven aan)

De vorm van de gecombineerde gegevens is 3002 brokken, met 32000 afmetingen.

Nu gaan we de gegevens opsplitsen in trainings- en validatiesets.

van sklearn.model_selection import train_test_split x_tr, x_val, y_tr, y_val = train_test_split(np.array(audio),np.array(labels), stratify=labels,test_size = 0.1, random_state=777,shuffle=True)

Deze twee arrays, x_tr en x_val zijn tweedimensionale arrays. De eerste dimensie is het aantal brokken en de tweede dimensie is het aantal monsters dat 32000 is.

Zoals we weten, heeft een sequentiemodel drie dimensies, namelijk het aantal voorbeelden of chunks, het aantal tijdstappen en de derde dimensie is de lengte van de features. Deze derde dimensie is vanaf nu niet aanwezig in onze reeks. Dus in deze codecel hervormen we de tweedimensionale arrays in driedimensionale arrays en in de derde dimensie hebben we het op één gezet.

x_tr_features = x_tr.reshape(len(x_tr),-1,1) x_val_features = x_val.reshape(len(x_val),-1,1) print("Reshaped Array Size",x_tr_features.shape)

En als je nu de vorm van de resulterende array controleert, heeft deze drie dimensies.

Dus in deze sectie hebben we een paar stappen voltooid, zoals: -

1. Hoe audiogegevens te laden,

2. Hoe het te visualiseren.

3. Hoe het in stukjes te breken?

4. En tot slot hoe u trainings- en validatiesets voorbereidt.

Dus nu zijn we klaar met onze gegevens en kunnen we deze gebruiken om een ​​deep learning-model te trainen.

Laten we eens kijken hoe het wordt gedaan, in de volgende sectie.

https://drive.google.com/file/d/14ZCIdME9M1CN7Bu7MAbZ5qY9X0HWr0nC/view

Audioclassificatie met behulp van tijddomeinfuncties

In dit vorige gedeelte hebben we twee audioclips geladen voor nood- en niet-noodopnames en deze vervolgens opgesplitst in audio-brokken. Nu zullen we deze audio-brokken gebruiken om diepgaand leren van de classificatiemodellen te trainen.

Laten we eens kijken naar de architectuur die we gaan gebruiken. Merk op dat we hier de functionele API van Keras gaan gebruiken. In deze architectuur gebruiken we twee sets convolutionele en max-poollagen.

Modelbouw met CNN

Merk op dat we eendimensionale convolutionele lagen of Conv1D gebruiken omdat we willen dat de filters alleen eendimensionaal bewegen. Het aantal filters in de eerste Conv1D-laag is 8 en de hoogte van de filters is 13. het aantal filters in de tweede Conv1D-laag is 16 en de hoogte van het filter is 11. komt dan naar beneden in de GLobal max-pool-laag , waarmee de tweedimensionale array-uitvoer van de vorige laag wordt geconverteerd. De eendimensionale uitvoer wordt naar één dichte laag gevoerd, zoals u hier kunt zien. Ten slotte maakt de laatste laag de voorspelling.

Deze hele architectuur zit in een functie zodat je deze architectuur meerdere keren kunt gebruiken zonder hem steeds opnieuw te moeten definiëren, en deze functie retourneert twee items, het model zelf en de opgeslagen modelgewichten.

van keras.layers import * van keras.models import * van keras.callbacks import * van keras import backend als K def cnn(x_tr): K.clear_session() inputs = Input(shape=(x_tr.shape[1],x_tr .shape[2])) #Eerste Conv1D-laag conv = Conv1D (8, 13, padding='same', activation='relu')(inputs) conv = Dropout(0.3)(conv) conv = MaxPooling1D(2)( conv) #Second Conv1D laag conv = Conv1D (16, 11, padding='same', activation='relu')(conv) conv = Dropout(0.3)(conv) conv = MaxPooling1D(2)(conv) #MaxPooling 1D conv = GlobalMaxPool1D()(conv) #Dense Layer conv = Dichte (16, activatie='relu')(conv) outputs = Dichte(1,activation='sigmoid')(conv) model = Model(inputs, outputs) model .compile(loss='binary_crossentropy',optimizer='adam',metrics=['acc']) model_checkpoint = ModelCheckpoint('best_model.hdf5', monitor='val_acc', verbose=1, save_best_only=True, mode=' max') retourmodel, model_checkpoint-model, model_checkpoint = cnn(x_tr_features)

Als u geïnteresseerd bent in de vorm van de uitgangen op elke laag van ons model, dan kunt u deze hier in de samenvatting bekijken.

Model Samenvatting()

En dan trainen we het model. Merk op dat we hier nauwkeurigheid gebruiken als evaluatiemaatstaf, aangezien beide klassen min of meer dezelfde verhouding hebben.

history=model.fit(x_tr_features, y_tr ,epochs=10, callbacks=[model_checkpoint], batch_size=32, validation_data=(x_val_features,y_val))

model.load_weights('best_model.hdf5')

Hier hebben we een plot van modelprestaties in termen van verliesvermindering. Zoals je hier ziet, bleef het validatieverlies tot het tijdperk afnemen.

#samenvatting van de geschiedenis voor verlies

plt.plot(geschiedenis.geschiedenis['verlies'])

plt.plot(geschiedenis.geschiedenis['val_loss'])

plt.title('Modelverlies')

plt.xlabel('Tijd')

plt.ylabel('tijdperk')

plt.legend(['train','validatie'],loc = 'linksboven')

plt.show ()

                                      Bron: auteur

En de algehele nauwkeurigheid van dit model op de validatiegegevens is meer dan 88%.

_, acc = model.evaluate(x_val_features,y_val) print("Validatienauwkeurigheid:",acc)

Laten we nu eens kijken hoe we dit model kunnen gebruiken om inkomende audio te classificeren als een noodopnamegeluid of een niet-noodopnamegeluid. o hier is een audio-invoer naar het model, en de modelvoorspelling is niet-noodgevallen, wat de juiste voorspelling is.

ind=35 test_audio = x_val[ind] ipd.Audio(test_audio,rate=16000) feature = x_val_features[ind] prob = model.predict(feature.reshape(1,-1,1)) if (prob[0][ 0] < 0.5 ): pred='emergency' else: pred='non emergency' print("Prediction:",pred)

Maar aangezien de nauwkeurigheid van de validatieset iets meer dan 88% is, kunnen we beter doen dan dit. Laten we een ander model uitproberen. We zullen LSTM gebruiken in plaats van het CNN-model.

Modelbouw met LSTM

Laten we nogmaals kijken naar de vorm van de invoerreeksen. Het aantal samples is 32000 en als u een LSTM-laag gebruikt, betekent dit dat er voor elk kanaal 32000 stappen nodig zijn. In dat geval zou de modeltraining extreem traag zijn en zou ook de verdwijnende gradiënt een rol kunnen spelen.

Dus om dit probleem op te lossen, zullen we een eenvoudige hack gebruiken, dus zoals je hier in de vorm kunt zien, in plaats van de derde dimensies als één te behouden, kunnen we het op een hoger getal instellen, zoals 160, dus dat zal, in draai, breng de tijdstappen terug van 3200 naar slechts 200, en dan kunnen we gemakkelijk gebruiken

deze hervormde kenmerken of reeksen in ons model.

x_tr_features = x_tr.reshape(len(x_tr),-1,160) x_val_features = x_val.reshape(len(x_val),-1,160) print("Reshaped Array Size",x_tr_features.shape)

Laten we nu eens kijken naar de modelarchitectuur. Vanaf nu is er slechts één LSTM-laag in deze architectuur, maar u kunt desgewenst meer lagen toevoegen. Je kunt dit model op dezelfde manier noemen als het op CNN gebaseerde model.

def lstm(x_tr): K.clear_session() inputs = Input(shape=(x_tr.shape[1],x_tr.shape[2])) #lstm x = LSTM(128)(inputs) x = Dropout(0.3) (x) #dense x= Dichte(64,activation='relu')(x) x= Dichte(1,activation='sigmoid')(x) model = Model(inputs, x) model.compile(loss=' binary_crossentropy',optimizer='adam',metrics=['acc']) retourmodel model = lstm(x_tr_features) model.summary()

mc = ModelCheckpoint('best_model.hdf5', monitor='val_acc', verbose=1, save_best_only=True, mode='max')

En vervolgens trainen we dit model voor 10 tijdperken, voel je vrij om het aantal tijdperken te verhogen.

Het is gewoon een hyperpiramide.

history=model.fit(x_tr_features, y_tr, epochs=10, callbacks=[mc], batch_size=32, validation_data=(x_val_features,y_val))

model.load_weights('best_model.hdf5')

In deze epoch versus loss plot is het moment van verlies vrij ongelijk voor zowel de validatie als de treinset.

#summarize history for loss plt.plot(history.history['loss']) plt.plot(history.history['val_loss']) plt.title('Model loss') plt.xlabel('Time') plt. ylabel('epoch') plt.legend(['train','validatie'],loc = 'linksboven') plt.show()

                                        Bron: auteur

Als je kijkt naar de prestatie op de validatieset is het gewoon 0.89, wat iets beter is dan wat we met het vorige model kregen.

_,acc = model.evaluate(x_val_features,y_val) print("Nauwkeurigheid:",acc)

Na het modelverlies voor CNN en LSTM te hebben waargenomen, zou ik nog steeds voor het op CNN gebaseerde model gaan in plaats van LSTM, hoewel de prestaties van LSTM beter zijn dan CNN, omdat het verlies daar geleidelijk en soepel afneemt bij CNN en hier is het onvoorspelbaar.

Dus in deze sectie hebben we een degelijk classificatiemodel gebouwd met behulp van twee verschillende soorten deep learning-modellen, de ene was gebaseerd op CNN en de andere was gebaseerd op LSTM. We hebben ook de invoerarrays opnieuw vormgegeven, rekening houdend met de beperkingen van de LSTM. De functies die we hier in beide modellen hebben gebruikt, zijn de tijddomeinfuncties.

De volgende sectie zal werken met de spectrogramfunctie en kijken of dat enige verbetering in de prestaties oplevert of niet.

Audioclassificatie met behulp van tijdspectrogramfuncties

Laten we een functie definiëren die het spectrogram berekent. Daarvoor moeten we begrijpen hoe het spectrogram wordt berekend.

Spectrogram berekend

Spectrogram accepteert de onbewerkte audiogolf en verdeelt deze vervolgens in brokken of vensters en past vervolgens snelle Fourier-transformatie (FFT) toe op elk venster om de frequenties te berekenen.

Komende tot de parameters voor het berekenen van spectrogram:

In de vorige sectie hebben we twee classificatiemodellen gebouwd, de ene was gebaseerd op CNN en de andere was gebaseerd op LSTM.

We gebruikten de tijddomeinfunctie in beide modellen en we kregen de beste nauwkeurigheid in het bereik van 88 tot 89%.

Nu gaan we werken met spectrogrammen van audio en we zullen zien hoe ze worden gebruikt als functies om deep learning-modellen te trainen.

In deze sectie gebruiken we de signaal module vanaf scipy, om een ​​spectrogram te berekenen voor een bepaald audioblok.

Deze functie pittig. ignal.spectrogram geeft drie arrays terug. De eerste reeks is de reeksfrequenties en de tweede reeks segmenttijden. Deze twee arrays hebben op dit moment niet veel nut voor ons, maar deze derde array 'spec' is belangrijk voor ons. Dit stelt het spectrogram voor.

Merk op dat we de log van het spectrogram retourneren, omdat de waarden in het spectrogram, die amplitudewaarden zijn, extreem klein kunnen zijn op de schaal van 10 tot de macht min acht, en het is moeilijk om zulke kleine waarden te onderscheiden. Daarom nemen we het logboek van het spectrogram.

def log_specgram(audio, sample_rate, eps=1e-10): nperseg = 320 noverlap = 160 freqs, times, spec = signal.spectrogram(audio,fs=sample_rate, nperseg=nperseg,noverlap=noverlap,detrend=False) return freqs , tijden, np.log(spec.T.astype(np.float32) + eps)

Het spectrogram visualiseren

U kunt ook een Librosa-bibliotheek gebruiken om spectrogramfuncties voor te bereiden.

Laten we eens kijken hoe deze spectrogrammen eruit zien. dit is de functie die we zullen gebruiken om de spectrogrammen te visualiseren. zijn functie heeft twee argumenten. Het eerste argument is het 'SPECTROGRAM' en het tweede argument is het 'label', dat ofwel 'noodgeval' of 'niet-noodgeval' is. In dit spectrogram van hulpverleningsvoertuigen zien we enkele onderscheidende lijnen. Misschien zijn deze te wijten aan het geluid van de sirene, terwijl er geen dergelijk patroon is in het spectrogram van een niet-noodvoertuig.

def plot(spectrogram,label): fig = plt.figure(figsize=(14, 8)) ax = fig.add_subplot(211) ax.imshow(spectrogram.T, aspect='auto', origin='lower', extent=[times.min(), times.max(), freqs.min(), freqs.max()]) ax.set_title('Spectrogram van '+label) ax.set_ylabel('Freqs in Hz') ax .set_xlabel('Seconden')

De functie aanroepen om het spectrogram te berekenen en te visualiseren:

freqs, times, spectrogram = log_specgram(noodgeval[300], sample_rate) plot(spectrogram,"noodgeval") freqs, times, spectrogram = log_specgram(non_emergency[300], sample_rate) plot(spectrogram,"niet noodgeval")

                Bron: auteur

De vorm van het spectrogram:

spectrogram.vorm

Extraheer de spectrogramfuncties

Nu zal de onderstaande functie worden gebruikt om spectrogramkenmerken te extraheren uit dezelfde audioblokken die we hebben voorbereid toen we met de tijddomeinfuncties werkten.

def extract_spectrogram_features(x_tr): features=[] for i in x_tr: _, _, spectrogram = log_specgram(i, sample_rate) mean = np.mean(spectrogram, axis=0) std = np.std(spectrogram, axis=0 ) spectrogram = (spectrogram - gemiddelde) / std features.append(spectrogram) return np.array(features)

We zullen deze functie hier aanroepen om de functies voor zowel de trainingsset als de validatieset te krijgen.

x_tr_features = extract_spectrogram_features(x_tr) x_val_features = extract_spectrogram_features(x_val)

Modelbouw met LSTM

Nu we bij het model komen, gebruiken we opnieuw dezelfde LSTM-architectuur en hoeven we de architectuur hier niet opnieuw te definiëren.

We kunnen dezelfde functie gewoon 'LSTM_model' noemen en dat is het dan.

model, mc = lstm(x_tr_features) model.summary()

Dan trainen we het model met de spectrogramkenmerken, en als je op het laatste moment kijkt, is het nog steeds ongelijk.

history=model.fit(x_tr_features, y_tr, epochs=10, callbacks=[mc], batch_size=32, validation_data=(x_val_features,y_val))

Maar niet zoveel als het was met de tijddomeinfuncties. en de prestaties van het model op de validatieset zijn uitstekend.

model.load_weights('best_model.hdf5') _,acc = model.evaluate(x_val_features,y_val) print("Nauwkeurigheid:",ACC)

Het heeft een nauwkeurigheid van meer dan 94%. o het doorzoeken van spectrogramfuncties levert een aantal significante prestatieverbeteringen op.

Modelbouw met CNN

Laten we eens kijken hoe deze functies presteren met een op CNN gebaseerd model. e zal gewoon dezelfde op CNN gebaseerde modelarchitectuur gebruiken en we zullen de functie 'conv_model' gebruiken en we zijn klaar om te gaan.

model, mc = conv1d(x_tr_features) model.summary()

Het is ook getraind voor 10 tijdperken. We houden alle hyperparameters hetzelfde voor alle modellen, zodat de modelvergelijking eerlijk blijft. En als je op het laatste moment kijkt, is het redelijk constant en wordt het geleidelijk aan minder.

history=model.fit(x_tr_features, y_tr, epochs=10, callbacks=[mc], batch_size=32, validation_data=(x_val_features,y_val))

model.load_weights('best_model.hdf5') _,acc = model.evaluate(x_val_features,y_val) print("Nauwkeurigheid:",acc)

Op de validatieset presteerde het niet beter dan het vorige LSTM-model, maar het heeft geweldig werk geleverd door een nauwkeurigheid van meer dan 96% te behalen.

De spectrogramfuncties spelen een grote rol bij het oplossen van deze audioclassificatietaak en bij het proberen de prestaties van het model te verbeteren.

Er zijn veel dingen die je kunt doen. Met behulp van de functie API van Keras kunt u verschillende modelarchitecturen uitproberen. U kunt verschillende soorten functies gebruiken, zoals frequentiedomeinfuncties, en u kunt ook proberen de lengte van de invoerreeks te wijzigen, wat een prestatieverbetering zou kunnen geven.

Conclusie

Over de auteur

Hallo, ik ben Kajal Kumari. heb mijn master van IIT (ISM) Dhanbad in Computer Science & Engineering afgerond. Sinds kort werk ik als Machine Learning Engineer in Hyderabad. Je kunt ook een paar andere blogs bekijken die ik heb geschreven hier.

De in dit artikel getoonde media zijn geen eigendom van Analytics Vidhya en worden naar goeddunken van de auteur gebruikt. 

Verwant

• Coinsmart. Europa's beste Bitcoin- en crypto-uitwisseling.
• Platoblockchain. Web3 Metaverse Intelligentie. Kennis versterkt. GRATIS TOEGANG.
• CryptoHawk. Altcoin-radar. Gratis proefversie.
• Bron: https://www.analyticsvidhya.com/blog/2022/01/vehicle-sound-classification-using-deep-learning/