Jak nauczyć AI rozpoznawać gatunki muzyczne - przewodnik

AI potrafi napisać wiersz, wygenerować obraz i prowadzić rozmowę. Ale czy potrafi odróżnić heavy metal od disco? Okazuje się, że tak - ale musisz go tego nauczyć. I nie, nie potrzebujesz doktoratu z informatyki ani serwera za 50 tysięcy złotych.

Fine-tuning modelu do klasyfikacji muzyki to proces, w którym bierzesz gotowy model AI (wytrenowany na ogólnych danych) i dostosujesz go do konkretnego zadania - w tym przypadku rozpoznawania gatunków muzycznych. Zamiast uczyć model od zera, wykorzystujesz to, czego już się nauczył, i dodajesz mu specjalistyczną wiedzę.

W tym przewodniku pokażę Ci, jak to zrobić krok po kroku. Użyjemy lekkiego modelu transformer, który uruchomisz nawet na darmowym GPU w Google Colab. Żadnych kosztów, żadnych skomplikowanych instalacji - tylko praktyka.

Zanim zaczniesz - co musisz mieć

Dobra wiadomość: nie potrzebujesz prawie nic. Wystarczy:

• Konto Google - do uruchomienia Google Colab (darmowe GPU T4 z 16GB pamięci)
• Podstawowa znajomość Pythona - musisz wiedzieć, co to zmienna i funkcja (reszta to kopiuj-wklej)
• 2-3 godziny czasu - na przejście przez cały proces od początku do końca

Nie musisz mieć własnego GPU, nie musisz instalować niczego na swoim komputerze. Wszystko działa w przeglądarce.

Krok 1: Pobierz i przygotuj dane treningowe

Zaczniesz od zbioru danych GTZAN - popularny dataset zawierający 1000 piosenek po 30 sekund każda. Dziesięć gatunków muzycznych: od disco przez jazz po metal. Każdy utwór jest już oznaczony etykietą gatunku, więc nie musisz tego robić ręcznie.

Otwierasz Google Colab, tworzysz nowy notebook i wpisujesz:

from datasets import load_dataset

gtzan = load_dataset("marsyas/gtzan", "all")
print(gtzan)

Po uruchomieniu zobaczysz, że masz 999 przykładów (jeden z oryginalnych 1000 plików był uszkodzony i został usunięty). Dataset jest zbalansowany - każdy gatunek ma podobną liczbę utworów.

Podziel dane na treningowe i walidacyjne

GTZAN nie ma gotowego podziału na zbiór treningowy i walidacyjny, więc musisz go stworzyć sam. Użyjesz prostego podziału 90/10:

gtzan = gtzan["train"].train_test_split(seed=42, shuffle=True, test_size=0.1)
print(gtzan)

Teraz masz 899 utworów do treningu i 100 do walidacji. Seed=42 zapewnia, że za każdym razem dostaniesz ten sam podział (przydatne, jeśli będziesz chciał powtórzyć eksperyment).

Sprawdź, jak wyglądają dane

Zanim pójdziesz dalej, warto zobaczyć, z czym pracujesz:

print(gtzan["train"][0])

Zobaczysz, że każdy utwór to tablica NumPy z wartościami amplitudy. Częstotliwość próbkowania to 22 050 Hz - czyli 22 050 wartości na sekundę dźwięku. Dla 30-sekundowego utworu to ponad 660 tysięcy liczb.

Gatunek muzyczny jest zapisany jako liczba całkowita (class label) - format, w którym model będzie robił predykcje. Możesz zamienić te liczby na nazwy gatunków:

id2label_fn = gtzan["train"].features["genre"].int2str
id2label_fn(gtzan["train"][0]["genre"])

Jeśli wszystko działa, zobaczysz nazwę gatunku - na przykład "rock" lub "jazz".

Krok 2: Wybierz i załaduj model bazowy

Teraz potrzebujesz modelu, który dostosujesz do klasyfikacji muzyki. Nie będziesz trenował go od zera - użyjesz gotowego modelu, który już rozumie strukturę dźwięku.

Użyjesz DistilHuBERT - okrojona wersja modelu HuBERT, która trenuje się około 73% szybciej, zachowując większość możliwości oryginalnego modelu. Idealny kompromis między szybkością a jakością.

Załaduj model i procesor

Model potrzebuje dwóch elementów: samego modelu (który robi predykcje) i procesora (który przygotowuje dane audio do formatu zrozumiałego dla modelu):

from transformers import AutoFeatureExtractor, AutoModelForAudioClassification

