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