Keras - Módulos

Como aprendemos anteriormente, os módulos Keras contêm classes, funções e variáveis ​​predefinidas que são úteis para algoritmos de aprendizado profundo. Vamos aprender os módulos fornecidos por Keras neste capítulo.

Módulos Disponíveis

Vamos primeiro ver a lista de módulos disponíveis no Keras.

  • Initializers- Fornece uma lista de função de inicializadores. Podemos aprender em detalhes no capítulo da camada Keras . durante a fase de criação do modelo de aprendizado de máquina.

  • Regularizers- Fornece uma lista de funções de regularizadores. Podemos aprender em detalhes no capítulo Camadas Keras .

  • Constraints- Fornece uma lista de funções de restrições. Podemos aprender em detalhes no capítulo Camadas Keras .

  • Activations- Fornece uma lista de funções ativadoras. Podemos aprender em detalhes no capítulo Camadas Keras .

  • Losses- Fornece uma lista de função de perda. Podemos aprender em detalhes no capítulo Treinamento do modelo .

  • Metrics- Fornece uma lista de funções de métricas. Podemos aprender em detalhes no capítulo Treinamento do modelo .

  • Optimizers- Fornece uma lista de funções do otimizador. Podemos aprender em detalhes no capítulo Treinamento do modelo .

  • Callback- Fornece uma lista de função de retorno de chamada. Podemos usá-lo durante o processo de treinamento para imprimir os dados intermediários, bem como para interromper o próprio treinamento (EarlyStopping método) com base em alguma condição.

  • Text processing- Fornece funções para converter texto em array NumPy adequado para aprendizado de máquina. Podemos usá-lo na fase de preparação de dados do aprendizado de máquina.

  • Image processing- Fornece funções para converter imagens em array NumPy adequado para aprendizado de máquina. Podemos usá-lo na fase de preparação de dados do aprendizado de máquina.

  • Sequence processing- Fornece funções para gerar dados baseados no tempo a partir dos dados de entrada fornecidos. Podemos usá-lo na fase de preparação de dados do aprendizado de máquina.

  • Backend- Fornece a função da biblioteca backend como TensorFlow e Theano .

  • Utilities - Fornece muitas funções utilitárias úteis no aprendizado profundo.

Deixe-nos ver backend módulo e utils modelo neste capítulo.

módulo de backend

backend moduleé usado para operações de back-end do keras. Por padrão, o keras é executado no back-end do TensorFlow. Se desejar, você pode alternar para outros back-ends, como Theano ou CNTK. A configuração do back-end Defualt é definida dentro de seu diretório raiz no arquivo .keras / keras.json.

O módulo de backend Keras pode ser importado usando o código abaixo

>>> from keras import backend as k

Se estivermos usando o TensorFlow de back-end padrão , a função abaixo retornará informações baseadas no TensorFlow, conforme especificado abaixo -

>>> k.backend() 
'tensorflow'
>>> k.epsilon() 
1e-07
>>> k.image_data_format() 
'channels_last'
>>> k.floatx() 
'float32'

Vamos entender algumas das funções de back-end significativas usadas para análise de dados em breve -

get_uid ()

É o identificador do gráfico padrão. É definido abaixo -

>>> k.get_uid(prefix='') 
1 
>>> k.get_uid(prefix='') 2

reset_uids

Ele é usado para redefinir o valor uid.

>>> k.reset_uids()

Agora, execute novamente o get_uid () . Isso será redefinido e alterado novamente para 1.

>>> k.get_uid(prefix='') 
1

placeholder

É usado para instanciar um tensor de espaço reservado. Um espaço reservado simples para manter a forma 3-D é mostrado abaixo -

>>> data = k.placeholder(shape = (1,3,3)) 
>>> data 
<tf.Tensor 'Placeholder_9:0' shape = (1, 3, 3) dtype = float32> 

If you use int_shape(), it will show the shape. 

>>> k.int_shape(data) (1, 3, 3)

ponto

É usado para multiplicar dois tensores. Considere que aeb são dois tensores e c será o resultado da multiplicação de ab. Suponha que a forma seja (4,2) e a forma b seja (2,3). É definido abaixo,

>>> a = k.placeholder(shape = (4,2)) 
>>> b = k.placeholder(shape = (2,3)) 
>>> c = k.dot(a,b) 
>>> c 
<tf.Tensor 'MatMul_3:0' shape = (4, 3) dtype = float32> 
>>>

uns

É usado para inicializar tudo como one valor.

>>> res = k.ones(shape = (2,2)) 

#print the value 

>>> k.eval(res) 
array([[1., 1.], [1., 1.]], dtype = float32)

