Pular para o conteúdo
Local AI Wizard
Sua máquina
Tema

Janus Pro

DeepSeek · https://github.com/deepseek-ai/Janus

Licença dos pesos: Termos do publicador: MIT (code) / DeepSeek Model License (model) · código e componentes podem ter outros termos

QualidadeNota, posição e número de amostras da Artificial Analysis excluídos: o plano gratuito é só para uso interno. Fonte consultada em 2026-09-22.Sem score comparável
Tamanho do repositório publicado14,9 GBTodos os arquivos publicados · não é memória de execução
Parâmetros7 Bficha do fabricante
Componentes publicados1Informados na ficha do modelo

Qualidade

Sem score comparável

Nota, posição e número de amostras da Artificial Analysis excluídos: o plano gratuito é só para uso interno. Fonte consultada em 2026-09-22. Ranking (só link)

Informado pelo publicador

A ficha deste modelo ainda não foi lida em busca de resultados de benchmark. ficha ainda não lida

Roda em

Memória suficiente para a estimativa 57

A estimativa de planejamento de 16 bits cabe nesta memória. Não é um mínimo revisado.

Mostrar todos os 57

Falta um degrau de memória 25

As mesmas máquinas com o próximo tamanho de memória teriam o suficiente para a estimativa.

Mostrar todos os 25

O publicador não documenta mínimo para este checkpoint (fontes consultadas em 2026-10-13). Os perfis de hardware são agrupados por uma estimativa de planejamento de 16 bits, rotulada, a partir da contagem de parâmetros publicada (2 bytes por parâmetro, 20% de margem, 2 GB de reserva). Precisão, resolução, duração, encoders de texto e offload mudam o requisito real. Não é execução medida.

Planejar memória para este modelo

Considere para

Considere Janus Pro, de DeepSeek, para a tarefa de texto para imagem (7B de parâmetros).

Confira antes

Este catálogo não verificou os requisitos de hardware deste registro. A memória real depende de precisão, resolução, duração e offload; consulte a fonte oficial.

Velocidade medida

Nenhuma medição publicada para este checkpoint

O tempo de geração por imagem só aparece quando uma fonte o publica com hardware, build e configuração. Nunca é estimado.

Como rodar

Requisito de hardware não revisado. Este catálogo não verificou os requisitos de hardware deste registro. A memória real depende de precisão, resolução, duração e offload; consulte a fonte oficial.

Formas documentadas de rodar

Copiado como aparece na fonte vinculada (lida em 2026-10-18); não executado por este site.

Preparação indicada antes pela fonte · Janus
pip install -e .
Janus · README · Text-to-Image Generation
import os
import PIL.Image
import torch
import numpy as np
from transformers import AutoModelForCausalLM
from janus.models import MultiModalityCausalLM, VLChatProcessor


# specify the path to the model
model_path = "deepseek-ai/Janus-Pro-7B"
vl_chat_processor: VLChatProcessor = VLChatProcessor.from_pretrained(model_path)
tokenizer = vl_chat_processor.tokenizer

vl_gpt: MultiModalityCausalLM = AutoModelForCausalLM.from_pretrained(
    model_path, trust_remote_code=True
)
vl_gpt = vl_gpt.to(torch.bfloat16).cuda().eval()

conversation = [
    {
        "role": "<|User|>",
        "content": "A stunning princess from kabul in red, white traditional clothing, blue eyes, brown hair",
    },
    {"role": "<|Assistant|>", "content": ""},
]

sft_format = vl_chat_processor.apply_sft_template_for_multi_turn_prompts(
    conversations=conversation,
    sft_format=vl_chat_processor.sft_format,
    system_prompt="",
)
prompt = sft_format + vl_chat_processor.image_start_tag


