ASL-4B-v1

ASL 4B

ASL (أصل) is a 4-billion-parameter Arabic language model developed by SAAI. Built on Qwen3.5 and professionally tuned, it is designed to provide strong Arabic-language capabilities in a compact and efficient model, with particular emphasis on understanding Saudi dialect and local Saudi context.

The ASL Model was trained on a blend of open-source datasets and proprietary local data contributed by our partners. The data includes Saudi books, literary works, and journalistic publications. This training approach aims to deepen the model's understanding of Modern Standard Arabic, Saudi dialect, and local and institutional contexts.

ASL is SAAI's first research release and the first step in a longer effort to develop small, efficient, specialized Arabic models with native awareness of local context. Future releases will incorporate feedback, insights, and contributions from collaborators across the Arab research community.

Model Details

Recommended Generation Configurations

ASL supports both reasoning-enabled and standard-generation modes. The following settings are recommended starting points for vLLM and Hugging Face Transformers.

Note: Enable or disable reasoning using the model's chat template, serving framework, or inference API. The sampling settings below control generation behavior; they do not independently toggle reasoning.

Reasoning Enabled

Use this mode for mathematical reasoning, multi-step problem solving, structured analysis, and tasks where deliberate reasoning improves answer quality.

vLLM

from vllm import SamplingParams

reasoning_sampling_params = SamplingParams(
    temperature=0.6,
    top_p=0.95,
    top_k=20,
    min_p=0.0,
    presence_penalty=0.5,
    repetition_penalty=1.05,
)

Hugging Face Transformers

import torch
from transformers import LogitsProcessor, LogitsProcessorList

class PresenceFrequencyPenaltyProcessor(LogitsProcessor):
    def __init__(self, prompt_length, presence_penalty=0.0, frequency_penalty=0.0):
        self.prompt_length = prompt_length
        self.presence_penalty = presence_penalty
        self.frequency_penalty = frequency_penalty

    def __call__(self, input_ids, scores):
        generated_ids = input_ids[:, self.prompt_length:]

        for batch_index, token_ids in enumerate(generated_ids):
            unique_tokens, counts = torch.unique(token_ids, return_counts=True)

            if self.presence_penalty != 0.0:
                scores[batch_index, unique_tokens] -= self.presence_penalty

            if self.frequency_penalty != 0.0:
                scores[batch_index, unique_tokens] -= (
                    self.frequency_penalty * counts.to(scores.dtype)
                )

        return scores

inputs = tokenizer(prompt, return_tensors="pt").to(model.device)
prompt_length = inputs.input_ids.shape[3]

reasoning_logits_processor = LogitsProcessorList([
    PresenceFrequencyPenaltyProcessor(
        prompt_length=prompt_length,
        presence_penalty=0.5,
        frequency_penalty=0.0,
    )
])

output_ids = model.generate(
    **inputs,
    do_sample=True,
    temperature=0.6,
    top_p=0.95,
    top_k=20,
    min_p=0.0,
    repetition_penalty=1.05,
    logits_processor=reasoning_logits_processor,
    max_new_tokens=2048,
)

Reasoning Disabled

Use this mode for general chat, text generation, extraction, classification, and latency-sensitive workloads where explicit multi-step reasoning is not required.

vLLM

from vllm import SamplingParams

standard_sampling_params = SamplingParams(
    temperature=0.7,
    top_p=0.8,
    top_k=20,
    min_p=0.0,
    presence_penalty=1.0,
    frequency_penalty=0.0,
    repetition_penalty=1.0,
)

Hugging Face Transformers

import torch
from transformers import LogitsProcessor, LogitsProcessorList

class PresenceFrequencyPenaltyProcessor(LogitsProcessor):
    def __init__(self, prompt_length, presence_penalty=0.0, frequency_penalty=0.0):
        self.prompt_length = prompt_length
        self.presence_penalty = presence_penalty
        self.frequency_penalty = frequency_penalty

    def __call__(self, input_ids, scores):
        generated_ids = input_ids[:, self.prompt_length:]

        for batch_index, token_ids in enumerate(generated_ids):
            unique_tokens, counts = torch.unique(token_ids, return_counts=True)

            if self.presence_penalty != 0.0:
                scores[batch_index, unique_tokens] -= self.presence_penalty

            if self.frequency_penalty != 0.0:
                scores[batch_index, unique_tokens] -= (
                    self.frequency_penalty * counts.to(scores.dtype)
                )

        return scores

inputs = tokenizer(prompt, return_tensors="pt").to(model.device)
prompt_length = inputs.input_ids.shape[3]

standard_logits_processor = LogitsProcessorList([
    PresenceFrequencyPenaltyProcessor(
        prompt_length=prompt_length,
        presence_penalty=1.0,
        frequency_penalty=0.0,
    )
])

output_ids = model.generate(
    **inputs,
    do_sample=True,
    temperature=0.7,
    top_p=0.8,
    top_k=20,
    min_p=0.0,
    repetition_penalty=1.0,
    logits_processor=standard_logits_processor,
    max_new_tokens=2048,
)

Benchmark Results

The benchmarks were evaluated using a customized version of the LM Evaluation Harness. The Reasoning AraMath evaluation was conducted separately using an answer-parsing approach. All benchmarks were evaluated in a zero-shot setting, with no task-specific examples provided in the prompts. The following results compare ASL (4B) with Qwen3.5 4B, Fanar 1 (9B), Fanar 2 (27B), and ALLaM 7B. Higher scores indicate better performance for all benchmarks except AraSafe invalid rate, where lower is better. n/a indicates that a result was not available.

Intended Use

ASL is intended for research and development of Arabic language applications, including Arabic text generation, Saudi-dialect understanding, local-context assistance.

Limitations

ASL may generate inaccurate, incomplete, or biased content. Benchmark performance does not guarantee reliability in real-world settings. Evaluate the model for the target use case, especially before deploying it in high-impact, safety-sensitive, or decision-making applications.

License

ASL is released under the Apache License 2.0.