Keras - Ebenen

Wie bereits erwähnt, sind Keras-Ebenen der Hauptbaustein von Keras-Modellen. Jede Schicht empfängt Eingabeinformationen, führt einige Berechnungen durch und gibt schließlich die transformierten Informationen aus. Die Ausgabe einer Ebene fließt als Eingabe in die nächste Ebene. In diesem Kapitel erfahren Sie alles über Ebenen.

Einführung

Eine Keras-Ebene erfordert shape of the input (input_shape) um die Struktur der Eingabedaten zu verstehen, initializerum das Gewicht für jeden Eingang festzulegen und schließlich Aktivatoren, um den Ausgang so zu transformieren, dass er nicht linear ist. Dazwischen beschränken Einschränkungen den Bereich, in dem das Gewicht der zu generierenden Eingabedaten und des Regularisierers versucht, die Ebene (und das Modell) zu optimieren, indem sie die Strafen während des Optimierungsprozesses dynamisch auf die Gewichte anwenden.

Zusammenfassend erfordert die Keras-Ebene unter den Mindestdetails, um eine vollständige Ebene zu erstellen.

Form der Eingabedaten
Anzahl der Neuronen / Einheiten in der Schicht
Initializers
Regularizers
Constraints
Activations

Lassen Sie uns das Grundkonzept im nächsten Kapitel verstehen. Bevor wir das Grundkonzept verstehen, erstellen wir eine einfache Keras-Ebene mithilfe der sequentiellen Modell-API, um eine Vorstellung davon zu erhalten, wie das Keras-Modell und die Ebene funktionieren.

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

wo,

Line 1-5 importiert die erforderlichen Module.
Line 7 Erstellt ein neues Modell mithilfe der sequentiellen API.
Line 9 schafft eine neue Dense Ebene und fügen Sie es in das Modell. Denseist eine von Keras bereitgestellte Einstiegsschicht, die die Anzahl der Neuronen oder Einheiten (32) als erforderlichen Parameter akzeptiert. Wenn die Schicht die erste Schicht ist, müssen wir bereitstellenInput Shape, (16,)auch. Andernfalls wird die Ausgabe der vorherigen Ebene als Eingabe der nächsten Ebene verwendet. Alle anderen Parameter sind optional.
- Der erste Parameter gibt die Anzahl der Einheiten (Neuronen) an.
- input_shape repräsentieren die Form der Eingabedaten.
- kernel_initializer den zu verwendenden Initialisierer darstellen. he_uniform Funktion wird als Wert gesetzt.
- kernel_regularizer vertreten regularizerbenutzt werden. Keiner ist als Wert festgelegt.
- kernel_constraint die zu verwendende Einschränkung darstellen. MaxNorm Funktion wird als Wert gesetzt.
- activationdie zu verwendende Aktivierung darstellen. Die Relu-Funktion wird als Wert festgelegt.
Line 10 schafft zweite Dense Schicht mit 16 Einheiten und setzen relu als Aktivierungsfunktion.
Line 11 Erstellt die letzte dichte Ebene mit 8 Einheiten.

Grundkonzept von Ebenen

Lassen Sie uns das Grundkonzept der Ebene sowie die Unterstützung der einzelnen Konzepte durch Keras verstehen.

Form eingeben

Beim maschinellen Lernen werden alle Arten von Eingabedaten wie Text, Bilder oder Videos zuerst in eine Reihe von Zahlen konvertiert und dann in den Algorithmus eingespeist. Eingabenummern können ein eindimensionales Array, ein zweidimensionales Array (Matrix) oder ein mehrdimensionales Array sein. Wir können die Dimensionsinformationen mit angebenshape, ein Tupel von ganzen Zahlen. Zum Beispiel,(4,2) stellen Matrix mit vier Zeilen und zwei Spalten dar.

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

Ähnlich, (3,4,2) dreidimensionale Matrix mit drei Sammlungen von 4x2-Matrix (zwei Zeilen und vier Spalten).

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

Um die erste Ebene des Modells (oder die Eingabeebene des Modells) zu erstellen, sollte die Form der Eingabedaten angegeben werden.

Initialisierer

Beim maschinellen Lernen werden alle Eingabedaten gewichtet. InitializersDas Modul bietet verschiedene Funktionen zum Einstellen dieses Anfangsgewichts. Manche derKeras Initializer Funktion sind wie folgt -

Nullen

Erzeugt 0 für alle Eingabedaten.

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

Wo, kernel_initializer stellen den Initialisierer für den Kernel des Modells dar.

Einsen

Erzeugt 1 für alle Eingabedaten.

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

Konstante

Erzeugt einen konstanten Wert (z. 5) vom Benutzer für alle Eingabedaten angegeben.

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

wo, value repräsentieren den konstanten Wert

RandomNormal

Erzeugt einen Wert unter Verwendung der Normalverteilung der Eingabedaten.

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

wo,

