Upload 10 files

.gitattributes

@@ -57,3 +57,5 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 # Video files - compressed
 *.mp4 filter=lfs diff=lfs merge=lfs -text
 *.webm filter=lfs diff=lfs merge=lfs -text
+HyperScholar-OmniPython-50K-CodeOnly.jsonl filter=lfs diff=lfs merge=lfs -text
+HyperScholar-OmniPython-50K-HyperReason.jsonl filter=lfs diff=lfs merge=lfs -text

EVAL_README.md

@@ -0,0 +1,16 @@
+# Evaluation (Standardized)
+
+## Goal
+Make results comparable across community fine-tunes.
+
+## Recommended metrics
+- HumanEval pass@1
+- Optional: MBPP pass@1
+
+## Suggested tool
+Use lm-evaluation-harness (or your preferred harness) to run HumanEval and report settings:
+- base model
+- training recipe (full / LoRA / QLoRA)
+- sequence length
+- epochs
+- hardware

HyperScholar-OmniPython-50K-CodeOnly.jsonl

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

HyperScholar-OmniPython-50K-HyperReason.jsonl

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

LEADERBOARD.md

@@ -0,0 +1,7 @@
+# HyperScholar-OmniPython Community Leaderboard (WithIn Us AI)
+
+Submit a PR adding your model results (use `MODEL_SUBMISSION_TEMPLATE.md`).
+
+| Date | Model | Base | Config | Method | HumanEval pass@1 | Notes |
+|---|---|---|---|---|---:|---|
+|  |  |  |  |  |  |  |

MODEL_SUBMISSION_TEMPLATE.md

@@ -0,0 +1,21 @@
+# Model Submission Template — WithIn Us AI
+
+## Model
+- Model name (HF): 
+- Base model: 
+- Dataset config: codeonly / hyperreason
+- Training method: full finetune / LoRA / QLoRA
+- Seq length:
+- Epochs:
+- LR / scheduler:
+- Batch size / grad acc:
+- Hardware (GPU + VRAM):
+
+## Results
+- HumanEval pass@1:
+- HumanEval pass@10 (optional):
+- Other evals (MBPP, etc.):
+
+## Notes
+- Any special tricks (packing, chat template, prompt format)?
+- Known failure modes?

README.md

@@ -0,0 +1,109 @@
+---
+pretty_name: HyperScholar-OmniPython (50K Spec→Code→Tests) — WithIn Us AI
+language:
+- en
+license: apache-2.0
+task_categories:
+- text-generation
+- text2text-generation
+tags:
+- python
+- code
+- instruction-tuning
+- sft
+- unit-tests
+- software-engineering
+- security
+- async
+- algorithms
+- trl
+size_categories:
+- 10K<n<100K
+configs:
+- config_name: codeonly
+  data_files: HyperScholar-OmniPython-50K-CodeOnly.jsonl
+- config_name: hyperreason
+  data_files: HyperScholar-OmniPython-50K-HyperReason.jsonl
+---
+
+# HyperScholar-OmniPython (50K) — WithIn Us AI
+
+Publisher: **WithIn Us AI**  
+Hugging Face: **gss1147**
+
+A developer-focused Python fine-tuning dataset that trains **engineering discipline** with a Mixture-of-Experts flavor:
+clear requirements, edge cases, complexity awareness, secure defaults, and minimal tests.
+
+## What’s included
+
+Two configs (each **50,000** records):
+
+- **codeonly**: assistant outputs *final code only* (clean production behavior)
+- **hyperreason**: assistant outputs:
+  - Expert (MoE label: ALG | DATA | ASYNC | SEC | API | TEST | PERF | STYLE)
+  - Spec
+  - Edge cases
+  - Complexity
+  - Implementation
+  - Minimal tests
+
+## Why developers want this
+
+- Teaches habits that improve reliability in real codebases:
+  - fail-closed validation and security patterns
+  - minimal tests and typing discipline
+  - async/reliability primitives (timeouts, concurrency limits, backoff, circuit breaker)
+  - standard library competence and clean APIs
+
+## Files in this repo
+
+- `HyperScholar-OmniPython-50K-CodeOnly.jsonl`
+- `HyperScholar-OmniPython-50K-HyperReason.jsonl`
+- `train_sft_omni_50k.py`
+- `requirements_omni_50k.txt`
+- `hf_upload_dataset.py`
+- `EVAL_README.md`
+- `LEADERBOARD.md`
+- `MODEL_SUBMISSION_TEMPLATE.md`
+
+## Schema (JSONL)
+
+Each line:
+```json
+{
+  "id": "OMNI00001",
+  "tags": ["..."],
+  "prompt": [
+    {"role":"system","content":"..."},
+    {"role":"user","content":"..."}
+  ],
+  "completion": [
+    {"role":"assistant","content":"..."}
+  ]
+}
+```
+
+## Train (TRL SFTTrainer)
+
+```bash
+pip install -r requirements_omni_50k.txt
+
+python train_sft_omni_50k.py \
+  --model YOUR_BASE_MODEL \
+  --dataset HyperScholar-OmniPython-50K-CodeOnly.jsonl \
+  --output_dir out_omni_50k \
+  --use_lora --use_4bit --bf16 \
+  --max_seq_len 4096 \
+  --gradient_accumulation_steps 16 \
+  --learning_rate 2e-4 \
+  --num_train_epochs 1 \
+  --packing
+```
+
+To train the structured “engineering discipline” behavior:
+- set `--dataset HyperScholar-OmniPython-50K-HyperReason.jsonl`
+
+## Contribute / publish your fine-tuned model
+
+Train a model on this dataset and publish it on Hugging Face, then add your result in `LEADERBOARD.md`
+using `MODEL_SUBMISSION_TEMPLATE.md`.

