Qualcomm AI: Classifique, Detecte, Otimize!

IA Turbinada no seu Bolso: O Guia Completo do Qualcomm AI Hub!

Olá, pessoal! Aqui é o Lucas Tech, e preparem-se porque hoje vamos mergulhar de cabeça em algo que vai mudar a forma como vocês veem a Inteligência Artificial rodando em dispositivos do dia a dia. Esqueça a IA "presa" na nuvem ou em máquinas super potentes! Com o Qualcomm AI Hub, a gente consegue colocar modelos de IA para rodar de um jeito absurdamente eficiente, otimizado para o hardware dos nossos celulares, drones e outros gadgets. É a performance máxima da IA no seu bolso, e eu vou te mostrar como fazer isso, na prática!

Desvendando o Qualcomm AI Hub: O Fluxo Completo

Vamos desmistificar como pegar um modelo de IA e fazer ele "conversar" direitinho com o hardware da Qualcomm. Neste guia completo, vamos desde a configuração inicial, passando pela descoberta de modelos, até a inferência local com o MobileNet-V2. Ah, e claro, vamos resolver aquela "dor de cabeça" clássica do formato dos dados de entrada (NHWC para NCHW).

Além disso, vamos rodar inferências tanto com dados de exemplo quanto com imagens reais, inspecionar as previsões e até executar as demos oficiais do Qualcomm AI Hub, incluindo um exemplo com YOLOv7 para detecção de objetos. E a cereja do bolo? Uma seção opcional onde a gente compila, otimiza e roda o modelo num dispositivo Qualcomm de verdade lá na nuvem! É a IA na prática, do começo ao fim!

Copy Code

import subprocess, sys, os, glob, textwrap, traceback
import numpy as np, torch
from PIL import Image
import matplotlib.pyplot as plt
def pip_install(*pkgs):
   subprocess.run([sys.executable, "-m", "pip", "install", "-q", *pkgs], check=True)
pip_install("qai_hub_models")
OUT_DIR = "/content/qaihm_out"; os.makedirs(OUT_DIR, exist_ok=True)
torch.set_grad_enabled(False)
def to_nchw(value):
   arr = value[0] if isinstance(value, (list, tuple)) else value
   t = torch.from_numpy(np.asarray(arr, dtype=np.float32))
   if t.ndim == 3:
       t = t.unsqueeze(0)
   if t.ndim == 4 and t.shape[1] != 3 and t.shape[-1] == 3:
       t = t.permute(0, 3, 1, 2).contiguous()
   return t

Configuração Inicial e Primeiros Passos

Beleza, galera! Pra começar com o pé direito, a gente importa as bibliotecas essenciais e cria uma funçãozinha super útil pra instalar pacotes direto no Colab. O primeiro passo é instalar o qai_hub_models – afinal, é ele que faz a mágica acontecer!

Depois, a gente organiza a casa criando um diretório pra salvar nossas saídas. Ah, e uma dica de ouro: desativamos o rastreamento de gradientes do PyTorch (torch.set_grad_enabled(False)), porque como vamos fazer só inferência, não precisamos calcular gradientes e economizamos recursos.

Por último, mas não menos importante, definimos a função to_nchw(). Ela é crucial pra garantir que qualquer tensor de imagem que a gente use esteja no formato channel-first (NCHW) que o modelo espera. Sem essa, a gente pode ter problemas!

Copy Code

import pkgutil, qai_hub_models.models as _m
model_ids = sorted(n for _, n, p in pkgutil.iter_modules(_m.__path__)
                  if p and not n.startswith("_"))
print(f">>> {len(model_ids)} models available. First 40:\n")
print(textwrap.fill(", ".join(model_ids[:40]), 100), "\n")
from qai_hub_models.models.mobilenet_v2 import Model as MobileNetV2
model = MobileNetV2.from_pretrained().eval()
spec = model.get_input_spec()
input_name = list(spec.keys())[0]
print(">>> Input:", input_name, spec[input_name].shape, spec[input_name].dtype)
from torchvision.models import MobileNet_V2_Weights
IMAGENET_CLASSES = MobileNet_V2_Weights.IMAGENET1K_V1.meta["categories"]
def top5(logits):
   if logits.ndim == 1: logits = logits.unsqueeze(0)
   probs = torch.softmax(logits, dim=1)[0]
   conf, idx = probs.topk(5)
   return [(IMAGENET_CLASSES[i], float(c)) for c, i in zip(conf, idx)]

Explorando Modelos e Preparando para Inferência

Agora sim, a parte divertida: vamos dar uma olhada no que o Qualcomm AI Hub tem a oferecer! A gente consegue listar todos os modelos disponíveis e dar uma espiadinha nos primeiros IDs para ter uma ideia do arsenal que temos em mãos.

