Tio Lu

Tag: Jetson

  • Edge AI: Inteligência na Ponta dos Dedos

    Edge AI: Inteligência na Ponta dos Dedos

    Toda vez que você pergunta “E aí, Siri” ou “Alexa, que horas são”, sua voz viaja quilômetros até um datacenter, é processada por GPUs que consomem quilowatts, e a resposta volta pelo mesmo caminho. Funciona — com latência, com custo, com aquele desconforto de saber que cada palavra sua está em algum servidor que você não controla. Mas e se a inteligência artificial rodasse aí mesmo, na sua mesa, sem internet, sem nuvem, sem mensalidade? Isso é Edge AI — e em 2026, ela está mais acessível do que nunca.

    Cloud vs Edge: Por Que Isso Importa

    Quando você processa dados na nuvem, está pagando três coisas: latência (o tempo de ida e volta dos dados), banda (o volume de dados trafegando) e servidores (manutenção, energia, assinatura). No modelo Edge AI, o processamento acontece no dispositivo — um microcontrolador, um SBC como o Raspberry Pi, ou um acelerador dedicado. As vantagens são claras:

    • Latência zero de rede: classificação de imagem em 20 milissegundos, não 200 ms. Crítico para robótica, drones, veículos autônomos.
    • Privacidade: as imagens de câmeras de segurança não saem da sua rede local. A voz do assistente não viaja para datacenters. O dado fica onde foi gerado.
    • Offline-first: funciona sem internet. No campo, na fábrica, numa trilha. Seu dispositivo não vira peso de papel quando cai o WiFi.
    • Custo zero de API: sem créditos da OpenAI, sem assinatura AWS, sem taxa por inferência. O hardware se paga.

    A contrapartida é que os modelos precisam ser menores. Não dá para rodar GPT-4 num ESP32. Mas você não precisa de GPT-4 para identificar um objeto numa imagem — e é aí que o TensorFlow Lite entra.

    O Pipeline Edge AI

    O fluxo de trabalho é: treinar o modelo num PC parrudo (ou usar um modelo pré-treinado) → converter para TensorFlow Lite (.tflite) → fazer deploy no dispositivo de borda → inferência local. O TensorFlow Lite é uma versão otimizada do TensorFlow voltada para dispositivos com recursos limitados. Os modelos são quantizados — os pesos das redes neurais, originalmente em float32, são convertidos para int8, reduzindo o tamanho em 4x com perda mínima de precisão. Um modelo MobileNet V2 que ocupa 50 MB em float32 cabe em 13 MB quantizado — e roda num Pi 5 com folga.

    Hardware: O Que Usar

    O hardware para Edge AI em 2026 está num momento fascinante. Quatro opções cobrem o espectro de preço e desempenho:

    • Raspberry Pi 5 (CPU, ~R$ 700): Com seus 8 GB de RAM e CPU quad-core Cortex-A76, o Pi 5 consegue rodar inferência de classificação de imagem a 8-15 FPS usando apenas a CPU com TFLite. Suficiente para projetos que não dependem de tempo real. O gargalo é que a CPU não foi feita para multiplicação de matrizes em paralelo — a GPU VideoCore VII pode ajudar, mas o suporte do TFLite para ela ainda é experimental.
    • Google Coral USB Accelerator (~R$ 400-600): Um pendrive que contém o chip Edge TPU — um ASIC (circuito integrado de aplicação específica) feito sob medida para inferência de redes neurais. Conectado via USB 3.0 ao Pi, entrega 4 TOPS (trilhões de operações por segundo) com consumo de apenas 2,5W. Para modelos compatíveis (MobileNet, EfficientNet), a diferença é brutal: 30+ FPS vs 8 FPS na CPU do Pi. O porém é que nem todo modelo roda no Edge TPU — ele suporta apenas operações específicas, e o processo de compilação (via Edge TPU Compiler) pode ser restritivo.
    • NVIDIA Jetson Nano / Orin Nano (~R$ 1000-3000): A linha Jetson da NVIDIA é o canhão: GPU integrada com núcleos CUDA, suporte nativo ao TensorRT, capacidade de rodar modelos bem maiores (YOLOv8, Detectron2, Stable Diffusion otimizado). O Jetson Orin Nano de entrada entrega 40 TOPS. O preço e o consumo (~7-15W) são mais altos, mas se seu projeto envolve visão computacional em tempo real complexa, é a escolha.
    • Hailo-8L (~R$ 400-500): O concorrente direto do Coral, no formato de HAT (placa que encaixa no GPIO do Pi 5). Entrega 13 TOPS — mais de 3x o Coral. A Hailo tem ganhado tração no mercado de Edge AI com suporte crescente a frameworks (ONNX, TFLite via conversão). Para quem quer o máximo de desempenho no formato compacto do Raspberry Pi, é a opção mais interessante de 2026.

    Tutorial: Classificação de Imagem com MobileNet V2 + TFLite no Pi 5

    Vamos ao que interessa. Assumo que você tem um Raspberry Pi 5 com Raspberry Pi OS (64-bit) instalado e está no terminal.

    # 1. Atualize o sistema sudo apt update && sudo apt upgrade -y # 2. Instale dependências Python sudo apt install python3-pip python3-opencv -y # 3. Instale o TFLite Runtime (versão ARM64, sem GPU por enquanto) pip3 install tflite-runtime # 4. Instale Pillow e numpy pip3 install pillow numpy

    Agora baixe o modelo MobileNet V2 pré-treinado e quantizado do TensorFlow Hub:

    # 5. Baixe o modelo e o arquivo de labels wget https://tfhub.dev/google/lite-model/imagenet/mobilenet_v2_100_224/classification/5?lite-format=tflite -O mobilenet_v2.tflite wget https://storage.googleapis.com/download.tensorflow.org/models/tflite/mobilenet_v2_1.0_224_quant_labels.txt -O labels.txt

    O script de inferência (salve como classify.py):

    import cv2 import numpy as np try: from tflite_runtime.interpreter import Interpreter except: from tensorflow.lite.python.interpreter import Interpreter import time # Carrega modelo e labels interpreter = Interpreter(model_path="mobilenet_v2.tflite") interpreter.allocate_tensors() input_details = interpreter.get_input_details() output_details = interpreter.get_output_details() # Carrega labels with open("labels.txt") as f: labels = f.read().strip().split("\n") # Configura câmera (USB webcam ou módulo de câmera) cap = cv2.VideoCapture(0) cap.set(cv2.CAP_PROP_FRAME_WIDTH, 224) cap.set(cv2.CAP_PROP_FRAME_HEIGHT, 224) print("Pressione Q para sair") while True: ret, frame = cap.read() if not ret: break # Pré-processa: redimensiona para 224x224 (já feito acima), # normaliza para uint8 e adiciona dimensão do batch input_data = np.expand_dims(frame, axis=0) # Inferência start = time.time() interpreter.set_tensor(input_details[0]['index'], input_data) interpreter.invoke() output_data = interpreter.get_tensor(output_details[0]['index']) elapsed = (time.time() - start) * 1000 # Decodifica resultado (top-1) predicted_idx = np.argmax(output_data[0]) label = labels[predicted_idx] confidence = output_data[0][predicted_idx] / 255.0 # modelo quantizado # Exibe display = cv2.putText( frame.copy(), f"{label} ({confidence:.2f}) - {elapsed:.0f}ms", (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 255, 0), 2 ) cv2.imshow("Edge AI - MobileNet V2", display) if cv2.waitKey(1) & 0xFF == ord('q'): break cap.release() cv2.destroyAllWindows()

    Execute com python3 classify.py. Em segundos, você verá a câmera classificando objetos em tempo real — tudo offline, nenhum dado sai do seu Pi. No Pi 5 puro, espere ~80-120ms por frame (8-12 FPS). Com um Coral USB conectado e usando o delegate Edge TPU, isso cai para 15-30ms (30+ FPS) — mas isso é assunto para um post avançado.

    Quando Edge AI Vale a Pena (E Quando Não)

    Edge AI não substitui a nuvem — complementa. Se você precisa de um LLM completo (como o ChatGPT) para conversação complexa, ainda vai precisar da nuvem (embora modelos como o Llama 3.2 rodando quantizado no Pi 5 com Ollama estejam começando a mudar isso — mas aí é outro post). Para tarefas específicas — detecção de objetos, classificação de áudio, reconhecimento de fala, leitura de sensores com IA — o edge é imbatível.

    A pergunta certa não é “nuvem ou edge” — é “o que roda onde”. E cada vez mais, a resposta começa na sua mesa, não num datacenter a 500 km de distância.

    Fontes e Referências