@torch.inference_mode()
def generate(
    mmgpt: MultiModalityCausalLM,
    vl_chat_processor: VLChatProcessor,
    prompt: str,
    temperature: float = 1,
    parallel_size: int = 16,
    cfg_weight: float = 5,
    image_token_num_per_image: int = 576,
    img_size: int = 384,
    patch_size: int = 16,
):
    input_ids = vl_chat_processor.tokenizer.encode(prompt)
    input_ids = torch.LongTensor(input_ids)

    tokens = torch.zeros((parallel_size*2, len(input_ids)), dtype=torch.int).cuda()
    for i in range(parallel_size*2):
        tokens[i, :] = input_ids
        if i % 2 != 0:
            tokens[i, 1:-1] = vl_chat_processor.pad_id

    inputs_embeds = mmgpt.language_model.get_input_embeddings()(tokens)

    generated_tokens = torch.zeros((parallel_size, image_token_num_per_image), dtype=torch.int).cuda()

    for i in range(image_token_num_per_image):
        outputs = mmgpt.language_model.model(inputs_embeds=inputs_embeds, use_cache=True, past_key_values=outputs.past_key_values if i != 0 else None)
        hidden_states = outputs.last_hidden_state
        
        logits = mmgpt.gen_head(hidden_states[:, -1, :])
        logit_cond = logits[0::2, :]
        logit_uncond = logits[1::2, :]
        
        logits = logit_uncond + cfg_weight * (logit_cond-logit_uncond)
        probs = torch.softmax(logits / temperature, dim=-1)

        next_token = torch.multinomial(probs, num_samples=1)
        generated_tokens[:, i] = next_token.squeeze(dim=-1)

        next_token = torch.cat([next_token.unsqueeze(dim=1), next_token.unsqueeze(dim=1)], dim=1).view(-1)
        img_embeds = mmgpt.prepare_gen_img_embeds(next_token)
        inputs_embeds = img_embeds.unsqueeze(dim=1)


    dec = mmgpt.gen_vision_model.decode_code(generated_tokens.to(dtype=torch.int), shape=[parallel_size, 8, img_size//patch_size, img_size//patch_size])
    dec = dec.to(torch.float32).cpu().numpy().transpose(0, 2, 3, 1)

    dec = np.clip((dec + 1) / 2 * 255, 0, 255)

    visual_img = np.zeros((parallel_size, img_size, img_size, 3), dtype=np.uint8)
    visual_img[:, :, :] = dec

    os.makedirs('generated_samples', exist_ok=True)
    for i in range(parallel_size):
        save_path = os.path.join('generated_samples', "img_{}.jpg".format(i))
        PIL.Image.fromarray(visual_img[i]).save(save_path)


generate(
    vl_gpt,
    vl_chat_processor,
    prompt,
)

Nível da evidência: Apenas estimativa genérica; nenhuma execução reproduzida por este site.

Antes de baixar
  1. Confirme o checkpoint exato e a licença vinculada aqui.
  2. Confirme runtime e precisão ou quantização compatíveis com sua plataforma.
  3. Reserve memória para contexto, lote e eventuais componentes de mídia além dos pesos.

Detalhes técnicos

O que a fonte e o catálogo guardam deste checkpoint. Campos ausentes ficam de fora, nunca como zero.

Tarefa e modalidade
texto para imagem · imagem
Contagem e base
7B · ficha do fabricante
Lançamento
deepseek-ai/Janus README (GitHub), News · consultado em 2026-10-09fonte
Tamanho do repositório publicado
14,9 GBNão é memória de execução nem download mínimo.arquivos
Componentes publicados
Technical details pending review
Runtime e precisão
Nenhuma execução local verificada.
Uso comercial
Permitido DeepSeek Model License (deepseek-ai/DeepSeek-LLM LICENSE-MODEL) · consultado em 2026-10-18texto da licença

Licença, contagem de parâmetros e data de lançamento vêm das fontes do publicador listadas nesta página (uma data que nenhuma fonte informa fica vazia). O requisito de hardware não foi revisado, então a memória é uma estimativa rotulada. O tamanho do repositório, quando aparece, é o download publicado completo.

Fontes

Identidade e especificações publicadas vêm da página do checkpoint. As notas pertencem à rodada indicada e não medem velocidade no seu computador.

Catálogo revisado: 2026-09-22.