Keras - Kompilasi Model

Sebelumnya, kita mempelajari dasar-dasar cara membuat model menggunakan Sequential dan Functional API. Bab ini menjelaskan tentang cara mengompilasi model. Kompilasi adalah langkah terakhir dalam membuat model. Setelah kompilasi selesai, kita dapat melanjutkan ke fase pelatihan.

Mari kita pelajari beberapa konsep yang diperlukan untuk lebih memahami proses kompilasi.

Kerugian

Dalam pembelajaran mesin, LossFungsi digunakan untuk mencari kesalahan atau penyimpangan dalam proses pembelajaran. Keras membutuhkan fungsi kerugian selama proses kompilasi model.

Keras menyediakan cukup banyak fungsi kerugian di file losses modul dan mereka adalah sebagai berikut -

  • mean_squared_error
  • mean_absolute_error
  • mean_absolute_percentage_error
  • mean_squared_logarithmic_error
  • squared_hinge
  • hinge
  • categorical_hinge
  • logcosh
  • huber_loss
  • categorical_crossentropy
  • sparse_categorical_crossentropy
  • binary_crossentropy
  • kullback_leibler_divergence
  • poisson
  • cosine_proximity
  • is_categorical_crossentropy

Semua fungsi kerugian di atas menerima dua argumen -

  • y_true - label benar sebagai tensor

  • y_pred - prediksi dengan bentuk yang sama seperti y_true

Impor modul kerugian sebelum menggunakan fungsi kerugian seperti yang ditentukan di bawah ini -

from keras import losses

Pengoptimal

Dalam pembelajaran mesin, Optimizationadalah proses penting yang mengoptimalkan bobot input dengan membandingkan prediksi dan fungsi kerugian. Keras menyediakan beberapa pengoptimal sebagai modul, pengoptimal , dan mereka adalah sebagai berikut:

SGD - Pengoptimal penurunan gradien stokastik.

keras.optimizers.SGD(learning_rate = 0.01, momentum = 0.0, nesterov = False)

RMSprop - Pengoptimal RMSProp.

keras.optimizers.RMSprop(learning_rate = 0.001, rho = 0.9)

Adagrad - Pengoptimal Adagrad.

keras.optimizers.Adagrad(learning_rate = 0.01)

Adadelta - Pengoptimal Adadelta.

keras.optimizers.Adadelta(learning_rate = 1.0, rho = 0.95)

Adam - Pengoptimal Adam.

keras.optimizers.Adam(
   learning_rate = 0.001, beta_1 = 0.9, beta_2 = 0.999, amsgrad = False
)

Adamax - Pengoptimal Adamax dari Adam.

keras.optimizers.Adamax(learning_rate = 0.002, beta_1 = 0.9, beta_2 = 0.999)

Nadam - Pengoptimal Nesterov Adam.

keras.optimizers.Nadam(learning_rate = 0.002, beta_1 = 0.9, beta_2 = 0.999)

Impor modul pengoptimal sebelum menggunakan pengoptimal seperti yang ditentukan di bawah ini -

from keras import optimizers

Metrik

Dalam pembelajaran mesin, Metricsdigunakan untuk mengevaluasi kinerja model Anda. Ini mirip dengan fungsi kerugian, tetapi tidak digunakan dalam proses pelatihan. Keras menyediakan beberapa metrik sebagai modul,metrics dan mereka adalah sebagai berikut

  • accuracy
  • binary_accuracy
  • categorical_accuracy
  • sparse_categorical_accuracy
  • top_k_categorical_accuracy
  • sparse_top_k_categorical_accuracy
  • cosine_proximity
  • clone_metric

Mirip dengan fungsi kerugian, metrik juga menerima dua argumen di bawah ini -

  • y_true - label benar sebagai tensor

  • y_pred - prediksi dengan bentuk yang sama seperti y_true

Impor modul metrik sebelum menggunakan metrik seperti yang ditentukan di bawah ini -

from keras import metrics

Kompilasi model

Model keras menyediakan metode, compile()untuk mengkompilasi model. Argumen dan nilai default daricompile() metode adalah sebagai berikut

compile(
   optimizer, 
   loss = None, 
   metrics = None, 
   loss_weights = None, 
   sample_weight_mode = None, 
   weighted_metrics = None, 
   target_tensors = None
)

Argumen pentingnya adalah sebagai berikut -

  • fungsi kerugian
  • Optimizer
  • metrics

