Upload folder using huggingface_hub

README.md

@@ -0,0 +1,82 @@
+---
+language: en
+library_name: pytorch
+license: mit
+pipeline_tag: text-classification
+tags:
+  - pytorch
+  - multitask
+  - ai-detection
+---
+
+# SuaveAI Detection Multitask Model V1
+
+This repository contains a custom PyTorch multitask model checkpoint and auxiliary files.
+
+## Files
+
+- `multitask_model.pth`: model checkpoint weights
+- `label_encoder.pkl`: label encoder used to map predictions to labels
+- `tok.txt`: tokenizer/vocabulary artifact used during preprocessing
+
+## Important
+
+This is a **custom PyTorch checkpoint** and is not a native Transformers `AutoModel` package.
+This repo now includes Hugging Face custom-code files so it can be loaded from Hub with
+`trust_remote_code=True`.
+
+## Load from Hugging Face Hub
+
+```python
+import torch
+from transformers import AutoModel, AutoTokenizer
+
+repo_id = "DaJulster/SuaveAI-Dectection-Multitask-Model-V1"
+
+tokenizer = AutoTokenizer.from_pretrained(repo_id, trust_remote_code=True)
+model = AutoModel.from_pretrained(repo_id, trust_remote_code=True)
+model.eval()
+
+text = "This is a sample input"
+inputs = tokenizer(text, return_tensors="pt", truncation=True)
+with torch.no_grad():
+  outputs = model(**inputs)
+
+binary_logits = outputs.logits_binary
+multiclass_logits = outputs.logits_multiclass
+```
+
+Binary prediction uses `logits_binary`, and AI-model classification uses `logits_multiclass`.
+
+## Quick start
+
+```python
+import torch
+import pickle
+
+# 1) Recreate your model class exactly as in training
+# from model_def import MultiTaskModel
+# model = MultiTaskModel(...)
+
+model = ...  # instantiate your model architecture
+state = torch.load("multitask_model.pth", map_location="cpu")
+model.load_state_dict(state)
+model.eval()
+
+with open("label_encoder.pkl", "rb") as f:
+    label_encoder = pickle.load(f)
+
+with open("tok.txt", "r", encoding="utf-8") as f:
+    tokenizer_artifact = f.read()
+
+# Run your preprocessing + inference pipeline here
+```
+
+## Intended use
+
+- Multitask AI detection inference in your custom pipeline.
+
+## Limitations
+
+- Requires matching model definition and preprocessing pipeline.
+- Not plug-and-play with `transformers.AutoModel.from_pretrained`.

configuration_suave_multitask.py

@@ -0,0 +1,17 @@
+from transformers import PretrainedConfig
+
+
+class SuaveMultitaskConfig(PretrainedConfig):
+    model_type = "suave_multitask"
+
+    def __init__(
+        self,
+        base_model_name="roberta-base",
+        num_ai_classes=2,
+        classifier_dropout=0.1,
+        **kwargs,
+    ):
+        self.base_model_name = base_model_name
+        self.num_ai_classes = num_ai_classes
+        self.classifier_dropout = classifier_dropout
+        super().__init__(**kwargs)

modeling_suave_multitask.py

@@ -0,0 +1,71 @@
+from dataclasses import dataclass
+from typing import Optional, Tuple
+
+import torch
+import torch.nn as nn
+from transformers import AutoModel, PreTrainedModel
+from transformers.modeling_outputs import ModelOutput
+
+from configuration_suave_multitask import SuaveMultitaskConfig
+
+
+@dataclass
+class SuaveMultitaskOutput(ModelOutput):
+    loss: Optional[torch.FloatTensor] = None
+    logits_binary: Optional[torch.FloatTensor] = None
+    logits_multiclass: Optional[torch.FloatTensor] = None
+    hidden_states: Optional[Tuple[torch.FloatTensor, ...]] = None
+    attentions: Optional[Tuple[torch.FloatTensor, ...]] = None
+
+
+class SuaveMultitaskModel(PreTrainedModel):
+    config_class = SuaveMultitaskConfig
+    base_model_prefix = "encoder"
+
+    def __init__(self, config: SuaveMultitaskConfig):
+        super().__init__(config)
+        self.encoder = AutoModel.from_pretrained(config.base_model_name)
+        hidden_size = self.encoder.config.hidden_size
+
+        self.dropout = nn.Dropout(config.classifier_dropout)
+        self.classifier_binary = nn.Linear(hidden_size, 2)
+        self.classifier_multiclass = nn.Linear(hidden_size, config.num_ai_classes)
+
+        self.post_init()
+
+    def forward(
+        self,
+        input_ids=None,
+        attention_mask=None,
+        labels_binary=None,
+        labels_multiclass=None,
+        **kwargs,
+    ):
+        outputs = self.encoder(
+            input_ids=input_ids,
+            attention_mask=attention_mask,
+            output_hidden_states=kwargs.get("output_hidden_states", False),
+            output_attentions=kwargs.get("output_attentions", False),
+        )
+
+        pooled = outputs.last_hidden_state[:, 0]
+        pooled = self.dropout(pooled)
+
+        logits_binary = self.classifier_binary(pooled)
+        logits_multiclass = self.classifier_multiclass(pooled)
+
+        loss = None
+        if labels_binary is not None and labels_multiclass is not None:
+            loss_binary = nn.CrossEntropyLoss()(logits_binary, labels_binary)
+            loss_multiclass = nn.CrossEntropyLoss(ignore_index=-1)(
+                logits_multiclass, labels_multiclass
+            )
+            loss = loss_binary + 0.5 * loss_multiclass
+
+        return SuaveMultitaskOutput(
+            loss=loss,
+            logits_binary=logits_binary,
+            logits_multiclass=logits_multiclass,
+            hidden_states=outputs.hidden_states,
+            attentions=outputs.attentions,
+        )

