Gemma 4 toma decisiones autónomas con visión en Jetson Orin Nano

Gemma 4 es un asistente virtual que utiliza la tecnología de Jetson Orin Nano Super para responder preguntas mediante webcam y procesamiento de voz. Esta solución permite a Gemma decidir cuándo es necesario utilizar la cámara para proporcionar respuestas más contextualizadas.

El funcionamiento básico implica que el usuario habla, el sistema convierte el habla a texto (STT), Gemma procesa la información y, si es necesario, utiliza la webcam para obtener más contexto antes de responder utilizando un sistema de texto a voz (TTS).

Obten el código

El script completo de esta demo está disponible en GitHub, en el repositorio Google_Gemma junto a las demostraciones de Gemma 2:

github.com/asierarranz/Google_Gemma

Descárgalo utilizando uno de los siguientes comandos:

 git clone https://github.com/asierarranz/Google_Gemma.git cd Google_Gemma/Gemma4 wget https://raw.githubusercontent.com/asierarranz/Google_Gemma/main/Gemma4/Gemma4_vla.py 

El archivo Gemma4_vla.py es todo lo que necesitas. Este archivo descargará los modelos STT/TTS y los recursos de voz de Hugging Face en su primer uso.

Hardware

Los componentes utilizados en esta demo son:

• NVIDIA Jetson Orin Nano Super (8 GB)
• Cámara web Logitech C920 (micrófono incorporado)
• Altavoz USB
• Teclado USB (para presionar SPACE)

No es necesario utilizar estos dispositivos específicos, cualquier cámara web, micrófono y altavoz USB compatibles con Linux deberían funcionar.

Paso 1: Paquetes del sistema

En un Jetson nuevo, instala los paquetes básicos:

sudo apt update sudo apt install -y git build-essential cmake curl wget pkg-config python3-pip python3-venv python3-dev alsa-utils pulseaudio-utils v4l-utils psmisc ffmpeg libsndfile1 

Los paquetes build-essential y cmake son necesarios solo si eliges la opción nativa en el paso 4. Los demás son para audio, webcam y Python.

Paso 2: Entorno de Python

python3 -m venv .venv source .venv/bin/activate pip install --upgrade pip pip install opencv-python-headless onnx_asr kokoro-onnx soundfile huggingface-hub numpy 

Paso 3: Liberar RAM (opcional pero recomendado)

Es recomendable liberar RAM en el dispositivo, especialmente si se ha utilizado Docker u otras aplicaciones pesadas anteriormente. Puedes usar los siguientes comandos para ayudar:

Añadir swap

El swap no acelerará la inferencia, pero actúa como red de seguridad durante la carga del modelo:

sudo fallocate -l 8G /swapfile sudo chmod 600 /swapfile sudo mkswap /swapfile sudo swapon /swapfile echo '/swapfile none swap sw 0 0' | sudo tee -a /etc/fstab 

Eliminar procesos que consumen RAM

sudo systemctl stop docker 2>/dev/null || true sudo systemctl stop containerd 2>/dev/null || true pkill -f tracker-miner-fs-3 || true pkill -f gnome-software || true free -h 

Es recomendable cerrar pestañas del navegador y ventanas de IDE que no se necesiten. Cada MB cuenta.

¿Aún con poca RAM?

Los modelos Q4_K_M y Q4_K_S funcionan cómodamente en la placa de 8 GB después de la limpieza. Si hay otros procesos que no se pueden cerrar, puedes utilizar un modelo Q3 que es más ligero. Simplemente cambia el nombre del archivo en el paso 4:

gemma-4-E2B-it-Q3_K_M.gguf # en lugar de Q4_K_M 

Aun así, se recomienda mantener el modelo Q4_K_M si es posible.

Paso 4: Servir Gemma 4

Es necesario tener un llama-server en funcionamiento con Gemma 4 antes de lanzar la demo. Construiremos llama.cpp de manera nativa en el Jetson para obtener el mejor rendimiento y control sobre el proyector de visión que necesita la demo.

Construir llama.cpp

cd ~ git clone https://github.com/ggml-org/llama.cpp.git cd llama.cpp cmake -B build -DGGML_CUDA=ON -DCMAKE_CUDA_ARCHITECTURES="87" -DGGML_NATIVE=ON -DCMAKE_BUILD_TYPE=Release cmake --build build --config Release -j4 

Descargar el modelo y el proyector de visión

mkdir -p ~/models && cd ~/models wget -O gemma-4-E2B-it-Q4_K_M.gguf https://huggingface.co/unsloth/gemma-4-E2B-it-GGUF/resolve/main/gemma-4-E2B-it-Q4_K_M.gguf wget -O mmproj-gemma4-e2b-f16.gguf https://huggingface.co/ggml-org/gemma-4-E2B-it-GGUF/resolve/main/mmproj-gemma4-e2b-f16.gguf 

El archivo mmproj es necesario para que Gemma pueda ver, no lo omitas.

Iniciar el servidor

~/llama.cpp/build/bin/llama-server -m ~/models/gemma-4-E2B-it-Q4_K_M.gguf --mmproj ~/models/mmproj-gemma4-e2b-f16.gguf -c 2048 --image-min-tokens 70 --image-max-tokens 70 --ubatch-size 512 --batch-size 512 --host 0.0.0.0 --port 8080 -ngl 99 --flash-attn on --no-mmproj-offload --jinja -np 1 