batch_dot

É utilizado para realizar o produto de dois dados em lotes. A dimensão de entrada deve ser 2 ou superior. É mostrado abaixo -

>>> a_batch = k.ones(shape = (2,3)) 
>>> b_batch = k.ones(shape = (3,2)) 
>>> c_batch = k.batch_dot(a_batch,b_batch) 
>>> c_batch 
<tf.Tensor 'ExpandDims:0' shape = (2, 1) dtype = float32>

variável

É usado para inicializar uma variável. Vamos realizar uma operação simples de transposição nesta variável.

>>> data = k.variable([[10,20,30,40],[50,60,70,80]]) 
#variable initialized here 
>>> result = k.transpose(data) 
>>> print(result) 
Tensor("transpose_6:0", shape = (4, 2), dtype = float32) 
>>> print(k.eval(result)) 
   [[10. 50.] 
   [20. 60.] 
   [30. 70.] 
   [40. 80.]]

Se você deseja acessar de numpy -

>>> data = np.array([[10,20,30,40],[50,60,70,80]]) 

>>> print(np.transpose(data)) 
   [[10 50] 
   [20 60] 
   [30 70] 
   [40 80]] 

>>> res = k.variable(value = data) 
>>> print(res) 
<tf.Variable 'Variable_7:0' shape = (2, 4) dtype = float32_ref>

is_sparse (tensor)

É usado para verificar se o tensor é esparso ou não.

>>> a = k.placeholder((2, 2), sparse=True) 

>>> print(a) SparseTensor(indices =       
   Tensor("Placeholder_8:0", 
   shape = (?, 2), dtype = int64), 
values = Tensor("Placeholder_7:0", shape = (?,), 
dtype = float32), dense_shape = Tensor("Const:0", shape = (2,), dtype = int64)) 

>>> print(k.is_sparse(a)) True

to_dense ()

É usado para converter esparso em denso.

>>> b = k.to_dense(a) 
>>> print(b) Tensor("SparseToDense:0", shape = (2, 2), dtype = float32) 
>>> print(k.is_sparse(b)) False

random_uniform_variable

É usado para inicializar usando uniform distribution conceito.

k.random_uniform_variable(shape, mean, scale)

Aqui,

  • shape - denota as linhas e colunas no formato de tuplas.

  • mean - média de distribuição uniforme.

  • scale - desvio padrão da distribuição uniforme.

Vamos dar uma olhada no exemplo de uso abaixo -

>>> a = k.random_uniform_variable(shape = (2, 3), low=0, high = 1) 
>>> b = k. random_uniform_variable(shape = (3,2), low = 0, high = 1) 
>>> c = k.dot(a, b) 
>>> k.int_shape(c) 
(2, 2)

módulo utils

utilsfornece funções de utilitários úteis para aprendizado profundo. Alguns dos métodos fornecidos peloutils módulo é o seguinte -

HDF5Matrix

É usado para representar os dados de entrada no formato HDF5.

from keras.utils import HDF5Matrix data = HDF5Matrix('data.hdf5', 'data')

to_categorical

É usado para converter o vetor de classe em matriz de classe binária.

>>> from keras.utils import to_categorical 
>>> labels = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] 
>>> to_categorical(labels) 
array([[1., 0., 0., 0., 0., 0., 0., 0., 0., 0.], 
   [0., 1., 0., 0., 0., 0., 0., 0., 0., 0.], 
   [0., 0., 1., 0., 0., 0., 0., 0., 0., 0.], 
   [0., 0., 0., 1., 0., 0., 0., 0., 0., 0.], 
   [0., 0., 0., 0., 1., 0., 0., 0., 0., 0.], 
   [0., 0., 0., 0., 0., 1., 0., 0., 0., 0.], 
   [0., 0., 0., 0., 0., 0., 1., 0., 0., 0.], 
   [0., 0., 0., 0., 0., 0., 0., 1., 0., 0.], 
   [0., 0., 0., 0., 0., 0., 0., 0., 1., 0.], 
   [0., 0., 0., 0., 0., 0., 0., 0., 0., 1.]], dtype = float32)
>>> from keras.utils import normalize 
>>> normalize([1, 2, 3, 4, 5]) 
array([[0.13483997, 0.26967994, 0.40451992, 0.53935989, 0.67419986]])

print_summary

É usado para imprimir o resumo do modelo.

from keras.utils import print_summary print_summary(model)

plot_model

É usado para criar a representação do modelo em formato de ponto e salvá-la em um arquivo.

from keras.utils import plot_model 
plot_model(model,to_file = 'image.png')

este plot_model irá gerar uma imagem para entender o desempenho do modelo.