zer0int/RTA-100-Multilingual

RTA-100 Multilingual

A multilingual typographic attack benchmark dataset.

A multilingual, adapted version of the Original RTA-100; contains digital typographic attacks in multiple languages (no handwriting).
See here for RTA-100 English (clean, handwritten, digital) instead.

Contains clean NoRTA control and German(de), Spanish(es), French(fr), Italian(it), English(en), Arabic(ar), Japanese(ja), Korean(ko), Russian(ru), Chinese(zh).

📌 Usage

Load a single language subset:

from datasets import load_dataset

ds = load_dataset("zer0int/RTA-100-Multilingual", "ja", split="train")

Clean no-text control:

ds = load_dataset("zer0int/RTA-100-Multilingual", "norta", split="train")

Everything:

ds = load_dataset("zer0int/RTA-100-Multilingual", "all", split="train")

Arbitrary mixture after loading all:

wanted = {"norta", "zh", "ja", "ko"}
ds = load_dataset("zer0int/RTA-100-Multilingual", "all", split="train")
ds = ds.filter(lambda row: row["subset"] in wanted)

The object_label and attack_word are translated labels corresponding to the rendered language.
Canonical English labels available as object_label_en and attack_word_en.

---

👉 CLICK to expand code for using this dataset with AltCLIP-m9 ⚡💻

import torch
import torch.nn.functional as F
from datasets import load_dataset
from transformers import (
    AltCLIPModel,
    CLIPImageProcessor,
    AutoTokenizer,
)

MODEL_ID = "BAAI/AltCLIP-m9"
MODEL_REVISION = "54ed32587457bb33ce2d5285a9361281e1ca8530"
DATASET_ID = "zer0int/RTA-100-Multilingual"

LANGUAGES = ["en", "es", "fr", "it", "de", "ru", "ar", "ko", "ja", "zh"]

PROMPTS = {
    "en": "a photo of a {word}",
    "es": "una foto de {word}",
    "fr": "une photo de {word}",
    "it": "una foto di {word}",
    "de": "Foto: {word}",
    "ru": "фото: {word}",
    "ar": "صورة: {word}",
    "ko": "{word} 사진",
    "ja": "{word}の写真",
    "zh": "一张{word}的照片",
}

DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
BATCH_SIZE = 64


model = AltCLIPModel.from_pretrained(
    MODEL_ID,
    revision=MODEL_REVISION,
    use_safetensors=True,
).eval().to(DEVICE)

image_processor = CLIPImageProcessor.from_pretrained(
    MODEL_ID,
    revision=MODEL_REVISION,
)

tokenizer = AutoTokenizer.from_pretrained(
    MODEL_ID,
    revision=MODEL_REVISION,
)

def get_features(output):
    if torch.is_tensor(output):
        return output
    return output.pooler_output

@torch.inference_mode()
def encode_images(dataset):
    chunks = []

    for start in range(0, len(dataset), BATCH_SIZE):
        images = [
            dataset[i]["image"]
            for i in range(start, min(start + BATCH_SIZE, len(dataset)))
        ]

        pixel_values = image_processor(
            images=images,
            return_tensors="pt",
        )["pixel_values"].to(DEVICE)

        features = get_features(
            model.get_image_features(pixel_values=pixel_values)
        )
        chunks.append(F.normalize(features.float(), dim=-1).cpu())


    return torch.cat(chunks)


@torch.inference_mode()
def encode_labels(labels, language):
    prompts = [PROMPTS[language].format(word=label) for label in labels]

    inputs = tokenizer(
        prompts,
        padding=True,
        truncation=True,
        return_tensors="pt",
    ).to(DEVICE)

    features = get_features(
        model.get_text_features(**inputs)
    )
    return F.normalize(features.float(), dim=-1).cpu()


def binary_accuracy(image_features, dataset, text_features, label_index):
    correct = 0

    for image_feature, row in zip(image_features, dataset):
        object_feature = text_features[label_index[row["object_label"]]]
        attack_feature = text_features[label_index[row["attack_word"]]]

        object_score = image_feature @ object_feature
        attack_score = image_feature @ attack_feature

        correct += int(object_score >= attack_score)

    return correct / len(dataset)


# Clean images are shared by all languages.
norta = load_dataset(DATASET_ID, "norta", split="train")
norta_features = encode_images(norta)
norta_index = {
    sample_key: i
    for i, sample_key in enumerate(norta["sample_key"])
}


print(f"{'Language':<10} {'NoRTA':>10} {'SynthRTA':>10}")
print("-" * 32)

for language in LANGUAGES:
    synth = load_dataset(DATASET_ID, language, split="train")

    # All 100 translated object/attack concepts for this language.
    labels = sorted(
        set(synth["object_label"]) | set(synth["attack_word"]),
        key=str.casefold,
    )

    text_features = encode_labels(labels, language)
    label_index = {label: i for i, label in enumerate(labels)}

    # Pair every attacked image with its exact clean NoRTA source image.
    clean_indices = torch.tensor(
        [norta_index[key] for key in synth["sample_key"]]
    )
    clean_features = norta_features[clean_indices]

    clean_acc = binary_accuracy(
        clean_features,
        synth,
        text_features,
        label_index,
    )

    synth_features = encode_images(synth)
    synth_acc = binary_accuracy(
        synth_features,
        synth,
        text_features,
        label_index,
    )

    print(
        f"{language:<10} "
        f"{clean_acc:>9.1%} "
        f"{synth_acc:>9.1%}"
    )

Example ZS accuracy, AltCLIP-m9:

Language	NoRTA	SynthRTA
English (en)	99.3%	42.5%
Spanish (es)	98.5%	81.6%
French (fr)	97.2%	75.8%
Italian (it)	97.7%	83.4%
German (de)	90.3%	27.5%
Russian (ru)	98.4%	93.3%
Arabic (ar)	97.3%	94.1%
Korean (ko)	98.8%	96.2%
Japanese (ja)	99.5%	97.7%
Chinese (zh)	99.3%	97.7%