Keras - warstwy

Jak dowiedzieliśmy się wcześniej, warstwy Keras są podstawowym budulcem modeli Keras. Każda warstwa otrzymuje informacje wejściowe, wykonuje pewne obliczenia i na koniec wyświetla przetworzone informacje. Dane wyjściowe jednej warstwy wpłyną do następnej warstwy jako jej dane wejściowe. W tym rozdziale poznajmy wszystkie szczegóły dotyczące warstw.

Wprowadzenie

Warstwa Keras wymaga shape of the input (input_shape) zrozumieć strukturę danych wejściowych, initializerustawić wagę dla każdego wejścia i wreszcie aktywatory, aby przekształcić wyjście, aby było nieliniowe. W międzyczasie ograniczenia ograniczają i określają zakres, w którym waga danych wejściowych do wygenerowania, a regulator będzie próbował zoptymalizować warstwę (i model), dynamicznie nakładając kary na wagi podczas procesu optymalizacji.

Podsumowując, warstwa Keras wymaga poniżej minimum szczegółów, aby utworzyć pełną warstwę.

Kształt danych wejściowych
Liczba neuronów / jednostek w warstwie
Initializers
Regularizers
Constraints
Activations

Rozumiemy podstawową koncepcję w następnym rozdziale. Zanim zrozumiemy podstawową koncepcję, stwórzmy prostą warstwę Keras przy użyciu interfejsu API modelu sekwencyjnego, aby dowiedzieć się, jak działa model i warstwa 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))

gdzie,

Line 1-5 importuje niezbędne moduły.
Line 7 tworzy nowy model przy użyciu Sequential API.
Line 9 tworzy nowy Dense warstwę i dodaj ją do modelu. Denseto podstawowa warstwa dostarczana przez Keras, która przyjmuje liczbę neuronów lub jednostek (32) jako wymagany parametr. Jeśli warstwa jest pierwszą warstwą, musimy ją dostarczyćInput Shape, (16,)także. W przeciwnym razie dane wyjściowe z poprzedniej warstwy zostaną użyte jako dane wejściowe dla następnej warstwy. Wszystkie inne parametry są opcjonalne.
- Pierwszy parametr reprezentuje liczbę jednostek (neuronów).
- input_shape reprezentują kształt danych wejściowych.
- kernel_initializer reprezentują inicjator do użycia. he_uniform funkcja jest ustawiona jako wartość.
- kernel_regularizer przedstawiać regularizerbyć używana. Brak jest ustawiane jako wartość.
- kernel_constraint reprezentują ograniczenie, które ma być użyte. MaxNorm funkcja jest ustawiona jako wartość.
- activationreprezentują aktywację do użycia. Funkcja relu jest ustawiona jako wartość.
Line 10 tworzy drugi Dense warstwa z 16 jednostkami i zestawem relu jako funkcja aktywacji.
Line 11 tworzy końcową gęstą warstwę z 8 jednostkami.

Podstawowe pojęcia warstw

Zrozummy podstawową koncepcję warstwy, a także sposób, w jaki Keras obsługuje każdą koncepcję.

Kształt wejściowy

W uczeniu maszynowym wszystkie typy danych wejściowych, takie jak tekst, obrazy lub filmy, zostaną najpierw przekonwertowane na tablicę liczb, a następnie przesłane do algorytmu. Liczby wejściowe mogą być tablicą jednowymiarową, tablicą dwuwymiarową (matrycą) lub tablicą wielowymiarową. Możemy określić informacje o wymiarach za pomocąshape, krotka liczb całkowitych. Na przykład,(4,2) reprezentują macierz z czterema wierszami i dwiema kolumnami.

>>> import numpy as np 
>>> shape = (4, 2) 
>>> input = np.zeros(shape) 
>>> print(input) 
[
   [0. 0.] 
   [0. 0.] 
   [0. 0.] 
   [0. 0.]
] 
>>>

Podobnie, (3,4,2) trójwymiarowa macierz posiadająca trzy zbiory macierzy 4x2 (dwa wiersze i cztery kolumny).

>>> 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.]]
]
>>>

Aby utworzyć pierwszą warstwę modelu (lub warstwę wejściową modelu), należy określić kształt danych wejściowych.

Inicjatory

W uczeniu maszynowym wszystkim danym wejściowym zostanie przypisana waga. InitializersModuł zapewnia różne funkcje do ustawienia wagi początkowej. NiektórzyKeras Initializer funkcje są następujące -

Zera

Generuje 0 dla wszystkich danych wejściowych.

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))

Gdzie, kernel_initializer reprezentują inicjator jądra modelu.

Jedni

Generuje 1 dla wszystkich danych wejściowych.

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))

Stały

Generuje stałą wartość (powiedzmy, 5) określone przez użytkownika dla wszystkich danych wejściowych.

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)
)

gdzie, value reprezentują stałą wartość

RandomNormal

Generuje wartość przy użyciu rozkładu normalnego danych wejściowych.

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))

gdzie,

mean reprezentują średnią z wartości losowych do wygenerowania
stddev reprezentują odchylenie standardowe losowych wartości do wygenerowania
seed reprezentują wartości do wygenerowania liczby losowej

