Laporan Proyek LSTM-Music

Tujuan Proyek
Proyek ini bertujuan untuk menggunakan jaringan Long Short-Term Memory (LSTM),
sebuah jenis jaringan saraf rekuren, untuk menghasilkan musik. Ini melibatkan
pemrosesan dan pembelajaran dari data file MIDI untuk menciptakan urutan musik baru.

Persiapan dan Prapemrosesan Data

1. Pengelolaan File MIDI: Proyek dimulai dengan mengelola file MIDI. File MIDI
menyimpan musik sebagai informasi digital, ideal untuk manipulasi menggunakan
algoritma. File-file ini diekstrak dan dimuat untuk diproses.
2. Ekstraksi Nota: Data utama untuk proyek ini berasal dari pesan 'note_on' dalam file
MIDI. Pesan ini menandakan mulainya sebuah nota dan berisi informasi tentang pitch
nota tersebut. Proses ekstraksi memfilter pesan-pesan spesifik ini, dengan fokus pada satu
saluran (channel 0) untuk menjaga konsistensi.
3. Penskalaan Data: Data nota yang diekstrak kemudian diskalakan menggunakan
MinMaxScaler, sebuah teknik prapemrosesan umum.

Arsitektur Model LSTM

Model ini termasuk beberapa lapisan LSTM dengan jumlah unit yang bervariasi (256,
128, dan 64). Lapisan-lapisan ini dirancang untuk menangkap ketergantungan temporal
dalam data musik. Setiap lapisan LSTM diikuti oleh lapisan dropout dengan tingkat 0,6.
Dropout adalah teknik regularisasi untuk mencegah overfitting.

Pelatihan
Model LSTM dilatih pada dataset yang telah dipersiapkan selama 10 epoch dengan
ukuran batch 16.

Generasi dan Penyimpanan Musik

Setelah pelatihan, model menghasilkan prediksi musik berdasarkan data uji. Langkah ini
pada dasarnya melibatkan model dalam menciptakan urutan nota baru berdasarkan
pembelajarannya.

Kesimpulan dan Pekerjaan Masa Depan

Meskipun notebook tidak secara eksplisit menyediakan kesimpulan atau membahas
pekerjaan masa depan, ini menunjukkan potensi jaringan LSTM dalam menghasilkan
musik. Peningkatan masa depan bisa termasuk eksperimen dengan arsitektur jaringan
saraf yang berbeda.

Mengimpor Paket dan Memasang `mido`

```

!pip install mido

import mido

from mido import MidiFile, MidiTrack, Message

from keras.layers import LSTM, Dense, Activation, Dropout, Flatten

from keras.preprocessing import sequence

from keras.models import Sequential

from tensorflow.keras.optimizers import Adam

from sklearn.preprocessing import MinMaxScaler, StandardScaler

import numpy as np

```

- `!pip install mido`: Memasang pustaka `mido` di Python, digunakan untuk bekerja
dengan file MIDI.

- `import mido`: Mengimpor pustaka `mido`.

- `from mido import MidiFile, MidiTrack, Message`: Mengimpor kelas tertentu dari
`mido` untuk mengelola file dan pesan MIDI.

- `from keras.layers import LSTM, Dense, Activation, Dropout, Flatten`: Mengimpor

berbagai lapisan dari Keras yang digunakan untuk membangun model LSTM, termasuk
lapisan LSTM, lapisan padat (fully connected), dan lapisan dropout.

- `from keras.preprocessing import sequence`: Mengimpor modul `sequence` dari Keras,

mungkin digunakan untuk pra-pemrosesan data urutan.

- `from keras.models import Sequential`: Mengimpor kelas model `Sequential` dari

Keras, yaitu tumpukan linier lapisan.
- `from tensorflow.keras.optimizers import Adam`: Mengimpor pengoptimal Adam dari
API Keras TensorFlow.

- `from sklearn.preprocessing import MinMaxScaler, StandardScaler`: Mengimpor

utilitas penskalaan dari `sklearn`, digunakan untuk menormalkan data.

- `import numpy as np`: Mengimpor NumPy, paket fundamental untuk komputasi ilmiah
dalam Python.

Memuat dan Mengolah File MIDI

```

!unzip /content/chillhopdata.zip -d chillhop

import os

notes = []

for song in os.listdir("/content/chillhop"):

mid = MidiFile('/content/chillhop/' + song)

for msg in mid:

if not msg.is_meta and msg.channel == 0 and msg.type == 'note_on':

data = msg.bytes()

notes.append(data[1])

```

- `!unzip /content/chillhopdata.zip -d chillhop`: Mengekstrak file yang berisi file MIDI ke

dalam direktori bernama `chillhop`.

- `import os`: Mengimpor modul `os` untuk berinteraksi dengan sistem operasi.

