Idefics2 Raven Finetuned

🚀 AI Raven模型

本模型旨在解决瑞文推理矩阵问题，基于即将推出的多模态基础模型的早期检查点进行训练。通过使用特定数据集训练，在验证集上达到了较高的准确率，为解决相关问题提供了有效方案。

🚀 快速开始

你可以先尝试 在线演示！

✨ 主要特性

• 该模型经过训练，专门用于解决瑞文推理矩阵问题。
• 基于即将推出的视觉 - 语言基础模型的早期检查点构建。
• 在验证集上，模型的准确率可达 91%。

📦 安装指南

文档未提及安装步骤，故跳过此章节。

💻 使用示例

基础用法

此代码片段展示了如何使用该模型进行批量推理。当我们将模型集成到 HF Transformers 中时，许多输入准备工作将被封装起来。

import torch
import requests

from io import BytesIO
from PIL import Image
from transformers import AutoModelForCausalLM, AutoProcessor

from transformers.image_utils import to_numpy_array, PILImageResampling, ChannelDimension
from transformers.image_transforms import resize, to_channel_dimension_format


DEVICE = torch.device("cuda")
PROCESSOR = AutoProcessor.from_pretrained(
    "HuggingFaceM4/tr_272_bis_opt_step_15000_merge",
    token=API_TOKEN,
)
MODEL = AutoModelForCausalLM.from_pretrained(
    "HuggingFaceM4/tr_272_bis_opt_step_15000_merge",
    token=API_TOKEN,
    trust_remote_code=True,
    torch_dtype=torch.bfloat16,
).to(DEVICE)
image_seq_len = MODEL.config.perceiver_config.resampler_n_latents
BOS_TOKEN = PROCESSOR.tokenizer.bos_token
BAD_WORDS_IDS = PROCESSOR.tokenizer(["<image>", "<fake_token_around_image>"], add_special_tokens=False).input_ids


def convert_to_rgb(image):
    # `image.convert("RGB")` would only work for .jpg images, as it creates a wrong background
    # for transparent images. The call to `alpha_composite` handles this case
    if image.mode == "RGB":
        return image

    image_rgba = image.convert("RGBA")
    background = Image.new("RGBA", image_rgba.size, (255, 255, 255))
    alpha_composite = Image.alpha_composite(background, image_rgba)
    alpha_composite = alpha_composite.convert("RGB")
    return alpha_composite


# The processor is the same as the Idefics processor except for the BILINEAR interpolation,
# so this is a hack in order to redefine ONLY the transform method
def custom_transform(x):
    x = convert_to_rgb(x)
    x = to_numpy_array(x)

    height, width = x.shape[:2]
    aspect_ratio = width / height
    if width >= height and width > 980:
        width = 980
        height = int(width / aspect_ratio)
    elif height > width and height > 980:
        height = 980
        width = int(height * aspect_ratio)
    width = max(width, 378)
    height = max(height, 378)

    x = resize(x, (height, width), resample=PILImageResampling.BILINEAR)
    x = PROCESSOR.image_processor.rescale(x, scale=1 / 255)
    x = PROCESSOR.image_processor.normalize(
        x,
        mean=PROCESSOR.image_processor.image_mean,
        std=PROCESSOR.image_processor.image_std
    )
    x = to_channel_dimension_format(x, ChannelDimension.FIRST)
    x = torch.tensor(x)
    return x


# Create text token inputs
image_seq = '<image>' * image_seq_len
inputs = PROCESSOR.tokenizer(
    [
        f"{BOS_TOKEN}User:<fake_token_around_image>{image_seq}<fake_token_around_image>Which figure should complete the logical sequence?<end_of_utterance>\nAssistant:",
        f"{BOS_TOKEN}User:<fake_token_around_image>{image_seq}<fake_token_around_image>Which figure should complete the logical sequence?<end_of_utterance>\nAssistant:",
    ],
    return_tensors="pt",
    add_special_tokens=False,
    padding=True,
)

# Create pixel inputs
raw_images = [
    [your_raven_puzzle_as_a_pil_image1],
    [your_raven_puzzle_as_a_pil_image2],
]
output_images = [
    [PROCESSOR.image_processor(img, transform=custom_transform) for img in img_list]
    for img_list in raw_images
]
total_batch_size = len(output_images)
max_num_images = max([len(img_l) for img_l in output_images])
max_height = max([i.size(2) for img_l in output_images for i in img_l])
max_width = max([i.size(3) for img_l in output_images for i in img_l])
padded_image_tensor = torch.zeros(total_batch_size, max_num_images, 3, max_height, max_width)
padded_pixel_attention_masks = torch.zeros(
    total_batch_size, max_num_images, max_height, max_width, dtype=torch.bool
)
for batch_idx, img_l in enumerate(output_images):
    for img_idx, img in enumerate(img_l):
        im_height, im_width = img.size()[2:]
        padded_image_tensor[batch_idx, img_idx, :, :im_height, :im_width] = img
        padded_pixel_attention_masks[batch_idx, img_idx, :im_height, :im_width] = True

inputs["pixel_values"] = padded_image_tensor
inputs["pixel_attention_mask"] = padded_pixel_attention_masks
inputs = {k: v.to(DEVICE) for k, v in inputs.items()}

generated_ids = MODEL.generate(**inputs, bad_words_ids=BAD_WORDS_IDS, max_new_tokens=10)
generated_texts = PROCESSOR.batch_decode(generated_ids, skip_special_tokens=True)

print(generated_texts)

高级用法

模型经过专门微调以解决瑞文谜题，若未进行适当调整，我们不能保证它在该用例之外能准确运行。

📚 详细文档

模型详情

📄 许可证

该模型基于两个预训练模型构建：SigLIP 和 mistralai/Mistral - 7B - v0.1，它们均遵循 Apache - 2.0 许可证分发。因此，用户应遵守这些模型的许可证规定。

这两个预训练模型通过我们训练的新初始化参数相互连接。这些参数并非基于构成复合模型的两个基础冻结模型。我们将训练得到的额外权重以 Apache - 2.0 许可证发布。