环境：ubuntu gtx1070 cuda11.8

# 下载1B模型
modelscope download --model deepseek-ai/Janus-Pro-1B --local_dir ./Janus-Pro-1B
# 或者./hfd.sh deepseek-ai/Janus-Pro-1B --tool wget

# 克隆仓库
git clone https://github.com/deepseek-ai/Janus.git
cd Janus
pip install -e . -i  https://pypi.tuna.tsinghua.edu.cn/simple
    #为预防环境冲突，手动删除了requirements.txt 的torch 后续警告不知道是不是这里的问题

图片理解代码

空格显示有点问题

import torch
from transformers import AutoModelForCausalLM
from Janus.janus.models import MultiModalityCausalLM, VLChatProcessor
from Janus.janus.utils.io import load_pil_images

# 模型路径，指向预训练的多模态因果语言模型
model_path = "/root/ai/Janus/Janus-Pro-1B"

# 图片路径，用于后续的多模态输入
image = './img.png'
# 用户提出的问题，将与图片一起输入模型
question = '请说明一下这张图片'

# 加载预训练的多模态对话处理器（VLChatProcessor），用于处理对话和图片输入
vl_chat_processor: VLChatProcessor = VLChatProcessor.from_pretrained(model_path)
# 获取 tokenizer，用于文本的编码和解码
tokenizer = vl_chat_processor.tokenizer

# 加载预训练的多模态因果语言模型（MultiModalityCausalLM）
vl_gpt: MultiModalityCausalLM = AutoModelForCausalLM.from_pretrained(
    model_path, trust_remote_code=True  # 允许加载远程代码（如果模型中包含自定义代码）
)
# 将模型转换为 bfloat16 数据类型，并移动到 GPU 上，设置为评估模式
vl_gpt = vl_gpt.to(torch.bfloat16).cuda().eval()

# 定义对话内容，包含用户的角色、问题以及对应的图片路径
conversation = [
    {
        "role": "<|User|>",  # 用户角色标识
        "content": f"<image_placeholder>\n{question}",  # 图片占位符和问题文本
        "images": [image],  # 图片路径列表
    },
    {"role": "<|Assistant|>", "content": ""},  # 助手角色的初始内容为空
]

# 加载图片并准备输入数据
# 使用 load_pil_images 函数加载对话中提到的图片
pil_images = load_pil_images(conversation)
# 使用 VLChatProcessor 处理对话和图片，准备模型的输入数据
# force_batchify=True 强制将输入数据批量化处理
prepare_inputs = vl_chat_processor(
    conversations=conversation, images=pil_images, force_batchify=True
).to(vl_gpt.device)  # 将输入数据移动到模型所在的设备（GPU）

# 运行图像编码器，获取图像嵌入（embeddings）
# 使用模型的 prepare_inputs_embeds 方法处理输入数据，提取图像嵌入
inputs_embeds = vl_gpt.prepare_inputs_embeds(**prepare_inputs)

# 运行模型生成回答
# 使用模型的语言模型（language_model）生成回答
# 设置生成参数，如最大新生成的 token 数量、是否采样等
outputs = vl_gpt.language_model.generate(
    inputs_embeds=inputs_embeds,  # 输入嵌入
    attention_mask=prepare_inputs.attention_mask,  # 注意力掩码
    pad_token_id=tokenizer.eos_token_id,  # 填充 token 的 ID
    bos_token_id=tokenizer.bos_token_id,  # 开始 token 的 ID
    eos_token_id=tokenizer.eos_token_id,  # 结束 token 的 ID
    max_new_tokens=512,  # 最大新生成的 token 数量
    do_sample=False,  # 是否采样生成
    use_cache=True,  # 是否使用缓存
)

# 解码生成的回答
# 使用 tokenizer 将生成的 token 序列解码为文本
answer = tokenizer.decode(outputs[0].cpu().tolist(), skip_special_tokens=True)
# 打印对话格式和模型生成的回答
print(f"{prepare_inputs['sft_format'][0]}", answer)

文生图代码

parallel_size: int = 4,太高会爆8g显存

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 = "/root/ai/Janus/Janus-Pro-1B"
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": "红色跑车",
    },
    {"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 = 4,
    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,
)