model_id = "ntu-spml/distilhubert"
feature_extractor = AutoFeatureExtractor.from_pretrained(model_id)
model = AutoModelForAudioClassification.from_pretrained(model_id, num_labels=10)

Parametr num_labels=10 mówi modelowi, że ma rozróżniać 10 gatunków muzycznych. Model bazowy był trenowany na innych zadaniach, więc musisz zmienić ostatnią warstwę, żeby pasowała do Twojego problemu.

Sprawdź częstotliwość próbkowania

Model DistilHuBERT został wytrenowany na danych z częstotliwością 16 000 Hz. Twoje dane GTZAN mają 22 050 Hz. Musisz je przekonwertować, żeby model działał poprawnie:

from datasets import Audio

gtzan = gtzan.cast_column("audio", Audio(sampling_rate=16000))

Ta jedna linijka automatycznie zmieni częstotliwość próbkowania wszystkich plików audio w datasecie. Nie musisz robić tego ręcznie dla każdego pliku.

Jeśli chcesz dowiedzieć się więcej o tym, jak AI przetwarza różne typy danych, sprawdź nasz przewodnik po RAG - podobne zasady działają dla tekstu, obrazów i dźwięku.

Krok 3: Przygotuj dane do treningu

Model nie potrafi czytać surowych plików audio. Musisz przekształcić każdy utwór w format, który model rozumie - czyli tensor liczbowy.

Stwórz funkcję preprocessingu

Napiszesz funkcję, która:

1. Bierze plik audio
2. Przekształca go przez feature extractor
3. Zwraca tensor gotowy do wrzucenia do modelu

def preprocess_function(examples):
 audio_arrays = [x["array"] for x in examples["audio"]]
 inputs = feature_extractor(
 audio_arrays,
 sampling_rate=16000,
 padding=True,
 max_length=16000 * 30,
 truncation=True
 )
 return inputs

Parametr max_length=16000 * 30 ustawia maksymalną długość na 30 sekund (16 000 próbek na sekundę × 30 sekund). Krótsze utwory zostaną wypełnione zerami (padding), dłuższe - obcięte (truncation).

Zastosuj preprocessing do całego datasetu

Teraz uruchamiasz tę funkcję na wszystkich utworach:

encoded_gtzan = gtzan.map(
 preprocess_function,
 remove_columns=["audio", "file"],
 batched=True,
 batch_size=100,
 num_proc=1
)

Parametr batched=True sprawia, że funkcja przetwarza 100 utworów naraz zamiast po jednym - znacznie przyspiesza proces. remove_columns usuwa oryginalne pliki audio, bo już ich nie potrzebujesz (masz przetworzone tensory).

Ten krok może zająć kilka minut. Spokojnie możesz pójść zrobić kawę.

Krok 4: Skonfiguruj parametry treningu

Teraz musisz powiedzieć modelowi, jak ma się uczyć. Ile razy przejrzeć dane? Jak szybko aktualizować wagi? Kiedy zapisać checkpoint?

Zdefiniuj argumenty treningowe

from transformers import TrainingArguments

training_args = TrainingArguments(
 output_dir="./music_classifier",
 evaluation_strategy="epoch",
 save_strategy="epoch",
 learning_rate=5e-5,
 per_device_train_batch_size=8,
 per_device_eval_batch_size=8,
 num_train_epochs=10,
 warmup_ratio=0.1,
 logging_steps=10,
 load_best_model_at_end=True,
 metric_for_best_model="accuracy",
 push_to_hub=False,
)

Co oznaczają te parametry:

• learning_rate=5e-5 - jak szybko model uczy się (5×10⁻⁵ to dobry punkt startowy dla fine-tuningu)
• per_device_train_batch_size=8 - ile utworów przetwarza naraz (8 zmieści się w 16GB GPU)
• num_train_epochs=10 - ile razy model przejrzy cały dataset (10 to standard dla małych zbiorów)
• warmup_ratio=0.1 - przez pierwsze 10% kroków learning rate rośnie stopniowo (stabilizuje trening)
• load_best_model_at_end=True - po treningu załaduj najlepszy checkpoint, nie ostatni

Jeśli masz mniej pamięci GPU

Jeśli dostajesz błąd "out of memory", zmniejsz batch size do 4 lub 2:

per_device_train_batch_size=4,
per_device_eval_batch_size=4,

Albo włącz gradient accumulation (model akumuluje gradienty przez kilka kroków zamiast aktualizować wagi za każdym razem):

gradient_accumulation_steps=2,

To spowalnia trening, ale pozwala używać mniejszego GPU.

Krok 5: Zdefiniuj metrykę ewaluacji

