Implementasi Berbagai Model Pembelajaran Mesin dengan Python: Panduan Komprehensif

Isi artikel:

Saya. Pendahuluan

• Ikhtisar singkat tentang pembelajaran mesin dan aplikasinya
• Penjelasan berbagai jenis model pembelajaran mesin (diawasi, tidak diawasi, penguatan, dll.)

II. Model Pembelajaran yang Diawasi

A. Regresi Linier

• Penjelasan cara kerja regresi linier
• Implementasi dengan Python menggunakan perpustakaan scikit-learn

B. Regresi Logistik

• Penjelasan tentang cara kerja regresi logistik
• Implementasi dengan Python menggunakan perpustakaan scikit-learn

C. Pohon Keputusan

• Penjelasan tentang cara kerja pohon keputusan
• Implementasi dengan Python menggunakan perpustakaan scikit-learn

D. Hutan Acak

• Penjelasan tentang cara kerja hutan acak
• Implementasi dengan Python menggunakan perpustakaan scikit-learn

AKU AKU AKU. Model Pembelajaran Tanpa Pengawasan

A. Pengelompokan K-Means

• Penjelasan cara kerja k-means clustering
• Implementasi dengan Python menggunakan perpustakaan scikit-learn

B. Analisis Komponen Utama (PCA)

• Penjelasan cara kerja PCA
• Implementasi dengan Python menggunakan perpustakaan scikit-learn

C. Pengelompokan Hierarki

• Penjelasan tentang cara kerja pengelompokan hierarki
• Implementasi dengan Python menggunakan perpustakaan scikit-learn

IV. Model Pembelajaran Penguatan

A. Q-Pembelajaran

• Penjelasan tentang cara kerja Q-learning
• Implementasi dengan Python menggunakan perpustakaan Keras

B. SARSA

from sklearn.linear_model import LinearRegression
from sklearn.model_selection import train_test_split

# Import data
X = [[1, 2], [2, 3], [3, 4], [4, 5]] # Input variables
y = [1, 2, 3, 4] # Target variable

# Split data into training and testing sets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2,
                                   random_state=0)

# Create and train the linear regression model
lin_reg = LinearRegression()
lin_reg.fit(X_train, y_train)

# Predict target variable for test data
y_pred = lin_reg.predict(X_test)

# Print coefficients and score of the model
print("Coefficients: ", lin_reg.coef_)
print("Intercept: ", lin_reg.intercept_)
print("Score: ", lin_reg.score(X_test, y_test))

from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split

# Import data
X = [[1, 2], [2, 3], [3, 4], [4, 5]] # Input variables
y = [0, 0, 1, 1] # Target variable (0 or 1)

# Split data into training and testing sets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, 
                                   random_state=0)

# Create and train the logistic regression model
log_reg = LogisticRegression()
log_reg.fit(X_train, y_train)

# Predict target variable for test data
y_pred = log_reg.predict(X_test)

# Print coefficients and score of the model
print("Coefficients: ", log_reg.coef_)
print("Intercept: ", log_reg.intercept_)
print("Score: ", log_reg.score(X_test, y_test))

C. Pohon Keputusan

• Penjelasan tentang cara kerja pohon keputusan

"Pohon keputusan"adalah jenis model pembelajaran terbimbing yang digunakan untuk memprediksi variabel target berdasarkan satu atau lebih variabel masukan. Pohon keputusan bekerja dengan membagi data menjadi beberapa subset secara rekursif berdasarkan nilai variabel masukan, dan kemudian membuat prediksi berdasarkan kelas mayoritas di setiap subset.

Proses membangun pohon keputusan dimulai dengan memilih variabel input dan nilai yang menghasilkan pengurangan pengotor (disebut juga kriteria pengotor) terbesar untuk variabel target. Proses ini diulangi secara rekursif untuk setiap subset data hingga kriteria penghentian terpenuhi. Hasilnya adalah struktur seperti pohon dengan serangkaian cabang dan simpul, di mana setiap cabang mewakili pemisahan variabel masukan dan setiap simpul daun mewakili prediksi.

Kriteria pengotor yang paling umum digunakan dalam pohon keputusan adalah indeks pengotor Gini dan perolehan informasi. Pengotor Gini mengukur proporsi data yang salah klasifikasi jika sampel acak dipilih dari data. Perolehan informasi mengukur pengurangan entropi (ukuran ketidakteraturan atau ketidakpastian) ketika variabel masukan tertentu digunakan untuk membagi data.