Em seguida, carregamos o nosso velho conhecido MobileNet-V2, já pré-treinado (afinal, ninguém quer reinventar a roda, né?). É super importante entender a especificação de entrada que ele espera para garantir que nossos dados cheguem no formato certinho.

Pra deixar tudo mais fácil de entender, preparamos os rótulos das classes do ImageNet e definimos uma função top5(). Com ela, os logits brutos do modelo se transformam em previsões legíveis, mostrando as 5 principais categorias com suas respectivas confianças. Assim, a gente consegue ver o que o modelo "está pensando" de um jeito bem claro!

Copy Code

sample = model.sample_inputs()
x = to_nchw(sample[input_name])
print(">>> fed tensor shape:", tuple(x.shape))
print("\n>>> Top-5 for the built-in sample input:")
for label, conf in top5(model(x)):
   print(f"    {conf:6.2%}  {label}")
from torchvision import transforms
preprocess = transforms.Compose([
   transforms.Resize(256), transforms.CenterCrop(224), transforms.ToTensor(),
])
img = None
try:
   import urllib.request
   p = os.path.join(OUT_DIR, "input.jpg")
   urllib.request.urlretrieve(
       "https://raw.githubusercontent.com/pytorch/hub/master/images/dog.jpg", p)
   img = Image.open(p).convert("RGB")
except Exception as e:
   print(">>> photo download skipped:", e)
if img is not None:
   preds = top5(model(preprocess(img).unsqueeze(0)))
   print("\n>>> Top-5 for the downloaded photo:")
   for label, conf in preds: print(f"    {conf:6.2%}  {label}")
   plt.figure(figsize=(5,5)); plt.imshow(img); plt.axis("off")
   plt.title(f"{preds[0][0]}  ({preds[0][1]:.1%})"); plt.show()

Rodando Inferência: De Exemplos a Imagens Reais

Chegou a hora da verdade, pessoal: vamos colocar o MobileNet-V2 para trabalhar! Primeiro, a gente faz uma inferência usando um input de exemplo que já vem com o modelo. Aquele to_nchw() que a gente definiu antes entra em cena aqui para garantir que o formato do tensor esteja perfeito antes de passar para o modelo.

Depois de testar com o exemplo, que tal um desafio real? Vamos baixar uma imagem (tipo um cachorro fofo, por exemplo!) e fazer um pré-processamento padrão: redimensionar, cortar e converter para tensor. Com a imagem pronta, rodamos outra previsão!

E pra fechar com chave de ouro, a gente exibe a imagem original junto com o rótulo principal que o modelo previu. É a melhor forma de visualizar e entender o que o nosso modelo de IA está "enxergando"! Ver pra crer, né?

Copy Code

def run_demo(module, extra=None, timeout=900):
   cmd = [sys.executable, "-m", module, "--eval-mode", "fp",
          "--output-dir", OUT_DIR] + (extra or [])
   print(f"\n>>> {' '.join(cmd)}")
   try:
       r = subprocess.run(cmd, capture_output=True, text=True, timeout=timeout)
       print("\n".join((r.stdout + r.stderr).strip().splitlines()[-25:]))
   except Exception as e:
       print(">>> demo skipped:", e)
run_demo("qai_hub_models.models.mobilenet_v2.demo")
try:
   pip_install("qai_hub_models[yolov7]")
   run_demo("qai_hub_models.models.yolov7.demo")
   imgs = sorted(glob.glob(OUT_DIR + "/*.png") + glob.glob(OUT_DIR + "/*.jpg"),
                 key=os.path.getmtime)
   if imgs:
       plt.figure(figsize=(9,9)); plt.imshow(Image.open(imgs[-1]).convert("RGB"))
       plt.axis("off"); plt.title("YOLOv7 detections"); plt.show()
   else:
       print(">>> no output image found (results may have printed instead).")
except Exception:
   print(">>> YOLOv7 section skipped:\n", traceback.format_exc())

Explorando as Demos Oficiais e Detecção de Objetos com YOLOv7

Sabiam que o Qualcomm AI Hub vem com umas demos oficiais super úteis? Pra facilitar a vida, a gente criou uma função run_demo() que serve pra executar esses exemplos direto da linha de comando. É um jeito prático de ver os modelos em ação!

Primeiro, usamos essa função para rodar a demo do MobileNet-V2, o nosso modelo de classificação. Depois, para dar um "upgrade" no nosso workflow, instalamos os extras do YOLOv7, que é um modelo fera em detecção de objetos.

Com o YOLOv7 instalado, executamos a demo dele também! Se o modelo gerar uma imagem de saída com as detecções, a gente corre pra visualizar e mostrar pra vocês como ele identificou os objetos na cena. É impressionante ver a IA trabalhando!

Copy Code