Contoh kode untuk mengkompilasi mode adalah sebagai berikut -

from keras import losses 
from keras import optimizers 
from keras import metrics 

model.compile(loss = 'mean_squared_error',  
   optimizer = 'sgd', metrics = [metrics.categorical_accuracy])

dimana,

  • fungsi kerugian ditetapkan sebagai mean_squared_error

  • pengoptimal disetel sebagai sgd

  • metrik ditetapkan sebagai metrics.categorical_accuracy

Pelatihan Model

Model dilatih oleh array NumPy menggunakan fit(). Tujuan utama dari fungsi fit ini digunakan untuk mengevaluasi model Anda pada pelatihan. Ini juga dapat digunakan untuk kinerja model grafik. Ini memiliki sintaks berikut -

model.fit(X, y, epochs = , batch_size = )

Sini,

  • X, y - Ini adalah tupel untuk mengevaluasi data Anda.

  • epochs - berapa kali model perlu dievaluasi selama pelatihan.

  • batch_size - contoh pelatihan.

Mari kita ambil contoh sederhana dari data acak numpy untuk menggunakan konsep ini.

Buat data

Mari kita buat data acak menggunakan numpy untuk x dan y dengan bantuan perintah yang disebutkan di bawah ini -

import numpy as np 

x_train = np.random.random((100,4,8)) 
y_train = np.random.random((100,10))

Sekarang, buat data validasi acak,

x_val = np.random.random((100,4,8)) 
y_val = np.random.random((100,10))

Buat model

Mari kita buat model sekuensial sederhana -

from keras.models import Sequential model = Sequential()

Tambahkan lapisan

Buat lapisan untuk menambahkan model -

from keras.layers import LSTM, Dense 

# add a sequence of vectors of dimension 16 
model.add(LSTM(16, return_sequences = True)) 
model.add(Dense(10, activation = 'softmax'))

model kompilasi

Sekarang model telah ditentukan. Anda dapat mengkompilasi menggunakan perintah di bawah ini -

model.compile(
   loss = 'categorical_crossentropy', optimizer = 'sgd', metrics = ['accuracy']
)

Terapkan fit ()

Sekarang kami menerapkan fungsi fit () untuk melatih data kami -

model.fit(x_train, y_train, batch_size = 32, epochs = 5, validation_data = (x_val, y_val))

Buat JST Perceptron Multi-Layer

Kami telah belajar membuat, mengkompilasi dan melatih model Keras.

Mari kita terapkan pembelajaran kita dan membuat JST berbasis MPL sederhana.

Modul set data

Sebelum membuat model, kita perlu memilih masalah, perlu mengumpulkan data yang diperlukan dan mengonversi data ke array NumPy. Setelah data terkumpul, kita bisa menyiapkan model dan melatihnya dengan menggunakan data yang sudah terkumpul. Pengumpulan data adalah salah satu fase pembelajaran mesin yang paling sulit. Keras menyediakan modul khusus, dataset untuk mengunduh data pembelajaran mesin online untuk keperluan pelatihan. Ini mengambil data dari server online, memproses data dan mengembalikan data sebagai set pelatihan dan pengujian. Mari kita periksa data yang diberikan oleh modul dataset Keras. Data yang tersedia dalam modul adalah sebagai berikut,

  • Klasifikasi gambar kecil CIFAR10
  • Klasifikasi gambar kecil CIFAR100
  • Film IMDB meninjau klasifikasi sentimen
  • Klasifikasi topik berita Reuters
  • Database MNIST dari digit tulisan tangan
  • Database fashion-MNIST artikel fashion
  • Dataset regresi harga perumahan Boston

Mari kita gunakan MNIST database of handwritten digits(atau minst) sebagai masukan kami. minst adalah kumpulan 60.000, gambar abu-abu 28x28. Ini berisi 10 digit. Ini juga berisi 10.000 gambar uji.

Kode di bawah ini dapat digunakan untuk memuat dataset -

from keras.datasets import mnist 

(x_train, y_train), (x_test, y_test) = mnist.load_data()

dimana

  • Line 1 impor minst dari modul keras dataset.

  • Line 3 memanggil load_data fungsi, yang akan mengambil data dari server online dan mengembalikan data sebagai 2 tupel, tupel pertama, (x_train, y_train) mewakili data pelatihan dengan bentuk, (number_sample, 28, 28) dan label digitnya dengan bentuk, (number_samples, ). Tupel kedua,(x_test, y_test) merepresentasikan data uji dengan bentuk yang sama.

