Instructions to use AhmedReda25300/Ara-JEV with libraries, inference providers, notebooks, and local apps. Follow these links to get started.
- Libraries
- Transformers
How to use AhmedReda25300/Ara-JEV with Transformers:
# Use a pipeline as a high-level helper from transformers import pipeline pipe = pipeline("text-generation", model="AhmedReda25300/Ara-JEV", trust_remote_code=True) messages = [ { "role": "user", "content": [ {"type": "image", "url": "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/p-blog/candy.JPG"}, {"type": "text", "text": "What animal is on the candy?"} ] }, ] pipe(text=messages)# pip install -U transformers accelerate # Load model directly from transformers import AutoProcessor, AutoModelForMultimodalLM processor = AutoProcessor.from_pretrained("AhmedReda25300/Ara-JEV", trust_remote_code=True) model = AutoModelForMultimodalLM.from_pretrained("AhmedReda25300/Ara-JEV", trust_remote_code=True, device_map="auto") messages = [ { "role": "user", "content": [ {"type": "image", "url": "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/p-blog/candy.JPG"}, {"type": "text", "text": "What animal is on the candy?"} ] }, ] inputs = processor.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=256) print(processor.decode(outputs[0][inputs["input_ids"].shape[-1]:])) - Notebooks
- Google Colab
- Kaggle
- Local Apps Settings
- vLLM
How to use AhmedReda25300/Ara-JEV with vLLM:
Install from pip and serve model
# Install vLLM from pip: pip install vllm # Start the vLLM server: vllm serve "AhmedReda25300/Ara-JEV" # Call the server using curl (OpenAI-compatible API): curl -X POST "http://localhost:8000/v1/chat/completions" \ -H "Content-Type: application/json" \ --data '{ "model": "AhmedReda25300/Ara-JEV", "messages": [ { "role": "user", "content": "What is the capital of France?" } ] }'Use Docker
docker model run hf.co/AhmedReda25300/Ara-JEV
- SGLang
How to use AhmedReda25300/Ara-JEV 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 "AhmedReda25300/Ara-JEV" \ --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": "AhmedReda25300/Ara-JEV", "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 "AhmedReda25300/Ara-JEV" \ --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": "AhmedReda25300/Ara-JEV", "messages": [ { "role": "user", "content": "What is the capital of France?" } ] }' - Docker Model Runner
How to use AhmedReda25300/Ara-JEV with Docker Model Runner:
docker model run hf.co/AhmedReda25300/Ara-JEV
Ara-JEV
Ara-JEV is a compact Arabic decision model fine-tuned from Qwen3.5-0.8B. Given a short state, a question, and optional candidate choices, it selects the best answer label.
This repository contains a standalone merged checkpoint: the trained LoRA weights have been merged into the base model. You do not need to load a separate adapter.
Model details
| Property | Value |
|---|---|
| Base model | Qwen/Qwen3.5-0.8B |
| Architecture | Qwen3.5 conditional-generation model |
| Fine-tuning | LoRA, rank 16; adapter merged into base weights |
| Training strategy | One epoch of LoRA fine-tuning |
| Training data | Deduplicated Arabic decision and reasoning datasets |
| License | Apache-2.0 (same as the base model) |
Evaluation
The held-out test set contains 10,419 examples. The results below use constrained candidate-label scoring: for each example, the evaluator scores the allowed labels and selects the highest-scoring one. This measures decision accuracy when the candidate labels are known; it is not free-form generation accuracy.
The primary evaluation prompt does not include dialect metadata.
Accuracy by question type
| Type | Correct | Examples | Accuracy |
|---|---|---|---|
| Choice | 6,901 | 7,016 | 98.36% |
Yes/no (noul) |
2,265 | 2,772 | 81.71% |
| Score | 601 | 631 | 95.25% |
The yes/no subset is the main weakness. Consider this when choosing the model for arithmetic-heavy or binary decisions.
vLLM latency sample
A separate 100-example sample was benchmarked using vLLM 0.32.0 on an NVIDIA A40. Requests were sequential, used bfloat16 and constrained candidate labels, and ran locally after five warm-up requests.
| Metric | Result |
|---|---|
| Mean latency | 61.3 ms/request |
| Median latency | 59.9 ms/request |
| 95th-percentile latency | 71.3 ms/request |
| Sequential throughput | 16.3 requests/second |
These are local, single-request measurements; latency and throughput vary with hardware, prompt length, concurrency, and serving configuration. The sample's 93/100 accuracy is not the full held-out test score above.
Quick start
Transformers
Install the runtime dependencies (use Transformers 5.17 or newer for Qwen3.5):
pip install "transformers>=5.17" torch
Load Ara-JEV directly with standard Transformers. The predict function keeps
prompt construction and constrained option scoring together:
import torch
from transformers import AutoModelForImageTextToText
model_id = "AhmedReda25300/Ara-JEV"
model = AutoModelForImageTextToText.from_pretrained(
model_id,
dtype=torch.bfloat16,
device_map="auto",
trust_remote_code=True,
).eval()
result = model.predict(
state="ุงูุงุฌุชู
ุงุน ูุจุฏุฃ ุงูุณุงุนุฉ ุงูุนุงุดุฑุฉ ุตุจุงุญูุง. ุฏูููุชู ุงูุณุงุนุฉ ุชุณุนุฉ.",
question="ูู ุจุฏุฃ ุงูุงุฌุชู
ุงุนุ",
options=["ูุนู
", "ูุง"],
)
print(result) # ูุง
score = model.predict(
state=(
"ุจูุงุบ ุงูุฏุนู
ุจูููู ุฅู ุจูุงูุงุช ุดุฎุตูุฉ ุธูุฑุช ูู
ุณุชุฎุฏู
ู
ุด ุตุงุญุจูุง. "
"ุงูุชูุงุตู ูุงู ุนู ุทุฑูู ุชุฐูุฑุฉ ู
ู ููุญุฉ ุงูุชุญูู
ุ ูุงูุนู
ูู ุทูุจ ุชุญุฏูุซ ูู
ุง ูุธูุฑ ุฌุฏูุฏ."
),
question="ูููู
ุฃููููุฉ ุงูุชุนุงู
ู ู
ุน ุงูุจูุงุบ.",
options=[
"ู
ูุฎูุถุฉ: ูุชุงุจุน ูู ุงูู
ุณุงุฑ ุงูู
ุนุชุงุฏ",
"ู
ุชูุณุทุฉ: ู
ุญุชุงุฌุฉ ู
ุชุงุจุนุฉ ูุฑูุจุฉ",
"ุนุงููุฉ: ุชุชุตุนูุฏ ุจุณุฑุนุฉ ุจุณุจุจ ุงูุฃุซุฑ",
],
)
print(score) # 2 (integer index of the selected option)
The prediction helper is built into the Transformers model class, so prompt
construction and option scoring are handled internally. No dialect metadata is
required. Arabic Yes/No options return the chosen option text; other option
lists return the selected option's zero-based integer index. trust_remote_code
is required to load Ara-JEV's custom predict method from the model repository.
vLLM
vllm serve AhmedReda25300/Ara-JEV \
--dtype bfloat16 \
--max-model-len 8192
The checkpoint was tested with vLLM 0.32.0. Use the chat-completions API and constrain the response to the labels allowed for each task when supported by your serving client.
Intended use and limitations
- Intended for Arabic decision and routing tasks similar to the evaluation data.
- Performance on dialects, domains, and tasks not represented in evaluation has not been established.
- For the reported evaluation, candidate labels were known and predictions were selected from those labels. Do not interpret that score as open-ended reasoning or general Arabic understanding.
- Test accuracy is an aggregate; results vary by question type, as shown above. Validate on representative data before deployment.
- The model is not a substitute for expert review in high-impact decisions.
- Downloads last month
- 1,095