RandomUniform

Generuje wartość przy użyciu jednolitego rozkładu danych wejściowych.

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))

gdzie,

minval reprezentują dolną granicę losowych wartości do wygenerowania
maxval reprezentują górną granicę losowych wartości do wygenerowania

TruncatedNormal

Generuje wartość przy użyciu obciętego rozkładu normalnego danych wejściowych.

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

Generuje wartość na podstawie kształtu wejściowego i kształtu wyjściowego warstwy wraz z określoną skalą.

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))

gdzie,

scale reprezentują współczynnik skalowania
mode reprezentują dowolną z fan_in, fan_out i fan_avg wartości
distribution reprezentują jedną z normal lub uniform

VarianceScaling

Znajduje stddev wartość rozkładu normalnego za pomocą poniższego wzoru, a następnie znajdź wagi przy użyciu rozkładu normalnego,

stddev = sqrt(scale / n)

gdzie n przedstawiać,

liczba jednostek wejściowych dla mode = fan_in
liczba jednostek wyjściowych dla mode = fan_out
średnia liczba jednostek wejściowych i wyjściowych dla trybu = śr ._wachlarza

Podobnie, znajduje granicę równomiernego rozkładu za pomocą poniższego wzoru, a następnie znajduje wagi przy użyciu równomiernego rozkładu,

limit = sqrt(3 * scale / n)

lecun_normal

Generuje wartość przy użyciu rozkładu normalnego Lecuna danych wejściowych.

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))

Znajduje stddev używając poniższego wzoru, a następnie zastosuj rozkład normalny

stddev = sqrt(1 / fan_in)

gdzie, fan_in reprezentują liczbę jednostek wejściowych.

lecun_uniform

Generuje wartość przy użyciu równomiernego rozkładu danych wejściowych.

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))

Znajduje limit używając poniższego wzoru, a następnie zastosuj równomierną dystrybucję

limit = sqrt(3 / fan_in)

gdzie,

fan_in reprezentuje liczbę jednostek wejściowych
fan_out reprezentuje liczbę jednostek wyjściowych

glorot_normal

Generuje wartość przy użyciu rozkładu normalnego glorota danych wejściowych.

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)
)

Znajduje stddev używając poniższego wzoru, a następnie zastosuj rozkład normalny

stddev = sqrt(2 / (fan_in + fan_out))

gdzie,

fan_in reprezentuje liczbę jednostek wejściowych
fan_out reprezentuje liczbę jednostek wyjściowych

glorot_uniform

Generuje wartość przy użyciu jednorodnej dystrybucji danych wejściowych Glorot.

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))

Znajduje limit używając poniższego wzoru, a następnie zastosuj równomierną dystrybucję

limit = sqrt(6 / (fan_in + fan_out))

gdzie,

fan_in reprezentują liczbę jednostek wejściowych.
fan_out reprezentuje liczbę jednostek wyjściowych

he_normal

Generuje wartość przy użyciu rozkładu normalnego danych wejściowych.

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))

Znajduje stddev przy użyciu poniższego wzoru, a następnie stosuje rozkład normalny.

stddev = sqrt(2 / fan_in)

gdzie, fan_in reprezentują liczbę jednostek wejściowych.

he_uniform

Generuje wartość przy użyciu jednolitego rozkładu danych wejściowych.

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))

Znajduje limit używając poniższego wzoru, a następnie zastosuj równomierną dystrybucję.

limit = sqrt(6 / fan_in)

gdzie, fan_in reprezentują liczbę jednostek wejściowych.

Prostokątny

Generuje losową macierz ortogonalną.

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))

gdzie, gain reprezentują mnożnik macierzy.

Tożsamość

Generuje macierz tożsamości.

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)
)

Ograniczenia

W uczeniu maszynowym ograniczenie zostanie ustawione na parametr (waga) podczas fazy optymalizacji. <> Moduł ograniczeń udostępnia różne funkcje do ustawiania ograniczeń na warstwie. Oto niektóre funkcje ograniczające.

NonNeg

Ogranicza wagi, aby były nieujemne.

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)
)

gdzie, kernel_constraint reprezentują wiązanie, które ma być użyte w warstwie.

UnitNorm

Ogranicza wagi, aby były normą jednostkową.

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

Ogranicza wagę do normy mniejszej lub równej podanej wartości.

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))

gdzie,

max_value reprezentują górną granicę
oś reprezentuje wymiar, w którym ma zostać zastosowane wiązanie. np. w kształcie (2, 3, 4) oś 0 oznacza pierwszy wymiar, 1 oznacza drugi wymiar, a 2 oznacza trzeci wymiar

MinMaxNorm

Ogranicza wagi, aby były normami między określonymi wartościami minimalnymi i maksymalnymi.

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))

gdzie, rate reprezentują szybkość, z jaką stosowane jest ograniczenie wagi.

Regulatory

W uczeniu maszynowym w fazie optymalizacji używane są regulatory. Podczas optymalizacji nakłada pewne kary na parametr warstwy. Moduł regularyzacji Keras udostępnia poniższe funkcje do ustawiania kar na warstwie. Uregulowanie dotyczy tylko poszczególnych warstw.

