Keras - Lapisan
Seperti yang dipelajari sebelumnya, lapisan Keras adalah blok pembangun utama model Keras. Setiap lapisan menerima informasi masukan, melakukan beberapa perhitungan dan akhirnya mengeluarkan informasi yang diubah. Keluaran satu lapisan akan dialirkan ke lapisan berikutnya sebagai masukannya. Mari kita pelajari detail lengkap tentang lapisan di bab ini.
pengantar
Lapisan Keras membutuhkan shape of the input (input_shape) untuk memahami struktur data masukan, initializeruntuk mengatur bobot untuk setiap masukan dan terakhir penggerak untuk mengubah keluaran menjadi non-linier. Di antaranya, batasan membatasi dan menentukan kisaran di mana bobot data input yang akan dihasilkan dan regulator akan mencoba mengoptimalkan lapisan (dan model) dengan secara dinamis menerapkan penalti pada bobot selama proses pengoptimalan.
Untuk meringkas, lapisan Keras membutuhkan detail minimum di bawah ini untuk membuat lapisan lengkap.
- Bentuk data masukan
- Jumlah neuron / unit di lapisan
- Initializers
- Regularizers
- Constraints
- Activations
Mari kita pahami konsep dasar di bab selanjutnya. Sebelum memahami konsep dasar, mari kita membuat lapisan Keras menggunakan API model Sequential untuk mendapatkan gambaran tentang cara kerja model dan lapisan Keras.
from keras.models import Sequential
from keras.layers import Activation, Dense
from keras import initializers
from keras import regularizers
from keras import constraints
model = Sequential()
model.add(Dense(32, input_shape=(16,), kernel_initializer = 'he_uniform',
kernel_regularizer = None, kernel_constraint = 'MaxNorm', activation = 'relu'))
model.add(Dense(16, activation = 'relu'))
model.add(Dense(8))dimana,
Line 1-5 mengimpor modul yang diperlukan.
Line 7 membuat model baru menggunakan Sequential API.
Line 9 menciptakan yang baru Dense lapisan dan menambahkannya ke dalam model. Denseadalah lapisan tingkat awal yang disediakan oleh Keras, yang menerima jumlah neuron atau unit (32) sebagai parameter yang diperlukan. Jika lapisannya adalah lapisan pertama, maka kita perlu menyediakanInput Shape, (16,)demikian juga. Jika tidak, keluaran dari lapisan sebelumnya akan digunakan sebagai masukan untuk lapisan berikutnya. Semua parameter lainnya bersifat opsional.
Parameter pertama mewakili jumlah unit (neuron).
input_shape mewakili bentuk data masukan.
kernel_initializer mewakili penginisialisasi yang akan digunakan. he_uniform fungsi ditetapkan sebagai nilai.
kernel_regularizer mewakili regularizeruntuk digunakan. Tidak ada yang ditetapkan sebagai nilai.
kernel_constraint mewakili kendala untuk digunakan. MaxNorm fungsi ditetapkan sebagai nilai.
activationmewakili aktivasi untuk digunakan. fungsi relu diset sebagai nilai.
Line 10 menciptakan yang kedua Dense lapisan dengan 16 unit dan set relu sebagai fungsi aktivasi.
Line 11 membuat lapisan Dense akhir dengan 8 unit.
Konsep Dasar Lapisan
Mari kita pahami konsep dasar layer serta bagaimana Keras mendukung setiap konsep.
Bentuk masukan
Dalam pembelajaran mesin, semua jenis data input seperti teks, gambar, atau video akan diubah terlebih dahulu menjadi deretan angka dan kemudian dimasukkan ke dalam algoritma. Nomor masukan dapat berupa larik berdimensi tunggal, larik dua dimensi (matriks), atau larik multi-dimensi. Kita dapat menentukan informasi dimensional menggunakanshape, tupel bilangan bulat. Sebagai contoh,(4,2) mewakili matriks dengan empat baris dan dua kolom.
>>> import numpy as np
>>> shape = (4, 2)
>>> input = np.zeros(shape)
>>> print(input)
[
[0. 0.]
[0. 0.]
[0. 0.]
[0. 0.]
]
>>>Demikian pula, (3,4,2) matriks tiga dimensi memiliki tiga kumpulan matriks 4x2 (dua baris dan empat kolom).
>>> import numpy as np
>>> shape = (3, 4, 2)
>>> input = np.zeros(shape)
>>> print(input)
[
[[0. 0.] [0. 0.] [0. 0.] [0. 0.]]
[[0. 0.] [0. 0.] [0. 0.] [0. 0.]]
[[0. 0.] [0. 0.] [0. 0.] [0. 0.]]
]
>>>Untuk membuat lapisan pertama model (atau lapisan masukan model), bentuk data masukan harus ditentukan.
Penginisialisasi
Dalam Pembelajaran Mesin, bobot akan ditetapkan ke semua data masukan. Initializersmodul menyediakan fungsi yang berbeda untuk mengatur bobot awal ini. Beberapa dariKeras Initializer fungsinya adalah sebagai berikut -
Nol
Menghasilkan 0 untuk semua data masukan.
from keras.models import Sequential
from keras.layers import Activation, Dense
from keras import initializers
my_init = initializers.Zeros()
model = Sequential()
model.add(Dense(512, activation = 'relu', input_shape = (784,),
kernel_initializer = my_init))Dimana, kernel_initializer mewakili penginisialisasi untuk kernel model.
Ones
Menghasilkan 1 untuk semua data masukan.
from keras.models import Sequential
from keras.layers import Activation, Dense
from keras import initializers
my_init = initializers.Ones()
model.add(Dense(512, activation = 'relu', input_shape = (784,),
kernel_initializer = my_init))Konstan
Menghasilkan nilai konstan (katakanlah, 5) ditentukan oleh pengguna untuk semua data masukan.
from keras.models import Sequential
from keras.layers import Activation, Dense
from keras import initializers
my_init = initializers.Constant(value = 0) model.add(
Dense(512, activation = 'relu', input_shape = (784,), kernel_initializer = my_init)
)dimana, value mewakili nilai konstanta
RandomNormal
Menghasilkan nilai menggunakan distribusi data input normal.
from keras.models import Sequential
from keras.layers import Activation, Dense
from keras import initializers
my_init = initializers.RandomNormal(mean=0.0,
stddev = 0.05, seed = None)
model.add(Dense(512, activation = 'relu', input_shape = (784,),
kernel_initializer = my_init))dimana,
mean mewakili mean dari nilai acak yang akan dihasilkan
stddev mewakili deviasi standar dari nilai acak yang akan dihasilkan
seed mewakili nilai untuk menghasilkan nomor acak
RandomUniform
Menghasilkan nilai menggunakan distribusi data input yang seragam.
from keras import initializers
my_init = initializers.RandomUniform(minval = -0.05, maxval = 0.05, seed = None)
model.add(Dense(512, activation = 'relu', input_shape = (784,),
kernel_initializer = my_init))dimana,
minval mewakili batas bawah dari nilai acak yang akan dihasilkan
maxval mewakili batas atas dari nilai acak yang akan dihasilkan
TruncatedNormal
Menghasilkan nilai menggunakan distribusi normal data input yang terpotong.
from keras.models import Sequential
from keras.layers import Activation, Dense
from keras import initializers
my_init = initializers.TruncatedNormal(mean = 0.0, stddev = 0.05, seed = None
model.add(Dense(512, activation = 'relu', input_shape = (784,),
kernel_initializer = my_init))VarianceScaling
Menghasilkan nilai berdasarkan bentuk masukan dan bentuk keluaran dari lapisan bersama dengan skala yang ditentukan.
from keras.models import Sequential
from keras.layers import Activation, Dense
from keras import initializers
my_init = initializers.VarianceScaling(
scale = 1.0, mode = 'fan_in', distribution = 'normal', seed = None)
model.add(Dense(512, activation = 'relu', input_shape = (784,),
skernel_initializer = my_init))dimana,
scale mewakili faktor penskalaan
mode mewakili salah satu dari fan_in, fan_out dan fan_avg nilai-nilai
distribution mewakili salah satu dari normal atau uniform
VarianceScaling
Ia menemukan stddev nilai distribusi normal menggunakan rumus di bawah ini dan kemudian mencari bobotnya menggunakan distribusi normal,
stddev = sqrt(scale / n)dimana n mewakili,
jumlah unit masukan untuk mode = fan_in
jumlah unit keluar untuk mode = fan_out
jumlah rata-rata unit input dan output untuk mode = fan_avg
Demikian pula, ia menemukan batas untuk distribusi seragam menggunakan rumus di bawah ini dan kemudian menemukan bobotnya menggunakan distribusi seragam,
limit = sqrt(3 * scale / n)lecun_normal
Menghasilkan nilai menggunakan lecun distribusi normal data masukan.
from keras.models import Sequential
from keras.layers import Activation, Dense
from keras import initializers
my_init = initializers.RandomUniform(minval = -0.05, maxval = 0.05, seed = None)
model.add(Dense(512, activation = 'relu', input_shape = (784,),
kernel_initializer = my_init))Ia menemukan stddev menggunakan rumus di bawah ini dan kemudian menerapkan distribusi normal
stddev = sqrt(1 / fan_in)dimana, fan_in mewakili jumlah unit masukan.
lecun_uniform
Menghasilkan nilai menggunakan distribusi data input yang seragam.
from keras.models import Sequential
from keras.layers import Activation, Dense
from keras import initializers
my_init = initializers.lecun_uniform(seed = None)
model.add(Dense(512, activation = 'relu', input_shape = (784,),
kernel_initializer = my_init))Ia menemukan limit menggunakan rumus di bawah ini dan kemudian menerapkan distribusi seragam
limit = sqrt(3 / fan_in)dimana,
fan_in mewakili jumlah unit masukan
fan_out mewakili jumlah unit keluaran
glorot_normal
Menghasilkan nilai menggunakan glorot distribusi normal data masukan.
from keras.models import Sequential
from keras.layers import Activation, Dense
from keras import initializers
my_init = initializers.glorot_normal(seed=None) model.add(
Dense(512, activation = 'relu', input_shape = (784,), kernel_initializer = my_init)
)Ia menemukan stddev menggunakan rumus di bawah ini dan kemudian menerapkan distribusi normal
stddev = sqrt(2 / (fan_in + fan_out))dimana,
fan_in mewakili jumlah unit masukan
fan_out mewakili jumlah unit keluaran
glorot_uniform
Menghasilkan nilai menggunakan distribusi seragam glorot dari data masukan.
from keras.models import Sequential
from keras.layers import Activation, Dense
from keras import initializers
my_init = initializers.glorot_uniform(seed = None)
model.add(Dense(512, activation = 'relu', input_shape = (784,),
kernel_initializer = my_init))Ia menemukan limit menggunakan rumus di bawah ini dan kemudian menerapkan distribusi seragam
limit = sqrt(6 / (fan_in + fan_out))dimana,
fan_in mewakili jumlah unit masukan.
fan_out mewakili jumlah unit keluaran
he_normal
Menghasilkan nilai menggunakan distribusi normal data masukan.
from keras.models import Sequential
from keras.layers import Activation, Dense
from keras import initializers
my_init = initializers.RandomUniform(minval = -0.05, maxval = 0.05, seed = None)
model.add(Dense(512, activation = 'relu', input_shape = (784,),
kernel_initializer = my_init))Ia menemukan stddev menggunakan rumus di bawah ini dan kemudian menerapkan distribusi normal.
stddev = sqrt(2 / fan_in)dimana, fan_in mewakili jumlah unit masukan.
he_uniform
Menghasilkan nilai menggunakan distribusi data input yang seragam.
from keras.models import Sequential
from keras.layers import Activation, Dense
from keras import initializers
my_init = initializers.he_normal(seed = None)
model.add(Dense(512, activation = 'relu', input_shape = (784,),
kernel_initializer = my_init))Ia menemukan limit menggunakan rumus di bawah ini dan kemudian menerapkan distribusi seragam.
limit = sqrt(6 / fan_in)dimana, fan_in mewakili jumlah unit masukan.
Ortogonal
Menghasilkan matriks ortogonal acak.
from keras.models import Sequential
from keras.layers import Activation, Dense
from keras import initializers
my_init = initializers.Orthogonal(gain = 1.0, seed = None)
model.add(Dense(512, activation = 'relu', input_shape = (784,),
kernel_initializer = my_init))dimana, gain mewakili faktor perkalian dari matriks.
Identitas
Menghasilkan matriks identitas.
from keras.models import Sequential
from keras.layers import Activation, Dense
from keras import initializers
my_init = initializers.Identity(gain = 1.0) model.add(
Dense(512, activation = 'relu', input_shape = (784,), kernel_initializer = my_init)
)Kendala
Dalam pembelajaran mesin, batasan akan ditetapkan pada parameter (bobot) selama fase pengoptimalan. <> Modul batasan menyediakan fungsi yang berbeda untuk mengatur batasan pada lapisan. Beberapa fungsi kendala adalah sebagai berikut.
NonNeg
Batasi bobot menjadi non-negatif.
from keras.models import Sequential
from keras.layers import Activation, Dense
from keras import initializers
my_init = initializers.Identity(gain = 1.0) model.add(
Dense(512, activation = 'relu', input_shape = (784,),
kernel_initializer = my_init)
)dimana, kernel_constraint mewakili batasan yang akan digunakan di lapisan.
UnitNorm
Batasi bobot menjadi norma satuan.
from keras.models import Sequential
from keras.layers import Activation, Dense
from keras import constraints
my_constrain = constraints.UnitNorm(axis = 0)
model = Sequential()
model.add(Dense(512, activation = 'relu', input_shape = (784,),
kernel_constraint = my_constrain))MaxNorm
Batasi bobot ke norma kurang dari atau sama dengan nilai yang diberikan.
from keras.models import Sequential
from keras.layers import Activation, Dense
from keras import constraints
my_constrain = constraints.MaxNorm(max_value = 2, axis = 0)
model = Sequential()
model.add(Dense(512, activation = 'relu', input_shape = (784,),
kernel_constraint = my_constrain))dimana,
max_value mewakili batas atas
sumbu mewakili dimensi di mana batasan akan diterapkan. misalnya dalam Bentuk (2,3,4) sumbu 0 menunjukkan dimensi pertama, 1 menunjukkan dimensi kedua dan 2 menunjukkan dimensi ketiga
MinMaxNorm
Membatasi bobot menjadi norma antara nilai minimum dan maksimum yang ditentukan.
from keras.models import Sequential
from keras.layers import Activation, Dense
from keras import constraints
my_constrain = constraints.MinMaxNorm(min_value = 0.0, max_value = 1.0, rate = 1.0, axis = 0)
model = Sequential()
model.add(Dense(512, activation = 'relu', input_shape = (784,),
kernel_constraint = my_constrain))dimana, rate mewakili tingkat di mana batasan bobot diterapkan.
Regularizer
Dalam pembelajaran mesin, regulator digunakan dalam fase pengoptimalan. Ini menerapkan beberapa penalti pada parameter lapisan selama pengoptimalan. Modul regularisasi Keras menyediakan fungsi-fungsi di bawah ini untuk mengatur penalti pada lapisan. Regularisasi hanya berlaku per lapisan.
Regularizer L1
Ini menyediakan regularisasi berbasis L1.
from keras.models import Sequential
from keras.layers import Activation, Dense
from keras import regularizers
my_regularizer = regularizers.l1(0.)
model = Sequential()
model.add(Dense(512, activation = 'relu', input_shape = (784,),
kernel_regularizer = my_regularizer))dimana, kernel_regularizer mewakili tingkat di mana batasan bobot diterapkan.
Pengatur L2
Ini menyediakan regularisasi berbasis L2.
from keras.models import Sequential
from keras.layers import Activation, Dense
from keras import regularizers
my_regularizer = regularizers.l2(0.)
model = Sequential()
model.add(Dense(512, activation = 'relu', input_shape = (784,),
kernel_regularizer = my_regularizer))Regularizer L1 dan L2
Ini menyediakan regularisasi berbasis L1 dan L2.
from keras.models import Sequential
from keras.layers import Activation, Dense
from keras import regularizers
my_regularizer = regularizers.l2(0.)
model = Sequential()
model.add(Dense(512, activation = 'relu', input_shape = (784,),
kernel_regularizer = my_regularizer))Aktivasi
Dalam pembelajaran mesin, fungsi aktivasi adalah fungsi khusus yang digunakan untuk mengetahui apakah neuron tertentu diaktifkan atau tidak. Pada dasarnya, fungsi aktivasi melakukan transformasi nonlinier dari data masukan dan dengan demikian memungkinkan neuron untuk belajar lebih baik. Keluaran neuron tergantung pada fungsi aktivasi.
Jika Anda mengingat kembali konsep persepsi tunggal, keluaran dari perceptron (neuron) hanyalah hasil dari fungsi aktivasi, yang menerima penjumlahan semua masukan dikalikan dengan bobot yang sesuai ditambah bias keseluruhan, jika ada.
result = Activation(SUMOF(input * weight) + bias)Jadi, fungsi aktivasi memainkan peran penting dalam keberhasilan pembelajaran model. Keras menyediakan banyak fungsi aktivasi dalam modul aktivasi. Mari kita pelajari semua aktivasi yang tersedia di modul.
linier
Menerapkan fungsi Linear. Tidak melakukan apa-apa.
from keras.models import Sequential
from keras.layers import Activation, Dense
model = Sequential()
model.add(Dense(512, activation = 'linear', input_shape = (784,)))Dimana, activationmengacu pada fungsi aktivasi lapisan. Ini dapat ditentukan hanya dengan nama fungsinya dan lapisan akan menggunakan aktivator yang sesuai.
elu
Menerapkan unit linier eksponensial.
from keras.models import Sequential
from keras.layers import Activation, Dense
model = Sequential()
model.add(Dense(512, activation = 'elu', input_shape = (784,)))selu
Menerapkan satuan linier eksponensial berskala.
from keras.models import Sequential
from keras.layers import Activation, Dense
model = Sequential()
model.add(Dense(512, activation = 'selu', input_shape = (784,)))relu
Menerapkan Satuan Linear Rektifikasi.
from keras.models import Sequential
from keras.layers import Activation, Dense
model = Sequential()
model.add(Dense(512, activation = 'relu', input_shape = (784,)))softmax.dll
Menerapkan fungsi Softmax.
from keras.models import Sequential
from keras.layers import Activation, Dense
model = Sequential()
model.add(Dense(512, activation = 'softmax', input_shape = (784,)))softplus
Menerapkan fungsi Softplus.
from keras.models import Sequential
from keras.layers import Activation, Dense
model = Sequential()
model.add(Dense(512, activation = 'softplus', input_shape = (784,)))softsign
Menerapkan fungsi Softsign.
from keras.models import Sequential
from keras.layers import Activation, Dense
model = Sequential()
model.add(Dense(512, activation = 'softsign', input_shape = (784,)))tanh
Menerapkan fungsi tangen hiperbolik.
from keras.models import Sequential
from keras.layers import Activation, Dense
model = Sequential()
model.add(Dense(512, activation = 'tanh', input_shape = (784,)))sigmoid.dll
Menerapkan fungsi Sigmoid.
from keras.models import Sequential
from keras.layers import Activation, Dense
model = Sequential()
model.add(Dense(512, activation = 'sigmoid', input_shape = (784,)))hard_sigmoid
Menerapkan fungsi Hard Sigmoid.
from keras.models import Sequential
from keras.layers import Activation, Dense
model = Sequential()
model.add(Dense(512, activation = 'hard_sigmoid', input_shape = (784,)))eksponensial
Menerapkan fungsi eksponensial.
from keras.models import Sequential
from keras.layers import Activation, Dense
model = Sequential()
model.add(Dense(512, activation = 'exponential', input_shape = (784,)))| Sr Tidak | Lapisan & Deskripsi |
|---|---|
| 1 | Lapisan Padat Dense layer adalah lapisan jaringan saraf yang terhubung dalam. |
| 2 | Lapisan Putus Sekolah Dropout adalah salah satu konsep penting dalam pembelajaran mesin. |
| 3 | Ratakan Lapisan Flatten digunakan untuk meratakan masukan. |
| 4 | Bentuk Ulang Lapisan Reshape digunakan untuk mengubah bentuk input. |
| 5 | Lapisan Permute Permute juga digunakan untuk mengubah bentuk input menggunakan pola. |
| 6 | RepeatVector Layers RepeatVector digunakan untuk mengulang input untuk set nomor, n kali. |
| 7 | Lapisan Lambda Lambda digunakan untuk mengubah data masukan menggunakan ekspresi atau fungsi. |
| 8 | Lapisan Konvolusi Keras berisi banyak lapisan untuk membuat ANN berbasis Konvolusi, yang populer disebut Jaringan Neural Konvolusi (CNN) . |
| 9 | Pooling Layer Ini digunakan untuk melakukan operasi penggabungan maksimal pada data temporal. |
| 10 | Lapisan yang terhubung secara lokal Lapisan yang terhubung secara lokal mirip dengan lapisan Konv1D tetapi perbedaannya adalah bobot lapisan Konv1D digunakan bersama tetapi di sini bobot tidak dibagi. |
| 11 | Gabungkan Lapisan Ini digunakan untuk menggabungkan daftar input. |
| 12 | Lapisan Embedding Ini melakukan operasi penyematan di lapisan masukan. |