AI dengan Python - Neural Networks

Jaringan syaraf tiruan adalah perangkat komputasi paralel yang merupakan upaya untuk membuat model komputer otak. Tujuan utama dibelakangnya adalah untuk mengembangkan sistem untuk melakukan berbagai tugas komputasi lebih cepat daripada sistem tradisional. Tugas-tugas ini meliputi Pengenalan Pola dan Klasifikasi, Perkiraan, Optimasi, dan Pengelompokan Data.

Apa itu Artificial Neural Networks (ANN)

Jaringan Syaraf Tiruan (JST) adalah sistem komputasi efisien yang tema sentralnya dipinjam dari analogi jaringan saraf tiruan. JST juga disebut sebagai Sistem Saraf Tiruan, Sistem Pemrosesan Terdistribusi Paralel, dan Sistem Koneksionis. JST memperoleh banyak koleksi unit yang saling berhubungan dalam beberapa pola untuk memungkinkan komunikasi di antara mereka. Satuan ini, juga disebut sebagainodes atau neurons, adalah prosesor sederhana yang beroperasi secara paralel.

Setiap neuron terhubung dengan neuron lain melalui a connection link. Setiap tautan koneksi dikaitkan dengan bobot yang memiliki informasi tentang sinyal input. Ini adalah informasi yang paling berguna bagi neuron untuk memecahkan masalah tertentu karenaweightbiasanya membangkitkan atau menghambat sinyal yang sedang dikomunikasikan. Setiap neuron memiliki keadaan internalnya yang disebutactivation signal. Sinyal keluaran, yang dihasilkan setelah menggabungkan sinyal masukan dan aturan aktivasi, dapat dikirim ke unit lain.

Jika Anda ingin mempelajari jaringan saraf secara detail maka Anda dapat mengikuti tautan - Jaringan Syaraf Tiruan .

Menginstal Paket Berguna

Untuk membuat jaringan saraf dengan Python, kita dapat menggunakan paket yang kuat untuk jaringan saraf yang disebut NeuroLab. Ini adalah pustaka dari algoritma jaringan saraf dasar dengan konfigurasi jaringan yang fleksibel dan algoritma pembelajaran untuk Python. Anda dapat menginstal paket ini dengan bantuan perintah berikut pada command prompt -

pip install NeuroLab

Jika Anda menggunakan lingkungan Anaconda, gunakan perintah berikut untuk menginstal NeuroLab -

conda install -c labfabulous neurolab

Membangun Jaringan Neural

Di bagian ini, mari kita membangun beberapa jaringan neural dengan Python menggunakan paket NeuroLab.

Pengklasifikasi berbasis Perceptron

Perceptrons adalah blok bangunan ANN. Jika Anda ingin tahu lebih banyak tentang Perceptron, Anda dapat mengikuti tautan - artificial_neural_network

Berikut ini adalah eksekusi bertahap dari kode Python untuk membangun pengklasifikasi berbasis perceptron jaringan saraf sederhana -

Impor paket yang diperlukan seperti yang ditunjukkan -

import matplotlib.pyplot as plt
import neurolab as nl

Masukkan nilai masukan. Perhatikan bahwa ini adalah contoh pembelajaran yang diawasi, oleh karena itu Anda harus memberikan nilai target juga.

input = [[0, 0], [0, 1], [1, 0], [1, 1]]
target = [[0], [0], [0], [1]]

Buat jaringan dengan 2 input dan 1 neuron -

net = nl.net.newp([[0, 1],[0, 1]], 1)

Sekarang, latih jaringannya. Di sini, kami menggunakan aturan Delta untuk pelatihan.

error_progress = net.train(input, target, epochs=100, show=10, lr=0.1)

Sekarang, visualisasikan hasilnya dan plot grafiknya -

plt.figure()
plt.plot(error_progress)
plt.xlabel('Number of epochs')
plt.ylabel('Training error')
plt.grid()
plt.show()

Anda dapat melihat grafik berikut yang menunjukkan kemajuan pelatihan menggunakan metrik kesalahan -

Jaringan Neural Lapisan Tunggal

Dalam contoh ini, kami membuat jaringan saraf lapisan tunggal yang terdiri dari neuron independen yang bekerja pada data masukan untuk menghasilkan keluaran. Perhatikan bahwa kami menggunakan file teks bernamaneural_simple.txt sebagai masukan kami.

Impor paket yang berguna seperti yang ditunjukkan -

import numpy as np
import matplotlib.pyplot as plt
import neurolab as nl

Muat kumpulan data sebagai berikut -

