Machine & Deep Learning

Python TensorFlow Keras: as 9 etapas-chave para passar de zero a operacional

Python TensorFlow Keras: o essencial em um artigo — código real, diagramas e etapas concretas, trechos de um curso de 34 lições.

REHOUMA Haythem

12 Jun 2026 • 11 min read

Todo mundo pode aprender Python TensorFlow Keras — desde que siga as etapas na ordem correta. Condensamos um curso completo de 34 lições em um percurso claro, com os trechos de código mais úteis.

tl;dr

Introdução e instalação
Bases do TensorFlow
Keras Sequential API
Rede densa MLP
Redes Neurais Convolucionais

~$ cat ./parcours.md # Python TensorFlow Keras — 10 capítulos

Introdução e instalação

→ O que é deep learning ?→ Instalar TensorFlow 2.x+ 1 mais lições

Bases do TensorFlow

→ Tensores e operações→ GradientTape e autodiff+ 1 mais lições

Keras Sequential API

→ Sequential — empilhar camadas→ Compilar — optimizer, loss, metrics+ 1 mais lições

Rede densa MLP

→ Arquitetura MLP (Multi-Layer Perceptron)→ Classificação MNIST com MLP+ 1 mais lições

Redes Neurais Convolucionais

→ Convoluções e pooling→ CNN no CIFAR-10+ 2 mais lições

Redes recorrentes e NLP

→ RNN, LSTM, GRU→ Embeddings para o texto+ 2 mais lições

Transfer learning

→ Por que e quando usar transfer learning→ Fine-tuning MobileNet+ 1 mais lições

Tuning e otimização

→ Otimizadores SGD, Adam, RMSprop→ Agendamento de taxa de aprendizado+ 2 mais lições

🏁

Projeto final (+ 2 capítulos no caminho)

→ Você sai com um projeto concreto e demonstrável

Por que e quando usar transfer learning

NOTEObjetivo — Entender como reutilizar modelos pré-treinados no ImageNet para suas próprias tarefas.

A ideia

Em vez de treinar um modelo from scratch (custa dias e exige milhões de imagens), pegamos um modelo já treinado no ImageNet (1,4M imagens, 1000 classes) e o adaptamos.

Por que funciona?

TIPResultado mágico — Alcançar 95% de accuracy em 1000 imagens personalizadas em vez de 70% from scratch.

2 estratégias principais

Estratégia	Quando	Como
Feature extraction	Dataset pequeno (<1000)	Congelar a base, treinar uma cabeça
Fine-tuning	Dataset médio (1k-10k)	Descongelar as últimas camadas

Modelos pré-treinados populares

Modelo	Domínio	Tamanho
MobileNetV2 / V3	Imagens, mobile	3-5 MB
EfficientNet B0-B7	Imagens, máxima precisão	20-200 MB
ResNet50 / 152	Imagens, clássico	100-200 MB
VGG16 / 19	Imagens, vintage	500 MB+
BERT	NLP	400 MB
DistilBERT	NLP rápido	250 MB

Carregar um modelo pré-treinado

output

from tensorflow.keras.applications import MobileNetV2

base = MobileNetV2(
    input_shape=(224, 224, 3),
    include_top=False,    # remover a cabeça ImageNet
    weights="imagenet"
)
base.trainable = False     # congelar os pesos

print(base.summary())

Construir o novo modelo

output

from tensorflow.keras import models, layers

n_classes = 5   # suas classes

model = models.Sequential([
    layers.Input(shape=(224, 224, 3)),
    
    # Pré-processamento específico do modelo
    tf.keras.applications.mobilenet_v2.preprocess_input,
    
    # Base congelada
    base,
    
    # Nova cabeça
    layers.GlobalAveragePooling2D(),
    layers.Dropout(0.3),
    layers.Dense(n_classes, activation="softmax")
])

model.compile(optimizer="adam",
              loss="sparse_categorical_crossentropy",
              metrics=["accuracy"])

Pré-processamento por modelo

