TensorFlow - Tarefa, Técnica e Algoritmo

Este guia ajuda na seleção adequada de abordagens de deep learning usando o TensorFlow, considerando a natureza do problema e os recursos disponíveis.

Hierarquia de Decisão no TensorFlow

Problema → Arquitetura → Implementação

1. Escolha da Tarefa Principal

Visão Computacional

Classificação de imagens, detecção de objetos, segmentação semântica

# Exemplo: Classificação de imagens
import tensorflow as tf
from tensorflow.keras.applications import ResNet50

model = ResNet50(weights='imagenet')

# Exemplo: Classificação de imagens

import tensorflow as tf

from tensorflow.keras.applications import ResNet50

model = ResNet50(weights='imagenet')

Processamento de Linguagem Natural (PLN)

Tradução automática, análise de sentimentos, geração de texto

# Exemplo: Modelo de linguagem
import tensorflow as tf
from tensorflow.keras.layers import LSTM, Embedding

model = tf.keras.Sequential([
    Embedding(vocab_size, embedding_dim),
    LSTM(128),
    tf.keras.layers.Dense(1, activation='sigmoid')
])

# Exemplo: Modelo de linguagem

import tensorflow as tf

from tensorflow.keras.layers import LSTM, Embedding

model = tf.keras.Sequential([

Embedding(vocab_size, embedding_dim),

LSTM(128),

tf.keras.layers.Dense(1, activation='sigmoid')

])

Series Temporais

Previsão de demanda, análise de tendências, forecasting

# Exemplo: Previsão de séries temporais
model = tf.keras.Sequential([
    tf.keras.layers.LSTM(50, return_sequences=True),
    tf.keras.layers.LSTM(50),
    tf.keras.layers.Dense(1)
])

# Exemplo: Previsão de séries temporais

model = tf.keras.Sequential([

tf.keras.layers.LSTM(50, return_sequences=True),

tf.keras.layers.LSTM(50),

tf.keras.layers.Dense(1)

])

2. Escolha da Técnica/Arquitetura

Redes Neurais Convolucionais (CNNs)

Aplicação: Dados com estrutura espacial (imagens, vídeos)

Vantagem: Captura padrões locais e hierárquicos

from tensorflow.keras.layers import Conv2D, MaxPooling2D

model.add(Conv2D(32, (3, 3), activation='relu'))
model.add(MaxPooling2D((2, 2)))

from tensorflow.keras.layers import Conv2D, MaxPooling2D

model.add(Conv2D(32, (3, 3), activation='relu'))

model.add(MaxPooling2D((2, 2)))

Redes Neurais Recorrentes (RNNs/LSTMs)

Aplicação: Dados sequenciais (texto, séries temporais)

Vantagem: Mantém memória de estados anteriores

from tensorflow.keras.layers import LSTM, GRU

model.add(LSTM(64, return_sequences=True))
model.add(GRU(32))

from tensorflow.keras.layers import LSTM, GRU

model.add(LSTM(64, return_sequences=True))

model.add(GRU(32))

Transformers/Attention

Aplicação: Tarefas complexas de PLN, visão computacional

Vantagem: Processamento paralelo, captura dependências de longo alcance

from transformers import TFAutoModel

model = TFAutoModel.from_pretrained("bert-base-uncased")

from transformers import TFAutoModel

model = TFAutoModel.from_pretrained("bert-base-uncased")

3. Escolha do Algoritmo de Otimização

Otimizador	Taxa de Aprendizado	Casos de Uso	Vantagens
Adam	0.001	Problemas gerais, default recomendado	Combina momentum e adaptabilidade
SGD	0.01	Quando precisa de convergência precisa	Simples, resultados interpretáveis
RMSprop	0.001	Problemas com dados esparsos	Adapta taxa por feature
Adagrad	0.01	Dados esparsos, NLP	Taxa adaptativa por parâmetro

# Exemplos de otimizadores no TensorFlow
optimizer_adam = tf.keras.optimizers.Adam(learning_rate=0.001)
optimizer_sgd = tf.keras.optimizers.SGD(learning_rate=0.01, momentum=0.9)
optimizer_rms = tf.keras.optimizers.RMSprop(learning_rate=0.001)

model.compile(optimizer=optimizer_adam, 
              loss='categorical_crossentropy', 
              metrics=['accuracy'])

# Exemplos de otimizadores no TensorFlow

optimizer_adam = tf.keras.optimizers.Adam(learning_rate=0.001)

optimizer_sgd = tf.keras.optimizers.SGD(learning_rate=0.01, momentum=0.9)

optimizer_rms = tf.keras.optimizers.RMSprop(learning_rate=0.001)

model.compile(optimizer=optimizer_adam,

loss='categorical_crossentropy',

metrics=['accuracy'])

⚡ Considerações de Função de Perda

A escolha da loss function é crucial e depende da tarefa:

Classificação binária: Binary Crossentropy
Classificação multiclasse: Categorical Crossentropy
Regressão: Mean Squared Error (MSE)
Segmentação: Dice Loss, Focal Loss

\(L_{CE} = -\sum_{i=1}^{C} y_i \log(\hat{y}_i)\)