input_data = np.loadtxt(“/Users/admin/neural_simple.txt')

Berikut ini adalah data yang akan kami gunakan. Perhatikan bahwa dalam data ini, dua kolom pertama adalah fitur dan dua kolom terakhir adalah label.

array([[2. , 4. , 0. , 0. ],
      [1.5, 3.9, 0. , 0. ],
      [2.2, 4.1, 0. , 0. ],
      [1.9, 4.7, 0. , 0. ],
      [5.4, 2.2, 0. , 1. ],
      [4.3, 7.1, 0. , 1. ],
      [5.8, 4.9, 0. , 1. ],
      [6.5, 3.2, 0. , 1. ],
      [3. , 2. , 1. , 0. ],
      [2.5, 0.5, 1. , 0. ],
      [3.5, 2.1, 1. , 0. ],
      [2.9, 0.3, 1. , 0. ],
      [6.5, 8.3, 1. , 1. ],
      [3.2, 6.2, 1. , 1. ],
      [4.9, 7.8, 1. , 1. ],
      [2.1, 4.8, 1. , 1. ]])

Sekarang, pisahkan keempat kolom ini menjadi 2 kolom data dan 2 label -

data = input_data[:, 0:2]
labels = input_data[:, 2:]

Plot data input menggunakan perintah berikut -

plt.figure()
plt.scatter(data[:,0], data[:,1])
plt.xlabel('Dimension 1')
plt.ylabel('Dimension 2')
plt.title('Input data')

Sekarang, tentukan nilai minimum dan maksimum untuk setiap dimensi seperti yang ditunjukkan di sini -

dim1_min, dim1_max = data[:,0].min(), data[:,0].max()
dim2_min, dim2_max = data[:,1].min(), data[:,1].max()

Selanjutnya, tentukan jumlah neuron di lapisan keluaran sebagai berikut -

nn_output_layer = labels.shape[1]

Sekarang, tentukan jaringan saraf lapisan tunggal -

dim1 = [dim1_min, dim1_max]
dim2 = [dim2_min, dim2_max]
neural_net = nl.net.newp([dim1, dim2], nn_output_layer)

Latih jaringan saraf dengan jumlah waktu dan kecepatan pembelajaran seperti yang ditunjukkan -

error = neural_net.train(data, labels, epochs = 200, show = 20, lr = 0.01)

Sekarang, visualisasikan dan plot kemajuan pelatihan menggunakan perintah berikut -

plt.figure()
plt.plot(error)
plt.xlabel('Number of epochs')
plt.ylabel('Training error')
plt.title('Training error progress')
plt.grid()
plt.show()

Sekarang, gunakan poin data uji di pengklasifikasi di atas -

print('\nTest Results:')
data_test = [[1.5, 3.2], [3.6, 1.7], [3.6, 5.7],[1.6, 3.9]] for item in data_test:
   print(item, '-->', neural_net.sim([item])[0])

Anda dapat menemukan hasil tes seperti yang ditunjukkan di sini -

[1.5, 3.2] --> [1. 0.]
[3.6, 1.7] --> [1. 0.]
[3.6, 5.7] --> [1. 1.]
[1.6, 3.9] --> [1. 0.]

Anda dapat melihat grafik berikut sebagai output dari kode yang dibahas sampai sekarang -

Jaringan Neural Multi-Lapisan

Dalam contoh ini, kami membuat jaringan saraf multi-lapisan yang terdiri dari lebih dari satu lapisan untuk mengekstrak pola yang mendasari dalam data pelatihan. Jaringan saraf multilayer ini akan bekerja seperti regressor. Kami akan menghasilkan beberapa titik data berdasarkan persamaan: y = 2x ² +8.

Impor paket yang diperlukan seperti yang ditunjukkan -

import numpy as np
import matplotlib.pyplot as plt
import neurolab as nl

Hasilkan beberapa titik data berdasarkan persamaan yang disebutkan di atas -

min_val = -30
max_val = 30
num_points = 160
x = np.linspace(min_val, max_val, num_points)
y = 2 * np.square(x) + 8
y /= np.linalg.norm(y)

Sekarang, bentuk kembali kumpulan data ini sebagai berikut -

data = x.reshape(num_points, 1)
labels = y.reshape(num_points, 1)

Visualisasikan dan plot kumpulan data masukan menggunakan perintah berikut -

plt.figure()
plt.scatter(data, labels)
plt.xlabel('Dimension 1')
plt.ylabel('Dimension 2')
plt.title('Data-points')

Sekarang, bangun jaringan saraf yang memiliki dua lapisan tersembunyi dengan neurolab dengan ten neuron di lapisan tersembunyi pertama, six di lapisan tersembunyi kedua dan one di lapisan keluaran.

neural_net = nl.net.newff([[min_val, max_val]], [10, 6, 1])

Sekarang gunakan algoritma pelatihan gradien -

neural_net.trainf = nl.train.train_gd

Sekarang latih jaringan dengan tujuan mempelajari data yang dihasilkan di atas -

error = neural_net.train(data, labels, epochs = 1000, show = 100, goal = 0.01)

Sekarang, jalankan jaringan saraf pada poin data pelatihan -

output = neural_net.sim(data)
y_pred = output.reshape(num_points)

Sekarang tugas plot dan visualisasi -

plt.figure()
plt.plot(error)
plt.xlabel('Number of epochs')
plt.ylabel('Error')
plt.title('Training error progress')

Sekarang kita akan merencanakan keluaran aktual versus hasil prediksi -

x_dense = np.linspace(min_val, max_val, num_points * 2)
y_dense_pred = neural_net.sim(x_dense.reshape(x_dense.size,1)).reshape(x_dense.size)
plt.figure()
plt.plot(x_dense, y_dense_pred, '-', x, y, '.', x, y_pred, 'p')
plt.title('Actual vs predicted')
plt.show()

Sebagai hasil dari perintah di atas, Anda dapat mengamati grafik seperti yang ditunjukkan di bawah ini -