En este tutorial, trabajamos en un flujo de trabajo de un extremo a otro para los modelos Qualcomm AI Hub. Comenzamos configurando el paquete requerido, descubriendo la colección de modelos disponibles y cargando MobileNet-V2 para la inferencia local de PyTorch. También manejamos un problema importante de forma de entrada al convertir los tensores de imagen NHWC al formato NCHW esperado por el modelo. A partir de ahí, ejecutamos inferencias tanto en la entrada de muestra integrada del modelo como en una imagen real, inspeccionamos las principales predicciones, ejecutamos la demostración oficial de la CLI de Qualcomm AI Hub y ampliamos el flujo de trabajo con un ejemplo de detección de objetos YOLOv7. Además, incluimos una sección opcional de dispositivo en la nube donde compilamos, perfilamos y ejecutamos el modelo en un dispositivo Qualcomm real cuando hay un token API disponible.
importar subproceso, sys, os, glob, textwrap, traceback importar numpy como np, torch desde PIL importar imagen importar matplotlib.pyplot como plt def pip_install(*pkgs): subprocess.run([sys.executable, “-m”, “pip”, “install”, “-q”, *pkgs]marcar=Verdadero) 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(valor): arr = valor[0] if isinstance(valor, (lista, tupla)) else valor t = torch.from_numpy(np.asarray(arr, dtype=np.float32)) if t.ndim == 3: t = t.unsqueeze(0) if t.ndim == 4 y t.shape[1] != 3 y forma t[-1] == 3: t = t.permute(0, 3, 1, 2).contiguo() devuelve t
Comenzamos importando bibliotecas y configurando una función auxiliar para instalar paquetes directamente dentro de Colab. Instalamos qai_hub_models, creamos un directorio de salida y deshabilitamos el seguimiento de gradiente ya que solo necesitamos inferencia. También definimos la función to_nchw() para convertir cualquier tensor de imagen de entrada al formato de canal primero esperado por el modelo.
import pkgutil, qai_hub_models.models as _m model_ids = sorted(n for _, n, p in pkgutil.iter_modules(_m.__path__) if p y no n.startswith(“_”)) print(f”>>> {len(model_ids)} modelos disponibles. Primeros 40:\n”) print(textwrap.fill(“, “.join(model_ids)[:40]), 100), “\n”) de qai_hub_models.models.mobilenet_v2 import Modelo como modelo MobileNetV2 = MobileNetV2.from_pretrained().eval() especificación = model.get_input_spec() input_name = list(spec.keys())[0]
print(“>>> Entrada:”, nombre_entrada, especificación[input_name].forma, especificación[input_name].dtype) de torchvision.models import MobileNet_V2_Weights IMAGENET_CLASSES = MobileNet_V2_Weights.IMAGENET1K_V1.meta[“categories”]
def top5(logits): si logits.ndim == 1: logits = logits.unsqueeze(0) problemas = torch.softmax(logits, dim=1)[0]
conf, idx = problemas.topk(5) retorno [(IMAGENET_CLASSES[i]float(c)) para c, i en zip(conf, idx)]
Descubrimos los paquetes de modelos de Qualcomm AI Hub disponibles e imprimimos el primer conjunto de ID de modelo para comprender a qué se puede acceder. Luego cargamos el modelo MobileNet-V2 previamente entrenado, leemos su especificación de entrada e identificamos el nombre de entrada correcto. También preparamos las etiquetas de clase ImageNet y definimos una función top5() para convertir logits del modelo en predicciones legibles de los 5 mejores.
muestra = model.sample_inputs() x = to_nchw(muestra[input_name]) print(“>>> forma del tensor alimentado:”, tuple(x.shape)) print(“\n>>> Top-5 para la entrada de muestra incorporada:”) para etiqueta, conf en top5(model(x)): print(f” {conf:6.2%} {label}”) de torchvision import transforms preprocess = transforms.Compose([
transforms.Resize(256), transforms.CenterCrop(224), transforms.ToTensor(),
]) img = Ninguno intente: 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”) excepto excepción como e: print(“>>> descarga de fotos omitida:”, e) if img no es Ninguno: preds = top5(model(preprocess(img).unsqueeze(0))) print(“\n>>> Top-5 para la foto descargada:”) para etiqueta, conf en preds: print(f” {conf:6.2%} {label}”) plt.figure(figsize=(5,5)); plt.imshow(img); plt.axis(“apagado”) plt.title(f”{preds[0][0]} ({preds[0][1]:.1%})”); plt.show()
Primero ejecutamos la inferencia usando la entrada de muestra incorporada del modelo y usamos to_nchw() para corregir la forma del tensor antes de pasarla a MobileNet-V2. Luego descargamos una imagen real, la procesamos previamente utilizando los pasos estándar de cambio de tamaño, recorte y conversión de tensor, y ejecutamos otra predicción. Finalmente mostramos la imagen con la etiqueta prevista superior para conectar visualmente la salida del modelo con la foto de entrada.
def run_demo(módulo, extra=Ninguno, tiempo de espera=900): cmd = [sys.executable, “-m”, module, “–eval-mode”, “fp”,
“–output-dir”, OUT_DIR] + (extra o []) print(f”\n>>> {‘ ‘.join(cmd)}”) prueba: r = subprocess.run(cmd, capture_output=True, text=True, timeout=timeout) print(“\n”.join((r.stdout + r.stderr).strip().splitlines()[-25:])) excepto excepción como e: print(“>>> demostración omitida:”, e) run_demo(“qai_hub_models.models.mobilenet_v2.demo”) intente: 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(“apagado”); plt.title(“Detecciones de YOLOv7”); plt.show() else: print(“>>> no se encontró ninguna imagen de salida (es posible que se hayan impreso los resultados en su lugar).”) excepto excepción: print(“>>> sección YOLOv7 omitida:\n”, traceback.format_exc())
Definimos una función run_demo() reutilizable que ejecuta demostraciones del modelo oficial de Qualcomm AI Hub desde la línea de comandos. Lo usamos para ejecutar la demostración de MobileNet-V2 y luego instalar los extras de YOLOv7 para la detección de objetos. Ejecutamos la demostración de YOLOv7, buscamos la imagen de salida generada y visualizamos las detecciones si se crea una imagen.
intente: importar qai_hub como dispositivos concentradores = hub.get_devices() print(f”\n>>> Autenticado. {len(dispositivos)} dispositivos en la nube disponibles.”) dispositivo = hub.Device(“Samsung Galaxy S24 (Familia)”) muestra = model.sample_inputs() nchw = to_nchw(muestra[input_name]) rastreado = torch.jit.trace(modelo, [nchw]) entradas_nube = {nombre_entrada: [nchw.numpy()]} cj = hub.submit_compile_job(modelo=trazado, dispositivo=dispositivo, input_specs=model.get_input_spec(), opciones=”–target_runtime tflite”) objetivo = cj.get_target_model(); print(“>>> compilado:”, cj.url) pj = hub.submit_profile_job(modelo=destino, dispositivo=dispositivo); print(“>>> perfilado:”, pj.url) ij = hub.submit_inference_job(model=target, dispositivo=dispositivo, inputs=cloud_inputs) out = ij.download_output_data() dev_logits = torch.from_numpy(np.asarray(list(out.values())[0][0])) print(“>>> Top-5 del dispositivo REAL:”) para etiqueta, conf en top5(dev_logits): print(f” {conf:6.2%} {label}”) target.download(os.path.join(OUT_DIR, “mobilenet_v2.tflite”)) print(“>>> .tflite compilado guardado en”, OUT_DIR) excepto excepción como e: print(“\n>>> Cloud (en el dispositivo) omitida: no hay ningún token API configurado.”) print(” Obtenga uno en workbench.aihub.qualcomm.com, luego:”) print(” !qai-hub configure –api_token YOUR_TOKEN”) print(” detalle:”, (str(e).splitlines() o [type(e).__name__])[0]) print(“\n>>> Tutorial completo. Salidas en:”, OUT_DIR)
Incluimos un flujo de trabajo en la nube opcional de Qualcomm AI Hub que se ejecuta solo cuando se configura un token API. Recuperamos los dispositivos en la nube disponibles, rastreamos el modelo PyTorch, lo compilamos para TFLite, lo perfilamos en un dispositivo Qualcomm y enviamos un trabajo de inferencia. Luego descargamos la salida del dispositivo, imprimimos las predicciones principales, guardamos el modelo TFLite compilado y terminamos mostrando dónde se almacenan todas las salidas del tutorial.
En conclusión, tenemos un flujo de trabajo práctico completo para utilizar los modelos Qualcomm AI Hub dentro de Colab. Aprendimos cómo cargar modelos previamente entrenados, preparar entradas correctamente, ejecutar inferencias locales, visualizar resultados de clasificación y detección y utilizar las demostraciones oficiales como puntos de referencia reproducibles. También vimos cómo el mismo modelo puede ir más allá de la ejecución local de PyTorch al canal de dispositivos en la nube de Qualcomm para compilación, creación de perfiles e inferencia de dispositivos reales. Proporciona un camino desde la simple experimentación hasta la implementación basada en hardware con Qualcomm AI Hub.
Consulte los códigos completos con Notebook aquí. Además, no dude en seguirnos en Twitter y no olvide unirse a nuestro SubReddit de más de 150.000 ML y suscribirse a nuestro boletín. ¡Esperar! estas en telegrama? Ahora también puedes unirte a nosotros en Telegram.
¿Necesita asociarse con nosotros para promocionar su repositorio de GitHub O su página principal de Hugging O su lanzamiento de producto O seminario web, etc.? Conéctate con nosotros
La publicación Un tutorial práctico de codificación sobre los modelos de centros de IA de Qualcomm para clasificación, detección de objetos e implementación basada en hardware apareció por primera vez en MarkTechPost.