Dataset lain juga bisa diambil menggunakan API serupa dan setiap API mengembalikan data yang serupa juga kecuali bentuk datanya. Bentuk datanya bergantung pada jenis datanya.

Buat model

Mari kita memilih multi-layer perceptron (MLP) sederhana seperti yang ditunjukkan di bawah ini dan mencoba membuat model menggunakan Keras.

Fitur inti dari model ini adalah sebagai berikut -

  • Lapisan masukan terdiri dari 784 nilai (28 x 28 = 784).

  • Lapisan tersembunyi pertama, Dense terdiri dari 512 neuron dan fungsi aktivasi 'relu'.

  • Lapisan tersembunyi kedua, Dropout memiliki 0,2 sebagai nilainya.

  • Lapisan tersembunyi ketiga, lagi Dense terdiri dari 512 neuron dan fungsi aktivasi 'relu'.

  • Lapisan tersembunyi keempat, Dropout memiliki 0,2 sebagai nilainya.

  • Lapisan kelima dan terakhir terdiri dari 10 neuron dan fungsi aktivasi 'softmax'.

  • Menggunakan categorical_crossentropy sebagai fungsi kerugian.

  • Menggunakan RMSprop() sebagai Pengoptimal.

  • Menggunakan accuracy sebagai metrik.

  • Gunakan 128 sebagai ukuran batch.

  • Gunakan 20 sebagai epoch.

Step 1 − Import the modules

Mari kita impor modul yang diperlukan.

import keras 
from keras.datasets import mnist 
from keras.models import Sequential 
from keras.layers import Dense, Dropout 
from keras.optimizers import RMSprop 
import numpy as np

Step 2 − Load data

Mari kita impor dataset mnist.

(x_train, y_train), (x_test, y_test) = mnist.load_data()

Step 3 − Process the data

Mari kita ubah dataset sesuai dengan model kita, sehingga bisa dimasukkan ke dalam model kita.

x_train = x_train.reshape(60000, 784) 
x_test = x_test.reshape(10000, 784) 
x_train = x_train.astype('float32') 
x_test = x_test.astype('float32') 
x_train /= 255 
x_test /= 255 

y_train = keras.utils.to_categorical(y_train, 10) 
y_test = keras.utils.to_categorical(y_test, 10)

Dimana

  • reshape digunakan untuk membentuk kembali input dari (28, 28) tuple ke (784,)

  • to_categorical digunakan untuk mengubah vektor menjadi matriks biner

Step 4 − Create the model

Mari kita buat model sebenarnya.

model = Sequential() 
model.add(Dense(512, activation = 'relu', input_shape = (784,))) 
model.add(Dropout(0.2)) 
model.add(Dense(512, activation = 'relu'))
model.add(Dropout(0.2)) 
model.add(Dense(10, activation = 'softmax'))

Step 5 − Compile the model

Mari kita kompilasi model menggunakan fungsi kerugian, pengoptimal, dan metrik yang dipilih.

model.compile(loss = 'categorical_crossentropy',     
   optimizer = RMSprop(), 
   metrics = ['accuracy'])

Step 6 − Train the model

Mari kita latih modelnya menggunakan fit() metode.

history = model.fit(
   x_train, y_train, 
   batch_size = 128, 
   epochs = 20, 
   verbose = 1, 
   validation_data = (x_test, y_test)
)

Pikiran terakhir

Kami telah membuat model, memuat data dan juga melatih data ke model. Kita masih perlu mengevaluasi model dan memprediksi keluaran untuk masukan yang tidak diketahui, yang akan kita pelajari di bab selanjutnya.

import keras 
from keras.datasets import mnist 
from keras.models import Sequential 
from keras.layers import Dense, Dropout 
from keras.optimizers import RMSprop 
import numpy as np 

(x_train, y_train), (x_test, y_test) = mnist.load_data() 

x_train = x_train.reshape(60000, 784) 
x_test = x_test.reshape(10000, 784) 
x_train = x_train.astype('float32') 
x_test = x_test.astype('float32') 
x_train /= 255 
x_test /= 255 

y_train = keras.utils.to_categorical(y_train, 10) 
y_test = keras.utils.to_categorical(y_test, 10) 

