Idefics2 Raven Finetuned

🚀 モデルAI Raven

このモデルは、レイヴンの漸進マトリックスを解くために訓練されたものです。視覚言語基礎モデルの早期チェックポイントをベースに構築されています。

デモを試してみましょう！

🚀 クイックスタート

このモデルは、レイヴンの漸進マトリックスを解くために訓練されています。手続き的に生成されたレイヴンパズルのRAVENデータセットを使用して訓練され、検証セットでは91％の精度を達成します。

✨ 主な機能

• レイヴンの漸進マトリックスを解くことができます。
• バッチ推論が可能です。

📦 インストール

インストールに関する具体的な手順は元文書に記載されていないため、このセクションをスキップします。

💻 使用例

基本的な使用法

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 という2つの事前学習モデルをベースに構築されています。これらのモデルはApache-2.0ライセンスの下で提供されています。したがって、ユーザーはこれらのモデルのライセンスに準拠する必要があります。

2つの事前学習モデルは、新しく初期化されたパラメータで接続され、訓練されています。これらは、複合モデルを形成する2つのベースの凍結モデルのいずれにも基づいていません。私たちは、訓練した追加の重みをApache-2.0ライセンスの下で公開しています。