Cómo instalar Janus Pro: Guía completa y hardware necesario

Leíste bien, Janus Pro es la nueva inteligencia artificial de esta ya famosa empresa China ‘Deepseek’ la cual ha publicado un modelo hace unas horas que rebasa por mucho a las empresas occidentales como OpenAI y otros de código abierto.

Según Hugging Face un sitio web que contiene los modelos de IA mas importantes del mundo, describe a Janus-Pro como un nuevo marco autorregresivo que unifica la comprensión y la generación multimodal.

¿Cómo lo hace?

Ahora supera las limitaciones que tenía en sus versiones anteriores desacoplando la codificación visual en vías separadas, pero esto sin sacrificar su sistema de arquitectura de transformador unificada para el procesamiento. Esto ha logrado que el desacoplamiento libere estrés en el codificador visual durante la comprensión y la generación, y a todo esto le suma una increíble flexibilidad.

Lo anterior le permite superar al modelo anterior y a los actuales de las empresas occidentales en rendimiento.

Según los expertos, este modelo es importante para la comunidad de código abierto ya que impacta la imposibilidad de tener LLM que occidente hacía ver con sus cada vez más herméticas soluciones.

Janus-Pro está construido sobre la base de DeepSeek-LLM-1.5b/DeepSeek-LLM-7b. Para lograr la comprensión multimodal utiliza SigLIP-L como codificador de visión, aunque por el momento esto lo limita a una entrada de imágenes de 384×384. Además también utiliza el tokenizador LlamaGen

¿Por qué supera a DALL-E 3 y Stable Difussion?

Tan simple como por su precisión general, y aquí te dejo la tabla de referencia:

En rendimiento tenemos los siguientes datos según GenEval:

En precisión según GenEval

¿Cómo instalarlo?

El proyecto está disponible en Github para bajarse bajo la licencia MIT y sujeta a la licencia DeepSeek.

Proyecto Janus-Pro Github para su descarga.

Para poder instalarlo puedes seguir varios tutoriales y recomendaciones para hacerlo más optimizado para pruebas. Lo mejor es rentar tu propio hardware en la nube, así que te explicaremos donde puedes hacerlo y como probarlo.

Hardware requerido

Como todo modelo de Inteligencia Artificial el hardware para procesar (VRAM y GPUs) son vitales para poder probar estos modelos, afortunadamente ahora que son mucho más eficientes y precisos, no es necesario tener todo un centro de datos para correrlo.

Algunos usuarios han reportado haber hecho pruebas con el usando una Tarjeta de Video NVIDIA RTX 4090 con 24 GB y les habría tomando lograr un output después de 10 minutos.

Pero si no tienes un GPU de ese nivel y quiere probar, puedes rentar equipos en la nube, para ello vamos a ir al sitio web de Massed Compute y después de registrarte recomiendo usar la H100 NVL de 94GB, la cual el costo aproximado en pesos es de $50.00 MXN.

Software Requerido

Una vez que ya tengas acceso a tu consola o S.O. con el hardware requerido, es necesario que descargues los archivos del modelo desde HuggingFace, ¿cómo los descargo?

Usa la librería del mismo sitio «huggingface_hub» para poder acceder a los repos ó también desde el sitio web te dejo los links de los archivos:

Una vez descargado asegurate de tener instalado en la instancia o equipo local Python en la versión 3.9 o superior.

También requerirás de Pytorch y HuggingFace Transformers:

pip install torch torchvision torchaudio transformers accelerate janus Pillow numpy

Carga el modelo y pruébalo con el siguiente código:

import torch
from transformers import AutoConfig, AutoModelForCausalLM
from janus.models import VLChatProcessor
from PIL import Image
import numpy as np

# Ruta del modelo en Hugging Face
model_path = "deepseek-ai/Janus-Pro-7B"

# Cargar configuración y modelo
config = AutoConfig.from_pretrained(model_path)
language_config = config.language_config
language_config._attn_implementation = 'eager'
vl_gpt = AutoModelForCausalLM.from_pretrained(
    model_path,
    language_config=language_config,
    trust_remote_code=True
)

# Configurar el dispositivo y tipo de datos
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
vl_gpt = vl_gpt.to(device)

# Cargar el procesador
vl_chat_processor = VLChatProcessor.from_pretrained(model_path)
tokenizer = vl_chat_processor.tokenizer

# Función para comprensión multimodal
@torch.inference_mode()
def multimodal_understanding(image_path, question, seed=42, top_p=0.95, temperature=0.1):
    # Establecer semilla para reproducibilidad
    torch.manual_seed(seed)
    np.random.seed(seed)
    if torch.cuda.is_available():
        torch.cuda.manual_seed(seed)

    # Cargar imagen
    image = Image.open(image_path).convert('RGB')

    # Crear conversación
    conversation = [
        {
            "role": "<|User|>",
            "content": f"<image_placeholder>\n{question}",
            "images": [image],
        },
        {"role": "<|Assistant|>", "content": ""},
    ]

    # Preparar entradas
    prepare_inputs = vl_chat_processor(
        conversations=conversation, images=[image], force_batchify=True
    ).to(device)

    # Obtener embeddings de entrada
    inputs_embeds = vl_gpt.prepare_inputs_embeds(**prepare_inputs)

    # Generar salida
    outputs = vl_gpt.language_model.generate(
        inputs_embeds=inputs_embeds,
        attention_mask=prepare_inputs.attention_mask,
        pad_token_id=tokenizer.eos_token_id,
        bos_token_id=tokenizer.bos_token_id,
        eos_token_id=tokenizer.eos_token_id,
        max_new_tokens=512,
        do_sample=temperature > 0,
        use_cache=True,
        temperature=temperature,
        top_p=top_p,
    )

    # Decodificar respuesta
    answer = tokenizer.decode(outputs[0].cpu().tolist(), skip_special_tokens=True)
    return answer

# Ejemplo de uso
image_path = "ruta/a/tu/imagen.jpg"
question = "¿Qué se muestra en esta imagen?"
respuesta = multimodal_understanding(image_path, question)
print("Respuesta:", respuesta)

Importante

Es evidente que requieres de conocimientos básicos de infraestructura y programación para poder ejecutar los ejemplos anteriores.

¿Qué representa en economía y política?

La empresa DeepSeek acaba de cambiar las reglas del juego, ahora la IA está accesible y de código abierto, más eficiente y mucho más barata. Y en efecto esto ha hecho que las grandes compañías como NVIDIA hayan perdido en un sólo día su trono en la bolsa, ahora con la salida de Janus-Pro probablemente en las próximas horas también veamos un desplome similar.