mean stellen den Mittelwert der zu generierenden Zufallswerte dar
stddev stellen die Standardabweichung der zu erzeugenden Zufallswerte dar
seed stellen die Werte dar, um eine Zufallszahl zu erzeugen

RandomUniform

Generiert Wert durch gleichmäßige Verteilung der Eingabedaten.

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

wo,

minval stellen die Untergrenze der zu generierenden Zufallswerte dar
maxval stellen die Obergrenze der zu generierenden Zufallswerte dar

TruncatedNormal

Erzeugt einen Wert unter Verwendung einer abgeschnittenen Normalverteilung der Eingabedaten.

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

Varianzskalierung

Erzeugt einen Wert basierend auf der Eingabe- und Ausgabeform der Ebene zusammen mit der angegebenen Skalierung.

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

wo,

scale repräsentieren den Skalierungsfaktor
mode repräsentieren einen von fan_in, fan_out und fan_avg Werte
distribution repräsentieren eines von normal oder uniform

Varianzskalierung

Es findet das stddev Wert für die Normalverteilung unter Verwendung der folgenden Formel und dann die Gewichte unter Verwendung der Normalverteilung finden,

stddev = sqrt(scale / n)

wo n vertreten,

Anzahl der Eingabeeinheiten für mode = fan_in
Anzahl der Out-Einheiten für mode = fan_out
durchschnittliche Anzahl der Ein- und Ausgabeeinheiten für mode = fan_avg

In ähnlicher Weise wird die Grenze für die gleichmäßige Verteilung unter Verwendung der folgenden Formel ermittelt und dann die Gewichte unter Verwendung der gleichmäßigen Verteilung ermittelt.

limit = sqrt(3 * scale / n)

lecun_normal

Erzeugt einen Wert unter Verwendung der Lecun-Normalverteilung der Eingabedaten.

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

Es findet das stddev Verwenden Sie die folgende Formel und wenden Sie dann die Normalverteilung an

stddev = sqrt(1 / fan_in)

wo, fan_in stellen die Anzahl der Eingabeeinheiten dar.

lecun_uniform

Erzeugt einen Wert unter Verwendung der Lecun-Gleichverteilung der Eingabedaten.

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

Es findet das limit Verwenden Sie die folgende Formel und wenden Sie dann eine gleichmäßige Verteilung an

limit = sqrt(3 / fan_in)

wo,

fan_in repräsentiert die Anzahl der Eingabeeinheiten
fan_out repräsentiert die Anzahl der Ausgabeeinheiten

glorot_normal

Erzeugt einen Wert unter Verwendung der Glorot-Normalverteilung der Eingabedaten.

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

Es findet das stddev Verwenden Sie die folgende Formel und wenden Sie dann die Normalverteilung an

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

wo,

fan_in repräsentiert die Anzahl der Eingabeeinheiten
fan_out repräsentiert die Anzahl der Ausgabeeinheiten

glorot_uniform

Erzeugt einen Wert unter Verwendung einer gleichmäßigen Verteilung der Eingabedaten.

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

Es findet das limit Verwenden Sie die folgende Formel und wenden Sie dann eine gleichmäßige Verteilung an

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

wo,

fan_in stellen die Anzahl der Eingabeeinheiten dar.
fan_out repräsentiert die Anzahl der Ausgabeeinheiten

he_normal

Erzeugt einen Wert unter Verwendung der Normalverteilung der Eingabedaten.

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

Es findet das stddev unter Verwendung der folgenden Formel und wendet dann die Normalverteilung an.

stddev = sqrt(2 / fan_in)

wo, fan_in stellen die Anzahl der Eingabeeinheiten dar.

he_uniform

Generiert Wert durch gleichmäßige Verteilung der Eingabedaten.

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

Es findet das limit Verwenden Sie die folgende Formel und wenden Sie dann eine gleichmäßige Verteilung an.

limit = sqrt(6 / fan_in)

wo, fan_in stellen die Anzahl der Eingabeeinheiten dar.

Senkrecht

Erzeugt eine zufällige orthogonale Matrix.

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

wo, gain repräsentieren den Multiplikationsfaktor der Matrix.

Identität

Erzeugt eine Identitätsmatrix.

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

Einschränkungen

Beim maschinellen Lernen wird während der Optimierungsphase eine Einschränkung für den Parameter (Gewicht) festgelegt. Das Modul <> Einschränkungen bietet verschiedene Funktionen zum Festlegen der Einschränkung für die Ebene. Einige der Einschränkungsfunktionen sind wie folgt.

NonNeg

Beschränkt die Gewichtung auf nicht negativ.

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

wo, kernel_constraint stellen die Einschränkung dar, die in der Ebene verwendet werden soll.

UnitNorm

Beschränkt die Gewichte auf Einheitsnorm.

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

Beschränkt das Gewicht auf die Norm, die kleiner oder gleich dem angegebenen Wert ist.

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

wo,