MobileNet	`preprocess_input` : [-1, 1]
ResNet	Média ImageNet subtraída
EfficientNet	`preprocess_input` : [0, 255]

WARNINGSempre aplicar o pré-processamento do modelo original. Sem isso, desempenho ruim.

Quando usar transfer learning

SIM

NÃO

Resumo

NOTEPara lembrar

Transfer learning = reutiliza um modelo pré-treinado
Feature extraction se poucos dados
Fine-tuning se dataset médio
Sempre aplicar o pré-processamento do modelo
tf.keras.applications = modelos prontos

Próxima etapa : Parte 2 — Fine-tuning MobileNet

O que é deep learning?

NOTEObjetivo — Entender o que distingue o deep learning do ML clássico, e quando utilizá-lo.

Definição

O deep learning é um sub-ramo do machine learning que utiliza redes neurais profundas (várias camadas ocultas) para aprender representações hierárquicas dos dados.

ML clássico vs Deep Learning

Aspecto	ML clássico	Deep Learning
Dados	Centenas a milhares	Milhares a milhões
Features	Manuais (engenharia)	Aprendidas automaticamente
Hardware	CPU suficiente	GPU/TPU recomendado
Tempo de treinamento	Segundos a minutos	Horas a dias
Interpretabilidade	Boa	Baixa (caixa preta)
Casos de uso	Tabular	Imagens, áudio, texto

Um neurônio artificial

output

# Saída = ativação(soma(pesos * entradas) + viés)
y = activation(w1*x1 + w2*x2 + ... + w_n*x_n + b)

Vários neurônios em paralelo = camada. Várias camadas = rede profunda.

Anatomia de uma rede densa

output

Input (28x28=784)
   |
   v
Camada oculta 1 (128 neurônios, ReLU)
   |
   v
Camada oculta 2 (64 neurônios, ReLU)
   |
   v
Camada de saída (10 neurônios, Softmax)
   |
   v
Probabilidades das 10 classes

Arquiteturas principais

MLP (Densa)

Tabular, classificação simples. Base do DL.

CNN (Convolucional)

Imagens. Detecta padrões locais via convoluções.

RNN / LSTM / GRU

Sequências: texto, áudio, séries temporais.

Transformers

NLP moderno (BERT, GPT). Mecanismo de atenção.

Quando usar DL?

TIPBons casos

Imagens, áudio, vídeo, texto
Muitos dados (10k+ exemplos)
Desempenho máximo buscado
Padrões complexos não lineares

WARNINGMaus casos

Dados tabulares < 10k linhas (prefira GBM)
Interpretabilidade crítica
Sem GPU disponível
Problema simples linearmente separável

TensorFlow vs PyTorch

TensorFlow / Keras	Pronto para produção, implantação fácil, mobile (TFLite)
PyTorch	Pesquisa, mais pythonic, dominante em NLP
JAX	Desempenho bruto, Google interno

Resumo

NOTEPara lembrar

DL = redes profundas que aprendem as features sozinhas
Excelente para imagens, áudio, texto
Exige GPU e muitos dados
4 famílias: MLP, CNN, RNN, Transformer
TensorFlow + Keras = pronto para produção

API FastAPI + implantação Docker

Projeto final • FastAPI • Docker • produção

NOTEObjetivo — Servir o modelo de detecção de máscaras via uma API FastAPI, empacotar em um contêiner Docker e testar em produção.

Estrutura do projeto

output

mask-api/
  â“œâ”€â”€ app/
  â”‚   â“œâ”€â”€ main.py          # FastAPI
  â”‚   â“œâ”€â”€ mask_final.keras # modelo
  â”‚   â””â”€â”€ __init__.py
  â“œâ”€â”€ requirements.txt
  â“œâ”€â”€ Dockerfile
  â””â”€â”€ README.md

requirements.txt

output

fastapi==0.109.0
uvicorn[standard]==0.27.0
tensorflow==2.16.1
pillow==10.2.0
python-multipart==0.0.6

app/main.py

output

