Music Genre Classification dengan KNN

Pada artikel kali ini kita akan melakukan klasifikasi audio terkait music genre. Klasifikasi audio adalah Aplikasi pembelajaran mesin di mana suara yang berbeda dikategorikan dalam kategori tertentu. Di artikel kami sebelumnya, kami telah mempelajari klasifikasi Audio menggunakan ANN dan membuat model dari awal.

Pengantar Klasifikasi Music Genre

Pemrosesan audio adalah salah satu tugas paling kompleks dalam ilmu data dibandingkan dengan pemrosesan gambar dan teknik klasifikasi lainnya. Salah satu aplikasi tersebut adalah klasifikasi genre musik yang bertujuan untuk mengklasifikasikan file audio dalam kategori suara tertentu.

Aplikasi ini sangat penting dan membutuhkan otomatisasi untuk mengurangi kesalahan manual dan waktu karena jika kita harus mengklasifikasikan musik secara manual maka kita harus mendengarkan setiap file untuk durasi yang lengkap.

Jadi Untuk mengotomatiskan proses kami menggunakan machine learning dan algoritma deep learning. Inilah yang akan kita terapkan dalam artikel ini.

Gambaran Umum dan Pendekatan Proyek

Singkatnya, kita dapat mendefinisikan pernyataan masalah proyek kita seperti diberikan beberapa file audio, dan tugasnya adalah mengkategorikan setiap file audio dalam kategori tertentu seperti audio milik Disco, hip-hop, dll.

Klasifikasi genre musik dapat dibangun menggunakan pendekatan yang berbeda di mana 4 pendekatan teratas yang paling banyak digunakan tercantum di bawah ini.

Multiclass support vector machine
K-Nearest Neighbors
K-means clustering algorithm
Convolutional neural network

Kita akan menggunakan algoritma K-Nearest Neighbors karena berbagai penelitian membuktikan bahwa ini adalah salah satu algoritma terbaik untuk memberikan kinerja yang baik dan sampai waktu seiring dengan model yang dioptimalkan.

K-Nearest Neighbor (KNN) adalah algoritma machine learning yang digunakan untuk regresi dan klasifikasi. Ia juga dikenal sebagai lazy learner algorithm. Itu hanya menggunakan metode berbasis jarak untuk menemukan jumlah K tetangga yang mirip dengan data baru dan kelas di mana sebagian besar tetangga berada, menghasilkan kelas itu sebagai output. Sekarang mari kita siapkan sistem kita untuk implementasi proyek.

Dataset

Dataset yang akan kita gunakan diberi nama dataset kumpulan genre GTZAN yang merupakan kumpulan data kumpulan audio yang sangat populer. Ini berisi sekitar 1000 file audio yang termasuk dalam 10 kelas berbeda.

Setiap file audio dalam format .wav (ekstensi). Kelas yang dimiliki file audio adalah Blues, Hip-hop, klasik, pop, Disco, Country, Metal, Jazz, Reggae, dan Rock. Anda dapat dengan mudah menemukan kumpulan data melalui Kaggle dan dapat mengunduhnya dari sini. Jika Anda tidak memiliki banyak ruang memori, Anda dapat membuat Kaggle notebook dan mempraktikkannya di sana.

Instalasi Libraries

Sebelum kita pindah untuk memuat dataset dan pembuatan model, penting untuk menginstal library yang akan digunakan. Di artikel sebelumnya, kita telah menggunakan librosa untuk mengekstrak fitur.

Sekarang kita akan menggunakan library python speech feature untuk mengekstrak fitur dan memiliki pendekatan yang berbeda. Serta untuk memuat dataset dalam format WAV kita akan menggunakan library scipy sehingga kita perlu menginstall kedua library tersebut.

!pip install python_speech_features
!pip install scipy

Implementasi Klasifikasi Music Genre

Pertama kita buka notebook Jupyter atau notebook Kaggle yang baru dibuat. Selanjutnya adalah melakukan impor library yang diperlukan untuk melakukan klasifikasi music genre.

import numpy as np
import pandas as pd
import scipy.io.wavfile as wav
from python_speech_features import mfcc
from tempfile import TemporaryFile
import os
import math
import pickle
import random
import operator

Kemudian kita perlu menentukan fungsi untuk menghitung jarak antara vektor fitur, dan untuk menemukan tetangga. Cara kerja KNN adalah dengan menghitung jarak dan mencari jumlah K tetangga. Untuk mencapai ini hanya untuk setiap fungsionalitas, kita akan menerapkan fungsi yang berbeda.

Pertama, kita akan mengimplementasikan fungsi yang akan menerima data pelatihan, current instances, dan jumlah tetangga yang diperlukan. Ini akan menemukan jarak setiap titik dengan setiap titik lainnya dalam data pelatihan.

Setelah itu, kita menemukan semua tetangga K terdekat dan mengembalikan semua tetangga. untuk menghitung jarak dua titik kita akan mengimplementasikan fungsi setelah menjelaskan beberapa langkah untuk membuat alur kerja proyek sederhana dan mudah dipahami.

