Release original SafeAge-trained xlmr baseline checkpoint

Original evaluated weights matched to archived training-run SHA256 records; includes tokenizer, frozen validation threshold, loading example, attribution, and provenance. No retraining or new evaluation.

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+tokenizer.json filter=lfs diff=lfs merge=lfs -text

LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) Facebook, Inc. and its affiliates.
+Copyright (c) 2026 SafeAge authors (fine-tuning and original release materials).
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

LICENSE.base-model.mit

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Facebook, Inc. and its affiliates.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -0,0 +1,114 @@
+---
+language:
+- bn
+- en
+license: mit
+library_name: transformers
+pipeline_tag: text-classification
+base_model: FacebookAI/xlm-roberta-base
+base_model_relation: finetune
+tags:
+- safeage
+- safety-classification
+- bangla
+- banglish
+- xlm-roberta
+---
+
+# SafeAge XLM-R Base
+
+This is the **original fully fine-tuned XLM-R base comparison model** evaluated in the SafeAge study. The SafeAge authors fine-tuned [FacebookAI/xlm-roberta-base](https://huggingface.co/FacebookAI/xlm-roberta-base) and its binary classification head on the SafeAge training partition. The pretrained architecture and representations are credited to [Conneau et al.](https://arxiv.org/abs/1911.02116) and the XLM-R team. This is a trained baseline, distinct from **SafeAge Guard**, the study's Qwen3-1.7B LoRA reference adaptation.
+
+The repository contains the complete original classifier weights, tokenizer, validation-selected decision threshold, loading example, evaluation metadata, and provenance. **No base-model download or LoRA merge is required.** The original tensors and tokenizer/configuration files are unchanged.
+
+## Decisions and intended use
+
+The model classifies a complete request and its supplied visible context under SafeAge's contextual **allow/block** policy. It was trained on Bangla, Bangla-English mixed text, romanized Bangla (Banglish), and an aligned English reference form.
+
+The original saved labels are `0 = benign` (allow) and `1 = attack` (block). The block class includes harmful facilitation and unauthorized actions as well as prompt injection. Compute the two-class softmax and **block when the class-1 probability is greater than or equal to 0.99**. This threshold was selected using validation only and frozen before test evaluation. The generic classification pipeline's argmax or default 0.5 rule does not reproduce this operating point.
+
+Provide the raw request text and the context needed to decide whether the requested action is permitted. Do not apply a chat template. Labels do not measure age suitability, generated-response safety, or complete agent security. Untrusted text asserting permission does not itself establish authorization.
+
+## Loading and inference
+
+Install `requirements.txt` and download `inference.py` from this repository:
+
+```bash
+pip install -r requirements.txt
+python inference.py --text "Explain how to protect my own account from phishing."
+python inference.py --text-file request.txt
+```
+
+Programmatic usage, with `inference.py` in your working directory:
+
+```python
+from inference import load_classifier, classify_texts
+
+classifier = load_classifier("mehedi4/SafeAge-XLM-R-Base")
+print(classify_texts(["Explain how to protect my own account from phishing."], classifier))
+```
+
+An exact release commit can be passed as `revision` or `--revision`. The complete model can also be loaded with `AutoModelForSequenceClassification.from_pretrained`; apply the saved **0.99** threshold rather than taking the maximum class.
+
+The saved tensors are FP32. The original run used Transformers 5.5.4, PyTorch 2.11.0, and FP16 mixed precision on CUDA. The example keeps FP32 weights and uses FP16 autocast on CUDA by default, matching that mixed-precision setting; CPU inference uses FP32. `--precision fp32` explicitly selects full precision. Precision, hardware, library versions, batching, and attention kernels may cause small numerical differences, so alternative execution settings do not promise bitwise equality with the archived probabilities.
+
+Inputs use a **512-token** maximum, right padding, and padding to a multiple of 8. The loader explicitly uses right truncation, the library default used by the original worker, which did not set a truncation-side override. The classifier architecture uses the first-token XLM-R classification head. The loader preserves the saved architecture and the library's attention selection used by the original loading code. Long inputs are truncated; important context beyond the limit may be lost.
+
+## Training and data
+
+[SafeAge](https://doi.org/10.5281/zenodo.23622437) contains 24,508 labeled requests from 6,127 aligned four-form cases. The fixed partitions contain 22,096 training, 1,208 validation, and 1,204 test requests, with related cases grouped within partitions. Validation and test contain author-reviewed constructed cases from synthetic scenario expansions. They are not independently collected user traffic.
+
+The two authors annotated disjoint assigned subsets and repeatedly reviewed their own examples. The same procedure applied to validation and test. No independent double-annotation set was used, so inter-annotator agreement was not estimated.
+
+| Setting | Value |
+|---|---|
+| Pretrained base | `FacebookAI/xlm-roberta-base` |
+| Exact pretrained revision | `e73636d4f797dec63c3081bb6ed5c7b0bb3f2089` |
+| Training method | Full fine-tuning, including a binary classification head |
+| Parameters | 278,045,186 |
+| Saved tensor dtype / training precision | FP32 / FP16 mixed |
+| Optimizer / learning rate | AdamW / 0.00002 |
+| Weight decay / warmup | 0.01 / 10% |
+| Effective batch size | 32 |
+| Completed epochs / selected epoch | 5 / 5 |
+| Training seed | 42 |
+| Maximum input length | 512 tokens |
+| Checkpoint selection | Highest validation macro F1 at threshold 0.5 |
+| Decision threshold selection | Validation macro F1 on a 0.01-spaced grid; ties closest to 0.5, then lower threshold |
+
+## Held-out evaluation
+
+At the frozen threshold **0.99**, the original checkpoint achieved the following on **1,204 SafeAge test requests** (301 cases; 199 connected groups):
+
+| Metric | Result |
+|---|---:|
+| Accuracy | 91.03% |
+| Macro F1 | 90.14% |
+| Block precision | 93.15% |
+| Block recall | 81.92% |
+| Benign false positive rate | 3.57% |
+| Brier score | 0.08267 |
+
+Confusion counts: **729 true negatives, 27 false positives, 81 false negatives, and 367 true positives**. `evaluation/test_metrics.json` contains the original run's results at thresholds 0.5 and 0.99; `evaluation/test_by_language_variant.csv` records language slices. These are archived measurements, not a new inference run during release. The paper's confidence intervals use connected-group resampling and do not estimate training-seed variation.
+
+## Verification and limitations
+
+All **seven original checkpoint files** were checked against the archived run's SHA256 manifest. Five inference-required original files are released byte-for-byte; `trainer_state.json` and `training_args.bin` are training-only artifacts and are not required for inference.
+
+The complete `model.safetensors` SHA256 is:
+
+```text
+050b292486894af1e841a0d4a9f6a3992f5bb3413a4ddeb59806d6a458dce442
+```
+
+The file contains 201 FP32 tensors, including the trained classifier's dense and output projection weights and biases. The archived eight-validation-row reload check passed with a maximum positive-probability difference of `4.27e-08`, as recorded in `provenance/model_reload_check.json`. Release preparation checks artifact identity and structure; it does not add a fresh model evaluation.
+
+Results use a single seed on an author-curated benchmark with synthetic held-out scenarios and no measured independent annotation agreement. Template regularities, translation style, and truncation may affect performance. The model has not established universal safety performance or deployment reliability. Its validation-selected threshold does not guarantee the same error rates on other data.
+
+## License and attribution
+
+The pinned [upstream XLM-R model card](https://huggingface.co/FacebookAI/xlm-roberta-base/blob/e73636d4f797dec63c3081bb6ed5c7b0bb3f2089/README.md) declares **MIT**. The original fairseq MIT copyright notice is included as `LICENSE.base-model.mit`; the source URL and revision are recorded in `provenance/upstream_license_source.json`. The SafeAge fine-tuned release and accompanying original materials use MIT, consistent with the authors' SafeAge Guard release, while preserving upstream attribution. The SafeAge dataset has separate release terms; this model license does not relicense the dataset.
+
+Dataset and adaptation authors: **Md. Rehanul Bary and Mehedi Hasan Emon**. Associated manuscript: *SafeAge: Context-Sensitive Safety Classification for Bangla LLMs and Agentic Systems across Four Language Forms*. No conference acceptance or publication is claimed here.
+
+Historical experiment identifiers in provenance retain their original version strings for traceability. The dataset's display name is **SafeAge**.

SHA256SUMS

@@ -0,0 +1,21 @@
+fb5a8d4e1db3b510fdec89f13a0bd7b04e2340dd3fa090e19618b33f0b8eacd1  LICENSE
+52412d7bc7ce4157ea628bbaacb8829e0a9cb3c58f57f99176126bc8cf2bfc85  LICENSE.base-model.mit
+155fef939c4b3457a7674a19c8c78a10a15731e159b074b1f3b45fd5b30ca8d3  README.md
+886e8ca7cd4f2275bd9ef27ef300947720772e890cb5759b4102f6cd5f97c709  base_model_reference.json
+9438e0e2e31d4e3d23c2dc7c03d828c2fe935ece253961bfc8a1d83dbba59aea  config.json
+5e205df03ac49585e4f32fd21bf2947ecd11470bd380ab2af21dca8c08638f93  decision_threshold.json
+5ad15a1e7c8bfd423f2b9aed05a4439dfffb6f1eb564a8f769f49896fe6f2b4b  evaluation/test_by_language_variant.csv
+f1c4650dc4c37a88c61b18dc3a6217737133ca80f98103de57898ff43497cc8c  evaluation/test_metrics.json
+53325b09949b6cc71e6ffba4d22fc942e3c57f1c68670004367c06545e31a543  inference.py
+050b292486894af1e841a0d4a9f6a3992f5bb3413a4ddeb59806d6a458dce442  model.safetensors
+9ba46d0d822b7a3b52f37a6e598285f78f493e3a898473a2481c02683c5e37b1  provenance/environment.json
+4a0b373298c9cb9b3cbb49a2bc96378cb4ea8aabf7e7afbffa459a1e15426d28  provenance/model_reload_check.json
+17d1b70eb1aa582d07372c1993db738bf0a52fd1a04bc6d791553a29ec90ef73  provenance/original_checkpoint_sha256.json
+840bacdd195a9c6c825fabf9cafa8efd032a7e8073ca181d4c7546a2102cdd08  provenance/release_verification.json
+b378ed2a1680acf4f113e81df1094b4ec9ee76625402b5c3b9e77e6f58b59525  provenance/training_configuration.json
+bc126adec626ce03e965030c2638d3e3358565614e0189268f81cd2023d0bc5f  provenance/upstream_license_source.json
+bec9f2cd81f7396a64ee474145117d81139906443a21480cbe4993c97cb499aa  provenance/upstream_model_card.md
+006e42d58819f1bc1f876431ac60579ce182f586a17b0be69b60d1bdeaf1cb46  provenance/weight_update_check.json
+c7e44a25ec692b836b4336d66c185fa9c0456109dd64b88cd50ccf8954e592c4  requirements.txt
+acbd420e2269cdc1ef45332d3d5c418be4aef6b8cb5a0b7ccae0893485307153  tokenizer.json
+159697d23b04b1e7a607e737f5d331e2d356e8484080d723a9495dafc58caab1  tokenizer_config.json

base_model_reference.json

@@ -0,0 +1,17 @@
+{
+  "model_source": "FacebookAI/xlm-roberta-base",
+  "model_revision": "e73636d4f797dec63c3081bb6ed5c7b0bb3f2089",
+  "training_method": "full_finetune",
+  "requires_base_model_download": false,
+  "num_labels": 2,
+  "id2label": {
+    "0": "benign",
+    "1": "attack"
+  },
+  "max_length": 512,
+  "pad_token_id": 1,
+  "saved_dtype": "float32",
+  "original_training_precision": "float16_mixed",
+  "padding_side": "right",
+  "truncation_side": "right"
+}

config.json

@@ -0,0 +1,39 @@
+{
+  "add_cross_attention": false,
+  "architectures": [
+    "XLMRobertaForSequenceClassification"
+  ],
+  "attention_probs_dropout_prob": 0.1,
+  "bos_token_id": 0,
+  "classifier_dropout": null,
+  "dtype": "float32",
+  "eos_token_id": 2,
+  "hidden_act": "gelu",
+  "hidden_dropout_prob": 0.1,
+  "hidden_size": 768,
+  "id2label": {
+    "0": "benign",
+    "1": "attack"
+  },
+  "initializer_range": 0.02,
+  "intermediate_size": 3072,
+  "is_decoder": false,
+  "label2id": {
+    "attack": 1,
+    "benign": 0
+  },
+  "layer_norm_eps": 1e-05,
+  "max_position_embeddings": 514,
+  "model_type": "xlm-roberta",
+  "num_attention_heads": 12,
+  "num_hidden_layers": 12,
+  "output_past": true,
+  "pad_token_id": 1,
+  "position_embedding_type": "absolute",
+  "problem_type": "single_label_classification",
+  "tie_word_embeddings": true,
+  "transformers_version": "5.5.4",
+  "type_vocab_size": 1,
+  "use_cache": false,
+  "vocab_size": 250002
+}

decision_threshold.json

@@ -0,0 +1,10 @@
+{
+  "threshold": 0.99,
+  "selected_using": "validation_macro_f1",
+  "tie_break": "closest to 0.5, then lower threshold",
+  "source_split": "valid",
+  "positive_class": "attack",
+  "positive_class_id": 1,
+  "comparison": "probability_attack >= threshold",
+  "smoke_run": false
+}

evaluation/test_by_language_variant.csv

@@ -0,0 +1,5 @@
+language_variant,independent_groups,rows,benign_rows,attack_rows,threshold,accuracy,balanced_accuracy,macro_f1,attack_precision,attack_recall,attack_f1,benign_specificity,benign_false_positive_rate,attack_false_negative_rate,roc_auc,average_precision,brier_score,log_loss,tn,fp,fn,tp
+banglish,199,301,189,112,0.99,0.8903654485049833,0.8708664021164021,0.87960145937625,0.898989898989899,0.7946428571428571,0.8436018957345972,0.9470899470899471,0.05291005291005291,0.20535714285714285,0.9588766061980348,0.942103455794577,0.11305866331354969,0.7794276160798205,179,10,23,89
+bn,199,301,189,112,0.99,0.9169435215946844,0.9011243386243386,0.9091808778980653,0.9306930693069307,0.8392857142857143,0.8826291079812206,0.9629629629629629,0.037037037037037035,0.16071428571428573,0.9689862055933484,0.9603811310910885,0.07639742406036554,0.5753729884552156,182,7,18,94
+bn_en,199,301,189,112,0.99,0.9169435215946844,0.8993055555555556,0.9087889843759469,0.9393939393939394,0.8303571428571429,0.8815165876777251,0.9682539682539683,0.031746031746031744,0.16964285714285715,0.9724584278155707,0.9630867201418858,0.07518063140097832,0.5491630271223695,183,6,19,93
+en,199,301,189,112,0.99,0.9169435215946844,0.8956679894179894,0.9079679569497952,0.9578947368421052,0.8125,0.8792270531400966,0.9788359788359788,0.021164021164021163,0.1875,0.9772770219198792,0.9698465793237102,0.06604231339754098,0.47274693667632417,185,4,21,91

evaluation/test_metrics.json

@@ -0,0 +1,48 @@
+{
+  "default_0_5": {
+    "rows": 1204,
+    "benign_rows": 756,
+    "attack_rows": 448,
+    "threshold": 0.5,
+    "accuracy": 0.9127906976744186,
+    "balanced_accuracy": 0.9000909391534392,
+    "macro_f1": 0.9053775802797357,
+    "attack_precision": 0.9093078758949881,
+    "attack_recall": 0.8504464285714286,
+    "attack_f1": 0.8788927335640139,
+    "benign_specificity": 0.9497354497354498,
+    "benign_false_positive_rate": 0.05026455026455026,
+    "attack_false_negative_rate": 0.14955357142857142,
+    "roc_auc": 0.970037320483749,
+    "average_precision": 0.9595743795979578,
+    "brier_score": 0.08266975804310862,
+    "log_loss": 0.5941776420834323,
+    "tn": 718,
+    "fp": 38,
+    "fn": 67,
+    "tp": 381
+  },
+  "validation_selected": {
+    "rows": 1204,
+    "benign_rows": 756,
+    "attack_rows": 448,
+    "threshold": 0.99,
+    "accuracy": 0.9102990033222591,
+    "balanced_accuracy": 0.8917410714285714,
+    "macro_f1": 0.9013842247522319,
+    "attack_precision": 0.9314720812182741,
+    "attack_recall": 0.8191964285714286,
+    "attack_f1": 0.8717339667458432,
+    "benign_specificity": 0.9642857142857143,
+    "benign_false_positive_rate": 0.03571428571428571,
+    "attack_false_negative_rate": 0.18080357142857142,
+    "roc_auc": 0.970037320483749,
+    "average_precision": 0.9595743795979578,
+    "brier_score": 0.08266975804310862,
+    "log_loss": 0.5941776420834323,
+    "tn": 729,
+    "fp": 27,
+    "fn": 81,
+    "tp": 367
+  }
+}

inference.py

@@ -0,0 +1,86 @@
+"""Load the original fully fine-tuned SafeAge XLM-R binary baseline."""
+import argparse
+import contextlib
+import json
+from pathlib import Path
+
+DEFAULT_REPO = "mehedi4/SafeAge-XLM-R-Base"
+
+
+def load_classifier(source=DEFAULT_REPO, revision=None, device=None, precision="auto"):
+    import torch
+    from huggingface_hub import snapshot_download
+    from transformers import AutoModelForSequenceClassification, AutoTokenizer
+
+    folder = Path(source)
+    if not folder.is_dir():
+        folder = Path(snapshot_download(
+            repo_id=source, revision=revision,
+            allow_patterns=["config.json", "model.safetensors", "decision_threshold.json",
+                            "tokenizer.json", "tokenizer_config.json", "base_model_reference.json"],
+        ))
+    reference = json.loads((folder / "base_model_reference.json").read_text())
+    decision = json.loads((folder / "decision_threshold.json").read_text())
+    tokenizer = AutoTokenizer.from_pretrained(folder, use_fast=True, local_files_only=True)
+    tokenizer.model_max_length = reference["max_length"]
+    tokenizer.padding_side = "right"
+    tokenizer.truncation_side = "right"
+    if tokenizer.pad_token_id != reference["pad_token_id"]:
+        raise ValueError("Padding token differs from the original evaluated tokenizer")
+    model = AutoModelForSequenceClassification.from_pretrained(
+        folder, local_files_only=True, use_safetensors=True, dtype=torch.float32,
+    ).eval()
+    if model.config.model_type != "xlm-roberta" or model.config.num_labels != 2:
+        raise ValueError("Expected the original binary XLM-R classifier")
+    model.requires_grad_(False)
+    device = torch.device(device or ("cuda" if torch.cuda.is_available() else "cpu"))
+    if precision not in {"auto", "fp32", "fp16_mixed"}:
+        raise ValueError("Precision must be auto, fp32, or fp16_mixed")
+    mixed = device.type == "cuda" if precision == "auto" else precision == "fp16_mixed"
+    if mixed and device.type != "cuda":
+        raise ValueError("FP16 mixed inference requires a CUDA device; use fp32 on CPU")
+    model.to(device)
+    return model, tokenizer, reference, decision, mixed
+
+
+def classify_texts(texts, classifier):
+    """Classify complete raw requests with context; no chat template is applied."""
+    import torch
+    if isinstance(texts, str):
+        texts = [texts]
+    if not texts or any(not isinstance(text, str) for text in texts):
+        raise ValueError("Supply one or more strings")
+    model, tokenizer, reference, decision, mixed = classifier
+    encoded = tokenizer(
+        texts, truncation=True, max_length=reference["max_length"], padding=True,
+        pad_to_multiple_of=8, return_token_type_ids=False, return_tensors="pt",
+    )
+    device = next(model.parameters()).device
+    encoded = {key: value.to(device) for key, value in encoded.items()}
+    amp = torch.autocast(device_type="cuda", dtype=torch.float16) if mixed else contextlib.nullcontext()
+    with torch.inference_mode(), amp:
+        logits = model(**encoded).logits
+    # The archived worker computes softmax after converting logits to float64.
+    values = torch.softmax(logits.double(), dim=-1)[:, decision["positive_class_id"]].cpu().tolist()
+    threshold = float(decision["threshold"])
+    return [{"decision": "block" if p >= threshold else "allow",
+             "block_probability": p, "threshold": threshold} for p in values]
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    group = parser.add_mutually_exclusive_group(required=True)
+    group.add_argument("--text", help="Complete raw request and its visible context")
+    group.add_argument("--text-file", type=Path, help="UTF-8 file containing one complete request")
+    parser.add_argument("--source", default=DEFAULT_REPO, help="Hub repository or local folder")
+    parser.add_argument("--revision", help="Optional exact release commit")
+    parser.add_argument("--device", help="cpu, cuda, or cuda:0; default selects CUDA if available")
+    parser.add_argument("--precision", choices=["auto", "fp32", "fp16_mixed"], default="auto")
+    args = parser.parse_args()
+    text = args.text if args.text is not None else args.text_file.read_text(encoding="utf-8")
+    classifier = load_classifier(args.source, args.revision, args.device, args.precision)
+    print(json.dumps(classify_texts(text, classifier)[0], ensure_ascii=False, indent=2))
+
+
+if __name__ == "__main__":
+    main()

model.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:050b292486894af1e841a0d4a9f6a3992f5bb3413a4ddeb59806d6a458dce442
+size 1112204984

provenance/environment.json

@@ -0,0 +1,17 @@
+{
+  "versions": {
+    "torch": "2.11.0+cu128",
+    "transformers": "5.5.4",
+    "accelerate": "1.13.0",
+    "numpy": "2.1.3",
+    "pandas": "2.3.3",
+    "scikit-learn": "1.6.1",
+    "tokenizers": "0.22.2",
+    "huggingface-hub": "1.29.0"
+  },
+  "cuda_version": "12.8",
+  "world_size": 2,
+  "effective_batch_size": 32,
+  "model_revision": "e73636d4f797dec63c3081bb6ed5c7b0bb3f2089",
+  "model_path": "/kaggle/working/hf_cache/models--FacebookAI--xlm-roberta-base/snapshots/e73636d4f797dec63c3081bb6ed5c7b0bb3f2089"
+}

provenance/model_reload_check.json

@@ -0,0 +1,5 @@
+{
+  "status": "PASS",
+  "validation_rows": 8,
+  "maximum_probability_difference": 4.270144715601276e-08
+}

provenance/original_checkpoint_sha256.json

@@ -0,0 +1,9 @@
+{
+  "config.json": "9438e0e2e31d4e3d23c2dc7c03d828c2fe935ece253961bfc8a1d83dbba59aea",
+  "decision_threshold.json": "5e205df03ac49585e4f32fd21bf2947ecd11470bd380ab2af21dca8c08638f93",
+  "model.safetensors": "050b292486894af1e841a0d4a9f6a3992f5bb3413a4ddeb59806d6a458dce442",
+  "tokenizer.json": "acbd420e2269cdc1ef45332d3d5c418be4aef6b8cb5a0b7ccae0893485307153",
+  "tokenizer_config.json": "159697d23b04b1e7a607e737f5d331e2d356e8484080d723a9495dafc58caab1",
+  "trainer_state.json": "9234ad8b94308a82c0a487c5265167d8f5afea7cde4174e006fb68a2475cf431",
+  "training_args.bin": "dcc4257d8b83dec675a33e0ee1af4429f34c4f1bc5a015012563a466d0c5eb20"
+}

provenance/release_verification.json

@@ -0,0 +1,83 @@
+{
+  "repository": "mehedi4/SafeAge-XLM-R-Base",
+  "original_checkpoint_directory": "xlmr/safeage_v3_xlmr_base_full_seed42_20261024_144752_7006aa/best_model",
+  "all_original_checkpoint_files_verified": true,
+  "original_file_count": 7,
+  "original_checkpoint_sha256": {
+    "config.json": "9438e0e2e31d4e3d23c2dc7c03d828c2fe935ece253961bfc8a1d83dbba59aea",
+    "decision_threshold.json": "5e205df03ac49585e4f32fd21bf2947ecd11470bd380ab2af21dca8c08638f93",
+    "model.safetensors": "050b292486894af1e841a0d4a9f6a3992f5bb3413a4ddeb59806d6a458dce442",
+    "tokenizer.json": "acbd420e2269cdc1ef45332d3d5c418be4aef6b8cb5a0b7ccae0893485307153",
+    "tokenizer_config.json": "159697d23b04b1e7a607e737f5d331e2d356e8484080d723a9495dafc58caab1",
+    "trainer_state.json": "9234ad8b94308a82c0a487c5265167d8f5afea7cde4174e006fb68a2475cf431",
+    "training_args.bin": "dcc4257d8b83dec675a33e0ee1af4429f34c4f1bc5a015012563a466d0c5eb20"
+  },
+  "published_original_files": [
+    "config.json",
+    "decision_threshold.json",
+    "model.safetensors",
+    "tokenizer.json",
+    "tokenizer_config.json"
+  ],
+  "excluded_training_only_files": [
+    "trainer_state.json",
+    "training_args.bin"
+  ],
+  "all_published_checkpoint_files_unchanged": true,
+  "model_tensor_count": 201,
+  "model_parameter_count": 278045186,
+  "classifier_tensors": {
+    "classifier.dense.bias": {
+      "dtype": "F32",
+      "shape": [
+        768
+      ],
+      "data_offsets": [
+        0,
+        3072
+      ]
+    },
+    "classifier.dense.weight": {
+      "dtype": "F32",
+      "shape": [
+        768,
+        768
+      ],
+      "data_offsets": [
+        3072,
+        2362368
+      ]
+    },
+    "classifier.out_proj.bias": {
+      "dtype": "F32",
+      "shape": [
+        2
+      ],
+      "data_offsets": [
+        2362368,
+        2362376
+      ]
+    },
+    "classifier.out_proj.weight": {
+      "dtype": "F32",
+      "shape": [
+        2,
+        768
+      ],
+      "data_offsets": [
+        2362376,
+        2368520
+      ]
+    }
+  },
+  "base_model_revision": "e73636d4f797dec63c3081bb6ed5c7b0bb3f2089",
+  "threshold": 0.99,
+  "inference_script_syntax_valid": true,
+  "release_new_inference_performed": false,
+  "original_model_reload_check": {
+    "status": "PASS",
+    "validation_rows": 8,
+    "maximum_probability_difference": 4.270144715601276e-08
+  },
+  "license_selection_source": "Pinned upstream XLM-R card declares MIT; upstream fairseq copyright preserved; MIT for SafeAge modifications follows the authors' existing SafeAge Guard release."
+}

provenance/training_configuration.json

@@ -0,0 +1,19 @@
+{
+  "seed": 42,
+  "model_source": "FacebookAI/xlm-roberta-base",
+  "model_revision": "e73636d4f797dec63c3081bb6ed5c7b0bb3f2089",
+  "max_length": 512,
+  "expected_world_size": 2,
+  "per_device_train_batch_size": 4,
+  "gradient_accumulation_steps": 4,
+  "epochs": 5,
+  "learning_rate": 2e-05,
+  "weight_decay": 0.01,
+  "warmup_fraction": 0.1,
+  "optimizer": "adamw_torch",
+  "fp16": true,
+  "bf16": false,
+  "precision": "float16_mixed",
+  "training_method": "full_finetune",
+  "resolved_model_revision": "e73636d4f797dec63c3081bb6ed5c7b0bb3f2089"
+}

provenance/upstream_license_source.json

@@ -0,0 +1,6 @@
+{
+  "license": "MIT",
+  "pinned_huggingface_card": "https://huggingface.co/FacebookAI/xlm-roberta-base/blob/e73636d4f797dec63c3081bb6ed5c7b0bb3f2089/README.md",
+  "license_file_source": "https://raw.githubusercontent.com/facebookresearch/fairseq/3d262bb25690e4eb2e7d3c1309b1e9c406ca4b99/LICENSE",
+  "upstream_fairseq_revision": "3d262bb25690e4eb2e7d3c1309b1e9c406ca4b99"
+}

provenance/upstream_model_card.md

@@ -0,0 +1,200 @@
+---
+tags:
+- exbert
+language: 
+- multilingual
+- af
+- am
+- ar
+- as
+- az
+- be
+- bg
+- bn
+- br
+- bs
+- ca
+- cs
+- cy
+- da
+- de
+- el
+- en
+- eo
+- es
+- et
+- eu
+- fa
+- fi
+- fr
+- fy
+- ga
+- gd
+- gl
+- gu
+- ha
+- he
+- hi
+- hr
+- hu
+- hy
+- id
+- is
+- it
+- ja
+- jv
+- ka
+- kk
+- km
+- kn
+- ko
+- ku
+- ky
+- la
+- lo
+- lt
+- lv
+- mg
+- mk
+- ml
+- mn
+- mr
+- ms
+- my
+- ne
+- nl
+- no
+- om
+- or
+- pa
+- pl
+- ps
+- pt
+- ro
+- ru
+- sa
+- sd
+- si
+- sk
+- sl
+- so
+- sq
+- sr
+- su
+- sv
+- sw
+- ta
+- te
+- th
+- tl
+- tr
+- ug
+- uk
+- ur
+- uz
+- vi
+- xh
+- yi
+- zh
+license: mit
+---
+
+# XLM-RoBERTa (base-sized model) 
+
+XLM-RoBERTa model pre-trained on 2.5TB of filtered CommonCrawl data containing 100 languages. It was introduced in the paper [Unsupervised Cross-lingual Representation Learning at Scale](https://arxiv.org/abs/1911.02116) by Conneau et al. and first released in [this repository](https://github.com/pytorch/fairseq/tree/master/examples/xlmr). 
+
+Disclaimer: The team releasing XLM-RoBERTa did not write a model card for this model so this model card has been written by the Hugging Face team.
+
+## Model description
+
+XLM-RoBERTa is a multilingual version of RoBERTa. It is pre-trained on 2.5TB of filtered CommonCrawl data containing 100 languages. 
+
+RoBERTa is a transformers model pretrained on a large corpus in a self-supervised fashion. This means it was pretrained on the raw texts only, with no humans labelling them in any way (which is why it can use lots of publicly available data) with an automatic process to generate inputs and labels from those texts.
+
+More precisely, it was pretrained with the Masked language modeling (MLM) objective. Taking a sentence, the model randomly masks 15% of the words in the input then run the entire masked sentence through the model and has to predict the masked words. This is different from traditional recurrent neural networks (RNNs) that usually see the words one after the other, or from autoregressive models like GPT which internally mask the future tokens. It allows the model to learn a bidirectional representation of the sentence.
+
+This way, the model learns an inner representation of 100 languages that can then be used to extract features useful for downstream tasks: if you have a dataset of labeled sentences for instance, you can train a standard classifier using the features produced by the XLM-RoBERTa model as inputs.
+
+## Intended uses & limitations
+
+You can use the raw model for masked language modeling, but it's mostly intended to be fine-tuned on a downstream task. See the [model hub](https://huggingface.co/models?search=xlm-roberta) to look for fine-tuned versions on a task that interests you.
+
+Note that this model is primarily aimed at being fine-tuned on tasks that use the whole sentence (potentially masked) to make decisions, such as sequence classification, token classification or question answering. For tasks such as text generation, you should look at models like GPT2.
+
+## Usage
+
+You can use this model directly with a pipeline for masked language modeling:
+
+```python
+>>> from transformers import pipeline
+>>> unmasker = pipeline('fill-mask', model='xlm-roberta-base')
+>>> unmasker("Hello I'm a <mask> model.")
+
+[{'score': 0.10563907772302628,
+  'sequence': "Hello I'm a fashion model.",
+  'token': 54543,
+  'token_str': 'fashion'},
+ {'score': 0.08015287667512894,
+  'sequence': "Hello I'm a new model.",
+  'token': 3525,
+  'token_str': 'new'},
+ {'score': 0.033413201570510864,
+  'sequence': "Hello I'm a model model.",
+  'token': 3299,
+  'token_str': 'model'},
+ {'score': 0.030217764899134636,
+  'sequence': "Hello I'm a French model.",
+  'token': 92265,
+  'token_str': 'French'},
+ {'score': 0.026436051353812218,
+  'sequence': "Hello I'm a sexy model.",
+  'token': 17473,
+  'token_str': 'sexy'}]
+```
+
+Here is how to use this model to get the features of a given text in PyTorch:
+
+```python
+from transformers import AutoTokenizer, AutoModelForMaskedLM
+
+tokenizer = AutoTokenizer.from_pretrained('xlm-roberta-base')
+model = AutoModelForMaskedLM.from_pretrained("xlm-roberta-base")
+
+# prepare input
+text = "Replace me by any text you'd like."
+encoded_input = tokenizer(text, return_tensors='pt')
+
+# forward pass
+output = model(**encoded_input)
+```
+
+### BibTeX entry and citation info
+
+```bibtex
+@article{DBLP:journals/corr/abs-1911-02116,
+  author    = {Alexis Conneau and
+               Kartikay Khandelwal and
+               Naman Goyal and
+               Vishrav Chaudhary and
+               Guillaume Wenzek and
+               Francisco Guzm{\'{a}}n and
+               Edouard Grave and
+               Myle Ott and
+               Luke Zettlemoyer and
+               Veselin Stoyanov},
+  title     = {Unsupervised Cross-lingual Representation Learning at Scale},
+  journal   = {CoRR},
+  volume    = {abs/1911.02116},
+  year      = {2019},
+  url       = {http://arxiv.org/abs/1911.02116},
+  eprinttype = {arXiv},
+  eprint    = {1911.02116},
+  timestamp = {Mon, 11 Nov 2019 18:38:09 +0100},
+  biburl    = {https://dblp.org/rec/journals/corr/abs-1911-02116.bib},
+  bibsource = {dblp computer science bibliography, https://dblp.org}
+}
+```
+
+<a href="https://huggingface.co/exbert/?model=xlm-roberta-base">
+	<img width="300px" src="https://cdn-media.huggingface.co/exbert/button.png">
+</a>

provenance/weight_update_check.json

@@ -0,0 +1,5 @@
+{
+  "changed": true,
+  "initial_classifier_head_sha256": "8525992b7c0f62ea5e7d4d9ba33a20aa71acf73016426ef8315c03aa6386e112",
+  "selected_classifier_head_sha256": "79dc02c2255263b0d4b98924ab1a23831c33d92c4505deda2b88e3f6b5027f1d"
+}

requirements.txt

@@ -0,0 +1,6 @@
+torch==2.11.0
+transformers==5.5.4
+accelerate==1.13.0
+tokenizers==0.22.2
+huggingface_hub==1.29.0
+safetensors>=0.4.3

tokenizer.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:acbd420e2269cdc1ef45332d3d5c418be4aef6b8cb5a0b7ccae0893485307153
+size 17098086

tokenizer_config.json

@@ -0,0 +1,14 @@
+{
+  "add_prefix_space": true,
+  "backend": "tokenizers",
+  "bos_token": "<s>",
+  "cls_token": "<s>",
+  "eos_token": "</s>",
+  "is_local": true,
+  "mask_token": "<mask>",
+  "model_max_length": 512,
+  "pad_token": "<pad>",
+  "sep_token": "</s>",
+  "tokenizer_class": "XLMRobertaTokenizer",
+  "unk_token": "<unk>"
+}