model = Sequential() 
model.add(Dense(512, activation='relu', input_shape = (784,))) 
model.add(Dropout(0.2)) 
model.add(Dense(512, activation = 'relu')) model.add(Dropout(0.2)) 
model.add(Dense(10, activation = 'softmax'))
model.compile(loss = 'categorical_crossentropy', 
   optimizer = RMSprop(), 
   metrics = ['accuracy']) 

history = model.fit(x_train, y_train, 
   batch_size = 128, epochs = 20, verbose = 1, validation_data = (x_test, y_test))

Menjalankan aplikasi akan memberikan konten di bawah ini sebagai output -

Train on 60000 samples, validate on 10000 samples Epoch 1/20 
60000/60000 [==============================] - 7s 118us/step - loss: 0.2453 
- acc: 0.9236 - val_loss: 0.1004 - val_acc: 0.9675 Epoch 2/20 
60000/60000 [==============================] - 7s 110us/step - loss: 0.1023 
- acc: 0.9693 - val_loss: 0.0797 - val_acc: 0.9761 Epoch 3/20 
60000/60000 [==============================] - 7s 110us/step - loss: 0.0744 
- acc: 0.9770 - val_loss: 0.0727 - val_acc: 0.9791 Epoch 4/20 
60000/60000 [==============================] - 7s 110us/step - loss: 0.0599 
- acc: 0.9823 - val_loss: 0.0704 - val_acc: 0.9801 Epoch 5/20 
60000/60000 [==============================] - 7s 112us/step - loss: 0.0504 
- acc: 0.9853 - val_loss: 0.0714 - val_acc: 0.9817 Epoch 6/20 
60000/60000 [==============================] - 7s 111us/step - loss: 0.0438 
- acc: 0.9868 - val_loss: 0.0845 - val_acc: 0.9809 Epoch 7/20 
60000/60000 [==============================] - 7s 114us/step - loss: 0.0391 
- acc: 0.9887 - val_loss: 0.0823 - val_acc: 0.9802 Epoch 8/20 
60000/60000 [==============================] - 7s 112us/step - loss: 0.0364 
- acc: 0.9892 - val_loss: 0.0818 - val_acc: 0.9830 Epoch 9/20 
60000/60000 [==============================] - 7s 113us/step - loss: 0.0308 
- acc: 0.9905 - val_loss: 0.0833 - val_acc: 0.9829 Epoch 10/20 
60000/60000 [==============================] - 7s 112us/step - loss: 0.0289 
- acc: 0.9917 - val_loss: 0.0947 - val_acc: 0.9815 Epoch 11/20 
60000/60000 [==============================] - 7s 112us/step - loss: 0.0279 
- acc: 0.9921 - val_loss: 0.0818 - val_acc: 0.9831 Epoch 12/20 
60000/60000 [==============================] - 7s 112us/step - loss: 0.0260 
- acc: 0.9927 - val_loss: 0.0945 - val_acc: 0.9819 Epoch 13/20 
60000/60000 [==============================] - 7s 112us/step - loss: 0.0257 
- acc: 0.9931 - val_loss: 0.0952 - val_acc: 0.9836 Epoch 14/20
60000/60000 [==============================] - 7s 112us/step - loss: 0.0229 
- acc: 0.9937 - val_loss: 0.0924 - val_acc: 0.9832 Epoch 15/20 
60000/60000 [==============================] - 7s 115us/step - loss: 0.0235 
- acc: 0.9937 - val_loss: 0.1004 - val_acc: 0.9823 Epoch 16/20 
60000/60000 [==============================] - 7s 113us/step - loss: 0.0214 
- acc: 0.9941 - val_loss: 0.0991 - val_acc: 0.9847 Epoch 17/20 
60000/60000 [==============================] - 7s 112us/step - loss: 0.0219 
- acc: 0.9943 - val_loss: 0.1044 - val_acc: 0.9837 Epoch 18/20 
60000/60000 [==============================] - 7s 112us/step - loss: 0.0190 
- acc: 0.9952 - val_loss: 0.1129 - val_acc: 0.9836 Epoch 19/20 
60000/60000 [==============================] - 7s 112us/step - loss: 0.0197 
- acc: 0.9953 - val_loss: 0.0981 - val_acc: 0.9841 Epoch 20/20 
60000/60000 [==============================] - 7s 112us/step - loss: 0.0198 
- acc: 0.9950 - val_loss: 0.1215 - val_acc: 0.9828