Keras - camadas

Conforme aprendido anteriormente, as camadas Keras são o bloco de construção principal dos modelos Keras. Cada camada recebe informações de entrada, faz alguns cálculos e, por fim, produz as informações transformadas. A saída de uma camada fluirá para a próxima camada como sua entrada. Vamos aprender detalhes completos sobre as camadas neste capítulo.

Introdução

Uma camada Keras requer shape of the input (input_shape) para entender a estrutura dos dados de entrada, initializerpara definir o peso de cada entrada e, finalmente, ativadores para transformar a saída para torná-la não linear. No meio, as restrições restringem e especificam o intervalo no qual o peso dos dados de entrada a serem gerados e o regularizador tentará otimizar a camada (e o modelo) aplicando dinamicamente as penalidades nos pesos durante o processo de otimização.

Para resumir, a camada Keras requer os detalhes mínimos abaixo para criar uma camada completa.

  • Forma dos dados de entrada
  • Número de neurônios / unidades na camada
  • Initializers
  • Regularizers
  • Constraints
  • Activations

Vamos entender o conceito básico no próximo capítulo. Antes de entender o conceito básico, vamos criar uma camada Keras simples usando a API do modelo sequencial para ter uma ideia de como o modelo e a camada Keras funcionam.

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

Onde,

  • Line 1-5 importa os módulos necessários.

  • Line 7 cria um novo modelo usando API sequencial.

  • Line 9 cria um novo Dense camada e adicione-o ao modelo. Denseé uma camada de nível de entrada fornecida por Keras, que aceita o número de neurônios ou unidades (32) como seu parâmetro obrigatório. Se a camada for a primeira camada, precisamos fornecerInput Shape, (16,)também. Caso contrário, a saída da camada anterior será usada como entrada da próxima camada. Todos os outros parâmetros são opcionais.

    • O primeiro parâmetro representa o número de unidades (neurônios).

    • input_shape representam a forma dos dados de entrada.

    • kernel_initializer representa o inicializador a ser usado. he_uniform função é definida como valor.

    • kernel_regularizer representar regularizerser usado. Nenhum é definido como valor.

    • kernel_constraint representam a restrição a ser usada. MaxNorm função é definida como valor.

    • activationrepresentam a ativação a ser usada. a função relu é definida como valor.

  • Line 10 cria segundo Dense camada com 16 unidades e conjunto relu como a função de ativação.

  • Line 11 cria a camada Densa final com 8 unidades.

Conceito Básico de Camadas

Vamos entender o conceito básico de camada e também como Keras apóia cada conceito.

Forma de entrada

No aprendizado de máquina, todos os tipos de dados de entrada, como texto, imagens ou vídeos, serão primeiro convertidos em uma matriz de números e, em seguida, alimentados no algoritmo. Os números de entrada podem ser matriz unidimensional, matriz bidimensional (matriz) ou matriz multidimensional. Podemos especificar as informações dimensionais usandoshape, uma tupla de inteiros. Por exemplo,(4,2) representam a matriz com quatro linhas e duas colunas.

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

Similarmente, (3,4,2) matriz tridimensional com três coleções de matriz 4x2 (duas linhas e quatro colunas).

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

Para criar a primeira camada do modelo (ou camada de entrada do modelo), a forma dos dados de entrada deve ser especificada.

Inicializadores

No aprendizado de máquina, o peso será atribuído a todos os dados de entrada. InitializersO módulo fornece diferentes funções para definir esses pesos iniciais. Alguns dosKeras Initializer função são as seguintes -

Zeros

Gera 0 para todos os dados de entrada.

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

Onde, kernel_initializer representam o inicializador para o kernel do modelo.

uns

Gera 1 para todos os dados de entrada.

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

Constante

Gera um valor constante (digamos, 5) especificado pelo usuário para todos os dados de entrada.

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

Onde, value representam o valor constante

RandomNormal

