Add matchmaker 1B training pipeline

.gitignore

@@ -17,6 +17,11 @@ yarn-debug.log*
 yarn-error.log*
 pnpm-debug.log*
 
+# Python
+__pycache__/
+**/__pycache__/
+*.pyc
+
 # Backend build
 backend/dist/
 
@@ -40,3 +45,8 @@ frontend/ios/Flutter/Flutter.podspec
 # Supabase
 .branches/
 .temp/
+
+# Training artifacts may contain profile-derived data
+training/outputs/
+training/.cache/
+wandb/

README.md

@@ -21,8 +21,9 @@ Premium AI dating platform powered by OpenClaw.
 - `backend/supabase/migrations/` PostgreSQL schema, RLS, pgvector matching RPC.
 - `shared/` full compatibility questionnaire and shared TypeScript contracts.
 - `artifacts/` OpenClaw prompt and response schema.
-- `docs/` setup, API, and deployment notes.
-- `app.py` Gradio/Hugging Face Space adapter.
+- `docs/` setup, API, and deployment notes.
+- `app.py` Gradio/Hugging Face Space adapter.
+- `training/` privacy-preserving matchmaker model training pipeline.
 
 ## Gradio Space
 
@@ -58,7 +59,21 @@ $env:DATACLAW_ALLOW_PROFILE_DECRYPT="1"
 python tools/dataclaw_profile_vault.py encrypted-profile.jsonl.enc --output decrypted.jsonl --i-understand-raw-profile-output
 ```
 
-Do not expose decrypted JSONL through the Space UI or logs.
+Do not expose decrypted JSONL through the Space UI or logs.
+
+## Matchmaker Training
+
+The training pipeline builds de-identified pairwise examples from the encrypted matchmaker table and trains a small LoRA matchmaker model.
+
+```powershell
+$env:MATCHMAKER_TRAINING_ACK="1"
+python training/prepare_dataset.py `
+  --input training/examples/synthetic_profiles.jsonl `
+  --input-format plain-profiles `
+  --out-dir training/outputs/datasets/synthetic
+```
+
+See `training/README.md` for real Dataclaw table prep, 1B LoRA training, prediction, and evaluation.
 
 ## Backend
 

training/README.md

