O TensorFlow 2.0 alpha já foi lançado. O framework tem um impacto significativo na comunidade de deep learning. Profissionais, pesquisadores e desenvolvedores adoram a ferramenta e a adotaram como nunca. É, sem dúvida, um dos principais motores por trás do salto nas aplicações modernas com deep learning que vemos hoje. Dito isso, o TensorFlow 1.x também tem seus contras (como muitos outros frameworks). Como disse Martin Wicke (engenheiro de software do time do TensorFlow) durante o TF Dev Summit '19 -
Aprendemos muito desde a versão 1.0.
Com todas as lições aprendidas junto à ampla base de usuários, issues no GitHub, o time do TensorFlow lançou o TensorFlow 2.0 alpha com uma série de mudanças importantes para melhorar desempenho, experiência do usuário e muito mais. Ele permite prototipagem rápida e incorpora várias práticas modernas de deep learning. Neste artigo, você vai conhecer algumas dessas mudanças por meio de implementações objetivas.
Observação: as atualizações discutidas aqui são, na opinião do autor, as mais relevantes. Você vai precisar de alguma experiência prévia com TensorFlow e Keras para acompanhar o conteúdo. A seguir estão alguns recursos úteis, caso queira relembrar conceitos de TensorFlow e Keras:
Para atualizar para o TensorFlow 2.0, execute a seguinte linha de código em um Jupyter Notebook:
!pip install tensorflow==2.0.0-alpha0
A variante com GPU também pode ser instalada da mesma forma (requer CUDA previamente):
!pip install tensorflow-gpu==2.0.0-alpha0
Você encontra mais detalhes sobre o processo de instalação aqui.
Algumas das atualizações que você vai ver incluem implementações em código. Nesses casos, você vai precisar de um dataset. Para este artigo, usaremos o Adult dataset do repositório UCI.
import pandas as pd
columns =["Age","WorkClass","fnlwgt","Education","EducationNum","MaritalStatus","Occupation","Relationship","Race","Gender","CapitalGain","CapitalLoss","HoursPerWeek","NativeCountry","Income"]
data = pd.read_csv('https://archive.ics.uci.edu/ml/machine-learning-databases/adult/adult.data',
header=None,
names=columns)
data.head()Tecnologia
Age
WorkClass
fnlwgt
Education
EducationNum
MaritalStatus
Occupation
Relationship
Race
Gender
CapitalGain
CapitalLoss
HoursPerWeek
NativeCountry
Income
0
39
State-gov
77516
Bachelors
13
Never-married
Adm-clerical
Not-in-family
White
Male
2174
0
40
United-States
<=50K
1
50
Self-emp-not-inc
83311
Bachelors
13
Married-civ-spouse
Exec-managerial
Husband
White
Male
0
0
13
United-States
<=50K
2
38
Private
215646
HS-grad
9
Divorced
Handlers-cleaners
Not-in-family
White
Male
0
0
40
United-States
<=50K
3
53
Private
234721
11th
7
Married-civ-spouse
Handlers-cleaners
Husband
Black
Male
0
0
40
United-States
<=50K
4
28
Private
338409
Bachelors
13
Married-civ-spouse
Prof-specialty
Wife
Black
Female
0
0
40
Cuba
<=50K
Esse dataset representa uma tarefa de classificação binária: prever se uma pessoa ganha mais de US$ 50 mil por ano ou não, a partir de um conjunto de dados pessoais.
Vamos fazer um pré-processamento básico e depois separar os dados na proporção 80:20:
from sklearn.preprocessing import LabelEncoder
from sklearn.model_selection import train_test_split
import numpy as np
# Label Encode
le = LabelEncoder()
data = data.apply(le.fit_transform)# Segregate data features & convert into NumPy arrays
X = data.iloc[:,0:-1].values
y = data['Income'].values
# Split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=7)Tecnologia
Agora você já deve ter um ambiente funcional com TensorFlow 2.0 instalado e um dataset carregado no seu workspace. Vamos às novidades.
1. Eager execution por padrão
No TensorFlow 2.0, você não precisa mais criar uma sessão e executar o grafo computacional dentro dela. O eager execution vem ativado por padrão na versão 2.0, permitindo construir e executar modelos imediatamente. Se quiser, você pode desativá-lo assim:
tf.compat.v1.disable_eager_execution() (considerando que tensorflow foi importado como tf.)
Abaixo vai uma comparação em código que mostra essa diferença:
2. tf.function e AutoGraph
Embora o eager execution permita programação imperativa, para treino distribuído, otimização em larga escala e ambientes de produção, a execução por grafo no estilo do TensorFlow 1.x ainda tem vantagens. No TensorFlow 2.0, você mantém a execução baseada em grafo, mas de forma mais flexível. Isso é feito com tf.function e AutoGraph.
O tf.function permite definir grafos do TensorFlow com sintaxe estilo Python via AutoGraph. O AutoGraph suporta boa parte das construções Python, como if, for, while, iteradores etc. Há limitações, claro. Aqui você encontra a lista completa do que é suportado atualmente. Abaixo, um exemplo de como é simples definir um grafo do TensorFlow usando apenas um decorator.
import tensorflow as tf
# Define the forward pass@tf.functiondefsingle_layer(x, y):return tf.nn.relu(tf.matmul(x, y))# Generate random data drawn from a uniform distribution
x = tf.random.uniform((2,3))
y = tf.random.uniform((3,5))
single_layer(x, y)Tecnologia
Perceba que não foi preciso criar sessões ou placeholders para rodar a função single_layer(). Essa é uma das vantagens do tf.function. Por baixo dos panos, ele faz as otimizações necessárias para seu código rodar mais rápido.
3. tf.variable_scope não é mais necessário
No TensorFlow 1.x, para usar tf.layers como variáveis e reutilizá-las, você precisava do bloco tf.variable. No TensorFlow 2.0 isso não é mais necessário. Como o keras é a API de alto nível central no TensorFlow 2.0, todas as camadas criadas com tf.layers podem ser facilmente colocadas em uma definição tf.keras.Sequential. O código fica mais legível, e você ainda acompanha variáveis e losses.
Exemplo:
# Define the model
model = tf.keras.Sequential([
tf.keras.layers.Dropout(rate=0.2, input_shape=X_train.shape[1:]),
tf.keras.layers.Dense(units=64, activation='relu'),
tf.keras.layers.Dropout(rate=0.2),
tf.keras.layers.Dense(units=64, activation='relu'),
tf.keras.layers.Dropout(rate=0.2),
tf.keras.layers.Dense(units=1, activation='sigmoid')])# Get the output probabilities
out_probs = model(X_train.astype(np.float32), training=True)print(out_probs)Tecnologia
No exemplo acima, passamos os dados de treino pelo model apenas para obter as probabilidades brutas de saída. É só um forward pass. Você pode, claro, treinar o modelo:
Em pesquisa de machine learning e também em aplicações industriais, muitas vezes é preciso criar camadas personalizadas para casos específicos. O TensorFlow 2.0 torna isso super simples: você escreve sua própria camada e usa junto com as camadas existentes. Também dá para customizar o forward pass do seu modelo do jeito que quiser.
Para criar uma camada personalizada, a forma mais fácil é estender a classe Layer de tf.keras.layers e então defini-la. Você vai criar uma camada customizada e definir seus cálculos forward. A seguir está a saída de help(tf.keras.layers.Layer), mostrando o que é preciso especificar:
Seguindo as dicas do trecho acima, você vai:
Definir o construtor com o número de saídas
No método build(), adicionar os pesos da sua camada
Por fim, no método call(), definir o forward pass encadeando multiplicação de matrizes e relu()
classMyDenseLayer(tf.keras.layers.Layer):# Define the constructordef__init__(self, num_outputs):super(MyDenseLayer, self).__init__()
self.num_outputs = num_outputs
# Define the build function to add the weightsdefbuild(self, input_shape):
self.kernel = self.add_variable("kernel",
shape=[input_shape[-1],
self.num_outputs])# Define the forward passdefcall(self,input):
matmul = tf.matmul(input, self.kernel)return tf.nn.relu(matmul)# Initialize the layer with 10 output units
layer = MyDenseLayer(10)# Supply the input shape
layer(tf.random.uniform((10,3)))# Display the trainable parameters of the layerprint(layer.trainable_variables)Tecnologia
Você pode compor várias camadas estendendo a classe Model de tf.keras. Saiba mais sobre como compor modelos aqui.
5. Mais flexibilidade no treinamento
O TensorFlow pode usar diferenciação automática para calcular os gradientes da função de loss em relação aos parâmetros do modelo. O tf.GradientTape cria um contexto de "fita" que o TensorFlow usa para registrar os gradientes de cada operação. Para entender, vamos definir um modelo em nível mais baixo estendendo tf.keras.Model.
from tensorflow.keras import Model
classCustomModel(Model):def__init__(self):super(CustomModel, self).__init__()
self.do1 = tf.keras.layers.Dropout(rate=0.2, input_shape=(14,))
self.fc1 = tf.keras.layers.Dense(units=64, activation='relu')
self.do2 = tf.keras.layers.Dropout(rate=0.2)
self.fc2 = tf.keras.layers.Dense(units=64, activation='relu')
self.do3 = tf.keras.layers.Dropout(rate=0.2)
self.out = tf.keras.layers.Dense(units=1, activation='sigmoid')defcall(self, x):
x = self.do1(x)
x = self.fc1(x)
x = self.do2(x)
x = self.fc2(x)
x = self.do3(x)return self.out(x)
model = CustomModel()Tecnologia
Note que a topologia é exatamente a mesma do modelo definido anteriormente. Para treinar esse modelo usando diferenciação automática, você precisa definir a função de loss e o otimizador de forma diferente:
Agora, vamos definir as métricas que medem o desempenho da rede durante o treinamento. Aqui, desempenho significa loss e acurácia do modelo.
# Average the loss across the batch size within an epoch
train_loss = tf.keras.metrics.Mean(name='train_loss')
train_acc = tf.keras.metrics.BinaryAccuracy(name='train_acc')
valid_loss = tf.keras.metrics.Mean(name='test_loss')
valid_acc = tf.keras.metrics.BinaryAccuracy(name='valid_acc')Tecnologia
O tf.data oferece utilitários para construir pipelines de entrada de dados. Isso é especialmente útil quando você lida com grandes volumes.
Agora vamos definir o gerador de dados, que cria os batches durante o treino.
Agora estamos prontos para treinar o modelo usando tf.GradientTape. Primeiro, definimos um método que treina o modelo com os dados criados via tf.data.DataSet. Também vamos usar o decorator tf.function para acelerar a computação.
Treinamento e validação do modelo
# Train the model@tf.functiondefmodel_train(features, labels):# Define the GradientTape contextwith tf.GradientTape()as tape:# Get the probabilities
predictions = model(features)# Calculate the loss
loss = loss_func(labels, predictions)# Get the gradients
gradients = tape.gradient(loss, model.trainable_variables)# Update the weights
optimizer.apply_gradients(zip(gradients, model.trainable_variables))
train_loss(loss)
train_acc(labels, predictions)Tecnologia
Este exemplo foi inspirado neste guia dos autores do TensorFlow 2.0.
6. TensorFlow Datasets
Um módulo separado, chamado DataSets, é usado para trabalhar com o modelo de rede de forma elegante. Você já viu isso no exemplo anterior. Nesta seção, veremos como carregar o dataset MNIST do jeito que preferir.
Você pode instalar a biblioteca tensorflow_datasets com pip. Uma vez instalada, é só usar. Ela oferece várias funções utilitárias para montar pipelines de construção de datasets com flexibilidade. Saiba mais aqui e aqui. Agora vamos criar um pipeline de entrada de dados para carregar o MNIST.
import tensorflow_datasets as tfds
# You can fetch the DatasetBuilder class by string
mnist_builder = tfds.builder("mnist")# Download the dataset
mnist_builder.download_and_prepare()# Construct a tf.data.Dataset: train and test
ds_train, ds_test = mnist_builder.as_dataset(split=[tfds.Split.TRAIN, tfds.Split.TEST])Tecnologia
Você pode ignorar o aviso. Veja como o tensorflow_datasets organiza o pipeline de forma elegante.
# Prepare batches of 128 from the training set
ds_train = ds_train.batch(128)# Load in the dataset in the simplest way possiblefor features in ds_train:
image, label = features["image"], features["label"]Tecnologia
Agora você pode exibir a primeira imagem do conjunto carregado. Observação: o tensorflow_datasets funciona tanto em modo eager quanto com execução por grafo.
import matplotlib.pyplot as plt
%matplotlib inline
# You can convert a TensorFlow tensor just by using# .numpy()
plt.imshow(image[0].numpy().reshape(28,28), cmap=plt.cm.binary)
plt.show()Tecnologia
7. Política de mixed precision automática
A política de mixed precision foi proposta pela NVIDIA no ano passado. Você encontra o artigo original aqui. Em resumo, a ideia é usar uma mistura de meia precisão (FP16) e precisão total (FP32) para aproveitar o melhor dos dois mundos. Os resultados no treino de redes neurais muito profundas são impressionantes (em tempo e qualidade).
Se você estiver em um ambiente com GPU compatível com CUDA (por exemplo, geração Volta, Tesla T4) e tiver instalado a variante GPU do TensorFlow 2.0, pode instruir o TensorFlow a treinar em mixed precision assim:
Isso fará o casting automático das operações do grafo conforme necessário. Você deve notar um bom ganho de desempenho no seu modelo. Também é possível otimizar operações core do TensorFlow com mixed precision. Veja este artigo para saber mais.
O TensorFlow 2.0 facilita muito distribuir o treinamento em múltiplas GPUs. Isso é especialmente útil em produção, quando é preciso lidar com cargas pesadas. Basicamente, basta colocar o bloco de treinamento do seu modelo dentro de um bloco with.
A estratégia mirrored cria uma réplica por GPU e espelha as variáveis do modelo entre as GPUs. Você pode usar a estratégia assim:
with mirrored_strategy.scope():
model = tf.keras.Sequential([tf.keras.layers.Dense(1, input_shape=(1,))])
model.compile(loss='mse', optimizer='sgd')
model.fit(X_train, y_train,
validation_data=(X_test, y_test),
batch_size=128,
epochs=10)Tecnologia
Observação: o código acima só será útil se você tiver múltiplas GPUs configuradas na mesma máquina. Há várias estratégias de distribuição disponíveis. Saiba mais aqui.
9. TensorBoard dentro do Jupyter Notebook
Provavelmente a parte mais empolgante desta atualização: visualizar o treinamento diretamente no Jupyter Notebook via TensorBoard. A nova versão traz recursos como profiling de memória, visualização de dados de imagem (incluindo matriz de confusão), grafo conceitual do modelo e muito mais. Saiba mais aqui.
Nesta seção, vamos configurar o ambiente para exibir o TensorBoard dentro do Jupyter Notebook. Primeiro, carregue a extensão tensorboard.notebook:
Agora defina o callback do TensorBoard usando tf.keras.callbacks.
from datetime import datetime
import os
# Make a directory to keep the training logs
os.mkdir("logs")# Set the callback
logdir ="logs"
tensorboard_callback = tf.keras.callbacks.TensorBoard(log_dir=logdir)Tecnologia
Reconstrua o modelo usando a API Sequential do tf.keras:
# Define the model
model = tf.keras.Sequential([
tf.keras.layers.Dropout(rate=0.2, input_shape=X_train.shape[1:]),
tf.keras.layers.Dense(units=64, activation='relu'),
tf.keras.layers.Dropout(rate=0.2),
tf.keras.layers.Dense(units=64, activation='relu'),
tf.keras.layers.Dropout(rate=0.2),
tf.keras.layers.Dense(units=1, activation='sigmoid')])# Compile the model
model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])Tecnologia
Os conjuntos de treino e teste foram modificados para usos diferentes. Vale a pena separá-los novamente:
# The TensorBoard extension%tensorboard --logdir logs/# Pass the TensorBoard callback you defined
model.fit(X_train, y_train,
validation_data=(X_test, y_test),
batch_size=64,
epochs=10,
callbacks=[tensorboard_callback],
verbose=False)Tecnologia
<iframe
width="100%"
height="800"
src="http://localhost:6006"
frameborder="0"
allowfullscreen
></iframe><tensorflow.python.keras.callbacks.History at 0x7fc215b69400>Tecnologia
O dashboard do TensorBoard deve ser carregado no seu Jupyter Notebook, permitindo acompanhar as métricas de treino e validação.
10. TensorFlow para Swift
Apesar de todo o sucesso, há algo chato sobre o Python: ele é lento. Para ajudar pesquisadores, profissionais e até iniciantes, o time do TensorFlow desenvolveu uma versão para Swift. Embora ainda não esteja tão pronta para produção quanto a variante em Python, ela tem muito potencial. Swift permite interações de baixo nível e recursos avançados de compilação. Aqui você encontra tudo sobre a variante em Swift do TensorFlow. Vale também assistir esta entrevista com Jeremy Howard conduzida por Josh Gordon, em que Jeremy comenta essa direção.
O que vem a seguir?
Chegamos ao fim. A beleza do deep learning está na aplicação. Seu próximo passo é colocar em prática as ideias discutidas aqui. Esta atualização do TensorFlow é uma das mais completas e amigáveis para desenvolvedores. Recomendamos conferir esta playlist do YouTube do TensorFlow Dev Summit deste ano, com novidades sobre TensorFlow lattice, TensorFlow probability, TensorFlow lite e muito mais.
Se você quer reforçar seus conhecimentos em deep learning, confira estes cursos:
Projetos de machine learning para iniciantes, estudantes do último ano e profissionais. A lista tem projetos guiados, tutoriais e exemplos de código-fonte.
Descubra tudo o que você precisa saber sobre os tipos de modelos de aprendizado de máquina, inclusive para que eles são usados e exemplos de como implementá-los.
Compreender e implementar o otimizador Adam em Python. Com o PyTorch, você aprenderá a intuição, a matemática e as aplicações práticas do machine learning
O
TensorFlow 2.0 alphajá foi lançado. O framework tem um impacto significativo na comunidade de deep learning. Profissionais, pesquisadores e desenvolvedores adoram a ferramenta e a adotaram como nunca. É, sem dúvida, um dos principais motores por trás do salto nas aplicações modernas com deep learning que vemos hoje. Dito isso, oTensorFlow 1.xtambém tem seus contras (como muitos outros frameworks). Como disse Martin Wicke (engenheiro de software do time doTensorFlow) durante o TF Dev Summit '19 -Com todas as lições aprendidas junto à ampla base de usuários, issues no GitHub, o time do
TensorFlowlançou oTensorFlow 2.0 alphacom uma série de mudanças importantes para melhorar desempenho, experiência do usuário e muito mais. Ele permite prototipagem rápida e incorpora várias práticas modernas de deep learning. Neste artigo, você vai conhecer algumas dessas mudanças por meio de implementações objetivas.Observação: as atualizações discutidas aqui são, na opinião do autor, as mais relevantes. Você vai precisar de alguma experiência prévia com
TensorFloweKeraspara acompanhar o conteúdo. A seguir estão alguns recursos úteis, caso queira relembrar conceitos deTensorFloweKeras:Instalação e um dataset de demonstração
Para atualizar para o
TensorFlow 2.0, execute a seguinte linha de código em um Jupyter Notebook:!pip install tensorflow==2.0.0-alpha0A variante com GPU também pode ser instalada da mesma forma (requer CUDA previamente):
!pip install tensorflow-gpu==2.0.0-alpha0Você encontra mais detalhes sobre o processo de instalação aqui.
Algumas das atualizações que você vai ver incluem implementações em código. Nesses casos, você vai precisar de um dataset. Para este artigo, usaremos o Adult dataset do repositório UCI.
Esse dataset representa uma tarefa de classificação binária: prever se uma pessoa ganha mais de US$ 50 mil por ano ou não, a partir de um conjunto de dados pessoais.
Vamos fazer um pré-processamento básico e depois separar os dados na proporção 80:20:
Agora você já deve ter um ambiente funcional com
TensorFlow 2.0instalado e um dataset carregado no seu workspace. Vamos às novidades.1. Eager execution por padrão
No
TensorFlow 2.0, você não precisa mais criar uma sessão e executar o grafo computacional dentro dela. O eager execution vem ativado por padrão na versão 2.0, permitindo construir e executar modelos imediatamente. Se quiser, você pode desativá-lo assim:tf.compat.v1.disable_eager_execution()(considerando quetensorflowfoi importado comotf.)Abaixo vai uma comparação em código que mostra essa diferença:
2. tf.function e AutoGraph
Embora o eager execution permita programação imperativa, para treino distribuído, otimização em larga escala e ambientes de produção, a execução por grafo no estilo do
TensorFlow 1.xainda tem vantagens. NoTensorFlow 2.0, você mantém a execução baseada em grafo, mas de forma mais flexível. Isso é feito comtf.functioneAutoGraph.O
tf.functionpermite definir grafos doTensorFlowcom sintaxe estilo Python viaAutoGraph. OAutoGraphsuporta boa parte das construções Python, comoif,for,while,iteradoresetc. Há limitações, claro. Aqui você encontra a lista completa do que é suportado atualmente. Abaixo, um exemplo de como é simples definir um grafo doTensorFlowusando apenas umdecorator.Perceba que não foi preciso criar sessões ou placeholders para rodar a função
single_layer(). Essa é uma das vantagens dotf.function. Por baixo dos panos, ele faz as otimizações necessárias para seu código rodar mais rápido.3.
tf.variable_scopenão é mais necessárioNo
TensorFlow 1.x, para usartf.layerscomo variáveis e reutilizá-las, você precisava do blocotf.variable. NoTensorFlow 2.0isso não é mais necessário. Como okerasé a API de alto nível central noTensorFlow 2.0, todas as camadas criadas comtf.layerspodem ser facilmente colocadas em uma definiçãotf.keras.Sequential. O código fica mais legível, e você ainda acompanha variáveis e losses.Exemplo:
No exemplo acima, passamos os dados de treino pelo
modelapenas para obter as probabilidades brutas de saída. É só um forward pass. Você pode, claro, treinar o modelo:Você pode listar os parâmetros treináveis do modelo, camada por camada, assim:
4. Camadas personalizadas ficaram muito fáceis
Em pesquisa de machine learning e também em aplicações industriais, muitas vezes é preciso criar camadas personalizadas para casos específicos. O
TensorFlow 2.0torna isso super simples: você escreve sua própria camada e usa junto com as camadas existentes. Também dá para customizar o forward pass do seu modelo do jeito que quiser.Para criar uma camada personalizada, a forma mais fácil é estender a classe
Layerdetf.keras.layerse então defini-la. Você vai criar uma camada customizada e definir seus cálculos forward. A seguir está a saída dehelp(tf.keras.layers.Layer), mostrando o que é preciso especificar:Seguindo as dicas do trecho acima, você vai:
build(), adicionar os pesos da sua camadacall(), definir o forward pass encadeando multiplicação de matrizes erelu()Você pode compor várias camadas estendendo a classe
Modeldetf.keras. Saiba mais sobre como compor modelos aqui.5. Mais flexibilidade no treinamento
O
TensorFlowpode usar diferenciação automática para calcular os gradientes da função de loss em relação aos parâmetros do modelo. Otf.GradientTapecria um contexto de "fita" que oTensorFlowusa para registrar os gradientes de cada operação. Para entender, vamos definir um modelo em nível mais baixo estendendotf.keras.Model.Note que a topologia é exatamente a mesma do modelo definido anteriormente. Para treinar esse modelo usando diferenciação automática, você precisa definir a função de loss e o otimizador de forma diferente:
Agora, vamos definir as métricas que medem o desempenho da rede durante o treinamento. Aqui, desempenho significa loss e acurácia do modelo.
O
tf.dataoferece utilitários para construir pipelines de entrada de dados. Isso é especialmente útil quando você lida com grandes volumes.Agora vamos definir o gerador de dados, que cria os batches durante o treino.
Agora estamos prontos para treinar o modelo usando
tf.GradientTape. Primeiro, definimos um método que treina o modelo com os dados criados viatf.data.DataSet. Também vamos usar o decoratortf.functionpara acelerar a computação.Treinamento e validação do modelo
Use os dois métodos acima para treinar e validar o modelo por 5 épocas.
Este exemplo foi inspirado neste guia dos autores do
TensorFlow 2.0.6. TensorFlow Datasets
Um módulo separado, chamado
DataSets, é usado para trabalhar com o modelo de rede de forma elegante. Você já viu isso no exemplo anterior. Nesta seção, veremos como carregar o dataset MNIST do jeito que preferir.Você pode instalar a biblioteca
tensorflow_datasetscompip. Uma vez instalada, é só usar. Ela oferece várias funções utilitárias para montar pipelines de construção de datasets com flexibilidade. Saiba mais aqui e aqui. Agora vamos criar um pipeline de entrada de dados para carregar o MNIST.Você pode ignorar o aviso. Veja como o
tensorflow_datasetsorganiza o pipeline de forma elegante.Agora você pode exibir a primeira imagem do conjunto carregado. Observação: o
tensorflow_datasetsfunciona tanto em modo eager quanto com execução por grafo.7. Política de mixed precision automática
A política de mixed precision foi proposta pela NVIDIA no ano passado. Você encontra o artigo original aqui. Em resumo, a ideia é usar uma mistura de meia precisão (FP16) e precisão total (FP32) para aproveitar o melhor dos dois mundos. Os resultados no treino de redes neurais muito profundas são impressionantes (em tempo e qualidade).
Se você estiver em um ambiente com GPU compatível com CUDA (por exemplo, geração Volta, Tesla T4) e tiver instalado a variante GPU do
TensorFlow 2.0, pode instruir oTensorFlowa treinar em mixed precision assim:os.environ['TF_ENABLE_AUTO_MIXED_PRECISION'] = '1'Isso fará o casting automático das operações do grafo conforme necessário. Você deve notar um bom ganho de desempenho no seu modelo. Também é possível otimizar operações core do TensorFlow com mixed precision. Veja este artigo para saber mais.
Importante: esse recurso é suportado apenas no container Docker do TensorFlow da NVIDIA. Para integrar o treino de mixed precision nativamente no tf.keras, recomendo conferir este artigo. Agradeço ao Abhishek Thanki por me alertar sobre isso.
8. Treinamento distribuído
O
TensorFlow 2.0facilita muito distribuir o treinamento em múltiplas GPUs. Isso é especialmente útil em produção, quando é preciso lidar com cargas pesadas. Basicamente, basta colocar o bloco de treinamento do seu modelo dentro de um blocowith.Primeiro, defina uma estratégia de distribuição:
mirrored_strategy = tf.distribute.MirroredStrategy()A estratégia mirrored cria uma réplica por GPU e espelha as variáveis do modelo entre as GPUs. Você pode usar a estratégia assim:
Observação: o código acima só será útil se você tiver múltiplas GPUs configuradas na mesma máquina. Há várias estratégias de distribuição disponíveis. Saiba mais aqui.
9. TensorBoard dentro do Jupyter Notebook
Provavelmente a parte mais empolgante desta atualização: visualizar o treinamento diretamente no Jupyter Notebook via
TensorBoard. A nova versão traz recursos como profiling de memória, visualização de dados de imagem (incluindo matriz de confusão), grafo conceitual do modelo e muito mais. Saiba mais aqui.Nesta seção, vamos configurar o ambiente para exibir o
TensorBoarddentro do Jupyter Notebook. Primeiro, carregue a extensãotensorboard.notebook:Agora defina o callback do
TensorBoardusandotf.keras.callbacks.Reconstrua o modelo usando a API
Sequentialdotf.keras:Os conjuntos de treino e teste foram modificados para usos diferentes. Vale a pena separá-los novamente:
Tudo pronto para treinar:
O dashboard do
TensorBoarddeve ser carregado no seu Jupyter Notebook, permitindo acompanhar as métricas de treino e validação.10. TensorFlow para Swift
Apesar de todo o sucesso, há algo chato sobre o Python: ele é lento. Para ajudar pesquisadores, profissionais e até iniciantes, o time do
TensorFlowdesenvolveu uma versão para Swift. Embora ainda não esteja tão pronta para produção quanto a variante em Python, ela tem muito potencial. Swift permite interações de baixo nível e recursos avançados de compilação. Aqui você encontra tudo sobre a variante em Swift do TensorFlow. Vale também assistir esta entrevista com Jeremy Howard conduzida por Josh Gordon, em que Jeremy comenta essa direção.O que vem a seguir?
Chegamos ao fim. A beleza do deep learning está na aplicação. Seu próximo passo é colocar em prática as ideias discutidas aqui. Esta atualização do
TensorFlowé uma das mais completas e amigáveis para desenvolvedores. Recomendamos conferir esta playlist do YouTube doTensorFlowDev Summit deste ano, com novidades sobreTensorFlow lattice,TensorFlow probability,TensorFlow litee muito mais.Se você quer reforçar seus conhecimentos em deep learning, confira estes cursos:
Bons
eager_executes!