🔧 Exemplo Completo: CNN para Classificação de Imagens

import tensorflow as tf
from tensorflow.keras import layers, models

# 1. Definir tarefa: Classificação de imagens (CIFAR-10)
# 2. Escolher técnica: CNN (adequada para dados espaciais)
# 3. Selecionar arquitetura: Sequential com camadas convolucionais

def create_cnn_model():
    model = models.Sequential([
        # Bloco convolucional 1
        layers.Conv2D(32, (3, 3), activation='relu', input_shape=(32, 32, 3)),
        layers.MaxPooling2D((2, 2)),
        
        # Bloco convolucional 2
        layers.Conv2D(64, (3, 3), activation='relu'),
        layers.MaxPooling2D((2, 2)),
        
        # Bloco convolucional 3
        layers.Conv2D(64, (3, 3), activation='relu'),
        
        # Classificador
        layers.Flatten(),
        layers.Dense(64, activation='relu'),
        layers.Dense(10, activation='softmax')  # 10 classes no CIFAR-10
    ])
    
    return model

# Criar e compilar o modelo
model = create_cnn_model()
model.compile(optimizer='adam',
              loss='sparse_categorical_crossentropy',
              metrics=['accuracy'])

# Resumo da arquitetura
model.summary()

import tensorflow as tf

from tensorflow.keras import layers, models

# 1. Definir tarefa: Classificação de imagens (CIFAR-10)

# 2. Escolher técnica: CNN (adequada para dados espaciais)

# 3. Selecionar arquitetura: Sequential com camadas convolucionais

def create_cnn_model():

model = models.Sequential([

# Bloco convolucional 1

layers.Conv2D(32, (3, 3), activation='relu', input_shape=(32, 32, 3)),

layers.MaxPooling2D((2, 2)),

# Bloco convolucional 2

layers.Conv2D(64, (3, 3), activation='relu'),

layers.MaxPooling2D((2, 2)),

# Bloco convolucional 3

layers.Conv2D(64, (3, 3), activation='relu'),

# Classificador

layers.Flatten(),

layers.Dense(64, activation='relu'),

layers.Dense(10, activation='softmax') # 10 classes no CIFAR-10

])

return model

# Criar e compilar o modelo

model = create_cnn_model()

model.compile(optimizer='adam',

loss='sparse_categorical_crossentropy',

metrics=['accuracy'])

# Resumo da arquitetura

model.summary()

⚠️ Considerações de Hardware

TensorFlow oferece diferentes opções de aceleração:

# Verificar disponibilidade de GPU
print("GPUs disponíveis:", tf.config.list_physical_devices('GPU'))

# Estrategia de distribuição para múltiplas GPUs
strategy = tf.distribute.MirroredStrategy()
with strategy.scope():
    model = create_model()  # Modelo criado dentro do escopo da estratégia

# Uso de TPU (Tensor Processing Unit)
resolver = tf.distribute.cluster_resolver.TPUClusterResolver()
tf.config.experimental_connect_to_cluster(resolver)
tf.tpu.experimental.initialize_tpu_system(resolver)

# Verificar disponibilidade de GPU

print("GPUs disponíveis:", tf.config.list_physical_devices('GPU'))

# Estrategia de distribuição para múltiplas GPUs

strategy = tf.distribute.MirroredStrategy()

with strategy.scope():

model = create_model() # Modelo criado dentro do escopo da estratégia

# Uso de TPU (Tensor Processing Unit)

resolver = tf.distribute.cluster_resolver.TPUClusterResolver()

tf.config.experimental_connect_to_cluster(resolver)

tf.tpu.experimental.initialize_tpu_system(resolver)

Referências e Práticas Recomendadas

Transfer Learning

Use modelos pré-treinados para economizar tempo e recursos:

from tensorflow.keras.applications import VGG16, EfficientNetB0

# Carregar modelo pré-treinado
base_model = EfficientNetB0(weights='imagenet', include_top=False)
base_model.trainable = False  # Congelar camadas base

from tensorflow.keras.applications import VGG16, EfficientNetB0

# Carregar modelo pré-treinado

base_model = EfficientNetB0(weights='imagenet', include_top=False)

base_model.trainable = False # Congelar camadas base

Callbacks para Treinamento

Monitoramento e controle automático do treinamento:

callbacks = [
    tf.keras.callbacks.EarlyStopping(patience=3),
    tf.keras.callbacks.ModelCheckpoint('best_model.h5'),
    tf.keras.callbacks.ReduceLROnPlateau(factor=0.5, patience=2)
]

callbacks = [

tf.keras.callbacks.EarlyStopping(patience=3),

tf.keras.callbacks.ModelCheckpoint('best_model.h5'),

tf.keras.callbacks.ReduceLROnPlateau(factor=0.5, patience=2)

]

Conclusão

No TensorFlow, a escolha adequada segue: identifique a natureza do problema (tarefa), selecione a arquitetura neural apropriada (técnica) e configure os algoritmos de otimização. Considere sempre transfer learning para economizar recursos e use callbacks para otimizar o treinamento.

Indice