Salah satu keuntungan utama pohon keputusan adalah kemampuan interpretasinya. Pohon keputusan mudah dipahami dan diinterpretasikan, karena proses pengambilan keputusan direpresentasikan dalam struktur yang jelas seperti pohon. Selain itu, pohon keputusan dapat menangani data numerik dan kategorikal, tahan terhadap outlier, dan memerlukan sedikit pemrosesan awal data.

Namun, pohon keputusan juga memiliki beberapa keterbatasan. mereka dapat dengan mudah melakukan overfit ketika pohonnya terlalu dalam dan rumit, yang menyebabkan kinerja generalisasi yang buruk pada data baru. Selain itu, pohon keputusan sensitif terhadap perubahan kecil pada data dan dapat dengan mudah mengubah prediksinya dalam kasus ini.

Oleh karena itu, untuk mengatasi keterbatasan ini, pohon keputusan dapat digunakan bersama dengan model lain seperti Random Forest.

• Implementasi dengan Python menggunakan pustaka scikit-learn

Pohon keputusan dapat dengan mudah diimplementasikan dalam Python menggunakan perpustakaan scikit-learn. Pustaka menyediakan kelas DecisionTreeClassifier bawaan untuk tugas klasifikasi, dan kelas DecisionTreeRegressor untuk tugas regresi. Berikut ini contoh cara menggunakan kelas DecisionTreeClassifier untuk melatih model pohon keputusan untuk klasifikasi:

from sklearn.tree import DecisionTreeClassifier
from sklearn.model_selection import train_test_split

# Import data
X = [[1, 2], [2, 3], [3, 4], [4, 5]] # Input variables
y = [0, 0, 1, 1] # Target variable (0 or 1)

# Split data into training and testing sets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2,
                                   random_state=0)

# Create and train the decision tree model
tree_clf = DecisionTreeClassifier()
tree_clf.fit(X_train, y_train)

# Predict target variable for test data
y_pred = tree_clf.predict(X_test)

# Print accuracy of the model
print("Accuracy: ", tree_clf.score(X_test, y_test))

Proses ini mirip dengan contoh regresi linier dan logistik, di mana kita terlebih dahulu mengimpor kelas DecisionTreeClassifier dari modul sklearn.tree, dan fungsi train_test_split dari modul sklearn.model_selection. Kemudian kami mengimpor data dan menggunakan fungsi train_test_split untuk membagi data menjadi set pelatihan dan pengujian.

Kita membuat instance kelas DecisionTreeClassifier dan memanggil metode fit() untuk melatih model pada data pelatihan. Metode fit() mengambil variabel masukan dan variabel target sebagai argumen.

Setelah model dilatih, kita dapat menggunakan metode prediksi() untuk membuat prediksi pada data baru dengan meneruskan variabel masukan sebagai argumen. Dalam contoh ini, kami meneruskan data pengujian untuk memprediksi variabel target biner.

Kita juga dapat memeriksa keakuratan model dengan membandingkan nilai target prediksi dengan nilai sebenarnya.

Perlu dicatat bahwa Anda harus menginstal perpustakaan scikit-learn sebelum mencoba menggunakannya dalam kode Anda, Anda dapat melakukannya dengan

D. Hutan Acak

• Penjelasan tentang cara kerja hutan acak

Hutan acak adalah kumpulan pohon keputusan yang bekerja dengan menggabungkan beberapa pohon keputusan untuk meningkatkan kinerja dan ketahanan model. Hutan acak adalah jenis model pembelajaran terbimbing yang dapat digunakan untuk tugas klasifikasi dan regresi.

Proses membangun hutan acak melibatkan pelatihan beberapa pohon keputusan pada subkumpulan data yang berbeda. Subkumpulan data ini dibuat dengan pengambilan sampel acak dari data asli dengan penggantian, yang dikenal sebagai bootstrapping. Selain bootstrapping, subset variabel input acak dipilih sebagai kriteria pemisahan pada setiap node pohon. Ini dikenal sebagai metode subruang acak.