def getNeighbors(trainingset, instance, k):
    distances = []
    for x in range(len(trainingset)):
        dist = distance(trainingset[x], instance, k) + distance(instance,trainingset[x],k)
        distances.append((trainingset[x][2], dist))
    distances.sort(key=operator.itemgetter(1))
    neighbors = []
    for x in range(k):
        neighbors.append(distances[x][0])
    return neighbors

Selanjutnya, kita akan identifikasi kelas tetangga terdekat. Sekarang kita memiliki daftar tetangga dan kita perlu mencari kelas yang memiliki jumlah tetangga maksimum.

Jadi kita mendeklarasikan dictionary yang akan menyimpan kelas dan jumlah tetangganya masing-masing. Setelah membuat peta frekuensi, kita akan mengurutkan peta dalam urutan menurun berdasarkan jumlah tetangga dan mengembalikan kelas pertama.

def nearestclass(neighbors):
    classVote = {}
    
    for x in range(len(neighbors)):
        response = neighbors[x]
        if response in classVote:
            classVote[response] += 1
        else:
            classVote[response] = 1
            
    sorter = sorted(classVote.items(), key=operator.itemgetter(1), reverse=True)
    return sorter[0][0]

Kita juga memerlukan fungsi yang mengevaluasi model untuk memeriksa keakuratan dan performa algoritma yang kita bangun. Jadi kita akan membangun sebuah fungsi yang merupakan kalkulator akurasi yang cukup sederhana yang menyatakan jumlah total prediksi yang benar dibagi dengan jumlah total prediksi.

def getAccuracy(testSet, prediction):
    correct = 0
    for x in range(len(testSet)):
        if testSet[x][-1] == prediction[x]:
            correct += 1
    return 1.0 * correct / len(testSet)

Kita telah mengimplementasikan model dan selanjutnya kita akan mengekstrak fitur dari data. Jadi karena kita menggunakan KNN Classifier dan kita hanya menerapkan algoritma dari awal untuk membuat Anda memahami bagaimana proyek berjalan.

Saya harap Anda memiliki 70 persen gagasan tentang bagaimana proyek akan bekerja. Jadi sekarang kita akan memuat data dari semua 10 folder dari masing-masing kategori dan mengekstrak fitur dari setiap file audio dan menyimpan fitur yang diekstraksi dalam bentuk biner dalam format ekstensi DAT.

Mel Frequency Cepstral Coefficients

Ekstraksi fitur adalah proses untuk mengekstraksi fitur penting dari data. Ini termasuk mengidentifikasi data linguistik dan menghindari noise apa pun. Fitur audio diklasifikasikan ke dalam 3 kategori fitur audio tingkat tinggi, tingkat menengah, dan tingkat rendah.

Fitur tingkat tinggi terkait dengan lirik musik seperti chrods, ritme, melodi, dll.
Fitur tingkat menengah mencakup atribut tingkat ketukan, pola fluktuasi seperti nada dan MFCC.
Fitur tingkat rendah termasuk energi, tingkat zero-crossing yang merupakan ukuran statistik yang diekstraksi dari audio selama ekstraksi fitur.

Jadi untuk menghasilkan fitur ini kita menggunakan serangkaian langkah tertentu dan digabungkan dengan satu nama sebagai MFCC yang membantu mengekstrak fitur audio level menengah dan level rendah. di bawah ini adalah langkah-langkah yang dibahas untuk cara kerja MFCC dalam ekstraksi fitur.

File audio memiliki panjang (durasi) tertentu dalam hitungan detik atau selama dalam hitungan menit dan juga nada atau frekuensi terus berubah. Jadi untuk memahami ini pertama-tama kita membagi file audio menjadi frame kecil-kecil yang panjangnya sekitar 20 hingga 40 ms.
Setelah membagi menjadi beberapa frame, kita mencoba mengidentifikasi dan mengekstraksi frekuensi yang berbeda dari setiap frame. Ketika kita membagi dalam frame sekecil itu, anggaplah bahwa satu frame terbagi dalam satu frekuensi.
Memisahkan frekuensi linguistik dari noise.
Untuk menghilangkan semua jenis noise, gunakan discrete cosine transform (DCT) dari frekuensi. Siswa yang berasal dari latar belakang teknik mungkin mengetahui transformasi cosinus dan telah mempelajarinya dalam mata pelajaran matematika diskrit.

Sekarang kita tidak perlu mengimplementasikan semua langkah ini secara terpisah. MFCC membawa semua ini untuk kita yang telah kita impor dari library python speech feature.

Kita akan mengulangi setiap folder kategori, membaca file audio, mengekstrak fitur MFCC, dan membuangnya ke dalam file biner menggunakan modul pickle. Saya menyarankan untuk selalu menggunakan try-catch saat memuat kumpulan data besar untuk memahami dan mengontrol jika terjadi pengecualian.