Gera valor usando distribuição normal de dados de entrada.

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

Onde,

  • mean representam a média dos valores aleatórios para gerar

  • stddev representam o desvio padrão dos valores aleatórios para gerar

  • seed representam os valores para gerar um número aleatório

RandomUniform

Gera valor usando distribuição uniforme de dados de entrada.

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

Onde,

  • minval representam o limite inferior dos valores aleatórios para gerar

  • maxval representam o limite superior dos valores aleatórios para gerar

TruncatedNormal

Gera valor usando distribuição normal truncada de dados de entrada.

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

Gera valor com base na forma de entrada e forma de saída da camada junto com a escala especificada.

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

Onde,

  • scale representam o fator de escala

  • mode representar qualquer um de fan_in, fan_out e fan_avg valores

  • distribution representar qualquer um dos normal ou uniform

VarianceScaling

Encontra o stddev valor para a distribuição normal usando a fórmula abaixo e, em seguida, encontre os pesos usando a distribuição normal,

stddev = sqrt(scale / n)

Onde n representar,

  • número de unidades de entrada para modo = fan_in

  • número de unidades externas para modo = fan_out

  • número médio de unidades de entrada e saída para modo = fan_avg

Da mesma forma, ele encontra o limite para distribuição uniforme usando a fórmula abaixo e, em seguida, encontra os pesos usando distribuição uniforme,

limit = sqrt(3 * scale / n)

lecun_normal

Gera valor usando a distribuição normal lecun de dados de entrada.

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

Encontra o stddev usando a fórmula abaixo e, em seguida, aplique a distribuição normal

stddev = sqrt(1 / fan_in)

Onde, fan_in representam o número de unidades de entrada.

lecun_uniform

Gera valor usando distribuição uniforme lecun de dados de entrada.

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

Encontra o limit usando a fórmula abaixo e, em seguida, aplique a distribuição uniforme

limit = sqrt(3 / fan_in)

Onde,

  • fan_in representa o número de unidades de entrada

  • fan_out representa o número de unidades de produção

glorot_normal

Gera valor usando distribuição normal glorot de dados de entrada.

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

Encontra o stddev usando a fórmula abaixo e, em seguida, aplique a distribuição normal

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

Onde,

  • fan_in representa o número de unidades de entrada

  • fan_out representa o número de unidades de produção

glorot_uniform

Gera valor usando a distribuição uniforme glorot de dados de entrada.

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

Encontra o limit usando a fórmula abaixo e, em seguida, aplique a distribuição uniforme

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

Onde,

  • fan_in representam o número de unidades de entrada.

  • fan_out representa o número de unidades de produção

he_normal

Gera valor usando a distribuição normal de dados de entrada.

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

Ele encontra o stddev usando a fórmula abaixo e, em seguida, aplica a distribuição normal.

stddev = sqrt(2 / fan_in)

Onde, fan_in representam o número de unidades de entrada.

he_uniforme

Gera valor usando a distribuição uniforme de dados de entrada.

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

Encontra o limit usando a fórmula abaixo e, em seguida, aplique uma distribuição uniforme.

limit = sqrt(6 / fan_in)

Onde, fan_in representam o número de unidades de entrada.

Ortogonal

Gera uma matriz ortogonal aleatória.

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

Onde, gain representam o fator de multiplicação da matriz.

Identidade

Gera matriz de identidade.

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

Restrições

No aprendizado de máquina, uma restrição será definida no parâmetro (peso) durante a fase de otimização. <> O módulo de restrições fornece diferentes funções para definir a restrição na camada. Algumas das funções de restrição são as seguintes.

NonNeg

Limita os pesos a não negativos.

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

Onde, kernel_constraint representam a restrição a ser usada na camada.

UnitNorm

Limita os pesos para serem norma unitária.

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

Limita o peso à norma menor ou igual ao valor fornecido.

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

