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