L1 Regulator

Zapewnia regularyzację opartą na 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))

gdzie, kernel_regularizer reprezentują szybkość, z jaką stosowane jest ograniczenie wagi.

L2 Regulator

Zapewnia regularyzację opartą na 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))

Regulatory L1 i L2

Zapewnia regularyzację opartą na L1 i 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))

Aktywacje

W uczeniu maszynowym funkcja aktywacji to specjalna funkcja używana do sprawdzania, czy określony neuron jest aktywowany, czy nie. Zasadniczo funkcja aktywacji dokonuje nieliniowej transformacji danych wejściowych, a tym samym umożliwia neuronom lepsze uczenie się. Wyjście neuronu zależy od funkcji aktywacji.

Jak pamiętasz koncepcję pojedynczej percepcji, wyjście perceptronu (neuronu) jest po prostu wynikiem funkcji aktywacji, która akceptuje sumowanie wszystkich danych wejściowych pomnożonych przez odpowiadającą mu wagę plus ogólne odchylenie, jeśli takie istnieje.

result = Activation(SUMOF(input * weight) + bias)

Tak więc funkcja aktywacji odgrywa ważną rolę w pomyślnym uczeniu się modelu. Keras zapewnia wiele funkcji aktywacji w module aktywacji. Poznajmy wszystkie aktywacje dostępne w module.

liniowy

Stosuje funkcję liniową. Nic nie robi.

from keras.models import Sequential 
from keras.layers import Activation, Dense 

model = Sequential() 
model.add(Dense(512, activation = 'linear', input_shape = (784,)))

Gdzie, activationodnosi się do funkcji aktywacji warstwy. Można to określić po prostu nazwą funkcji, a warstwa użyje odpowiednich aktywatorów.

elu

Stosuje wykładniczą jednostkę liniową.

from keras.models import Sequential 
from keras.layers import Activation, Dense 

model = Sequential() 
model.add(Dense(512, activation = 'elu', input_shape = (784,)))

selu

Stosuje skalowaną wykładniczą jednostkę liniową.

from keras.models import Sequential 
from keras.layers import Activation, Dense 

model = Sequential() 
model.add(Dense(512, activation = 'selu', input_shape = (784,)))

relu

Dotyczy rektyfikowanej jednostki liniowej.

from keras.models import Sequential 
from keras.layers import Activation, Dense 

model = Sequential() 
model.add(Dense(512, activation = 'relu', input_shape = (784,)))

softmax

Dotyczy funkcji Softmax.

from keras.models import Sequential 
from keras.layers import Activation, Dense 

model = Sequential() 
model.add(Dense(512, activation = 'softmax', input_shape = (784,)))

softplus

Dotyczy funkcji Softplus.

from keras.models import Sequential 
from keras.layers import Activation, Dense 

model = Sequential() 
model.add(Dense(512, activation = 'softplus', input_shape = (784,)))

softsign

Stosuje funkcję Softsign.

from keras.models import Sequential 
from keras.layers import Activation, Dense 

model = Sequential() 
model.add(Dense(512, activation = 'softsign', input_shape = (784,)))

tanh

Stosuje funkcję styczną hiperboliczną.

from keras.models import Sequential 
from keras.layers import Activation, Dense 
model = Sequential() 
model.add(Dense(512, activation = 'tanh', input_shape = (784,)))

esicy

Stosuje funkcję 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

Stosuje funkcję 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,)))

wykładniczy

Stosuje funkcję wykładniczą.

from keras.models import Sequential 
from keras.layers import Activation, Dense 

model = Sequential() 
model.add(Dense(512, activation = 'exponential', input_shape = (784,)))

Sr.No	Warstwy i opis
1	Gęsta warstwa Dense layer to regularna, głęboko połączona warstwa sieci neuronowej.
2	Warstwy rezygnacji *Dropout* jest jedną z ważnych koncepcji uczenia maszynowego.
3	Spłaszcz warstwy Flatten służy do spłaszczania danych wejściowych.
4	Zmień kształt warstw *Reshape* służy do zmiany kształtu wejścia.
5	Permute Layers Permute służy również do zmiany kształtu wejścia za pomocą wzorca.
6	Warstwy RepeatVector *RepeatVector* służy do powtórzenia wejścia dla określonej liczby, n razy.
7	Warstwy Lambda *Lambda* służy do przekształcania danych wejściowych za pomocą wyrażenia lub funkcji.
8	Warstwy splotu Keras zawiera wiele warstw do tworzenia sieci ANN opartej na splotach, popularnie nazywanej Convolution Neural Network (CNN) .
9	Warstwa łącząca Służy do wykonywania maksymalnych operacji pulowania danych czasowych.
10	Warstwa połączona lokalnie Warstwy połączone lokalnie są podobne do warstwy Conv1D, ale różnica polega na tym, że wagi warstw Conv1D są wspólne, ale tutaj wagi nie są dzielone.
11	Scal warstwę Służy do łączenia listy wejść.
12	Osadzanie warstwy Wykonuje operacje osadzania w warstwie wejściowej.