Un flag importante es -ngl 99, que indica al llama-server que cargue todas las capas del modelo en la GPU. Si experimentas problemas de memoria, puedes reducir este número para evitar que se carguen demasiadas capas en la GPU.

Verificar que está funcionando

Desde otra terminal, verifica el funcionamiento:

curl -s http://localhost:8080/v1/chat/completions -H "Content-Type: application/json" -d '{"model":"gemma4","messages":[{"role":"user","content":"¡Hola!"}],"max_tokens":32}' | python3 -m json.tool 

Si obtienes respuesta en formato JSON, todo está en orden.

Paso 5: Encontrar tu micrófono, altavoz y webcam

Micrófono

arecord -l 

Busca tu micrófono USB. En nuestro caso, la C920 se identificó como plughw:3,0.

Altavoz

pactl list short sinks 

Esto lista tus salidas de audio. Selecciona la que coincida con tu altavoz, será un nombre largo como alsa_output.usb-....

Cámara web

v4l2-ctl --list-devices 

Generalmente, el índice será 0 (es decir, /dev/video0).

Prueba rápida

export MIC_DEVICE="plughw:3,0" export SPK_DEVICE="alsa_output.usb-Generic_USB2.0_Device_20130100ph0-00.analog-stereo" arecord -D "$MIC_DEVICE" -f S16_LE -r 16000 -c 1 -d 3 /tmp/test.wav paplay --device="$SPK_DEVICE" /tmp/test.wav 

Si te escuchas, todo está configurado correctamente.

Paso 6: Ejecutar la demo

Asegúrate de que el servidor del paso 4 esté funcionando, luego:

source .venv/bin/activate export MIC_DEVICE="plughw:3,0" export SPK_DEVICE="alsa_output.usb-Generic_USB2.0_Device_20130100ph0-00.analog-stereo" export WEBCAM=0 export VOICE="af_jessica" python3 Gemma4_vla.py 

En el primer lanzamiento, el script descargará los modelos Parakeet STT, Kokoro TTS y generará los archivos de voz. Esto puede tardar un minuto, y luego estarás listo para usarlo.

• SPACE → iniciar grabación
• habla tu pregunta
• SPACE → detener grabación

También hay un modo solo texto si deseas omitir la configuración de audio y probar directamente el modelo:

python3 Gemma4_vla.py --text 

Cambiar la voz

Kokoro ofrece varias voces. Puedes cambiarla con:

export VOICE="am_puck" python3 Gemma4_vla.py 

Algunas buenas opciones son: af_jessica, af_nova, am_puck, bf_emma, am_onyx.

Cómo funciona

El script ofrece una herramienta a Gemma 4:

{ "name": "look_and_answer", "description": "Toma una foto con la webcam y analiza lo que es visible." } 

Cuando haces una pregunta:

1. Tu voz se transcribe localmente (Parakeet STT)
2. Gemma recibe el texto y la definición de la herramienta
3. Si la pregunta requiere visión, llama a look_and_answer, el script captura un fotograma de la webcam y lo envía
4. Gemma responde y Kokoro lo vocaliza

No se utiliza coincidencia de palabras clave. El modelo decide cuándo necesita ver, lo que constituye la parte VLA.

El flag --jinja en llama-server habilita esta funcionalidad, activando el soporte nativo de llamadas a herramientas de Gemma.

Solución de problemas

El servidor se queda sin memoria, realiza nuevamente la limpieza del paso 3. Cierra todo lo que no necesites. Este modelo se adapta a 8 GB, pero es importante mantener el sistema ordenado.

Sin sonido, verifica pactl list short sinks para confirmar que SPK_DEVICE coincida con una salida real.

El micrófono graba silencio, revisa nuevamente con arecord -l y prueba grabar manualmente.

La primera ejecución es lenta, esto es normal. Está descargando modelos y generando archivos de voz. La segunda ejecución será más rápida.

Variables de entorno

Bonus: ¿solo quieres probar Gemma 4 en modo texto?

Si solo deseas experimentar con Gemma 4 en tu Jetson sin compilar nada, hay una imagen de Docker lista para usar desde Jetson AI Lab con llama.cpp precompilado para Orin:

sudo docker run -it --rm --pull always --runtime=nvidia --network host -v $HOME/.cache/huggingface:/root/.cache/huggingface ghcr.io/nvidia-ai-iot/llama_cpp:latest-jetson-orin llama-server -hf unsloth/gemma-4-E2B-it-GGUF:Q4_K_S 

Con un solo comando, sin compilación, y -hf descarga el GGUF de Hugging Face en el primer uso. Puedes acceder a http://localhost:8080 con cualquier cliente compatible y empezar a chatear.

Ten en cuenta que este método es solo texto. No carga el proyector de visión, por lo que no funcionará con la demo VLA anterior. Para la experiencia completa con webcam, sigue el método de construcción nativa en el paso 4.

---

Esperamos que hayas disfrutado este tutorial. Si tienes preguntas o sugerencias, no dudes en contactarnos.

Asier Arranz | NVIDIA