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)

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.