- `notes = []`: Menginisialisasi daftar kosong untuk menyimpan data nota.

- `for song in os.listdir("/content/chillhop")`: Mengulang setiap file dalam direktori

`chillhop`.

- `mid = MidiFile('/content/chillhop/' + song)`: Memuat setiap file MIDI.

- `for msg in mid`: Mengulang setiap pesan dalam file MIDI.

- `if not msg.is_meta and msg.channel == 0 and msg.type == 'note_on'`: Memfilter pesan
untuk hanya menyertakan pesan 'note_on' pada saluran 0.

- `data = msg.bytes()`: Mengekstrak byte mentah dari pesan MIDI.

- `notes.append(data[1])`: Menambahkan nilai nota (byte kedua dari pesan) ke dalam

daftar `notes`.

Menskalakan Data

```

scaler = MinMaxScaler()

notes = list(scaler.fit_transform(np.array(notes).reshape(-1, 1)))

```

- `scaler = MinMaxScaler()`: Membuat objek `MinMaxScaler` untuk menskalakan data.

- `notes = list(scaler.fit_transform(np.array(notes).reshape(-1, 1)))`: Menskalakan data

`notes`. Data terlebih dahulu dikonversi menjadi array NumPy dan diubah bentuk
menjadi array 2D sesuai kebutuhan `MinMaxScaler`. Metode `fit_transform` digunakan
untuk menskalakan data.

Membuat Data Pelatihan

```

notes = [list(note) for note in notes]

X = []

y = []

n_prev = 30
for i in range(len(notes) - n_prev):

X.append(notes[i:i+n_prev])

y.append(notes[i+n_prev])

X_test = X[-300:]

X = X[:-300]

y = y[:-300]

```

- `notes = [list(note) for note in notes]`: Mengubah setiap nota yang telah diskalakan
menjadi daftar (jika belum).

- `X = []`, `

y = []`: Menginisialisasi daftar kosong untuk fitur input (`X`) dan nilai target (`y`).

- `n_prev = 30`: Menetapkan jumlah nota sebelumnya yang akan dipertimbangkan untuk
memprediksi nota berikutnya.

- Perulangan `for` membuat urutan nota (`X`) dan nota berikutnya yang sesuai (`y`).

- `X_test = X[-300:]`, `X = X[:-300]`, `y = y[:-300]`: Memisahkan data menjadi set

pelatihan dan pengujian.

Membangun Model LSTM

```

model = Sequential()

model.add(LSTM(256, input_shape=(n_prev, 1), return_sequences=True))

model.add(Dropout(0.6))

model.add(LSTM(128, input_shape=(n_prev, 1), return_sequences=True))

model.add(Dropout(0.6))
model.add(LSTM(64, input_shape=(n_prev, 1), return_sequences=False))

model.add(Dropout(0.6))

model.add(Dense(1))

model.add(Activation('linear'))

model.summary()

optimizer = Adam(lr=0.001)

model.compile(loss='mse', optimizer=optimizer)

```

- `model = Sequential()`: Menginisialisasi model berurutan.

- `model.add(LSTM(...))`: Menambahkan lapisan LSTM dengan berbagai jumlah unit.

- `model.add(Dropout(0.6))`: Menambahkan lapisan dropout dengan tingkat dropout

60%.

- `model.add(Dense(1))`: Menambahkan lapisan padat dengan satu unit keluaran.

- `model.add(Activation('linear'))`: Menambahkan fungsi aktivasi linear.

- `model.summary()`: Mencetak ringkasan model.

- `optimizer = Adam(lr=0.001)`: Menginisialisasi pengoptimal Adam dengan kecepatan

pembelajaran 0.001.

- `model.compile(loss='mse', optimizer=optimizer)`: Mengompilasi model dengan fungsi

kerugian mean squared error dan pengoptimal Adam.

Melatih Model

```

model.fit(np.array(X), np.array(y), batch_size=16, epochs=10, verbose=1)

```

- `model.fit(...)`: Melatih model pada data yang telah dipersiapkan (`X` dan `y`)
menggunakan ukuran batch 16 untuk 10 epoch.
Menghasilkan dan Menyimpan Musik

Bagian kode ini melibatkan penggunaan model yang telah dilatih untuk menghasilkan
urutan musik baru dan kemudian menyimpan urutan ini sebagai file MIDI. Sayangnya,
kode pasti untuk bagian ini tidak ditampilkan dalam ikhtisar awal, sehingga saya tidak
dapat memberikan penjelasan baris-per-baris untuk itu.

Setiap bagian kode ini memainkan peran penting dalam mencapai tujuan buku catatan
"LSTM-Music" Anda, yaitu menghasilkan musik menggunakan jaringan LSTM. Proses
ini melibatkan persiapan data, pembangunan dan pelatihan model, dan akhirnya, generasi
musik.