Prediksi yang dibuat oleh masing-masing pohon keputusan kemudian digabungkan untuk membuat prediksi akhir. Dalam tugas klasifikasi, prediksi akhir biasanya didasarkan pada pemungutan suara terbanyak, dimana kelas yang memperoleh suara terbanyak dipilih sebagai prediksi akhir. Dalam tugas regresi, prediksi akhir biasanya didasarkan pada rata-rata prediksi semua pohon keputusan.

Keuntungan utama dari random forest adalah dapat mengatasi masalah overfitting yang umumnya terkait dengan pohon keputusan. Dengan menggabungkan prediksi beberapa pohon keputusan, random forest mampu mengurangi varians dan meningkatkan ketahanan model. Selain itu, random forest juga dapat menangani data dalam jumlah besar dan ruang fitur berdimensi tinggi, sehingga cocok untuk aplikasi data besar.

Namun, hutan acak juga bukannya tanpa batasan. Salah satu keterbatasan utamanya adalah bahwa hutan acak dapat memakan biaya komputasi yang mahal dan memerlukan sejumlah besar memori untuk menyimpan beberapa pohon keputusan. Selain itu, random forest tidak dapat diinterpretasikan seperti pohon keputusan individual, karena sulit untuk memahami kontribusi setiap pohon keputusan terhadap prediksi akhir.

Secara keseluruhan, random forest banyak digunakan dalam banyak aplikasi seperti pemrosesan bahasa alami, komputer

• Implementasi dengan Python menggunakan pustaka scikit-learn

Hutan acak dapat dengan mudah diimplementasikan dengan Python menggunakan perpustakaan scikit-learn. Pustaka menyediakan kelas RandomForestClassifier bawaan untuk tugas klasifikasi, dan kelas RandomForestRegressor untuk tugas regresi. Berikut ini contoh cara menggunakan kelas RandomForestClassifier untuk melatih model hutan acak untuk klasifikasi:

from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split

# Import data
X = [[1, 2], [2, 3], [3, 4], [4, 5]] # Input variables
y = [0, 0, 1, 1] # Target variable (0 or 1)

# Split data into training and testing sets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2,
                                   random_state=0)

# Create and train the random forest model
rf_clf = RandomForestClassifier()
rf_clf.fit(X_train, y_train)

# Predict target variable for test data
y_pred = rf_clf.predict(X_test)

# Print accuracy of the model
print("Accuracy: ", rf_clf.score(X_test, y_test))

Prosesnya mirip dengan contoh Decision tree dimana kita pertama kali mengimpor kelas RandomForestClassifier dari modul sklearn.ensemble, dan fungsi train_test_split dari modul sklearn.model_selection. Kemudian kami mengimpor data dan menggunakan fungsi train_test_split untuk membagi data menjadi set pelatihan dan pengujian.

Kita membuat instance kelas RandomForestClassifier dan memanggil metode fit() untuk melatih model pada data pelatihan. Metode fit() mengambil variabel masukan dan variabel target sebagai argumen.

Setelah model dilatih, kita dapat menggunakan metode prediksi() untuk membuat prediksi pada data baru dengan meneruskan variabel masukan sebagai argumen. Dalam contoh ini, kami meneruskan data pengujian untuk memprediksi variabel target biner.

Kita juga dapat memeriksa keakuratan model dengan membandingkan nilai target prediksi dengan nilai sebenarnya.

Perlu dicatat bahwa Anda harus menginstal perpustakaan scikit-learn sebelum mencoba menggunakannya dalam kode Anda, Anda dapat melakukan ini dengan menjalankan pip install scikit-learn di command prompt atau terminal Anda.

Selain itu, Jumlah pohon keputusan di hutan dapat ditentukan menggunakan parameter n_estimators, yang secara default sudah disetel

III. Model Pembelajaran Tanpa Pengawasan

A. Pengelompokan K-Means

• Penjelasan tentang cara kerja pengelompokan k-means

Pengelompokan K-means adalah jenis algoritme pembelajaran tanpa pengawasan yang digunakan untuk mengelompokkan titik data serupa menjadi beberapa kluster. Tujuan dari pengelompokan k-means adalah untuk mempartisi kumpulan data menjadi k cluster, di mana setiap cluster diwakili oleh pusat massanya (juga dikenal sebagai rata-rata titik data dalam cluster).