try:
   import qai_hub as hub
   devices = hub.get_devices()
   print(f"\n>>> Authenticated. {len(devices)} cloud devices available.")
   device = hub.Device("Samsung Galaxy S24 (Family)")
   sample = model.sample_inputs()
   nchw = to_nchw(sample[input_name])
   traced = torch.jit.trace(model, [nchw])
   cloud_inputs = {input_name: [nchw.numpy()]}
   cj = hub.submit_compile_job(model=traced, device=device,
                               input_specs=model.get_input_spec(),
                               options="--target_runtime tflite")
   target = cj.get_target_model(); print(">>> compiled:", cj.url)
   pj = hub.submit_profile_job(model=target, device=device); print(">>> profiling:", pj.url)
   ij = hub.submit_inference_job(model=target, device=device, inputs=cloud_inputs)
   out = ij.download_output_data()
   dev_logits = torch.from_numpy(np.asarray(list(out.values())[0][0]))
   print(">>> Top-5 from the REAL device:")
   for label, conf in top5(dev_logits): print(f"    {conf:6.2%}  {label}")
   target.download(os.path.join(OUT_DIR, "mobilenet_v2.tflite"))
   print(">>> saved compiled .tflite to", OUT_DIR)
except Exception as e:
   print("\n>>> Cloud (on-device) section skipped — no API token configured.")
   print("    Get one at workbench.aihub.qualcomm.com, then:")
   print("    !qai-hub configure --api_token YOUR_TOKEN")
   print("    detail:", (str(e).splitlines() or [type(e).__name__])[0])
print("\n>>> Tutorial complete. Outputs in:", OUT_DIR)

A Cereja do Bolo: IA na Nuvem Qualcomm e Hardware Real!

E agora, pra quem quer ir além, temos a parte mais avançada (e super legal!): o workflow de nuvem do Qualcomm AI Hub. Essa seção é opcional e só roda se você tiver um token de API configurado (se não tiver, não se preocupe, te mostro como conseguir!).

Aqui, a gente dá um passo gigante: primeiro, conectamos aos dispositivos na nuvem da Qualcomm, que são hardwares reais! Em seguida, "rastreamos" nosso modelo PyTorch (o MobileNet-V2) e o compilamos para o formato TFLite, otimizado para esses dispositivos. O mais legal é que a gente pode até perfilar o modelo para ver como ele se comporta no hardware de verdade.

Depois, submetemos um trabalho de inferência para o dispositivo, baixamos a saída e mostramos as principais previsões, agora vindas direto de um hardware Qualcomm! Pra finalizar, salvamos o modelo TFLite compilado, prontinho para ser implementado. É a prova de que a sua IA pode sair do seu notebook e rodar de forma otimizada no mundo real! No final, mostramos onde todas as saídas do tutorial estão guardadas.

Conclusão da Jornada no Qualcomm AI Hub

Ufa! Que jornada incrível, não é mesmo? Chegamos ao fim de um fluxo de trabalho completo e super prático para usar os Modelos do Qualcomm AI Hub dentro do Colab. A gente aprendeu a carregar modelos pré-treinados, preparar as entradas direitinho, rodar inferência local e até visualizar os resultados de classificação e detecção de objetos.

O mais legal é que vimos como ir além da execução local em PyTorch, conectando nossos modelos à pipeline de nuvem-dispositivo da Qualcomm para compilação, perfilamento e inferência em hardware real. Isso não é pouca coisa, pessoal! Significa que a gente tem um caminho claro desde a experimentação simples até a implantação de IA otimizada para hardware, tudo isso com o Qualcomm AI Hub. É a IA saindo do laboratório e indo direto para o campo de batalha, otimizada para alta performance!

Minha Visão

Olha, como entusiasta de tecnologia, ver ferramentas como o Qualcomm AI Hub me deixa super empolgado! Por muito tempo, a IA rodando em dispositivos edge era um desafio e tanto, sempre batendo na parede da performance e do consumo de energia. Mas com essa ponte entre o software e a otimização de hardware que o Hub oferece, a gente está falando de uma nova era para a IA embarcada.

Imagina só a quantidade de aplicações que se tornam viáveis agora: carros autônomos com decisão em tempo real, drones com visão computacional super eficiente, assistentes de voz que respondem instantaneamente sem precisar da nuvem, ou até mesmo diagnósticos médicos mais rápidos em dispositivos portáteis. É a democratização da IA de alta performance, tirando ela dos data centers e colocando-a diretamente nas mãos dos usuários. Pra mim, isso é a prova de que o futuro da IA é edge e cada vez mais inteligente!

E você, quais projetos ou ideias mirabolantes você consegue imaginar rodando com essa IA turbinada e otimizada diretamente no hardware do seu dispositivo? Compartilha comigo!

Referência: Matéria Original