Onde,

  • max_value representam o limite superior

  • eixo representa a dimensão na qual a restrição a ser aplicada. por exemplo, em Forma (2,3,4) o eixo 0 denota a primeira dimensão, 1 denota a segunda dimensão e 2 denota a terceira dimensão

MinMaxNorm

Restringe os pesos para serem normais entre os valores mínimo e máximo especificados.

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

Onde, rate representam a taxa na qual a restrição de peso é aplicada.

Regularizadores

No aprendizado de máquina, os regularizadores são usados ​​na fase de otimização. Ele aplica algumas penalidades no parâmetro da camada durante a otimização. O módulo de regularização Keras fornece as funções abaixo para definir penalidades na camada. A regularização aplica-se apenas por camada.

Regularizador L1

Ele fornece regularização baseada em 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))

Onde, kernel_regularizer representam a taxa na qual a restrição de peso é aplicada.

Regularizador L2

Ele fornece regularização baseada em 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))

Regularizador L1 e L2

Ele fornece regularização baseada em 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))

Ativações

No aprendizado de máquina, a função de ativação é uma função especial usada para descobrir se um neurônio específico está ativado ou não. Basicamente, a função de ativação faz uma transformação não linear dos dados de entrada e, assim, permite que os neurônios aprendam melhor. A saída de um neurônio depende da função de ativação.

Como você lembra do conceito de percepção única, a saída de um perceptron (neurônio) é simplesmente o resultado da função de ativação, que aceita a soma de todas as entradas multiplicadas com seu peso correspondente mais o viés geral, se houver.

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

Portanto, a função de ativação desempenha um papel importante no aprendizado bem-sucedido do modelo. Keras fornece várias funções de ativação no módulo de ativação. Vamos conhecer todas as ativações disponíveis no módulo.

linear

Aplica a função Linear. Faz nada.

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

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

Onde, activationrefere-se à função de ativação da camada. Ele pode ser especificado simplesmente pelo nome da função e a camada usará os ativadores correspondentes.

elu

Aplica unidade linear exponencial.

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

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

selu

Aplica a unidade linear exponencial com escala.

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

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

relu

Aplica unidade linear retificada.

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

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

softmax

Aplica a função Softmax.

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

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

softplus

Aplica a função Softplus.

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

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

softsign

Aplica a função Softsign.

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

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

tanh

Aplica a função tangente hiperbólica.

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

sigmóide

Aplica a função 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

Aplica a função Sigmoid Hard.

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

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

exponencial

Aplica função exponencial.

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

model = Sequential() 
model.add(Dense(512, activation = 'exponential', input_shape = (784,)))
Sr. Não Camadas e descrição
1

Camada Densa

Dense layer é a camada de rede neural profundamente conectada regular.

2

Camadas de exclusão

Dropout é um dos conceitos importantes no aprendizado de máquina.

3

Camadas planas

Flatten é usado para nivelar a entrada.

4

Remodelar camadas

Reshape é usado para alterar a forma da entrada.

5

Camadas permutadas

Permute também é usado para alterar a forma da entrada usando o padrão.

6

Camadas de vetor repetido

RepeatVector é usado para repetir a entrada para o número definido, n de vezes.

7

Camadas Lambda

Lambda é usado para transformar os dados de entrada usando uma expressão ou função.

8

Camadas de Convolução

Keras contém muitas camadas para a criação de RNA baseada em convolução, popularmente chamada de Rede Neural de Convolução (CNN) .

9

Camada de pooling

Ele é usado para executar operações de pooling máximas em dados temporais.

10

Camada conectada localmente

Camadas conectadas localmente são semelhantes à camada Conv1D, mas a diferença é que os pesos das camadas Conv1D são compartilhados, mas aqui os pesos não são compartilhados.

11

Mesclar Camada

É usado para mesclar uma lista de entradas.

12

Camada de incorporação

Ele executa operações de incorporação na camada de entrada.