Algoritme k-means bekerja dengan menugaskan setiap titik data secara berulang ke cluster yang pusat massanya paling dekat dengannya. Hal ini dilakukan dengan menghitung jarak antara setiap titik data dan pusat massa setiap cluster. Setelah semua titik data telah ditugaskan ke sebuah cluster, pusat massa setiap cluster dihitung ulang sebagai rata-rata dari semua titik data yang ditugaskan ke cluster tersebut. Proses ini diulangi hingga penetapan titik data ke cluster tidak lagi berubah atau jumlah iterasi maksimum tercapai.

Algoritma k-means mensyaratkan jumlah cluster, k, ditentukan terlebih dahulu. Pilihan k sering kali didasarkan pada pengetahuan domain atau informasi apriori tentang data. Algoritme ini sensitif terhadap pilihan awal centroid, sehingga proses algoritma yang berbeda dapat menghasilkan solusi yang berbeda.

Salah satu keuntungan utama k-means clustering adalah efisiensi komputasinya, terutama ketika jumlah titik data dan jumlah clusternya banyak. Selain itu, k-means juga mudah untuk diinterpretasikan, karena cluster akhir diwakili oleh pusat massanya, yang dapat dengan mudah divisualisasikan.

Namun, pengelompokan k-means juga memiliki beberapa keterbatasan. Algoritma ini sensitif terhadap pilihan awal

• Implementasi dengan Python menggunakan pustaka scikit-learn

"Pengelompokan K-means"dapat dengan mudah diimplementasikan dalam Python menggunakan perpustakaan scikit-learn. Pustaka menyediakan kelas KMeans bawaan yang dapat digunakan untuk membuat dan melatih model pengelompokan k-means. Berikut ini contoh cara menggunakan kelas KMeans untuk mengelompokkan dataset menjadi 2 cluster:

from sklearn.cluster import KMeans
import numpy as np

# Import data
X = np.array([[1, 2], [2, 3], [3, 4], [4, 5],
              [1, 2], [2, 3], [3, 4], [4, 5]]) # Input variables

# Create and train the k-means model
kmeans = KMeans(n_clusters=2)
kmeans.fit(X)

# Predict the cluster for each data point
y_pred = kmeans.predict(X)

# Print the cluster centers
print("Cluster centers: ", kmeans.cluster_centers_)

Prosesnya mirip dengan contoh regresi linier dan logistik, di mana kita terlebih dahulu mengimpor kelas KMeans dari modul sklearn.cluster. Kemudian kita import datanya, pada contoh ini kita menggunakan array numpy yang terdiri dari 8 titik data.

Kita membuat instance kelas KMeans dan memanggil metode fit() untuk melatih model pada data. Metode fit() menggunakan variabel input sebagai argumen.

Hal penting yang perlu diperhatikan adalah kita perlu menentukan jumlah cluster, k, sebagai argumen untuk kelas KMeans. Di sini, kami menentukan bahwa kami ingin mengelompokkan data menjadi 2 cluster.

Setelah model dilatih, kita dapat menggunakan metode prediksi() untuk membuat prediksi pada data baru dengan meneruskan variabel masukan sebagai argumen. Dalam contoh ini, kami meneruskan data X untuk memprediksi cluster setiap titik data.

Kita juga dapat memeriksa pusat klaster model, yang merupakan rata-rata titik data yang ditetapkan ke klaster tersebut.

Perlu dicatat bahwa Anda harus menginstal perpustakaan scikit-learn sebelum mencoba menggunakannya dalam kode Anda, Anda dapat melakukan ini dengan menjalankan pip install scikit-learn di command prompt atau terminal Anda. Selain itu, dalam contoh ini, model k-means akan mengelompokkan 4 titik data pertama dan mengelompokkan 4 titik data terakhir karena keduanya sangat mirip.

B. Analisis Komponen Utama (PCA)

• Penjelasan tentang cara kerja PCA

Analisis komponen utama (PCA) adalah teknik reduksi dimensi yang digunakan untuk menyederhanakan kumpulan data berdimensi tinggi dengan mengidentifikasi dan mempertahankan fitur paling penting (juga dikenal sebagai komponen utama) yang menjelaskan varian paling banyak dalam data. Ide utama di balik PCA adalah memproyeksikan data asli ke ruang berdimensi lebih rendah baru yang menangkap fitur terpenting dari data.

