Visão computacional: detecção em tempo real com YOLOv8 e Streamlit

A Stack de processamento

• YOLOv8 (Ultralytics): O estado da arte em velocidade. Usaremos a versão Nano, que é extremamente leve e eficiente para CPUs.

• OpenCV: O motor para captura e redimensionamento inteligente de frames.

• Streamlit: A camada de apresentação, permitindo criar interfaces web reativas para dados usando apenas Python.

• Google Antigravity: Nossa IDE e ambiente de execução. Ela elimina a barreira entre o código local e o deploy, oferecendo um ambiente pré-configurado com aceleração de hardware que garante que o processamento do YOLO não "engasgue" o navegador.

Pré-requisitos e instalação

1. Requisitos de sistema

• Python 3.8 ou superior.

• Webcam: integrada ou USB (certifique-se de que outros aplicativos de vídeo estejam fechados).

2. Criando o ambiente virtual

# Criação do ambiente
python3 -m venv venv

# Ativação (Linux/macOS)
source venv/bin/activate

# Ativação (Windows)
.\venv\Scripts\activate

3. Instalando as bibliotecas

pip install --upgrade pip
pip install streamlit ultralytics opencv-python-headless

Otimização de performance e interface

1. Redimensionamento nativo: reduzimos o frame para 640x360 via OpenCV antes da inferência. Menos pixels para a IA analisar significa muito mais velocidade.

2. Layout por colunas: usamos o sistema de grades do Streamlit para limitar o tamanho visual da câmera, criando um painel lateral dedicado para métricas e controles.

Implementação Core: app.py

import streamlit as st
import cv2
from ultralytics import YOLO
import time

# 1. Configuração da Interface
st.set_page_config(page_title="AI Sentinel", layout="wide")

st.markdown("""
    <style>
    .stMetric { background-color: #161b22; border: 1px solid #30363d; padding: 10px; border-radius: 10px; }
    </style>
    """, unsafe_allow_html=True)

@st.cache_resource
def load_model():
    return YOLO('yolov8n.pt') # Modelo Nano: apenas 6MB

model = load_model()

# 2. Estrutura de Colunas (Controlando o tamanho da imagem)
st.title("🛡️ AI Sentinel: Real-Time Monitor")
st.divider()

col_cam, col_stats = st.columns([2, 1]) # Proporção 2:1 para o vídeo não dominar a tela

with col_cam:
    frame_placeholder = st.empty()

with col_stats:
    st.subheader("Métricas do Sistema")
    fps_metric = st.metric("Velocidade", "0 FPS")
    obj_metric = st.metric("Objetos", "0")
    
    st.divider()
    conf_level = st.slider("Confiança", 0.3, 1.0, 0.5)
    stop_btn = st.button("Interromper Sistema")

# 3. Loop de Captura e Inferência
cap = cv2.VideoCapture(0)
prev_time = 0

while cap.isOpened() and not stop_btn:
    ret, frame = cap.read()
    if not ret: break

    # Otimização crucial: Diminuindo a imagem para ganhar FPS
    frame_small = cv2.resize(frame, (640, 360)) 

    # Inferência YOLOv8
    results = model(frame_small, stream=True, conf=conf_level, verbose=False)

    for r in results:
        # Plotando as detecções e convertendo para RGB
        annotated_frame = r.plot()
        annotated_frame = cv2.cvtColor(annotated_frame, cv2.COLOR_BGR2RGB)
        
        # Cálculo de FPS
        curr_time = time.time()
        fps = 1 / (curr_time - prev_time)
        prev_time = curr_time

        # Renderização controlada pela largura da coluna
        frame_placeholder.image(annotated_frame, use_container_width=True)
        
        # Atualização da GUI
        fps_metric.metric("Velocidade", f"{fps:.1f} FPS")
        obj_metric.metric("Objetos", len(r.boxes))

cap.release()

O diferencial tecnológico

• use_container_width=True: garante que a imagem se ajuste perfeitamente à coluna do Streamlit, impedindo que ela estoure o layout.

• model(stream=True): utiliza geradores do Python para processar os resultados, economizando memória RAM e evitando gargalos em fluxos contínuos de vídeo.

• Redimensionamento prévio: ao reduzir a imagem no OpenCV antes de entregá-la ao YOLO, reduzimos o custo computacional exponencialmente.

Construa um projeto real com Inteligência Artificial e descubra, na prática, o poder do Desenvolvimento Agêntico.