Prédire les tags en extrayant des fonctionnalités musicales avec Deep Learning

motivation

Il semble que la technologie conventionnelle de recommandation musicale utilise souvent le filtrage coopératif, mais le filtrage coopératif a l'inconvénient de ne pas pouvoir gérer les œuvres qui "ne recueillent pas les évaluations des utilisateurs" telles que les chansons mineures et les nouvelles chansons.

Une autre approche de la technologie de recommandation musicale, la méthode "d'extraction de caractéristiques musicales et de leur utilisation dans les recommandations", semble pouvoir éviter les problèmes mentionnés ci-dessus.

Ainsi, lorsque j'ai essayé d'étudier en utilisant le papier «Apprentissage de bout en bout pour la musique audio» [^ 1], je n'ai pas trouvé le code source, alors je l'ai reproduit par moi-même et j'ai dit: «Extrayez la quantité de fonctionnalités musicales avec Deep Learning et étiquetez-la. J'ai décidé de faire la tâche de «prédire». (Veuillez noter que certains travaux ont été modifiés et qu'il ne s'agit pas d'une reproduction complète.)

Je n'ai pas trouvé beaucoup d'articles sur le traitement de la musique avec Python et Deep Learning, alors j'espère que cela aide.

Obtention d'un jeu de données

Utilisez l'ensemble de données MagnaTagATune [^ 2]. Chaque chanson a 29 secondes de musique, 25863 chansons et 188 balises.

#Obtention de données MP3
$ 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

#Consolider et décompresser les fichiers zip fractionnés
$ cat mp3.zip* > ~/music.zip
$ unzip music.zip

#Obtention des données de balise
$ wget http://mi.soi.city.ac.uk/datasets/magnatagatune/annotations_final.csv

Autoriser la gestion du MP3 par Numpy

Installer pydub

Les fonctionnalités vocales qui sont normalement utilisées dans la reconnaissance vocale et MIR (récupération d'informations musicales) sont le kepstram de fréquence de mél après l'application de l'extraction de fonctionnalités aux données RAW. Cependant, dans cet article, les données RAW sont utilisées telles quelles en tant que fonction audio. Comme l'image, il est émouvant de mettre les données brutes dans le Deep Learning et d'extraire automatiquement les fonctionnalités.

J'ai utilisé un package appelé pydub pour convertir MP3 en RAW. Vous avez également besoin de libav ou ffmpeg (qui semble encoder et décoder l'audio). Pour plus d'informations, accédez à Official Github

$ pip install pydub

#Pour Mac
$ brew install libav --with-libvorbis --with-sdl --with-theora

#Pour Linux
$ apt-get install libav-tools libavcodec-extra-53

De plus, la méthode officielle ne fonctionnait pas dans mon environnement ubuntu, je me suis donc référé à cet article.

Importation de fichiers et conversion vers ndarray

Définissons la fonction suivante qui crée un ndarray avec le chemin du fichier mp3 comme argument.

import numpy as np
from pydub import AudioSegment

def mp3_to_array(file):
    
    #Convertir de MP3 en RAW
    song = AudioSegment.from_mp3(file)
    
    #Conversion de RAW en type bytestring
    song_data = song._data
    
    #Conversion de bytestring en tableau Numpy
    song_arr = np.fromstring(song_data, np.int16)
    
    return song_arr

Préparation du jeu de données

Préparation de l'étiquette de chanson (y)

Lisons les données de balises téléchargées plus tôt. Veuillez également noter les deux points suivants.

• Limitation des balises à 50 balises couramment utilisées
• Limité à 3000 échantillons car il ne survit pas à la mémoire

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

Préparation des données RAW (X)

--Utilisez le tag_df car il contient le chemin du fichier mp3. --X est remodelé en [échantillons (nombre de morceaux), fonctionnalités, canal (1 cette fois)].

• Puisque les données RAW sont de 16 kHz, elles ont 16000 fonctionnalités par seconde et 465984 fonctionnalités en environ 30 secondes. ――Dans le papier d'origine, la source sonore a été divisée en 3 secondes pour l'entraînement, mais comme c'est gênant, je vais la coller dans 30 secondes.

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)

Préparation des données d'entraînement et des données de test

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)

Apprentissage et test (révision 7/9)

Construction de modèles

J'ai essayé d'utiliser Keras. Contrairement au papier original, la dimension de x est aussi longue que 465984, nous allons donc empiler les couches un peu plus profondément.

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') # (Nombre de fonctionnalités,Nombre de canaux)
x = Conv1D(128, 256, strides=256,
           padding='valid', activation='relu') (x_inputs)
x = Conv1D(32, 8, activation='relu') (x) # (Nombre de canaux,Longueur du filtre)
x = MaxPooling1D(4) (x) #(Longueur du filtre)
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) #(Nombre d'unités)
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)

Visualisation du graphe de calcul

'''Sortie au format png''' 
from keras.utils.visualize_util import plot
plot(model, to_file="music_only.png ", show_shapes=True)


'''Visualisation interactive'''
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'))

tester

Dans l'article original, il s'agissait d'environ AUC: 0,87, mais dans cette expérience, il n'est que de 0,66. La taille de l'échantillon étant inférieure à 1/5, elle sera faible, mais disons qu'il était possible de prédire dans une certaine mesure en alimentant les données audio brutes (et toujours 30 secondes) telles quelles.

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

Résumé

• J'ai pu convertir le fichier audio en ndarray.
• J'ai pu prédire la balise en insérant un fichier RAW sans extraction de fonctionnalités. ――L'environnement de recherche sera bientôt prêt, je voudrais donc augmenter le nombre d'échantillons et l'essayer.