directory = '../input/gtzan-dataset-music-genre-classification/Data/genres_original'
f = open("mydataset.dat", "wb")
i = 0
for folder in os.listdir(directory):
    #print(folder)
    i += 1
    if i == 11:
        break
    for file in os.listdir(directory+"/"+folder):
        #print(file)
        try:
            (rate, sig) = wav.read(directory+"/"+folder+"/"+file)
            mfcc_feat = mfcc(sig, rate, winlen = 0.020, appendEnergy=False)
            covariance = np.cov(np.matrix.transpose(mfcc_feat))
            mean_matrix = mfcc_feat.mean(0)
            feature = (mean_matrix, covariance, i)
            pickle.dump(feature, f)
        except Exception as e:
            print("Got an exception: ", e, 'in folder: ', folder, ' filename: ', file)
f.close()

Sekarang kita telah mengekstraksi fitur dari file audio yang dibuang dalam format biner sebagai nama file dari dataset. Selanjutnya, kita akan mengimplementasikan fungsi yang menerima nama file dan menyalin semua data dalam bentuk dataframe.

Setelah itu berdasarkan ambang batas tertentu, kita akan membagi data secara acak menjadi set pelatihan dan pengujian karena kita menginginkan campuran genre yang berbeda di kedua set. Ada beberapa pendekatan berbeda untuk melakukan train test split.

Di sini saya menggunakan modul acak dan menjalankan loop hingga panjang dataset dan menghasilkan angka pecahan acak antara 0-1 dan jika kurang dari 66 maka baris tertentu ditambahkan dalam train set yang lain di test set.

dataset = []

def loadDataset(filename, split, trset, teset):
    with open('my.dat','rb') as f:
        while True:
            try:
                dataset.append(pickle.load(f))
            except EOFError:
                f.close()
                break
    for x in range(len(dataset)):
        if random.random() < split:
            trset.append(dataset[x])
        else:
            teset.append(dataset[x])

trainingSet = []
testSet = []
loadDataset('my.dat', 0.68, trainingSet, testSet)

Selanjutnya, kita perlu menghitung jarak antara dua instance. Fungsi ini harus kita terapkan di bagian atas untuk menghitung jarak antara dua titik tetapi untuk menjelaskan kepada Anda alur kerja proyek yang lengkap. Saya menjelaskan fungsi pendukung setelah langkah utama.

Tetapi Anda perlu menambahkan fungsi di atas. Jadi, fungsi tersebut menerima dua titik data (koordinat X dan y) untuk menghitung jarak sebenarnya di antara keduanya.

Kita menggunakan paket aljabar linier numpy yang menyediakan implementasi aljabar linier standar tingkat rendah. Jadi pertama-tama kita cari perkalian titik antara koordinat X-X dan Y-Y kedua titik untuk mengetahui jarak sebenarnya. Setelah itu, kita ekstrak determinan resultan array kedua titik tersebut dan dapatkan jaraknya.

def distance(instance1, instance2, k):
    distance = 0
    mm1 = instance1[0]
    cm1 = instance1[1]
    mm2 = instance2[0]
    cm2 = instance2[1]
    distance = np.trace(np.dot(np.linalg.inv(cm2), cm1))
    distance += (np.dot(np.dot((mm2-mm1).transpose(), np.linalg.inv(cm2)), mm2-mm1))
    distance += np.log(np.linalg.det(cm2)) - np.log(np.linalg.det(cm1))
    distance -= k
    return distance

Kemudian kita akan melatih Model dan membuat prediksi. Mungkin, Anda semua sedang menunggu untuk memasukkan data ke algoritma KNN dan membuat semua prediksi dan menerima akurasi pada dataset uji.

Kode langkah ini tampaknya besar tetapi sangat kecil karena kita mengikuti pendekatan pemrograman fungsional secara bertahap sehingga kita hanya perlu memanggil fungsi. Yang pertama adalah mendapatkan neighbors, mengekstrak kelas, dan memeriksa keakuratan model.

length = len(testSet)
predictions = []
for x in range(length):
    predictions.append(nearestclass(getNeighbors(trainingSet, testSet[x], 5)))

accuracy1 = getAccuracy(testSet, predictions)
print(accuracy1)

Langkah terakhir yaitu uji Pengklasifikasi dengan File Audio baru. Sekarang kita telah menerapkan dan melatih model, kemudian saatnya mencoba data baru untuk memeriksa seberapa akurat model kami dalam memprediksi file audio baru.

Jadi kita memiliki semua label (kelas) dalam bentuk numerik dan kita perlu memeriksa nama kelasnya terlebih dahulu. Kita akan mengimplementasikan dictionary di mana kuncinya adalah label numerik dan nilai adalah nama kategorinya.

from collections import defaultdict
results = defaultdict(int)

directory = "../input/gtzan-dataset-music-genre-classification/Data/genres_original"

i = 1
for folder in os.listdir(directory):
    results[i] = folder
    i += 1

Sekarang kita dapat memprediksi kategori musik pada file audio baru yang diinputkan.

pred = nearestclass(getNeighbors(dataset, feature, 5))
print(results[pred])

Penutup

Selamat kita telah mengimplementasikan music genre classification dengan KNN. Kita telah memulai proyek dengan pengaturan awal dan menggunakan MFCC untuk mengekstrak fitur dari file audio.