prepare_hf_artifacts.py

@@ -0,0 +1,50 @@
+from pathlib import Path
+import pickle
+
+import torch
+from transformers import AutoTokenizer
+
+from configuration_suave_multitask import SuaveMultitaskConfig
+from modeling_suave_multitask import SuaveMultitaskModel
+
+
+def main():
+    model_ckpt = Path("multitask_model.pth")
+    label_encoder_path = Path("label_encoder.pkl")
+
+    if not model_ckpt.exists():
+        raise FileNotFoundError("multitask_model.pth not found")
+    if not label_encoder_path.exists():
+        raise FileNotFoundError("label_encoder.pkl not found")
+
+    with open(label_encoder_path, "rb") as file:
+        label_encoder = pickle.load(file)
+
+    num_ai_classes = len(label_encoder.classes_)
+
+    config = SuaveMultitaskConfig(
+        base_model_name="roberta-base",
+        num_ai_classes=num_ai_classes,
+        id2label={0: "human", 1: "ai"},
+        label2id={"human": 0, "ai": 1},
+    )
+    config.auto_map = {
+        "AutoConfig": "configuration_suave_multitask.SuaveMultitaskConfig",
+        "AutoModel": "modeling_suave_multitask.SuaveMultitaskModel",
+    }
+
+    model = SuaveMultitaskModel(config)
+    state_dict = torch.load(model_ckpt, map_location="cpu")
+    model.load_state_dict(state_dict, strict=True)
+    model.eval()
+
+    model.save_pretrained(".", safe_serialization=True)
+
+    tokenizer = AutoTokenizer.from_pretrained(config.base_model_name)
+    tokenizer.save_pretrained(".")
+
+    print("HF artifacts generated: config.json, model.safetensors, tokenizer files")
+
+
+if __name__ == "__main__":
+    main()

upload.py

@@ -0,0 +1,48 @@
+from pathlib import Path
+import os
+
+from huggingface_hub import HfApi
+
+api = HfApi()
+
+# Replace with your desired repo name, e.g., "username/ai-detector-v1"
+repo_id = "DaJulster/SuaveAI-Dectection-Multitask-Model-V1"
+
+required_files = [
+    "multitask_model.pth",
+    "label_encoder.pkl",
+    "README.md",
+]
+
+missing = [file_name for file_name in required_files if not Path(file_name).exists()]
+if missing:
+    raise FileNotFoundError(f"Missing required files: {', '.join(missing)}")
+
+# 1. Create the repository on the Hub (if it doesn't exist)
+api.create_repo(repo_id=repo_id, repo_type="model", exist_ok=True)
+
+# 2. Generate HF-compatible artifacts from existing checkpoint (optional)
+skip_prepare = os.environ.get("SKIP_HF_PREPARE", "0") == "1"
+if not skip_prepare:
+    from prepare_hf_artifacts import main as prepare_hf_artifacts
+
+    prepare_hf_artifacts()
+else:
+    print("Skipping HF artifact generation (SKIP_HF_PREPARE=1)")
+
+# 3. Upload all local artifacts (model card + model files)
+api.upload_folder(
+    folder_path=".",
+    repo_id=repo_id,
+    repo_type="model",
+    ignore_patterns=[
+        "*.pyc",
+        "__pycache__/*",
+        ".git/*",
+        "*.ipynb",
+        "venv/*",
+        "tok.txt",
+    ],
+)
+
+print(f"Model pushed successfully to: https://huggingface.co/{repo_id}")