Algoritme PCA bekerja dengan menghitung vektor eigen (juga dikenal sebagai komponen utama) dan nilai eigen dari matriks kovarians data. Vektor eigen mewakili arah data yang memiliki varian paling banyak, dan nilai eigen mewakili jumlah varian di setiap arah. Vektor eigen dan nilai eigen digunakan untuk membuat sistem koordinat baru, dimana sumbu pertama (disebut juga komponen utama pertama) adalah vektor eigen dengan nilai eigen terbesar, sumbu kedua adalah vektor eigen dengan nilai eigen terbesar kedua, dan seterusnya.

Setelah sistem koordinat baru dibuat, data dapat diproyeksikan ke sumbu baru dengan menghitung perkalian titik dari data dan vektor eigen. Proyeksi yang dihasilkan mewakili representasi data baru yang berdimensi lebih rendah. Jumlah dimensi dalam representasi baru dapat dikontrol dengan menentukan jumlah vektor eigen yang akan digunakan, yang disebut jumlah komponen.

Salah satu keunggulan utama PCA adalah efisiensi komputasinya, terutama ketika jumlah titik data dan jumlah fiturnya banyak. Selain itu, PCA juga mudah diinterpretasikan, karena proyeksi akhir dapat divisualisasikan dalam plot dua dimensi.

Namun, PCA juga memiliki beberapa keterbatasan. Algoritme ini sensitif terhadap penskalaan data, jadi disarankan untuk melakukan standarisasi data sebelum menerapkan PCA. Selain itu, PCA tidak kuat terhadap outlier, jadi disarankan untuk menghilangkan outlier sebelum menerapkan PCA.

Secara keseluruhan, PCA banyak digunakan di banyak aplikasi seperti kompresi gambar, ekstraksi fitur, dan visualisasi data.

• Implementasi dengan Python menggunakan pustaka scikit-learn

Analisis Komponen Utama (PCA) dapat dengan mudah diimplementasikan dalam Python menggunakan pustaka scikit-learn. Perpustakaan menyediakan kelas PCA bawaan, yang dapat digunakan untuk membuat dan melatih model PCA. Berikut adalah contoh cara menggunakan kelas PCA untuk mengurangi dimensi kumpulan data:

from sklearn.decomposition import PCA
import numpy as np

# Import data
X = np.array([[1, 2], [2, 3], [3, 4], [4, 5], [1, 2],
              [2, 3], [3, 4], [4, 5]]) # Input variables

# Create and train the PCA model
pca = PCA(n_components=1)
pca.fit(X)

# Transform the data
X_transformed = pca.transform(X)

# Print the explained variance
print("Explained variance: ", pca.explained_variance_ratio_)

Prosesnya mirip dengan contoh clustering k-means, dimana kita terlebih dahulu mengimpor kelas PCA dari modul sklearn.decomposition. Kemudian kita import datanya, pada contoh ini kita menggunakan array numpy yang terdiri dari 8 titik data.

Kami membuat instance kelas PCA dan memanggil metode fit() untuk melatih model pada data. Metode fit() menggunakan variabel masukan sebagai argumen.

Hal penting yang perlu diperhatikan adalah kita perlu menentukan jumlah komponen utama, n_components, sebagai argumen untuk kelas PCA. Di sini, kami menetapkan bahwa kami ingin mengurangi dimensi data menjadi 1 komponen utama.

Setelah model dilatih, kita dapat menggunakan metode transform() untuk memproyeksikan data ke ruang berdimensi lebih rendah dengan meneruskan variabel masukan sebagai argumen.

Kita juga dapat memeriksa varians yang dijelaskan, yang mewakili proporsi varians yang dijelaskan oleh masing-masing komponen utama. Dalam contoh ini, komponen utama pertama menjelaskan 100% varians dalam data, seperti yang telah kita tentukan bahwa kita ingin mengurangi dimensi menjadi 1 komponen utama.

Perlu dicatat bahwa Anda harus menginstal perpustakaan scikit-learn sebelum mencoba menggunakannya dalam kode Anda, Anda dapat melakukan ini dengan menjalankan pip install scikit-learn di command prompt atau terminal Anda.

C. Pengelompokan Hierarki

• Penjelasan tentang cara kerja pengelompokan hierarki

