Melatih Perceptron Jaringan Syaraf Tiruan Dasar dengan Python: Panduan Langkah demi Langkah

Melatih Perceptron Jaringan Syaraf Tiruan Dasar dengan Python

Panduan ini memandu Anda melalui implementasi Python yang dikomentari sepenuhnya yang secara otomatis mempelajari bobot untuk perceptron satu lapisan. Kode siap untuk disalin-tempel, dijalankan, dan disesuaikan dengan data Anda sendiri.

Jelajahi Seri Perceptron AAC

Untuk konteks yang lebih dalam atau untuk melompat ke topik lanjutan, cek artikel lain kami:

1. Bagaimana Melakukan Klasifikasi Menggunakan Jaringan Syaraf Tiruan: Apa Itu Perceptron?
2. Bagaimana Menggunakan Contoh Jaringan Syaraf Tiruan Perceptron Sederhana untuk Mengklasifikasikan Data
3. Bagaimana Melatih Jaringan Syaraf Tiruan Perceptron Dasar
4. Memahami Pelatihan Jaringan Syaraf Tiruan Sederhana
5. Pengantar Teori Pelatihan untuk Jaringan Syaraf Tiruan
6. Memahami Learning Rate dalam Jaringan Syaraf Tiruan
7. Machine Learning Tingkat Lanjut dengan Perceptron Lapisan Ganda
8. Fungsi Aktivasi Sigmoid: Aktivasi dalam Jaringan Syaraf Tiruan Perceptron Lapisan Ganda
9. Bagaimana Melatih Jaringan Syaraf Tiruan Perceptron Lapisan Ganda
10. Memahami Rumus Pelatihan dan Backpropagation untuk Perceptron Lapisan Ganda
11. Arsitektur Jaringan Syaraf Tiruan untuk Implementasi Python
12. Bagaimana Membuat Jaringan Syaraf Tiruan Perceptron Lapisan Ganda dalam Python
13. Pemrosesan Sinyal Menggunakan Jaringan Syaraf Tiruan: Validasi dalam Desain Jaringan Syaraf Tiruan
14. Dataset Pelatihan untuk Jaringan Syaraf Tiruan: Bagaimana Melatih dan Memvalidasi Jaringan Syaraf Tiruan Python

Klasifikasi dengan Perceptron Satu Lapisan

Kami memulai dengan masalah klasifikasi biner klasik dalam ruang 3-D. Arsitektur jaringan adalah satu lapisan tersembunyi dengan tiga node input dan satu node output yang menggunakan fungsi aktivasi unit-step.

Node output menerapkan fungsi unit-step berikut:

\[f(x)=\begin{cases}0 & x < 0\\1 & x \ge 0\end{cases}\]

Untuk mengilustrasikan pembelajaran, kami memperluas arsitektur untuk menyesuaikan bobotnya secara otomatis melalui loop pelatihan sederhana:

Implementasi Python

Skrip berikut membaca data pelatihan dari file Excel, menginisialisasi bobot secara acak, dan secara berulang memperbarui mereka menggunakan aturan pembelajaran perceptron.

 import pandas import numpy as np # Dimensionalitas ruang input (x, y, z) input_dim = 3 # Learning rate mengontrol magnitudo penyesuaian bobot learning_rate = 0.01 # Bobot awal acak; Anda dapat mengatur nilai tetap untuk reproduktibilitas Weights = np.random.rand(input_dim) # Weights = np.array([0.5, 0.5, 0.5]) # Muat dataset: lembar dengan kolom untuk setiap fitur dan kolom 'output' Training_Data = pandas.read_excel("3D_data.xlsx") # Pisahkan output yang diharapkan dari matriks fitur Expected_Output = Training_Data.output Training_Data = Training_Data.drop(["output"], axis=1) # Konversi ke array NumPy untuk operasi vektorisasi Training_Data = np.asarray(Training_Data) training_count = len(Training_Data[:, 0]) # Latih selama beberapa epoch for epoch in range(5): for datum in range(training_count): # Jumlah terbobot dari input Output_Sum = np.sum(np.multiply(Training_Data[datum, :], Weights)) # Terapkan aktivasi unit-step Output_Value = 0 if Output_Sum < 0 else 1 # Hitung error antara output yang diharapkan dan aktual error = Expected_Output[datum] - Output_Value # Perbarui setiap bobot sesuai aturan pembelajaran for n in range(input_dim): Weights[n] += learning_rate * error * Training_Data[datum, n] print(f"w_0 = {Weights[0]:.3f}") print(f"w_1 = {Weights[1]:.3f}") print(f"w_2 = {Weights[2]:.3f}") 

Konsep Kunci Dijelaskan

Mengonfigurasi Jaringan dan Mengatur Data

Jaringan memiliki tiga node input untuk mencocokkan koordinat 3-D. Learning rate 0,01 adalah titik awal standar; Anda dapat menyesuaikannya setelah bereksperimen. Bobot di-seed secara acak untuk menghindari simetri, tetapi Anda dapat mengaturnya ke nilai tetap jika Anda ingin perilaku deterministik.

Data pelatihan dibaca dari file Excel, dipisahkan menjadi input dan output yang diharapkan, lalu dikonversi ke array NumPy untuk komputasi yang efisien.

Menghitung Nilai Output

Setiap epoch mengulangi semua sampel pelatihan. Untuk setiap sampel, jumlah terbobot dari input dihitung. Fungsi unit-step kemudian memetakan jumlah ini ke output biner: 0 jika jumlahnya negatif, 1 jika tidak.

Memperbarui Bobot

Ketika output yang diprediksi berbeda dengan output yang diharapkan, aturan pembelajaran perceptron menyesuaikan setiap bobot proporsional terhadap nilai input, error, dan learning rate:

\[w_{new} = w + (\alpha \times \delta \times input)\]

di mana \(\delta = \text{output}_{expected} - \text{output}_{calculated}\) dan \(\alpha\) adalah learning rate.

Kesimpulan

Anda telah melihat implementasi Python yang lengkap dan diannotasi dari perceptron satu lapisan. Kode ini adalah dasar yang kokoh untuk bereksperimen dengan dataset yang berbeda, learning rate, atau bahkan memperluas jaringan ke beberapa output dalam proyek masa depan.