Keras - Livelli
Come appreso in precedenza, i livelli di Keras sono l'elemento principale dei modelli Keras. Ciascun livello riceve le informazioni di input, esegue alcuni calcoli e infine emette le informazioni trasformate. L'output di un livello fluirà nel livello successivo come input. Impariamo i dettagli completi sui livelli in questo capitolo.
introduzione
Un livello Keras richiede shape of the input (input_shape) per comprendere la struttura dei dati di input, initializerper impostare il peso per ogni ingresso e infine gli attivatori per trasformare l'uscita per renderla non lineare. In mezzo, i vincoli restringono e specificano l'intervallo in cui il peso dei dati di input da generare e il regolarizzatore tenterà di ottimizzare il layer (e il modello) applicando dinamicamente le penalità sui pesi durante il processo di ottimizzazione.
Per riassumere, il livello Keras richiede i dettagli minimi per creare un livello completo.
- Forma dei dati di input
- Numero di neuroni / unità nel livello
- Initializers
- Regularizers
- Constraints
- Activations
Cerchiamo di capire il concetto di base nel prossimo capitolo. Prima di comprendere il concetto di base, creiamo un semplice layer Keras utilizzando l'API del modello sequenziale per avere un'idea di come funzionano il modello e il layer 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))dove,
Line 1-5 importa i moduli necessari.
Line 7 crea un nuovo modello utilizzando l'API sequenziale.
Line 9 crea un nuovo Dense strato e aggiungilo nel modello. Denseè un livello di ingresso fornito da Keras, che accetta il numero di neuroni o unità (32) come parametro richiesto. Se il livello è il primo livello, allora dobbiamo fornireInput Shape, (16,)anche. Altrimenti, l'output del livello precedente verrà utilizzato come input del livello successivo. Tutti gli altri parametri sono opzionali.
Il primo parametro rappresenta il numero di unità (neuroni).
input_shape rappresentano la forma dei dati di input.
kernel_initializer rappresentano l'inizializzatore da utilizzare. he_uniform la funzione è impostata come valore.
kernel_regularizer rappresentare regularizerda essere usato. Nessuno è impostato come valore.
kernel_constraint rappresentano il vincolo da utilizzare. MaxNorm la funzione è impostata come valore.
activationrappresentano l'attivazione da utilizzare. la funzione relu è impostata come valore.
Line 10 crea il secondo Dense strato con 16 unità e set relu come funzione di attivazione.
Line 11 crea lo strato denso finale con 8 unità.
Concetto di base dei livelli
Cerchiamo di comprendere il concetto di base di livello e il modo in cui Keras supporta ciascun concetto.
Forma di input
Nell'apprendimento automatico, tutti i tipi di dati di input come testo, immagini o video verranno prima convertiti in array di numeri e quindi inseriti nell'algoritmo. I numeri di input possono essere array monodimensionale, array bidimensionale (matrice) o array multidimensionale. Possiamo specificare le informazioni dimensionali usandoshape, una tupla di numeri interi. Per esempio,(4,2) rappresentano la matrice con quattro righe e due colonne.
>>> import numpy as np
>>> shape = (4, 2)
>>> input = np.zeros(shape)
>>> print(input)
[
[0. 0.]
[0. 0.]
[0. 0.]
[0. 0.]
]
>>>Allo stesso modo, (3,4,2) matrice tridimensionale con tre raccolte di matrice 4x2 (due righe e quattro colonne).
>>> 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.]]
]
>>>Per creare il primo livello del modello (o livello di input del modello), è necessario specificare la forma dei dati di input.
Inizializzatori
In Machine Learning, il peso verrà assegnato a tutti i dati di input. InitializersIl modulo fornisce diverse funzioni per impostare questo peso iniziale. Alcuni deiKeras Initializer le funzioni sono le seguenti:
Zeri
Genera 0 per tutti i dati di input.
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))Dove, kernel_initializer rappresentano l'inizializzatore per il kernel del modello.
Ones
Genera 1 per tutti i dati di input.
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))Costante
Genera un valore costante (ad esempio, 5) specificato dall'utente per tutti i dati di input.
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)
)dove, value rappresentano il valore costante
RandomNormal
Genera valore utilizzando la distribuzione normale dei dati di input.
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))dove,
mean rappresentano la media dei valori casuali da generare
stddev rappresentano la deviazione standard dei valori casuali da generare
seed rappresentano i valori per generare un numero casuale
RandomUniform
Genera valore utilizzando una distribuzione uniforme dei dati di input.
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))dove,
minval rappresentano il limite inferiore dei valori casuali da generare
maxval rappresentano il limite superiore dei valori casuali da generare
TruncatedNormal
Genera valore utilizzando la distribuzione normale troncata dei dati di input.
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
Genera un valore in base alla forma di input e alla forma di output del livello insieme alla scala specificata.
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))dove,
scale rappresentano il fattore di scala
mode rappresentare uno qualsiasi di fan_in, fan_out e fan_avg valori
distribution rappresentano uno di normal o uniform
VarianceScaling
Trova il file stddev valore per la distribuzione normale utilizzando la formula seguente e quindi trovare i pesi utilizzando la distribuzione normale,
stddev = sqrt(scale / n)dove n rappresentare,
numero di unità di ingresso per mode = fan_in
numero di unità out per mode = fan_out
numero medio di unità di input e output per mode = fan_avg
Allo stesso modo, trova il limite per la distribuzione uniforme utilizzando la formula seguente e quindi trova i pesi utilizzando la distribuzione uniforme,
limit = sqrt(3 * scale / n)lecun_normal
Genera valore utilizzando la normale distribuzione lecun dei dati di input.
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))Trova il file stddev utilizzando la formula seguente e quindi applicare la distribuzione normale
stddev = sqrt(1 / fan_in)dove, fan_in rappresentano il numero di unità di input.
lecun_uniform
Genera valore utilizzando la distribuzione uniforme lecun dei dati di input.
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))Trova il file limit utilizzando la formula seguente e quindi applicare una distribuzione uniforme
limit = sqrt(3 / fan_in)dove,
fan_in rappresenta il numero di unità di input
fan_out rappresenta il numero di unità di output
glorot_normal
Genera valore utilizzando la distribuzione normale glorot dei dati di input.
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)
)Trova il file stddev utilizzando la formula seguente e quindi applicare la distribuzione normale
stddev = sqrt(2 / (fan_in + fan_out))dove,
fan_in rappresenta il numero di unità di input
fan_out rappresenta il numero di unità di output
glorot_uniform
Genera valore utilizzando la distribuzione uniforme glorot dei dati di input.
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))Trova il file limit utilizzando la formula seguente e quindi applicare una distribuzione uniforme
limit = sqrt(6 / (fan_in + fan_out))dove,
fan_in rappresentano il numero di unità di input.
fan_out rappresenta il numero di unità di output
he_normal
Genera valore utilizzando la distribuzione normale dei dati di input.
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))Trova lo stddev usando la formula seguente e quindi applica la distribuzione normale.
stddev = sqrt(2 / fan_in)dove, fan_in rappresentano il numero di unità di input.
he_uniform
Genera valore utilizzando la distribuzione uniforme dei dati di input.
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))Trova il file limit utilizzando la formula seguente e quindi applicare una distribuzione uniforme.
limit = sqrt(6 / fan_in)dove, fan_in rappresentano il numero di unità di input.
Ortogonale
Genera una matrice ortogonale casuale.
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))dove, gain rappresentano il fattore di moltiplicazione della matrice.
Identità
Genera matrice identità.
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)
)Vincoli
Nel machine learning, verrà impostato un vincolo sul parametro (peso) durante la fase di ottimizzazione. <> Il modulo Vincoli fornisce diverse funzioni per impostare il vincolo sul livello. Alcune delle funzioni di vincolo sono le seguenti.
NonNeg
Limita i pesi a essere non negativi.
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)
)dove, kernel_constraint rappresentano il vincolo da utilizzare nel layer.
UnitNorm
Vincola i pesi a essere una norma unitaria.
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
Vincola il peso alla norma minore o uguale al valore dato.
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))dove,
max_value rappresentano il limite superiore
gli assi rappresentano la dimensione in cui il vincolo deve essere applicato. ad esempio in Shape (2,3,4) l'asse 0 indica la prima dimensione, 1 indica la seconda dimensione e 2 indica la terza dimensione
MinMaxNorm
Vincola i pesi a essere la norma tra i valori minimo e massimo specificati.
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))dove, rate rappresentano la velocità con cui viene applicato il vincolo di peso.
Regolarizzatori
Nell'apprendimento automatico, i regolarizzatori vengono utilizzati nella fase di ottimizzazione. Applica alcune penalità al parametro del layer durante l'ottimizzazione. Il modulo di regolarizzazione di Keras fornisce le seguenti funzioni per impostare le penalità sul livello. La regolarizzazione si applica solo in base al livello.
Regolarizzatore L1
Fornisce una regolarizzazione basata su 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))dove, kernel_regularizer rappresentano la velocità con cui viene applicato il vincolo di peso.
Regolarizzatore L2
Fornisce una regolarizzazione basata su 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))Regolarizzatore L1 e L2
Fornisce una regolarizzazione basata su L1 e 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))Attivazioni
Nell'apprendimento automatico, la funzione di attivazione è una funzione speciale utilizzata per scoprire se un neurone specifico è attivato o meno. Fondamentalmente, la funzione di attivazione esegue una trasformazione non lineare dei dati di input e quindi consente ai neuroni di apprendere meglio. L'output di un neurone dipende dalla funzione di attivazione.
Come ricordi il concetto di percezione singola, l'output di un perceptron (neurone) è semplicemente il risultato della funzione di attivazione, che accetta la somma di tutti gli input moltiplicati per il suo peso corrispondente più il bias complessivo, se disponibile.
result = Activation(SUMOF(input * weight) + bias)Quindi, la funzione di attivazione gioca un ruolo importante nel successo dell'apprendimento del modello. Keras fornisce molte funzioni di attivazione nel modulo di attivazione. Impariamo tutte le attivazioni disponibili nel modulo.
lineare
Applica la funzione lineare. Non fa nulla.
from keras.models import Sequential
from keras.layers import Activation, Dense
model = Sequential()
model.add(Dense(512, activation = 'linear', input_shape = (784,)))Dove, activationsi riferisce alla funzione di attivazione del layer. Può essere specificato semplicemente con il nome della funzione e il livello utilizzerà gli attivatori corrispondenti.
elu
Applica l'unità lineare esponenziale.
from keras.models import Sequential
from keras.layers import Activation, Dense
model = Sequential()
model.add(Dense(512, activation = 'elu', input_shape = (784,)))selu
Applica unità lineare esponenziale scalata.
from keras.models import Sequential
from keras.layers import Activation, Dense
model = Sequential()
model.add(Dense(512, activation = 'selu', input_shape = (784,)))relu
Applica unità lineare rettificata.
from keras.models import Sequential
from keras.layers import Activation, Dense
model = Sequential()
model.add(Dense(512, activation = 'relu', input_shape = (784,)))softmax
Applica la funzione Softmax.
from keras.models import Sequential
from keras.layers import Activation, Dense
model = Sequential()
model.add(Dense(512, activation = 'softmax', input_shape = (784,)))softplus
Applica la funzione Softplus.
from keras.models import Sequential
from keras.layers import Activation, Dense
model = Sequential()
model.add(Dense(512, activation = 'softplus', input_shape = (784,)))softsign
Applica la funzione Softsign.
from keras.models import Sequential
from keras.layers import Activation, Dense
model = Sequential()
model.add(Dense(512, activation = 'softsign', input_shape = (784,)))tanh
Applica la funzione tangente iperbolica.
from keras.models import Sequential
from keras.layers import Activation, Dense
model = Sequential()
model.add(Dense(512, activation = 'tanh', input_shape = (784,)))sigmoide
Applica la funzione Sigmoide.
from keras.models import Sequential
from keras.layers import Activation, Dense
model = Sequential()
model.add(Dense(512, activation = 'sigmoid', input_shape = (784,)))hard_sigmoid
Applica la funzione 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,)))esponenziale
Applica la funzione esponenziale.
from keras.models import Sequential
from keras.layers import Activation, Dense
model = Sequential()
model.add(Dense(512, activation = 'exponential', input_shape = (784,)))| Suor n | Livelli e descrizione |
|---|---|
| 1 |
Strato denso Dense layer è il normale livello di rete neurale profondamente connesso. |
| 2 |
Livelli di esclusione Dropout è uno dei concetti importanti nell'apprendimento automatico. |
| 3 |
Livelli appiattiti Flatten viene utilizzato per appiattire l'input. |
| 4 |
Rimodellare i livelli Reshape viene utilizzato per modificare la forma dell'input. |
| 5 |
Permuta strati Permute è anche usato per cambiare la forma dell'input usando il pattern. |
| 6 |
Ripeti livelli vettoriali RepeatVector viene utilizzato per ripetere l'immissione per il numero impostato, n di volte. |
| 7 |
Strati Lambda Lambda viene utilizzato per trasformare i dati di input utilizzando un'espressione o una funzione. |
| 8 |
Livelli di convoluzione Keras contiene molti livelli per la creazione di ANN basata su Convolution, popolarmente chiamata Convolution Neural Network (CNN) . |
| 9 |
Livello di pooling Viene utilizzato per eseguire operazioni di pooling massimo sui dati temporali. |
| 10 |
Livello connesso localmente I livelli connessi localmente sono simili al livello Conv1D ma la differenza è che i pesi dei livelli Conv1D sono condivisi ma qui i pesi non sono condivisi. |
| 11 |
Unisci livello Viene utilizzato per unire un elenco di input. |
| 12 |
Livello di incorporamento Esegue operazioni di incorporamento nel livello di input. |