Model musi wiedzieć, jak mierzyć swój postęp. Użyjesz accuracy - procent poprawnie sklasyfikowanych utworów.

import numpy as np
from datasets import load_metric

metric = load_metric("accuracy")

def compute_metrics(eval_pred):
 predictions = np.argmax(eval_pred.predictions, axis=1)
 return metric.compute(predictions=predictions, references=eval_pred.label_ids)

Funkcja compute_metrics bierze predykcje modelu (prawdopodobieństwa dla każdego gatunku), wybiera gatunek z najwyższym prawdopodobieństwem (argmax) i porównuje z prawdziwymi etykietami.

Jeśli interesuje Cię, jak oceniać jakość odpowiedzi AI w bardziej złożonych scenariuszach, sprawdź nasz przewodnik po LLM-as-Judge.

Krok 6: Uruchom trening

Wszystko gotowe. Teraz łączysz model, dane i parametry w jeden obiekt Trainer i uruchamiasz trening:

from transformers import Trainer

trainer = Trainer(
 model=model,
 args=training_args,
 train_dataset=encoded_gtzan["train"],
 eval_dataset=encoded_gtzan["test"],
 tokenizer=feature_extractor,
 compute_metrics=compute_metrics,
)

trainer.train()

Po uruchomieniu zobaczysz logi pokazujące:

• Numer epoki
• Loss (im niższy, tym lepiej)
• Accuracy na zbiorze walidacyjnym
• Czas treningu

Na darmowym GPU T4 w Google Colab cały proces powinien zająć około 30-45 minut. Model będzie zapisywał checkpointy po każdej epoce w folderze ./music_classifier.

Co robić, jeśli trening się zawiesza

Jeśli Google Colab rozłącza sesję (zdarza się po 12 godzinach bezczynności), możesz wznowić trening od ostatniego checkpointu:

trainer.train(resume_from_checkpoint=True)

Trainer automatycznie znajdzie ostatni zapisany checkpoint i kontynuuje od tego miejsca.

Krok 7: Przetestuj wytrenowany model

Trening się skończył. Czas sprawdzić, czy model naprawdę nauczył się rozpoznawać gatunki muzyczne.

Załaduj najlepszy checkpoint

best_model = AutoModelForAudioClassification.from_pretrained("./music_classifier/checkpoint-best")

Zrób predykcję na nowym utworze

Weź utwór ze zbioru walidacyjnego (którego model nie widział podczas treningu):

test_audio = encoded_gtzan["test"][0]
inputs = feature_extractor(test_audio["audio"]["array"], sampling_rate=16000, return_tensors="pt")

with torch.no_grad():
 logits = best_model(**inputs).logits

predicted_class_id = logits.argmax(-1).item()
predicted_label = id2label_fn(predicted_class_id)
print(f"Predykcja: {predicted_label}")
print(f"Prawdziwa etykieta: {id2label_fn(test_audio['genre'])}")

Jeśli model działa dobrze, powinieneś zobaczyć zgodność między predykcją a prawdziwą etykietą w około 70-80% przypadków (dokładny wynik zależy od szczęścia podczas treningu i podziału danych).

Stwórz prosty interfejs do testowania

Możesz stworzyć prosty interfejs w Gradio, żeby testować model na własnych plikach audio:

import gradio as gr

def classify_audio(audio_path):
 audio_array, sr = librosa.load(audio_path, sr=16000)
 inputs = feature_extractor(audio_array, sampling_rate=16000, return_tensors="pt")
 with torch.no_grad():
 logits = best_model(**inputs).logits
 predicted_class_id = logits.argmax(-1).item()
 return id2label_fn(predicted_class_id)

demo = gr.Interface(
 fn=classify_audio,
 inputs=gr.Audio(type="filepath"),
 outputs="text",
 title="Klasyfikator gatunków muzycznych"
)

demo.launch()

Po uruchomieniu dostaniesz link do interfejsu, gdzie możesz wrzucić własny plik MP3 i zobaczyć, co model myśli o gatunku.

Typowe problemy i jak je rozwiązać

Model daje losowe predykcje

Jeśli accuracy oscyluje wokół 10% (czyli losowe zgadywanie dla 10 klas), prawdopodobnie:

• Learning rate jest za wysoki - spróbuj 1e-5 zamiast 5e-5
• Za mało epok - zwiększ do 15-20
• Dane nie zostały poprawnie przetworzone - sprawdź częstotliwość próbkowania

Out of memory error

Zmniejsz batch size do 4 lub 2, włącz gradient accumulation (patrz Krok 4), albo użyj krótszych fragmentów audio (np. 15 sekund zamiast 30).

