scripts/upload_hf_release.py

from __future__ import annotations

import argparse
import json
from dataclasses import dataclass
from pathlib import Path

from huggingface_hub import CommitOperationAdd, HfApi


@dataclass(frozen=True)
class ModelRelease:
    repo_name: str
    checkpoint: str
    config: str
    report_dir: str
    title: str
    description: str
    context_length: int
    evaluation: str


MODEL_RELEASES = (
    ModelRelease(
        repo_name="KAWK-1.5-50M-Korean-Base",
        checkpoint="runs/kawk50m-fixed-recovery-6b-5090/checkpoint-00038147",
        config="configs/pretrain_fixed_recovery_plus5b_5090.yaml",
        report_dir="reports/fixed-recovery-6b",
        title="KAWK-1.5-50M Korean Base",
        description="한국어 중심 데이터 6B 토큰으로 학습한 51.5M 파라미터 베이스 모델",
        context_length=1024,
        evaluation="validation loss 2.8903 (이전 1B 체크포인트 2.9745)",
    ),
    ModelRelease(
        repo_name="KAWK-1.5-50M-Korean-Base-5K",
        checkpoint="runs/kawk50m-fixed-ko-cpt-3b-5k-5090/checkpoint-00024415",
        config="configs/cpt_fixed_ko_3b_5k_5090.yaml",
        report_dir="reports/fixed-ko-cpt-3b-5k",
        title="KAWK-1.5-50M Korean Base 5K",
        description="KAWK 한국어 베이스 모델을 5,120 토큰 문맥으로 계속 사전학습한 모델",
        context_length=5120,
        evaluation="validation loss 2.8583",
    ),
    ModelRelease(
        repo_name="KAWK-1.5-50M-Korean-Instruct",
        checkpoint="runs/kawk50m-ko-instruct-v1-5090/checkpoint-00001303",
        config="configs/sft_ko_80m_5k_5090.yaml",
        report_dir="reports/kawk50m-ko-instruct-v1",
        title="KAWK-1.5-50M Korean Instruct",
        description="5K 문맥 한국어 베이스 모델에 약 80M 토큰의 한국어 SFT를 적용한 모델",
        context_length=5120,
        evaluation="SFT validation loss 2.3216 (베이스라인 2.5483)",
    ),
)


def model_card(spec: ModelRelease, repo_id: str) -> bytes:
    card = f"""---
language:
- ko
library_name: transformers
pipeline_tag: text-generation
tags:
- llama
- korean
- causal-lm
- kawk50m
---

# {spec.title}

{spec.description}입니다. 이 저장소는 우선 비공개 백업 및 검증 목적으로 생성됐습니다.

## 구조

- 아키텍처: Llama 계열 decoder-only Transformer
- 파라미터: 51,542,528
- 어휘: 한국어 SentencePiece Unigram 20,000
- 레이어/hidden/MLP: 14 / 512 / 1,408
- Attention/KV heads: 8 / 4
- 최대 문맥: {spec.context_length:,} 토큰
- 입력·출력 임베딩 공유

## 평가

{spec.evaluation}. 자세한 결과와 로그는 `training/reports/`에 포함했습니다.

평가는 소규모 내부 검증 세트에 기반하므로 범용 한국어 성능을 보장하지 않습니다. 50M급 모델인 만큼 지식량, 추론, 사실성 및 장문 지시 수행에 뚜렷한 한계가 있습니다.

## 사용 예시

```python
from transformers import AutoModelForCausalLM, AutoTokenizer

repo_id = "{repo_id}"
tokenizer = AutoTokenizer.from_pretrained(repo_id)
model = AutoModelForCausalLM.from_pretrained(repo_id)
```

## 데이터 및 공개 전 확인사항

한국어 웹 데이터와 공개 한국어 대화형 데이터가 사용됐습니다. 저장소를 공개로 전환하기 전에 데이터 출처별 재배포 조건, 모델 라이선스, 개인정보 및 평가 한계를 다시 검토해야 합니다.
"""
    return card.encode("utf-8")


def archive_card(title: str, body: str) -> bytes:
    return f"""---
language:
- ko
tags:
- korean
- language-modeling
- kawk50m
---

# {title}

{body}

이 저장소는 비공개 프로젝트 백업용입니다. 공개 전환 전에 원천 데이터 라이선스, 개인정보, 중복 파일 및 실패 실험 산출물을 검토해야 합니다.
""".encode("utf-8")


def create_private_repo(api: HfApi, repo_id: str, repo_type: str) -> None:
    api.create_repo(repo_id=repo_id, repo_type=repo_type, private=True, exist_ok=True)


def upload_readme(api: HfApi, repo_id: str, repo_type: str, content: bytes) -> None:
    api.create_commit(
        repo_id=repo_id,
        repo_type=repo_type,
        operations=[CommitOperationAdd(path_in_repo="README.md", path_or_fileobj=content)],
        commit_message="Add repository card",
    )


