[PYTHON] Vorhersagen von Tags durch Extrahieren von Musikfunktionen mit Deep Learning

Motivation

Es scheint, dass die konventionelle Musikempfehlungstechnologie häufig kooperative Filterung verwendet, aber kooperative Filterung hat den Nachteil, dass sie keine Werke verarbeiten kann, die "keine Benutzerbewertungen sammeln", wie kleinere Songs und neue Songs.

Ein anderer Ansatz zur Musikempfehlungstechnologie, die Methode, "Musikmerkmale zu extrahieren und in Empfehlungen zu verwenden", scheint in der Lage zu sein, die oben genannten Probleme zu vermeiden.

Als ich versuchte, mit dem Artikel "End-to-End-Lernen für Musik-Audio" [^ 1] zu lernen, konnte ich den Quellcode nicht finden. Deshalb habe ich ihn selbst reproduziert und gesagt: "Extrahieren Sie den Musikfeature-Betrag mit Deep Learning und markieren Sie ihn. Ich beschloss, die Aufgabe des "Vorhersagen" zu übernehmen. (Bitte beachten Sie, dass einige Arbeiten geändert wurden und es sich nicht um eine vollständige Reproduktion handelt.)

Ich konnte nicht viele Artikel über die Verarbeitung von Musik mit Python und Deep Learning finden, also hoffe ich, dass es hilft.

Einen Datensatz erhalten

Verwenden Sie den MagnaTagATune-Datensatz [^ 2]. Jedes Lied hat 29 Sekunden Musik, 25863 Lieder und 188 Tags.

#MP3-Daten abrufen
$ wget http://mi.soi.city.ac.uk/datasets/magnatagatune/mp3.zip.001
$ wget http://mi.soi.city.ac.uk/datasets/magnatagatune/mp3.zip.002
$ wget http://mi.soi.city.ac.uk/datasets/magnatagatune/mp3.zip.003

#Konsolidieren und entpacken Sie geteilte Zip-Dateien
$ cat mp3.zip* > ~/music.zip
$ unzip music.zip

#Tag-Daten abrufen
$ wget http://mi.soi.city.ac.uk/datasets/magnatagatune/annotations_final.csv

Ermöglichen Sie die Verarbeitung von MP3 durch Numpy

Installieren Sie pydub

Die Sprachfunktionen, die normalerweise bei der Spracherkennung und beim MIR (Musikinformationsabruf) verwendet werden, sind das Mel-Frequenz-Kepstram, nachdem die Merkmalsextraktion auf RAW-Daten angewendet wurde. In diesem Dokument werden RAW-Daten jedoch so wie sie sind als Audiofunktion verwendet. Wie das Bild ist es sehr gefühlvoll, die Rohdaten in Deep Learning zu integrieren und die Funktionen automatisch zu extrahieren.

Ich habe ein Paket namens pydub verwendet, um MP3 in RAW zu konvertieren. Sie benötigen auch libav oder ffmpeg (das das Audio zu codieren und zu decodieren scheint). Weitere Informationen finden Sie unter Official Github.

$ pip install pydub

#Für Mac
$ brew install libav --with-libvorbis --with-sdl --with-theora

#Für Linux
$ apt-get install libav-tools libavcodec-extra-53

