Keras - Couches
Comme appris précédemment, les couches Keras sont le principal élément constitutif des modèles Keras. Chaque couche reçoit des informations d'entrée, effectue des calculs et génère enfin les informations transformées. La sortie d'une couche se dirigera vers la couche suivante en tant qu'entrée. Apprenons tous les détails sur les couches dans ce chapitre.
introduction
Une couche Keras nécessite shape of the input (input_shape) pour comprendre la structure des données d'entrée, initializerpour définir le poids de chaque entrée et enfin des activateurs pour transformer la sortie pour la rendre non linéaire. Entre les deux, les contraintes restreignent et spécifient la plage dans laquelle le poids des données d'entrée à générer et le régularisateur tentera d'optimiser la couche (et le modèle) en appliquant dynamiquement les pénalités sur les poids pendant le processus d'optimisation.
Pour résumer, la couche Keras nécessite des détails inférieurs au minimum pour créer une couche complète.
- Forme des données d'entrée
- Nombre de neurones / unités dans la couche
- Initializers
- Regularizers
- Constraints
- Activations
Comprenons le concept de base dans le chapitre suivant. Avant de comprendre le concept de base, créons une couche Keras simple à l'aide de l'API de modèle séquentiel pour avoir une idée du fonctionnement du modèle et de la couche 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))où,
Line 1-5 importe les modules nécessaires.
Line 7 crée un nouveau modèle à l'aide de l'API séquentielle.
Line 9 crée un nouveau Dense couche et ajoutez-la au modèle. Denseest une couche d'entrée de gamme fournie par Keras, qui accepte le nombre de neurones ou d'unités (32) comme paramètre requis. Si la couche est la première couche, nous devons fournirInput Shape, (16,)ainsi que. Sinon, la sortie de la couche précédente sera utilisée comme entrée de la couche suivante. Tous les autres paramètres sont facultatifs.
Le premier paramètre représente le nombre d'unités (neurones).
input_shape représentent la forme des données d'entrée.
kernel_initializer représentent l'initialiseur à utiliser. he_uniform La fonction est définie comme valeur.
kernel_regularizer représenter regularizerà utiliser. Aucun n'est défini comme valeur.
kernel_constraint représentent la contrainte à utiliser. MaxNorm La fonction est définie comme valeur.
activationreprésentent l'activation à utiliser. La fonction relu est définie comme valeur.
Line 10 crée la seconde Dense couche avec 16 unités et ensemble relu comme fonction d'activation.
Line 11 crée la couche Dense finale avec 8 unités.
Concept de base des couches
Comprenons le concept de base de la couche ainsi que la manière dont Keras prend en charge chaque concept.
Forme d'entrée
Dans l'apprentissage automatique, tous les types de données d'entrée comme le texte, les images ou les vidéos seront d'abord convertis en tableau de nombres, puis alimentés dans l'algorithme. Les nombres d'entrée peuvent être un tableau unidimensionnel, un tableau bidimensionnel (matrice) ou un tableau multidimensionnel. Nous pouvons spécifier les informations dimensionnelles en utilisantshape, un tuple d'entiers. Par exemple,(4,2) représentent une matrice avec quatre lignes et deux colonnes.
>>> import numpy as np
>>> shape = (4, 2)
>>> input = np.zeros(shape)
>>> print(input)
[
[0. 0.]
[0. 0.]
[0. 0.]
[0. 0.]
]
>>>De même, (3,4,2) matrice tridimensionnelle ayant trois collections de matrice 4x2 (deux lignes et quatre colonnes).
>>> 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.]]
]
>>>Pour créer la première couche du modèle (ou la couche d'entrée du modèle), la forme des données d'entrée doit être spécifiée.
Initialiseurs
Dans le Machine Learning, le poids sera attribué à toutes les données d'entrée. InitializersLe module fournit différentes fonctions pour régler ces poids initiaux. CertainsKeras Initializer la fonction sont les suivantes -
Zéros
Génère 0 pour toutes les données d'entrée.
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))Où, kernel_initializer représentent l'initialiseur pour le noyau du modèle.
Les
Génère 1 pour toutes les données d'entrée.
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))Constant
Génère une valeur constante (disons, 5) spécifié par l'utilisateur pour toutes les données d'entrée.
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)
)où, value représente la valeur constante
AléatoireNormal
Génère de la valeur en utilisant la distribution normale des données d'entrée.
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))où,
mean représentent la moyenne des valeurs aléatoires à générer
stddev représentent l'écart type des valeurs aléatoires à générer
seed représentent les valeurs pour générer un nombre aléatoire
AléatoireUniforme
Génère de la valeur en utilisant une distribution uniforme des données d'entrée.
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))où,
minval représentent la borne inférieure des valeurs aléatoires à générer
maxval représentent la limite supérieure des valeurs aléatoires à générer
TronquéNormal
Génère une valeur à l'aide d'une distribution normale tronquée des données d'entrée.
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))VarianceÉchelle
Génère une valeur basée sur la forme d'entrée et la forme de sortie du calque avec l'échelle spécifiée.
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))où,
scale représentent le facteur d'échelle
mode représentent l'un des fan_in, fan_out et fan_avg valeurs
distribution représentent l'un ou l'autre des normal ou uniform
VarianceÉchelle
Il trouve le stddev valeur de la distribution normale en utilisant la formule ci-dessous, puis trouvez les poids en utilisant la distribution normale,
stddev = sqrt(scale / n)où n représenter,
nombre d'unités d'entrée pour mode = fan_in
nombre d'unités de sortie pour mode = fan_out
nombre moyen d'unités d'entrée et de sortie pour mode = fan_avg
De même, il trouve la limite de la distribution uniforme en utilisant la formule ci-dessous, puis les poids en utilisant une distribution uniforme,
limit = sqrt(3 * scale / n)lecun_normal
Génère de la valeur en utilisant la distribution normale lecun des données d'entrée.
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))Il trouve le stddev en utilisant la formule ci-dessous, puis appliquez la distribution normale
stddev = sqrt(1 / fan_in)où, fan_in représentent le nombre d'unités d'entrée.
lecun_uniform
Génère de la valeur en utilisant la distribution uniforme lecun des données d'entrée.
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))Il trouve le limit en utilisant la formule ci-dessous, puis appliquez une distribution uniforme
limit = sqrt(3 / fan_in)où,
fan_in représente le nombre d'unités d'entrée
fan_out représente le nombre d'unités de sortie
glorot_normal
Génère de la valeur en utilisant la distribution normale glorot des données d'entrée.
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)
)Il trouve le stddev en utilisant la formule ci-dessous, puis appliquez la distribution normale
stddev = sqrt(2 / (fan_in + fan_out))où,
fan_in représente le nombre d'unités d'entrée
fan_out représente le nombre d'unités de sortie
glorot_uniform
Génère de la valeur en utilisant une distribution uniforme glorieuse des données d'entrée.
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))Il trouve le limit en utilisant la formule ci-dessous, puis appliquez une distribution uniforme
limit = sqrt(6 / (fan_in + fan_out))où,
fan_in représentent le nombre d'unités d'entrée.
fan_out représente le nombre d'unités de sortie
il_normal
Génère de la valeur en utilisant la distribution normale des données d'entrée.
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))Il trouve le stddev en utilisant la formule ci-dessous, puis applique la distribution normale.
stddev = sqrt(2 / fan_in)où, fan_in représentent le nombre d'unités d'entrée.
il_uniforme
Génère de la valeur en utilisant la distribution uniforme des données d'entrée.
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))Il trouve le limit en utilisant la formule ci-dessous, puis appliquez une distribution uniforme.
limit = sqrt(6 / fan_in)où, fan_in représentent le nombre d'unités d'entrée.
Orthogonal
Génère une matrice orthogonale aléatoire.
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))où, gain représentent le facteur de multiplication de la matrice.
Identité
Génère une matrice d'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)
)Contraintes
En machine learning, une contrainte sera définie sur le paramètre (poids) lors de la phase d'optimisation. <> Le module Contraintes fournit différentes fonctions pour définir la contrainte sur la couche. Certaines des fonctions de contrainte sont les suivantes.
NonNeg
Oblige les pondérations à être non négatives.
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)
)où, kernel_constraint représentent la contrainte à utiliser dans le calque.
UnitNorm
Contraint les poids à être la norme unitaire.
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
Contraint le poids à la norme inférieure ou égale à la valeur donnée.
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))où,
max_value représente la limite supérieure
axis représente la dimension dans laquelle la contrainte à appliquer. Par exemple, dans l'axe de forme (2,3,4), 0 désigne la première dimension, 1 désigne la deuxième dimension et 2 la troisième dimension
MinMaxNorm
Contraint les poids à être normaux entre les valeurs minimales et maximales spécifiées.
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))où, rate représentent la vitesse à laquelle la contrainte de poids est appliquée.
Régulateurs
Dans l'apprentissage automatique, les régulariseurs sont utilisés dans la phase d'optimisation. Il applique des pénalités sur le paramètre de couche lors de l'optimisation. Le module de régularisation Keras fournit ci-dessous les fonctions permettant de définir des pénalités sur la couche. La régularisation s'applique uniquement par couche.
Régularisateur L1
Il fournit une régularisation basée sur la 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))où, kernel_regularizer représentent la vitesse à laquelle la contrainte de poids est appliquée.
Régularisateur L2
Il fournit une régularisation basée sur 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))Régulariseur L1 et L2
Il fournit une régularisation basée sur les L1 et 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))Activations
Dans l'apprentissage automatique, la fonction d'activation est une fonction spéciale utilisée pour déterminer si un neurone spécifique est activé ou non. Fondamentalement, la fonction d'activation effectue une transformation non linéaire des données d'entrée et permet ainsi aux neurones de mieux apprendre. La sortie d'un neurone dépend de la fonction d'activation.
Comme vous vous souvenez du concept de perception unique, la sortie d'un perceptron (neurone) est simplement le résultat de la fonction d'activation, qui accepte la somme de toutes les entrées multipliées par son poids correspondant plus le biais global, le cas échéant.
result = Activation(SUMOF(input * weight) + bias)Ainsi, la fonction d'activation joue un rôle important dans l'apprentissage réussi du modèle. Keras fournit de nombreuses fonctions d'activation dans le module d'activation. Apprenons toutes les activations disponibles dans le module.
linéaire
Applique la fonction linéaire. Ne fait rien.
from keras.models import Sequential
from keras.layers import Activation, Dense
model = Sequential()
model.add(Dense(512, activation = 'linear', input_shape = (784,)))Où, activationfait référence à la fonction d'activation de la couche. Il peut être spécifié simplement par le nom de la fonction et la couche utilisera les activateurs correspondants.
elu
Applique l'unité linéaire exponentielle.
from keras.models import Sequential
from keras.layers import Activation, Dense
model = Sequential()
model.add(Dense(512, activation = 'elu', input_shape = (784,)))selu
Applique l'unité linéaire exponentielle mise à l'échelle.
from keras.models import Sequential
from keras.layers import Activation, Dense
model = Sequential()
model.add(Dense(512, activation = 'selu', input_shape = (784,)))relu
Applique l'unité linéaire rectifiée.
from keras.models import Sequential
from keras.layers import Activation, Dense
model = Sequential()
model.add(Dense(512, activation = 'relu', input_shape = (784,)))softmax
Applique la fonction Softmax.
from keras.models import Sequential
from keras.layers import Activation, Dense
model = Sequential()
model.add(Dense(512, activation = 'softmax', input_shape = (784,)))softplus
Applique la fonction Softplus.
from keras.models import Sequential
from keras.layers import Activation, Dense
model = Sequential()
model.add(Dense(512, activation = 'softplus', input_shape = (784,)))softsign
Applique la fonction Softsign.
from keras.models import Sequential
from keras.layers import Activation, Dense
model = Sequential()
model.add(Dense(512, activation = 'softsign', input_shape = (784,)))tanh
Applique la fonction tangente hyperbolique.
from keras.models import Sequential
from keras.layers import Activation, Dense
model = Sequential()
model.add(Dense(512, activation = 'tanh', input_shape = (784,)))sigmoïde
Applique la fonction sigmoïde.
from keras.models import Sequential
from keras.layers import Activation, Dense
model = Sequential()
model.add(Dense(512, activation = 'sigmoid', input_shape = (784,)))hard_sigmoid
Applique la fonction 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,)))exponentiel
Applique la fonction exponentielle.
from keras.models import Sequential
from keras.layers import Activation, Dense
model = Sequential()
model.add(Dense(512, activation = 'exponential', input_shape = (784,)))| Sr. Non | Couches et description |
|---|---|
| 1 | Couche dense Dense layer est la couche régulière du réseau neuronal profondément connecté. |
| 2 | Couches d'abandon Dropout est l'un des concepts importants de l'apprentissage automatique. |
| 3 | Aplatir les couches Flatten est utilisé pour aplatir l'entrée. |
| 4 | Remodeler les calques Reshape est utilisé pour changer la forme de l'entrée. |
| 5 | Permuter les couches Permute est également utilisé pour changer la forme de l'entrée à l'aide de pattern. |
| 6 | Répéter les couches vectorielles RepeatVector est utilisé pour répéter l'entrée pour un nombre défini, n fois. |
| sept | Couches Lambda Lambda est utilisé pour transformer les données d'entrée à l'aide d'une expression ou d'une fonction. |
| 8 | Couches de convolution Keras contient de nombreuses couches pour créer un ANN basé sur la convolution, communément appelé réseau neuronal à convolution (CNN) . |
| 9 | Couche de mise en commun Il est utilisé pour effectuer des opérations de regroupement maximum sur des données temporelles. |
| dix | Couche connectée localement Les couches connectées localement sont similaires à la couche Conv1D, mais la différence est que les poids des couches Conv1D sont partagés, mais ici les poids ne sont pas partagés. |
| 11 | Fusionner le calque Il est utilisé pour fusionner une liste d'entrées. |
| 12 | Intégration de la couche Il effectue des opérations d'incorporation dans la couche d'entrée. |