Tradução do guia de visão geral do Tensorflow.org. Este guia fornecerá o básico para começar a usar o Keras. A leitura leva 10 minutos.
Importar tf.keras
tf.keras é uma implementação da especificação da API TensorFlow Keras. Essa é uma API de alto nível para modelos de construção e treinamento que inclui suporte de primeira classe para funcionalidades específicas do TensorFlow, como
execução tf.data , pipelines
tf.data e
Estimadores .
tf.keras facilita o uso do TensorFlow sem sacrificar a flexibilidade e o desempenho.
Para começar, importe
tf.keras como parte da sua configuração do TensorFlow:
from __future__ import absolute_import, division, print_function, unicode_literals import tensorflow as tf from tensorflow import keras
tf.keras pode executar qualquer código compatível com Keras, mas lembre-se:
- A versão do
tf.keras na versão mais recente do TensorFlow pode ser diferente da versão mais recente do keras no PyPI. Confira tf.keras.__version__ . - Quando você salva pesos de modelo,
tf.keras faz isso por padrão no formato de ponto de verificação. Passe o save_format='h5' para usar o HDF5 (ou adicione a extensão .h5 ao .h5 do arquivo).
Construa um modelo simples
Modelo sequencial
No Keras, você coleta
camadas para criar
modelos . Um modelo é (geralmente) um gráfico de camada. O tipo mais comum de modelo é a pilha de camadas:
tf.keras.Sequential model.
Construímos uma rede simples e totalmente conectada (ou seja, um perceptron multicamada):
from tensorflow.keras import layers model = tf.keras.Sequential()
Personalizar camadas
Muitas variedades de camadas
tf.keras.layers estão
tf.keras.layers . A maioria deles usa um construtor de argumento comum:
activation : define a função de ativação para a camada. Este parâmetro especifica o nome da função interna ou do objeto chamado. O parâmetro não possui valor padrão.kernel_initializer e bias_initializer : esquemas de inicialização que criam pesos de camada (core e shift). Este parâmetro pode ser o nome ou o objeto chamado. O inicializador padrão é "Glorot uniform" .kernel_regularizer e bias_regularizer : esquemas de regularização adicionados aos pesos da camada (núcleo e deslocamento), como regularização L1 ou L2. Por padrão, a regularização não está definida.
Os seguintes exemplos de instâncias das camadas `tf.keras.layers.Dense` usam argumentos construtores:
Treinamento e avaliação
Configuração de treinamento
Após a construção do modelo, configure o processo de aprendizado chamando o método
compile :
model = tf.keras.Sequential([
tf.keras.Model.compile aceita três argumentos importantes:
optimizer : este objeto define o procedimento de treinamento. Passe instâncias do otimizador do módulo tf.keras.optimizers , como tf.keras.optimizers.Adam ou tf.keras.optimizers.SGD . Se você quiser apenas usar as opções padrão, também poderá especificar otimizadores com palavras-chave como 'adam' ou 'sgd' .loss : é uma função minimizada no processo de aprendizagem. Entre as variações comuns estão o erro padrão ( mse ), categorical_crossentropy , binary_crossentropy . As funções de perda são especificadas pelo nome ou passando o objeto chamado do módulo tf.keras.losses .metrics : usadas para monitorar o treinamento. Estes são nomes de sequência ou objetos chamados do módulo tf.keras.metrics .- Além disso, para garantir que o modelo seja treinado e avaliado com avidez, verifique se você passa o parâmetro
run_eagerly=True para o compilador
A seguir, veremos alguns exemplos de configuração de modelo para treinamento:
Aprendendo com os dados do NumPy
Para conjuntos de dados menores, use as matrizes de memória do NumPy para treinar e avaliar o modelo. O modelo é "treinado" em dados de treinamento usando o método `fit`:
import numpy as np data = np.random.random((1000, 32)) labels = np.random.random((1000, 10)) model.fit(data, labels, epochs=10, batch_size=32)
tf.keras.Model.fit usa três argumentos importantes:
epochs : o aprendizado é dividido em * épocas *. A era é uma iteração em todos os dados de entrada (isso é feito em pequenos lotes).batch_size : ao transmitir dados do NumPy, o modelo divide os dados em blocos menores (lotes) e itera sobre esses blocos durante o treinamento. Este número indica o tamanho de cada bloco de dados. Lembre-se de que o último bloco pode ser menor se o número total de registros não for dividido pelo tamanho do lote.validation_data : ao prototipar um modelo, você deseja acompanhar facilmente seu desempenho nos dados de validação. Passar uma tupla de dados e rótulos de entrada com esse argumento permite que o modelo exiba os valores da função de perda e as métricas no modo de saída para os dados transmitidos no final de cada era.
Aqui está um exemplo usando
validation_data :
import numpy as np data = np.random.random((1000, 32)) labels = np.random.random((1000, 10)) val_data = np.random.random((100, 32)) val_labels = np.random.random((100, 10)) model.fit(data, labels, epochs=10, batch_size=32, validation_data=(val_data, val_labels))
Treinamento usando conjuntos de dados tf.data
Use a API de conjuntos de dados para dimensionar grandes bancos de dados ou treinamento em vários dispositivos. Passe a instância de `tf.data.Dataset` para o método
fit :
Como o
Dataset fornece dados em lotes, esse trecho de código não requer o argumento
batch_size .
Os conjuntos de dados também podem ser usados para validar:
dataset = tf.data.Dataset.from_tensor_slices((data, labels)) dataset = dataset.batch(32) val_dataset = tf.data.Dataset.from_tensor_slices((val_data, val_labels)) val_dataset = val_dataset.batch(32) model.fit(dataset, epochs=10, validation_data=val_dataset)
Avaliação e previsão
Os
tf.keras.Model.predict e
tf.keras.Model.predict podem usar os
tf.data.Dataset NumPy e
tf.data.Dataset .
É assim que você pode
estimar as perdas no modo de saída e nas métricas para os dados fornecidos:
E aqui está como
prever a saída do último nível no modo de saída para os dados fornecidos como uma matriz NumPy:
Construindo modelos complexos
A API Funcional
O modelo
tf.keras.Sequential é uma pilha de camadas simples com a qual você não pode imaginar um modelo arbitrário. Use a API funcional Keras para criar topologias de modelo complexas, como:
- Vários modelos de entrada
- Modelos com várias saídas,
- Modelos com camadas comuns (a mesma camada é chamada várias vezes),
- Modelos com fluxos de dados inconsistentes (por exemplo, relações residuais).
A construção de um modelo com uma API funcional funciona da seguinte maneira:
- A instância da camada é passível de chamada e retorna um tensor.
- Os tensores de entrada e saída são usados para determinar a instância de
tf.keras.Model - Este modelo é treinado exatamente como o modelo `Sequencial`.
O exemplo a seguir usa a API funcional para criar uma rede simples e totalmente conectada:
inputs = tf.keras.Input(shape=(32,))
Crie uma instância do modelo com essas entradas e saídas.
model = tf.keras.Model(inputs=inputs, outputs=predictions)
Modelos de subclassificação
Crie um modelo totalmente personalizável usando a subclasse
tf.keras.Model e definindo sua própria distribuição direta. Crie camadas no método
__init__ e defina-as como atributos da instância da classe. Defina a propagação direta no método de
call .
A subclassificação de um modelo é especialmente útil quando a execução rápida é ativada, pois permite escrever imperativamente a distribuição direta.
Nota: se você deseja que seu modelo
sempre seja executado imperativamente, é possível definir
dynamic=True quando chamar o
super construtor.
Ponto principal: use a API correta para funcionar. Embora a subclasse de um modelo forneça flexibilidade, é necessário pagar por ele com maior complexidade e maior potencial para erros personalizados. Se possível, escolha a API funcional.
O exemplo a seguir mostra um modelo tf.keras.Model subclassificado usando distribuição direta customizada, que não precisa ser imperativa:
class MyModel(tf.keras.Model): def __init__(self, num_classes=10): super(MyModel, self).__init__(name='my_model') self.num_classes = num_classes
Crie uma instância da nova classe de modelo:
model = MyModel(num_classes=10)
Camadas personalizadas
Crie uma camada personalizada subclassificando
tf.keras.layers.Layer e implementando os seguintes métodos:
__init__ : especifique opcionalmente as subcamadas a serem usadas nesta camada.- *
build : Crie pesos da camada. Adicione pesos usando o método add_weight call : Defina distribuição direta.- Opcionalmente, a camada pode ser serializada implementando o método
get_config e o from_config classe from_config .
Abaixo está um exemplo de uma camada de usuário que multiplica a matriz (
matmul ) alimentada na entrada pela matriz do kernel:
class MyLayer(layers.Layer): def __init__(self, output_dim, **kwargs): self.output_dim = output_dim super(MyLayer, self).__init__(**kwargs) def build(self, input_shape):
Crie um modelo usando sua camada personalizada:
model = tf.keras.Sequential([ MyLayer(10), layers.Activation('softmax')])
Kolbeki
Kolbek é um objeto transferido para o modelo para personalizar e expandir seu comportamento durante o treinamento. Você pode gravar seu próprio retorno de chamada personalizado ou usar os
tf.keras.callbacks que incluem:
tf.keras.callbacks.ModelCheckpoint : Salvando pontos de interrupção do modelo em intervalos regulares.
tf.keras.callbacks.LearningRateScheduler : altere dinamicamente a etapa de aprendizado.
tf.keras.callbacks.EarlyStopping : Parando o treinamento quando o resultado da validação para de melhorar.
tf.keras.callbacks.TensorBoard: Monitorar o comportamento do modelo usando
Tensorboard
Para usar
tf.keras.callbacks.Callback , passe-o para o método de modelo de
fit :
callbacks = [
Salvando e restaurando
Salvando apenas valores de peso
Salve e carregue pesos do modelo usando
tf.keras.Model.save_weights :
model = tf.keras.Sequential([ layers.Dense(64, activation='relu', input_shape=(32,)), layers.Dense(10, activation='softmax')]) model.compile(optimizer=tf.keras.optimizers.Adam(0.001), loss='categorical_crossentropy', metrics=['accuracy'])
Por padrão, os pesos do modelo são salvos no formato de ponto de verificação TensorFlow. Os pesos também podem ser salvos no formato Keras HDF5 (valor padrão para a implementação universal do Keras):
Salvando apenas a configuração do modelo
A configuração do modelo pode ser salva - isso serializa a arquitetura do modelo sem nenhum peso. Uma configuração salva pode restaurar e inicializar o mesmo modelo, mesmo sem o código definindo o modelo original. O Keras suporta os formatos de serialização JSON e YAML:
import json import pprint pprint.pprint(json.loads(json_string))
Restaurando um modelo (reinicializado) do JSON:
fresh_model = tf.keras.models.model_from_json(json_string)
Serializar o modelo para YAML requer a instalação de `pyyaml`
antes de importar o TensorFlow :
yaml_string = model.to_yaml() print(yaml_string)
Restaurando um modelo do YAML:
fresh_model = tf.keras.models.model_from_yaml(yaml_string)
Nota: modelos em subclasses não são serializáveis, porque sua arquitetura é definida pelo código Python no corpo do método `call`.
Salvando o modelo inteiro em um arquivo
O modelo inteiro pode ser salvo em um arquivo que contém os valores dos pesos, a configuração do modelo e até a configuração do otimizador. Isso permitirá que você defina um ponto de interrupção do modelo e continue treinando posteriormente exatamente da mesma posição, mesmo sem acesso ao código-fonte.
# model = tf.keras.Sequential([ layers.Dense(10, activation='softmax', input_shape=(32,)), layers.Dense(10, activation='softmax') ]) model.compile(optimizer='rmsprop', loss='categorical_crossentropy', metrics=['accuracy']) model.fit(data, labels, batch_size=32, epochs=5) # HDF5 model.save('my_model.h5') # . model = tf.keras.models.load_model('my_model.h5')
Execução ansiosa
A execução ansiosa é um ambiente de programação imperativo que executa operações imediatamente. Isso não é necessário para o Keras, mas é suportado pelo
tf.keras e é útil para verificar seu programa e depurar.
Todos os modelos de construção da API `tf.keras` são compatíveis com uma execução rápida. Embora as APIs sequenciais e funcionais possam ser usadas, a execução rápida é especialmente útil ao
subclassificar um modelo e criar
camadas personalizadas - essas APIs exigem que você escreva a distribuição direta na forma de código (em vez das APIs que criam modelos montando as camadas existentes).
Distribuição
GPUs múltiplas
tf.keras modelos
tf.keras podem ser executados em várias GPUs usando
tf.distribute.Strategy . Essa API fornece aprendizado distribuído em várias GPUs com pouca ou nenhuma alteração no código existente.
Atualmente,
tf.distribute.MirroredStrategy única estratégia de distribuição suportada.
MirroredStrategy replica gráficos com
aprendizado síncrono usando redução total em uma máquina. Para usar `
distribute.Strategy , aninhe a instalação, o design e a compilação do otimizador
.scope() Strategy .scope() `e, em seguida, treine o modelo.
O exemplo a seguir distribui
tf.keras.Model entre várias GPUs na mesma máquina.
Primeiro, definimos um modelo dentro da área de uma estratégia distribuída:
strategy = tf.distribute.MirroredStrategy() with strategy.scope(): model = tf.keras.Sequential() model.add(layers.Dense(16, activation='relu', input_shape=(10,))) model.add(layers.Dense(1, activation='sigmoid')) optimizer = tf.keras.optimizers.SGD(0.2) model.compile(loss='binary_crossentropy', optimizer=optimizer) model.summary()
Em seguida, treinamos o modelo nos dados, como de costume:
x = np.random.random((1024, 10)) y = np.random.randint(2, size=(1024, 1)) x = tf.cast(x, tf.float32) dataset = tf.data.Dataset.from_tensor_slices((x, y)) dataset = dataset.shuffle(buffer_size=1024).batch(32) model.fit(dataset, epochs=1)
Após a verificação, a tradução também aparecerá no Tensorflow.org. Se você deseja participar da tradução da documentação do site Tensorflow.org para o russo, entre em contato com um comentário ou pessoal. Quaisquer correções ou comentários são apreciados.