Außerdem funktionierte die offizielle Methode in meiner Ubuntu-Umgebung nicht, sodass ich auf [diesen Artikel] verwies (http://qiita.com/yayugu/items/d7f6a15a6f988064f51c).

Dateien importieren und nach ndarray konvertieren

Definieren wir die folgende Funktion, die ein ndarray mit dem Pfad der MP3-Datei als Argument erstellt.

import numpy as np
from pydub import AudioSegment

def mp3_to_array(file):
    
    #Konvertieren Sie von MP3 nach RAW
    song = AudioSegment.from_mp3(file)
    
    #Konvertierung von RAW in Bytestring-Typ
    song_data = song._data
    
    #Konvertierung von bytestring zu Numpy Array
    song_arr = np.fromstring(song_data, np.int16)
    
    return song_arr

Datensatzvorbereitung

Vorbereitung des Songtags (y)

Lesen wir die zuvor heruntergeladenen Tag-Daten. Beachten Sie auch die folgenden zwei Punkte.

• Begrenzung der Tags auf 50 häufig verwendete Tags
• Auf 3000 Samples begrenzt, da der Speicher nicht überlebt wird

import pandas as pd

tags_df = pd.read_csv('annotations_final.csv', delim_whitespace=True)
tags_df = tags_df.sample(frac=1)
tags_df = tags_df[:3000]

top50_tags = tags_df.iloc[:, 1:189].sum().sort_values(ascending=False).index[:50].tolist()
y =  tags_df[top50_tags].values

Vorbereitung von RAW-Daten (X)

--Verwenden Sie tags_df, da es den Pfad zur MP3-Datei enthält. --X wird in [Samples (Anzahl der Songs), Features, Kanal (diesmal 1)] umgeformt.

• Da RAW-Daten 16 kHz groß sind, haben sie 16000 Funktionen pro Sekunde und 465984 Funktionen in etwa 30 Sekunden. ――In der Originalarbeit wurde die Tonquelle für das Training in 3 Sekunden unterteilt. Da dies jedoch problematisch ist, werde ich sie in 30 Sekunden festhalten.

files = tags_df.mp3_path.values
X = np.array([ mp3_to_array(file) for file in files ])
X = X.reshape(X.shape[0], X.shape[1], 1)

Vorbereitung von Trainingsdaten und Testdaten

from sklearn.model_selection import train_test_split
random_state = 42

train_X, test_X, train_y, test_y = train_test_split(X, y, test_size=0.2, random_state=random_state)

Lernen & Testen (7/9 Revision)

Modellbau

Ich habe versucht, Keras zu verwenden. Im Gegensatz zum Originalpapier beträgt die Abmessung von x 465984, sodass wir die Schichten etwas tiefer stapeln.

import keras
from keras.models import Model
from keras.layers import Dense,  Flatten, Input
from keras.layers import Conv1D, MaxPooling1D

features = train_X.shape[1]

x_inputs = Input(shape=(features, 1), name='x_inputs') # (Anzahl der Funktionen,Anzahl der Kanäle)
x = Conv1D(128, 256, strides=256,
           padding='valid', activation='relu') (x_inputs)
x = Conv1D(32, 8, activation='relu') (x) # (Anzahl der Kanäle,Filterlänge)
x = MaxPooling1D(4) (x) #(Filterlänge)
x = Conv1D(32, 8, activation='relu') (x)
x = MaxPooling1D(4) (x)
x = Conv1D(32, 8, activation='relu') (x)
x = MaxPooling1D(4) (x)
x = Conv1D(32, 8, activation='relu') (x)
x = MaxPooling1D(4) (x)
x = Flatten() (x)
x = Dense(100, activation='relu') (x) #(Anzahl der Einheiten)
x_outputs = Dense(50, activation='sigmoid', name='x_outputs') (x)

model = Model(inputs=x_inputs, outputs=x_outputs)
model.compile(optimizer='adam',
              loss='categorical_crossentropy',
              metrics=['accuracy'])
model.fit(train_X1, train_y, batch_size=600, epochs=50)

Visualisierung des Berechnungsdiagramms

'''Ausgabe an png''' 
from keras.utils.visualize_util import plot
plot(model, to_file="music_only.png ", show_shapes=True)


'''Interaktive Visualisierung'''
from IPython.display import SVG
from keras.utils.visualize_util import model_to_dot
SVG(model_to_dot(model, show_shapes=True).create(prog='dot', format='svg'))

Prüfung

In der Originalarbeit war es ungefähr AUC: 0,87, aber in diesem Experiment sind es nur 0,66. Da die Stichprobengröße weniger als 1/5 beträgt, ist sie gering. Nehmen wir jedoch an, dass es möglich war, eine gewisse Vorhersage zu treffen, indem die Roh-Audiodaten (und immer noch 30 Sekunden) so wie sie sind eingespeist wurden.

from sklearn.metrics import roc_auc_score
pred_y_x1 = model.predict(test_X1, batch_size=50)
print(roc_auc_score(test_y, pred_y_x1)) # => 0.668582599155

Zusammenfassung

• Ich konnte die Audiodatei in ndarray konvertieren.
• Ich konnte das Tag vorhersagen, indem ich eine RAW-Datei ohne Feature-Extraktion einfügte. ――Die Forschungsumgebung wird bald fertig sein, daher möchte ich die Anzahl der Proben erhöhen und ausprobieren.