@@ -0,0 +1,130 @@
+# loveGPT Matchmaker 1B Training Pipeline
+
+This pipeline trains a small instruction model to score, weight, and compare de-identified dating profiles for the loveGPT matchmaker.
+
+The model is not trained to reveal people. It is trained to return a structured compatibility judgment from two profile views:
+
+```json
+{
+  "compatibility": 72.4,
+  "label": "candidate",
+  "invite_to_speed_date": true,
+  "dimensions": [
+    {"id": "values_future", "score": 81.0, "weight": 0.18}
+  ],
+  "rationale": ["Strongest signal: Values and future direction at 81.0%."]
+}
+```
+
+## Privacy Rules
+
+- The Space UI never exposes raw JSONL.
+- Dataset preparation requires `MATCHMAKER_TRAINING_ACK=1`.
+- Encrypted matchmaker rows are decrypted only by the training prep script and immediately converted into a de-identified training view.
+- Training examples remove `userId`, `username`, `profileId`, display name, exact age, exact location, contact details, URLs, emails, phone numbers, and handles.
+- Do not commit `training/outputs/`; it may contain sensitive profile-derived text.
+
+## Base Model
+
+Default: `meta-llama/Llama-3.2-1B-Instruct`
+
+Good alternatives:
+
+- `TinyLlama/TinyLlama-1.1B-Chat-v1.0` for very low-resource experiments.
+- `HuggingFaceTB/SmolLM2-1.7B-Instruct` if a slightly larger small model is acceptable.
+- `Qwen/Qwen2.5-1.5B-Instruct` if you want stronger JSON behavior and are okay using Qwen-family models.
+
+## Install
+
+```powershell
+python -m pip install -r training/requirements-training.txt
+```
+
+For QLoRA on Windows, `bitsandbytes` may not be available. Train on Linux/RunPod/Hugging Face GPU for the normal 4-bit path.
+
+## Smoke Test With Synthetic Profiles
+
+```powershell
+$env:MATCHMAKER_TRAINING_ACK="1"
+python training/prepare_dataset.py `
+  --input training/examples/synthetic_profiles.jsonl `
+  --input-format plain-profiles `
+  --out-dir training/outputs/datasets/synthetic
+
+python training/evaluate_matchmaker.py `
+  --dataset training/outputs/datasets/synthetic/eval.jsonl
+```
+
+## Prepare Real Dataclaw Data
+
+Use the encrypted matchmaker table, not raw user exports.
+
+```powershell
+$env:MATCHMAKER_TABLE_KEY="your-space-secret"
+$env:MATCHMAKER_TRAINING_ACK="1"
+
+python training/prepare_dataset.py `
+  --input C:\path\to\lovegpt-matchmaker-table.jsonl.enc `
+  --input-format encrypted-matchmaker `
+  --out-dir training/outputs/datasets/matchmaker `
+  --max-pairs 50000
+```
+
+If `MATCHMAKER_TABLE_KEY` is not set, the prep script can derive the table key from `DATACLAW_PROFILE_KEY`, matching the Space behavior.
+
+Optional feedback override file:
+
+```json
+{"profileAId":"profile-a","profileBId":"profile-b","compatibility":88,"label":"high_match","invite_to_speed_date":true,"rationale":["Both users opted into contact exchange after the speed-date."]}
+```
+
+Use it like this:
+
+```powershell
+python training/prepare_dataset.py `
+  --input C:\path\to\lovegpt-matchmaker-table.jsonl.enc `
+  --input-format encrypted-matchmaker `
+  --feedback C:\path\to\matchmaker-feedback.jsonl `
+  --out-dir training/outputs/datasets/matchmaker
+```
+
+## Train LoRA
+
+```powershell
+python training/train_lora.py `
+  --config training/config/matchmaker_1b_lora.yaml
+```
+
+Output adapter:
+
+```text
+training/outputs/adapters/matchmaker-1b-lora
+```
+
+## Predict And Evaluate
+
+```powershell
+python training/predict.py `
+  --model meta-llama/Llama-3.2-1B-Instruct `
+  --adapter training/outputs/adapters/matchmaker-1b-lora `
+  --input training/outputs/datasets/matchmaker/test.jsonl `
+  --output training/outputs/predictions/matchmaker-test.jsonl
+
+python training/evaluate_matchmaker.py `
+  --dataset training/outputs/datasets/matchmaker/test.jsonl `
+  --predictions training/outputs/predictions/matchmaker-test.jsonl
+```
+
+Metrics:
+
+- `validJsonRate`: model follows the strict output contract.
+- `compatibilityMae`: average absolute error against the teacher/human target score.
+- `inviteAccuracy`: whether the model agrees on opening a speed-date.
+
+## Improvement Loop
+
+1. Start with `strict-v1` teacher labels from the current matchmaker harness.
+2. Add human feedback later from mutual exchange outcomes, post-chat ratings, safety reports, and blocks.
+3. Weight feedback labels above teacher labels once enough data exists.
+4. Keep the deterministic harness as a fallback and safety gate.
+5. Only let the trained model propose scores; final room creation should still require hard privacy/safety checks.

training/config/matchmaker_1b_lora.yaml

@@ -0,0 +1,41 @@
+model:
+  base_model: meta-llama/Llama-3.2-1B-Instruct
+  trust_remote_code: false
+  load_in_4bit: true
+  device_map: auto
+
+lora:
+  r: 32
+  alpha: 64
+  dropout: 0.05
+  target_modules:
+    - q_proj
+    - k_proj
+    - v_proj
+    - o_proj
+    - gate_proj
+    - up_proj
+    - down_proj
+
+data:
+  train_file: training/outputs/datasets/matchmaker/train.jsonl
+  eval_file: training/outputs/datasets/matchmaker/eval.jsonl
+
+training:
+  output_dir: training/outputs/runs/matchmaker-1b-lora
+  adapter_output_dir: training/outputs/adapters/matchmaker-1b-lora
+  max_seq_length: 4096
+  per_device_train_batch_size: 1
+  per_device_eval_batch_size: 1
+  gradient_accumulation_steps: 16
+  learning_rate: 0.00015
+  num_train_epochs: 2
+  warmup_ratio: 0.05
+  logging_steps: 10
+  eval_steps: 100
+  save_steps: 100
+  save_total_limit: 2
+  bf16: true
+  fp16: false
+  packing: false
+  report_to: []

training/evaluate_matchmaker.py

@@ -0,0 +1,93 @@
+from __future__ import annotations
+
+import argparse
+import json
+import math
+from pathlib import Path
+from statistics import mean
+from typing import Any
+
+
+def load_jsonl(path: Path) -> list[dict[str, Any]]:
+    return [json.loads(line) for line in path.read_text(encoding="utf-8").splitlines() if line.strip()]
+
+
+def parse_prediction(row: dict[str, Any]) -> dict[str, Any] | None:
+    text = row.get("predictionText", "")
+    if isinstance(text, dict):
+        return text
+    start = str(text).find("{")
+    end = str(text).rfind("}")
+    if start < 0 or end <= start:
+        return None
+    try:
+        parsed = json.loads(str(text)[start : end + 1])
+    except json.JSONDecodeError:
+        return None
+    return parsed if isinstance(parsed, dict) else None
+
+
+def invite(value: dict[str, Any]) -> bool:
+    return bool(value.get("invite_to_speed_date") or value.get("passed"))
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Evaluate matchmaker predictions against teacher or feedback labels.")
+    parser.add_argument("--dataset", type=Path, required=True, help="Test/eval JSONL produced by prepare_dataset.py.")
+    parser.add_argument("--predictions", type=Path, help="Prediction JSONL produced by predict.py.")
+    args = parser.parse_args()
+
+    dataset = {row["pairHash"]: row for row in load_jsonl(args.dataset)}
+    if not args.predictions:
+        scores = [float(row["target"]["compatibility"]) for row in dataset.values()]
+        labels = {row["target"]["label"] for row in dataset.values()}
+        print(
+            json.dumps(
+                {
+                    "pairs": len(dataset),
+                    "meanTeacherCompatibility": round(mean(scores), 3) if scores else 0,
+                    "positiveRate": round(sum(invite(row["target"]) for row in dataset.values()) / max(1, len(dataset)), 4),
+                    "labels": sorted(labels),
+                },
+                indent=2,
+                sort_keys=True,
+            )
+        )
+        return
+
+    pred_rows = load_jsonl(args.predictions)
+    mae_values: list[float] = []
+    exact_invite = 0
+    valid_json = 0
+    evaluated = 0
+    for pred_row in pred_rows:
+        target_row = dataset.get(pred_row["pairHash"])
+        if not target_row:
+            continue
+        evaluated += 1
+        parsed = parse_prediction(pred_row)
+        if not parsed:
+            continue
+        valid_json += 1
+        target_score = float(target_row["target"]["compatibility"])
+        pred_score = float(parsed.get("compatibility", math.nan))
+        if not math.isnan(pred_score):
+            mae_values.append(abs(pred_score - target_score))
+        exact_invite += int(invite(parsed) == invite(target_row["target"]))
+
+    print(
+        json.dumps(
+            {
+                "evaluated": evaluated,
+                "validJsonRate": round(valid_json / max(1, evaluated), 4),
+                "compatibilityMae": round(mean(mae_values), 3) if mae_values else None,
+                "inviteAccuracy": round(exact_invite / max(1, evaluated), 4),
+            },
+            indent=2,
+            sort_keys=True,
+        )
+    )
+
+
+if __name__ == "__main__":
+    main()

training/examples/synthetic_profiles.jsonl

@@ -0,0 +1,3 @@
+{"source":"synthetic","profileId":"synthetic-a","profileComplete":true,"profile":{"display_name":"Synthetic A","age":"31","location":"Hidden","intent":"Long-term relationship"},"answers":{"q1":{"answer":"Honesty, warmth, loyalty, emotional courage, and building a thoughtful life through daily follow-through.","dealbreakerSeverity":null},"q2":{"answer":"A calm home, meaningful work, shared rituals, and enough ambition to keep growing without burning out.","dealbreakerSeverity":null},"q6":{"answer":"I bond through consistency, direct reassurance, and quiet dependability.","dealbreakerSeverity":null},"q11":{"answer":"I am captivated by kindness with backbone, dry wit, competence, and emotional steadiness.","dealbreakerSeverity":null},"q16":{"answer":"Poor hygiene, contempt toward service workers, and cruelty presented as humor are hard no signals.","dealbreakerSeverity":"high"},"q23":{"answer":"Conflict needs accountability, repair, and no disappearing for days.","dealbreakerSeverity":null},"q27":{"answer":"I prefer tidy spaces, planned weekends, health routines, and a grounded social life.","dealbreakerSeverity":null},"q37":{"answer":"Average build, active, comfortable with a soft but healthy body.","dealbreakerSeverity":null},"q38":{"answer":"I am attracted to average to athletic builds and am flexible when warmth and chemistry are there.","dealbreakerSeverity":null},"q39":{"answer":"Flexibility matters more than exact body type; hygiene and confidence carry a lot.","dealbreakerSeverity":null},"q40":{"answer":"I want my body to be seen kindly and realistically, not inspected like a checklist.","dealbreakerSeverity":null}},"captivatingTraits":["kindness with backbone","dry wit","competence"],"disgustTriggers":["poor hygiene","cruelty","contempt"]}
+{"source":"synthetic","profileId":"synthetic-b","profileComplete":true,"profile":{"display_name":"Synthetic B","age":"33","location":"Hidden","intent":"Life partner"},"answers":{"q1":{"answer":"Kindness, honesty, accountability, curiosity, and a peaceful home life are non-negotiable.","dealbreakerSeverity":null},"q2":{"answer":"I want a warm home, good work, shared meals, travel sometimes, and a partner who repairs conflict quickly.","dealbreakerSeverity":null},"q6":{"answer":"I feel safest with steady communication and someone who means what they say.","dealbreakerSeverity":null},"q11":{"answer":"I admire emotionally mature people who are funny, grounded, capable, and affectionate.","dealbreakerSeverity":null},"q16":{"answer":"Cruel jokes, dirty living spaces, and chronic disrespect make attraction disappear.","dealbreakerSeverity":"high"},"q23":{"answer":"I can handle hard conversations if there is no stonewalling and both people apologize clearly.","dealbreakerSeverity":null},"q27":{"answer":"A clean home, moderate social life, exercise, and financial responsibility fit me best.","dealbreakerSeverity":null},"q37":{"answer":"Average active body type, not extremely lean, comfortable and healthy.","dealbreakerSeverity":null},"q38":{"answer":"I like average, soft, or athletic bodies and care more about energy and hygiene than a strict type.","dealbreakerSeverity":null},"q39":{"answer":"Very flexible if the person is confident, kind, and physically affectionate.","dealbreakerSeverity":null},"q40":{"answer":"I want attraction to feel mutual and generous.","dealbreakerSeverity":null}},"captivatingTraits":["emotionally mature","funny","grounded"],"disgustTriggers":["dirty living spaces","cruel jokes","disrespect"]}
+{"source":"synthetic","profileId":"synthetic-c","profileComplete":true,"profile":{"display_name":"Synthetic C","age":"29","location":"Hidden","intent":"Intentional dating"},"answers":{"q1":{"answer":"Freedom, novelty, ambition, intensity, independence, and social momentum matter most.","dealbreakerSeverity":null},"q2":{"answer":"I want a highly mobile life with spontaneous travel, big career swings, and no fixed domestic routine.","dealbreakerSeverity":null},"q6":{"answer":"I need a lot of space and dislike frequent reassurance conversations.","dealbreakerSeverity":null},"q11":{"answer":"I am drawn to status, edge, boldness, nightlife charisma, and high intensity chemistry.","dealbreakerSeverity":null},"q16":{"answer":"Clinginess, routine, domestic predictability, and cautious people turn me off.","dealbreakerSeverity":"medium"},"q23":{"answer":"I prefer to cool off alone and revisit conflict later if it still matters.","dealbreakerSeverity":null},"q27":{"answer":"Late nights, travel, networking, and loose plans suit me best.","dealbreakerSeverity":null},"q37":{"answer":"Lean athletic body and high energy lifestyle.","dealbreakerSeverity":null},"q38":{"answer":"I strongly prefer very fit, polished, high-energy partners.","dealbreakerSeverity":null},"q39":{"answer":"I am not very flexible on physical type because attraction is immediate for me.","dealbreakerSeverity":null},"q40":{"answer":"I want a partner to appreciate discipline and presentation.","dealbreakerSeverity":null}},"captivatingTraits":["status","edge","boldness"],"disgustTriggers":["clinginess","routine","cautious people"]}

training/predict.py

@@ -0,0 +1,59 @@
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+
+
+def load_jsonl(path: Path) -> list[dict]:
+    return [json.loads(line) for line in path.read_text(encoding="utf-8").splitlines() if line.strip()]
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Generate matchmaker predictions from a trained adapter.")
+    parser.add_argument("--model", required=True, help="Base model id or merged model path.")
+    parser.add_argument("--adapter", default="", help="Optional PEFT adapter path.")
+    parser.add_argument("--input", type=Path, required=True)
+    parser.add_argument("--output", type=Path, required=True)
+    parser.add_argument("--max-new-tokens", type=int, default=512)
+    args = parser.parse_args()
+
+    import torch
+    from peft import PeftModel
+    from transformers import AutoModelForCausalLM, AutoTokenizer
+
+    tokenizer = AutoTokenizer.from_pretrained(args.adapter or args.model, trust_remote_code=True)
+    if tokenizer.pad_token is None:
+        tokenizer.pad_token = tokenizer.eos_token
+    model = AutoModelForCausalLM.from_pretrained(
+        args.model,
+        device_map="auto",
+        torch_dtype=torch.bfloat16 if torch.cuda.is_available() else torch.float32,
+        trust_remote_code=True,
+    )
+    if args.adapter:
+        model = PeftModel.from_pretrained(model, args.adapter)
+    model.eval()
+
+    rows = load_jsonl(args.input)
+    args.output.parent.mkdir(parents=True, exist_ok=True)
+    with args.output.open("w", encoding="utf-8") as handle:
+        for row in rows:
+            messages = row["messages"][:2]
+            prompt = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True) if getattr(tokenizer, "chat_template", None) else "\n\n".join(f"{m['role'].upper()}: {m['content']}" for m in messages)
+            inputs = tokenizer(prompt, return_tensors="pt").to(model.device)
+            with torch.no_grad():
+                output = model.generate(
+                    **inputs,
+                    max_new_tokens=args.max_new_tokens,
+                    temperature=0.0,
+                    do_sample=False,
+                    pad_token_id=tokenizer.eos_token_id,
+                )
+            text = tokenizer.decode(output[0][inputs["input_ids"].shape[1] :], skip_special_tokens=True)
+            handle.write(json.dumps({"pairHash": row["pairHash"], "target": row["target"], "predictionText": text}, ensure_ascii=False, sort_keys=True))
+            handle.write("\n")
+
+
+if __name__ == "__main__":
+    main()

training/prepare_dataset.py

@@ -0,0 +1,215 @@
+from __future__ import annotations
+
+import argparse
+import itertools
+import json
+import random
+import sys
+from pathlib import Path
+from typing import Any
+
+ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(ROOT / "training" / "src"))
+
+from lovegpt_matchmaker_training.crypto import decrypt_matchmaker_row
+from lovegpt_matchmaker_training.features import compact_profile_for_prompt, sanitize_profile
+from lovegpt_matchmaker_training.privacy import require_training_ack, stable_hash
+from lovegpt_matchmaker_training.questions import load_questions
+from lovegpt_matchmaker_training.teacher import label_from_score, strict_matchmaker_judgment
+
+
+SYSTEM_PROMPT = """You are the loveGPT matchmaker scoring model.
+Compare two de-identified dating profiles. Measure long-term values, emotional safety,
+captivating traits, disgust filters, conflict repair, lifestyle fit, and body-attraction alignment.
+Return one valid JSON object only. Never infer or reveal private identity details."""
+
+
+def load_plain_profiles(path: Path) -> list[dict[str, Any]]:
+    profiles: list[dict[str, Any]] = []
+    for line in path.read_text(encoding="utf-8").splitlines():
+        if not line.strip():
+            continue
+        profiles.append(json.loads(line))
+    return profiles
+
+
+def load_encrypted_matchmaker_profiles(path: Path) -> list[dict[str, Any]]:
+    latest: dict[str, dict[str, Any]] = {}
+    for line in path.read_text(encoding="utf-8").splitlines():
+        if not line.strip():
+            continue
+        payload = decrypt_matchmaker_row(line)
+        profile_id = str(payload.get("profileId") or "")
+        if not profile_id:
+            continue
+        previous = latest.get(profile_id)
+        if previous is None or str(payload.get("loggedAt", "")) >= str(previous.get("loggedAt", "")):
+            latest[profile_id] = payload
+    return list(latest.values())
+
+
+def anonymized_profile_key(payload: dict[str, Any]) -> str:
+    raw = "::".join(
+        [
+            str(payload.get("profileId") or ""),
+            str(payload.get("userId") or ""),
+            json.dumps(payload.get("answers", {}), sort_keys=True, ensure_ascii=False)[:2048],
+        ]
+    )
+    return stable_hash(raw)
+
+
+def load_feedback(path: Path | None, profiles: list[dict[str, Any]]) -> dict[str, dict[str, Any]]:
+    if not path:
+        return {}
+    by_profile_id = {str(profile.get("profileId") or ""): anonymized_profile_key(profile) for profile in profiles}
+    feedback: dict[str, dict[str, Any]] = {}
+    for line in path.read_text(encoding="utf-8").splitlines():
+        if not line.strip():
+            continue
+        row = json.loads(line)
+        pair_hash = row.get("pairHash")
+        if not pair_hash:
+            profile_a_id = str(row.get("profileAId") or "")
+            profile_b_id = str(row.get("profileBId") or "")
+            if profile_a_id not in by_profile_id or profile_b_id not in by_profile_id:
+                continue
+            pair_hash = stable_hash("::".join(sorted([by_profile_id[profile_a_id], by_profile_id[profile_b_id]])), salt="lovegpt-pair")
+        target: dict[str, Any] = {}
+        if "compatibility" in row:
+            target["compatibility"] = round(float(row["compatibility"]), 1)
+        if "label" in row:
+            target["label"] = str(row["label"])
+        if "invite_to_speed_date" in row:
+            target["invite_to_speed_date"] = bool(row["invite_to_speed_date"])
+        if "dimensions" in row and isinstance(row["dimensions"], list):
+            target["dimensions"] = row["dimensions"]
+        if "rationale" in row and isinstance(row["rationale"], list):
+            target["rationale"] = [str(item)[:240] for item in row["rationale"][:6]]
+        if target:
+            feedback[str(pair_hash)] = target
+    return feedback
+
+
+def build_pair_example(profile_a: dict[str, Any], profile_b: dict[str, Any], split: str, feedback: dict[str, Any] | None = None) -> dict[str, Any]:
+    _, questions = load_questions()
+    safe_a = sanitize_profile(profile_a, questions)
+    safe_b = sanitize_profile(profile_b, questions)
+    judgment = strict_matchmaker_judgment(safe_a, safe_b)
+    score = float(judgment["compatibility"])
+    output = {
+        "compatibility": score,
+        "label": label_from_score(score),
+        "invite_to_speed_date": bool(judgment["passed"]),
+        "dimensions": judgment["dimensions"],
+        "rationale": dimension_rationale(judgment),
+    }
+    if feedback:
+        output = {
+            **output,
+            **feedback,
+            "compatibility": float(feedback.get("compatibility", output["compatibility"])),
+            "label": str(feedback.get("label", output["label"])),
+            "invite_to_speed_date": bool(feedback.get("invite_to_speed_date", output["invite_to_speed_date"])),
+            "dimensions": feedback.get("dimensions", output["dimensions"]),
+            "rationale": feedback.get("rationale", output["rationale"]),
+        }
+    user_payload = {
+        "profileA": compact_profile_for_prompt(safe_a),
+        "profileB": compact_profile_for_prompt(safe_b),
+        "task": "Score whether these two de-identified dating profiles should be introduced for a 20-minute speed-date.",
+    }
+    pair_id = "::".join(sorted([anonymized_profile_key(profile_a), anonymized_profile_key(profile_b)]))
+    return {
+        "schema": "lovegpt.matchmaker.sft_pair.v1",
+        "pairHash": stable_hash(pair_id, salt="lovegpt-pair"),
+        "split": split,
+        "targetSource": "feedback-v1" if feedback else "strict-v1",
+        "messages": [
+            {"role": "system", "content": SYSTEM_PROMPT},
+            {"role": "user", "content": json.dumps(user_payload, ensure_ascii=False, sort_keys=True)},
+            {"role": "assistant", "content": json.dumps(output, ensure_ascii=False, sort_keys=True)},
+        ],
+        "target": output,
+    }
+
+
+def dimension_rationale(judgment: dict[str, Any]) -> list[str]:
+    ordered = sorted(judgment["dimensions"], key=lambda item: item["score"])
+    weakest = ordered[:2]
+    strongest = ordered[-2:]
+    notes = [
+        f"Strongest signal: {item['label']} at {item['score']}%."
+        for item in reversed(strongest)
+    ]
+    notes.extend(
+        f"Weakness to respect: {item['label']} at {item['score']}%."
+        for item in weakest
+    )
+    return notes
+
+
+def split_for_pair(pair_hash: str, train_ratio: float, eval_ratio: float) -> str:
+    bucket = int(pair_hash[:8], 16) / 0xFFFFFFFF
+    if bucket < train_ratio:
+        return "train"
+    if bucket < train_ratio + eval_ratio:
+        return "eval"
+    return "test"
+
+
+def write_jsonl(path: Path, rows: list[dict[str, Any]]) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with path.open("w", encoding="utf-8") as handle:
+        for row in rows:
+            handle.write(json.dumps(row, ensure_ascii=False, sort_keys=True))
+            handle.write("\n")
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Prepare de-identified loveGPT matchmaker pairwise SFT data.")
+    parser.add_argument("--input", required=True, type=Path, help="Encrypted matchmaker JSONL or plain profile JSONL.")
+    parser.add_argument("--input-format", choices=["encrypted-matchmaker", "plain-profiles"], default="encrypted-matchmaker")
+    parser.add_argument("--out-dir", type=Path, default=Path("training/outputs/datasets/matchmaker"))
+    parser.add_argument("--max-pairs", type=int, default=20000)
+    parser.add_argument("--seed", type=int, default=17)
+    parser.add_argument("--train-ratio", type=float, default=0.82)
+    parser.add_argument("--eval-ratio", type=float, default=0.09)
+    parser.add_argument("--feedback", type=Path, help="Optional Dataclaw-only JSONL of pair labels that override teacher targets.")
+    args = parser.parse_args()
+
+    require_training_ack()
+    profiles = load_plain_profiles(args.input) if args.input_format == "plain-profiles" else load_encrypted_matchmaker_profiles(args.input)
+    profiles = [profile for profile in profiles if profile.get("profileComplete") or profile.get("answers")]
+    if len(profiles) < 2:
+        raise SystemExit("Need at least two profiles to build pairwise examples.")
+
+    pairs = list(itertools.combinations(profiles, 2))
+    random.Random(args.seed).shuffle(pairs)
+    pairs = pairs[: args.max_pairs]
+    feedback_by_pair = load_feedback(args.feedback, profiles)
+
+    rows: list[dict[str, Any]] = []
+    for profile_a, profile_b in pairs:
+        pair_hash = stable_hash("::".join(sorted([anonymized_profile_key(profile_a), anonymized_profile_key(profile_b)])), salt="lovegpt-pair")
+        rows.append(build_pair_example(profile_a, profile_b, split_for_pair(pair_hash, args.train_ratio, args.eval_ratio), feedback_by_pair.get(pair_hash)))
+
+    for split in ("train", "eval", "test"):
+        split_rows = [row for row in rows if row["split"] == split]
+        write_jsonl(args.out_dir / f"{split}.jsonl", split_rows)
+
+    manifest = {
+        "schema": "lovegpt.matchmaker.dataset_manifest.v1",
+        "profileCount": len(profiles),
+        "pairCount": len(rows),
+        "splits": {split: sum(1 for row in rows if row["split"] == split) for split in ("train", "eval", "test")},
+        "feedbackOverrides": sum(1 for row in rows if row.get("targetSource") == "feedback-v1"),
+        "inputFormat": args.input_format,
+        "privacy": "De-identified profile view: no user ids, usernames, names, exact ages, exact locations, contacts, or URLs.",
+    }
+    (args.out_dir / "manifest.json").write_text(json.dumps(manifest, indent=2, sort_keys=True), encoding="utf-8")
+    print(json.dumps(manifest, indent=2, sort_keys=True))
+
+
+if __name__ == "__main__":
+    main()

training/requirements-training.txt

@@ -0,0 +1,10 @@
+accelerate>=0.34
+bitsandbytes>=0.43; platform_system != "Windows"
+cryptography>=42,<47
+datasets>=2.20
+huggingface_hub>=0.33.5,<2
+peft>=0.12
+pyyaml>=6.0.2
+scikit-learn>=1.5
+torch>=2.3
+transformers>=4.45

training/src/lovegpt_matchmaker_training/__init__.py

@@ -0,0 +1,5 @@
+"""Training utilities for the loveGPT matchmaker model."""
+
+__all__ = ["__version__"]
+
+__version__ = "0.1.0"

training/src/lovegpt_matchmaker_training/crypto.py

@@ -0,0 +1,68 @@
+from __future__ import annotations
+
+import base64
+import hashlib
+import hmac
+import json
+import os
+from typing import Any
+
+from cryptography.hazmat.primitives.ciphers.aead import AESGCM
+
+MATCHMAKER_TABLE_SCHEMA = "opendatebase.matchmaker.table.v1"
+
+
+def b64url_decode(value: str) -> bytes:
+    return base64.urlsafe_b64decode(value + ("=" * (-len(value) % 4)))
+
+
+def canonical_json(value: Any) -> bytes:
+    return json.dumps(value, sort_keys=True, separators=(",", ":"), ensure_ascii=False).encode("utf-8")
+
+
+def _dataclaw_profile_key() -> tuple[bytes, str]:
+    raw = os.getenv("DATACLAW_PROFILE_KEY", "").strip()
+    if not raw:
+        raise SystemExit("DATACLAW_PROFILE_KEY or MATCHMAKER_TABLE_KEY is required to decrypt encrypted matchmaker rows.")
+    try:
+        decoded = b64url_decode(raw)
+    except Exception:
+        decoded = b""
+    if len(decoded) >= 32:
+        return hashlib.sha256(decoded).digest(), "dataclaw-secret"
+    return hashlib.sha256(raw.encode("utf-8")).digest(), "dataclaw-secret"
+
+
+def matchmaker_table_key() -> bytes:
+    raw = os.getenv("MATCHMAKER_TABLE_KEY", "").strip()
+    if raw:
+        try:
+            decoded = b64url_decode(raw)
+        except Exception:
+            decoded = b""
+        if len(decoded) >= 32:
+            return hashlib.sha256(decoded).digest()
+        return hashlib.sha256(raw.encode("utf-8")).digest()
+
+    key, _scope = _dataclaw_profile_key()
+    return hashlib.sha256(key + b"opendatebase-matchmaker-table").digest()
+
+
+def scoped_key_id(key: bytes, scope: bytes) -> str:
+    return hmac.new(key, scope, hashlib.sha256).hexdigest()[:16]
+
+
+def decrypt_matchmaker_row(row: dict[str, Any] | str) -> dict[str, Any]:
+    encrypted = json.loads(row) if isinstance(row, str) else row
+    if encrypted.get("schema") != MATCHMAKER_TABLE_SCHEMA:
+        raise ValueError("Unsupported matchmaker row schema.")
+    key = matchmaker_table_key()
+    expected_key_id = scoped_key_id(key, b"opendatebase-matchmaker-table")
+    if not hmac.compare_digest(str(encrypted.get("keyId", "")), expected_key_id):
+        raise ValueError("Matchmaker table key mismatch.")
+    plaintext = AESGCM(key).decrypt(
+        b64url_decode(str(encrypted["nonce"])),
+        b64url_decode(str(encrypted["ciphertext"])),
+        canonical_json(encrypted["aad"]),
+    )
+    return json.loads(plaintext.decode("utf-8"))

training/src/lovegpt_matchmaker_training/features.py

@@ -0,0 +1,85 @@
+from __future__ import annotations
+
+from typing import Any
+
+from .privacy import age_bucket, normalize_text, redact_contacts
+from .questions import load_questions
+from .schema import ProfilePayload, Question
+
+
+SENSITIVE_PROFILE_KEYS = {
+    "display_name",
+    "name",
+    "full_name",
+    "location",
+    "email",
+    "phone",
+    "contact",
+    "handle",
+}
+
+
+def _answer_text(answer: Any) -> str:
+    if isinstance(answer, list):
+        return redact_contacts("; ".join(normalize_text(item) for item in answer))
+    return redact_contacts(normalize_text(answer))
+
+
+def sanitize_profile(payload: ProfilePayload, questions: list[Question] | None = None) -> dict[str, Any]:
+    """Return the training-safe view of a questionnaire payload.
+
+    This intentionally excludes user ids, usernames, profile ids, exact location,
+    exact age, and display names. It keeps questionnaire content because that is
+    the signal the matchmaker must learn from.
+    """
+
+    _, all_questions = load_questions()
+    questions = questions or all_questions
+    answers = payload.get("answers", {}) if isinstance(payload.get("answers"), dict) else {}
+    profile = payload.get("profile", {}) if isinstance(payload.get("profile"), dict) else {}
+
+    sanitized_answers: dict[str, dict[str, Any]] = {}
+    for question in questions:
+        raw = answers.get(question.id)
+        if not isinstance(raw, dict):
+            continue
+        answer = _answer_text(raw.get("answer"))
+        if not answer:
+            continue
+        sanitized_answers[question.id] = {
+            "question": question.prompt,
+            "categoryId": question.category_id,
+            "tags": list(question.tags),
+            "answer": answer,
+            "dealbreakerSeverity": raw.get("dealbreakerSeverity"),
+        }
+
+    return {
+        "ageBucket": age_bucket(profile.get("age", "")),
+        "intent": redact_contacts(normalize_text(profile.get("intent", ""))) or "unknown",
+        "profileComplete": bool(payload.get("profileComplete")),
+        "answerCount": len(sanitized_answers),
+        "answers": sanitized_answers,
+        "captivatingTraits": [redact_contacts(normalize_text(item)) for item in payload.get("captivatingTraits", [])][:16],
+        "disgustTriggers": [redact_contacts(normalize_text(item)) for item in payload.get("disgustTriggers", [])][:16],
+    }
+
+
+def compact_profile_for_prompt(profile: dict[str, Any], max_answer_chars: int = 420) -> dict[str, Any]:
+    answers = {}
+    for question_id, answer in profile.get("answers", {}).items():
+        text = normalize_text(answer.get("answer", ""))
+        answers[question_id] = {
+            "categoryId": answer.get("categoryId"),
+            "tags": answer.get("tags", []),
+            "answer": text[:max_answer_chars],
+            "dealbreakerSeverity": answer.get("dealbreakerSeverity"),
+        }
+    return {
+        "ageBucket": profile.get("ageBucket", "unknown"),
+        "intent": profile.get("intent", "unknown"),
+        "answerCount": profile.get("answerCount", len(answers)),
+        "answers": answers,
+        "captivatingTraits": profile.get("captivatingTraits", [])[:8],
+        "disgustTriggers": profile.get("disgustTriggers", [])[:8],
+    }

training/src/lovegpt_matchmaker_training/privacy.py

@@ -0,0 +1,49 @@
+from __future__ import annotations
+
+import hashlib
+import hmac
+import os
+import re
+from typing import Any
+
+CONTACT_PATTERNS = [
+    re.compile(r"\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}\b", re.IGNORECASE),
+    re.compile(r"\b(?:\+?1[\s.-]?)?(?:\(?\d{3}\)?[\s.-]?)\d{3}[\s.-]?\d{4}\b"),
+    re.compile(r"\b(?:instagram|insta|ig|snapchat|telegram|discord|whatsapp|signal)\s*[:@]\s*[A-Za-z0-9_.-]+\b", re.IGNORECASE),
+    re.compile(r"\bhttps?://\S+\b", re.IGNORECASE),
+]
+
+
+def normalize_text(value: Any) -> str:
+    return re.sub(r"\s+", " ", str(value or "").strip())
+
+
+def redact_contacts(value: str) -> str:
+    text = normalize_text(value)
+    for pattern in CONTACT_PATTERNS:
+        text = pattern.sub("[redacted-contact]", text)
+    return text
+
+
+def stable_hash(value: str, salt: str = "lovegpt-training") -> str:
+    digest = hmac.new(salt.encode("utf-8"), value.encode("utf-8"), hashlib.sha256).hexdigest()
+    return digest[:16]
+
+
+def age_bucket(value: Any) -> str:
+    text = normalize_text(value)
+    match = re.search(r"\d{1,3}", text)
+    if not match:
+        return "unknown"
+    age = max(18, min(99, int(match.group(0))))
+    lower = (age // 5) * 5
+    upper = lower + 4
+    return f"{lower}-{upper}"
+
+
+def require_training_ack() -> None:
+    if os.getenv("MATCHMAKER_TRAINING_ACK") != "1":
+        raise SystemExit(
+            "Set MATCHMAKER_TRAINING_ACK=1 before writing model-training data. "
+            "This acknowledges that Dataclaw-authorized profile text will be de-identified and used for training."
+        )

training/src/lovegpt_matchmaker_training/questions.py

@@ -0,0 +1,27 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from .schema import Question
+
+
+def project_root() -> Path:
+    return Path(__file__).resolve().parents[3]
+
+
+def load_questions(path: Path | None = None) -> tuple[list[dict], list[Question]]:
+    questions_path = path or project_root() / "shared" / "questions.json"
+    document = json.loads(questions_path.read_text(encoding="utf-8"))
+    questions = [
+        Question(
+            id=item["id"],
+            number=int(item["number"]),
+            category_id=item["categoryId"],
+            prompt=item["prompt"],
+            weight=float(item["weight"]),
+            tags=tuple(item.get("tags", [])),
+        )
+        for item in document["questions"]
+    ]
+    return list(document["categories"]), questions

training/src/lovegpt_matchmaker_training/schema.py

@@ -0,0 +1,26 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+
+@dataclass(frozen=True)
+class Question:
+    id: str
+    number: int
+    category_id: str
+    prompt: str
+    weight: float
+    tags: tuple[str, ...]
+
+
+@dataclass(frozen=True)
+class HarnessDimension:
+    id: str
+    label: str
+    weight: float
+    tags: frozenset[str]
+
+
+ProfilePayload = dict[str, Any]
+PairExample = dict[str, Any]

training/src/lovegpt_matchmaker_training/teacher.py

@@ -0,0 +1,107 @@
+from __future__ import annotations
+
+import math
+import re
+from typing import Any
+
+from .questions import load_questions
+from .schema import HarnessDimension, ProfilePayload
+
+MATCHMAKER_HARNESS = [
+    HarnessDimension("values_future", "Values and future direction", 0.18, frozenset({"values", "future", "long_term_fit", "life_design"})),
+    HarnessDimension("emotional_safety", "Emotional safety and attachment", 0.16, frozenset({"emotional_safety", "attachment", "trust", "care", "support"})),
+    HarnessDimension("captivation", "Captivating traits and admiration", 0.14, frozenset({"captivating_traits", "attraction", "desire", "chemistry"})),
+    HarnessDimension("disgust_filters", "Disgust filters and aversions", 0.17, frozenset({"disgust", "hygiene", "hard_filter", "lifestyle_filters"})),
+    HarnessDimension("conflict_repair", "Conflict and repair", 0.13, frozenset({"conflict", "repair", "apology", "communication"})),
+    HarnessDimension("lifestyle", "Lifestyle and practical future", 0.10, frozenset({"lifestyle", "money", "family", "home", "health", "growth"})),
+    HarnessDimension("body_attraction", "Body-type attraction alignment", 0.12, frozenset({"body_type", "desired_body_type", "physical_attraction", "body_preference"})),
+]
+
+
+def lexical_score(a: str, b: str) -> float:
+    a_terms = {term for term in re.findall(r"[a-z0-9]{3,}", a.lower())}
+    b_terms = {term for term in re.findall(r"[a-z0-9]{3,}", b.lower())}
+    if not a_terms or not b_terms:
+        return 0.0
+    return len(a_terms & b_terms) / math.sqrt(len(a_terms) * len(b_terms))
+
+
+def answers_for_tags(payload: ProfilePayload, tags: frozenset[str]) -> str:
+    _, questions = load_questions()
+    answers = payload.get("answers", {})
+    chunks: list[str] = []
+    for question in questions:
+        if question.id not in answers or not (set(question.tags) & tags):
+            continue
+        answer = answers[question.id].get("answer", "")
+        if isinstance(answer, list):
+            chunks.extend(str(item) for item in answer)
+        else:
+            chunks.append(str(answer))
+    return " ".join(chunks)
+
+
+def question_answer(payload: ProfilePayload, question_id: str) -> str:
+    answer = payload.get("answers", {}).get(question_id, {}).get("answer", "")
+    if isinstance(answer, list):
+        return " ".join(str(item) for item in answer)
+    return str(answer)
+
+
+def open_preference_text(value: str) -> bool:
+    lowered = value.lower()
+    return any(term in lowered for term in ("open", "flexible", "range", "many", "varied", "not picky", "any", "all body"))
+
+
+def body_alignment_score(a: ProfilePayload, b: ProfilePayload) -> float:
+    a_own = " ".join([question_answer(a, "q37"), question_answer(a, "q40")])
+    a_wants = " ".join([question_answer(a, "q38"), question_answer(a, "q39")])
+    b_own = " ".join([question_answer(b, "q37"), question_answer(b, "q40")])
+    b_wants = " ".join([question_answer(b, "q38"), question_answer(b, "q39")])
+    if not a_wants or not b_wants:
+        return 0.0
+    a_to_b = 0.75 if open_preference_text(a_wants) else lexical_score(a_wants, b_own)
+    b_to_a = 0.75 if open_preference_text(b_wants) else lexical_score(b_wants, a_own)
+    return max(0.0, min(1.0, (a_to_b + b_to_a) / 2))
+
+
+def strict_matchmaker_judgment(a: ProfilePayload, b: ProfilePayload) -> dict[str, Any]:
+    dimensions: list[dict[str, Any]] = []
+    weighted = 0.0
+    for item in MATCHMAKER_HARNESS:
+        score = body_alignment_score(a, b) if item.id == "body_attraction" else lexical_score(answers_for_tags(a, item.tags), answers_for_tags(b, item.tags))
+        weighted += score * item.weight
+        dimensions.append(
+            {
+                "id": item.id,
+                "label": item.label,
+                "score": round(score * 100, 1),
+                "weight": item.weight,
+            }
+        )
+
+    body_score = next(row["score"] for row in dimensions if row["id"] == "body_attraction")
+    disgust_score = next(row["score"] for row in dimensions if row["id"] == "disgust_filters")
+    total = round(weighted * 100, 1)
+    passed = total >= 62 and body_score >= 20 and disgust_score >= 12
+    return {
+        "harness": "strict-v1-teacher",
+        "compatibility": total,
+        "passed": passed,
+        "dimensions": dimensions,
+        "requirements": {
+            "minimumCompatibility": 62,
+            "minimumBodyAlignment": 20,
+            "minimumDisgustAlignment": 12,
+        },
+    }
+
+
+def label_from_score(score: float) -> str:
+    if score >= 78:
+        return "high_match"
+    if score >= 62:
+        return "candidate"
+    if score >= 42:
+        return "weak_match"
+    return "do_not_match"

training/train_lora.py

@@ -0,0 +1,127 @@
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+from typing import Any
+
+ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(ROOT / "training" / "src"))
+
+
+def load_config(path: Path) -> dict[str, Any]:
+    import yaml
+
+    return yaml.safe_load(path.read_text(encoding="utf-8"))
+
+
+def load_jsonl(path: Path) -> list[dict[str, Any]]:
+    return [json.loads(line) for line in path.read_text(encoding="utf-8").splitlines() if line.strip()]
+
+
+def format_messages(tokenizer: Any, row: dict[str, Any]) -> str:
+    messages = row["messages"]
+    if getattr(tokenizer, "chat_template", None):
+        return tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=False)
+    return "\n\n".join(f"{msg['role'].upper()}: {msg['content']}" for msg in messages)
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Train a small loveGPT matchmaker LoRA adapter.")
+    parser.add_argument("--config", type=Path, default=Path("training/config/matchmaker_1b_lora.yaml"))
+    args = parser.parse_args()
+
+    import torch
+    from datasets import Dataset
+    from peft import LoraConfig, get_peft_model, prepare_model_for_kbit_training
+    from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig, DataCollatorForLanguageModeling, Trainer, TrainingArguments
+
+    cfg = load_config(args.config)
+    model_name = cfg["model"]["base_model"]
+    train_rows = load_jsonl(Path(cfg["data"]["train_file"]))
+    eval_rows = load_jsonl(Path(cfg["data"]["eval_file"]))
+
+    tokenizer = AutoTokenizer.from_pretrained(model_name, trust_remote_code=cfg["model"].get("trust_remote_code", False))
+    if tokenizer.pad_token is None:
+        tokenizer.pad_token = tokenizer.eos_token
+
+    train_dataset = Dataset.from_list([{"text": format_messages(tokenizer, row)} for row in train_rows])
+    eval_dataset = Dataset.from_list([{"text": format_messages(tokenizer, row)} for row in eval_rows])
+
+    quant_cfg = None
+    if cfg["model"].get("load_in_4bit", True):
+        quant_cfg = BitsAndBytesConfig(
+            load_in_4bit=True,
+            bnb_4bit_quant_type="nf4",
+            bnb_4bit_use_double_quant=True,
+            bnb_4bit_compute_dtype=torch.bfloat16 if torch.cuda.is_available() else torch.float32,
+        )
+
+    model = AutoModelForCausalLM.from_pretrained(
+        model_name,
+        quantization_config=quant_cfg,
+        device_map=cfg["model"].get("device_map", "auto"),
+        trust_remote_code=cfg["model"].get("trust_remote_code", False),
+    )
+    if quant_cfg is not None:
+        model = prepare_model_for_kbit_training(model)
+
+    lora = LoraConfig(
+        r=int(cfg["lora"]["r"]),
+        lora_alpha=int(cfg["lora"]["alpha"]),
+        lora_dropout=float(cfg["lora"]["dropout"]),
+        bias="none",
+        task_type="CAUSAL_LM",
+        target_modules=list(cfg["lora"]["target_modules"]),
+    )
+    model = get_peft_model(model, lora)
+
+    training_args = TrainingArguments(
+        output_dir=cfg["training"]["output_dir"],
+        per_device_train_batch_size=int(cfg["training"]["per_device_train_batch_size"]),
+        per_device_eval_batch_size=int(cfg["training"]["per_device_eval_batch_size"]),
+        gradient_accumulation_steps=int(cfg["training"]["gradient_accumulation_steps"]),
+        learning_rate=float(cfg["training"]["learning_rate"]),
+        num_train_epochs=float(cfg["training"]["num_train_epochs"]),
+        warmup_ratio=float(cfg["training"]["warmup_ratio"]),
+        logging_steps=int(cfg["training"]["logging_steps"]),
+        evaluation_strategy="steps",
+        eval_steps=int(cfg["training"]["eval_steps"]),
+        save_steps=int(cfg["training"]["save_steps"]),
+        save_total_limit=int(cfg["training"]["save_total_limit"]),
+        bf16=bool(cfg["training"].get("bf16", True)) and torch.cuda.is_available(),
+        fp16=bool(cfg["training"].get("fp16", False)) and torch.cuda.is_available(),
+        report_to=list(cfg["training"].get("report_to", [])),
+        remove_unused_columns=False,
+    )
+
+    max_seq_length = int(cfg["training"]["max_seq_length"])
+
+    def tokenize(batch: dict[str, list[str]]) -> dict[str, Any]:
+        return tokenizer(
+            batch["text"],
+            truncation=True,
+            max_length=max_seq_length,
+            padding=False,
+        )
+
+    tokenized_train = train_dataset.map(tokenize, batched=True, remove_columns=["text"])
+    tokenized_eval = eval_dataset.map(tokenize, batched=True, remove_columns=["text"])
+    collator = DataCollatorForLanguageModeling(tokenizer=tokenizer, mlm=False)
+
+    trainer = Trainer(
+        model=model,
+        args=training_args,
+        train_dataset=tokenized_train,
+        eval_dataset=tokenized_eval,
+        data_collator=collator,
+    )
+    trainer.train()
+    trainer.save_model(cfg["training"]["adapter_output_dir"])
+    tokenizer.save_pretrained(cfg["training"]["adapter_output_dir"])
+    print(f"Saved adapter to {cfg['training']['adapter_output_dir']}")
+
+
+if __name__ == "__main__":
+    main()