Pengelompokan hierarki adalah jenis algoritme pembelajaran tanpa pengawasan yang digunakan untuk mengelompokkan titik data serupa menjadi beberapa kluster secara hierarkis. Tujuan dari hirarki clustering adalah untuk membangun hirarki cluster dengan menggabungkan atau memisahkan cluster yang sudah ada. Hierarki klaster yang dihasilkan dapat divisualisasikan sebagai dendrogram, di mana daun mewakili titik data individual dan cabang mewakili klaster.

Ada dua jenis utama algoritma pengelompokan hierarki: aglomeratif dan memecah belah.

Pengelompokan hierarki aglomeratif dimulai dengan setiap titik data sebagai klaster terpisah, dan pada setiap langkah, dua klaster terdekat digabungkan menjadi satu klaster. Proses ini diulangi hingga semua titik data dikelompokkan menjadi satu cluster atau jumlah cluster maksimum tercapai.

Pengelompokan hierarki yang memecah-belah dimulai dengan semua titik data dalam satu klaster, dan pada setiap langkah, klaster tersebut dibagi menjadi dua atau lebih klaster. Proses ini diulangi hingga setiap titik data berada dalam clusternya sendiri.

Dalam kedua jenis pengelompokan hierarki, kriteria keterkaitan digunakan untuk menentukan kedekatan antar cluster. Kriteria keterkaitan dapat didasarkan pada keterkaitan tunggal (jarak antar titik data terdekat), keterkaitan lengkap (jarak antar titik data terjauh), keterkaitan rata-rata (rata-rata jarak antara semua titik data), atau keterkaitan lingkungan (pertambahan jumlah kuadrat jarak yang disebabkan oleh penggabungan dua cluster).

Salah satu keuntungan utama pengelompokan hierarki adalah dapat menangani berbagai jenis data, seperti data kategorikal atau numerik. Selain itu, pengelompokan hierarki juga dapat digunakan untuk mengidentifikasi kelompok dengan berbagai bentuk dan ukuran.

Namun, pengelompokan hierarki juga memiliki beberapa keterbatasan. Algoritme ini sensitif terhadap skala data dan kriteria keterkaitan, sehingga disarankan untuk melakukan standarisasi data sebelum menerapkan pengelompokan hierarki. Selain itu, pengelompokan hierarki tidak seefisien pengelompokan k-means, terutama ketika jumlah titik datanya besar.

Secara keseluruhan, pengelompokan hierarki banyak digunakan dalam banyak aplikasi seperti segmentasi gambar, analisis ekspresi gen, dan bioinformatika.

• Implementasi dengan Python menggunakan pustaka scikit-learn

Pengelompokan hierarki dapat dengan mudah diimplementasikan dalam Python menggunakan pustaka scikit-learn. Pustaka menyediakan kelas AgglomerativeClustering bawaan yang dapat digunakan untuk membuat dan melatih model pengelompokan hierarki aglomeratif. Berikut adalah contoh cara menggunakan kelas AgglomerativeClustering untuk mengelompokkan dataset menjadi 2 cluster:

from sklearn.cluster import AgglomerativeClustering
import numpy as np

# Import data
X = np.array([[1, 2], [2, 3], [3, 4], [4, 5],
             [1, 2], [2, 3], [3, 4], [4, 5]]) # Input variables

# Create and train the agglomerative hierarchical clustering model
agg_clustering = AgglomerativeClustering(n_clusters=2)
agg_clustering.fit(X)

# Predict the cluster for each data point
y_pred = agg_clustering.fit_predict(X)

# Print the cluster labels
print("Cluster labels: ", y_pred)

Prosesnya mirip dengan contoh pengelompokan k-means, di mana kita terlebih dahulu mengimpor kelas AgglomerativeClustering dari modul sklearn.cluster. Kemudian kita import datanya, pada contoh ini kita menggunakan array numpy yang terdiri dari 8 titik data.

Kita membuat instance kelas AgglomerativeClustering dan memanggil metode fit() untuk melatih model pada data. Metode fit() menggunakan variabel masukan sebagai argumen.

Hal penting yang perlu diperhatikan adalah kita perlu menentukan jumlah cluster, k, sebagai argumen untuk kelas AgglomerativeClustering. Di sini, kami menentukan bahwa kami ingin mengelompokkan data menjadi 2 cluster.

Setelah model dilatih, kita dapat menggunakan metode fit_predict() untuk membuat prediksi pada data baru dengan meneruskan variabel masukan sebagai argumen. Dalam contoh ini, kami meneruskan data X untuk memprediksi cluster setiap titik data.