def upload_models(api: HfApi, root: Path, namespace: str) -> None:
    for spec in MODEL_RELEASES:
        repo_id = f"{namespace}/{spec.repo_name}"
        checkpoint = root / spec.checkpoint
        model_dir = checkpoint / "model"
        tokenizer_dir = checkpoint / "tokenizer"
        if not model_dir.is_dir() or not tokenizer_dir.is_dir():
            raise FileNotFoundError(f"Incomplete checkpoint: {checkpoint}")

        create_private_repo(api, repo_id, "model")
        upload_readme(api, repo_id, "model", model_card(spec, repo_id))
        api.upload_folder(
            repo_id=repo_id,
            repo_type="model",
            folder_path=model_dir,
            commit_message="Upload model weights and configuration",
        )
        api.upload_folder(
            repo_id=repo_id,
            repo_type="model",
            folder_path=tokenizer_dir,
            commit_message="Upload Korean tokenizer",
        )
        api.upload_file(
            repo_id=repo_id,
            repo_type="model",
            path_or_fileobj=checkpoint / "trainer_state.pt",
            path_in_repo="training/trainer_state.pt",
            commit_message="Upload resumable trainer state",
        )
        api.upload_file(
            repo_id=repo_id,
            repo_type="model",
            path_or_fileobj=checkpoint / "state_summary.json",
            path_in_repo="training/state_summary.json",
            commit_message="Upload checkpoint summary",
        )
        api.upload_file(
            repo_id=repo_id,
            repo_type="model",
            path_or_fileobj=root / spec.config,
            path_in_repo=f"training/{Path(spec.config).name}",
            commit_message="Upload training configuration",
        )
        api.upload_folder(
            repo_id=repo_id,
            repo_type="model",
            folder_path=root / spec.report_dir,
            path_in_repo="training/reports",
            commit_message="Upload evaluation reports and logs",
        )
        files = set(api.list_repo_files(repo_id=repo_id, repo_type="model"))
        required = {"config.json", "model.safetensors", "tokenizer.model", "README.md"}
        missing = required - files
        if missing:
            raise RuntimeError(f"Upload verification failed for {repo_id}: {sorted(missing)}")
        print(json.dumps({"repo": repo_id, "status": "verified", "files": len(files)}))


def upload_archive(
    api: HfApi,
    *,
    root: Path,
    namespace: str,
    phase: str,
    workers: int,
) -> None:
    definitions = {
        "project": (
            "KAWK50M-Project",
            root,
            archive_card(
                "KAWK50M Project",
                "한국어 50M 언어모델의 코드, 설정, 토크나이저 산출물 및 평가 보고서입니다.",
            ),
            [
                "data/**",
                "runs/**",
                ".venv/**",
                ".git/**",
                ".cache/**",
                ".pytest_cache/**",
                "README.md",
                "**/__pycache__/**",
                "**/*.pyc",
            ],
        ),
        "data": (
            "KAWK50M-Training-Data",
            root / "data",
            archive_card(
                "KAWK50M Training Data Archive",
                "수집 원문, 정제 말뭉치, 토큰화 바이너리와 SFT 데이터의 전체 작업 사본입니다.",
            ),
            [".cache/**", "**/__pycache__/**"],
        ),
        "runs": (
            "KAWK50M-Training-Runs",
            root / "runs",
            archive_card(
                "KAWK50M Training Runs Archive",
                "최종·중간·실험 체크포인트를 포함한 전체 학습 이력입니다.",
            ),
            [".cache/**", "**/__pycache__/**"],
        ),
    }
    repo_name, folder, card, ignore = definitions[phase]
    repo_id = f"{namespace}/{repo_name}"
    create_private_repo(api, repo_id, "dataset")
    api.upload_large_folder(
        repo_id=repo_id,
        repo_type="dataset",
        folder_path=folder,
        ignore_patterns=ignore,
        num_workers=workers,
        print_report=True,
        print_report_every=60,
    )
    if phase == "project":
        api.upload_file(
            repo_id=repo_id,
            repo_type="dataset",
            path_or_fileobj=root / "README.md",
            path_in_repo="PROJECT_README.md",
            commit_message="Upload project README",
        )
    upload_readme(api, repo_id, "dataset", card)
    files = api.list_repo_files(repo_id=repo_id, repo_type="dataset")
    if "README.md" not in files:
        raise RuntimeError(f"Upload verification failed for {repo_id}")
    print(json.dumps({"repo": repo_id, "status": "verified", "files": len(files)}))


def parse_args() -> argparse.Namespace:
    parser = argparse.ArgumentParser(description="Upload KAWK50M releases to Hugging Face")
    parser.add_argument("--namespace", required=True)
    parser.add_argument("--project-root", type=Path, default=Path.cwd())
    parser.add_argument(
        "--phase",
        choices=("models", "project", "data", "runs", "all"),
        default="models",
    )
    parser.add_argument("--workers", type=int, default=8)
    return parser.parse_args()


def main() -> None:
    args = parse_args()
    root = args.project_root.resolve()
    api = HfApi(token=True)
    identity = api.whoami()
    if identity.get("name") != args.namespace:
        raise RuntimeError(
            f"Authenticated as {identity.get('name')!r}, expected {args.namespace!r}"
        )

    phases = ("models", "project", "data", "runs") if args.phase == "all" else (args.phase,)
    for phase in phases:
        if phase == "models":
            upload_models(api, root, args.namespace)
        else:
            upload_archive(
                api,
                root=root,
                namespace=args.namespace,
                phase=phase,
                workers=args.workers,
            )


if __name__ == "__main__":
    main()