RESULTS_SCHEMA.json

@@ -0,0 +1,11 @@
+{
+  "date": "YYYY-MM-DD",
+  "model_id": "username/model",
+  "base_model": "base",
+  "config": "codeonly|hyperreason",
+  "method": "full|lora|qlora",
+  "humaneval_pass1": 0.0,
+  "mbpp_pass1": null,
+  "hardware": "GPU",
+  "notes": ""
+}

hf_upload_dataset.py

@@ -0,0 +1,39 @@
+#!/usr/bin/env python3
+# WithIn Us AI / gss1147 upload helper for Hugging Face datasets.
+#
+# Usage:
+#   export HF_TOKEN=...
+#   python hf_upload_dataset.py --folder . --repo_id gss1147/HyperScholar-OmniPython-50K
+#
+from __future__ import annotations
+import argparse, os
+from pathlib import Path
+from huggingface_hub import create_repo, upload_folder
+
+def main() -> None:
+    p = argparse.ArgumentParser()
+    p.add_argument("--repo_id", default="gss1147/HyperScholar-OmniPython-50K")
+    p.add_argument("--folder", default=".")
+    p.add_argument("--private", action="store_true")
+    args = p.parse_args()
+
+    token = os.getenv("HF_TOKEN")
+    if not token:
+        raise SystemExit("Set HF_TOKEN env var with a write-enabled token.")
+
+    folder = Path(args.folder).resolve()
+    if not folder.exists():
+        raise SystemExit(f"Folder not found: {folder}")
+
+    create_repo(args.repo_id, repo_type="dataset", exist_ok=True, private=args.private, token=token)
+    upload_folder(
+        repo_id=args.repo_id,
+        repo_type="dataset",
+        folder_path=str(folder),
+        commit_message="Upload HyperScholar-OmniPython-50K (WithIn Us AI)",
+        token=token,
+    )
+    print("Uploaded:", args.repo_id)
+
+if __name__ == "__main__":
+    main()

requirements_omni_50k.txt

@@ -0,0 +1,6 @@
+transformers>=4.42.0
+datasets>=2.19.0
+accelerate>=0.33.0
+trl>=0.26.2
+peft>=0.12.0
+bitsandbytes>=0.43.0

train_sft_omni_50k.py