Perlu dicatat bahwa Anda harus menginstal perpustakaan scikit-learn sebelum mencoba menggunakannya dalam kode Anda, Anda dapat melakukan ini dengan menjalankan pip install scikit-learn di command prompt atau terminal Anda. Selain itu, dalam contoh ini, model pengelompokan hierarki akan mengelompokkan 4 titik data pertama dan mengelompokkan 4 titik data terakhir karena keduanya sangat mirip.

IV. Model Pembelajaran Penguatan

A. Q-Pembelajaran

• Penjelasan tentang cara kerja Q-learning

Q-learning adalah jenis algoritme pembelajaran penguatan yang digunakan untuk mempelajari tindakan optimal yang harus diambil dalam keadaan tertentu. Tujuan dari Q-learning adalah untuk memperkirakan fungsi nilai tindakan yang optimal, yang mewakili imbalan jangka panjang yang diharapkan untuk mengambil tindakan tertentu dalam keadaan tertentu. Fungsi nilai tindakan dapat direpresentasikan sebagai tabel atau fungsi, yang mana barisnya berhubungan dengan keadaan dan kolomnya berhubungan dengan tindakan.

Algoritme Q-learning bekerja dengan memperbarui fungsi nilai tindakan secara berulang berdasarkan imbalan dan perkiraan fungsi nilai tindakan dari keadaan berikutnya. Pembaruan dilakukan menggunakan persamaan berikut:

Q(s,a) = Q(s,a) + α(r + γ max(Q(s', a')) — Q(s,a))

import numpy as np
from keras.models import Sequential
from keras.layers import Dense

# Define the environment
n_states = 4 # Number of states
n_actions = 2 # Number of actions

# Create the Q-network
model = Sequential()
model.add(Dense(10, input_dim=n_states, activation='relu')) # Input layer
model.add(Dense(n_actions, activation='linear')) # Output layer
model.compile(loss='mse', optimizer='adam')

# Define the Q-learning algorithm
epsilon = 0.1 # Exploration rate
alpha = 0.1 # Learning rate
gamma = 0.9 # Discount factor

for episode in range(10000):
    # Initialize the state
    state = np.random.randint(0, n_states)
    done = False
    while not done:
        # Choose an action using an epsilon-greedy policy
        if np.random.rand() < epsilon:
            action = np.random.randint(0, n_actions)
        else:
            action = np.argmax(model.predict(state))
      # Take the action and observe the next state, reward, and done signal
        next_state, reward, done = step(state, action)
        # Update the Q-value using the Q-learning update rule
        target = reward + gamma * np.max(model.predict(next_state))
        target_vec = model.predict(state)
        target_vec[action] = target
        model.fit(state, target_vec, epochs=1, verbose=0)
        # Update the state
        state = next_state

import numpy as np
from keras.models import Sequential
from keras.layers import Dense

# Define the environment
n_states = 4 # Number of states
n_actions = 2 # Number of actions

# Create the Q-network
model = Sequential()
model.add(Dense(10, input_dim=n_states, activation='relu')) # Input layer
model.add(Dense(n_actions, activation='linear')) # Output layer
model.compile(loss='mse', optimizer='adam')

# Define the SARSA algorithm
epsilon = 0.1 # Exploration rate
alpha = 0.1 # Learning rate
gamma = 0.9 # Discount factor

for episode in range(10000):
    # Initialize the state
    state = np.random.randint(0, n_states)
    # Choose an action using an epsilon-greedy policy
    if np.random.rand() < epsilon:
        action = np.random.randint(0, n_actions)
    else:
        action = np.argmax(model.predict(state))
    done = False
    while not done:
      # Take the action and observe the next state, reward, and done signal
        next_state, reward, done = step(state, action)
        # Choose the next action using an epsilon-greedy policy
        if np.random.rand() < epsilon:
            next_action = np.random.randint(0, n_actions)
        else:
            next_action = np.argmax(model.predict(next_state))
        # Update the Q-value using the SARSA update rule
        target = reward + gamma * model.predict(next_state)[0][next_action]
        target_vec = model.predict(state)
        target_vec[action] = target
        model.fit(state, target_vec, epochs=1, verbose=0)
        # Update the state and action
        state = next_state
        action = next_action