from fastapi import FastAPI, UploadFile, File, HTTPException
from fastapi.responses import JSONResponse
import tensorflow as tf
import numpy as np
from PIL import Image
import io

app = FastAPI(title="Face Mask Detection", version="1.0")
model = tf.keras.models.load_model("app/mask_final.keras")
LABELS = ["with_mask", "without_mask"]

@app.get("/")
def root():
    return {"service": "face-mask-detection", "version": "1.0"}

@app.get("/health")
def health():
    return {"status": "ok", "model_loaded": True}

@app.post("/predict")
async def predict(file: UploadFile = File(...)):
    if file.content_type not in ["image/jpeg", "image/png"]:
        raise HTTPException(400, "Only JPEG/PNG allowed")
    
    contents = await file.read()
    img = Image.open(io.BytesIO(contents)).convert("RGB").resize((224, 224))
    arr = np.expand_dims(np.array(img), axis=0).astype("float32")
    
    proba = float(model.predict(arr, verbose=0)[0][0])
    label = LABELS[int(proba > 0.5)]
    confidence = proba if proba > 0.5 else 1 - proba
    
    return {
        "prediction": label,
        "confidence": round(confidence, 4),
        "with_mask_proba": round(1 - proba, 4),
        "without_mask_proba": round(proba, 4)
    }

Testar localmente

output

uvicorn app.main:app --host 0.0.0.0 --port 8000 --reload

# Documentação automática em http://localhost:8000/docs

# Teste curl
curl -X POST "http://localhost:8000/predict" \
     -F "file=@test.jpg"

Dockerfile

output

FROM python:3.11-slim

WORKDIR /app

COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

COPY app/ ./app/

EXPOSE 8000

HEALTHCHECK --interval=30s --timeout=10s \
    CMD curl -f http://localhost:8000/health || exit 1

CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8000"]

Build e run

output

docker build -t mask-detection:1.0 .
docker run -d -p 8000:8000 --name mask-api mask-detection:1.0

# Verificar
docker logs mask-api
curl http://localhost:8000/health

va-plus-loin

Este artigo cobre os trechos mais úteis — o curso completo Python TensorFlow Keras (10 capítulos, 34 lições, exercícios corrigidos e projeto final) leva você até o fim.

./acceder-au-cours-complet curso gratuito : Maîtriser Claude Code

FAQ

Quanto tempo para aprender Python TensorFlow Keras?

Com uma progressão estruturada (10 capítulos, 34 lições curtas e práticas), alcançamos um nível operacional em algumas semanas a 30-60 minutos por dia. O importante é praticar cada conceito imediatamente.

Precisa de pré-requisitos?

Básicos de informática bastam. Se você sabe usar um terminal e ler código simples, está pronto.

Por onde começar concretamente?

Reproduza os comandos deste artigo, depois siga o curso completo Python TensorFlow Keras: ele encadeia as 34 lições em ordem, com exercícios e projeto final.

./a-lire-aussi

→ Lance-toi en Machine Learning Débutants : ton premier pas concret aujourd'hui → Machine Learning Simplifié en pratique : le code et les commandes qui comptent vraiment → Apprentissage Automatique Python : les 9 étapes clés pour passer de zéro à opérationnel

📬 Você quer receber este tipo de guia toda semana? Inscreva-se gratuitamente — código real, zero enrolação.

Por que e quando usar transfer learning

A ideia

Por que funciona?

2 estratégias principais

Modelos pré-treinados populares

Carregar um modelo pré-treinado

Construir o novo modelo

Pré-processamento por modelo

Quando usar transfer learning

SIM

NÃO

Resumo

O que é deep learning?

Definição

ML clássico vs Deep Learning

Um neurônio artificial

Anatomia de uma rede densa

Arquiteturas principais

MLP (Densa)

CNN (Convolucional)

RNN / LSTM / GRU

Transformers

Quando usar DL?

TensorFlow vs PyTorch

Resumo

API FastAPI + implantação Docker

Estrutura do projeto

requirements.txt

app/main.py

Testar localmente

Dockerfile

Build e run

FAQ

Stay up to date