Model overfituje (100% accuracy na treningu, 50% na walidacji)

Dodaj regularyzację:

weight_decay=0.01, # w TrainingArguments

Albo użyj data augmentation - losowe zniekształcenia audio podczas treningu (wymaga dodatkowych bibliotek jak audiomentations).

Co dalej - jak poprawić wyniki

Podstawowy model działa, ale możesz go ulepszyć:

1. Użyj większego modelu bazowego - zamiast DistilHuBERT spróbuj pełnego HuBERT lub Wav2Vec2 (wymaga więcej pamięci GPU)
2. Dodaj więcej danych - GTZAN to tylko 999 utworów; większe datasety jak FMA lub Million Song Dataset dadzą lepsze wyniki
3. Eksperymentuj z augmentacją - dodawanie szumu, zmiana tempa, pitch shifting zwiększają różnorodność danych treningowych
4. Dostosuj learning rate scheduler - zamiast stałego learning rate użyj cosine annealing lub linear decay
5. Ensemble kilku modeli - wytrenuj 3-5 modeli z różnymi seedami i uśrednij ich predykcje

Jeśli chcesz zgłębić temat jak poprawić jakość danych treningowych, mamy osobny przewodnik na ten temat.

Najczęstsze pytania

Czy mogę użyć tego samego procesu do klasyfikacji mowy?

Tak, dokładnie ten sam proces działa dla rozpoznawania mowy, klasyfikacji emocji w głosie, detekcji języka czy identyfikacji mówcy. Musisz tylko zmienić dataset i dostosować liczbę klas (num_labels). Modele audio są uniwersalne - różnica jest tylko w danych treningowych.

Ile danych potrzebuję, żeby model działał dobrze?

Dla fine-tuningu wystarczy 500-1000 przykładów na klasę (czyli 5000-10000 utworów dla 10 gatunków). Mniej niż 100 przykładów na klasę to za mało - model będzie overfitował. Więcej niż 10 000 na klasę to diminishing returns - poprawa jakości będzie minimalna w stosunku do czasu treningu.

Czy mogę użyć własnych plików MP3 zamiast datasetu GTZAN?

Tak, ale musisz je odpowiednio przygotować. Stwórz folder dla każdego gatunku, wrzuć tam pliki MP3, a potem załaduj je używając datasets.load_dataset("audiofolder", data_dir="./twoje_dane"). Upewnij się, że wszystkie pliki mają podobną długość (30 sekund) i jakość (co najmniej 128 kbps). Różne formaty audio (MP3, WAV, FLAC) działają, ale WAV jest najprostszy w przetwarzaniu.

Jak długo trwa trening na darmowym GPU w Google Colab?

Dla 999 utworów i 10 epok: około 30-45 minut na GPU T4. Jeśli używasz większego datasetu (np. 10 000 utworów), liczy się 4-6 godzin. Google Colab rozłącza sesję po 12 godzinach, więc dla bardzo długich treningów musisz używać checkpointów i wznawiać trening ręcznie.

Czy model nauczony na GTZAN zadziała na moich playlistach z Spotify?

Częściowo. GTZAN zawiera utwory z lat 70-90, więc model może mieć problem z nowoczesnymi gatunkami (trap, future bass, lo-fi hip hop). Dodatkowo Spotify używa kompresji, która zmienia charakterystykę audio. Jeśli chcesz klasyfikować współczesną muzykę, lepiej wytrenuj model na datasecie FMA (Free Music Archive), który zawiera nowsze utwory i więcej gatunków.

Podsumowanie - co właśnie zrobiłeś

Przeszedłeś przez cały proces fine-tuningu modelu AI od początku do końca. Pobrałeś dane, przygotowałeś je, skonfigurowałeś model, uruchomiłeś trening i przetestowałeś wyniki. To dokładnie ten sam proces, którego używają firmy do budowania systemów rozpoznawania mowy, analizy sentymentu czy moderacji treści.

Różnica między tym przewodnikiem a produkcyjnym systemem to skala - więcej danych, więcej mocy obliczeniowej, więcej testów. Fundamenty są identyczne.

Jeden krok na start

Otwórz Google Colab, skopiuj kod z Kroku 1 i uruchom. Zobaczysz dataset GTZAN załadowany w przeglądarce. To zajmie Ci 2 minuty. Reszta to już tylko konsekwentne przechodzenie przez kolejne kroki. Nie musisz rozumieć każdej linijki kodu - musisz tylko uruchomić i zobaczyć, co się stanie.