@@ -0,0 +1,167 @@
+#!/usr/bin/env python3
+"""
+HyperScholar-OmniPython SFT training script (TRL SFTTrainer)
+
+Dataset format: JSONL where each record is:
+{
+  "id": "...",
+  "tags": [...],
+  "prompt": [{"role":"system","content":"..."},{"role":"user","content":"..."}],
+  "completion": [{"role":"assistant","content":"..."}]
+}
+
+Example:
+  python train_sft_omni_50k.py --model <base> --dataset HyperScholar-OmniPython-50K-CodeOnly.jsonl --output_dir out --use_lora --use_4bit --bf16
+"""
+
+from __future__ import annotations
+
+import argparse
+import os
+from dataclasses import dataclass
+
+import torch
+from datasets import load_dataset
+from transformers import AutoModelForCausalLM, AutoTokenizer, TrainingArguments
+from trl import SFTTrainer
+
+
+@dataclass(frozen=True)
+class Args:
+    model: str
+    dataset: str
+    output_dir: str
+    max_seq_len: int
+    per_device_train_batch_size: int
+    gradient_accumulation_steps: int
+    learning_rate: float
+    num_train_epochs: float
+    logging_steps: int
+    save_steps: int
+    warmup_ratio: float
+    lr_scheduler_type: str
+    bf16: bool
+    fp16: bool
+    packing: bool
+    attn_implementation: str | None
+    use_lora: bool
+    lora_r: int
+    lora_alpha: int
+    lora_dropout: float
+    use_4bit: bool
+    gradient_checkpointing: bool
+    seed: int
+
+
+def parse_args() -> Args:
+    p = argparse.ArgumentParser()
+    p.add_argument("--model", required=True)
+    p.add_argument("--dataset", required=True, help="Local JSONL path or HF dataset repo id.")
+    p.add_argument("--output_dir", default="./out_omni_50k")
+    p.add_argument("--max_seq_len", type=int, default=4096)
+    p.add_argument("--per_device_train_batch_size", type=int, default=1)
+    p.add_argument("--gradient_accumulation_steps", type=int, default=16)
+    p.add_argument("--learning_rate", type=float, default=2e-4)
+    p.add_argument("--num_train_epochs", type=float, default=1.0)
+    p.add_argument("--logging_steps", type=int, default=10)
+    p.add_argument("--save_steps", type=int, default=1000)
+    p.add_argument("--warmup_ratio", type=float, default=0.03)
+    p.add_argument("--lr_scheduler_type", default="cosine")
+    p.add_argument("--bf16", action="store_true")
+    p.add_argument("--fp16", action="store_true")
+    p.add_argument("--packing", action="store_true")
+    p.add_argument("--attn_implementation", default=None)
+    p.add_argument("--use_lora", action="store_true")
+    p.add_argument("--lora_r", type=int, default=16)
+    p.add_argument("--lora_alpha", type=int, default=32)
+    p.add_argument("--lora_dropout", type=float, default=0.05)
+    p.add_argument("--use_4bit", action="store_true")
+    p.add_argument("--gradient_checkpointing", action="store_true")
+    p.add_argument("--seed", type=int, default=42)
+    ns = p.parse_args()
+
+    if ns.bf16 and ns.fp16:
+        raise SystemExit("Choose only one: --bf16 or --fp16")
+    return Args(**vars(ns))
+
+
+def main() -> None:
+    a = parse_args()
+
+    if os.path.exists(a.dataset):
+        ds = load_dataset("json", data_files=a.dataset, split="train")
+    else:
+        ds = load_dataset(a.dataset, split="train")
+
+    tok = AutoTokenizer.from_pretrained(a.model, use_fast=True)
+    if tok.pad_token is None:
+        tok.pad_token = tok.eos_token
+
+    quantization_config = None
+    if a.use_4bit:
+        from transformers import BitsAndBytesConfig
+        quantization_config = BitsAndBytesConfig(
+            load_in_4bit=True,
+            bnb_4bit_use_double_quant=True,
+            bnb_4bit_quant_type="nf4",
+            bnb_4bit_compute_dtype=torch.bfloat16 if a.bf16 else torch.float16,
+        )
+
+    model = AutoModelForCausalLM.from_pretrained(
+        a.model,
+        device_map="auto",
+        torch_dtype=torch.bfloat16 if a.bf16 else (torch.float16 if a.fp16 else None),
+        attn_implementation=a.attn_implementation,
+        quantization_config=quantization_config,
+    )
+
+    if a.gradient_checkpointing:
+        model.gradient_checkpointing_enable()
+        model.config.use_cache = False
+
+    peft_config = None
+    if a.use_lora:
+        from peft import LoraConfig, TaskType
+        peft_config = LoraConfig(
+            r=a.lora_r,
+            lora_alpha=a.lora_alpha,
+            lora_dropout=a.lora_dropout,
+            bias="none",
+            task_type=TaskType.CAUSAL_LM,
+            target_modules="all-linear",
+        )
+
+    targs = TrainingArguments(
+        output_dir=a.output_dir,
+        per_device_train_batch_size=a.per_device_train_batch_size,
+        gradient_accumulation_steps=a.gradient_accumulation_steps,
+        learning_rate=a.learning_rate,
+        num_train_epochs=a.num_train_epochs,
+        logging_steps=a.logging_steps,
+        save_steps=a.save_steps,
+        warmup_ratio=a.warmup_ratio,
+        lr_scheduler_type=a.lr_scheduler_type,
+        bf16=a.bf16,
+        fp16=a.fp16,
+        optim="paged_adamw_32bit" if a.use_4bit else "adamw_torch",
+        report_to="none",
+        seed=a.seed,
+    )
+
+    trainer = SFTTrainer(
+        model=model,
+        tokenizer=tok,
+        train_dataset=ds,
+        args=targs,
+        max_seq_length=a.max_seq_len,
+        packing=a.packing,
+        peft_config=peft_config,
+    )
+
+    trainer.train()
+    trainer.save_model(a.output_dir)
+    tok.save_pretrained(a.output_dir)
+
+
+if __name__ == "__main__":
+    main()