TensorFlow

TensorFlow é um framework de código aberto para aprendizado de máquina (ML) que o Google lançou em novembro de 2015 sob a licença Apache 2.0, depois que a equipe do Google Brain o desenvolveu para pesquisas e produtos internos. Programas de aprendizado profundo e outros trabalhos numéricos representam a computação como operações sobre tensores, arranjos multidimensionais de números, e o TensorFlow diferencia automaticamente essas operações, compila-as em grafos otimizados e executa os grafos em CPUs, GPUs e TPUs. Seu ecossistema cobre todo o fluxo de MLOps, do treinamento à implantação de modelos: Keras para definir modelos, TensorBoard para acompanhar experimentos, TensorFlow Serving para servir modelos em produção, TensorFlow.js para navegadores e LiteRT, anteriormente TensorFlow Lite, para celulares e dispositivos embarcados que executam IA de borda. Com o TensorFlow 2.21, em março de 2026, o Google afirmou que o trabalho futuro no TensorFlow se concentraria em segurança e correções de bugs, atualizações de dependências e contribuições da comunidade, e indicou Keras 3, JAX ou PyTorch para novos projetos de IA generativa.

Como o TensorFlow funciona#

No TensorFlow 1.x, os usuários primeiro criavam um grafo computacional estático e depois o executavam em uma sessão. O TensorFlow 2.0, lançado em 2019, tornou a execução eager o padrão, de modo que as operações são executadas imediatamente, como código Python comum, e manteve os grafos como otimização: uma função decorada com tf.function é rastreada uma vez por assinatura de entrada para gerar um grafo que TensorFlow pode otimizar, compilar com o compilador XLA e salvar no formato SavedModel para implantação sem Python. tf.GradientTape registra as operações de uma passagem direta para que TensorFlow possa calcular gradientes para retropropagação e descida do gradiente. Este código faz as duas coisas:

import tensorflow as tf

w = tf.Variable([[1.0], [-2.0]])
x = tf.constant([[3.0, 4.0]])


@tf.function  # trace the Python function into a TensorFlow graph on the first call
def loss_fn(x):
    print("Tracing")  # Python code runs only while tracing, not on every call
    return tf.reduce_sum((x @ w) ** 2)


# Record operations on a tape to compute the gradient of the loss with respect to w
with tf.GradientTape() as tape:
    loss = loss_fn(x)
gradient = tape.gradient(loss, w)

loss_fn(x)  # same input shape and dtype: reuses the traced graph without printing
print(f"loss {loss.numpy()}, gradient {gradient.numpy().ravel()}")

Ele imprime Tracing uma vez e depois loss 25.0, gradient [-30. -40.]: a segunda chamada executou o grafo em cache sem executar o corpo Python, e o gradiente de (3w₁ + 4w₂)² em w = (1, -2) é 2 × (-5) × (3, 4). Para o treinamento distribuído, as estratégias tf.distribute replicam um modelo em várias GPUs, segmentos de TPU ou máquinas.

O ecossistema TensorFlow#

• Keras: A API de alto nível para definir camadas e modelos e treiná-los com fit. Desde o TensorFlow 2.16, instalar TensorFlow instala Keras 3, que também funciona com JAX e PyTorch.
• TensorBoard: Painel para curvas de perda, métricas, histogramas e gráficos do modelo durante o treinamento. Também lê registros gravados por outras estruturas, incluindo execuções de treinamento do Ultralytics YOLO, e o TensorFlow 2.21 já não o instala como dependência.
• TensorFlow Serving: Um sistema de serviço que carrega SavedModels e responde a solicitações de previsão por gRPC ou REST, com controle de versões para a troca dinâmica de modelos.
• TFX: Uma estrutura de pipeline para aprendizado de máquina em produção que encadeia a validação de dados, o treinamento, a avaliação e o envio de um modelo aprovado para o serviço.
• TensorFlow.js: Executa e treina modelos no navegador e no Node.js, permitindo que a inferência ocorra no dispositivo do usuário sem enviar dados a um servidor.
• LiteRT: O runtime do Google no dispositivo para Android, iOS, Linux incorporado e microcontroladores, renomeado de TensorFlow Lite em setembro de 2024. Executa modelos .tflite convertidos de TensorFlow, PyTorch ou JAX, com aceleração em GPUs móveis e NPUs.

TensorFlow, PyTorch e JAX#

• PyTorch vs. TensorFlow: PyTorch prioriza a execução eager desde o início, com torch.compile adicionando a compilação de grafos. É a estrutura padrão para a maioria dos novos códigos de pesquisa e modelos de pesos abertos, enquanto o ponto forte do TensorFlow é sua pilha madura de implantação para servidores, navegadores e dispositivos móveis.
• JAX: A biblioteca do Google no estilo NumPy de transformações combináveis, grad para derivadas, jit para compilação XLA e vmap para vetorização. O Google treina seus modelos Gemini com JAX.
• Keras: Uma API de alto nível, não um mecanismo separado. O código Keras 3 funciona com TensorFlow, JAX ou PyTorch, então a definição do modelo não vincula um projeto a uma única estrutura.

Conversão de modelos para runtimes do TensorFlow#

Modelos treinados em outras estruturas chegam às ferramentas de implantação do TensorFlow por meio de conversores: onnx2tf reconstrói um grafo ONNX como um TensorFlow SavedModel, jax2tf encapsula funções JAX como funções TensorFlow, e o conversor LiteRT Torch do Google produz modelos LiteRT diretamente do PyTorch. Os modelos Ultralytics YOLO são escritos em PyTorch, e seu modo de exportação usa esses caminhos para YOLO26: format="saved_model" exporta para ONNX e converte com onnx2tf em um SavedModel para TensorFlow Serving, format="edgetpu" compila um modelo INT8 para Coral Edge TPUs, e format="litert" usa LiteRT Torch, portanto não precisa de uma instalação do TensorFlow. Este código executa a exportação SavedModel:

from ultralytics import YOLO

# Load the smallest YOLO26 detection model
model = YOLO("yolo26n.pt")

# Convert through ONNX to a TensorFlow SavedModel directory
path = model.export(format="saved_model")
print(f"SavedModel: {path}")

A exportação grava uma pasta yolo26n_saved_model, que tf.saved_model.load carrega em Python e que o próprio Ultralytics YOLO pode executar com YOLO("yolo26n_saved_model").