max_value repräsentieren die Obergrenze
Achse stellen die Dimension dar, in der die Einschränkung angewendet werden soll. zB in Form (2,3,4) bezeichnet die Achse 0 die erste Dimension, 1 die zweite Dimension und 2 die dritte Dimension

MinMaxNorm

Beschränkt die Norm auf die angegebenen Werte zwischen den angegebenen Minimal- und Maximalwerten.

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

wo, rate stellen die Rate dar, mit der die Gewichtsbeschränkung angewendet wird.

Regularisierer

Beim maschinellen Lernen werden in der Optimierungsphase Regularisierer eingesetzt. Während der Optimierung werden einige Einschränkungen für den Ebenenparameter angewendet. Das Keras-Regularisierungsmodul bietet die folgenden Funktionen zum Festlegen von Strafen auf der Ebene. Die Regularisierung gilt nur pro Schicht.

L1 Regularizer

Es bietet eine L1-basierte Regularisierung.

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

wo, kernel_regularizer stellen die Rate dar, mit der die Gewichtsbeschränkung angewendet wird.

L2 Regularizer

Es bietet eine L2-basierte Regularisierung.

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

L1 und L2 Regularizer

Es bietet sowohl L1- als auch L2-basierte Regularisierung.

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

Aktivierungen

Beim maschinellen Lernen ist die Aktivierungsfunktion eine spezielle Funktion, mit der ermittelt wird, ob ein bestimmtes Neuron aktiviert ist oder nicht. Grundsätzlich führt die Aktivierungsfunktion eine nichtlineare Transformation der Eingabedaten durch und ermöglicht so den Neuronen, besser zu lernen. Die Ausgabe eines Neurons hängt von der Aktivierungsfunktion ab.

Wie Sie sich an das Konzept der Einzelwahrnehmung erinnern, ist die Ausgabe eines Perzeptrons (Neurons) einfach das Ergebnis der Aktivierungsfunktion, die die Summe aller Eingaben multipliziert mit dem entsprechenden Gewicht plus der Gesamtverzerrung, falls verfügbar, akzeptiert.

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

Die Aktivierungsfunktion spielt daher eine wichtige Rolle für das erfolgreiche Lernen des Modells. Keras bietet viele Aktivierungsfunktionen im Aktivierungsmodul. Lassen Sie uns alle im Modul verfügbaren Aktivierungen lernen.

linear

Wendet die lineare Funktion an. Tut nichts.

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

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

Wo, activationbezieht sich auf die Aktivierungsfunktion der Schicht. Es kann einfach durch den Namen der Funktion angegeben werden und die Ebene verwendet entsprechende Aktivatoren.

elu

Wendet eine exponentielle Lineareinheit an.

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

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

Selu

Wendet eine skalierte exponentielle Lineareinheit an.

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

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

relu

Gilt für die gleichgerichtete Lineareinheit.

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

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

Softmax

Wendet die Softmax-Funktion an.

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

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

softplus

Wendet die Softplus-Funktion an.

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

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

Softsign

Wendet die Softsign-Funktion an.

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

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

tanh

Wendet die hyperbolische Tangentenfunktion an.

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

Sigmoid

Wendet die Sigmoid-Funktion an.

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

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

hard_sigmoid

Wendet die Hard Sigmoid-Funktion an.

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

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

exponentiell

Wendet die Exponentialfunktion an.

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

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

Sr.Nr.	Ebenen & Beschreibung
1	Dichte Schicht Dense layer ist die reguläre tief verbundene neuronale Netzwerkschicht.
2	Dropout-Ebenen *Dropout* ist eines der wichtigsten Konzepte beim maschinellen Lernen.
3	Ebenen reduzieren Flatten wird verwendet, um die Eingabe zu reduzieren.
4	Ebenen neu formen *Reshape* wird verwendet, um die Form der Eingabe zu ändern.
5	Ebenen zulassen Permute wird auch verwendet, um die Form der Eingabe mithilfe eines Musters zu ändern.
6	RepeatVector-Ebenen *RepeatVector* wird verwendet, um die Eingabe für die eingestellte Anzahl n-mal zu wiederholen.
7	Lambda-Schichten *Lambda* wird verwendet, um die Eingabedaten mithilfe eines Ausdrucks oder einer Funktion zu transformieren.
8	Faltungsschichten Keras enthält viele Ebenen zum Erstellen von Convolution-basierten ANN, im Volksmund als Convolution Neural Network (CNN) bezeichnet .
9	Pooling-Schicht Es wird verwendet, um maximale Pooling-Operationen für zeitliche Daten durchzuführen.
10	Lokal verbundene Schicht Lokal verbundene Layer ähneln dem Conv1D-Layer, der Unterschied besteht jedoch darin, dass die Gewichte der Conv1D-Layer gemeinsam genutzt werden, die Gewichte hier jedoch nicht gemeinsam genutzt werden.
11	Ebene zusammenführen Es wird verwendet, um eine Liste von Eingaben zusammenzuführen.
12	Ebene einbetten Es führt Einbettungsvorgänge in der Eingabeebene aus.