---
license: mit
pipeline_tag: image-text-to-text
---

# InternVL2-8B-abliterated

## Introduction

Abliterated version of [InternVL2-8B](https://huggingface.co/OpenGVLab/InternVL2-8B), one of the most powerful multimodal large language models of its size class. Weight orthogonalization has been applied to inhibit the model's ability to express refusals while preserving the model's text and multimodal capabilities. Nonetheless, the model may still refuse your request, misunderstand your intent, or provide unsolicited advice regarding ethics or safety.

## Quickstart

```python
import torch
import torchvision.transforms as T
from PIL import Image
from torchvision.transforms.functional import InterpolationMode
from transformers import AutoModel, AutoTokenizer

IMAGENET_MEAN = (0.485, 0.456, 0.406)
IMAGENET_STD = (0.229, 0.224, 0.225)

def build_transform(input_size):
    MEAN, STD = IMAGENET_MEAN, IMAGENET_STD
    transform = T.Compose([
        T.Lambda(lambda img: img.convert("RGB") if img.mode != "RGB" else img),
        T.Resize((input_size, input_size), interpolation=InterpolationMode.BICUBIC),
        T.ToTensor(),
        T.Normalize(mean=MEAN, std=STD)
    ])
    return transform

def find_closest_aspect_ratio(aspect_ratio, target_ratios, width, height, image_size):
    best_ratio_diff = float("inf")
    best_ratio = (1, 1)
    area = width * height
    for ratio in target_ratios:
        target_aspect_ratio = ratio[0] / ratio[1]
        ratio_diff = abs(aspect_ratio - target_aspect_ratio)
        if ratio_diff < best_ratio_diff:
            best_ratio_diff = ratio_diff
            best_ratio = ratio
        elif ratio_diff == best_ratio_diff:
            if area > 0.5 * image_size * image_size * ratio[0] * ratio[1]:
                best_ratio = ratio
    return best_ratio

def dynamic_preprocess(image, min_num=1, max_num=12, image_size=448, use_thumbnail=False):
    orig_width, orig_height = image.size
    aspect_ratio = orig_width / orig_height

    # calculate the existing image aspect ratio
    target_ratios = set(
        (i, j) for n in range(min_num, max_num + 1) for i in range(1, n + 1) for j in range(1, n + 1) if
        i * j <= max_num and i * j >= min_num)
    target_ratios = sorted(target_ratios, key=lambda x: x[0] * x[1])

    # find the closest aspect ratio to the target
    target_aspect_ratio = find_closest_aspect_ratio(
        aspect_ratio, target_ratios, orig_width, orig_height, image_size)

    # calculate the target width and height
    target_width = image_size * target_aspect_ratio[0]
    target_height = image_size * target_aspect_ratio[1]
    blocks = target_aspect_ratio[0] * target_aspect_ratio[1]

    # resize the image
    resized_img = image.resize((target_width, target_height))
    processed_images = []
    for i in range(blocks):
        box = (
            (i % (target_width // image_size)) * image_size,
            (i // (target_width // image_size)) * image_size,
            ((i % (target_width // image_size)) + 1) * image_size,
            ((i // (target_width // image_size)) + 1) * image_size
        )
        # split the image
        split_img = resized_img.crop(box)
        processed_images.append(split_img)
    assert len(processed_images) == blocks
    if use_thumbnail and len(processed_images) != 1:
        thumbnail_img = image.resize((image_size, image_size))
        processed_images.append(thumbnail_img)
    return processed_images

def load_image(image_file, input_size=448, max_num=12):
    image = Image.open(image_file).convert("RGB")
    transform = build_transform(input_size=input_size)
    images = dynamic_preprocess(image, image_size=input_size, use_thumbnail=True, max_num=max_num)
    pixel_values = [transform(image) for image in images]
    pixel_values = torch.stack(pixel_values)
    return pixel_values

# If you want to load a model using multiple GPUs, please refer to the `Multiple GPUs` section.
path = "natong19/InternVL2-8B-abliterated"
model = AutoModel.from_pretrained(
    path,
    torch_dtype=torch.bfloat16,
    low_cpu_mem_usage=True,
    trust_remote_code=True).eval().cuda()
tokenizer = AutoTokenizer.from_pretrained(path, trust_remote_code=True, use_fast=False)

# set the max number of tiles in `max_num`
pixel_values = load_image("./examples/image1.jpg", max_num=12).to(torch.bfloat16).cuda()
generation_config = dict(max_new_tokens=1024, do_sample=False)

# pure-text conversation (纯文本对话)
question = "Hello, who are you?"
response, history = model.chat(tokenizer, None, question, generation_config, history=None, return_history=True)
print(f"User: {question}\nAssistant: {response}")

question = "Can you tell me a story?"
response, history = model.chat(tokenizer, None, question, generation_config, history=history, return_history=True)
print(f"User: {question}\nAssistant: {response}")

# single-image multi-round conversation (单图多轮对话)
question = "<image>\nPlease describe the image in detail."
response, history = model.chat(tokenizer, pixel_values, question, generation_config, history=None, return_history=True)
print(f"User: {question}\nAssistant: {response}")

question = "Please write a poem according to the image."
response, history = model.chat(tokenizer, pixel_values, question, generation_config, history=history, return_history=True)
print(f"User: {question}\nAssistant: {response}")

# multi-image multi-round conversation, separate images (多图多轮对话，独立图像)
pixel_values1 = load_image("./examples/image1.jpg", max_num=12).to(torch.bfloat16).cuda()
pixel_values2 = load_image("./examples/image2.jpg", max_num=12).to(torch.bfloat16).cuda()
pixel_values = torch.cat((pixel_values1, pixel_values2), dim=0)
num_patches_list = [pixel_values1.size(0), pixel_values2.size(0)]

question = "Image-1: <image>\nImage-2: <image>\nDescribe the two images in detail."
response, history = model.chat(tokenizer, pixel_values, question, generation_config,
                               num_patches_list=num_patches_list,
                               history=None, return_history=True)
print(f"User: {question}\nAssistant: {response}")

question = "What are the similarities and differences between these two images."
response, history = model.chat(tokenizer, pixel_values, question, generation_config,
                               num_patches_list=num_patches_list,
                               history=history, return_history=True)
print(f"User: {question}\nAssistant: {response}")
```

## Evaluation

Evaluation framework: lm-evaluation-harness 0.4.2 and lmms-eval 0.2.1

| Datasets | InternVL2-8B | InternVL2-8B-abliterated |
| :--- | :---: | :---: |
| _**Text benchmarks**_ |
| ARC (25-shot) | 59.1 | 58.5 |
| MMLU (5-shot) | 71.4 | 70.8 |
| TruthfulQA (0-shot) | 50.8 | 49.1 |
| Winogrande (5-shot) | 81.8 | 81.1 |
| _**Multimodal benchmarks**_ |
| AI2D (lite) | 80.2 | 80.0 |
| GQA (lite) | 74.0 | 74.6 |
| MMBench (EN dev, lite) |85.6 | 84.8 |
| MMMU (val) | 48.0 | 48.0 |
| OCRBench | 76.5 | 77.3 |
| VQAv2 (val, lite) | 76.4 | 76.2 |