Instructions to use QCRI/ProBel-MTL with libraries, inference providers, notebooks, and local apps. Follow these links to get started.

Libraries

How to use QCRI/ProBel-MTL with Transformers:

# Use a pipeline as a high-level helper
from transformers import pipeline

pipe = pipeline("text-generation", model="QCRI/ProBel-MTL")
messages = [
    {"role": "user", "content": "Who are you?"},
]
pipe(messages)

# Load model directly
from transformers import AutoTokenizer, AutoModelForCausalLM

tokenizer = AutoTokenizer.from_pretrained("QCRI/ProBel-MTL")
model = AutoModelForCausalLM.from_pretrained("QCRI/ProBel-MTL", device_map="auto")
messages = [
    {"role": "user", "content": "Who are you?"},
]
inputs = tokenizer.apply_chat_template(
	messages,
	add_generation_prompt=True,
	tokenize=True,
	return_dict=True,
	return_tensors="pt",
).to(model.device)

outputs = model.generate(**inputs, max_new_tokens=40)
print(tokenizer.decode(outputs[0][inputs["input_ids"].shape[-1]:]))

Notebooks
Google Colab
Kaggle
Local Apps Settings

vLLM

How to use QCRI/ProBel-MTL with vLLM:

Install from pip and serve model

# Install vLLM from pip:
pip install vllm
# Start the vLLM server:
vllm serve "QCRI/ProBel-MTL"
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:8000/v1/chat/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "QCRI/ProBel-MTL",
		"messages": [
			{
				"role": "user",
				"content": "What is the capital of France?"
			}
		]
	}'

Use Docker

docker model run hf.co/QCRI/ProBel-MTL

SGLang

How to use QCRI/ProBel-MTL with SGLang:

Install from pip and serve model

# Install SGLang from pip:
pip install sglang
# Start the SGLang server:
python3 -m sglang.launch_server \
    --model-path "QCRI/ProBel-MTL" \
    --host 0.0.0.0 \
    --port 30000
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:30000/v1/chat/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "QCRI/ProBel-MTL",
		"messages": [
			{
				"role": "user",
				"content": "What is the capital of France?"
			}
		]
	}'

Use Docker images

docker run --gpus all \
    --shm-size 32g \
    -p 30000:30000 \
    -v ~/.cache/huggingface:/root/.cache/huggingface \
    --env "HF_TOKEN=<secret>" \
    --ipc=host \
    lmsysorg/sglang:latest \
    python3 -m sglang.launch_server \
        --model-path "QCRI/ProBel-MTL" \
        --host 0.0.0.0 \
        --port 30000
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:30000/v1/chat/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "QCRI/ProBel-MTL",
		"messages": [
			{
				"role": "user",
				"content": "What is the capital of France?"
			}
		]
	}'

Docker Model Runner
How to use QCRI/ProBel-MTL with Docker Model Runner:
```
docker model run hf.co/QCRI/ProBel-MTL
```

ProBel-MTL

The bilingual multi-task model from the ProBel paper (Mt-SFT): a single Qwen2.5-7B-Instruct fine-tune that handles all five ProBel tasks in both Arabic and English — binary propaganda detection, coarse-category and fine-grained technique classification (with explanations), and technique-labeled span extraction in two output formats.

Trained with LoRA (r=16, alpha=32) on the Arabic and English training splits of QCRI/ProBel across all five task formats jointly; the checkpoint was selected on validation loss and merged into the base model, so it loads as a regular causal LM. The LoRA adapter alone is in lora_adapter/.

Companion resources: dataset · code · paper: ProBel: Propaganda Detection with Techniques, Spans, and Explanations (arXiv preprint; the link will be added here once the listing is live).

Test scores

	Binary	Coarse	Technique	Span-tag	Span-occ
Arabic	0.763	0.682	0.575	0.411	0.362
English	0.735	0.410	0.272	0.189	0.241

Binary is macro-F1; coarse/technique are micro-F1; spans use the overlap-adjusted micro-F1 of Da San Martino et al. (2020). These match the paper's Mt-SFT rows and were produced with greedy decoding.

Prompt templates

The model expects the exact task prompts it was trained on. prompts/templates.json ships all ten of them — {arabic, english} x {binary, coarse, multilabel, span_tag, span_match_occ} — each a {"system": ..., "user": ...} pair where the user message contains a {TEXT} placeholder for the input sentence.

Task	Model output
`binary`	`Label: true` or `Label: false`, then `Explanation: ...`
`coarse` / `multilabel`	`Labels: <names or none>`, then `Explanation: ...`
`span_tag`	the input sentence with inline `<span type="Technique">...</span>` tags
`span_match_occ`	a JSON list of `{"text", "label", "occurrence"}` objects

Arabic templates carry the same task instructions with an Arabic-specialized system prompt; the model answers Arabic inputs in Arabic.

Usage

pip install "transformers>=4.51" accelerate

Binary detection with an explanation:

import json
from huggingface_hub import hf_hub_download
from transformers import AutoModelForCausalLM, AutoTokenizer

templates = json.load(open(hf_hub_download("QCRI/ProBel-MTL", "prompts/templates.json")))
model = AutoModelForCausalLM.from_pretrained("QCRI/ProBel-MTL",
                                             dtype="bfloat16", device_map="auto")
tok = AutoTokenizer.from_pretrained("QCRI/ProBel-MTL")

def run(task, lang, text, max_new_tokens=512):
    t = templates[lang][task]
    msgs = [{"role": "system", "content": t["system"]},
            {"role": "user", "content": t["user"].replace("{TEXT}", text)}]
    ids = tok.apply_chat_template(msgs, add_generation_prompt=True,
                                  return_tensors="pt").to(model.device)
    out = model.generate(ids, max_new_tokens=max_new_tokens, do_sample=False)
    return tok.decode(out[0][ids.shape[1]:], skip_special_tokens=True)

print(run("binary", "english",
          "The corrupt elites are destroying everything we hold dear."))
# Label: true
# Explanation: The paragraph relies on a sweeping, emotive accusation that
# unnamed "elites" are ruining "everything we hold dear" ...

Technique-labeled span extraction (same helper):

print(run("span_tag", "english",
          "The corrupt elites are destroying everything we hold dear."))
# <span type="Appeal_to_Fear-Prejudice">The corrupt elites are destroying
# everything we hold dear.</span>

print(run("multilabel", "arabic",
          "الإعلام الكاذب يواصل نشر أكاذيبه المسمومة لتضليل الشعب."))
# Labels: Loaded_Language, Questioning_the_Reputation
# Explanation: يستخدم النص لغة محملة بالعواطف مثل "الكاذب" و"أكاذيبه المسمومة" ...

The model also serves directly with vLLM:

vllm serve QCRI/ProBel-MTL

The parsers that turn the span outputs back into character offsets, and the full evaluation pipeline, are in the code repository.

Intended use and limitations

Built for research on propaganda and persuasion-technique analysis in news and social-media text. Predictions are imperfect, technique performance follows the long-tailed label distribution (rare techniques are often missed), and outputs should support trained human reviewers rather than replace them, particularly in moderation or policy settings.

Citation

@misc{kmainasi2026probelpropagandadetectiontechniques,
      title={ProBel: Propaganda Detection with Techniques, Spans, and Explanations}, 
      author={Mohamed Bayan Kmainasi and Ali Ezzat Shahroor and Elisa Sartori and Giovanni Da San Martino and Firoj Alam},
      year={2026},
      eprint={2608.22388},
      archivePrefix={arXiv},
      primaryClass={cs.CL},
      url={https://arxiv.org/abs/2608.22388}, 
}