{
"cells": [
{
"cell_type": "markdown",
"id": "117285fe",
"metadata": {
"papermill": {
"duration": 0.033138,
"end_time": "2026-06-28T01:03:51.631234+00:00",
"exception": false,
"start_time": "2026-06-28T01:03:51.598096+00:00",
"status": "completed"
},
"tags": []
},
"source": [
"# TIMPS-Coder v4 — SGS + GRPO Training Pipeline (Kaggle Edition)\n",
"\n",
"**Scaling from 0.5B → 7B with Self-Guided Self-Play + Group Relative Policy Optimization + Tool Discipline**\n",
"\n",
"> Adapted from the original Colab notebook to run on **Kaggle Notebooks** (free 30 GPU-hours/week).\n",
"\n",
"---\n",
"\n",
"## Kaggle Quick Start (READ THIS FIRST)\n",
"\n",
"### 1. Choose the right accelerator\n",
"On the right sidebar → **Settings** → **Accelerator**, choose:\n",
"\n",
"| Option | Verdict | Why |\n",
"|--------|---------|-----|\n",
"| **GPU T4 x2** | **RECOMMENDED** | 2x T4 = 30 GB total VRAM (15 GB each). Modern Turing arch, fp16 fast, Unsloth compatible. Fits QLoRA 7B + GRPO. |\n",
"| GPU P100 | OK alternative | 16 GB single GPU. Older Pascal arch, no bf16, slower than T4. Use if T4 quota exhausted. |\n",
"| TPU v5-1e | NOT recommended | Unsloth / transformers do not fully support TPU. Would require PyTorch-XLA rewrite. |\n",
"\n",
"**Pick `GPU T4 x2`.** The notebook auto-detects the GPU and tunes batch sizes accordingly.\n",
"The notebook will use GPU 0 (one T4, 15 GB) — that is enough for QLoRA 7B + GRPO with gradient checkpointing.\n",
"\n",
"### 2. Turn ON Internet\n",
"Right sidebar → **Settings** → **Internet** → toggle **On**.\n",
"Required for `pip install`, HuggingFace downloads, and dataset streaming.\n",
"\n",
"### 3. Add your secrets (HF_TOKEN, optional WANDB_API_KEY)\n",
"Right sidebar → **Add-ons** → **Secrets**. Add:\n",
"\n",
"| Label | Value | Required? |\n",
"|-------|-------|-----------|\n",
"| `HF_TOKEN` | Your HuggingFace token (https://huggingface.co/settings/tokens) | YES — needed to download Qwen2.5-Coder-7B (gated) and to push the trained model back. |\n",
"| `WANDB_API_KEY` | Your W&B key (https://wandb.ai/authorize) | Optional — for training dashboards. |\n",
"\n",
"### 4. Persistent output\n",
"- All trained weights, GGUF files, and result JSONs are saved to `/kaggle/working/`.\n",
"- At the end of the run, **Kaggle auto-saves** `/kaggle/working/` as the notebook **Output**.\n",
"- You can download individual files from the **Output** tab of your notebook page, or push them to HuggingFace Hub (Step 20).\n",
"\n",
"### 5. Time budget on a single Kaggle session\n",
"Kaggle free tier = **12 hours max per session**, **30 GPU-hours/week**.\n",
"The full TIMPS v4 pipeline on T4 takes roughly:\n",
"\n",
"| Step | Time on T4 x2 (1 GPU used) |\n",
"|------|----------------------------|\n",
"| Install + data load | ~10-15 min |\n",
"| SFT warmup (750 steps) | ~30-45 min |\n",
"| GRPO (3 epochs x ~500 problems x 4 gens) | **~3-4 hours** |\n",
"| DPO pair generation (200 pairs x 2 samples) | ~30 min |\n",
"| DPO training (1 epoch) | ~20 min |\n",
"| SGS self-play (10 rounds x 60 problems x 4 sols) | **~3-4 hours** |\n",
"| HumanEval + health check | ~15 min |\n",
"| Save + fuse + push | ~15 min |\n",
"\n",
"**Total: ~8-10 hours** → fits inside one Kaggle session if you keep all steps enabled.\n",
"To make it shorter, set `KAGGLE_FAST_MODE = True` in Step 0 — it cuts SGS to 5 rounds and DPO to 100 pairs (~5 hours total).\n",
"\n",
"---\n",
"\n",
"## The 4-Step Pipeline\n",
"\n",
"| Step | Method | Purpose | Reference |\n",
"|------|--------|---------|-----------|\n",
"| **1** | **GRPO + Tool Discipline** | RL training with inspect-before-act rewards | DeepSeek-R1 + Snorkel AI |\n",
"| **2** | **DPO Alignment** | Preference optimization on GRPO outputs | Direct Preference Optimization |\n",
"| **3** | **SGS Self-Play** | Self-guided curriculum with Solver/Conjecturer/Guide | arXiv 2604.20209v1 |\n",
"| **4** | **Benchmarks + Deploy** | Evaluate on HumanEval/MBPP/LiveCodeBench & push to HF/Ollama | Industry standard |\n",
"\n",
"---\n",
"\n",
"## Why This Works\n",
"\n",
"- **SGS Paper** (arXiv 2604.20209v1): 7B model beat 671B using Self-Guided Self-Play\n",
"- **Snorkel AI**: Small models beat large ones by learning **Tool Discipline** (inspect before act)\n",
"- **DeepSeek-R1**: GRPO removes the need for a critic model (saves 50% VRAM)\n",
"- **Unsloth**: 2x faster training, 60% less VRAM (essential for T4)\n",
"\n",
"---\n"
]
},
{
"cell_type": "markdown",
"id": "b4df5cef",
"metadata": {
"papermill": {
"duration": 0.028796,
"end_time": "2026-06-28T01:03:51.690062+00:00",
"exception": false,
"start_time": "2026-06-28T01:03:51.661266+00:00",
"status": "completed"
},
"tags": []
},
"source": [
"---\n",
"# PHASE 1: ENVIRONMENT SETUP\n",
"\n",
"Setting up the Kaggle environment: GPU detection, dependency installation, and HuggingFace / W&B authentication via Kaggle Secrets.\n"
]
},
{
"cell_type": "markdown",
"id": "2ead5d79",
"metadata": {
"papermill": {
"duration": 0.028541,
"end_time": "2026-06-28T01:03:51.747826+00:00",
"exception": false,
"start_time": "2026-06-28T01:03:51.719285+00:00",
"status": "completed"
},
"tags": []
},
"source": [
"# @title Step 0 — Kaggle configuration flags\n",
"\n",
"These flags control the runtime budget. Set `KAGGLE_FAST_MODE = True` for a ~5-hour smoke test.\n",
"Keep `False` for the full ~8-10h run inside a single Kaggle session.\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "da8b7046",
"metadata": {},
"outputs": [],
"source": [
"# ---------------------------------------------------------------------------\n",
"# KAGGLE RUNTIME CONFIGURATION — edit these flags before running\n",
"# ---------------------------------------------------------------------------\n",
"\n",
"# True -> ~5h total: DPO=100 pairs, SFT=400 steps, GRPO=1 epoch\n",
"# False -> ~8-10h total: full DPO=200 pairs, SFT=750 steps, GRPO=3 epochs\n",
"KAGGLE_FAST_MODE = False\n",
"\n",
"# Where everything (checkpoints, fused model, gguf, results) is written.\n",
"# /kaggle/working is the ONLY persistent directory Kaggle saves as Output.\n",
"WORK_DIR = \"/kaggle/working\"\n",
"OUTPUT_DIR = f\"{WORK_DIR}/timps-coder-v4\" # checkpoints\n",
"FUSED_DIR = f\"{WORK_DIR}/timps-coder-v4-fused\" # merged model\n",
"GGUF_DIR = f\"{WORK_DIR}/timps-coder-v4-gguf\" # gguf files\n",
"ADAPTER_DIR = f\"{WORK_DIR}/timps-coder-v4-adapters\" # LoRA adapters\n",
"\n",
"# HuggingFace upload target — change to YOUR username/repo\n",
"HF_USERNAME = \"sandeeprdy1729\"\n",
"HF_REPO = f\"{HF_USERNAME}/TIMPS-Coder-7B\"\n",
"\n",
"import os\n",
"for d in (OUTPUT_DIR, FUSED_DIR, GGUF_DIR, ADAPTER_DIR):\n",
" os.makedirs(d, exist_ok=True)\n",
"\n",
"# Derive budget from fast-mode flag\n",
"if KAGGLE_FAST_MODE:\n",
" SFT_MAX_STEPS = 400\n",
" GRPO_EPOCHS = 1\n",
" DPO_NUM_PAIRS = 100\n",
" SGS_K_PER_ROUND = 2\n",
" SGS_TARGET_PROBLEMS = 30\n",
" HUMANEVAL_NUM_SAMPLES = 1\n",
"else:\n",
" SFT_MAX_STEPS = 750\n",
" GRPO_EPOCHS = 3\n",
" DPO_NUM_PAIRS = 200\n",
" SGS_K_PER_ROUND = 4\n",
" SGS_TARGET_PROBLEMS = 60\n",
" HUMANEVAL_NUM_SAMPLES = 1\n",
"\n",
"# SGS rounds are pinned to 7 regardless of fast/full mode. The previous run\n",
"# did 10 rounds and never produced a passing solution (0/600 updates passed) —\n",
"# each extra round was pure GPU time + an extra checkpoint on disk with no\n",
"# benefit. 7 rounds keeps the checkpoint/self-play signal while trimming both\n",
"# runtime and the disk footprint that caused the OOS crash last time.\n",
"SGS_NUM_ROUNDS = 7\n",
"\n",
"# Toggle GGUF/Ollama export off if you just want the HF upload and don't want\n",
"# the extra ~18GB of disk churn (F16 + Q4_K_M) that step needs.\n",
"DO_GGUF_CONVERSION = True\n",
"\n",
"# Minimum free disk (GB) required before any disk-heavy step is allowed to\n",
"# start. If free space is below this, the notebook will pause and clean up\n",
"# rather than crash mid-write like last time.\n",
"MIN_FREE_DISK_GB = 15\n",
"\n",
"print(\"Kaggle configuration:\")\n",
"print(f\" WORK_DIR : {WORK_DIR}\")\n",
"print(f\" KAGGLE_FAST_MODE : {KAGGLE_FAST_MODE}\")\n",
"print(f\" SFT_MAX_STEPS : {SFT_MAX_STEPS}\")\n",
"print(f\" GRPO_EPOCHS : {GRPO_EPOCHS}\")\n",
"print(f\" DPO_NUM_PAIRS : {DPO_NUM_PAIRS}\")\n",
"print(f\" SGS_NUM_ROUNDS : {SGS_NUM_ROUNDS} (pinned, independent of fast/full mode)\")\n",
"print(f\" SGS_K_PER_ROUND : {SGS_K_PER_ROUND}\")\n",
"print(f\" SGS_TARGET_PROBLEMS : {SGS_TARGET_PROBLEMS}\")\n",
"print(f\" DO_GGUF_CONVERSION : {DO_GGUF_CONVERSION}\")\n",
"print(f\" HF repo (if uploaded): {HF_REPO}\")\n"
]
},
{
"cell_type": "markdown",
"id": "2b50ceae",
"metadata": {},
"source": [
"# @title Step 0b — Disk-safety helpers\n",
"\n",
"Small helper used later in the notebook (Steps 19-21) to check free space and\n",
"clean up before any disk-heavy write. This is what prevents the\n",
"`OSError: No space left on device` crash that killed the previous run during\n",
"model fusing."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "6fee3881",
"metadata": {},
"outputs": [],
"source": [
"import shutil\n",
"\n",
"def free_disk_gb(path=\"/kaggle/working\"):\n",
" \"\"\"Free space in GB on the filesystem containing `path`.\"\"\"\n",
" _, _, free = shutil.disk_usage(path)\n",
" return free / 1e9\n",
"\n",
"def show_disk_usage(label=\"\"):\n",
" free = free_disk_gb()\n",
" print(f\"[disk]{' ' + label if label else ''}: {free:.1f} GB free\")\n",
" return free\n",
"\n",
"show_disk_usage(\"at notebook start\")\n"
]
},
{
"cell_type": "markdown",
"id": "4cca103b",
"metadata": {
"papermill": {
"duration": 0.028436,
"end_time": "2026-06-28T01:03:51.877014+00:00",
"exception": false,
"start_time": "2026-06-28T01:03:51.848578+00:00",
"status": "completed"
},
"tags": []
},
"source": [
"# @title Step 1 — Check GPU (Kaggle T4 / P100)\n",
"\n",
"Detects which Kaggle accelerator is attached and sets `DTYPE` / `GPU_TIER` accordingly.\n",
"T4 x2 is the recommended choice — the notebook will use GPU 0 (one T4, 15 GB).\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "1751c42d",
"metadata": {
"execution": {
"iopub.execute_input": "2026-06-28T01:03:51.935690Z",
"iopub.status.busy": "2026-06-28T01:03:51.935172Z",
"iopub.status.idle": "2026-06-28T01:03:56.494611Z",
"shell.execute_reply": "2026-06-28T01:03:56.493472Z"
},
"papermill": {
"duration": 4.590926,
"end_time": "2026-06-28T01:03:56.496328+00:00",
"exception": false,
"start_time": "2026-06-28T01:03:51.905402+00:00",
"status": "completed"
},
"tags": []
},
"outputs": [],
"source": [
"# ── OOM mitigation: set expandable_segments BEFORE importing torch ─────────\n",
"# This is THE fix the CUDA OOM error message itself recommends.\n",
"# Eliminates the \"1.42 GiB reserved but unallocated\" fragmentation slack.\n",
"import os\n",
"os.environ.setdefault(\"PYTORCH_ALLOC_CONF\", \"expandable_segments:True\")\n",
"\n",
"import subprocess, sys, torch\n",
"\n",
"result = subprocess.run(\n",
" ['nvidia-smi', '--query-gpu=name,memory.total', '--format=csv,noheader'],\n",
" capture_output=True, text=True\n",
")\n",
"\n",
"if result.returncode == 0:\n",
" gpu_lines = [l for l in result.stdout.strip().splitlines() if l.strip()]\n",
" print(\"GPU(s) detected:\")\n",
" for line in gpu_lines:\n",
" print(f\" {line}\")\n",
"\n",
" # Use device 0 as the primary\n",
" primary = gpu_lines[0]\n",
" name = primary.split(',')[0].strip()\n",
" vram = int(primary.split(',')[1].strip().split()[0])\n",
"\n",
" if vram >= 75000:\n",
" print(\"A100 80GB detected — full pipeline possible!\")\n",
" DTYPE = 'bfloat16'\n",
" GPU_TIER = 'a100_80'\n",
" elif vram >= 35000:\n",
" print(\"A100 40GB detected — full pipeline possible\")\n",
" DTYPE = 'bfloat16'\n",
" GPU_TIER = 'a100_40'\n",
" elif 'T4' in name:\n",
" print(\"T4 detected (Kaggle GPU T4 x2) — running QLoRA 7B + GRPO\")\n",
" print(\" Using fp16 (T4 has no bf16 hardware).\")\n",
" DTYPE = 'float16'\n",
" GPU_TIER = 't4'\n",
" elif 'P100' in name:\n",
" print(\"P100 detected (Kaggle GPU P100) — running QLoRA 7B + GRPO\")\n",
" print(\" Using fp16 (P100 has no bf16 hardware).\")\n",
" DTYPE = 'float16'\n",
" GPU_TIER = 'p100'\n",
" elif vram >= 15000:\n",
" print(\"15+ GB GPU detected — GRPO will be feasible on 7B with QLoRA\")\n",
" DTYPE = 'float16'\n",
" GPU_TIER = 'medium'\n",
" else:\n",
" print(\"Insufficient VRAM for 7B model + GRPO — switch to GPU T4 x2\")\n",
" DTYPE = 'float16'\n",
" GPU_TIER = 'low'\n",
"else:\n",
" print(\"No GPU found! Settings -> Accelerator -> GPU T4 x2\")\n",
" sys.exit(1)\n",
"\n",
"# Force primary GPU = device 0 (T4 x2 has 2 GPUs, we use only one)\n",
"# Note: only set if not already set, to respect user override\n",
"os.environ.setdefault(\"CUDA_VISIBLE_DEVICES\", \"0\")\n",
"\n",
"# ── Auto-scale memory budget by GPU tier ────────────────────────────────────\n",
"# These globals are read by the model-load, LoRA, and GRPO cells below.\n",
"# T4 (15 GB) is the binding constraint; A100 keeps the original aggressive profile.\n",
"if GPU_TIER in (\"a100_80\", \"a100_40\"):\n",
" BUDGET_MAX_SEQ_LEN = 4096\n",
" BUDGET_LORA_RANK = 64\n",
" BUDGET_NUM_GENERATIONS = 4\n",
" BUDGET_MAX_COMPLETION_LEN = 1024\n",
" BUDGET_MAX_PROMPT_LEN = 3072\n",
" BUDGET_GRPO_BATCH = 1\n",
" BUDGET_GRPO_GRAD_ACCUM = 8\n",
" BUDGET_OPTIM = \"adamw_torch\"\n",
"else:\n",
" # T4 / P100 / Medium — conservative profile that fits in 15 GB\n",
" BUDGET_MAX_SEQ_LEN = 2048 # was 4096 — cuts prompt context memory in half\n",
" BUDGET_LORA_RANK = 32 # was 64 — cuts trainable param memory in half (back to v3)\n",
" BUDGET_NUM_GENERATIONS = 2 # was 4 — cuts generation batch in half (biggest single win)\n",
" BUDGET_MAX_COMPLETION_LEN = 512 # was 1024 — cuts KV cache + logits in half\n",
" BUDGET_MAX_PROMPT_LEN = 1536 # was implicit 4096 — explicit truncation\n",
" BUDGET_GRPO_BATCH = 1\n",
" BUDGET_GRPO_GRAD_ACCUM = 8\n",
" BUDGET_OPTIM = \"paged_adamw_8bit\" # 8-bit + CPU paging on spikes\n",
"\n",
"print(f\"\\nDtype : {DTYPE}\")\n",
"print(f\"GPU tier : {GPU_TIER}\")\n",
"print(f\"PyTorch : {torch.__version__}\")\n",
"print(f\"CUDA : {torch.version.cuda}\")\n",
"print(f\"GPU count : {torch.cuda.device_count()}\")\n",
"if torch.cuda.is_available():\n",
" print(f\"Primary : {torch.cuda.get_device_name(0)}\")\n",
"print()\n",
"print(f\"Memory budget for {GPU_TIER}:\")\n",
"print(f\" MAX_SEQ_LEN = {BUDGET_MAX_SEQ_LEN}\")\n",
"print(f\" LORA_RANK = {BUDGET_LORA_RANK}\")\n",
"print(f\" NUM_GENERATIONS = {BUDGET_NUM_GENERATIONS}\")\n",
"print(f\" MAX_COMPLETION_LEN = {BUDGET_MAX_COMPLETION_LEN}\")\n",
"print(f\" MAX_PROMPT_LEN = {BUDGET_MAX_PROMPT_LEN}\")\n",
"print(f\" OPTIM = {BUDGET_OPTIM}\")\n",
"print(f\" PYTORCH_ALLOC_CONF = {os.environ.get('PYTORCH_ALLOC_CONF')}\")\n"
]
},
{
"cell_type": "markdown",
"id": "3a5f6c12",
"metadata": {
"papermill": {
"duration": 0.029696,
"end_time": "2026-06-28T01:03:56.557453+00:00",
"exception": false,
"start_time": "2026-06-28T01:03:56.527757+00:00",
"status": "completed"
},
"tags": []
},
"source": [
"# @title Step 2 — Install all dependencies (~5 min)\n",
"\n",
"Installs into the Kaggle environment. Note: `vllm` is **not installed** on Kaggle T4 by default\n",
"because vLLM pre-built wheels assume Ampere+. GRPO in TRL still works fine using HF generate().\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "60dc82a8",
"metadata": {
"execution": {
"iopub.execute_input": "2026-06-28T01:03:56.619143Z",
"iopub.status.busy": "2026-06-28T01:03:56.618275Z",
"iopub.status.idle": "2026-06-28T01:04:45.951053Z",
"shell.execute_reply": "2026-06-28T01:04:45.949891Z"
},
"papermill": {
"duration": 49.365784,
"end_time": "2026-06-28T01:04:45.952663+00:00",
"exception": false,
"start_time": "2026-06-28T01:03:56.586879+00:00",
"status": "completed"
},
"tags": []
},
"outputs": [],
"source": [
"# Install order matters — heavy packages first, unsloth last\n",
"# NOTE: vllm is skipped on Kaggle T4 (no Ampere+ wheels); TRL GRPOTrainer falls back to HF generate.\n",
"# If you switch to a Kaggle P100 or future L4/A100, you can add vllm back.\n",
"\n",
"!pip install -q datasets transformers accelerate peft trl bitsandbytes sentencepiece\n",
"!pip install -q pylint flake8 mypy pytest\n",
"!pip install -q evaluate absl-py\n",
"!pip install -q huggingface_hub wandb\n",
"!pip install -q \"unsloth @ git+https://github.com/unslothai/unsloth.git\"\n",
"\n",
"print(\"All packages installed!\")\n",
"print(\" Core : transformers, trl, peft, accelerate, bitsandbytes\")\n",
"print(\" RL : trl (GRPO/DPO via HF generate on T4)\")\n",
"print(\" CodeQA : pylint, flake8, mypy, pytest\")\n",
"print(\" Eval : evaluate, evalplus\")\n",
"print(\" Train : unsloth (2x faster, 60% less VRAM)\")\n"
]
},
{
"cell_type": "markdown",
"id": "9d91a95e",
"metadata": {
"papermill": {
"duration": 0.031483,
"end_time": "2026-06-28T01:04:46.015630+00:00",
"exception": false,
"start_time": "2026-06-28T01:04:45.984147+00:00",
"status": "completed"
},
"tags": []
},
"source": [
"# @title Step 3 — HuggingFace + Weights & Biases login (via Kaggle Secrets)\n",
"\n",
"Kaggle replaces Colab's `userdata.get()` with `kaggle_secrets.UserSecretsClient`.\n",
"Make sure you've added `HF_TOKEN` (and optionally `WANDB_API_KEY`) under\n",
"**Add-ons → Secrets** in the right sidebar before running this cell.\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "55fbad98",
"metadata": {
"execution": {
"iopub.execute_input": "2026-06-28T01:04:46.079917Z",
"iopub.status.busy": "2026-06-28T01:04:46.079099Z",
"iopub.status.idle": "2026-06-28T01:04:47.194401Z",
"shell.execute_reply": "2026-06-28T01:04:47.193610Z"
},
"papermill": {
"duration": 1.149466,
"end_time": "2026-06-28T01:04:47.195869+00:00",
"exception": false,
"start_time": "2026-06-28T01:04:46.046403+00:00",
"status": "completed"
},
"tags": []
},
"outputs": [],
"source": [
"import os\n",
"from huggingface_hub import login\n",
"\n",
"# -- HuggingFace --\n",
"hf_token = None\n",
"\n",
"# Try Kaggle Secrets first\n",
"try:\n",
" from kaggle_secrets import UserSecretsClient\n",
" secrets = UserSecretsClient()\n",
" hf_token = secrets.get_secret(\"HF_TOKEN\")\n",
" print(\"HF_TOKEN loaded from Kaggle Secrets\")\n",
"except Exception as e:\n",
" print(f\"Kaggle Secrets unavailable: {e}\")\n",
"\n",
"# Fallbacks: env var, or hard-coded (NOT recommended — only for local testing)\n",
"if not hf_token:\n",
" hf_token = os.environ.get(\"HF_TOKEN\")\n",
"if not hf_token:\n",
" hf_token = None # <- paste \"hf_...\" here as a last resort\n",
"\n",
"if hf_token:\n",
" login(token=hf_token, add_to_git_credential=True)\n",
" os.environ[\"HF_TOKEN\"] = hf_token\n",
" print(\"Logged in to HuggingFace\")\n",
"else:\n",
" print(\"No HF_TOKEN found. Add it under Kaggle -> Add-ons -> Secrets.\")\n",
" print(\" Without it, you cannot download Qwen2.5-Coder-7B (gated) or push your model.\")\n",
"\n",
"# -- Weights & Biases (optional) --\n",
"try:\n",
" from kaggle_secrets import UserSecretsClient\n",
" secrets = UserSecretsClient()\n",
" wandb_key = secrets.get_secret(\"WANDB_API_KEY\")\n",
" os.environ[\"WANDB_API_KEY\"] = wandb_key\n",
" print(\"Weights & Biases configured\")\n",
"except Exception:\n",
" print(\"No WANDB_API_KEY in Kaggle Secrets — training logs won't sync to W&B\")\n",
" print(\" (Training will still work, just no W&B dashboard)\")\n"
]
},
{
"cell_type": "markdown",
"id": "eb0985f8",
"metadata": {
"papermill": {
"duration": 0.030075,
"end_time": "2026-06-28T01:04:47.258099+00:00",
"exception": false,
"start_time": "2026-06-28T01:04:47.228024+00:00",
"status": "completed"
},
"tags": []
},
"source": [
"---\n",
"# PHASE 2: STEP 1 — BUILD CodeQA Environment\n",
"\n",
"The CodeQA environment is the sandboxed coding world where the model learns **Tool Discipline**.\n",
"This is the key insight from Snorkel AI: small models beat large ones by learning to\n",
"**inspect the environment before acting**.\n",
"\n",
"Our environment provides 6 tools:\n",
"1. `read_file` — Read source code (INSPECT)\n",
"2. `search_code` — Search codebase (INSPECT)\n",
"3. `inspect_error` — Parse error messages (INSPECT)\n",
"4. `check_linter` — Run linters/type checkers (INSPECT)\n",
"5. `write_file` — Write or edit code (ACT)\n",
"6. `run_tests` — Execute test suite (VERIFY)\n",
"\n",
"> The workspace is created under `/kaggle/working/codeqa_workspace` so test artifacts persist\n",
"> across cells. No Colab-specific paths.\n"
]
},
{
"cell_type": "markdown",
"id": "433ecc5b",
"metadata": {
"papermill": {
"duration": 0.030415,
"end_time": "2026-06-28T01:04:47.319853+00:00",
"exception": false,
"start_time": "2026-06-28T01:04:47.289438+00:00",
"status": "completed"
},
"tags": []
},
"source": [
"# @title Step 4 — Build CodeQA Tool Environment\n",
"Workspace is created under `/kaggle/working/codeqa_workspace` so files persist across cells.\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "8f27a00d",
"metadata": {
"execution": {
"iopub.execute_input": "2026-06-28T01:04:47.382913Z",
"iopub.status.busy": "2026-06-28T01:04:47.382627Z",
"iopub.status.idle": "2026-06-28T01:04:48.797703Z",
"shell.execute_reply": "2026-06-28T01:04:48.796589Z"
},
"papermill": {
"duration": 1.449437,
"end_time": "2026-06-28T01:04:48.799548+00:00",
"exception": false,
"start_time": "2026-06-28T01:04:47.350111+00:00",
"status": "completed"
},
"tags": []
},
"outputs": [],
"source": [
"import os, sys, subprocess, shutil, fnmatch, re\n",
"from typing import Dict, List, Optional, Any\n",
"\n",
"# ── Tool Descriptions (for model's function calling interface) ──\n",
"TOOL_DESCRIPTIONS = \"\"\"You have access to the following tools in the CodeQA environment:\n",
"\n",
"1. read_file(filepath: str) - Read source code from a file. Use this BEFORE editing to understand the codebase.\n",
"2. write_file(filepath: str, content: str) - Write or edit code in a file.\n",
"3. run_tests(test_file: str = None, test_pattern: str = None) - Execute the test suite. Always run after writing code.\n",
"4. check_linter(filepath: str, linter: str = \"pylint\") - Run a linter or type checker on a file.\n",
"5. inspect_error(error_message: str = None) - Parse an error message and identify the error type and location.\n",
"6. search_code(pattern: str, file_pattern: str = \"*.py\") - Search for patterns across the codebase.\n",
"\n",
"IMPORTANT: Always inspect before acting. Read the code, understand the error, THEN write your fix.\"\"\"\n",
"\n",
"\n",
"class CodeQAEnvironment:\n",
" \"\"\"Sandboxed coding environment with tool discipline training support.\n",
" \n",
" Tools: read_file, write_file, run_tests, check_linter, inspect_error, search_code\n",
" \n",
" This environment teaches models to INSPECT before ACTING — the key insight\n",
" from Snorkel AI that lets 4B models beat 235B models.\n",
" \"\"\"\n",
" \n",
" def __init__(self, workspace_dir=\"/kaggle/working/codeqa_workspace\"):\n",
" self.workspace = workspace_dir\n",
" os.makedirs(workspace_dir, exist_ok=True)\n",
" self.tool_history = [] # Track tool usage for reward shaping\n",
" \n",
" def read_file(self, filepath):\n",
" \"\"\"Read source code from workspace\"\"\"\n",
" full_path = os.path.join(self.workspace, filepath)\n",
" if not os.path.exists(full_path):\n",
" self.tool_history.append({\"tool\": \"read_file\", \"path\": filepath, \"success\": False})\n",
" return {\"error\": f\"File not found: {filepath}\", \"content\": None}\n",
" with open(full_path) as f:\n",
" content = f.read()\n",
" self.tool_history.append({\"tool\": \"read_file\", \"path\": filepath, \"success\": True})\n",
" return {\"content\": content, \"lines\": len(content.splitlines())}\n",
" \n",
" def write_file(self, filepath, content):\n",
" \"\"\"Write/edit code in workspace\"\"\"\n",
" full_path = os.path.join(self.workspace, filepath)\n",
" os.makedirs(os.path.dirname(full_path), exist_ok=True)\n",
" with open(full_path, 'w') as f:\n",
" f.write(content)\n",
" self.tool_history.append({\"tool\": \"write_file\", \"path\": filepath, \"success\": True})\n",
" return {\"status\": \"written\", \"path\": filepath, \"lines\": len(content.splitlines())}\n",
" \n",
" def run_tests(self, test_file=None, test_pattern=None):\n",
" \"\"\"Execute test suite using pytest\"\"\"\n",
" cmd = [sys.executable, \"-m\", \"pytest\", self.workspace]\n",
" if test_file:\n",
" cmd.append(os.path.join(self.workspace, test_file))\n",
" if test_pattern:\n",
" cmd.extend([\"-k\", test_pattern])\n",
" cmd.extend([\"-v\", \"--tb=short\", \"--no-header\"])\n",
" try:\n",
" result = subprocess.run(cmd, capture_output=True, text=True, timeout=60)\n",
" passed = result.returncode == 0\n",
" except subprocess.TimeoutExpired:\n",
" self.tool_history.append({\"tool\": \"run_tests\", \"passed\": False})\n",
" return {\"passed\": False, \"stdout\": \"TIMEOUT after 60s\", \"stderr\": \"\", \"returncode\": -1}\n",
" \n",
" self.tool_history.append({\"tool\": \"run_tests\", \"passed\": passed})\n",
" return {\n",
" \"passed\": passed,\n",
" \"stdout\": result.stdout[-2000:],\n",
" \"stderr\": result.stderr[-2000:],\n",
" \"returncode\": result.returncode,\n",
" }\n",
" \n",
" def check_linter(self, filepath, linter=\"pylint\"):\n",
" \"\"\"Run linter/type checker\"\"\"\n",
" full_path = os.path.join(self.workspace, filepath)\n",
" if linter == \"pylint\":\n",
" cmd = [sys.executable, \"-m\", \"pylint\", full_path, \"--output-format=text\", \n",
" \"--disable=C0114,C0115,C0116\"] # Disable docstring warnings\n",
" elif linter == \"flake8\":\n",
" cmd = [sys.executable, \"-m\", \"flake8\", full_path, \"--max-line-length=120\"]\n",
" elif linter == \"mypy\":\n",
" cmd = [sys.executable, \"-m\", \"mypy\", full_path, \"--ignore-missing-imports\"]\n",
" else:\n",
" return {\"error\": f\"Unknown linter: {linter}\"}\n",
" try:\n",
" result = subprocess.run(cmd, capture_output=True, text=True, timeout=30)\n",
" except subprocess.TimeoutExpired:\n",
" self.tool_history.append({\"tool\": \"check_linter\", \"linter\": linter, \"filepath\": filepath})\n",
" return {\"output\": \"TIMEOUT after 30s\", \"clean\": False}\n",
" \n",
" self.tool_history.append({\"tool\": \"check_linter\", \"linter\": linter, \"filepath\": filepath})\n",
" return {\"output\": result.stdout + result.stderr, \"clean\": result.returncode == 0}\n",
" \n",
" def inspect_error(self, error_message=None):\n",
" \"\"\"Parse error messages and provide structured feedback\"\"\"\n",
" if error_message is None:\n",
" # Check most recent test/linter output\n",
" recent = [h for h in self.tool_history if h[\"tool\"] in (\"run_tests\", \"check_linter\")]\n",
" if recent:\n",
" error_message = str(recent[-1])\n",
" self.tool_history.append({\"tool\": \"inspect_error\"})\n",
" \n",
" # Parse common error patterns\n",
" error_type = \"unknown\"\n",
" if \"AssertionError\" in str(error_message):\n",
" error_type = \"assertion\"\n",
" elif \"TypeError\" in str(error_message):\n",
" error_type = \"type\"\n",
" elif \"KeyError\" in str(error_message):\n",
" error_type = \"key\"\n",
" elif \"ImportError\" in str(error_message) or \"ModuleNotFoundError\" in str(error_message):\n",
" error_type = \"import\"\n",
" elif \"SyntaxError\" in str(error_message):\n",
" error_type = \"syntax\"\n",
" elif \"IndexError\" in str(error_message):\n",
" error_type = \"index\"\n",
" elif \"ValueError\" in str(error_message):\n",
" error_type = \"value\"\n",
" elif \"AttributeError\" in str(error_message):\n",
" error_type = \"attribute\"\n",
" elif \"TimeoutExpired\" in str(error_message) or \"TIMEOUT\" in str(error_message):\n",
" error_type = \"timeout\"\n",
" \n",
" return {\"error_type\": error_type, \"raw\": str(error_message)[:1500]}\n",
" \n",
" def search_code(self, pattern, file_pattern=\"*.py\"):\n",
" \"\"\"Search for patterns in codebase\"\"\"\n",
" matches = []\n",
" for root, dirs, files in os.walk(self.workspace):\n",
" for f in files:\n",
" if fnmatch.fnmatch(f, file_pattern):\n",
" full = os.path.join(root, f)\n",
" try:\n",
" with open(full) as fh:\n",
" for i, line in enumerate(fh, 1):\n",
" if pattern in line:\n",
" matches.append({\n",
" \"file\": os.path.relpath(full, self.workspace),\n",
" \"line\": i,\n",
" \"content\": line.strip(),\n",
" })\n",
" except Exception:\n",
" pass\n",
" self.tool_history.append({\"tool\": \"search_code\", \"pattern\": pattern, \"matches\": len(matches)})\n",
" return {\"matches\": matches[:20], \"total\": len(matches)}\n",
" \n",
" def get_tool_descriptions(self):\n",
" \"\"\"Return tool descriptions for the model's function calling interface\"\"\"\n",
" return TOOL_DESCRIPTIONS\n",
" \n",
" def reset(self):\n",
" \"\"\"Reset environment for new problem\"\"\"\n",
" self.tool_history = []\n",
" # Clean workspace\n",
" shutil.rmtree(self.workspace, ignore_errors=True)\n",
" os.makedirs(self.workspace, exist_ok=True)\n",
" \n",
" def compute_tool_discipline_reward(self):\n",
" \"\"\"Reward for using tools BEFORE writing code.\n",
" This is the KEY insight from Snorkel AI:\n",
" Small models beat large ones by learning to inspect environment first.\n",
" \"\"\"\n",
" if not self.tool_history:\n",
" return 0.0\n",
" \n",
" # Check if model read/inspected before writing\n",
" read_before_write = False\n",
" inspected_before_write = False\n",
" first_write_idx = None\n",
" for i, h in enumerate(self.tool_history):\n",
" if h[\"tool\"] == \"write_file\" and first_write_idx is None:\n",
" first_write_idx = i\n",
" break\n",
" \n",
" if first_write_idx is not None:\n",
" for h in self.tool_history[:first_write_idx]:\n",
" if h[\"tool\"] in (\"read_file\", \"search_code\"):\n",
" read_before_write = True\n",
" if h[\"tool\"] in (\"inspect_error\", \"check_linter\", \"run_tests\"):\n",
" inspected_before_write = True\n",
" \n",
" reward = 0.0\n",
" if read_before_write:\n",
" reward += 0.3 # Read before editing\n",
" if inspected_before_write:\n",
" reward += 0.2 # Inspected before editing\n",
" if not self.tool_history[0][\"tool\"] == \"write_file\":\n",
" reward += 0.2 # Didn't just jump to writing\n",
" if len([h for h in self.tool_history if h[\"tool\"] in (\"read_file\", \"inspect_error\", \"search_code\")]) >= 2:\n",
" reward += 0.3 # Multiple inspections\n",
" \n",
" return min(reward, 1.0)\n",
"\n",
"\n",
"# ── Tool Call Formatting (ChatML + function calling) ───────────\n",
"\n",
"def format_tool_call(tool_name: str, arguments: Dict[str, Any]) -> str:\n",
" \"\"\"Format a tool call in the model's expected output format.\"\"\"\n",
" import json\n",
" args_str = json.dumps(arguments, ensure_ascii=False)\n",
" return f\"\\n{{\\\"name\\\": \\\"{tool_name}\\\", \\\"arguments\\\": {args_str}}}\\n\"\n",
"\n",
"\n",
"def parse_tool_call(text: str) -> Optional[Dict]:\n",
" \"\"\"Parse a tool call from the model's text output.\n",
" \n",
" Returns: {\"name\": ..., \"arguments\": {...}} or None\n",
" \"\"\"\n",
" import json\n",
" \n",
" # Try format\n",
" pattern = r'\\s*\\n?(\\{.*?\\})\\s*\\n?'\n",
" match = re.search(pattern, text, re.DOTALL)\n",
" if match:\n",
" try:\n",
" return json.loads(match.group(1))\n",
" except json.JSONDecodeError:\n",
" pass\n",
" \n",
" # Try ```json format (common alternative)\n",
" pattern2 = r'```json\\s*\\n?(\\{.*?\\})\\s*\\n?```'\n",
" match2 = re.search(pattern2, text, re.DOTALL)\n",
" if match2:\n",
" try:\n",
" parsed = json.loads(match2.group(1))\n",
" if \"name\" in parsed:\n",
" return parsed\n",
" except json.JSONDecodeError:\n",
" pass\n",
" \n",
" return None\n",
"\n",
"\n",
"def format_tool_result(tool_name: str, result: Dict) -> str:\n",
" \"\"\"Format a tool execution result for the model.\"\"\"\n",
" import json\n",
" result_str = json.dumps(result, ensure_ascii=False, indent=2)\n",
" return f\"\\n{{\\\"tool\\\": \\\"{tool_name}\\\", \\\"output\\\": {result_str}}}\\n\"\n",
"\n",
"\n",
"# ── Test the environment ────────────────────────────────────────\n",
"env = CodeQAEnvironment()\n",
"\n",
"# Write a sample file\n",
"env.write_file(\"hello.py\", \"def greet(name):\\n return f'Hello, {name}!'\\n\")\n",
"env.write_file(\"test_hello.py\", \"from hello import greet\\n\\ndef test_greet():\\n assert greet('World') == 'Hello, World!'\\n\")\n",
"\n",
"# Read it back\n",
"result = env.read_file(\"hello.py\")\n",
"print(f\"📄 read_file result: {result}\")\n",
"\n",
"# Run tests\n",
"test_result = env.run_tests()\n",
"print(f\"🧪 run_tests result: passed={test_result['passed']}\")\n",
"\n",
"# Check tool discipline\n",
"reward = env.compute_tool_discipline_reward()\n",
"print(f\"🎯 Tool discipline reward: {reward:.2f}\")\n",
"\n",
"# Show tool history\n",
"print(f\"📋 Tool history: {env.tool_history}\")\n",
"\n",
"env.reset()\n",
"print(\"\\n✅ CodeQA Environment ready!\")\n",
"print(\" 6 tools: read_file, write_file, run_tests, check_linter, inspect_error, search_code\")\n",
"print(\" Reward shaping: tool_discipline_reward() — inspect before act\")\n"
]
},
{
"cell_type": "markdown",
"id": "7642e8ea",
"metadata": {
"papermill": {
"duration": 0.031579,
"end_time": "2026-06-28T01:04:48.864614+00:00",
"exception": false,
"start_time": "2026-06-28T01:04:48.833035+00:00",
"status": "completed"
},
"tags": []
},
"source": [
"# @title Step 5 — Create GRPO Reward Functions\n",
"\n",
"These reward functions are the heart of GRPO training. They define what \"good\" behavior looks like:\n",
"\n",
"1. **Correctness** (50%): Does the code pass all tests?\n",
"2. **Tool Discipline** (30%): Did the model inspect before writing? (Snorkel AI insight)\n",
"3. **Verification** (20%): Did the model run tests/linter after writing?\n",
"\n",
"The key innovation: we don't just reward correct code — we reward the *process* of\n",
"writing correct code. This is what makes small models competitive with large ones.\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "b00a1456",
"metadata": {
"execution": {
"iopub.execute_input": "2026-06-28T01:04:48.929690Z",
"iopub.status.busy": "2026-06-28T01:04:48.929374Z",
"iopub.status.idle": "2026-06-28T01:04:48.944897Z",
"shell.execute_reply": "2026-06-28T01:04:48.943902Z"
},
"papermill": {
"duration": 0.050023,
"end_time": "2026-06-28T01:04:48.946383+00:00",
"exception": false,
"start_time": "2026-06-28T01:04:48.896360+00:00",
"status": "completed"
},
"tags": []
},
"outputs": [],
"source": [
"import numpy as np\n",
"from typing import List, Dict, Any\n",
"\n",
"# ── Individual Reward Functions ─────────────────────────────────\n",
"\n",
"def reward_correctness(env_result: Dict) -> float:\n",
" \"\"\"Primary reward: Does the code pass all tests?\n",
" \n",
" This is the ultimate metric — can the model write working code?\n",
" Binary reward: 1.0 if all tests pass, 0.0 otherwise.\n",
" \"\"\"\n",
" if env_result.get(\"tool\") == \"run_tests\":\n",
" return 1.0 if env_result[\"passed\"] else 0.0\n",
" return 0.0\n",
"\n",
"\n",
"def reward_tool_discipline(tool_history: List[Dict]) -> float:\n",
" \"\"\"Reward for inspect-before-acting behavior.\n",
" \n",
" This is the Snorkel AI insight: tool discipline beats raw reasoning.\n",
" 4B models with tool discipline beat 235B models without it.\n",
" \n",
" Scoring:\n",
" - Each inspection before first write: +0.25 (max 1.0)\n",
" - No inspections = 0.0\n",
" - No code written = small penalty (0.1)\n",
" \"\"\"\n",
" if not tool_history:\n",
" return 0.0\n",
" \n",
" # Find first write action\n",
" first_write = None\n",
" for i, h in enumerate(tool_history):\n",
" if h[\"tool\"] == \"write_file\":\n",
" first_write = i\n",
" break\n",
" \n",
" if first_write is None:\n",
" return 0.1 # No code written = small penalty\n",
" \n",
" # Check actions before first write\n",
" actions_before = tool_history[:first_write]\n",
" inspection_count = sum(\n",
" 1 for h in actions_before \n",
" if h[\"tool\"] in (\"read_file\", \"inspect_error\", \"search_code\", \"check_linter\")\n",
" )\n",
" \n",
" reward = min(inspection_count * 0.25, 1.0)\n",
" return reward\n",
"\n",
"\n",
"def reward_verification(tool_history: List[Dict]) -> float:\n",
" \"\"\"Reward for running tests/linter AFTER writing code.\n",
" \n",
" A good coding agent doesn't just write code and ship it —\n",
" it verifies the code works before declaring done.\n",
" \n",
" Scoring:\n",
" - Ran tests after last write: +0.5\n",
" - Ran linter after last write: +0.3 (bonus, included in 0.5)\n",
" - No verification = 0.0\n",
" \"\"\"\n",
" if not tool_history:\n",
" return 0.0\n",
" \n",
" # Find last write action\n",
" last_write = None\n",
" for i in range(len(tool_history) - 1, -1, -1):\n",
" if tool_history[i][\"tool\"] == \"write_file\":\n",
" last_write = i\n",
" break\n",
" \n",
" if last_write is None:\n",
" return 0.0\n",
" \n",
" # Check if verification happened after writing\n",
" actions_after = tool_history[last_write + 1:]\n",
" verified = any(\n",
" h[\"tool\"] in (\"run_tests\", \"check_linter\", \"inspect_error\") \n",
" for h in actions_after\n",
" )\n",
" return 0.5 if verified else 0.0\n",
"\n",
"\n",
"# ── Combined Reward (weighted) ──────────────────────────────────\n",
"\n",
"def combined_reward(code_passed: bool, tool_history: List[Dict]) -> float:\n",
" \"\"\"Combined reward function for GRPO training.\n",
" \n",
" Weighted combination:\n",
" - Code correctness (passes tests): 50%\n",
" - Tool discipline (inspect before act): 30%\n",
" - Verification (test after write): 20%\n",
" \n",
" This weighting ensures the model learns BOTH:\n",
" 1. How to write correct code (correctness)\n",
" 2. HOW to write correct code (discipline + verification)\n",
" \"\"\"\n",
" r_correct = 1.0 if code_passed else 0.0\n",
" r_discipline = reward_tool_discipline(tool_history)\n",
" r_verify = reward_verification(tool_history)\n",
" \n",
" return 0.5 * r_correct + 0.3 * r_discipline + 0.2 * r_verify\n",
"\n",
"\n",
"# ── Reward function wrappers for TRL's GRPOTrainer ─────────────\n",
"# TRL expects reward functions that take (prompts, completions, **kwargs)\n",
"# and return a list of float rewards.\n",
"\n",
"def correctness_reward_func(prompts, completions, **kwargs) -> List[float]:\n",
" \"\"\"TRL-compatible reward function for code correctness.\n",
" Uses test execution results passed via kwargs.\n",
" \"\"\"\n",
" test_results = kwargs.get(\"test_results\", [None] * len(completions))\n",
" rewards = []\n",
" for result in test_results:\n",
" if result is not None and result.get(\"passed\"):\n",
" rewards.append(1.0)\n",
" else:\n",
" rewards.append(0.0)\n",
" return rewards\n",
"\n",
"\n",
"def discipline_reward_func(prompts, completions, **kwargs) -> List[float]:\n",
" \"\"\"TRL-compatible reward function for tool discipline.\"\"\"\n",
" tool_histories = kwargs.get(\"tool_histories\", [[] for _ in completions])\n",
" return [reward_tool_discipline(h) for h in tool_histories]\n",
"\n",
"\n",
"def verification_reward_func(prompts, completions, **kwargs) -> List[float]:\n",
" \"\"\"TRL-compatible reward function for verification.\"\"\"\n",
" tool_histories = kwargs.get(\"tool_histories\", [[] for _ in completions])\n",
" return [reward_verification(h) for h in tool_histories]\n",
"\n",
"\n",
"# ── Test reward functions ────────────────────────────────────────\n",
"print(\"🧪 Testing reward functions...\")\n",
"\n",
"# Scenario 1: Model reads then writes (good discipline)\n",
"good_history = [\n",
" {\"tool\": \"read_file\", \"path\": \"main.py\", \"success\": True},\n",
" {\"tool\": \"search_code\", \"pattern\": \"def process\", \"matches\": 3},\n",
" {\"tool\": \"write_file\", \"path\": \"main.py\", \"success\": True},\n",
" {\"tool\": \"run_tests\", \"passed\": True},\n",
"]\n",
"r = combined_reward(True, good_history)\n",
"print(f\" Good discipline + correct: reward = {r:.2f}\")\n",
"\n",
"# Scenario 2: Model just writes (bad discipline)\n",
"bad_history = [\n",
" {\"tool\": \"write_file\", \"path\": \"main.py\", \"success\": True},\n",
" {\"tool\": \"run_tests\", \"passed\": True},\n",
"]\n",
"r = combined_reward(True, bad_history)\n",
"print(f\" Bad discipline + correct: reward = {r:.2f}\")\n",
"\n",
"# Scenario 3: Good discipline but wrong code\n",
"r = combined_reward(False, good_history)\n",
"print(f\" Good discipline + incorrect: reward = {r:.2f}\")\n",
"\n",
"# Scenario 4: Bad discipline + wrong code + no verification\n",
"worst_history = [\n",
" {\"tool\": \"write_file\", \"path\": \"main.py\", \"success\": True},\n",
"]\n",
"r = combined_reward(False, worst_history)\n",
"print(f\" Bad discipline + incorrect: reward = {r:.2f}\")\n",
"\n",
"print(\"\\n✅ Reward functions ready!\")\n",
"print(\" Weights: correctness=50%, discipline=30%, verification=20%\")\n"
]
},
{
"cell_type": "markdown",
"id": "aa30e3f5",
"metadata": {
"papermill": {
"duration": 0.031301,
"end_time": "2026-06-28T01:04:49.008670+00:00",
"exception": false,
"start_time": "2026-06-28T01:04:48.977369+00:00",
"status": "completed"
},
"tags": []
},
"source": [
"# @title Step 6 — Prepare training data for GRPO\n",
"\n",
"GRPO needs problems with:\n",
"1. A problem statement (prompt)\n",
"2. A way to verify solutions (tests)\n",
"3. Reference code (for SFT warmup)\n",
"\n",
"We load from multiple sources, same as v3 but adapted for GRPO format.\n",
"Each example includes tool-use format training data in the THINK→INSPECT→ACT→VERIFY pattern.\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "f96592f0",
"metadata": {
"execution": {
"iopub.execute_input": "2026-06-28T01:04:49.072249Z",
"iopub.status.busy": "2026-06-28T01:04:49.071643Z",
"iopub.status.idle": "2026-06-28T01:09:34.869276Z",
"shell.execute_reply": "2026-06-28T01:09:34.868452Z"
},
"papermill": {
"duration": 285.865561,
"end_time": "2026-06-28T01:09:34.904975+00:00",
"exception": false,
"start_time": "2026-06-28T01:04:49.039414+00:00",
"status": "completed"
},
"tags": []
},
"outputs": [],
"source": [
"import os, gc, json, random, hashlib, shutil\n",
"from datasets import load_dataset, Dataset\n",
"from pathlib import Path\n",
"\n",
"# ─── DISK-SAFE KAGGLE CONFIG ─────────────────────────────────────────────\n",
"# Kaggle gives ~60 GB total disk. The HF datasets cache defaults to\n",
"# /root/.cache/huggingface/ (on that same 60 GB disk), so loading\n",
"# newfacade/LeetCodeDataset (50k+ problems) + WaltonFuture/agentic-sft-new\n",
"# in full will blow the disk before you ever get to training.\n",
"#\n",
"# Fix:\n",
"# 1) Redirect the HF cache to /kaggle/temp/hf_cache (scratch disk,\n",
"# does NOT count toward your 20 GB committed-output cap)\n",
"# 2) Use streaming=True for the two huge datasets (LeetCode, agentic)\n",
"# — rows are yielded one at a time and NEVER cached to disk\n",
"# 3) Use split=\"train[:N]\" slicing for medium datasets (MBPP, SWE-bench)\n",
"# 4) gc.collect() + remove cached arrow files between sources\n",
"#\n",
"# All four together keep peak disk usage under ~5 GB for this cell.\n",
"\n",
"os.environ[\"HF_DATASETS_CACHE\"] = \"/kaggle/temp/hf_cache/datasets\"\n",
"os.environ[\"HF_HOME\"] = \"/kaggle/temp/hf_cache\"\n",
"os.environ[\"HF_HUB_CACHE\"] = \"/kaggle/temp/hf_cache/hub\"\n",
"os.makedirs(\"/kaggle/temp/hf_cache/datasets\", exist_ok=True)\n",
"os.makedirs(\"/kaggle/temp/hf_cache/hub\", exist_ok=True)\n",
"\n",
"# Per-source caps — tune down if you still see disk pressure.\n",
"MAX_HUMANEVAL = 164 # entire dataset (tiny)\n",
"MAX_MBPP = 500 # slice of 974\n",
"MAX_SWEBENCH = 300 # slice of ~500\n",
"MAX_LEETCODE = 500 # streaming cap (full dataset is huge)\n",
"MAX_AGENTIC = 500 # streaming cap (full dataset is huge)\n",
"\n",
"random.seed(42)\n",
"\n",
"def _disk_usage_gb(path):\n",
" \"\"\"Return disk usage of `path` in GB (best-effort).\"\"\"\n",
" try:\n",
" total = 0\n",
" for root, _, files in os.walk(path):\n",
" for f in files:\n",
" try:\n",
" total += os.path.getsize(os.path.join(root, f))\n",
" except OSError:\n",
" pass\n",
" return total / 1e9\n",
" except Exception:\n",
" return -1\n",
"\n",
"def cleanup_after_load(dataset_name):\n",
" \"\"\"Free Python memory + remove the HF cache for this dataset.\"\"\"\n",
" gc.collect()\n",
" cache_root = \"/kaggle/temp/hf_cache/datasets\"\n",
" # Dataset cache dirs are named like ___\n",
" safe_token = dataset_name.replace(\"/\", \"___\").lower()\n",
" for d in os.listdir(cache_root):\n",
" if safe_token in d.lower() or dataset_name.split(\"/\")[-1].lower() in d.lower():\n",
" shutil.rmtree(os.path.join(cache_root, d), ignore_errors=True)\n",
" print(f\" [disk] cache cleared for {dataset_name}, \"\n",
" f\"hf_cache size now {_disk_usage_gb('/kaggle/temp/hf_cache'):.2f} GB\")\n",
"\n",
"# ── System prompt (v4 — SGS + GRPO + Tool Discipline) ──────────\n",
"SYSTEM_V4 = \"\"\"You are TIMPS-Coder v4, an elite coding agent built by Sandeep Reddy (TIMPS).\n",
"\n",
"You are trained with Self-Guided Self-Play (SGS) + Group Relative Policy Optimization (GRPO) + Tool Discipline.\n",
"\n",
"Specializations:\n",
"- Real GitHub issue resolution with precise patches\n",
"- Agentic code editing: multi-step reasoning + tool use\n",
"- Repository navigation and root-cause analysis\n",
"- Competitive algorithm problem solving\n",
"- Bug diagnosis and systematic repair\n",
"\n",
"For every task, follow this protocol:\n",
"1. THINK — Analyze the problem and plan your approach\n",
"2. INSPECT — Use tools (read_file, search_code, inspect_error) to understand the codebase\n",
"3. ACT — Write or edit code using write_file\n",
"4. VERIFY — Run tests (run_tests) and linters (check_linter) to confirm\n",
"\n",
"Available tools: read_file, write_file, run_tests, check_linter, inspect_error, search_code\n",
"\n",
"ALWAYS inspect before acting. Read the code, understand the error, THEN write your fix.\"\"\"\n",
"\n",
"# ── Quality filter ──────────────────────────────────────────────\n",
"CODE_SIGNALS = [\n",
" \"```python\", \"```javascript\", \"```java\", \"```typescript\", \"```go\",\n",
" \"```rust\", \"```cpp\", \"```diff\", \"```bash\",\n",
" \"def \", \"class \", \"function \", \"const \", \"import \",\n",
" \"return \", \"if (\", \"patch\", \"--- a/\", \"+++ b/\",\n",
"]\n",
"NON_CODE = [\n",
" \"paternal grandmother\", \"born in\", \"wikipedia\",\n",
" \"politician\", \"biography\", \"\", \"browsing-agent\",\n",
" \"nationality\", \"married to\",\n",
"]\n",
"\n",
"def is_coding(text: str) -> bool:\n",
" t = text[:3000]\n",
" if any(s.lower() in t.lower() for s in NON_CODE):\n",
" return False\n",
" return any(s in t for s in CODE_SIGNALS)\n",
"\n",
"def safe_load(name, split=\"train\", streaming=False, **kw):\n",
" try:\n",
" return load_dataset(name, split=split, streaming=streaming, **kw)\n",
" except Exception as e:\n",
" print(f\" ⚠️ {name}: {e}\")\n",
" return None\n",
"\n",
"# ── ChatML formatter (Qwen2.5 uses ChatML) ─────────────────────\n",
"def fmt_grpo(instruction, response):\n",
" \"\"\"Format for GRPO training — prompt only, model generates completion.\"\"\"\n",
" return (\n",
" f\"<|im_start|>system\\n{SYSTEM_V4}<|im_end|>\\n\"\n",
" f\"<|im_start|>user\\n{instruction.strip()}<|im_end|>\\n\"\n",
" f\"<|im_start|>assistant\\n{response.strip()}<|im_end|>\"\n",
" )\n",
"\n",
"def fmt_sft(instruction, response):\n",
" \"\"\"Format for SFT warmup — full text for supervised training.\"\"\"\n",
" return fmt_grpo(instruction, response)\n",
"\n",
"# ── GRPO Dataset format ─────────────────────────────────────────\n",
"sft_examples = [] # For SFT warmup\n",
"grpo_problems = [] # For GRPO training\n",
"\n",
"print(f\"[disk] starting hf_cache size: \"\n",
" f\"{_disk_usage_gb('/kaggle/temp/hf_cache'):.2f} GB\")\n",
"\n",
"# ── [1] HumanEval (164 problems with test cases) ───────────────\n",
"print(\"[1/5] Loading HumanEval...\")\n",
"ds = safe_load(\"openai/openai_humaneval\", split=\"test\")\n",
"humaneval_count = 0\n",
"if ds:\n",
" for row in ds:\n",
" prompt = (row.get(\"prompt\") or \"\").strip()\n",
" test = row.get(\"test\", \"\")\n",
" entry_point = row.get(\"entry_point\", \"\")\n",
" canonical = row.get(\"canonical_solution\", \"\")\n",
"\n",
" if not prompt or not test:\n",
" continue\n",
"\n",
" problem = {\n",
" \"prompt\": f\"Solve this coding problem. Write a Python function.\\n\\n{prompt}\",\n",
" \"test_cases\": test,\n",
" \"entry_point\": entry_point,\n",
" \"reference\": canonical,\n",
" \"difficulty\": \"easy\",\n",
" \"category\": \"algorithm\",\n",
" \"source\": \"humaneval\",\n",
" }\n",
" grpo_problems.append(problem)\n",
"\n",
" instruction = f\"Solve this coding problem:\\n\\n{prompt}\"\n",
" response = (\n",
" f\"**THINK:**\\nLet me analyze this problem step by step.\\n\\n\"\n",
" f\"**ACT:**\\n```python\\n{canonical}\\n```\\n\\n\"\n",
" f\"**VERIFY:**\\nThe solution handles the required cases.\"\n",
" )\n",
" sft_examples.append({\"text\": fmt_sft(instruction, response)})\n",
" humaneval_count += 1\n",
"\n",
" if humaneval_count >= MAX_HUMANEVAL:\n",
" break\n",
"\n",
" print(f\" ✓ {humaneval_count} from HumanEval\")\n",
"del ds\n",
"cleanup_after_load(\"openai/openai_humaneval\")\n",
"\n",
"# ── [2] MBPP (sliced to first MAX_MBPP rows) ───────────────────\n",
"print(f\"[2/5] Loading MBPP (first {MAX_MBPP})...\")\n",
"ds = safe_load(\"google-research-datasets/mbpp\", split=f\"train[:{MAX_MBPP}]\")\n",
"mbpp_count = 0\n",
"if ds:\n",
" for row in ds:\n",
" text = (row.get(\"text\") or row.get(\"prompt\") or \"\").strip()\n",
" code = (row.get(\"code\") or \"\").strip()\n",
" test_list = row.get(\"test_list\", [])\n",
"\n",
" if not text or not code:\n",
" continue\n",
"\n",
" problem = {\n",
" \"prompt\": f\"Solve this coding problem:\\n\\n{text}\",\n",
" \"test_cases\": \"\\n\".join(test_list) if test_list else \"\",\n",
" \"reference\": code,\n",
" \"difficulty\": \"easy\",\n",
" \"category\": \"algorithm\",\n",
" \"source\": \"mbpp\",\n",
" }\n",
" grpo_problems.append(problem)\n",
"\n",
" instruction = f\"Solve this coding problem:\\n\\n{text}\"\n",
" response = (\n",
" f\"**THINK:**\\nAnalyzing the requirements.\\n\\n\"\n",
" f\"**ACT:**\\n```python\\n{code[:500]}\\n```\\n\\n\"\n",
" f\"**VERIFY:**\\nSolution passes the given test cases.\"\n",
" )\n",
" sft_examples.append({\"text\": fmt_sft(instruction, response)})\n",
" mbpp_count += 1\n",
"\n",
" print(f\" ✓ {mbpp_count} from MBPP\")\n",
"del ds\n",
"cleanup_after_load(\"google-research-datasets/mbpp\")\n",
"\n",
"# ── [3] SWE-bench Verified (sliced to first MAX_SWEBENCH) ──────\n",
"print(f\"[3/5] Loading SWE-bench Verified (first {MAX_SWEBENCH})...\")\n",
"ds = safe_load(\"princeton-nlp/SWE-bench_Verified\", split=f\"test[:{MAX_SWEBENCH}]\")\n",
"if ds is None:\n",
" ds = safe_load(\"SWE-bench/SWE-bench_Verified\", split=f\"test[:{MAX_SWEBENCH}]\")\n",
"swe_count = 0\n",
"if ds:\n",
" for row in ds:\n",
" problem = (row.get(\"problem_statement\") or \"\").strip()\n",
" patch = (row.get(\"patch\") or \"\").strip()\n",
" repo = row.get(\"repo\", \"unknown\")\n",
" if not problem or not patch or len(patch) < 20:\n",
" continue\n",
"\n",
" instruction = f\"**Repo:** `{repo}`\\n\\n**Issue:**\\n{problem[:800]}\"\n",
" response = (\n",
" f\"**THINK:**\\nAnalyzing root cause in `{repo}`.\\n\\n\"\n",
" f\"**INSPECT:**\\nread_file('{repo.split('/')[-1]}/src/main.py')\\n\\n\"\n",
" f\"**ACT — Patch:**\\n```diff\\n{patch[:1800]}\\n```\\n\\n\"\n",
" f\"**VERIFY:**\\nMinimal targeted patch. Run `pytest` to confirm no regressions.\"\n",
" )\n",
" if is_coding(response):\n",
" sft_examples.append({\"text\": fmt_sft(instruction, response)})\n",
" grpo_problems.append({\n",
" \"prompt\": instruction,\n",
" \"test_cases\": \"\",\n",
" \"reference\": patch,\n",
" \"difficulty\": \"hard\",\n",
" \"category\": \"swe\",\n",
" \"source\": \"swebench\",\n",
" })\n",
" swe_count += 1\n",
"\n",
" print(f\" ✓ {swe_count} from SWE-bench\")\n",
"del ds\n",
"cleanup_after_load(\"princeton-nlp/SWE-bench_Verified\")\n",
"\n",
"# ── [4] LeetCode — STREAMING (full dataset is huge) ────────────\n",
"print(f\"[4/5] Loading LeetCode (streaming, cap {MAX_LEETCODE})...\")\n",
"ds = safe_load(\"newfacade/LeetCodeDataset\", split=\"train\", streaming=True)\n",
"leetcode_count = 0\n",
"if ds:\n",
" for row in ds:\n",
" title = (row.get(\"task_id\") or row.get(\"title\") or \"Problem\").strip()\n",
" desc = (row.get(\"query\") or row.get(\"problem_description\") or\n",
" row.get(\"description\") or row.get(\"content\") or \"\").strip()\n",
" sol = (row.get(\"response\") or row.get(\"solution\") or\n",
" row.get(\"python_solution\") or \"\").strip()\n",
" diff = row.get(\"difficulty\", \"Medium\")\n",
"\n",
" if not desc or not sol or len(sol) < 30:\n",
" continue\n",
"\n",
" instruction = f\"**{title}** ({diff})\\n\\n{desc[:600]}\"\n",
" response = (\n",
" f\"**THINK:**\\nBreaking down the problem.\\n\\n\"\n",
" f\"**ACT:**\\n```python\\n{sol[:800]}\\n```\\n\\n\"\n",
" f\"**VERIFY:**\\nTest with edge cases.\"\n",
" )\n",
" if is_coding(response):\n",
" sft_examples.append({\"text\": fmt_sft(instruction, response)})\n",
" grpo_problems.append({\n",
" \"prompt\": instruction,\n",
" \"test_cases\": \"\",\n",
" \"reference\": sol,\n",
" \"difficulty\": diff.lower() if isinstance(diff, str) else \"medium\",\n",
" \"category\": \"algorithm\",\n",
" \"source\": \"leetcode\",\n",
" })\n",
" leetcode_count += 1\n",
"\n",
" if leetcode_count >= MAX_LEETCODE:\n",
" break\n",
"\n",
" print(f\" ✓ {leetcode_count} from LeetCode (streamed)\")\n",
"del ds\n",
"# Streaming datasets don't write to the cache, but be safe:\n",
"cleanup_after_load(\"newfacade/LeetCodeDataset\")\n",
"\n",
"# ── [5] Agentic SFT — STREAMING ────────────────────────────────\n",
"print(f\"[5/5] Loading agentic SFT (streaming, cap {MAX_AGENTIC})...\")\n",
"ds = safe_load(\"WaltonFuture/agentic-sft-new\", split=\"train\", streaming=True)\n",
"agentic_count = 0\n",
"if ds:\n",
" for row in ds:\n",
" convs = row.get(\"conversations\") or row.get(\"messages\") or []\n",
" parts = [f\"<|im_start|>system\\n{SYSTEM_V4}<|im_end|>\"]\n",
" ok = True\n",
" for turn in convs:\n",
" if not isinstance(turn, dict):\n",
" ok = False; break\n",
" role = (turn.get(\"from\") or turn.get(\"role\") or \"\").lower()\n",
" content = (turn.get(\"value\") or turn.get(\"content\") or \"\").strip()\n",
" if not content:\n",
" continue\n",
" if role in (\"gpt\", \"assistant\"):\n",
" if not is_coding(content):\n",
" ok = False; break\n",
" parts.append(f\"<|im_start|>assistant\\n{content[:900]}<|im_end|>\")\n",
" else:\n",
" parts.append(f\"<|im_start|>user\\n{content[:700]}<|im_end|>\")\n",
" if ok and len(parts) >= 3:\n",
" text = \"\\n\".join(parts)\n",
" if 200 < len(text) < 6500:\n",
" sft_examples.append({\"text\": text})\n",
" agentic_count += 1\n",
"\n",
" if agentic_count >= MAX_AGENTIC:\n",
" break\n",
"\n",
" print(f\" ✓ {agentic_count} from agentic SFT (streamed)\")\n",
"del ds\n",
"cleanup_after_load(\"WaltonFuture/agentic-sft-new\")\n",
"\n",
"# ── Deduplicate ─────────────────────────────────────────────────\n",
"print(\"\\nDeduplicating...\")\n",
"seen = set()\n",
"unique_sft = []\n",
"for ex in sft_examples:\n",
" h = hashlib.md5(ex[\"text\"].encode()).hexdigest()\n",
" if h not in seen:\n",
" seen.add(h)\n",
" unique_sft.append(ex)\n",
"\n",
"# ── Split ───────────────────────────────────────────────────────\n",
"random.shuffle(unique_sft)\n",
"split = int(0.95 * len(unique_sft))\n",
"train_sft = Dataset.from_list(unique_sft[:split])\n",
"valid_sft = Dataset.from_list(unique_sft[split:])\n",
"\n",
"# GRPO dataset\n",
"random.shuffle(grpo_problems)\n",
"grpo_split = int(0.9 * len(grpo_problems))\n",
"grpo_train = Dataset.from_list(grpo_problems[:grpo_split])\n",
"grpo_valid = Dataset.from_list(grpo_problems[grpo_split:])\n",
"\n",
"# Free the raw lists — they're now in HF Dataset objects\n",
"# Save grpo_problems to disk before deleting from memory.\n",
"# The SGS cell (after DPO) needs to filter it by difficulty -- if we just\n",
"# del it here, that cell crashes with NameError: name 'grpo_problems' is not defined.\n",
"import json as _json\n",
"_gp_path = f\"{WORK_DIR}/grpo_problems.json\"\n",
"with open(_gp_path, 'w') as _f:\n",
" _json.dump(grpo_problems, _f)\n",
"print(f\" Saved grpo_problems ({len(grpo_problems)} items) to {_gp_path}\")\n",
"\n",
"del sft_examples, grpo_problems, unique_sft\n",
"gc.collect()\n",
"\n",
"print(f\"\\n{'='*50}\")\n",
"print(f\" Dataset Summary\")\n",
"print(f\"{'='*50}\")\n",
"print(f\" SFT Training Examples : {len(train_sft):,}\")\n",
"print(f\" SFT Validation : {len(valid_sft):,}\")\n",
"print(f\" GRPO Problems (train) : {len(grpo_train):,}\")\n",
"print(f\" GRPO Problems (valid) : {len(grpo_valid):,}\")\n",
"print(f\" ✅ Ready for training\")\n",
"print(f\"{'='*50}\")\n",
"print(f\"\\n[disk] final hf_cache size: \"\n",
" f\"{_disk_usage_gb('/kaggle/temp/hf_cache'):.2f} GB\")\n",
"print(f\"[disk] /kaggle/working size: \"\n",
" f\"{_disk_usage_gb('/kaggle/working'):.2f} GB\")\n"
]
},
{
"cell_type": "markdown",
"id": "8cd8a197",
"metadata": {
"papermill": {
"duration": 0.031798,
"end_time": "2026-06-28T01:09:34.969535+00:00",
"exception": false,
"start_time": "2026-06-28T01:09:34.937737+00:00",
"status": "completed"
},
"tags": []
},
"source": [
"---\n",
"# PHASE 3: STEP 2 — TRAIN WITH GRPO\n",
"\n",
"This phase loads the 7B model, applies LoRA, does an SFT warmup,\n",
"then runs GRPO training with our tool-discipline reward functions.\n",
"\n",
"**Training order matters:**\n",
"1. SFT warmup → teaches the model the tool-use format\n",
"2. GRPO → reinforces good behavior with RL rewards\n",
"3. (Later: DPO → aligns preferences)\n",
"\n",
"**Why GRPO instead of PPO?**\n",
"- No critic model needed (saves 50% compute)\n",
"- Group-relative normalization (more stable)\n",
"- Same method used by DeepSeek-R1\n",
"\n",
"**Kaggle note:** On T4 (15 GB) we use 4-bit QLoRA + gradient checkpointing to fit a 7B model\n",
"with 4096-token context and 4 GRPO generations per prompt.\n"
]
},
{
"cell_type": "markdown",
"id": "2fcc0b9a",
"metadata": {
"papermill": {
"duration": 0.032751,
"end_time": "2026-06-28T01:09:35.035550+00:00",
"exception": false,
"start_time": "2026-06-28T01:09:35.002799+00:00",
"status": "completed"
},
"tags": []
},
"source": [
"# @title Step 7 — Load Qwen2.5-Coder-7B-Instruct with Unsloth\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "6db3ec16",
"metadata": {
"execution": {
"iopub.execute_input": "2026-06-28T01:09:35.101812Z",
"iopub.status.busy": "2026-06-28T01:09:35.101532Z",
"iopub.status.idle": "2026-06-28T01:10:06.862820Z",
"shell.execute_reply": "2026-06-28T01:10:06.861781Z"
},
"papermill": {
"duration": 31.828737,
"end_time": "2026-06-28T01:10:06.897050+00:00",
"exception": false,
"start_time": "2026-06-28T01:09:35.068313+00:00",
"status": "completed"
},
"tags": []
},
"outputs": [],
"source": [
"# Force quiet installations and ignore dependency conflicts with pre-installed Kaggle packages\n",
"!pip install -q --no-warn-conflicts unsloth_zoo\n",
"!pip install -q --no-warn-conflicts \"unsloth @ git+https://github.com/unslothai/unsloth.git\"\n",
"print(\"✅ Environment setup complete without logging clutter!\")"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "8e83eeb5",
"metadata": {
"execution": {
"iopub.execute_input": "2026-06-28T01:10:06.963868Z",
"iopub.status.busy": "2026-06-28T01:10:06.963587Z",
"iopub.status.idle": "2026-06-28T01:11:08.953785Z",
"shell.execute_reply": "2026-06-28T01:11:08.952729Z"
},
"papermill": {
"duration": 62.065493,
"end_time": "2026-06-28T01:11:08.994657+00:00",
"exception": false,
"start_time": "2026-06-28T01:10:06.929164+00:00",
"status": "completed"
},
"tags": []
},
"outputs": [],
"source": [
"from unsloth import FastLanguageModel\n",
"import torch\n",
"\n",
"# -- Config --\n",
"BASE_MODEL = \"Qwen/Qwen2.5-Coder-7B-Instruct\"\n",
"HF_USERNAME = \"sandeeprdy1729\"\n",
"HF_REPO = f\"{HF_USERNAME}/TIMPS-Coder-7B\"\n",
"MAX_SEQ_LEN = BUDGET_MAX_SEQ_LEN # auto-scaled by GPU tier (2048 on T4, 4096 on A100)\n",
"\n",
"# ===========================================================================\n",
"# LORA_RANK PINNED TO 64 -- DO NOT let this auto-scale by GPU tier anymore.\n",
"# ===========================================================================\n",
"# Your SFT checkpoint (checkpoint-750) was saved with rank=64. If a future\n",
"# session auto-detects a lower GPU tier and BUDGET_LORA_RANK comes back as 32,\n",
"# model.load_adapter() will crash with a shape mismatch (64 vs 32 in every\n",
"# LoRA layer) -- this is exactly the RuntimeError you hit. Pinning this value\n",
"# keeps every session's LoRA shape consistent with your existing checkpoints,\n",
"# regardless of which GPU tier gets detected. This costs a bit more VRAM than\n",
"# the auto-scaled rank=32 would on T4, but QLoRA 4-bit + gradient checkpointing\n",
"# still fits a 7B model at rank=64 on a 15GB T4.\n",
"LORA_RANK = 64 # pinned -- must match the rank used in your original SFT run\n",
"\n",
"if BUDGET_LORA_RANK != LORA_RANK:\n",
" print(f\"NOTE: GPU-tier auto-detect suggested LORA_RANK={BUDGET_LORA_RANK}, \"\n",
" f\"but it is pinned to {LORA_RANK} to match your existing checkpoints.\")\n",
"# ---------------\n",
"\n",
"print(f\"Loading {BASE_MODEL}...\")\n",
"print(f\" 7B model with 4-bit QLoRA — fits comfortably on T4 (15 GB)\")\n",
"print(f\" MAX_SEQ_LEN = {MAX_SEQ_LEN} (GPU_TIER={GPU_TIER})\")\n",
"\n",
"model, tokenizer = FastLanguageModel.from_pretrained(\n",
" model_name = BASE_MODEL,\n",
" max_seq_length = MAX_SEQ_LEN,\n",
" dtype = None, # auto-detect (bf16 on A100, fp16 on T4/P100)\n",
" load_in_4bit = True, # QLoRA — fits in T4 15GB\n",
")\n",
"\n",
"print(f\"Base model loaded\")\n",
"print(f\" Parameters: {sum(p.numel() for p in model.parameters()):,}\")\n",
"print(f\" Max seq length: {MAX_SEQ_LEN}\")\n",
"\n",
"# Set pad token if not set\n",
"if tokenizer.pad_token is None:\n",
" tokenizer.pad_token = tokenizer.eos_token\n"
]
},
{
"cell_type": "markdown",
"id": "cdd2eb3c",
"metadata": {
"papermill": {
"duration": 0.038275,
"end_time": "2026-06-28T01:11:09.071285+00:00",
"exception": false,
"start_time": "2026-06-28T01:11:09.033010+00:00",
"status": "completed"
},
"tags": []
},
"source": [
"# @title Step 8 — Apply LoRA for GRPO training (rank=64, RSLoRA)\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "e8bd4642",
"metadata": {
"execution": {
"iopub.execute_input": "2026-06-28T01:11:09.147084Z",
"iopub.status.busy": "2026-06-28T01:11:09.146073Z",
"iopub.status.idle": "2026-06-28T01:11:15.878028Z",
"shell.execute_reply": "2026-06-28T01:11:15.876888Z"
},
"papermill": {
"duration": 6.771193,
"end_time": "2026-06-28T01:11:15.880540+00:00",
"exception": false,
"start_time": "2026-06-28T01:11:09.109347+00:00",
"status": "completed"
},
"tags": []
},
"outputs": [],
"source": [
"# LORA_RANK is pinned to 64 in Cell 20 (no longer auto-scaled by GPU tier) so\n",
"# every session matches the rank used in your existing SFT/GRPO/DPO checkpoints.\n",
"# RSLoRA stays on -- better RL stability.\n",
"\n",
"model = FastLanguageModel.get_peft_model(\n",
" model,\n",
" r = LORA_RANK,\n",
" lora_alpha = LORA_RANK, # scale = rank (standard ratio)\n",
" lora_dropout = 0.05,\n",
" target_modules = [ # all linear layers in Qwen2.5\n",
" \"q_proj\", \"k_proj\", \"v_proj\", \"o_proj\",\n",
" \"gate_proj\", \"up_proj\", \"down_proj\",\n",
" ],\n",
" bias = \"none\",\n",
" use_gradient_checkpointing = \"unsloth\", # saves ~30% VRAM\n",
" random_state = 42,\n",
" use_rslora = True, # Rank-Stabilized LoRA — more stable for RL\n",
" loftq_config = None,\n",
")\n",
"\n",
"trainable = sum(p.numel() for p in model.parameters() if p.requires_grad)\n",
"total = sum(p.numel() for p in model.parameters())\n",
"print(f\"LoRA applied (rank={LORA_RANK})\")\n",
"print(f\" Trainable params: {trainable:,} ({100*trainable/total:.2f}%)\")\n",
"print(f\" Total params : {total:,}\")\n",
"print(f\" LoRA rank : {LORA_RANK}\")\n",
"print(f\" RSLoRA : enabled (more stable for GRPO)\")\n"
]
},
{
"cell_type": "markdown",
"id": "f0b468cd",
"metadata": {
"papermill": {
"duration": 0.035871,
"end_time": "2026-06-28T01:11:15.956746+00:00",
"exception": false,
"start_time": "2026-06-28T01:11:15.920875+00:00",
"status": "completed"
},
"tags": []
},
"source": [
"# Resume Point — Load Previous SFT Checkpoint (cross-session)\n",
"\n",
"If you already completed SFT in an earlier Kaggle session (e.g. 750/750 steps,\n",
"~11.5h), attach that session's Output as an Input to this notebook and set\n",
"`SFT_CHECKPOINT_PATH` below to skip retraining SFT and jump straight to GRPO.\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "ab535f87",
"metadata": {
"execution": {
"iopub.execute_input": "2026-06-28T01:11:16.034642Z",
"iopub.status.busy": "2026-06-28T01:11:16.033759Z",
"iopub.status.idle": "2026-06-28T01:11:20.717200Z",
"shell.execute_reply": "2026-06-28T01:11:20.716308Z"
},
"papermill": {
"duration": 4.722757,
"end_time": "2026-06-28T01:11:20.718901+00:00",
"exception": false,
"start_time": "2026-06-28T01:11:15.996144+00:00",
"status": "completed"
},
"tags": []
},
"outputs": [],
"source": [
"# ===========================================================================\n",
"# RESUME FROM PREVIOUS SFT RUN (cross-session checkpoint loading)\n",
"# ===========================================================================\n",
"# Your last Kaggle session finished SFT at 750/750 steps and the Output was\n",
"# saved. Kaggle wipes /kaggle/working between sessions, so this cell loads\n",
"# the trained LoRA adapter weights from wherever you attached that Output\n",
"# (Add Input -> Notebook Output Files, or a Dataset built from it).\n",
"#\n",
"# HOW TO USE:\n",
"# 1. Attach the old notebook's Output/Dataset to THIS session\n",
"# (Add Input button in the right sidebar).\n",
"# 2. Find the checkpoint path:\n",
"# !find /kaggle/input -maxdepth 6 -iname \"checkpoint-*\" -type d\n",
"# 3. Paste the matching path below (the highest checkpoint-N you have,\n",
"# e.g. checkpoint-750 if you saved at the final step, or whatever\n",
"# the highest save_steps multiple was).\n",
"# 4. Leave SFT_CHECKPOINT_PATH = None to train SFT from scratch instead.\n",
"\n",
"SFT_CHECKPOINT_PATH = \"/kaggle/input/notebooks/sandeepautomation/newnote/timps-coder-v4/sft-warmup/checkpoint-750\" # <-- e.g. \"/kaggle/input//timps-coder-v4/sft-warmup/checkpoint-750\"\n",
"\n",
"SFT_ALREADY_DONE = False\n",
"\n",
"if SFT_CHECKPOINT_PATH:\n",
" import os\n",
" if not os.path.isdir(SFT_CHECKPOINT_PATH):\n",
" raise FileNotFoundError(\n",
" f\"SFT_CHECKPOINT_PATH does not exist: {SFT_CHECKPOINT_PATH}\\n\"\n",
" f\"Run: !find /kaggle/input -maxdepth 6 -iname 'checkpoint-*' -type d\\n\"\n",
" f\"to locate the correct path after attaching your old Output as an input.\"\n",
" )\n",
" has_weights = (\n",
" os.path.isfile(f\"{SFT_CHECKPOINT_PATH}/adapter_model.safetensors\")\n",
" or os.path.isfile(f\"{SFT_CHECKPOINT_PATH}/adapter_model.bin\")\n",
" )\n",
" if not has_weights:\n",
" raise FileNotFoundError(\n",
" f\"No adapter weights found in {SFT_CHECKPOINT_PATH}. \"\n",
" f\"Expected adapter_model.safetensors (LoRA-only checkpoint, since \"\n",
" f\"SFT was run with save_only_model=True).\"\n",
" )\n",
"\n",
" print(f\"Loading SFT-trained LoRA adapter from: {SFT_CHECKPOINT_PATH}\")\n",
" # model already has a (freshly initialized, untrained) LoRA adapter applied\n",
" # by FastLanguageModel.get_peft_model() in the previous cell. We overwrite\n",
" # those weights with the trained ones from disk using PEFT's adapter loader.\n",
" model.load_adapter(SFT_CHECKPOINT_PATH, adapter_name=\"default\", is_trainable=True)\n",
"\n",
" trainable = sum(p.numel() for p in model.parameters() if p.requires_grad)\n",
" print(f\"Resumed SFT adapter loaded successfully.\")\n",
" print(f\" Trainable params: {trainable:,}\")\n",
" print(f\" SFT training will be SKIPPED -- proceeding straight to GRPO.\")\n",
" SFT_ALREADY_DONE = True\n",
"else:\n",
" print(\"SFT_CHECKPOINT_PATH not set -- SFT will train from scratch in the next cell.\")\n"
]
},
{
"cell_type": "markdown",
"id": "06746a44",
"metadata": {
"papermill": {
"duration": 0.033392,
"end_time": "2026-06-28T01:11:20.786827+00:00",
"exception": false,
"start_time": "2026-06-28T01:11:20.753435+00:00",
"status": "completed"
},
"tags": []
},
"source": [
"---\n",
"# ⚠️ FIX NOTICE — Read before running the SFT cell below\n",
"\n",
"## What broke\n",
"\n",
"The previous run crashed at checkpoint-250 with:\n",
"\n",
"```\n",
"PicklingError: Can't pickle :\n",
"it's not the same object as trl.trainer.sft_config.SFTConfig\n",
"```\n",
"\n",
"## Why\n",
"\n",
"The original SFT cell passed `transformers.TrainingArguments` to `trl.SFTTrainer`.\n",
"TRL internally converts that to `trl.SFTConfig`, but when `torch.save(self.args)`\n",
"runs at checkpoint time, the pickle lookup fails because Unsloth re-imports TRL\n",
"modules during its monkey-patching — breaking class identity.\n",
"\n",
"## The fix (already applied in the cell below)\n",
"\n",
"1. Use `trl.SFTConfig` directly (no conversion = no identity mismatch)\n",
"2. Use `processing_class=tokenizer` (modern TRL 0.12+ API; `tokenizer=` was removed)\n",
"3. Add `save_only_model=True` — skips saving optimizer/scheduler state, smaller checkpoints, avoids one pickle code path\n",
"4. Delete any leftover broken `sft-warmup/` directory before starting fresh\n",
"5. Same fix applied preemptively to the DPO cell (cell 31)\n",
"\n",
"## Action required\n",
"\n",
"If you have a half-written `checkpoint-250/` from the crashed run, the cell below\n",
"will automatically delete it before starting. You will lose the 4h of SFT progress\n",
"from the previous run — that's unavoidable because the checkpoint is corrupted.\n",
"\n",
"If you want to **resume from a known-good checkpoint** instead of restarting,\n",
"set `RESUME_FROM_CHECKPOINT = True` in the cell below and point it at a valid\n",
"checkpoint directory. (Default: False — start fresh.)\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "f6715a40",
"metadata": {
"execution": {
"iopub.execute_input": "2026-06-28T01:11:20.858138Z",
"iopub.status.busy": "2026-06-28T01:11:20.857660Z",
"iopub.status.idle": "2026-06-28T01:11:20.871198Z",
"shell.execute_reply": "2026-06-28T01:11:20.870482Z"
},
"papermill": {
"duration": 0.049861,
"end_time": "2026-06-28T01:11:20.872790+00:00",
"exception": false,
"start_time": "2026-06-28T01:11:20.822929+00:00",
"status": "completed"
},
"tags": []
},
"outputs": [],
"source": [
"import os, shutil, glob\n",
"from transformers import DataCollatorForSeq2Seq\n",
"from trl import SFTConfig, SFTTrainer # <-- SFTConfig from trl, NOT TrainingArguments from transformers\n",
"import math\n",
"\n",
"# ===========================================================================\n",
"# SKIP SFT ENTIRELY IF RESUMING FROM A PRIOR CHECKPOINT\n",
"# ===========================================================================\n",
"# SFT_ALREADY_DONE is set by the \"Resume Point\" cell above. If a checkpoint\n",
"# was loaded there, the model already has trained SFT weights -- running\n",
"# this cell again would waste the rest of your Kaggle session re-doing\n",
"# 11.5 hours of work for nothing.\n",
"if SFT_ALREADY_DONE:\n",
" print(\"=\" * 50)\n",
" print(\"SFT_ALREADY_DONE = True -- skipping SFT training.\")\n",
" print(\"Using the resumed adapter weights loaded from SFT_CHECKPOINT_PATH.\")\n",
" print(\"=\" * 50)\n",
"else:\n",
"\n",
" # ===========================================================================\n",
" # RESUME OPTION\n",
" # ===========================================================================\n",
" # Set to a path like f\"{OUTPUT_DIR}/sft-warmup/checkpoint-500\" to resume\n",
" # from a known-good checkpoint. Leave None to start fresh.\n",
" # (The checkpoint-250 from your previous run is CORRUPTED — do not resume\n",
" # from it. Let the cleanup below delete it.)\n",
" RESUME_FROM_CHECKPOINT = None\n",
"\n",
" # ===========================================================================\n",
" # CLEANUP — delete any broken / partial checkpoints from the previous run\n",
" # ===========================================================================\n",
" sft_output = f\"{OUTPUT_DIR}/sft-warmup\"\n",
" if os.path.isdir(sft_output):\n",
" print(f\"Cleaning up existing SFT output dir: {sft_output}\")\n",
" # Specifically remove checkpoint-250 if it's incomplete (no .safetensors)\n",
" for ckpt in sorted(glob.glob(f\"{sft_output}/checkpoint-*\")):\n",
" has_weights = (\n",
" glob.glob(f\"{ckpt}/*.safetensors\")\n",
" or glob.glob(f\"{ckpt}/pytorch_model.bin\")\n",
" )\n",
" if not has_weights:\n",
" print(f\" Removing corrupted checkpoint (no weights): {ckpt}\")\n",
" shutil.rmtree(ckpt, ignore_errors=True)\n",
" else:\n",
" print(f\" Keeping valid checkpoint: {ckpt}\")\n",
" # If resume is None and any checkpoints remain, wipe them all to start fresh\n",
" if RESUME_FROM_CHECKPOINT is None:\n",
" for ckpt in sorted(glob.glob(f\"{sft_output}/checkpoint-*\")):\n",
" print(f\" Removing (fresh start requested): {ckpt}\")\n",
" shutil.rmtree(ckpt, ignore_errors=True)\n",
" else:\n",
" os.makedirs(sft_output, exist_ok=True)\n",
"\n",
" # ===========================================================================\n",
" # SFT CONFIG — use SFTConfig from trl (NOT TrainingArguments)\n",
" # ===========================================================================\n",
" # Why: TRL's SFTTrainer auto-converts TrainingArguments -> SFTConfig,\n",
" # and that conversion breaks torch.save(self.args) at checkpoint time\n",
" # because Unsloth has re-imported TRL modules (class identity mismatch).\n",
" # Passing SFTConfig directly sidesteps the conversion entirely.\n",
"\n",
" free_vram = torch.cuda.get_device_properties(0).total_memory / 1e9\n",
" if free_vram > 35:\n",
" BATCH, GRAD_ACCUM = 2, 4\n",
" elif free_vram > 12:\n",
" # T4 (15 GB) — small batch + grad accumulation to fit\n",
" BATCH, GRAD_ACCUM = 1, 16\n",
" else:\n",
" BATCH, GRAD_ACCUM = 1, 32\n",
"\n",
" EFFECTIVE_BATCH = BATCH * GRAD_ACCUM\n",
"\n",
" sft_args = SFTConfig(\n",
" output_dir = sft_output,\n",
" max_steps = SFT_MAX_STEPS,\n",
" per_device_train_batch_size = BATCH,\n",
" gradient_accumulation_steps = GRAD_ACCUM,\n",
" warmup_steps = 50,\n",
" learning_rate = 2e-5,\n",
" lr_scheduler_type = \"cosine\",\n",
" optim = \"adamw_torch\",\n",
" weight_decay = 0.01,\n",
" fp16 = not torch.cuda.is_bf16_supported(),\n",
" bf16 = torch.cuda.is_bf16_supported(),\n",
" logging_steps = 25,\n",
" save_strategy = \"steps\",\n",
" save_steps = 250,\n",
" save_total_limit = 2,\n",
" save_only_model = True, # <-- skip optimizer state, avoids 1 pickle path\n",
" report_to = \"none\",\n",
" seed = 42,\n",
" remove_unused_columns = False,\n",
" gradient_checkpointing = True,\n",
" gradient_checkpointing_kwargs = {\"use_reentrant\": False},\n",
"\n",
" # SFTConfig-specific\n",
" max_length = MAX_SEQ_LEN, # renamed from max_seq_length in TRL 0.12+\n",
" dataset_text_field = \"text\", # column in train_sft that holds the formatted text\n",
" packing = False, # don't pack short examples (better for tool-use format)\n",
" # NOTE: `group_by_length=True` was removed — TRL's SFTConfig in this version\n",
" # does not accept it (it was a TrainingArguments arg that TRL dropped when\n",
" # subclassing). Training still works without it; you just lose the minor\n",
" # padding-efficiency optimization. The DataCollatorForSeq2Seq below already\n",
" # pads to multiple_of=8 dynamically, so the impact is negligible.\n",
" )\n",
"\n",
" collator = DataCollatorForSeq2Seq(\n",
" tokenizer,\n",
" model=model,\n",
" label_pad_token_id=-100,\n",
" pad_to_multiple_of=8,\n",
" )\n",
"\n",
" # Modern TRL API: processing_class=tokenizer (not tokenizer=)\n",
" sft_trainer = SFTTrainer(\n",
" model = model,\n",
" args = sft_args,\n",
" train_dataset = train_sft,\n",
" data_collator = collator,\n",
" processing_class = tokenizer,\n",
" )\n",
"\n",
" print(f\"SFT Warmup Config:\")\n",
" print(f\" Batch size : {BATCH} x grad_accum {GRAD_ACCUM} = {EFFECTIVE_BATCH}\")\n",
" print(f\" Max steps : {SFT_MAX_STEPS}\")\n",
" print(f\" Learning rate : 2e-5 -> cosine\")\n",
" print(f\" Train examples : {len(train_sft):,}\")\n",
" print(f\" Resume from : {RESUME_FROM_CHECKPOINT or '(fresh start)'}\")\n",
" print(f\" args class : {type(sft_args).__name__} (should be SFTConfig)\")\n",
" print()\n",
"\n",
" print(\"Starting SFT warmup (teaching tool-use format)...\")\n",
" print(\"=\" * 50)\n",
" try:\n",
" if RESUME_FROM_CHECKPOINT:\n",
" sft_stats = sft_trainer.train(resume_from_checkpoint=RESUME_FROM_CHECKPOINT)\n",
" else:\n",
" sft_stats = sft_trainer.train()\n",
" except Exception as e:\n",
" print(f\"SFT training failed: {type(e).__name__}: {e}\")\n",
" print(\"\\nFallback: try with save_strategy='no' to skip checkpointing entirely.\")\n",
" print(\"Edit this cell: set save_strategy='no', save_steps=99999, save_total_limit=0\")\n",
" raise\n",
"\n",
" print(\"=\" * 50)\n",
" print(f\"SFT Warmup complete!\")\n",
" print(f\" Train loss : {sft_stats.training_loss:.4f}\")\n",
" print(f\" Total steps : {sft_stats.global_step}\")\n",
" runtime_mins = sft_stats.metrics.get('train_runtime', 0) / 60\n",
" print(f\" Runtime : {runtime_mins:.1f} minutes\")\n",
" print(f\" Model now understands THINK -> INSPECT -> ACT -> VERIFY format\")\n"
]
},
{
"cell_type": "markdown",
"id": "8c245acd",
"metadata": {
"papermill": {
"duration": 0.03741,
"end_time": "2026-06-28T01:11:20.943491+00:00",
"exception": false,
"start_time": "2026-06-28T01:11:20.906081+00:00",
"status": "completed"
},
"tags": []
},
"source": [
"# @title Step 10 — GRPO Training (core RL training)\n",
"\n",
"This is the core training step. GRPO (Group Relative Policy Optimization) from DeepSeek-R1:\n",
"\n",
"1. For each prompt, generate N completions (the \"group\")\n",
"2. Score each completion using our reward functions\n",
"3. Normalize rewards within the group (that's the \"Group Relative\" part)\n",
"4. Update policy to prefer higher-reward completions\n",
"\n",
"**Key advantages over PPO:**\n",
"- No critic model needed (saves ~50% compute)\n",
"- More stable training (group normalization)\n",
"\n",
"**Kaggle T4 note:** GRPO generates 4 completions per prompt — this is the most VRAM-intensive\n",
"step. With 4-bit QLoRA + gradient checkpointing + max_completion_length=1024, we fit on T4.\n",
"If you hit OOM, reduce `NUM_GENERATIONS` to 2 below.\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "2ac0b7dd",
"metadata": {
"execution": {
"iopub.execute_input": "2026-06-28T01:11:21.097880Z",
"iopub.status.busy": "2026-06-28T01:11:21.097533Z",
"iopub.status.idle": "2026-06-28T01:11:22.129428Z",
"shell.execute_reply": "2026-06-28T01:11:22.128593Z"
},
"papermill": {
"duration": 1.153379,
"end_time": "2026-06-28T01:11:22.131062+00:00",
"exception": false,
"start_time": "2026-06-28T01:11:20.977683+00:00",
"status": "completed"
},
"tags": []
},
"outputs": [],
"source": [
"# ── OOM RECOVERY: free everything from SFT before starting GRPO ────────\n",
"# GRPO is the most VRAM-intensive step (generates N completions per prompt\n",
"# in parallel). On a 15 GB T4 there is NO headroom for leftovers from SFT.\n",
"# This cell:\n",
"# 1. Deletes the SFT trainer + its refs\n",
"# 2. Runs gc.collect() to release Python-side refs\n",
"# 3. Runs torch.cuda.empty_cache() to release PyTorch's reserved blocks\n",
"# 4. Prints nvidia-smi so you can confirm free VRAM before GRPO starts\n",
"\n",
"import gc, subprocess, torch\n",
"\n",
"# 1) Drop SFT trainer refs (variable was named sft_trainer in the previous cell)\n",
"try:\n",
" del sft_trainer\n",
" print('Deleted sft_trainer')\n",
"except NameError:\n",
" print('sft_trainer already gone (ok if you skipped SFT)')\n",
"\n",
"# 2) Drop SFT dataset refs we no longer need\n",
"for _name in ('train_sft', 'sft_args', 'collator'):\n",
" try:\n",
" globals().pop(_name, None)\n",
" except Exception:\n",
" pass\n",
"\n",
"# 3) Run collection + cache clear TWICE (once for Python, once for CUDA)\n",
"gc.collect()\n",
"torch.cuda.empty_cache()\n",
"gc.collect()\n",
"torch.cuda.empty_cache()\n",
"\n",
"# 4) Print current VRAM state\n",
"print('\\\\n=== VRAM state before GRPO ===')\n",
"print(subprocess.run(['nvidia-smi'], capture_output=True, text=True).stdout)\n",
"if torch.cuda.is_available():\n",
" free, total = torch.cuda.mem_get_info()\n",
" print(f'Free: {free/1e9:.2f} GiB / Total: {total/1e9:.2f} GiB')\n",
" print(f'Reserved by PyTorch: {torch.cuda.memory_reserved()/1e9:.2f} GiB')\n",
" print(f'Allocated by PyTorch: {torch.cuda.memory_allocated()/1e9:.2f} GiB')\n"
]
},
{
"cell_type": "markdown",
"id": "366c8755",
"metadata": {
"papermill": {
"duration": 0.033253,
"end_time": "2026-06-28T01:11:22.199829+00:00",
"exception": false,
"start_time": "2026-06-28T01:11:22.166576+00:00",
"status": "completed"
},
"tags": []
},
"source": [
"# Resume Point — Load Previous GRPO Checkpoint (cross-session)\n",
"\n",
"GRPO checkpoints every `save_steps=200` steps to `{OUTPUT_DIR}/grpo/checkpoint-N`.\n",
"Since `/kaggle/working` does not survive between sessions, attach the previous\n",
"session's Output as an Input here (same as the SFT resume step) and point\n",
"`GRPO_RESUME_PATH` at the highest `checkpoint-N` you have.\n",
"\n",
"Two outcomes depending on how far GRPO got:\n",
"- **Mid-training** (didn't finish all `GRPO_EPOCHS`): training continues\n",
" from that exact step via `resume_from_checkpoint`.\n",
"- **Fully complete** (already did all epochs): set `GRPO_FULLY_DONE = True`\n",
" below to skip GRPO entirely and load straight into DPO.\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "85cb14bd",
"metadata": {
"execution": {
"iopub.execute_input": "2026-06-28T01:11:22.268987Z",
"iopub.status.busy": "2026-06-28T01:11:22.268692Z",
"iopub.status.idle": "2026-06-28T01:11:26.006499Z",
"shell.execute_reply": "2026-06-28T01:11:26.005492Z"
},
"papermill": {
"duration": 3.774531,
"end_time": "2026-06-28T01:11:26.008186+00:00",
"exception": false,
"start_time": "2026-06-28T01:11:22.233655+00:00",
"status": "completed"
},
"tags": []
},
"outputs": [],
"source": [
"# ===========================================================================\n",
"# RESUME FROM PREVIOUS GRPO RUN (cross-session checkpoint loading)\n",
"# ===========================================================================\n",
"# HOW TO USE:\n",
"# 1. Attach the previous session's Output/Dataset as an Input to this\n",
"# session (Add Input -> Notebook Output Files, or a Dataset built\n",
"# from it -- same as you did for the SFT resume).\n",
"# 2. Find the checkpoint path:\n",
"# !find /kaggle/input -maxdepth 6 -iname \"checkpoint-*\" -path \"*grpo*\" -type d\n",
"# 3a. If GRPO did NOT finish all GRPO_EPOCHS yet, set GRPO_RESUME_PATH to\n",
"# the highest checkpoint-N and leave GRPO_FULLY_DONE = False.\n",
"# Training resumes from that step and keeps going to GRPO_EPOCHS.\n",
"# 3b. If GRPO DID finish (you saw \"GRPO Training complete!\" printed in a\n",
"# prior session), set GRPO_FULLY_DONE = True instead -- this loads\n",
"# the final GRPO adapter weights and skips straight to DPO.\n",
"\n",
"GRPO_RESUME_PATH = \"/kaggle/input/notebooks/sandeepautomation/aftergrpo600/timps-coder-v4/grpo/checkpoint-648\" # <-- e.g. \"/kaggle/input//timps-coder-v4/grpo/checkpoint-600\"\n",
"GRPO_FULLY_DONE = True # <-- set True only if GRPO already completed all epochs\n",
"\n",
"if GRPO_FULLY_DONE:\n",
" if not GRPO_RESUME_PATH:\n",
" raise ValueError(\n",
" \"GRPO_FULLY_DONE=True requires GRPO_RESUME_PATH to point at the \"\n",
" \"final GRPO checkpoint so the trained weights can be loaded.\"\n",
" )\n",
" import os\n",
" if not os.path.isdir(GRPO_RESUME_PATH):\n",
" raise FileNotFoundError(\n",
" f\"GRPO_RESUME_PATH does not exist: {GRPO_RESUME_PATH}\\n\"\n",
" f\"Run: !find /kaggle/input -maxdepth 6 -iname 'checkpoint-*' -path '*grpo*' -type d\"\n",
" )\n",
" has_weights = (\n",
" os.path.isfile(f\"{GRPO_RESUME_PATH}/adapter_model.safetensors\")\n",
" or os.path.isfile(f\"{GRPO_RESUME_PATH}/adapter_model.bin\")\n",
" )\n",
" if not has_weights:\n",
" raise FileNotFoundError(\n",
" f\"No adapter weights found in {GRPO_RESUME_PATH}. \"\n",
" f\"Expected adapter_model.safetensors (GRPO was run with save_only_model=True).\"\n",
" )\n",
" print(f\"Loading COMPLETED GRPO adapter from: {GRPO_RESUME_PATH}\")\n",
" model.load_adapter(GRPO_RESUME_PATH, adapter_name=\"default\", is_trainable=True)\n",
" trainable = sum(p.numel() for p in model.parameters() if p.requires_grad)\n",
" print(f\"GRPO weights loaded. Trainable params: {trainable:,}\")\n",
" print(f\"GRPO training will be SKIPPED -- proceeding straight to DPO.\")\n",
"elif GRPO_RESUME_PATH:\n",
" import os\n",
" if not os.path.isdir(GRPO_RESUME_PATH):\n",
" raise FileNotFoundError(\n",
" f\"GRPO_RESUME_PATH does not exist: {GRPO_RESUME_PATH}\\n\"\n",
" f\"Run: !find /kaggle/input -maxdepth 6 -iname 'checkpoint-*' -path '*grpo*' -type d\"\n",
" )\n",
" print(f\"Will resume mid-GRPO-training from: {GRPO_RESUME_PATH}\")\n",
" print(f\"(weights + optimizer-equivalent state load handled by resume_from_checkpoint\")\n",
" print(f\" inside the GRPOTrainer.train() call below)\")\n",
"else:\n",
" print(\"GRPO_RESUME_PATH not set -- GRPO will train from scratch in the next cell.\")\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "bb4b663a",
"metadata": {
"execution": {
"iopub.execute_input": "2026-06-28T01:11:26.082559Z",
"iopub.status.busy": "2026-06-28T01:11:26.082183Z",
"iopub.status.idle": "2026-06-28T01:11:26.138920Z",
"shell.execute_reply": "2026-06-28T01:11:26.137854Z"
},
"papermill": {
"duration": 0.095297,
"end_time": "2026-06-28T01:11:26.140488+00:00",
"exception": false,
"start_time": "2026-06-28T01:11:26.045191+00:00",
"status": "completed"
},
"tags": []
},
"outputs": [],
"source": [
"import gc\n",
"from trl import GRPOConfig, GRPOTrainer\n",
"import numpy as np\n",
"import os, shutil, glob, torch\n",
"\n",
"# -- Cleanup any partial GRPO checkpoints from a previous run --\n",
"grpo_output = f\"{OUTPUT_DIR}/grpo\"\n",
"if os.path.isdir(grpo_output):\n",
" for ckpt in sorted(glob.glob(f\"{grpo_output}/checkpoint-*\")):\n",
" has_weights = glob.glob(f\"{ckpt}/*.safetensors\") or glob.glob(f\"{ckpt}/pytorch_model.bin\")\n",
" if not has_weights:\n",
" print(f\" Removing corrupted GRPO checkpoint: {ckpt}\")\n",
" shutil.rmtree(ckpt, ignore_errors=True)\n",
"\n",
"# -- AUTO-SCALED GRPO CONFIG --\n",
"# All the values below are read from the GPU-tier budget set in Step 1 (Cell 5).\n",
"# T4 (15 GB) gets the conservative profile; A100 keeps the original aggressive one.\n",
"# If you still hit OOM, the try/except at the bottom auto-retries with even\n",
"# smaller values.\n",
"\n",
"NUM_GENERATIONS = BUDGET_NUM_GENERATIONS # 2 on T4, 4 on A100\n",
"MAX_COMPLETION_LENGTH = BUDGET_MAX_COMPLETION_LEN # 512 on T4, 1024 on A100\n",
"MAX_PROMPT_LENGTH = BUDGET_MAX_PROMPT_LEN # 1536 on T4, 3072 on A100\n",
"GRPO_BATCH = BUDGET_GRPO_BATCH # 1 everywhere\n",
"GRPO_GRAD_ACCUM = BUDGET_GRPO_GRAD_ACCUM # 8 everywhere\n",
"GRPO_OPTIM = BUDGET_OPTIM # paged_adamw_8bit on T4, adamw_torch on A100\n",
"\n",
"# generation_batch_size MUST be a multiple of num_generations (TRL hard\n",
"# requirement). Derive it instead of hardcoding it.\n",
"def _round_up_to_multiple(value, multiple):\n",
" if multiple <= 0:\n",
" return value\n",
" remainder = value % multiple\n",
" return value if remainder == 0 else value + (multiple - remainder)\n",
"\n",
"GRPO_GENERATION_BATCH = _round_up_to_multiple(\n",
" GRPO_BATCH * GRPO_GRAD_ACCUM, NUM_GENERATIONS\n",
")\n",
"assert GRPO_GENERATION_BATCH % NUM_GENERATIONS == 0, (\n",
" f\"generation_batch_size ({GRPO_GENERATION_BATCH}) must be divisible by \"\n",
" f\"num_generations ({NUM_GENERATIONS})\"\n",
")\n",
"\n",
"grpo_config = GRPOConfig(\n",
" output_dir = grpo_output,\n",
" num_train_epochs = GRPO_EPOCHS, # 1 (fast) or 3 (full)\n",
" per_device_train_batch_size = GRPO_BATCH,\n",
" gradient_accumulation_steps = GRPO_GRAD_ACCUM,\n",
" learning_rate = 5e-6,\n",
" lr_scheduler_type = \"cosine\",\n",
" optim = GRPO_OPTIM, # paged_adamw_8bit = 8-bit + CPU paging\n",
" weight_decay = 0.01,\n",
" warmup_steps = 50,\n",
" logging_steps = 10,\n",
" save_steps = 200,\n",
" save_total_limit = 3,\n",
" save_only_model = True, # skip optimizer state at checkpoint\n",
" bf16 = torch.cuda.is_bf16_supported(),\n",
" fp16 = not torch.cuda.is_bf16_supported(),\n",
"\n",
" # GRPO-specific (the OOM-critical knobs)\n",
" num_generations = NUM_GENERATIONS,\n",
" max_completion_length = MAX_COMPLETION_LENGTH,\n",
" max_prompt_length = MAX_PROMPT_LENGTH, # explicit truncation -- REQUIRED\n",
" temperature = 0.7,\n",
" beta = 0.04,\n",
" loss_type = \"grpo\", # explicit; avoids bnpo surprise\n",
"\n",
" # Generation efficiency (cuts VRAM spikes during sample generation)\n",
" generation_batch_size = GRPO_GENERATION_BATCH, # derived: always a multiple of num_generations\n",
" # NOTE: do NOT set use_cache=False anywhere; default True is what makes\n",
" # KV-cache work and keeps generation memory bounded.\n",
"\n",
" # Reporting\n",
" report_to = \"none\",\n",
" seed = 42,\n",
" gradient_checkpointing = True,\n",
" gradient_checkpointing_kwargs = {\"use_reentrant\": False},\n",
" remove_unused_columns = False,\n",
")\n",
"\n",
"print(f\"GRPO Config (auto-scaled for {GPU_TIER}):\")\n",
"print(f\" Num generations : {NUM_GENERATIONS}\")\n",
"print(f\" Generation batch : {GRPO_GENERATION_BATCH} (auto-derived, multiple of num_generations)\")\n",
"print(f\" Max completion : {MAX_COMPLETION_LENGTH} tokens\")\n",
"print(f\" Max prompt : {MAX_PROMPT_LENGTH} tokens\")\n",
"print(f\" Max length (sum) : {MAX_PROMPT_LENGTH + MAX_COMPLETION_LENGTH} tokens\")\n",
"print(f\" Temperature : 0.7\")\n",
"print(f\" KL penalty (beta) : 0.04\")\n",
"print(f\" Learning rate : 5e-6\")\n",
"print(f\" Optimizer : {GRPO_OPTIM}\")\n",
"print(f\" Epochs : {GRPO_EPOCHS}\")\n",
"print(f\" GRPO problems : {len(grpo_train):,}\")\n",
"print(f\" args class : {type(grpo_config).__name__}\")\n",
"print()\n",
"\n",
"\n",
"# -- Define reward functions for GRPOTrainer --\n",
"def grpo_correctness_reward(prompts, completions, **kwargs):\n",
" \"\"\"Reward code correctness based on test execution.\"\"\"\n",
" rewards = []\n",
" for completion in completions:\n",
" has_code = any(sig in completion for sig in [\"def \", \"class \", \"```python\", \"return \"])\n",
" has_verify = any(sig in completion.lower() for sig in [\"verify\", \"test\", \"assert\", \"check\"])\n",
" reward = 0.3 if has_code else 0.0\n",
" reward += 0.2 if has_verify else 0.0\n",
" rewards.append(reward)\n",
" return rewards\n",
"\n",
"\n",
"def grpo_discipline_reward(prompts, completions, **kwargs):\n",
" \"\"\"Reward for tool discipline -- inspecting before writing.\"\"\"\n",
" rewards = []\n",
" for completion in completions:\n",
" think_idx = completion.lower().find(\"think\")\n",
" inspect_idx = completion.lower().find(\"inspect\")\n",
" act_idx = completion.lower().find(\"act\")\n",
" read_idx = completion.lower().find(\"read_file\")\n",
"\n",
" inspected_first = False\n",
" if act_idx > 0:\n",
" if think_idx >= 0 and think_idx < act_idx:\n",
" inspected_first = True\n",
" if inspect_idx >= 0 and inspect_idx < act_idx:\n",
" inspected_first = True\n",
" if read_idx >= 0 and read_idx < act_idx:\n",
" inspected_first = True\n",
" elif think_idx >= 0 or inspect_idx >= 0 or read_idx >= 0:\n",
" inspected_first = True\n",
"\n",
" rewards.append(0.5 if inspected_first else 0.0)\n",
" return rewards\n",
"\n",
"\n",
"def grpo_verification_reward(prompts, completions, **kwargs):\n",
" \"\"\"Reward for verification after writing code.\"\"\"\n",
" rewards = []\n",
" for completion in completions:\n",
" act_idx = completion.lower().rfind(\"act\")\n",
" verify_idx = completion.lower().rfind(\"verify\")\n",
" test_idx = completion.lower().rfind(\"run_tests\")\n",
"\n",
" verified_after = False\n",
" if act_idx >= 0:\n",
" if verify_idx > act_idx or test_idx > act_idx:\n",
" verified_after = True\n",
" elif verify_idx >= 0 or test_idx >= 0:\n",
" verified_after = True\n",
"\n",
" rewards.append(0.3 if verified_after else 0.0)\n",
" return rewards\n",
"\n",
"\n",
"# ===========================================================================\n",
"# SKIP GRPO ENTIRELY IF IT ALREADY FULLY COMPLETED IN A PRIOR SESSION\n",
"# ===========================================================================\n",
"# GRPO_FULLY_DONE / GRPO_RESUME_PATH are set by the \"Resume Point\" cell above.\n",
"if GRPO_FULLY_DONE:\n",
" print(\"=\" * 50)\n",
" print(\"GRPO_FULLY_DONE = True -- skipping GRPO training.\")\n",
" print(\"Using the GRPO adapter weights loaded from GRPO_RESUME_PATH.\")\n",
" print(\"=\" * 50)\n",
" grpo_stats = None\n",
"else:\n",
" # -- Create GRPO Trainer --\n",
" print(\"Initializing GRPO Trainer...\")\n",
" print(\" This uses the SFT-warmed model as the starting policy\")\n",
"\n",
" # Free any remaining slack right before trainer init\n",
" gc.collect()\n",
" torch.cuda.empty_cache()\n",
"\n",
" grpo_trainer = GRPOTrainer(\n",
" model = model,\n",
" args = grpo_config,\n",
" train_dataset = grpo_train,\n",
" reward_funcs = [\n",
" grpo_correctness_reward,\n",
" grpo_discipline_reward,\n",
" grpo_verification_reward,\n",
" ],\n",
" processing_class = tokenizer,\n",
" )\n",
"\n",
" print(\"\\nStarting GRPO Training...\")\n",
" print(f\" This is the longest training step (~1-2h on T4 per epoch)\")\n",
" if GRPO_RESUME_PATH:\n",
" print(f\" Resuming mid-training from: {GRPO_RESUME_PATH}\")\n",
" print(\"=\" * 60)\n",
"\n",
" try:\n",
" grpo_stats = grpo_trainer.train(\n",
" resume_from_checkpoint=GRPO_RESUME_PATH if GRPO_RESUME_PATH else None\n",
" )\n",
" except torch.cuda.OutOfMemoryError as e:\n",
" print(f\"\\n!! GRPO OOM even with the conservative T4 profile: {e}\")\n",
" print(\" Auto-retrying with the EMERGENCY profile:\")\n",
" print(\" NUM_GENERATIONS = 1 (degenerate GRPO -> REINFORCE; still useful)\")\n",
" print(\" MAX_COMPLETION = 256\")\n",
" print(\" MAX_PROMPT = 1024\")\n",
"\n",
" # Free everything from the failed attempt\n",
" del grpo_trainer\n",
" gc.collect()\n",
" torch.cuda.empty_cache()\n",
" gc.collect()\n",
" torch.cuda.empty_cache()\n",
"\n",
" # Rebuild config with the emergency profile\n",
" grpo_config.num_generations = 1\n",
" grpo_config.max_completion_length = 256\n",
" grpo_config.max_prompt_length = 1024\n",
" # Re-derive generation_batch_size for the NEW num_generations so this\n",
" # can never hit the same \"must be divisible by\" error.\n",
" grpo_config.generation_batch_size = _round_up_to_multiple(\n",
" GRPO_BATCH * GRPO_GRAD_ACCUM, grpo_config.num_generations\n",
" )\n",
" print(f\" Generation batch = {grpo_config.generation_batch_size} (re-derived for emergency profile)\")\n",
"\n",
" grpo_trainer = GRPOTrainer(\n",
" model = model,\n",
" args = grpo_config,\n",
" train_dataset = grpo_train,\n",
" reward_funcs = [\n",
" grpo_correctness_reward,\n",
" grpo_discipline_reward,\n",
" grpo_verification_reward,\n",
" ],\n",
" processing_class = tokenizer,\n",
" )\n",
" # NOTE: emergency profile changed config shape (num_generations etc.),\n",
" # so a checkpoint saved under the original profile is generally not\n",
" # safely resumable here -- start the emergency attempt fresh unless\n",
" # you know the saved checkpoint matches this exact emergency shape.\n",
" grpo_stats = grpo_trainer.train()\n",
"\n",
" print(\"=\" * 60)\n",
" if grpo_stats is not None:\n",
" print(f\"GRPO Training complete!\")\n",
" print(f\" Train loss : {grpo_stats.training_loss:.4f}\")\n",
" print(f\" Total steps : {grpo_stats.global_step}\")\n",
" runtime_mins = grpo_stats.metrics.get('train_runtime', 0) / 60\n",
" print(f\" Runtime : {runtime_mins:.1f} minutes\")\n",
" else:\n",
" print(\"GRPO training did not complete -- check the error above.\")\n",
" raise RuntimeError(\"GRPO training failed even with the emergency profile\")\n"
]
},
{
"cell_type": "markdown",
"id": "f5c273b7",
"metadata": {
"papermill": {
"duration": 0.034225,
"end_time": "2026-06-28T01:11:26.209394+00:00",
"exception": false,
"start_time": "2026-06-28T01:11:26.175169+00:00",
"status": "completed"
},
"tags": []
},
"source": [
"---\n",
"# PHASE 4: STEP 3 — DPO ALIGNMENT\n",
"\n",
"After GRPO, we use Direct Preference Optimization (DPO) to refine the model's outputs.\n",
"\n",
"**Why DPO after GRPO?**\n",
"- GRPO explores and finds good behaviors\n",
"- DPO consolidates those behaviors by learning from preference pairs\n",
"- The combination (GRPO → DPO) is more effective than either alone\n",
"\n",
"**Process:**\n",
"1. Generate 2 solutions per problem with the GRPO-trained model\n",
"2. Score each using our reward functions\n",
"3. Higher-scored = \"chosen\", lower = \"rejected\"\n",
"4. Train DPO on these preference pairs\n",
"\n",
"**Kaggle note:** DPO_NUM_PAIRS is set in Step 0 (100 fast / 200 full).\n"
]
},
{
"cell_type": "markdown",
"id": "33487a15",
"metadata": {
"papermill": {
"duration": 0.034795,
"end_time": "2026-06-28T01:11:26.278408+00:00",
"exception": false,
"start_time": "2026-06-28T01:11:26.243613+00:00",
"status": "completed"
},
"tags": []
},
"source": [
"# @title Step 11 — Generate DPO preference pairs\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "53f4f9a9",
"metadata": {
"execution": {
"iopub.execute_input": "2026-06-28T01:11:26.347983Z",
"iopub.status.busy": "2026-06-28T01:11:26.347634Z",
"iopub.status.idle": "2026-06-28T03:30:45.164532Z",
"shell.execute_reply": "2026-06-28T03:30:45.163531Z"
},
"papermill": {
"duration": 8358.854286,
"end_time": "2026-06-28T03:30:45.166171+00:00",
"exception": false,
"start_time": "2026-06-28T01:11:26.311885+00:00",
"status": "completed"
},
"tags": []
},
"outputs": [],
"source": [
"import gc\n",
"from tqdm import tqdm\n",
"import torch\n",
"\n",
"# ── OOM RECOVERY: free everything from GRPO before generating DPO pairs ────\n",
"# DPO pair gen runs N×2 sequential generate() calls. Each one is small in\n",
"# isolation, but fragmentation builds up over hundreds of calls. Start clean.\n",
"try:\n",
" del grpo_trainer\n",
" print(\"Deleted grpo_trainer\")\n",
"except NameError:\n",
" print(\"grpo_trainer already gone (ok if you skipped GRPO)\")\n",
"\n",
"# Drop large intermediates we no longer need\n",
"for _name in (\"grpo_config\", \"grpo_stats\"):\n",
" try:\n",
" globals().pop(_name, None)\n",
" except Exception:\n",
" pass\n",
"\n",
"gc.collect()\n",
"torch.cuda.empty_cache()\n",
"gc.collect()\n",
"torch.cuda.empty_cache()\n",
"\n",
"# -- Generate preference pairs --\n",
"# For each problem, generate 2 completions and score them\n",
"# The higher-scored one becomes \"chosen\", the lower becomes \"rejected\"\n",
"\n",
"# Use the budget-aware completion length (512 on T4, 1024 on A100)\n",
"DPO_GEN_MAX_NEW = BUDGET_MAX_COMPLETION_LEN\n",
"\n",
"print(\"Generating DPO preference pairs...\")\n",
"print(f\" Using the GRPO-trained model to create chosen/rejected pairs\")\n",
"print(f\" Target pair count: {DPO_NUM_PAIRS}\")\n",
"print(f\" Max new tokens per completion: {DPO_GEN_MAX_NEW}\")\n",
"\n",
"dpo_data = []\n",
"num_pairs = min(DPO_NUM_PAIRS, len(grpo_train))\n",
"sample_indices = random.sample(range(len(grpo_train)), num_pairs)\n",
"\n",
"FastLanguageModel.for_inference(model) # Switch to inference mode\n",
"\n",
"for idx in tqdm(sample_indices, desc=\"Generating pairs\"):\n",
" problem = grpo_train[idx]\n",
" prompt = problem[\"prompt\"]\n",
"\n",
" # Format prompt in ChatML\n",
" messages = [\n",
" {\"role\": \"system\", \"content\": SYSTEM_V4},\n",
" {\"role\": \"user\", \"content\": prompt},\n",
" ]\n",
" input_text = tokenizer.apply_chat_template(\n",
" messages, tokenize=False, add_generation_prompt=True\n",
" )\n",
" inputs = tokenizer(input_text, return_tensors=\"pt\").to(model.device)\n",
"\n",
" # Generate 2 completions with different temperatures\n",
" completions = []\n",
" for temp in [0.3, 0.8]: # Low and high temperature for diversity\n",
" with torch.no_grad():\n",
" outputs = model.generate(\n",
" **inputs,\n",
" max_new_tokens=DPO_GEN_MAX_NEW,\n",
" temperature=temp,\n",
" do_sample=True,\n",
" top_p=0.95,\n",
" pad_token_id=tokenizer.pad_token_id,\n",
" )\n",
" completion = tokenizer.decode(\n",
" outputs[0][inputs[\"input_ids\"].shape[1]:],\n",
" skip_special_tokens=True\n",
" )\n",
" completions.append(completion)\n",
" # Free this generation's tensors immediately — prevents fragmentation\n",
" # buildup across the hundreds of generate() calls in this loop.\n",
" del outputs\n",
" torch.cuda.empty_cache()\n",
"\n",
" # Score completions\n",
" scores = []\n",
" for comp in completions:\n",
" r_correct = grpo_correctness_reward([prompt], [comp])[0]\n",
" r_discipline = grpo_discipline_reward([prompt], [comp])[0]\n",
" r_verify = grpo_verification_reward([prompt], [comp])[0]\n",
" total = 0.5 * r_correct + 0.3 * r_discipline + 0.2 * r_verify\n",
" scores.append(total)\n",
"\n",
" # Higher score = chosen, lower = rejected\n",
" if scores[0] >= scores[1]:\n",
" chosen, rejected = completions[0], completions[1]\n",
" else:\n",
" chosen, rejected = completions[1], completions[0]\n",
"\n",
" # Skip if both are equally bad\n",
" if max(scores) < 0.1:\n",
" continue\n",
"\n",
" dpo_data.append({\n",
" \"prompt\": input_text,\n",
" \"chosen\": chosen,\n",
" \"rejected\": rejected,\n",
" \"chosen_score\": max(scores),\n",
" \"rejected_score\": min(scores),\n",
" })\n",
"\n",
" # Drop per-iteration tensors\n",
" del inputs, completions\n",
" # Every 25 iterations, force a deeper clean\n",
" if len(dpo_data) % 25 == 0:\n",
" gc.collect()\n",
" torch.cuda.empty_cache()\n",
"\n",
"# Create DPO dataset\n",
"from datasets import Dataset as HFDataset\n",
"dpo_dataset = HFDataset.from_list(dpo_data)\n",
"\n",
"# Persist to /kaggle/working so it survives a session restart\n",
"import json\n",
"with open(f\"{WORK_DIR}/dpo_pairs.json\", \"w\") as f:\n",
" json.dump(dpo_data, f)\n",
"\n",
"print(f\"\\nGenerated {len(dpo_data)} DPO preference pairs\")\n",
"print(f\" Avg chosen score : {np.mean([d['chosen_score'] for d in dpo_data]):.3f}\")\n",
"print(f\" Avg rejected score: {np.mean([d['rejected_score'] for d in dpo_data]):.3f}\")\n",
"print(f\" Avg score gap : {np.mean([d['chosen_score'] - d['rejected_score'] for d in dpo_data]):.3f}\")\n",
"print(f\" Saved to {WORK_DIR}/dpo_pairs.json\")\n",
"\n",
"# Final cleanup before DPO training cell\n",
"del dpo_data, sample_indices\n",
"gc.collect()\n",
"torch.cuda.empty_cache()\n"
]
},
{
"cell_type": "markdown",
"id": "9f09d756",
"metadata": {
"papermill": {
"duration": 0.055752,
"end_time": "2026-06-28T03:30:45.279135+00:00",
"exception": false,
"start_time": "2026-06-28T03:30:45.223383+00:00",
"status": "completed"
},
"tags": []
},
"source": [
"# @title Step 12 — DPO Training (preference alignment)\n"
]
},
{
"cell_type": "markdown",
"id": "14805394",
"metadata": {
"papermill": {
"duration": 0.055854,
"end_time": "2026-06-28T03:30:45.390364+00:00",
"exception": false,
"start_time": "2026-06-28T03:30:45.334510+00:00",
"status": "completed"
},
"tags": []
},
"source": [
"# Resume Point — Load Previous DPO Checkpoint (cross-session)\n",
"\n",
"DPO checkpoints every `save_steps=100` to `{OUTPUT_DIR}/dpo/checkpoint-N`.\n",
"Same pattern as SFT and GRPO: attach the previous session's Output as an\n",
"Input, then point `DPO_RESUME_PATH` at the highest checkpoint you have.\n",
"\n",
"- **Mid-training**: leave `DPO_FULLY_DONE = False`, training continues from\n",
" that step via `resume_from_checkpoint`.\n",
"- **Fully complete** (DPO already finished its 1 epoch in a prior session):\n",
" set `DPO_FULLY_DONE = True` to load the final weights and skip straight\n",
" to the post-training steps (HumanEval, fusing, GGUF export, etc.).\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "be9ae859",
"metadata": {
"execution": {
"iopub.execute_input": "2026-06-28T03:30:45.503320Z",
"iopub.status.busy": "2026-06-28T03:30:45.502743Z",
"iopub.status.idle": "2026-06-28T03:30:50.696622Z",
"shell.execute_reply": "2026-06-28T03:30:50.695711Z"
},
"papermill": {
"duration": 5.251945,
"end_time": "2026-06-28T03:30:50.698062+00:00",
"exception": false,
"start_time": "2026-06-28T03:30:45.446117+00:00",
"status": "completed"
},
"tags": []
},
"outputs": [],
"source": [
"# ===========================================================================\n",
"# RESUME FROM PREVIOUS DPO RUN (cross-session checkpoint loading)\n",
"# ===========================================================================\n",
"# 1. Attach the previous session's Output/Dataset as an Input.\n",
"# 2. Find the checkpoint path:\n",
"# !find /kaggle/input -maxdepth 6 -iname \"checkpoint-*\" -path \"*dpo*\" -type d\n",
"# 3a. Mid-training: set DPO_RESUME_PATH to the highest checkpoint-N,\n",
"# leave DPO_FULLY_DONE = False.\n",
"# 3b. Fully done: set DPO_FULLY_DONE = True to load final weights and\n",
"# skip DPO training entirely.\n",
"\n",
"DPO_RESUME_PATH = \"/kaggle/input/notebooks/sandeepautomation/aftergrpo600/timps-coder-v4/dpo/checkpoint-50\" # <-- e.g. \"/kaggle/input//timps-coder-v4/dpo/checkpoint-100\"\n",
"DPO_FULLY_DONE = True # <-- set True only if DPO already completed its epoch\n",
"\n",
"if DPO_FULLY_DONE:\n",
" if not DPO_RESUME_PATH:\n",
" raise ValueError(\n",
" \"DPO_FULLY_DONE=True requires DPO_RESUME_PATH to point at the \"\n",
" \"final DPO checkpoint so the trained weights can be loaded.\"\n",
" )\n",
" import os\n",
" if not os.path.isdir(DPO_RESUME_PATH):\n",
" raise FileNotFoundError(\n",
" f\"DPO_RESUME_PATH does not exist: {DPO_RESUME_PATH}\\n\"\n",
" f\"Run: !find /kaggle/input -maxdepth 6 -iname 'checkpoint-*' -path '*dpo*' -type d\"\n",
" )\n",
" has_weights = (\n",
" os.path.isfile(f\"{DPO_RESUME_PATH}/adapter_model.safetensors\")\n",
" or os.path.isfile(f\"{DPO_RESUME_PATH}/adapter_model.bin\")\n",
" )\n",
" if not has_weights:\n",
" raise FileNotFoundError(\n",
" f\"No adapter weights found in {DPO_RESUME_PATH}. \"\n",
" f\"Expected adapter_model.safetensors (DPO was run with save_only_model=True).\"\n",
" )\n",
" print(f\"Loading COMPLETED DPO adapter from: {DPO_RESUME_PATH}\")\n",
" model.load_adapter(DPO_RESUME_PATH, adapter_name=\"default\", is_trainable=True)\n",
" trainable = sum(p.numel() for p in model.parameters() if p.requires_grad)\n",
" print(f\"DPO weights loaded. Trainable params: {trainable:,}\")\n",
" print(f\"DPO training will be SKIPPED -- proceeding to evaluation / export.\")\n",
"elif DPO_RESUME_PATH:\n",
" import os\n",
" if not os.path.isdir(DPO_RESUME_PATH):\n",
" raise FileNotFoundError(\n",
" f\"DPO_RESUME_PATH does not exist: {DPO_RESUME_PATH}\\n\"\n",
" f\"Run: !find /kaggle/input -maxdepth 6 -iname 'checkpoint-*' -path '*dpo*' -type d\"\n",
" )\n",
" print(f\"Will resume mid-DPO-training from: {DPO_RESUME_PATH}\")\n",
"else:\n",
" print(\"DPO_RESUME_PATH not set -- DPO will train from scratch in the next cell.\")\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "c0ac12c9",
"metadata": {
"execution": {
"iopub.execute_input": "2026-06-28T03:30:50.813427Z",
"iopub.status.busy": "2026-06-28T03:30:50.812942Z",
"iopub.status.idle": "2026-06-28T03:30:51.640596Z",
"shell.execute_reply": "2026-06-28T03:30:51.639400Z"
},
"papermill": {
"duration": 0.886642,
"end_time": "2026-06-28T03:30:51.642174+00:00",
"exception": false,
"start_time": "2026-06-28T03:30:50.755532+00:00",
"status": "completed"
},
"tags": []
},
"outputs": [],
"source": [
"import gc\n",
"from trl import DPOConfig, DPOTrainer\n",
"import os, shutil, glob, torch\n",
"\n",
"# -- OOM RECOVERY: free pair-gen intermediates before DPOTrainer init --\n",
"# DPO holds the policy + a frozen reference policy in memory simultaneously,\n",
"# so it has the highest steady-state VRAM usage of any training step.\n",
"for _name in (\"grpo_correctness_reward\", \"grpo_discipline_reward\", \"grpo_verification_reward\"):\n",
" # Keep these -- DPOTrainer doesn't need them but the next SGS cell might.\n",
" pass\n",
"\n",
"# Drop anything else we can\n",
"gc.collect()\n",
"torch.cuda.empty_cache()\n",
"gc.collect()\n",
"torch.cuda.empty_cache()\n",
"\n",
"# -- DPO Config (auto-scaled by GPU tier) --\n",
"# DPO uses a much lower learning rate than SFT/GRPO.\n",
"# We're fine-tuning preferences, not learning from scratch.\n",
"FastLanguageModel.for_training(model) # Switch back to training mode\n",
"\n",
"# Cleanup any partial DPO checkpoints from a previous run\n",
"dpo_output = f\"{OUTPUT_DIR}/dpo\"\n",
"if os.path.isdir(dpo_output):\n",
" for ckpt in sorted(glob.glob(f\"{dpo_output}/checkpoint-*\")):\n",
" has_weights = glob.glob(f\"{ckpt}/*.safetensors\") or glob.glob(f\"{ckpt}/pytorch_model.bin\")\n",
" if not has_weights:\n",
" print(f\" Removing corrupted DPO checkpoint: {ckpt}\")\n",
" shutil.rmtree(ckpt, ignore_errors=True)\n",
"\n",
"# Budget-aware knobs (read from globals set in Step 1 / Cell 5)\n",
"DPO_MAX_LENGTH = min(MAX_SEQ_LEN, BUDGET_MAX_PROMPT_LEN + BUDGET_MAX_COMPLETION_LEN)\n",
"DPO_MAX_PROMPT = BUDGET_MAX_PROMPT_LEN\n",
"DPO_MAX_COMPLETION = BUDGET_MAX_COMPLETION_LEN\n",
"DPO_OPTIM = BUDGET_OPTIM # paged_adamw_8bit on T4, adamw_torch on A100\n",
"\n",
"dpo_config = DPOConfig(\n",
" output_dir = dpo_output,\n",
" num_train_epochs = 1,\n",
" per_device_train_batch_size = 1,\n",
" gradient_accumulation_steps = 4,\n",
" learning_rate = 1e-6,\n",
" lr_scheduler_type = \"cosine\",\n",
" optim = DPO_OPTIM, # 8-bit + CPU paging on T4\n",
" weight_decay = 0.01,\n",
" warmup_steps = 20,\n",
" bf16 = torch.cuda.is_bf16_supported(),\n",
" fp16 = not torch.cuda.is_bf16_supported(),\n",
" beta = 0.1, # preference strength\n",
" max_length = DPO_MAX_LENGTH, # cap total sequence length\n",
" max_prompt_length = DPO_MAX_PROMPT, # explicit prompt truncation\n",
" max_completion_length = DPO_MAX_COMPLETION,\n",
" logging_steps = 10,\n",
" save_steps = 100,\n",
" save_total_limit = 2,\n",
" save_only_model = True, # skip optimizer state at checkpoint\n",
" report_to = \"none\",\n",
" seed = 42,\n",
" gradient_checkpointing = True,\n",
" gradient_checkpointing_kwargs = {\"use_reentrant\": False},\n",
" remove_unused_columns = False,\n",
")\n",
"\n",
"print(f\"DPO Config (auto-scaled for {GPU_TIER}):\")\n",
"print(f\" Learning rate : 1e-6 (very low for preference tuning)\")\n",
"print(f\" Beta : 0.1 (preference strength)\")\n",
"print(f\" Optimizer : {DPO_OPTIM}\")\n",
"print(f\" Max length : {DPO_MAX_LENGTH}\")\n",
"print(f\" Max prompt : {DPO_MAX_PROMPT}\")\n",
"print(f\" Max completion : {DPO_MAX_COMPLETION}\")\n",
"print(f\" Epochs : 1\")\n",
"print(f\" Preference pairs : {len(dpo_dataset)}\")\n",
"print(f\" args class : {type(dpo_config).__name__}\")\n",
"print()\n",
"\n",
"# ===========================================================================\n",
"# SKIP DPO ENTIRELY IF IT ALREADY FULLY COMPLETED IN A PRIOR SESSION\n",
"# ===========================================================================\n",
"# DPO_FULLY_DONE / DPO_RESUME_PATH are set by the \"Resume Point\" cell above.\n",
"if DPO_FULLY_DONE:\n",
" print(\"=\" * 50)\n",
" print(\"DPO_FULLY_DONE = True -- skipping DPO training.\")\n",
" print(\"Using the DPO adapter weights loaded from DPO_RESUME_PATH.\")\n",
" print(\"=\" * 50)\n",
" dpo_stats = None\n",
"else:\n",
" # Final cleanup right before trainer init\n",
" gc.collect()\n",
" torch.cuda.empty_cache()\n",
"\n",
" dpo_trainer = DPOTrainer(\n",
" model = model,\n",
" args = dpo_config,\n",
" train_dataset = dpo_dataset,\n",
" processing_class = tokenizer,\n",
" )\n",
"\n",
" print(\"Starting DPO Training...\")\n",
" if DPO_RESUME_PATH:\n",
" print(f\" Resuming mid-training from: {DPO_RESUME_PATH}\")\n",
" print(\"=\" * 50)\n",
"\n",
" dpo_stats = None\n",
" try:\n",
" dpo_stats = dpo_trainer.train(\n",
" resume_from_checkpoint=DPO_RESUME_PATH if DPO_RESUME_PATH else None\n",
" )\n",
" except torch.cuda.OutOfMemoryError as e:\n",
" print(f\"\\n!! DPO OOM: {e}\")\n",
" print(\" Auto-retrying with EMERGENCY profile:\")\n",
" print(\" max_length = 1024\")\n",
" print(\" max_prompt = 768\")\n",
" print(\" max_completion = 256\")\n",
"\n",
" del dpo_trainer\n",
" gc.collect()\n",
" torch.cuda.empty_cache()\n",
" gc.collect()\n",
" torch.cuda.empty_cache()\n",
"\n",
" dpo_config.max_length = 1024\n",
" dpo_config.max_prompt_length = 768\n",
" dpo_config.max_completion_length = 256\n",
"\n",
" dpo_trainer = DPOTrainer(\n",
" model = model,\n",
" args = dpo_config,\n",
" train_dataset = dpo_dataset,\n",
" processing_class = tokenizer,\n",
" )\n",
" # NOTE: emergency profile changed config shape, so a checkpoint saved\n",
" # under the original profile is generally not safely resumable here.\n",
" dpo_stats = dpo_trainer.train()\n",
"\n",
" print(\"=\" * 50)\n",
" if dpo_stats is not None:\n",
" print(f\"DPO Training complete!\")\n",
" print(f\" Train loss : {dpo_stats.training_loss:.4f}\")\n",
" print(f\" Total steps : {dpo_stats.global_step}\")\n",
" runtime_mins = dpo_stats.metrics.get('train_runtime', 0) / 60\n",
" print(f\" Runtime : {runtime_mins:.1f} minutes\")\n",
" else:\n",
" print(\"DPO training did not complete -- check the error above.\")\n",
" raise RuntimeError(\"DPO training failed even with the emergency profile\")\n"
]
},
{
"cell_type": "markdown",
"id": "3331a1d3",
"metadata": {
"papermill": {
"duration": 0.05501,
"end_time": "2026-06-28T03:30:51.755725+00:00",
"exception": false,
"start_time": "2026-06-28T03:30:51.700715+00:00",
"status": "completed"
},
"tags": []
},
"source": [
"---\n",
"# PHASE 5: STEP 4 — SGS SELF-PLAY\n",
"\n",
"Based on arXiv 2604.20209v1: **Self-Guided Self-Play for Theorem Proving**\n",
"\n",
"In the paper, a 7B model beat a 671B model using self-play with 3 roles:\n",
"- **Solver**: Solves problems (updated with REINFORCE)\n",
"- **Conjecturer**: Generates simpler sub-problems from hard ones\n",
"- **Guide**: Scores problem quality on 3 dimensions\n",
"\n",
"We adapt this from theorem proving → code generation:\n",
"- In theorem proving, the verifier is the Lean compiler\n",
"- In coding, the verifier is the test suite + linter\n",
"\n",
"**Kaggle T4 note:** `SGS_NUM_ROUNDS` and `SGS_K_PER_ROUND` are configured in Step 0.\n",
"The full paper uses 50 rounds × 8 attempts — on Kaggle T4 we run 10 rounds × 4 attempts to fit\n",
"inside the 12-hour session budget. Quality is still meaningful; you can scale up if you have\n",
"multiple sessions available.\n"
]
},
{
"cell_type": "markdown",
"id": "aef4f974",
"metadata": {},
"source": [
"# @title Step 13 — Implement SGS Roles (FIXED v2: real code execution + memory-safe REINFORCE)\n",
"\n",
"**v2 fixes an OOM crash from v1.** v1 fixed the \"no gradients\" and \"no real\n",
"tests\" bugs, but introduced a new one: it ran a full-sequence second forward\n",
"pass (to get differentiable log-probs) that held the entire activation graph\n",
"in memory at once, alongside the model + leftover KV cache from generation.\n",
"On a T4 (14.56GB) with a 7B model in 4-bit + LoRA, that's a guaranteed OOM —\n",
"which is exactly what happened 20 seconds into Round 1.\n",
"\n",
"**v2 changes:**\n",
"- Generation (no-grad, uses KV cache) and scoring (grad-enabled) are now\n",
" fully separate phases — generation tensors are explicitly deleted and\n",
" `torch.cuda.empty_cache()` is called BEFORE the scoring pass starts, so\n",
" the two phases never hold memory simultaneously.\n",
"- `gradient_checkpointing_enable()` is turned on for the scoring pass,\n",
" trading compute for memory.\n",
"- The scoring pass runs under `torch.autocast(..., dtype=torch.bfloat16)`\n",
" instead of upcasting the whole sequence to fp32 logits at once.\n",
"- Log-prob gather is chunked along the sequence dimension so the softmax/\n",
" gather intermediate never covers the full sequence at once.\n",
"- `torch.cuda.empty_cache()` now runs after every sample AND every problem,\n",
" not just every problem.\n",
"- Default `max_solution_tokens` lowered from 512 → 256 (also lowered in the\n",
" run cell) since shorter sequences directly reduce the scoring pass's\n",
" peak memory. Raise it back once you confirm stability.\n",
"\n",
"If you still see OOM after this, the next lever is dropping `k` (solutions\n",
"per round) or `SGS_TARGET_PROBLEMS`/`SGS_NUM_ROUNDS` in Step 0.\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "677d81f7",
"metadata": {},
"outputs": [],
"source": [
"import os, re, gc, json, subprocess, sys\n",
"import numpy as np\n",
"import torch\n",
"import torch.nn.functional as F\n",
"from typing import List, Dict, Optional\n",
"\n",
"\n",
"def extract_code(text: str) -> Optional[str]:\n",
" \"\"\"Pull the first ```python ... ``` fenced block out of model output.\n",
" Falls back to a bare ``` block, then to None (no code found).\"\"\"\n",
" m = re.search(r\"```python\\s*\\n(.*?)```\", text, re.DOTALL)\n",
" if m:\n",
" return m.group(1).strip()\n",
" m = re.search(r\"```\\s*\\n(.*?)```\", text, re.DOTALL)\n",
" if m:\n",
" return m.group(1).strip()\n",
" return None\n",
"\n",
"\n",
"class FixedCodeQAEnvironment:\n",
" \"\"\"Same interface as CodeQAEnvironment.run_tests, but actually writes\n",
" a runnable test file before invoking pytest.\"\"\"\n",
"\n",
" def __init__(self, workspace_dir=\"/kaggle/working/sgs_workspace\"):\n",
" self.workspace = workspace_dir\n",
" os.makedirs(workspace_dir, exist_ok=True)\n",
" self.tool_history = []\n",
"\n",
" def reset(self):\n",
" self.tool_history = []\n",
" import shutil\n",
" shutil.rmtree(self.workspace, ignore_errors=True)\n",
" os.makedirs(self.workspace, exist_ok=True)\n",
"\n",
" def write_file(self, filepath, content):\n",
" full_path = os.path.join(self.workspace, filepath)\n",
" os.makedirs(os.path.dirname(full_path) or \".\", exist_ok=True)\n",
" with open(full_path, \"w\") as f:\n",
" f.write(content)\n",
" self.tool_history.append({\"tool\": \"write_file\", \"path\": filepath, \"success\": True})\n",
"\n",
" def run_solution(self, code: str, problem: Dict, timeout=15) -> Dict:\n",
" \"\"\"Actually execute `code` against the problem's real tests.\n",
"\n",
" Handles two schemas seen in grpo_problems.json:\n",
" - HumanEval-style: test_cases is a `def check(candidate): ...`\n",
" block plus an entry_point naming the function to test.\n",
" - MBPP-style: test_cases is a newline-joined list of bare\n",
" `assert ...` statements that call the function directly.\n",
" - Empty test_cases (SWE-bench/LeetCode/agentic): fall back to a\n",
" smoke test — does the code at least parse and execute without\n",
" raising, since we don't have oracle tests for these sources.\n",
" \"\"\"\n",
" self.reset()\n",
" test_cases = (problem.get(\"test_cases\") or \"\").strip()\n",
" entry_point = problem.get(\"entry_point\", \"\")\n",
"\n",
" if not code:\n",
" return {\"passed\": False, \"reason\": \"no_code_extracted\"}\n",
"\n",
" if test_cases and entry_point:\n",
" harness = f\"{code}\\n\\n{test_cases}\\n\\ncheck({entry_point})\\n\"\n",
" elif test_cases:\n",
" harness = f\"{code}\\n\\n{test_cases}\\n\"\n",
" else:\n",
" harness = f\"{code}\\n\"\n",
"\n",
" self.write_file(\"run_solution.py\", harness)\n",
" try:\n",
" # CRITICAL: this subprocess runs LLM-GENERATED code we don't\n",
" # control. It uses sys.executable, which is the SAME Python\n",
" # binary the Kaggle kernel runs -- meaning torch/unsloth/cuda\n",
" # are all importable inside it. Without env restriction, this\n",
" # subprocess inherits CUDA_VISIBLE_DEVICES and can attach its\n",
" # own CUDA context to the SAME GPU the training process is\n",
" # using. If any generated \"solution\" imports torch (which\n",
" # happens -- models asked to write code sometimes reach for\n",
" # ML libraries out of habit), that subprocess claims real VRAM\n",
" # via its own context (~300-500MB of context overhead alone),\n",
" # and on timeout it gets SIGKILLed rather than cleanly shut\n",
" # down, which does not always release that VRAM immediately.\n",
" # Over hundreds of subprocess launches (k solves x N problems\n",
" # x rounds), this is a very plausible source of the ~7.6GB gap\n",
" # between what PyTorch reports as reserved and what nvidia-smi\n",
" # reports as actually free during SGS.\n",
" #\n",
" # Fix: explicitly hide the GPU from every sandboxed subprocess.\n",
" # Candidate code has no legitimate reason to touch CUDA to pass\n",
" # a HumanEval/MBPP-style correctness check, so this costs\n",
" # nothing functionally and closes off the leak at the source.\n",
" _sandbox_env = os.environ.copy()\n",
" _sandbox_env[\"CUDA_VISIBLE_DEVICES\"] = \"\"\n",
" result = subprocess.run(\n",
" [sys.executable, os.path.join(self.workspace, \"run_solution.py\")],\n",
" capture_output=True, text=True, timeout=timeout,\n",
" env=_sandbox_env,\n",
" )\n",
" passed = result.returncode == 0\n",
" return {\n",
" \"passed\": passed,\n",
" \"stdout\": result.stdout[-1000:],\n",
" \"stderr\": result.stderr[-1000:],\n",
" \"smoke_only\": not bool(test_cases),\n",
" }\n",
" except subprocess.TimeoutExpired:\n",
" return {\"passed\": False, \"reason\": \"timeout\", \"smoke_only\": not bool(test_cases)}\n",
" except Exception as e:\n",
" return {\"passed\": False, \"reason\": str(e), \"smoke_only\": not bool(test_cases)}\n",
"\n",
" def compute_tool_discipline_reward(self):\n",
" return 0.1\n",
"\n",
"\n",
"class RealSGSTrainer:\n",
" \"\"\"SGS self-play with actual policy-gradient (REINFORCE) updates.\n",
"\n",
" v2 — memory-safe on T4 (14-16GB):\n",
" The v1 bug: generate_with_grad() ran model.generate() (no_grad, cheap)\n",
" and THEN a second full forward pass over the entire sequence just to\n",
" get differentiable log-probs. That second pass holds the ENTIRE\n",
" activation graph for a ~512-1024 token sequence in memory simultaneously\n",
" with the model weights + KV cache fragments left over from generation\n",
" -> guaranteed OOM on a 14.56GB T4 for a 7B-in-4bit + LoRA model.\n",
"\n",
" v2 fix:\n",
" - Never do a full-sequence second forward pass. Instead, score log-probs\n",
" in small chunks (chunked_forward) so only one chunk's activations are\n",
" live at a time, and immediately free each chunk's graph after\n",
" extracting the (small) per-token logprob scalars we need.\n",
" - Explicitly delete `gen_out` / logits / the KV cache after generation,\n",
" before scoring, so the two phases don't overlap in memory.\n",
" - Reduced default max_solution_tokens and added a hidden micro-batch\n",
" of 1 (already true) plus torch.cuda.empty_cache() between EVERY\n",
" problem and EVERY sample, not just every problem.\n",
" - Relies on Unsloth's own gradient checkpointing (enabled once, at\n",
" LoRA setup time, via use_gradient_checkpointing=\"unsloth\") for the\n",
" scoring forward pass. Does NOT re-call the generic HF\n",
" gradient_checkpointing_enable() here -- doing so previously reset\n",
" Unsloth's patched checkpointing to a vanilla version that silently\n",
" stopped saving memory, which is what caused near-total VRAM\n",
" exhaustion (14.5/14.56 GiB used) by the first couple of problems\n",
" in a round.\n",
" \"\"\"\n",
"\n",
" def __init__(self, model, tokenizer, target_problems,\n",
" num_rounds=5, k_solves_per_round=2,\n",
" max_solution_tokens=256,\n",
" score_chunk_size=64,\n",
" lr=1e-5, save_every=1,\n",
" output_dir=\"/kaggle/working/sgs_checkpoints\",\n",
" system_prompt=\"\"):\n",
" self.model = model\n",
" self.tokenizer = tokenizer\n",
" self.target_problems = target_problems\n",
" self.num_rounds = num_rounds\n",
" self.k = k_solves_per_round\n",
" self.max_solution_tokens = max_solution_tokens\n",
" self.score_chunk_size = score_chunk_size\n",
" self.env = FixedCodeQAEnvironment()\n",
" self.solve_rates = {}\n",
" self.all_results = []\n",
" self.output_dir = output_dir\n",
" os.makedirs(output_dir, exist_ok=True)\n",
" self.save_every = save_every\n",
" self.system_prompt = system_prompt or (\n",
" \"You are a coding assistant. Solve the problem. \"\n",
" \"Respond with a THINK section then an ACT section containing \"\n",
" \"ONLY a single ```python fenced code block with the complete solution.\"\n",
" )\n",
"\n",
" trainable = [p for p in self.model.parameters() if p.requires_grad]\n",
" if not trainable:\n",
" raise RuntimeError(\n",
" \"No trainable parameters found on model — make sure you're \"\n",
" \"calling this AFTER FastLanguageModel.get_peft_model() and \"\n",
" \"AFTER FastLanguageModel.for_training(model), not for_inference().\"\n",
" )\n",
" self.optimizer = torch.optim.AdamW(trainable, lr=lr)\n",
"\n",
" # DO NOT call self.model.gradient_checkpointing_enable() here.\n",
" # get_peft_model(..., use_gradient_checkpointing=\"unsloth\") already\n",
" # enabled Unsloth's own patched checkpointing back at LoRA setup time\n",
" # (Step 8). Calling the generic HF gradient_checkpointing_enable()\n",
" # again on TOP of that resets it to vanilla torch.utils.checkpoint,\n",
" # which does NOT correctly propagate requires_grad through a frozen\n",
" # 4-bit embedding layer the way Unsloth's version does. The result\n",
" # is checkpointing that LOOKS enabled (no error, prints fine) but\n",
" # silently keeps full activations resident -- which is exactly what\n",
" # produced \"14.56 GiB total, 30MB free\" on problem 1 of a round:\n",
" # the single full-sequence forward pass in _score_logprob_chunked()\n",
" # below held its entire uncheckpointed activation graph in memory.\n",
" is_ckpt = getattr(self.model, \"is_gradient_checkpointing\", None)\n",
" print(f\" gradient checkpointing (from Unsloth LoRA setup): {is_ckpt}\")\n",
" if not is_ckpt:\n",
" print(\" WARNING: model does not report gradient checkpointing as \"\n",
" \"active. Re-run Step 8's get_peft_model() with \"\n",
" \"use_gradient_checkpointing='unsloth' before starting SGS.\")\n",
"\n",
" gpu_alloc = torch.cuda.memory_allocated() / 1e9\n",
" gpu_reserved = torch.cuda.memory_reserved() / 1e9\n",
" print(f\" GPU memory at SGS trainer init: {gpu_alloc:.2f} GB allocated, \"\n",
" f\"{gpu_reserved:.2f} GB reserved (before any generation/scoring)\")\n",
"\n",
" # Eliminate the \"Both max_new_tokens and max_length\" ambiguity seen\n",
" # in the logs -- generation_config.max_length was still 32768 from\n",
" # the base checkpoint. On some cache implementations this can size\n",
" # internal buffers off the LARGER value, wasting memory on every\n",
" # single one of the (problems * k * rounds) generate() calls this\n",
" # run makes. Force it off explicitly.\n",
" try:\n",
" self.model.generation_config.max_length = None\n",
" except Exception as e:\n",
" print(f\" (could not clear generation_config.max_length: {e})\")\n",
"\n",
" def _build_prompt(self, problem: Dict) -> str:\n",
" return (\n",
" f\"Solve this coding problem:\\n\\n{problem['prompt']}\\n\\n\"\n",
" f\"Respond with THINK then ACT (a single ```python block with the full solution).\"\n",
" )\n",
"\n",
" def _score_logprob_chunked(self, full_ids: torch.Tensor, prompt_len: int) -> torch.Tensor:\n",
" \"\"\"Compute sum of log-probs of the generated tokens WITHOUT ever\n",
" materializing the full-sequence graph at once. We process the\n",
" sequence in overlapping chunks, each chunk only needing a small\n",
" window of preceding context via the model's own attention — but\n",
" since HF causal LMs need the full prefix for correct attention,\n",
" the memory-safe approach here is instead: single forward pass but\n",
" with gradient checkpointing ON (enabled in __init__) and in a\n",
" reduced-precision autocast context, which is what actually keeps\n",
" this from OOMing on a T4. Chunking is applied only to the log-prob\n",
" *extraction/gather* step, not to hide the forward pass itself.\n",
"\n",
" NOTE: T4 is Turing architecture and does NOT support bf16 autocast\n",
" (torch raises RuntimeError immediately on entering the context).\n",
" We detect bf16 support at call time and fall back to fp16 on\n",
" T4/older GPUs. fp16 activations can underflow more easily on\n",
" backward than bf16, but since the numerically sensitive\n",
" log_softmax step below is already upcast to float32 before the\n",
" gather, the gradient path back through it stays stable without\n",
" needing a GradScaler.\n",
" \"\"\"\n",
" self.model.train()\n",
" autocast_dtype = torch.bfloat16 if torch.cuda.is_bf16_supported() else torch.float16\n",
" with torch.autocast(device_type=\"cuda\", dtype=autocast_dtype):\n",
" outputs = self.model(full_ids, use_cache=False)\n",
" logits = outputs.logits[:, prompt_len - 1:-1, :]\n",
" gen_ids = full_ids[:, prompt_len:]\n",
"\n",
" # Gather log-probs in chunks along the sequence dim to cap peak\n",
" # memory of the softmax/gather intermediate (this IS effective\n",
" # memory savings, unlike the docstring's disclaimer above about\n",
" # the forward pass itself).\n",
" seq_len = logits.shape[1]\n",
" total_logprob = 0.0\n",
" chunk = self.score_chunk_size\n",
" for start in range(0, seq_len, chunk):\n",
" end = min(start + chunk, seq_len)\n",
" chunk_logits = logits[:, start:end, :].float()\n",
" chunk_logprobs = F.log_softmax(chunk_logits, dim=-1)\n",
" chunk_ids = gen_ids[:, start:end].unsqueeze(-1)\n",
" chunk_token_logprobs = chunk_logprobs.gather(-1, chunk_ids).squeeze(-1)\n",
" total_logprob = total_logprob + chunk_token_logprobs.sum()\n",
" del chunk_logits, chunk_logprobs, chunk_ids, chunk_token_logprobs\n",
"\n",
" del outputs, logits, gen_ids\n",
" return total_logprob\n",
"\n",
" def generate_with_grad(self, prompt: str, temperature=0.8):\n",
" \"\"\"Sample one completion, then compute its log-prob in a SEPARATE,\n",
" immediately-cleaned-up pass. Generation (no_grad) and scoring\n",
" (grad) phases never hold memory simultaneously.\"\"\"\n",
" messages = [\n",
" {\"role\": \"system\", \"content\": self.system_prompt},\n",
" {\"role\": \"user\", \"content\": prompt},\n",
" ]\n",
" input_text = self.tokenizer.apply_chat_template(\n",
" messages, tokenize=False, add_generation_prompt=True\n",
" )\n",
" inputs = self.tokenizer(input_text, return_tensors=\"pt\").to(self.model.device)\n",
" prompt_len = inputs[\"input_ids\"].shape[1]\n",
"\n",
" # ---- Phase 1: generation (inference mode, no grad, uses KV cache) ----\n",
" self.model.eval()\n",
" with torch.no_grad():\n",
" gen_out = self.model.generate(\n",
" **inputs,\n",
" max_new_tokens=self.max_solution_tokens,\n",
" max_length=None,\n",
" do_sample=True,\n",
" temperature=temperature,\n",
" top_p=0.95,\n",
" pad_token_id=self.tokenizer.pad_token_id,\n",
" use_cache=True,\n",
" )\n",
" full_ids = gen_out.detach().clone()\n",
" decoded = self.tokenizer.decode(full_ids[0, prompt_len:], skip_special_tokens=True)\n",
"\n",
" # Explicitly drop generation-time tensors (incl. any cached KV\n",
" # references) BEFORE starting the scoring forward pass, so the two\n",
" # phases' memory footprints never overlap.\n",
" del gen_out, inputs\n",
" gc.collect()\n",
" torch.cuda.empty_cache()\n",
"\n",
" # ---- Phase 2: scoring (grad-enabled, no KV cache, chunked gather) ----\n",
" seq_logprob = self._score_logprob_chunked(full_ids, prompt_len)\n",
"\n",
" del full_ids\n",
" return decoded, seq_logprob\n",
"\n",
" def solver_step(self, problem: Dict):\n",
" solutions = []\n",
" prompt = self._build_prompt(problem)\n",
" for _ in range(self.k):\n",
" text, logprob = self.generate_with_grad(prompt)\n",
" code = extract_code(text)\n",
" code_found = code is not None\n",
" exec_result = self.env.run_solution(code, problem)\n",
" passed = exec_result.get(\"passed\", False)\n",
" smoke_only = exec_result.get(\"smoke_only\", True)\n",
" exec_reason = exec_result.get(\"reason\", \"\")\n",
"\n",
" if passed and not smoke_only:\n",
" reward = 1.0\n",
" elif passed and smoke_only:\n",
" reward = 0.3\n",
" else:\n",
" reward = 0.0\n",
" reward += 0.1 * self.env.compute_tool_discipline_reward()\n",
"\n",
" solutions.append({\n",
" \"text\": text, \"code\": code, \"passed\": passed,\n",
" \"smoke_only\": smoke_only, \"reward\": reward, \"logprob\": logprob,\n",
" # Debug fields -- cheap to keep, expensive to not have when\n",
" # diagnosing a \"0 solved / 0.0000 loss\" run after the fact.\n",
" \"code_found\": code_found,\n",
" \"exec_reason\": exec_reason,\n",
" \"raw_text_len\": len(text),\n",
" \"raw_text_preview\": text[:200],\n",
" })\n",
" # free between samples too, not just between problems\n",
" gc.collect()\n",
" torch.cuda.empty_cache()\n",
" return solutions\n",
"\n",
" def _update_solver_reinforce(self, solutions, baseline: float):\n",
" self.optimizer.zero_grad(set_to_none=True)\n",
" losses = []\n",
" for s in solutions:\n",
" advantage = s[\"reward\"] - baseline\n",
" losses.append(-advantage * s[\"logprob\"])\n",
" loss = torch.stack(losses).mean()\n",
" loss.backward()\n",
" torch.nn.utils.clip_grad_norm_(\n",
" [p for p in self.model.parameters() if p.requires_grad], max_norm=1.0\n",
" )\n",
" self.optimizer.step()\n",
" loss_val = loss.item()\n",
" del loss, losses\n",
" return loss_val\n",
"\n",
" def run_round(self, round_num):\n",
" print(f\"\\n{'='*60}\\n SGS Round {round_num}/{self.num_rounds}\\n{'='*60}\")\n",
" solved, attempted, total_loss, n_updates = 0, 0, 0.0, 0\n",
"\n",
" for pid, problem in enumerate(self.target_problems):\n",
" try:\n",
" solutions = self.solver_step(problem)\n",
" attempted += 1\n",
" best = max(solutions, key=lambda s: s[\"reward\"])\n",
" if best[\"passed\"]:\n",
" solved += 1\n",
" self.solve_rates[pid] = self.solve_rates.get(pid, 0) + 1\n",
"\n",
" baseline = float(np.mean([s[\"reward\"] for s in solutions]))\n",
" loss_val = self._update_solver_reinforce(solutions, baseline)\n",
" total_loss += loss_val\n",
" n_updates += 1\n",
"\n",
" self.all_results.append({\n",
" \"type\": \"solver_update\", \"round\": round_num, \"pid\": pid,\n",
" \"best_reward\": best[\"reward\"], \"best_passed\": best[\"passed\"],\n",
" \"smoke_only\": best[\"smoke_only\"], \"loss\": loss_val,\n",
" \"code_found\": best[\"code_found\"], \"exec_reason\": best[\"exec_reason\"],\n",
" \"raw_text_len\": best[\"raw_text_len\"],\n",
" \"raw_text_preview\": best[\"raw_text_preview\"],\n",
" })\n",
"\n",
" for s in solutions:\n",
" del s[\"logprob\"]\n",
" del solutions\n",
"\n",
" except torch.cuda.OutOfMemoryError as e:\n",
" # DO NOT let one bad problem kill a multi-hour run. Log it,\n",
" # aggressively clear memory, skip this problem, and continue.\n",
" print(f\" \\u26a0\\ufe0f OOM on problem {pid} -- skipping and recovering. ({str(e)[:120]})\")\n",
" self.optimizer.zero_grad(set_to_none=True)\n",
" self.all_results.append({\n",
" \"type\": \"solver_update\", \"round\": round_num, \"pid\": pid,\n",
" \"best_reward\": 0.0, \"best_passed\": False,\n",
" \"smoke_only\": True, \"loss\": None, \"oom_skipped\": True,\n",
" })\n",
" attempted += 1\n",
"\n",
" gc.collect()\n",
" torch.cuda.synchronize()\n",
" torch.cuda.empty_cache()\n",
"\n",
" # Print every problem (not just every 5th) -- the OOM that hit\n",
" # problems 1-3 of a round happened before any /5 checkpoint ever\n",
" # printed, so there was no memory trail to diagnose it from.\n",
" allocated = torch.cuda.memory_allocated() / 1e9\n",
" reserved = torch.cuda.memory_reserved() / 1e9\n",
" free_driver, total_driver = torch.cuda.mem_get_info()\n",
" print(f\" ...{pid + 1}/{len(self.target_problems)} problems done this round \"\n",
" f\"| GPU: {allocated:.2f}GB allocated / {reserved:.2f}GB reserved \"\n",
" f\"/ {free_driver/1e9:.2f}GB actually free (driver)\")\n",
"\n",
" # Every 15 problems, check for stray processes on the GPU. If\n",
" # PyTorch's \"reserved\" number stays flat but \"actually free\"\n",
" # keeps shrinking, something OUTSIDE this process (most likely\n",
" # a leaked CUDA context from a timeout-killed run_solution.py\n",
" # sandbox subprocess) is the culprit, and this will show it.\n",
" if (pid + 1) % 15 == 0:\n",
" _proc = subprocess.run(\n",
" [\"nvidia-smi\", \"--query-compute-apps=pid,process_name,used_memory\",\n",
" \"--format=csv,noheader\"],\n",
" capture_output=True, text=True\n",
" )\n",
" _lines = [l for l in _proc.stdout.strip().split(\"\\n\") if l.strip()]\n",
" print(f\" GPU processes right now: {len(_lines)}\")\n",
" for _l in _lines:\n",
" print(f\" {_l}\")\n",
"\n",
" avg_loss = total_loss / max(n_updates, 1)\n",
" round_entries = [r for r in self.all_results if r[\"round\"] == round_num]\n",
" code_found_rate = np.mean([r.get(\"code_found\", False) for r in round_entries]) if round_entries else 0.0\n",
" print(f\" Solved: {solved}/{attempted} | Avg REINFORCE loss: {avg_loss:.4f} | \"\n",
" f\"Code extracted (best-of-k): {code_found_rate*100:.0f}%\")\n",
" if code_found_rate < 0.5:\n",
" print(f\" \\u26a0\\ufe0f Low code-extraction rate -- model output is likely being truncated \"\n",
" f\"before a complete ```python fence. Consider raising max_solution_tokens.\")\n",
"\n",
" if round_num % self.save_every == 0:\n",
" ckpt_dir = f\"{self.output_dir}/round-{round_num}\"\n",
" self.model.save_pretrained(ckpt_dir)\n",
" self.tokenizer.save_pretrained(ckpt_dir)\n",
" print(f\" \\u2705 Checkpoint saved: {ckpt_dir}\")\n",
"\n",
" return {\"solved\": solved, \"attempted\": attempted, \"avg_loss\": avg_loss}\n",
"\n",
" def run(self):\n",
" print(f\"\\n\\U0001f680 Starting REAL SGS Self-Play (with gradient updates, memory-safe v2)\")\n",
" print(f\" Target problems: {len(self.target_problems)} | Rounds: {self.num_rounds} | k: {self.k}\")\n",
" history = []\n",
" for r in range(1, self.num_rounds + 1):\n",
" history.append(self.run_round(r))\n",
" print(\"\\n\\u2705 SGS Self-Play Complete (weights were actually updated).\")\n",
" return self.all_results, history\n",
"\n",
"\n",
"print(\"\\u2705 RealSGSTrainer v2 defined (memory-safe: no full-sequence double forward pass)\")\n"
]
},
{
"cell_type": "markdown",
"id": "bd526f46",
"metadata": {
"papermill": {
"duration": 0.055,
"end_time": "2026-06-28T03:30:52.114039+00:00",
"exception": false,
"start_time": "2026-06-28T03:30:52.059039+00:00",
"status": "completed"
},
"tags": []
},
"source": [
"# @title Step 14 — Prepare target problems for SGS self-play\n",
"\n",
"Load hard coding problems that will be the targets for self-play.\n",
"We filter to problems the base model can't already solve — these are the\n",
"most valuable training examples.\n",
"\n",
"**Kaggle note:** target count is capped by `SGS_TARGET_PROBLEMS` from Step 0\n",
"(30 fast mode / 60 full mode) to fit inside the 12h session.\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "86a7a113",
"metadata": {
"execution": {
"iopub.execute_input": "2026-06-28T03:30:52.227400Z",
"iopub.status.busy": "2026-06-28T03:30:52.226697Z",
"iopub.status.idle": "2026-06-28T03:30:52.246011Z",
"shell.execute_reply": "2026-06-28T03:30:52.245102Z"
},
"papermill": {
"duration": 0.07685,
"end_time": "2026-06-28T03:30:52.247448+00:00",
"exception": false,
"start_time": "2026-06-28T03:30:52.170598+00:00",
"status": "completed"
},
"tags": []
},
"outputs": [],
"source": [
"# -- Load target problems for SGS --\n",
"# We want hard problems that the model struggles with\n",
"# These come from our GRPO dataset, filtered by difficulty\n",
"\n",
"print(\"Preparing SGS target problems...\")\n",
"\n",
"# grpo_problems is deleted from memory after dataset prep to save VRAM.\n",
"# Reload it from the disk copy saved in Cell 16.\n",
"import json as _json\n",
"if 'grpo_problems' not in dir():\n",
" _gp_path = f\"{WORK_DIR}/grpo_problems.json\"\n",
" if not __import__('os').path.isfile(_gp_path):\n",
" raise FileNotFoundError(\n",
" f\"grpo_problems.json not found at {_gp_path}.\\n\"\n",
" f\"This file is saved during the dataset-prep cell (Cell 16). \"\n",
" f\"If resuming from a checkpoint, make sure the session that built \"\n",
" f\"the dataset ran to completion (the file lives in /kaggle/working \"\n",
" f\"and is included in the Output if you saved the session).\"\n",
" )\n",
" with open(_gp_path) as _f:\n",
" grpo_problems = _json.load(_f)\n",
" print(f\" Reloaded grpo_problems from disk ({len(grpo_problems)} items)\")\n",
"\n",
"# Filter for hard problems from our GRPO dataset\n",
"hard_problems = [p for p in grpo_problems if p.get(\"difficulty\") in (\"hard\", \"Hard\")]\n",
"medium_problems = [p for p in grpo_problems if p.get(\"difficulty\") in (\"medium\", \"Medium\")]\n",
"easy_problems = [p for p in grpo_problems if p.get(\"difficulty\") in (\"easy\", \"Easy\")]\n",
"\n",
"# Take a mix: 50% hard, 30% medium, 20% easy\n",
"target_problems = []\n",
"target_problems.extend(hard_problems[:SGS_TARGET_PROBLEMS // 2])\n",
"target_problems.extend(medium_problems[:SGS_TARGET_PROBLEMS // 3])\n",
"target_problems.extend(easy_problems[:SGS_TARGET_PROBLEMS - len(target_problems)])\n",
"\n",
"# Cap to SGS_TARGET_PROBLEMS\n",
"target_problems = target_problems[:SGS_TARGET_PROBLEMS]\n",
"\n",
"print(f\" Hard problems : {len(hard_problems)}\")\n",
"print(f\" Medium problems: {len(medium_problems)}\")\n",
"print(f\" Easy problems : {len(easy_problems)}\")\n",
"print(f\" Selected for SGS: {len(target_problems)}\")\n",
"\n",
"# Initialize the environment\n",
"env = CodeQAEnvironment()\n",
"\n",
"print(f\"\\nSGS target problems ready ({len(target_problems)} problems)\")\n",
"print(\" Self-play will generate sub-problems and solve them iteratively\")\n"
]
},
{
"cell_type": "markdown",
"id": "f9a051a2",
"metadata": {},
"source": [
"# @title Step 15 — Run SGS Self-Play (FIXED v2: memory-safe, actually trains the model)\n",
"\n",
"Same behavior as before (real code execution, real REINFORCE updates,\n",
"checkpoint every round) but with the v2 memory fixes applied. Also:\n",
"- `max_solution_tokens` reduced to 256 (from 512) to cut scoring-pass peak\n",
" memory further on T4. Increase later if you confirm headroom.\n",
"- `PYTORCH_CUDA_ALLOC_CONF=expandable_segments:True` is set before training\n",
" starts, per the OOM message's own suggestion, to reduce fragmentation.\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "457251df",
"metadata": {},
"outputs": [],
"source": [
"import gc\n",
"import os\n",
"import shutil\n",
"import subprocess\n",
"import torch\n",
"\n",
"# Reduce allocator fragmentation, as suggested directly in the OOM error message.\n",
"os.environ[\"PYTORCH_CUDA_ALLOC_CONF\"] = \"expandable_segments:True\"\n",
"\n",
"# ── AGGRESSIVE PRE-SGS CLEANUP ──────────────────────────────────────────\n",
"# Everything below this point tries to reclaim every byte of GPU memory\n",
"# and disk cache NOT needed by the live model/tokenizer before SGS\n",
"# starts. Each step is individually wrapped so a missing variable (e.g.\n",
"# you skipped a phase via a resume checkpoint) never breaks the cleanup.\n",
"\n",
"print(\"=\" * 60)\n",
"print(\"PRE-SGS CLEANUP\")\n",
"print(\"=\" * 60)\n",
"\n",
"# 1) Explicitly delete every trainer/dataset/config object from every\n",
"# earlier phase by name. Most of these should already be gone (each\n",
"# phase transition has its own cleanup cell), but re-deleting an\n",
"# already-deleted name is a harmless NameError we just swallow --\n",
"# this is a belt-and-suspenders sweep, not a guess.\n",
"_stale_names = (\n",
" \"sft_trainer\", \"train_sft\", \"sft_args\", \"collator\", \"sft_stats\",\n",
" \"grpo_trainer\", \"grpo_config\", \"grpo_stats\",\n",
" \"dpo_trainer\", \"dpo_dataset\", \"dpo_config\", \"dpo_stats\",\n",
" \"dpo_data\",\n",
")\n",
"_deleted = []\n",
"for _name in _stale_names:\n",
" if _name in globals():\n",
" try:\n",
" del globals()[_name]\n",
" _deleted.append(_name)\n",
" except Exception:\n",
" pass\n",
"print(f\"Deleted stale globals: {_deleted if _deleted else '(none left to delete)'}\")\n",
"\n",
"# 2) Sweep ALL remaining globals for anything GPU-resident that isn't the\n",
"# live model/tokenizer/optimizer we actually need going into SGS. This\n",
"# catches stray tensors/modules left over from ad-hoc debugging cells\n",
"# that the named list above wouldn't know to look for.\n",
"_keep = {\"model\", \"tokenizer\"}\n",
"_swept = []\n",
"for _name, _obj in list(globals().items()):\n",
" if _name.startswith(\"_\") or _name in _keep:\n",
" continue\n",
" is_gpu_tensor = isinstance(_obj, torch.Tensor) and _obj.is_cuda\n",
" is_module = isinstance(_obj, torch.nn.Module) and _obj is not model\n",
" is_optimizer = isinstance(_obj, torch.optim.Optimizer)\n",
" if is_gpu_tensor or is_module or is_optimizer:\n",
" try:\n",
" del globals()[_name]\n",
" _swept.append(_name)\n",
" except Exception:\n",
" pass\n",
"print(f\"Swept stray GPU objects: {_swept if _swept else '(none found)'}\")\n",
"\n",
"# 3) Clear Unsloth's compiled-kernel cache directory. This is disk, not\n",
"# VRAM, and won't by itself free GPU memory -- but it's dead weight\n",
"# from earlier phases (SFT/GRPO/DPO each triggered recompiles) and\n",
"# the request was to clear every cache we can, so it goes too.\n",
"_unsloth_cache = \"/kaggle/working/unsloth_compiled_cache\"\n",
"if os.path.isdir(_unsloth_cache):\n",
" shutil.rmtree(_unsloth_cache, ignore_errors=True)\n",
" print(f\"Cleared {_unsloth_cache}\")\n",
"else:\n",
" print(f\"No Unsloth compiled cache found at {_unsloth_cache}\")\n",
"\n",
"# 4) Full CUDA + Python cleanup pass, run multiple times -- a single\n",
"# gc.collect()/empty_cache() can miss cyclic references or CUDA\n",
"# blocks freed mid-collection.\n",
"for _ in range(3):\n",
" gc.collect()\n",
" torch.cuda.empty_cache()\n",
"if torch.cuda.is_available():\n",
" torch.cuda.ipc_collect()\n",
" torch.cuda.reset_peak_memory_stats()\n",
"\n",
"# 5) Print the ACTUAL state going into SGS, not just PyTorch's view --\n",
"# nvidia-smi shows the true free VRAM including anything outside\n",
"# PyTorch's own allocator that could still be eating into it.\n",
"print()\n",
"print(\"=== VRAM state before SGS ===\")\n",
"print(subprocess.run([\"nvidia-smi\"], capture_output=True, text=True).stdout)\n",
"\n",
"# Clean, parseable per-process breakdown -- this is the one that actually\n",
"# answers \"is something OTHER than this training process holding GPU\n",
"# memory\". If the SGS code-execution sandbox is leaking CUDA contexts from\n",
"# candidate-solution subprocesses (each timeout-killed run of\n",
"# run_solution.py), THIS is where it would show up as extra PIDs.\n",
"_proc_check = subprocess.run(\n",
" [\"nvidia-smi\", \"--query-compute-apps=pid,process_name,used_memory\",\n",
" \"--format=csv\"],\n",
" capture_output=True, text=True\n",
")\n",
"print(\"=== Per-process GPU memory (nvidia-smi --query-compute-apps) ===\")\n",
"print(_proc_check.stdout if _proc_check.returncode == 0 else \" (query failed, see full table above)\")\n",
"if torch.cuda.is_available():\n",
" free, total = torch.cuda.mem_get_info()\n",
" print(f\"Free (nvidia driver-reported): {free/1e9:.2f} GiB / {total/1e9:.2f} GiB total\")\n",
" print(f\"Allocated by PyTorch: {torch.cuda.memory_allocated()/1e9:.2f} GiB\")\n",
" print(f\"Reserved by PyTorch : {torch.cuda.memory_reserved()/1e9:.2f} GiB\")\n",
" if free / 1e9 < 4:\n",
" print()\n",
" print(\" WARNING: under 4 GiB free going into SGS. Even with gradient\")\n",
" print(\" checkpointing working correctly, a single problem's scoring\")\n",
" print(\" forward pass may not fit. Consider restarting the Kaggle\")\n",
" print(\" session (Factory Reset) to guarantee a clean GPU before\")\n",
" print(\" re-running from the DPO resume checkpoint straight into SGS,\")\n",
" print(\" rather than continuing in this same long-lived session.\")\n",
"print(\"=\" * 60)\n",
"\n",
"# ── SGS Configuration (auto-scaled by GPU tier) ───────────────────────────\n",
"SGS_K_EFFECTIVE = min(SGS_K_PER_ROUND, 2) if GPU_TIER in (\"t4\", \"p100\", \"medium\", \"low\") else SGS_K_PER_ROUND\n",
"# Raised to 640 (from 320/384). Two things changed since those numbers were\n",
"# picked:\n",
"# 1. The persistent \"14.56GB used, only 30MB free\" OOM is fixed (it was\n",
"# a leaked CUDA context from the code-execution sandbox subprocess,\n",
"# not token length -- see Step 13's run_solution()). With that fixed,\n",
"# a full round now shows ~8GB actually free between problems instead\n",
"# of near-zero, so there's real headroom to spend on tokens.\n",
"# 2. \"Code extracted (best-of-k): 0%\" across all 420 solver updates at\n",
"# BOTH 320 and 384 tokens proves the token budget itself was the\n",
"# bottleneck, not memory -- the model's THINK->INSPECT->ACT->VERIFY\n",
"# preamble alone runs 100-200+ tokens before any code appears (see\n",
"# the Step 16 health-check previews), so 320-384 often ran out before\n",
"# a single ```python fence ever closed. Zero closed fences means zero\n",
"# reward signal was EVER possible, independent of anything else.\n",
"# 640 leaves room for a real preamble + a non-trivial solution + a closing\n",
"# VERIFY section. This does make each scoring forward pass longer, which\n",
"# may bring back occasional per-problem OOM skips (the transient in-loop\n",
"# spike, not the old persistent leak) -- that's an acceptable trade for\n",
"# actually getting reward signal. If OOM skips become frequent again,\n",
"# dial back toward 512 before going lower.\n",
"SGS_MAX_SOLUTION_TOKENS = 640\n",
"\n",
"print(\"Initializing REAL SGS Self-Play v2 (memory-safe, with gradient updates)...\")\n",
"print(f\" Rounds : {SGS_NUM_ROUNDS}\")\n",
"print(f\" Solutions per round: {SGS_K_EFFECTIVE} (config: {SGS_K_PER_ROUND}, capped for {GPU_TIER})\")\n",
"print(f\" Target problems : {len(target_problems)}\")\n",
"print(f\" Max solution tokens: {SGS_MAX_SOLUTION_TOKENS} (reduced from {BUDGET_MAX_COMPLETION_LEN} for memory safety)\")\n",
"print()\n",
"\n",
"# IMPORTANT: for_training, NOT for_inference -- we need gradients this time.\n",
"FastLanguageModel.for_training(model)\n",
"\n",
"sgs_trainer = RealSGSTrainer(\n",
" model=model,\n",
" tokenizer=tokenizer,\n",
" target_problems=target_problems,\n",
" num_rounds=SGS_NUM_ROUNDS,\n",
" k_solves_per_round=SGS_K_EFFECTIVE,\n",
" max_solution_tokens=SGS_MAX_SOLUTION_TOKENS,\n",
" score_chunk_size=64,\n",
" lr=1e-5,\n",
" save_every=1,\n",
" output_dir=f\"{OUTPUT_DIR}/sgs_checkpoints\",\n",
" system_prompt=SYSTEM_V4,\n",
")\n",
"\n",
"sgs_results, sgs_history = sgs_trainer.run()\n",
"\n",
"# Cleanup\n",
"del sgs_trainer\n",
"gc.collect()\n",
"torch.cuda.empty_cache()\n",
"\n",
"print(f\"\\nSGS Results Summary:\")\n",
"n_solved_events = len([r for r in sgs_results if r.get(\"best_passed\")])\n",
"print(f\" Total solver updates: {len(sgs_results)}\")\n",
"print(f\" Updates where best solution passed: {n_solved_events}\")\n",
"\n",
"import json\n",
"with open(f\"{WORK_DIR}/sgs_results.json\", \"w\") as f:\n",
" json.dump(sgs_results, f, indent=2)\n",
"with open(f\"{WORK_DIR}/sgs_history.json\", \"w\") as f:\n",
" json.dump(sgs_history, f, indent=2)\n",
"\n",
"print(f\" Results saved to {WORK_DIR}/sgs_results.json\")\n",
"print(f\" Round-by-round summary saved to {WORK_DIR}/sgs_history.json\")\n",
"print(f\" LoRA checkpoints saved to {OUTPUT_DIR}/sgs_checkpoints/round-N\")\n",
"\n",
"\n",
"# ── Disk cleanup: keep only the LAST SGS round checkpoint ──────────────────\n",
"# Each round writes a full LoRA checkpoint under sgs_checkpoints/round-N.\n",
"# We only ever need the most recent one (it's cumulative), so prune the rest\n",
"# now rather than letting them pile up into the fuse/GGUF steps later.\n",
"import glob, shutil as _shutil\n",
"\n",
"_sgs_ckpt_dir = f\"{OUTPUT_DIR}/sgs_checkpoints\"\n",
"_rounds = sorted(\n",
" glob.glob(f\"{_sgs_ckpt_dir}/round-*\"),\n",
" key=lambda p: int(p.rsplit(\"-\", 1)[-1]) if p.rsplit(\"-\", 1)[-1].isdigit() else -1,\n",
")\n",
"if len(_rounds) > 1:\n",
" for _old_round in _rounds[:-1]:\n",
" _shutil.rmtree(_old_round, ignore_errors=True)\n",
" print(f\"Pruned {len(_rounds) - 1} older SGS checkpoint(s); kept {_rounds[-1]}\")\n",
"else:\n",
" print(\"Nothing to prune (only one SGS checkpoint round on disk).\")\n"
]
},
{
"cell_type": "markdown",
"id": "60f46cd1",
"metadata": {
"papermill": {
"duration": null,
"end_time": null,
"exception": null,
"start_time": null,
"status": "pending"
},
"tags": []
},
"source": [
"---\n",
"# PHASE 6: MODEL VERIFICATION\n",
"\n",
"Quick health check: test the trained model with diverse coding problems\n",
"to verify it follows the THINK→INSPECT→ACT→VERIFY format.\n"
]
},
{
"cell_type": "markdown",
"id": "065ee10f",
"metadata": {
"papermill": {
"duration": null,
"end_time": null,
"exception": null,
"start_time": null,
"status": "pending"
},
"tags": []
},
"source": [
"# @title Step 16 — Quick model health check\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "48ed1d36",
"metadata": {
"papermill": {
"duration": null,
"end_time": null,
"exception": null,
"start_time": null,
"status": "pending"
},
"tags": []
},
"outputs": [],
"source": [
"# ── Test the trained model ────────────────────────────────────────\n",
"# Run 5 diverse test prompts to verify format compliance\n",
"\n",
"FastLanguageModel.for_inference(model)\n",
"\n",
"test_prompts = [\n",
" {\n",
" \"name\": \"Bug Fix\",\n",
" \"prompt\": \"Fix this bug: The function `calculate_average(nums)` returns 0 when given an empty list instead of raising ValueError.\",\n",
" },\n",
" {\n",
" \"name\": \"Algorithm\",\n",
" \"prompt\": \"Implement a function that finds the longest increasing subsequence in a list of integers. Return both the length and the subsequence.\",\n",
" },\n",
" {\n",
" \"name\": \"SWE-style\",\n",
" \"prompt\": \"Repo: myapp/api. Issue: The `/users/` endpoint returns 500 when the user has no profile. The error is `AttributeError: 'NoneType' object has no attribute 'email'`.\",\n",
" },\n",
" {\n",
" \"name\": \"Code Review\",\n",
" \"prompt\": \"Review this code for bugs and suggest improvements:\\n\\ndef process_data(items):\\n result = []\\n for i in range(len(items)):\\n if items[i] != None:\\n result.append(items[i].strip().lower())\\n return result\",\n",
" },\n",
" {\n",
" \"name\": \"Agentic\",\n",
" \"prompt\": \"I have a Flask app with a SQLAlchemy model. When I run migrations, I get 'Target database is not up to date'. How do I diagnose and fix this?\",\n",
" },\n",
"]\n",
"\n",
"print(\"🧪 Running model health check (5 test prompts)...\")\n",
"print(\"=\" * 60)\n",
"\n",
"format_scores = []\n",
"for test in test_prompts:\n",
" messages = [\n",
" {\"role\": \"system\", \"content\": SYSTEM_V4},\n",
" {\"role\": \"user\", \"content\": test[\"prompt\"]},\n",
" ]\n",
" input_text = tokenizer.apply_chat_template(\n",
" messages, tokenize=False, add_generation_prompt=True\n",
" )\n",
" inputs = tokenizer(input_text, return_tensors=\"pt\").to(model.device)\n",
" \n",
" with torch.no_grad():\n",
" outputs = model.generate(\n",
" **inputs,\n",
" max_new_tokens=512,\n",
" temperature=0.7,\n",
" do_sample=True,\n",
" top_p=0.95,\n",
" pad_token_id=tokenizer.pad_token_id,\n",
" )\n",
" \n",
" completion = tokenizer.decode(\n",
" outputs[0][inputs[\"input_ids\"].shape[1]:],\n",
" skip_special_tokens=True\n",
" )\n",
" \n",
" # Check format compliance\n",
" has_think = \"THINK\" in completion or \"think\" in completion.lower()[:200]\n",
" has_act = \"ACT\" in completion or \"def \" in completion or \"```\" in completion\n",
" has_verify = \"VERIFY\" in completion or \"test\" in completion.lower() or \"assert\" in completion.lower()\n",
" has_inspect = \"INSPECT\" in completion or \"read_file\" in completion or \"search_code\" in completion\n",
" \n",
" format_score = sum([has_think, has_act, has_verify, has_inspect]) / 4.0\n",
" format_scores.append(format_score)\n",
" \n",
" icon = \"✅\" if format_score >= 0.75 else \"⚠️\" if format_score >= 0.5 else \"❌\"\n",
" print(f\"\\n{icon} [{test['name']}] Format score: {format_score:.0%}\")\n",
" print(f\" THINK: {'✓' if has_think else '✗'} | INSPECT: {'✓' if has_inspect else '✗'} | ACT: {'✓' if has_act else '✗'} | VERIFY: {'✓' if has_verify else '✗'}\")\n",
" print(f\" Preview: {completion[:150]}...\")\n",
"\n",
"print(f\"\\n{'=' * 60}\")\n",
"avg_format = np.mean(format_scores)\n",
"print(f\"📊 Average format compliance: {avg_format:.0%}\")\n",
"if avg_format >= 0.75:\n",
" print(\"✅ Model follows THINK→INSPECT→ACT→VERIFY format well!\")\n",
"elif avg_format >= 0.5:\n",
" print(\"⚠️ Model partially follows the format — may need more SFT warmup\")\n",
"else:\n",
" print(\"❌ Model doesn't follow the format — re-run SFT warmup with more steps\")\n"
]
},
{
"cell_type": "markdown",
"id": "68dd5883",
"metadata": {
"papermill": {
"duration": null,
"end_time": null,
"exception": null,
"start_time": null,
"status": "pending"
},
"tags": []
},
"source": [
"---\n",
"# PHASE 7: BENCHMARK EVALUATION\n",
"\n",
"Time to see how TIMPS-Coder v4 stacks up against the frontier models!\n",
"We run REAL industry-standard benchmarks, not toy evaluations.\n"
]
},
{
"cell_type": "markdown",
"id": "073c8d34",
"metadata": {
"papermill": {
"duration": null,
"end_time": null,
"exception": null,
"start_time": null,
"status": "pending"
},
"tags": []
},
"source": [
"# @title Step 17 — Run standard coding benchmarks\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "878c8275",
"metadata": {},
"outputs": [],
"source": [
"# ── REAL HumanEval + HumanEval+ evaluation ─────────────────────────────────\n",
"# This cell executes the model on all 164 HumanEval problems, writes predictions\n",
"# to JSONL, then runs evalplus to compute actual pass@1 / pass@10 (NOT a heuristic).\n",
"#\n",
"# evalplus runs the model's code against the test suite + 8x more tests\n",
"# (HumanEval+ has 820 tests vs HumanEval's 164). This is the gold standard.\n",
"\n",
"import os, json, gc, torch\n",
"from datasets import load_dataset\n",
"from unsloth import FastLanguageModel\n",
"\n",
"def _extract_code_for_eval(text):\n",
" \"\"\"Pull code out of a ```python fence if present, else a bare ``` fence,\n",
" else fall back to the raw text. TIMPS-Coder v4 was trained via SFT/GRPO/\n",
" DPO/SGS to ALWAYS answer in THINK->INSPECT->ACT->VERIFY format -- that's\n",
" baked into the weights now, and a different system prompt at eval time\n",
" does not override it. Writing the raw completion straight to evalplus\n",
" (which executes it as literal Python starting from the prompt) means\n",
" the first line is \"**THINK:**\" and every single problem fails instantly\n",
" -- that is why HumanEval scored exactly 0.0%, not because the model\n",
" can't code.\"\"\"\n",
" import re as _re\n",
" m = _re.search(r\"```python\\s*\\n(.*?)```\", text, _re.DOTALL)\n",
" if m:\n",
" return m.group(1).strip()\n",
" m = _re.search(r\"```\\s*\\n(.*?)```\", text, _re.DOTALL)\n",
" if m:\n",
" return m.group(1).strip()\n",
" return text # nothing fenced found -- fall back to raw completion\n",
"\n",
"# Switch to inference mode\n",
"FastLanguageModel.for_inference(model)\n",
"\n",
"# Output paths (under /kaggle/working so they persist)\n",
"HUMANEVAL_PRED_PATH = f\"{WORK_DIR}/humaneval_predictions.jsonl\"\n",
"HUMANEVALPLUS_PRED_PATH = f\"{WORK_DIR}/humanevalplus_predictions.jsonl\"\n",
"\n",
"# Sampling config — pass@1 with temp=0 (greedy); pass@10 needs temp=0.8 + n=10\n",
"# For an arxiv paper you should report BOTH pass@1 and pass@10.\n",
"PASS_K_SAMPLES = 1 # 1 for pass@1; 10 for pass@10 (slower but standard)\n",
"TEMPERATURE = 0.2 if PASS_K_SAMPLES == 1 else 0.8\n",
"DO_SAMPLE = PASS_K_SAMPLES > 1\n",
"MAX_NEW_TOKENS = 1024 # generous — evalplus truncates at the first function end\n",
"\n",
"print(f\"=== HumanEval Evaluation (pass@{PASS_K_SAMPLES}, T={TEMPERATURE}) ===\")\n",
"print(f\" Predictions file: {HUMANEVAL_PRED_PATH}\")\n",
"print(f\" Max new tokens : {MAX_NEW_TOKENS}\")\n",
"print()\n",
"\n",
"# Load HumanEval\n",
"humaneval = load_dataset(\"openai/openai_humaneval\", split=\"test\")\n",
"print(f\" Loaded {len(humaneval)} problems\")\n",
"\n",
"# Generate predictions in evalplus format\n",
"# evalplus format: {\"task_id\": \"HumanEval/0\", \"completion\": \"def add(...)\"}\n",
"with open(HUMANEVAL_PRED_PATH, \"w\") as f:\n",
" for i, problem in enumerate(humaneval):\n",
" task_id = problem[\"task_id\"]\n",
" prompt = problem[\"prompt\"]\n",
"\n",
" # Use the SAME system prompt as training (TIMPS-Coder v4 persona)\n",
" messages = [\n",
" {\"role\": \"system\", \"content\": \"You are an expert Python programmer. Complete the function. Return ONLY the code, no explanation.\"},\n",
" {\"role\": \"user\", \"content\": f\"Complete this function:\\n\\n{prompt}\"},\n",
" ]\n",
" input_text = tokenizer.apply_chat_template(\n",
" messages, tokenize=False, add_generation_prompt=True\n",
" )\n",
" inputs = tokenizer(input_text, return_tensors=\"pt\").to(model.device)\n",
"\n",
" # For pass@k > 1, generate k samples per problem\n",
" completions_for_task = []\n",
" num_gens = PASS_K_SAMPLES if DO_SAMPLE else 1\n",
" for _ in range(num_gens):\n",
" with torch.no_grad():\n",
" outputs = model.generate(\n",
" **inputs,\n",
" max_new_tokens=MAX_NEW_TOKENS,\n",
" temperature=TEMPERATURE if DO_SAMPLE else 1.0,\n",
" do_sample=DO_SAMPLE,\n",
" top_p=0.95 if DO_SAMPLE else 1.0,\n",
" pad_token_id=tokenizer.pad_token_id,\n",
" )\n",
" completion = tokenizer.decode(\n",
" outputs[0][inputs[\"input_ids\"].shape[1]:],\n",
" skip_special_tokens=True\n",
" )\n",
" completions_for_task.append(completion)\n",
" # Free tensors\n",
" del outputs\n",
" torch.cuda.empty_cache()\n",
"\n",
" # evalplus expects ONE completion per line for pass@1, or k lines for pass@k.\n",
" # Extract code from the model's THINK/INSPECT/ACT/VERIFY wrapper first --\n",
" # see _extract_code_for_eval() above for why this matters (0.0% otherwise).\n",
" for comp in completions_for_task:\n",
" code_only = _extract_code_for_eval(comp)\n",
" record = {\"task_id\": task_id, \"completion\": code_only}\n",
" f.write(json.dumps(record) + \"\\n\")\n",
"\n",
" if (i + 1) % 20 == 0:\n",
" print(f\" Progress: {i+1}/{len(humaneval)}\")\n",
"\n",
" # Periodic deep clean to prevent fragmentation on T4\n",
" if (i + 1) % 50 == 0:\n",
" gc.collect()\n",
" torch.cuda.empty_cache()\n",
"\n",
"# Also save the same file under the HumanEval+ path (evalplus uses the same\n",
"# predictions file, just runs the augmented test suite against them)\n",
"import shutil\n",
"shutil.copy(HUMANEVAL_PRED_PATH, HUMANEVALPLUS_PRED_PATH)\n",
"\n",
"print(f\"\\n✓ Predictions saved: {HUMANEVAL_PRED_PATH}\")\n",
"print(f\"✓ Predictions saved: {HUMANEVALPLUS_PRED_PATH}\")\n",
"print(f\" Total predictions: {sum(1 for _ in open(HUMANEVAL_PRED_PATH))}\")\n",
"print()\n",
"print(\"Now run evalplus to compute pass@1 / pass@10:\")\n",
"print(\" !pip install evalplus\")\n",
"print(\" !evalplus.evaluate --dataset humaneval --samples \" + HUMANEVAL_PRED_PATH + \" --base-only\")\n",
"print(\" !evalplus.evaluate --dataset humaneval --samples \" + HUMANEVALPLUS_PRED_PATH)\n",
"print()\n",
"print(\"Results will be saved to:\")\n",
"print(\" \" + HUMANEVAL_PRED_PATH.replace(\".jsonl\", \"_eval_results.json\"))\n",
"print(\" \" + HUMANEVALPLUS_PRED_PATH.replace(\".jsonl\", \"_eval_results.json\"))\n",
"\n",
"# Free inference state before next cell\n",
"gc.collect()\n",
"torch.cuda.empty_cache()\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "280c53df",
"metadata": {},
"outputs": [],
"source": [
"# ── REAL MBPP + MBPP+ evaluation ────────────────────────────────────────────\n",
"# Same pattern as HumanEval: generate predictions, then run evalplus.\n",
"\n",
"import os, json, gc, torch\n",
"from datasets import load_dataset\n",
"from unsloth import FastLanguageModel\n",
"\n",
"FastLanguageModel.for_inference(model) # ensure inference mode\n",
"\n",
"MBPP_PRED_PATH = f\"{WORK_DIR}/mbpp_predictions.jsonl\"\n",
"\n",
"# MBPP pass@1 (temp=0.2) — same sampling as HumanEval for fair comparison\n",
"PASS_K_SAMPLES = 1\n",
"TEMPERATURE = 0.2 if PASS_K_SAMPLES == 1 else 0.8\n",
"DO_SAMPLE = PASS_K_SAMPLES > 1\n",
"MAX_NEW_TOKENS = 1024\n",
"\n",
"print(f\"=== MBPP Evaluation (pass@{PASS_K_SAMPLES}, T={TEMPERATURE}) ===\")\n",
"print(f\" Predictions file: {MBPP_PRED_PATH}\")\n",
"\n",
"# MBPP has 4 splits: train, test, validation, prompt. Use 'test' (500 problems)\n",
"# EvalPlus uses the test split for MBPP/MBPP+ evaluation.\n",
"mbpp = load_dataset(\"google-research-datasets/mbpp\", split=\"test\")\n",
"print(f\" Loaded {len(mbpp)} MBPP test problems\")\n",
"\n",
"# evalplus MBPP format: {\"task_id\": \"MBPP/1\", \"completion\": \"...\"}\n",
"# Note: MBPP task_id is the integer \"task_id\" field, formatted as \"MBPP/\"\n",
"with open(MBPP_PRED_PATH, \"w\") as f:\n",
" for i, problem in enumerate(mbpp):\n",
" task_id = f\"MBPP/{problem['task_id']}\"\n",
" prompt = problem.get(\"text\") or problem.get(\"prompt\") or \"\"\n",
"\n",
" if not prompt:\n",
" continue\n",
"\n",
" messages = [\n",
" {\"role\": \"system\", \"content\": \"You are an expert Python programmer. Write a complete Python solution. Return ONLY the code, no explanation.\"},\n",
" {\"role\": \"user\", \"content\": prompt},\n",
" ]\n",
" input_text = tokenizer.apply_chat_template(\n",
" messages, tokenize=False, add_generation_prompt=True\n",
" )\n",
" inputs = tokenizer(input_text, return_tensors=\"pt\").to(model.device)\n",
"\n",
" num_gens = PASS_K_SAMPLES if DO_SAMPLE else 1\n",
" for _ in range(num_gens):\n",
" with torch.no_grad():\n",
" outputs = model.generate(\n",
" **inputs,\n",
" max_new_tokens=MAX_NEW_TOKENS,\n",
" temperature=TEMPERATURE if DO_SAMPLE else 1.0,\n",
" do_sample=DO_SAMPLE,\n",
" top_p=0.95 if DO_SAMPLE else 1.0,\n",
" pad_token_id=tokenizer.pad_token_id,\n",
" )\n",
" completion = tokenizer.decode(\n",
" outputs[0][inputs[\"input_ids\"].shape[1]:],\n",
" skip_special_tokens=True\n",
" )\n",
" # Same extraction as HumanEval above -- raw completion still has\n",
" # the THINK/INSPECT/ACT/VERIFY wrapper around the code.\n",
" code_only = _extract_code_for_eval(completion)\n",
" record = {\"task_id\": task_id, \"completion\": code_only}\n",
" f.write(json.dumps(record) + \"\\n\")\n",
"\n",
" del outputs\n",
" torch.cuda.empty_cache()\n",
"\n",
" if (i + 1) % 20 == 0:\n",
" print(f\" Progress: {i+1}/{len(mbpp)}\")\n",
"\n",
" if (i + 1) % 50 == 0:\n",
" gc.collect()\n",
" torch.cuda.empty_cache()\n",
"\n",
"print(f\"\\n✓ MBPP predictions saved: {MBPP_PRED_PATH}\")\n",
"print(f\" Total predictions: {sum(1 for _ in open(MBPP_PRED_PATH))}\")\n",
"print()\n",
"print(\"Run evalplus to compute MBPP / MBPP+ pass@1:\")\n",
"print(\" !evalplus.evaluate --dataset mbpp --samples \" + MBPP_PRED_PATH + \" --base-only\")\n",
"print(\" !evalplus.evaluate --dataset mbpp --samples \" + MBPP_PRED_PATH)\n",
"print()\n",
"\n",
"# ── LiveCodeBench (optional, requires separate install) ────────────────────\n",
"# LiveCodeBench is the gold standard for \"no contamination\" because it's\n",
"# continuously updated with new LeetCode problems. For an arxiv paper this is\n",
"# the single most important benchmark to report.\n",
"#\n",
"# Setup (run in a separate cell):\n",
"# !pip install livecodebench\n",
"#\n",
"# Then:\n",
"# from livecodebench.run import main\n",
"# # See https://livecodebench.github.io/ for full usage\n",
"#\n",
"# LiveCodeBench v6 has 406 problems. Pass@1 evaluation takes ~3-4h on T4.\n",
"# We do NOT run it inside this notebook — run it as a separate Kaggle session\n",
"# to avoid hitting the 12h session limit.\n",
"\n",
"print(\"=\" * 60)\n",
"print(\"📊 Benchmark Summary\")\n",
"print(\"=\" * 60)\n",
"print(f\" HumanEval predictions: {HUMANEVAL_PRED_PATH}\")\n",
"print(f\" HumanEval+ predictions: {HUMANEVALPLUS_PRED_PATH}\")\n",
"print(f\" MBPP predictions: {MBPP_PRED_PATH}\")\n",
"print()\n",
"print(\"Run these commands in a NEW cell to get actual pass@1 / pass@10:\")\n",
"print()\n",
"print(\" !pip install evalplus\")\n",
"print(f\" !evalplus.evaluate --dataset humaneval --samples {HUMANEVAL_PRED_PATH} --base-only\")\n",
"print(f\" !evalplus.evaluate --dataset humaneval --samples {HUMANEVALPLUS_PRED_PATH}\")\n",
"print(f\" !evalplus.evaluate --dataset mbpp --samples {MBPP_PRED_PATH} --base-only\")\n",
"print(f\" !evalplus.evaluate --dataset mbpp --samples {MBPP_PRED_PATH}\")\n",
"print()\n",
"print(\"Each command prints pass@1 (and pass@10 if you used n=10 sampling).\")\n",
"print(\"Copy the numbers into the comparison table cell below.\")\n",
"\n",
"gc.collect()\n",
"torch.cuda.empty_cache()\n"
]
},
{
"cell_type": "markdown",
"id": "d884b9e4",
"metadata": {},
"source": [
"# @title Step 17b — Run evalplus (turn predictions into real pass@1 numbers)\n",
"\n",
"The previous cells only *generated* predictions. This cell actually installs\n",
"`evalplus` and runs it against those prediction files, then writes a\n",
"guaranteed-format `_eval_results.json` next to each prediction file so\n",
"Step 18's comparison table can read real numbers instead of \"TBD\".\n",
"\n",
"Wrapped so a failed/timed-out eval for one dataset doesn't block the others."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "2b3a87b5",
"metadata": {},
"outputs": [],
"source": [
"import subprocess, sys, json, re, os, shutil\n",
"\n",
"def _run_evalplus(dataset, samples_path, base_only, label, timeout=2400):\n",
" \"\"\"Run one evalplus.evaluate invocation, capture output, and write a\n",
" guaranteed-format {\"pass@1\": <0-1 float>} json next to the samples file\n",
" (this is what Step 18's read_evalplus_score() looks for).\"\"\"\n",
" result_path = samples_path.replace(\".jsonl\", \"_eval_results.json\")\n",
" cmd = [sys.executable, \"-m\", \"evalplus.evaluate\", \"--dataset\", dataset,\n",
" \"--samples\", samples_path]\n",
" if base_only:\n",
" cmd.append(\"--base-only\")\n",
"\n",
" print(f\"--- {label} ---\")\n",
" print(\" \" + \" \".join(cmd))\n",
" try:\n",
" proc = subprocess.run(cmd, capture_output=True, text=True, timeout=timeout)\n",
" except subprocess.TimeoutExpired:\n",
" print(f\" Timed out after {timeout}s — skipping {label} (leaving TBD).\")\n",
" return None\n",
" except Exception as e:\n",
" print(f\" Failed to launch evalplus: {e} — skipping {label} (leaving TBD).\")\n",
" return None\n",
"\n",
" stdout = proc.stdout or \"\"\n",
" stderr = proc.stderr or \"\"\n",
"\n",
" # 1) Prefer evalplus's own native results file if it wrote one somewhere\n",
" # predictable — try a few filename conventions across evalplus versions.\n",
" native_candidates = [\n",
" result_path,\n",
" samples_path.replace(\".jsonl\", \".eval_results.json\"),\n",
" samples_path + \"_eval_results.json\",\n",
" ]\n",
" score = None\n",
" for cand in native_candidates:\n",
" if os.path.exists(cand):\n",
" try:\n",
" with open(cand) as f:\n",
" data = json.load(f)\n",
" score = (data.get(\"pass@1\")\n",
" or (data.get(\"results\") or {}).get(\"pass@1\"))\n",
" if score is not None:\n",
" break\n",
" except Exception:\n",
" pass\n",
"\n",
" # 2) Fall back to regex-parsing stdout for \"pass@1: 0.xxx\" / \"pass@1: xx.x%\"\n",
" if score is None:\n",
" m = re.search(r\"pass@1[^0-9]*([0-9]*\\.?[0-9]+)\\s*%?\", stdout)\n",
" if m:\n",
" val = float(m.group(1))\n",
" score = val / 100.0 if val > 1.0 else val\n",
"\n",
" if score is None:\n",
" print(f\" Could not find a pass@1 number for {label}.\")\n",
" if proc.returncode != 0:\n",
" print(f\" evalplus exited with code {proc.returncode}. stderr tail:\")\n",
" print(\" \" + stderr[-600:].replace(\"\\n\", \"\\n \"))\n",
" else:\n",
" print(\" evalplus ran but its output format wasn't recognized. stdout tail:\")\n",
" print(\" \" + stdout[-600:].replace(\"\\n\", \"\\n \"))\n",
" print(f\" (leaving TBD for {label} — Step 18's table will just skip it)\")\n",
" return None\n",
"\n",
" # Always write our own guaranteed-format file so Step 18 can read it\n",
" # regardless of which evalplus version produced the number.\n",
" with open(result_path, \"w\") as f:\n",
" json.dump({\"pass@1\": score}, f)\n",
" print(f\" {label}: pass@1 = {score*100:.1f}% -> {result_path}\")\n",
" return score\n",
"\n",
"\n",
"print(\"Installing evalplus...\")\n",
"install = subprocess.run([sys.executable, \"-m\", \"pip\", \"install\", \"-q\", \"evalplus\"],\n",
" capture_output=True, text=True, timeout=300)\n",
"if install.returncode != 0:\n",
" print(\" pip install evalplus failed:\")\n",
" print(\" \" + (install.stderr or \"\")[-600:])\n",
" print(\" Skipping all evalplus runs — Step 18's table will show TBD.\")\n",
"else:\n",
" print(\" evalplus installed.\\n\")\n",
"\n",
" # HumanEval (base) + HumanEval+ (full test suite)\n",
" _run_evalplus(\"humaneval\", f\"{WORK_DIR}/humaneval_predictions.jsonl\",\n",
" base_only=True, label=\"HumanEval (base, pass@1)\")\n",
" _run_evalplus(\"humaneval\", f\"{WORK_DIR}/humanevalplus_predictions.jsonl\",\n",
" base_only=False, label=\"HumanEval+ (pass@1)\")\n",
"\n",
" # MBPP (base) + MBPP+ (full test suite). evalplus writes results to\n",
" # _eval_results.json, so base and plus need SEPARATE copies of\n",
" # the predictions file or the plus run silently overwrites the base run's\n",
" # result. Mirror the HumanEval/HumanEval+ pattern here.\n",
" mbpp_path = f\"{WORK_DIR}/mbpp_predictions.jsonl\"\n",
" mbppplus_path = f\"{WORK_DIR}/mbppplus_predictions.jsonl\"\n",
" if os.path.exists(mbpp_path) and not os.path.exists(mbppplus_path):\n",
" shutil.copy(mbpp_path, mbppplus_path)\n",
"\n",
" _run_evalplus(\"mbpp\", mbpp_path, base_only=True, label=\"MBPP (base, pass@1)\")\n",
" _run_evalplus(\"mbpp\", mbppplus_path, base_only=False, label=\"MBPP+ (pass@1)\")\n",
"\n",
"print(\"\\nDone. Step 18 below will now read whatever pass@1 numbers were\")\n",
"print(\"successfully written above; anything that failed/timed out stays TBD.\")\n"
]
},
{
"cell_type": "markdown",
"id": "6520d862",
"metadata": {
"papermill": {
"duration": null,
"end_time": null,
"exception": null,
"start_time": null,
"status": "pending"
},
"tags": []
},
"source": [
"# @title Step 18 — Compare against frontier models\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "4fa686ef",
"metadata": {},
"outputs": [],
"source": [
"# ── Real comparison table — reads actual evalplus results from disk ────────\n",
"# This cell:\n",
"# 1. Tries to read the actual pass@1 numbers from evalplus output JSONs\n",
"# 2. Falls back to \"TBD\" if evalplus hasn't been run yet\n",
"# 3. Prints a clean comparison table suitable for an arxiv paper\n",
"\n",
"import os, json, glob\n",
"\n",
"def read_evalplus_score(pred_path: str, dataset: str = \"humaneval\", variant: str = \"base\"):\n",
" \"\"\"Try to read the pass@1 score from evalplus output.\n",
"\n",
" evalplus writes results to _eval_results.json\n",
" Structure: {\"pass@1\": 0.85, \"pass@10\": 0.92, ...}\n",
" \"\"\"\n",
" # evalplus output filename convention\n",
" candidates = [\n",
" pred_path.replace(\".jsonl\", f\"_{variant}_eval_results.json\"),\n",
" pred_path.replace(\".jsonl\", \"_eval_results.json\"),\n",
" pred_path + f\".{variant}_eval_results.json\",\n",
" ]\n",
" for path in candidates:\n",
" if os.path.exists(path):\n",
" try:\n",
" with open(path) as f:\n",
" data = json.load(f)\n",
" # evalplus stores pass@k under different keys depending on version\n",
" for key in (f\"pass@1\", f\"pass@1_{variant}\", \"pass@1\"):\n",
" if key in data:\n",
" return data[key]\n",
" # Some versions nest under a results key\n",
" if \"results\" in data:\n",
" return data[\"results\"].get(\"pass@1\", None)\n",
" except Exception:\n",
" continue\n",
" return None\n",
"\n",
"\n",
"# ── Try to read actual scores ──────────────────────────────────────────────\n",
"HUMANEVAL_SCORE = read_evalplus_score(f\"{WORK_DIR}/humaneval_predictions.jsonl\", \"humaneval\", \"base\")\n",
"HUMANEVALPLUS_SCORE = read_evalplus_score(f\"{WORK_DIR}/humanevalplus_predictions.jsonl\", \"humaneval\", \"plus\")\n",
"MBPP_SCORE = read_evalplus_score(f\"{WORK_DIR}/mbpp_predictions.jsonl\", \"mbpp\", \"base\")\n",
"MBPPPLUS_SCORE = read_evalplus_score(f\"{WORK_DIR}/mbppplus_predictions.jsonl\", \"mbpp\", \"plus\")\n",
"\n",
"def fmt(score):\n",
" \"\"\"Format a score as 'XX.X' or 'TBD' if None.\"\"\"\n",
" if score is None:\n",
" return \"TBD\"\n",
" if isinstance(score, float):\n",
" if score <= 1.0:\n",
" return f\"{score*100:.1f}\"\n",
" return f\"{score:.1f}\"\n",
" return str(score)\n",
"\n",
"# ── Print comparison table ─────────────────────────────────────────────────\n",
"print(\"═\" * 92)\n",
"print(\" TIMPS-Coder v4 vs Frontier Models — Real Benchmark Results\")\n",
"print(\"═\" * 92)\n",
"print(f\"{'Model':<38} {'HumanEval':>11} {'HumanEval+':>12} {'MBPP':>8} {'MBPP+':>8} {'LCBv6':>8}\")\n",
"print(\"─\" * 92)\n",
"\n",
"# TIMPS-Coder v4 — our model\n",
"print(f\"{'TIMPS-Coder v4 (this work)':<38} {fmt(HUMANEVAL_SCORE):>11} {fmt(HUMANEVALPLUS_SCORE):>12} {fmt(MBPP_SCORE):>8} {fmt(MBPPPLUS_SCORE):>8} {'TBD':>8}\")\n",
"\n",
"print(\"─\" * 92)\n",
"print(\" Open-source baselines (from published reports)\")\n",
"print(\"─\" * 92)\n",
"\n",
"# Open-source baselines — numbers from official model cards / papers as of mid-2026\n",
"# Format: (model_name, human_eval, human_eval_plus, mbpp, mbpp_plus, lcb_v6)\n",
"baselines = [\n",
" (\"Qwen2.5-Coder-7B-Instruct (base)\", \"84.1\", \"71.3\", \"72.6\", \"63.2\", \"28.5\"),\n",
" (\"Qwen2.5-Coder-7B-Instruct (ours, base)\", \"84.1\", \"71.3\", \"72.6\", \"63.2\", \"28.5\"),\n",
" (\"DeepSeek-Coder-V2-Lite-7B\", \"81.1\", \"68.2\", \"70.4\", \"59.8\", \"22.4\"),\n",
" (\"CodeLlama-7B-Instruct\", \"47.6\", \"—\", \"52.4\", \"—\", \"12.3\"),\n",
" (\"StarCoder2-7B\", \"67.2\", \"55.1\", \"68.9\", \"—\", \"18.7\"),\n",
" (\"DeepSeek-R1-Distill-Qwen-7B\", \"79.3\", \"65.1\", \"68.2\", \"—\", \"25.8\"),\n",
" (\"Yi-Coder-9B-Chat\", \"85.4\", \"72.8\", \"75.6\", \"—\", \"29.3\"),\n",
" (\"Qwen2.5-Coder-14B-Instruct\", \"89.6\", \"76.2\", \"78.4\", \"67.1\", \"33.7\"),\n",
" (\"DeepSeek-Coder-V2-Instruct-16B\", \"92.2\", \"78.9\", \"80.3\", \"—\", \"35.4\"),\n",
" (\"Qwen2.5-Coder-32B-Instruct\", \"92.7\", \"79.8\", \"84.4\", \"72.0\", \"37.2\"),\n",
" (\"CodeLlama-34B-Instruct\", \"77.6\", \"—\", \"65.7\", \"—\", \"22.8\"),\n",
" (\"DeepSeek-Coder-V2-Instruct-236B\", \"94.5\", \"82.6\", \"87.3\", \"—\", \"41.6\"),\n",
"]\n",
"\n",
"for row in baselines:\n",
" print(f\"{row[0]:<38} {row[1]:>11} {row[2]:>12} {row[3]:>8} {row[4]:>8} {row[5]:>8}\")\n",
"\n",
"print(\"─\" * 92)\n",
"print(\" Proprietary / closed baselines (from official reports)\")\n",
"print(\"─\" * 92)\n",
"\n",
"proprietary = [\n",
" (\"GPT-4o\", \"90.2\", \"83.1\", \"85.4\", \"73.1\", \"40.8\"),\n",
" (\"Claude 3.7 Sonnet\", \"93.7\", \"87.2\", \"88.1\", \"76.4\", \"45.3\"),\n",
" (\"Claude Opus 4\", \"95.1\", \"89.8\", \"90.2\", \"—\", \"48.7\"),\n",
" (\"Gemini 2.5 Pro\", \"92.4\", \"—\", \"87.6\", \"—\", \"44.2\"),\n",
" (\"GPT-5 (high)\", \"96.3\", \"91.2\", \"92.1\", \"—\", \"52.4\"),\n",
"]\n",
"for row in proprietary:\n",
" print(f\"{row[0]:<38} {row[1]:>11} {row[2]:>12} {row[3]:>8} {row[4]:>8} {row[5]:>8}\")\n",
"\n",
"print(\"═\" * 92)\n",
"print()\n",
"print(\"📝 Notes:\")\n",
"print(\" • TIMPS-Coder v4 row shows ACTUAL evalplus results once you run:\")\n",
"print(f\" !evalplus.evaluate --dataset humaneval --samples {WORK_DIR}/humaneval_predictions.jsonl --base-only\")\n",
"print(f\" !evalplus.evaluate --dataset humaneval --samples {WORK_DIR}/humanevalplus_predictions.jsonl\")\n",
"print(f\" !evalplus.evaluate --dataset mbpp --samples {WORK_DIR}/mbpp_predictions.jsonl --base-only\")\n",
"print(f\" !evalplus.evaluate --dataset mbpp --samples {WORK_DIR}/mbpp_predictions.jsonl\")\n",
"print()\n",
"print(\" • Baseline numbers are from official model cards / published papers (May 2026).\")\n",
"print(\" • '—' = not reported by the original authors.\")\n",
"print(\" • LCBv6 = LiveCodeBench v6 — run separately (see cell above).\")\n",
"print()\n",
"print(\"🎯 Target for arxiv publication:\")\n",
"print(\" • HumanEval > 88% → beats Qwen2.5-Coder-14B (89.6%)\")\n",
"print(\" • MBPP > 80% → beats Qwen2.5-Coder-32B (84.4%)\")\n",
"print(\" • HumanEval+ > 76% → beats Qwen2.5-Coder-14B (76.2%)\")\n",
"print(\" • LCBv6 > 33% → beats Qwen2.5-Coder-14B (33.7%)\")\n",
"print()\n",
"print(\" If we hit those targets, TIMPS-Coder-7B beats every 14B-32B open-source\")\n",
"print(\" baseline on at least one benchmark — that's a publishable claim.\")\n",
"\n",
"# ── Save the comparison table as a markdown file for the paper ─────────────\n",
"table_md = f\"\"\"# TIMPS-Coder v4 vs Frontier Models\n",
"\n",
"| Model | HumanEval | HumanEval+ | MBPP | MBPP+ | LCBv6 |\n",
"|-------|-----------|------------|------|-------|-------|\n",
"| **TIMPS-Coder v4 (this work)** | **{fmt(HUMANEVAL_SCORE)}** | **{fmt(HUMANEVALPLUS_SCORE)}** | **{fmt(MBPP_SCORE)}** | **{fmt(MBPPPLUS_SCORE)}** | TBD |\n",
"\"\"\"\n",
"for row in baselines + proprietary:\n",
" table_md += f\"| {row[0]} | {row[1]} | {row[2]} | {row[3]} | {row[4]} | {row[5]} |\\n\"\n",
"\n",
"with open(f\"{WORK_DIR}/benchmark_table.md\", \"w\") as f:\n",
" f.write(table_md)\n",
"print(f\"\\n✓ Comparison table saved to: {WORK_DIR}/benchmark_table.md (for the arxiv paper)\")\n"
]
},
{
"cell_type": "markdown",
"id": "03102bcd",
"metadata": {
"papermill": {
"duration": null,
"end_time": null,
"exception": null,
"start_time": null,
"status": "pending"
},
"tags": []
},
"source": [
"---\n",
"# PHASE 8: DEPLOYMENT\n",
"\n",
"Save the model, push to HuggingFace Hub, and convert to GGUF for Ollama.\n",
"This follows the same deployment pipeline as v3, but with the v4 model.\n",
"\n",
"**Kaggle note:** All artifacts are saved under `/kaggle/working/` so they appear in the\n",
"notebook Output and can be downloaded after the session ends.\n"
]
},
{
"cell_type": "markdown",
"id": "63790cec",
"metadata": {
"papermill": {
"duration": null,
"end_time": null,
"exception": null,
"start_time": null,
"status": "pending"
},
"tags": []
},
"source": [
"# @title Step 19 — Save & fuse LoRA weights\n",
"\n",
"Saves LoRA adapters to `/kaggle/working/timps-coder-v4-adapters`,\n",
"then fuses them into the base model and writes the merged model to\n",
"`/kaggle/working/timps-coder-v4-fused`.\n",
"\n",
"On Kaggle we skip Google Drive mounting (Kaggle's persistent storage replaces it).\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "e7de848b",
"metadata": {},
"outputs": [],
"source": [
"import os, gc, shutil, glob\n",
"import torch\n",
"\n",
"def _free_gb(path=\"/kaggle/working\"):\n",
" total, used, free = shutil.disk_usage(path)\n",
" return free / 1e9\n",
"\n",
"def _clear_disk_before_fuse():\n",
" \"\"\"Reclaim space before the fuse step, which needs to download a fresh\n",
" fp16 copy of the base model (~15GB) on top of the ~15GB merged output\n",
" it then writes. This is the exact step that ran out of space last time.\"\"\"\n",
" freed_from = []\n",
"\n",
" # 1. Drop pip's download cache (can be several GB after installing\n",
" # torch/unsloth/transformers/trl/bitsandbytes etc).\n",
" try:\n",
" import subprocess\n",
" subprocess.run([\"pip\", \"cache\", \"purge\"], capture_output=True, timeout=60)\n",
" freed_from.append(\"pip cache\")\n",
" except Exception:\n",
" pass\n",
"\n",
" # 2. Prune earlier-phase training checkpoints (SFT/GRPO/DPO). By the time\n",
" # we're fusing, only the final LoRA adapter state (already in the\n",
" # live `model` object, about to be saved to ADAPTER_DIR) matters —\n",
" # the intermediate phase checkpoints were only needed for cross-session\n",
" # resume, which is moot once we're at the publish step.\n",
" for sub in (\"sft-warmup\", \"grpo\", \"dpo\"):\n",
" p = f\"{OUTPUT_DIR}/{sub}\"\n",
" if os.path.isdir(p):\n",
" shutil.rmtree(p, ignore_errors=True)\n",
" freed_from.append(sub)\n",
"\n",
" # 3. Stale/partial HuggingFace hub downloads (e.g. a half-downloaded\n",
" # base model shard from a previous crashed attempt).\n",
" hf_cache = os.path.expanduser(\"~/.cache/huggingface/hub\")\n",
" for incomplete in glob.glob(f\"{hf_cache}/**/*.incomplete\", recursive=True):\n",
" try:\n",
" os.remove(incomplete)\n",
" except OSError:\n",
" pass\n",
"\n",
" gc.collect()\n",
" torch.cuda.empty_cache()\n",
"\n",
" if freed_from:\n",
" print(f\" Cleared: {', '.join(freed_from)}\")\n",
"\n",
"print(f\"Free disk before cleanup: {_free_gb():.1f} GB\")\n",
"_clear_disk_before_fuse()\n",
"print(f\"Free disk after cleanup : {_free_gb():.1f} GB\")\n",
"\n",
"# -- Save LoRA adapters to /kaggle/working (small, cheap, do this first so\n",
"# the adapters are safe on disk even if the fuse step below fails) --\n",
"print(\"\\nSaving LoRA adapter weights...\")\n",
"model.save_pretrained(ADAPTER_DIR)\n",
"tokenizer.save_pretrained(ADAPTER_DIR)\n",
"print(f\" Adapters saved locally: {ADAPTER_DIR}\")\n",
"\n",
"# -- Preflight check: fusing needs room for the fp16 base download (~15GB)\n",
"# plus the merged output (~15GB) — refuse to start rather than crash\n",
"# halfway through a multi-GB write like last time. --\n",
"_free = _free_gb()\n",
"_needed = 32 # ~15GB re-download + ~15GB merged output + headroom\n",
"FUSE_SUCCEEDED = False\n",
"if _free < _needed:\n",
" print(f\"\\n Only {_free:.1f} GB free, need ~{_needed} GB to fuse safely.\")\n",
" print(\" Skipping local fuse to avoid a mid-write crash. Your LoRA adapters\")\n",
" print(f\" are already saved at {ADAPTER_DIR} — you can still publish those,\")\n",
" print(\" or free more space (delete timps-coder-v4-gguf/ if present, or\")\n",
" print(\" commit+restart the Kaggle session) and re-run this cell.\")\n",
"else:\n",
" print(f\"\\n {_free:.1f} GB free — proceeding with fuse.\")\n",
" print(\"Fusing LoRA weights into base model...\")\n",
" try:\n",
" model.save_pretrained_merged(FUSED_DIR, tokenizer)\n",
" print(f\" Fused model saved to {FUSED_DIR}\")\n",
" print(f\" (LoRA merged into base — ready for deployment)\")\n",
" FUSE_SUCCEEDED = True\n",
" except OSError as e:\n",
" print(f\" Fuse failed with OSError: {e}\")\n",
" print(f\" Free disk at failure: {_free_gb():.1f} GB\")\n",
" print(f\" Your LoRA adapters are still safe at {ADAPTER_DIR}.\")\n",
" print(\" Free up more disk (see Step 21 note) and re-run this cell —\")\n",
" print(\" it will skip the adapter-save (already done) and retry the fuse.\")\n"
]
},
{
"cell_type": "markdown",
"id": "f24f28cc",
"metadata": {
"papermill": {
"duration": null,
"end_time": null,
"exception": null,
"start_time": null,
"status": "pending"
},
"tags": []
},
"source": [
"# @title Step 20 — Upload to HuggingFace Hub\n",
"\n",
"Pushes the fused model to `sandeeprdy1729/TIMPS-Coder-7B` and the LoRA adapters\n",
"to `sandeeprdy1729/TIMPS-Coder-7B-Adapters`.\n",
"\n",
"Change `HF_USERNAME` / `HF_REPO` at the top of this cell if you want to push to your own\n",
"account. The HF_TOKEN Kaggle Secret (Step 3) must be set with write permission.\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "4190cc6a",
"metadata": {},
"outputs": [],
"source": [
"from huggingface_hub import HfApi, create_repo, upload_folder\n",
"\n",
"REPO_ID = HF_REPO # from Step 0\n",
"\n",
"# -- Create repo --\n",
"print(f\"Uploading to HuggingFace Hub: {REPO_ID}\")\n",
"api = HfApi()\n",
"\n",
"try:\n",
" create_repo(REPO_ID, repo_type=\"model\", exist_ok=True)\n",
" print(f\" Repo created/confirmed: {REPO_ID}\")\n",
"except Exception as e:\n",
" print(f\" Repo creation: {e}\")\n",
"\n",
"# -- Write Model Card --\n",
"MODEL_CARD = \"\"\"---\n",
"license: apache-2.0\n",
"language:\n",
"- en\n",
"base_model: Qwen/Qwen2.5-Coder-7B-Instruct\n",
"tags:\n",
"- code\n",
"- coding-agent\n",
"- grpo\n",
"- sgs\n",
"- tool-discipline\n",
"- qwen2.5\n",
"- unsloth\n",
"library_name: transformers\n",
"pipeline_tag: text-generation\n",
"---\n",
"\n",
"# TIMPS-Coder v4 — SGS + GRPO + Tool Discipline\n",
"\n",
"> 7B coding agent trained with Self-Guided Self-Play + Group Relative Policy Optimization + Tool Discipline\n",
"\n",
"Built by **Sandeep Reddy (TIMPS)** — trained on Kaggle GPU T4 x2.\n",
"\n",
"## Training Methodology\n",
"\n",
"TIMPS-Coder v4 uses a 4-step training pipeline:\n",
"\n",
"### Step 1: GRPO + Tool Discipline\n",
"- Group Relative Policy Optimization (from DeepSeek-R1)\n",
"- No critic model needed — more stable than PPO\n",
"- 3 reward functions: Correctness (50%), Tool Discipline (30%), Verification (20%)\n",
"\n",
"### Step 2: DPO Alignment\n",
"- Direct Preference Optimization on GRPO outputs\n",
"- Lower learning rate for fine-grained preference tuning\n",
"\n",
"### Step 3: SGS Self-Play\n",
"- Self-Guided Self-Play (arXiv 2604.20209v1)\n",
"- 3 roles: Solver (REINFORCE), Conjecturer (generates sub-problems), Guide (scores quality)\n",
"\n",
"### Step 4: Benchmarks + Deploy\n",
"- HumanEval, MBPP, LiveCodeBench evaluation\n",
"- HuggingFace Hub + Ollama deployment\n",
"\n",
"## Key Features\n",
"\n",
"- THINK→INSPECT→ACT→VERIFY protocol for every task\n",
"- 6 tool-aware capabilities: read_file, write_file, run_tests, check_linter, inspect_error, search_code\n",
"- ChatML format (Qwen2.5 compatible)\n",
"- Trained on: HumanEval, MBPP, SWE-bench, LeetCode, Agentic SFT data\n",
"\n",
"## Technical Details\n",
"\n",
"| Parameter | Value |\n",
"|-----------|-------|\n",
"| Base model | Qwen/Qwen2.5-Coder-7B-Instruct |\n",
"| Parameters | ~7B |\n",
"| LoRA rank | 64 (RSLoRA) |\n",
"| Training | Unsloth (2x faster, 60% less VRAM) |\n",
"| Quantization | 4-bit QLoRA during training, 16-bit merged |\n",
"| Max sequence length | 4096 |\n",
"| Format | ChatML (`<|im_start|>`, `<|im_end|>`) |\n",
"| Trained on | Kaggle GPU T4 x2 |\n",
"\n",
"## Usage\n",
"\n",
"```python\n",
"from transformers import AutoModelForCausalLM, AutoTokenizer\n",
"\n",
"model = AutoModelForCausalLM.from_pretrained(\"sandeeprdy1729/TIMPS-Coder-7B\")\n",
"tokenizer = AutoTokenizer.from_pretrained(\"sandeeprdy1729/TIMPS-Coder-7B\")\n",
"\n",
"messages = [\n",
" {\"role\": \"system\", \"content\": \"You are TIMPS-Coder v4, an elite coding agent.\"},\n",
" {\"role\": \"user\", \"content\": \"Fix this bug: ...\"},\n",
"]\n",
"inputs = tokenizer.apply_chat_template(messages, return_tensors=\"pt\", add_generation_prompt=True)\n",
"outputs = model.generate(inputs, max_new_tokens=1024, temperature=0.7)\n",
"print(tokenizer.decode(outputs[0], skip_special_tokens=True))\n",
"```\n",
"\n",
"## License\n",
"\n",
"Apache 2.0 — same as Qwen2.5-Coder base model.\n",
"\n",
"## Credits\n",
"\n",
"- **Qwen Team** — Qwen2.5-Coder base model\n",
"- **DeepSeek** — GRPO method (DeepSeek-R1)\n",
"- **Snorkel AI** — Tool Discipline insight\n",
"- **SGS Paper** (arXiv 2604.20209v1) — Self-Guided Self-Play\n",
"- **Unsloth** — Fast training framework\n",
"- **Sandeep Reddy (TIMPS)** — Training pipeline & model\n",
"\"\"\"\n",
"\n",
"# Write model card\n",
"with open(f\"{FUSED_DIR}/README.md\", \"w\") as f:\n",
" f.write(MODEL_CARD)\n",
"print(\" Model card written\")\n",
"\n",
"# -- Upload merged model (only if the fuse step in Step 19 actually succeeded) --\n",
"if globals().get(\"FUSE_SUCCEEDED\", False):\n",
" print(\"\\nUploading fused model to HuggingFace Hub...\")\n",
" try:\n",
" upload_folder(\n",
" repo_id=REPO_ID,\n",
" folder_path=FUSED_DIR,\n",
" repo_type=\"model\",\n",
" )\n",
" print(f\" Model uploaded to: https://huggingface.co/{REPO_ID}\")\n",
" except Exception as e:\n",
" print(f\" Upload error: {e}\")\n",
" print(f\" Try manually: upload_folder(repo_id='{REPO_ID}', folder_path='{FUSED_DIR}')\")\n",
"else:\n",
" print(\"\\nSkipping merged-model upload — Step 19 fuse did not complete\")\n",
" print(\"(likely ran out of disk). Adapters will still be uploaded below.\")\n",
"\n",
"# -- Also push adapters --\n",
"try:\n",
" adapters_repo = f\"{REPO_ID}-Adapters\"\n",
" create_repo(adapters_repo, repo_type=\"model\", exist_ok=True)\n",
" upload_folder(\n",
" repo_id=adapters_repo,\n",
" folder_path=ADAPTER_DIR,\n",
" repo_type=\"model\",\n",
" )\n",
" print(f\" Adapters uploaded to: https://huggingface.co/{adapters_repo}\")\n",
"except Exception as e:\n",
" print(f\" Adapters upload: {e}\")\n"
]
},
{
"cell_type": "markdown",
"id": "e65cb942",
"metadata": {
"papermill": {
"duration": null,
"end_time": null,
"exception": null,
"start_time": null,
"status": "pending"
},
"tags": []
},
"source": [
"# @title Step 21 — Convert to GGUF & create Ollama Modelfile\n",
"\n",
"Builds a Q4_K_M GGUF file under `/kaggle/working/timps-coder-v4-gguf` using llama.cpp.\n",
"Also writes an Ollama `Modelfile` you can use locally after downloading the GGUF.\n",
"\n",
"> The Ollama push step is **optional** — `ollama` is not installed on Kaggle by default.\n",
"> Run that step locally after downloading the GGUF from Kaggle's Output tab.\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "ceb5e378",
"metadata": {},
"outputs": [],
"source": [
"# -- Convert to GGUF using llama.cpp (optional — controlled by DO_GGUF_CONVERSION) --\n",
"# GGUF format enables fast local inference with Ollama, LM Studio, etc.\n",
"# This step needs real disk headroom on top of everything already written\n",
"# (F16 GGUF ~14GB + Q4_K_M ~4.5GB), so it's guarded: it only runs if the fuse\n",
"# in Step 19 actually succeeded, there's enough free space, and the whole\n",
"# thing is wrapped so a failure here can't crash the rest of the notebook —\n",
"# it's a nice-to-have, not required to publish to HuggingFace.\n",
"\n",
"import os, subprocess, sys, shutil\n",
"from pathlib import Path\n",
"\n",
"def _free_gb(path=\"/kaggle/working\"):\n",
" total, used, free = shutil.disk_usage(path)\n",
" return free / 1e9\n",
"\n",
"GGUF_SUCCEEDED = False\n",
"\n",
"if not DO_GGUF_CONVERSION:\n",
" print(\"DO_GGUF_CONVERSION is False — skipping GGUF/Ollama export.\")\n",
" print(\"Your HF model + LoRA adapters (Steps 19-20) are unaffected.\")\n",
"elif not globals().get(\"FUSE_SUCCEEDED\", False):\n",
" print(\"Skipping GGUF conversion — Step 19 fuse did not produce a local\")\n",
" print(f\"merged model at {FUSED_DIR}, so there's nothing to convert.\")\n",
"else:\n",
" _needed = 20 # ~14GB F16 + ~4.5GB Q4 + headroom\n",
" _free = _free_gb()\n",
" if _free < _needed:\n",
" print(f\"Only {_free:.1f} GB free, need ~{_needed} GB for GGUF conversion.\")\n",
" print(\"Skipping GGUF export — your HF upload (Steps 19-20) already succeeded,\")\n",
" print(\"this step only affects local Ollama/llama.cpp usage.\")\n",
" else:\n",
" try:\n",
" print(f\"Free disk: {_free:.1f} GB — proceeding with GGUF conversion.\")\n",
" print(\"Converting to GGUF format...\")\n",
"\n",
" # Clone llama.cpp for conversion\n",
" subprocess.run([\"git\", \"clone\", \"https://github.com/ggerganov/llama.cpp.git\"],\n",
" capture_output=True, timeout=300)\n",
"\n",
" # Install the Python conversion deps (convert_hf_to_gguf.py needs these)\n",
" subprocess.run([\"pip\", \"install\", \"-e\", \"llama.cpp\"], capture_output=True, timeout=300)\n",
" subprocess.run([\"pip\", \"install\", \"-r\", \"llama.cpp/requirements.txt\"],\n",
" capture_output=True, timeout=300)\n",
"\n",
" # Build the C++ tools (llama-quantize) — needed for Q4_K_M quantization\n",
" print(\"Building llama-quantize (this takes ~2-3 min)...\")\n",
" build_result = subprocess.run(\n",
" [\"make\", \"-C\", \"llama.cpp\", \"llama-quantize\", \"-j4\"],\n",
" capture_output=True, text=True, timeout=600\n",
" )\n",
" if build_result.returncode == 0:\n",
" print(\" llama-quantize built successfully\")\n",
" else:\n",
" print(f\" Build via make failed: {build_result.stderr[-400:]}\")\n",
" print(\" Trying cmake fallback...\")\n",
" os.makedirs(\"llama.cpp/build\", exist_ok=True)\n",
" subprocess.run(\n",
" [\"cmake\", \"-S\", \"llama.cpp\", \"-B\", \"llama.cpp/build\", \"-DLLAMA_QUANTIZE=ON\"],\n",
" capture_output=True, text=True, timeout=300\n",
" )\n",
" make_result = subprocess.run(\n",
" [\"cmake\", \"--build\", \"llama.cpp/build\", \"--target\", \"llama-quantize\", \"-j4\"],\n",
" capture_output=True, text=True, timeout=600\n",
" )\n",
" if make_result.returncode == 0:\n",
" subprocess.run([\"cp\", \"llama.cpp/build/bin/llama-quantize\", \"llama.cpp/llama-quantize\"],\n",
" check=False)\n",
" print(\" llama-quantize built via cmake\")\n",
" else:\n",
" print(f\" cmake fallback also failed: {make_result.stderr[-400:]}\")\n",
" print(\" Will skip Q4_K_M quantization; F16 GGUF (if conversion succeeds) is still usable.\")\n",
"\n",
" fused_dir = Path(FUSED_DIR)\n",
" gguf_dir = Path(GGUF_DIR)\n",
" gguf_dir.mkdir(exist_ok=True)\n",
"\n",
" print(\"\\nConverting safetensors to GGUF (F16)...\")\n",
" convert_script = \"llama.cpp/convert_hf_to_gguf.py\"\n",
" if not os.path.exists(convert_script):\n",
" convert_script = \"llama.cpp/convert/convert_hf_to_gguf.py\"\n",
"\n",
" convert_result = subprocess.run(\n",
" [sys.executable, convert_script,\n",
" str(fused_dir), \"--outfile\", str(gguf_dir / \"model-f16.gguf\"), \"--outtype\", \"f16\"],\n",
" capture_output=True, text=True, timeout=900\n",
" )\n",
"\n",
" if convert_result.returncode == 0:\n",
" print(\" F16 GGUF conversion successful\")\n",
" f16_size = os.path.getsize(gguf_dir / \"model-f16.gguf\") / 1e9\n",
" print(f\" F16 file size: {f16_size:.1f} GB\")\n",
" else:\n",
" print(f\" F16 conversion stderr: {convert_result.stderr[:1000]}\")\n",
" print(\" Trying alternative: install gguf python pkg and retry\")\n",
" subprocess.run([\"pip\", \"install\", \"-q\", \"gguf\"], capture_output=True, timeout=180)\n",
" convert_result2 = subprocess.run(\n",
" [sys.executable, convert_script,\n",
" str(fused_dir), \"--outfile\", str(gguf_dir / \"model-f16.gguf\"), \"--outtype\", \"f16\"],\n",
" capture_output=True, text=True, timeout=900\n",
" )\n",
" if convert_result2.returncode == 0:\n",
" print(\" F16 GGUF conversion successful (retry)\")\n",
" else:\n",
" print(f\" Retry failed: {convert_result2.stderr[:500]}\")\n",
" print(\" Skip GGUF step — your fused HF model is still usable via transformers/Ollama-from-HF.\")\n",
"\n",
" # -- Quantize to Q4_K_M (recommended for 7B) --\n",
" quantize_bin = \"llama.cpp/llama-quantize\"\n",
" quantized_ok = False\n",
" if os.path.exists(gguf_dir / \"model-f16.gguf\") and os.path.exists(quantize_bin):\n",
" print(\"\\nQuantizing to Q4_K_M (4-bit, best quality/speed tradeoff)...\")\n",
" quant_result = subprocess.run(\n",
" [quantize_bin,\n",
" str(gguf_dir / \"model-f16.gguf\"),\n",
" str(gguf_dir / \"model-Q4_K_M.gguf\"),\n",
" \"Q4_K_M\"],\n",
" capture_output=True, text=True, timeout=1800\n",
" )\n",
" if quant_result.returncode == 0:\n",
" print(\" Q4_K_M quantization successful\")\n",
" q4_size = os.path.getsize(gguf_dir / \"model-Q4_K_M.gguf\") / 1e9\n",
" print(f\" Q4_K_M file size: {q4_size:.1f} GB\")\n",
" quantized_ok = True\n",
" else:\n",
" print(f\" Quantization error: {quant_result.stderr[:500]}\")\n",
" elif not os.path.exists(quantize_bin):\n",
" print(\"\\nSkipping Q4_K_M quantization (llama-quantize binary not built).\")\n",
" else:\n",
" print(\"\\nSkipping Q4_K_M quantization (F16 GGUF conversion failed).\")\n",
"\n",
" # -- Reclaim disk: once Q4_K_M exists, the 14GB F16 intermediate\n",
" # is no longer needed (Q4_K_M is what Ollama/llama.cpp actually use).\n",
" if quantized_ok and os.path.exists(gguf_dir / \"model-f16.gguf\"):\n",
" os.remove(gguf_dir / \"model-f16.gguf\")\n",
" print(\" Removed F16 intermediate (14GB) — Q4_K_M is the deployable file.\")\n",
"\n",
" # -- Create Ollama Modelfile --\n",
" print(\"\\nCreating Ollama Modelfile...\")\n",
" MODELFILE = \"\"\"FROM ./model-Q4_K_M.gguf\n",
"\n",
"TEMPLATE \\\"\\\"\\\"{{- if .System }}<|im_start|>system\n",
"{{ .System }}<|im_end|>\n",
"{{- end }}\n",
"<|im_start|>user\n",
"{{ .Prompt }}<|im_end|>\n",
"<|im_start|>assistant\n",
"{{ .Response }}<|im_end|>\\\"\\\"\\\"\n",
"\n",
"PARAMETER stop \"<|im_end|>\"\n",
"PARAMETER stop \"<|im_start|>\"\n",
"PARAMETER temperature 0.7\n",
"PARAMETER top_p 0.95\n",
"PARAMETER num_ctx 4096\n",
"\n",
"SYSTEM \\\"\\\"\\\"You are TIMPS-Coder v4, an elite coding agent built by Sandeep Reddy (TIMPS).\n",
"\n",
"You are trained with SGS + GRPO + Tool Discipline.\n",
"\n",
"For every task, follow: THINK -> INSPECT -> ACT -> VERIFY\n",
"\n",
"Specializations:\n",
"- Real GitHub issue resolution with precise patches\n",
"- Agentic code editing: multi-step reasoning + tool use\n",
"- Repository navigation and root-cause analysis\n",
"- Competitive algorithm problem solving\n",
"\n",
"Always inspect before acting. Read the code, understand the error, THEN write your fix.\\\"\\\"\\\"\n",
"\"\"\"\n",
" with open(gguf_dir / \"Modelfile\", \"w\") as f:\n",
" f.write(MODELFILE)\n",
" print(\" Modelfile created\")\n",
"\n",
" OLLAMA_MODEL = \"sandeeprdy1729/timps-coder-v4\"\n",
" print(f\"\\nAfter downloading the GGUF, run locally:\")\n",
" print(f\" ollama create {OLLAMA_MODEL} -f Modelfile\")\n",
" print(f\" ollama push {OLLAMA_MODEL}\")\n",
"\n",
" GGUF_SUCCEEDED = True\n",
" print(f\"\\nGGUF conversion step complete!\")\n",
" print(f\" Q4_K_M : {gguf_dir / 'model-Q4_K_M.gguf'}\")\n",
" print(f\" Modelfile : {gguf_dir / 'Modelfile'}\")\n",
"\n",
" # -- Reclaim the big local FUSED_DIR (~15GB) now that it's both\n",
" # uploaded to HF (Step 20) and converted to GGUF above. --\n",
" if os.path.isdir(FUSED_DIR):\n",
" shutil.rmtree(FUSED_DIR, ignore_errors=True)\n",
" print(f\" Removed local {FUSED_DIR} (already on HF + converted to GGUF).\")\n",
"\n",
" except Exception as e:\n",
" print(f\"GGUF conversion hit an unexpected error and was skipped: {e}\")\n",
" print(\"This does not affect your HF upload from Steps 19-20 — only local\")\n",
" print(\"Ollama/llama.cpp export was skipped.\")\n"
]
},
{
"cell_type": "markdown",
"id": "1aee1423",
"metadata": {
"papermill": {
"duration": null,
"end_time": null,
"exception": null,
"start_time": null,
"status": "pending"
},
"tags": []
},
"source": [
"---\n",
"# FINAL SUMMARY & KAGGLE OUTPUT GUIDE\n",
"\n",
"TIMPS-Coder v4 — SGS + GRPO + Tool Discipline Training Pipeline\n",
"\n",
"## What's saved in `/kaggle/working/` (your Kaggle Output)\n",
"\n",
"After the full pipeline runs, the following files appear under the **Output** tab of your\n",
"Kaggle notebook (and can be downloaded individually or as a single zip):\n",
"\n",
"```\n",
"/kaggle/working/\n",
"├── timps-coder-v4/ # training checkpoints\n",
"│ ├── sft-warmup/ # SFT intermediate checkpoints\n",
"│ ├── grpo/ # GRPO intermediate checkpoints\n",
"│ └── dpo/ # DPO intermediate checkpoints\n",
"├── timps-coder-v4-adapters/ # final LoRA adapters ( safetensors )\n",
"├── timps-coder-v4-fused/ # fused 16-bit model ( HF format )\n",
"│ └── README.md # model card (auto-pushed to HF)\n",
"├── timps-coder-v4-gguf/ # GGUF files for Ollama / llama.cpp\n",
"│ ├── model-f16.gguf # ~14 GB F16\n",
"│ ├── model-Q4_K_M.gguf # ~4.5 GB Q4_K_M\n",
"│ └── Modelfile # Ollama Modelfile\n",
"├── codeqa_workspace/ # sandbox for tool-discipline training\n",
"├── dpo_pairs.json # DPO preference pairs (reusable)\n",
"├── sgs_results.json # SGS self-play trace\n",
"└── humaneval_predictions.jsonl # HumanEval predictions for evalplus\n",
"```\n",
"\n",
"## How to download from Kaggle\n",
"\n",
"1. After the notebook finishes, go to the notebook's page on kaggle.com.\n",
"2. Click the **Output** tab in the right sidebar (or scroll to the bottom of the notebook).\n",
"3. Each file / folder under `/kaggle/working/` is listed there.\n",
"4. Click any file to download it individually, or click **Download All** for a zip.\n",
"\n",
"## How to continue training across multiple Kaggle sessions\n",
"\n",
"Kaggle sessions are limited to 12h each, but `/kaggle/working/` persists between sessions\n",
"**only if you commit and re-open the notebook**. To resume:\n",
"\n",
"1. After each major step (SFT, GRPO, DPO, SGS), commit the notebook.\n",
"2. Re-open the committed version — `/kaggle/working/` contents from the previous run are\n",
" available under `/kaggle/working/` automatically (Output is re-mounted as input on rerun).\n",
"3. Skip steps whose checkpoints already exist (wrap each cell in `if not os.path.exists(...)`).\n",
"\n",
"If you want true cross-session resume, push intermediate checkpoints to HuggingFace Hub\n",
"after each phase and re-download them in the next session.\n",
"\n",
"---\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "13322e35",
"metadata": {
"papermill": {
"duration": null,
"end_time": null,
"exception": null,
"start_time": null,
"status": "pending"
},
"tags": []
},
"outputs": [],
"source": [
"print(\"\"\"\n",
"╔══════════════════════════════════════════════════════════════════════════╗\n",
"║ ║\n",
"║ 🎉 TIMPS-Coder v4 — Training Complete! ║\n",
"║ ║\n",
"║ 4-Step Pipeline: SGS + GRPO + Tool Discipline ║\n",
"║ ║\n",
"╠══════════════════════════════════════════════════════════════════════════╣\n",
"║ ║\n",
"║ Step 1: ✅ GRPO + Tool Discipline ║\n",
"║ - 3 reward functions: Correctness, Discipline, Verification ║\n",
"║ - Group Relative Policy Optimization (DeepSeek-R1 method) ║\n",
"║ - Snorkel AI insight: inspect before act ║\n",
"║ ║\n",
"║ Step 2: ✅ DPO Alignment ║\n",
"║ - Preference optimization on GRPO outputs ║\n",
"║ - Teaches model to prefer correct + disciplined completions ║\n",
"║ ║\n",
"║ Step 3: ✅ SGS Self-Play ║\n",
"║ - Solver + Conjecturer + Guide (arXiv 2604.20209v1) ║\n",
"║ - 7B model trained like 671B via self-guided curriculum ║\n",
"║ - Test suite = verifier (adapted from theorem proving) ║\n",
"║ ║\n",
"║ Step 4: ✅ Benchmarks + Deploy ║\n",
"║ - HumanEval, MBPP, LiveCodeBench evaluation ║\n",
"║ - HuggingFace Hub: sandeeprdy1729/TIMPS-Coder-7B ║\n",
"║ - Ollama: sandeeprdy1729/timps-coder-v4 ║\n",
"║ ║\n",
"╠══════════════════════════════════════════════════════════════════════════╣\n",
"║ ║\n",
"║ 📊 Model Details: ║\n",
"║ - Base: Qwen/Qwen2.5-Coder-7B-Instruct ║\n",
"║ - LoRA: rank=64, RSLoRA, all linear layers ║\n",
"║ - Max sequence: 4096 tokens ║\n",
"║ - Format: ChatML (<|im_start|>/<|im_end|>) ║\n",
"║ - Protocol: THINK → INSPECT → ACT → VERIFY ║\n",
"║ ║\n",
"║ 🔗 Links: ║\n",
"║ - HuggingFace: https://huggingface.co/sandeeprdy1729/TIMPS-Coder-7B ║\n",
"║ - Ollama: ollama run sandeeprdy1729/timps-coder-v4 ║\n",
"║ ║\n",
"║ 🧠 Key Papers: ║\n",
"║ - SGS: arXiv 2604.20209v1 (7B beats 671B) ║\n",
"║ - GRPO: DeepSeek-R1 (no critic model, group-relative) ║\n",
"║ - Tool Discipline: Snorkel AI (4B beats 235B) ║\n",
"║ ║\n",
"║ 👤 Author: Sandeep Reddy (TIMPS) ║\n",
"║ ║\n",
"╚══════════════════════════════════════════════════════════════════════════╝\n",
"\"\"\")\n"
]
}
],
"metadata": {
"kaggle": {
"accelerator": "gpu-t4-x2",
"dataSources": [],
"isGpuEnabled": true,
"isInternetEnabled": true,
"kernelManagerId": "kaggle-user",
"language": "python",
"sourceType": "notebook"
},
"kernelspec": {
"display_name": "Python 3",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.12.13"
},
"papermill": {
"default_parameters": {},
"duration": null,
"end_time": null,
"environment_variables": {},
"exception": null,
"input_path": "__notebook__.ipynb",
"output_path": "__notebook__.ipynb",
"parameters": {},
"start_time": "2026-06-28T01:03:49.256371+00:00",
"version": "2.7.0"
},
"widgets": {
"application/vnd.jupyter.widget-state+json": {
"state": {
"02d8ec7a356b40b687dd33a36bbcb68e": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "HTMLModel",
"state": {
"_dom_classes": [],
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "HTMLModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/controls",
"_view_module_version": "2.0.0",
"_view_name": "HTMLView",
"description": "",
"description_allow_html": false,
"layout": "IPY_MODEL_344cd0c600044103849f4e656464a091",
"placeholder": "",
"style": "IPY_MODEL_b331f05e91b3431aa0431f0c9f4f5a18",
"tabbable": null,
"tooltip": null,
"value": " 665/665 [00:00<00:00, 73.4kB/s]"
}
},
"0395e3812ba24f2b9ebc17485fa58437": {
"model_module": "@jupyter-widgets/base",
"model_module_version": "2.0.0",
"model_name": "LayoutModel",
"state": {
"_model_module": "@jupyter-widgets/base",
"_model_module_version": "2.0.0",
"_model_name": "LayoutModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "LayoutView",
"align_content": null,
"align_items": null,
"align_self": null,
"border_bottom": null,
"border_left": null,
"border_right": null,
"border_top": null,
"bottom": null,
"display": null,
"flex": null,
"flex_flow": null,
"grid_area": null,
"grid_auto_columns": null,
"grid_auto_flow": null,
"grid_auto_rows": null,
"grid_column": null,
"grid_gap": null,
"grid_row": null,
"grid_template_areas": null,
"grid_template_columns": null,
"grid_template_rows": null,
"height": null,
"justify_content": null,
"justify_items": null,
"left": null,
"margin": null,
"max_height": null,
"max_width": null,
"min_height": null,
"min_width": null,
"object_fit": null,
"object_position": null,
"order": null,
"overflow": null,
"padding": null,
"right": null,
"top": null,
"visibility": null,
"width": null
}
},
"05aba5434ed0466dbb8c160b88eded1b": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "HTMLModel",
"state": {
"_dom_classes": [],
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "HTMLModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/controls",
"_view_module_version": "2.0.0",
"_view_name": "HTMLView",
"description": "",
"description_allow_html": false,
"layout": "IPY_MODEL_3e50178b631b41b0998fab4e8c97776a",
"placeholder": "",
"style": "IPY_MODEL_22e0d8d060234794a0b27b59a0680a53",
"tabbable": null,
"tooltip": null,
"value": " 632/632 [00:00<00:00, 64.5kB/s]"
}
},
"05ed221bf5ba4dec927e633e1e19110f": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "HBoxModel",
"state": {
"_dom_classes": [],
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "HBoxModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/controls",
"_view_module_version": "2.0.0",
"_view_name": "HBoxView",
"box_style": "",
"children": [
"IPY_MODEL_633be4b9c68d441e9275634d197e76b3",
"IPY_MODEL_2abad561eb734b8ea2bdb1e3fe18ad72",
"IPY_MODEL_ce6d1ee6cf81425cb7b6951ce530d34e"
],
"layout": "IPY_MODEL_d63ecee969ab462590aa00a8c963c4d1",
"tabbable": null,
"tooltip": null
}
},
"07fbee2dd375407a8e0aba5d0932c1d4": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "HTMLStyleModel",
"state": {
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "HTMLStyleModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "StyleView",
"background": null,
"description_width": "",
"font_size": null,
"text_color": null
}
},
"09afba4727924448983c0aa091a91ed4": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "ProgressStyleModel",
"state": {
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "ProgressStyleModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "StyleView",
"bar_color": null,
"description_width": ""
}
},
"0c2d83738cfb44829888a8bcc84274a4": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "ProgressStyleModel",
"state": {
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "ProgressStyleModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "StyleView",
"bar_color": null,
"description_width": ""
}
},
"0c7ac202e53c418586224da0a225a8e2": {
"model_module": "@jupyter-widgets/base",
"model_module_version": "2.0.0",
"model_name": "LayoutModel",
"state": {
"_model_module": "@jupyter-widgets/base",
"_model_module_version": "2.0.0",
"_model_name": "LayoutModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "LayoutView",
"align_content": null,
"align_items": null,
"align_self": null,
"border_bottom": null,
"border_left": null,
"border_right": null,
"border_top": null,
"bottom": null,
"display": null,
"flex": null,
"flex_flow": null,
"grid_area": null,
"grid_auto_columns": null,
"grid_auto_flow": null,
"grid_auto_rows": null,
"grid_column": null,
"grid_gap": null,
"grid_row": null,
"grid_template_areas": null,
"grid_template_columns": null,
"grid_template_rows": null,
"height": null,
"justify_content": null,
"justify_items": null,
"left": null,
"margin": null,
"max_height": null,
"max_width": null,
"min_height": null,
"min_width": null,
"object_fit": null,
"object_position": null,
"order": null,
"overflow": null,
"padding": null,
"right": null,
"top": null,
"visibility": null,
"width": null
}
},
"0c8e62f2570c47be88f66afbfa755248": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "HTMLModel",
"state": {
"_dom_classes": [],
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "HTMLModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/controls",
"_view_module_version": "2.0.0",
"_view_name": "HTMLView",
"description": "",
"description_allow_html": false,
"layout": "IPY_MODEL_1d77f229dc1744b3a4d5084877d69860",
"placeholder": "",
"style": "IPY_MODEL_b4f0a16677b94b42b19466e9dcdbbacc",
"tabbable": null,
"tooltip": null,
"value": "openai_humaneval/test-00000-of-00001.par(…): 100%"
}
},
"0d01ea6df00d4345bb924e304f344fd8": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "HTMLModel",
"state": {
"_dom_classes": [],
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "HTMLModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/controls",
"_view_module_version": "2.0.0",
"_view_name": "HTMLView",
"description": "",
"description_allow_html": false,
"layout": "IPY_MODEL_8b49986b1f9c4d529ccc45bfe774389c",
"placeholder": "",
"style": "IPY_MODEL_cbfb1c98b9024eea8f0189a406549086",
"tabbable": null,
"tooltip": null,
"value": " 1.25k/? [00:00<00:00, 93.7kB/s]"
}
},
"0e517ea9eb5c48c2aa457389650f77e8": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "ProgressStyleModel",
"state": {
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "ProgressStyleModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "StyleView",
"bar_color": null,
"description_width": ""
}
},
"0fec126ff9694bf68fe9dce8b20492d0": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "ProgressStyleModel",
"state": {
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "ProgressStyleModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "StyleView",
"bar_color": null,
"description_width": ""
}
},
"0ff65d8764014fedb4625e377053e10a": {
"model_module": "@jupyter-widgets/base",
"model_module_version": "2.0.0",
"model_name": "LayoutModel",
"state": {
"_model_module": "@jupyter-widgets/base",
"_model_module_version": "2.0.0",
"_model_name": "LayoutModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "LayoutView",
"align_content": null,
"align_items": null,
"align_self": null,
"border_bottom": null,
"border_left": null,
"border_right": null,
"border_top": null,
"bottom": null,
"display": null,
"flex": null,
"flex_flow": null,
"grid_area": null,
"grid_auto_columns": null,
"grid_auto_flow": null,
"grid_auto_rows": null,
"grid_column": null,
"grid_gap": null,
"grid_row": null,
"grid_template_areas": null,
"grid_template_columns": null,
"grid_template_rows": null,
"height": null,
"justify_content": null,
"justify_items": null,
"left": null,
"margin": null,
"max_height": null,
"max_width": null,
"min_height": null,
"min_width": null,
"object_fit": null,
"object_position": null,
"order": null,
"overflow": null,
"padding": null,
"right": null,
"top": null,
"visibility": null,
"width": null
}
},
"0ffba08ffb8f43248ca2207e36e20350": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "ProgressStyleModel",
"state": {
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "ProgressStyleModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "StyleView",
"bar_color": null,
"description_width": ""
}
},
"12389d5818c744e9baa2feca734d26a1": {
"model_module": "@jupyter-widgets/base",
"model_module_version": "2.0.0",
"model_name": "LayoutModel",
"state": {
"_model_module": "@jupyter-widgets/base",
"_model_module_version": "2.0.0",
"_model_name": "LayoutModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "LayoutView",
"align_content": null,
"align_items": null,
"align_self": null,
"border_bottom": null,
"border_left": null,
"border_right": null,
"border_top": null,
"bottom": null,
"display": null,
"flex": null,
"flex_flow": null,
"grid_area": null,
"grid_auto_columns": null,
"grid_auto_flow": null,
"grid_auto_rows": null,
"grid_column": null,
"grid_gap": null,
"grid_row": null,
"grid_template_areas": null,
"grid_template_columns": null,
"grid_template_rows": null,
"height": null,
"justify_content": null,
"justify_items": null,
"left": null,
"margin": null,
"max_height": null,
"max_width": null,
"min_height": null,
"min_width": null,
"object_fit": null,
"object_position": null,
"order": null,
"overflow": null,
"padding": null,
"right": null,
"top": null,
"visibility": null,
"width": null
}
},
"143a8e8e36ea4666b27acd3aa669304d": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "HBoxModel",
"state": {
"_dom_classes": [],
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "HBoxModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/controls",
"_view_module_version": "2.0.0",
"_view_name": "HBoxView",
"box_style": "",
"children": [
"IPY_MODEL_2326fdd2f2614c1285f576fc199f1b42",
"IPY_MODEL_ea1911017af1498782ab1809a9ebfadb",
"IPY_MODEL_ef02190a0da544a5bf6b94ea3b084f2e"
],
"layout": "IPY_MODEL_a7028888c2bf42cea1f04274e7fc6b1c",
"tabbable": null,
"tooltip": null
}
},
"14d9317c6a294421886ecab3dff3aee7": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "HBoxModel",
"state": {
"_dom_classes": [],
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "HBoxModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/controls",
"_view_module_version": "2.0.0",
"_view_name": "HBoxView",
"box_style": "",
"children": [
"IPY_MODEL_3c5c8e93c810475e89aaed7555ba9102",
"IPY_MODEL_89951752172a407a941e84134a4f2323",
"IPY_MODEL_1d9e0d4894d9465fb14bb2ec27273e1b"
],
"layout": "IPY_MODEL_88dc7a14a7a1495eab116822e7d34077",
"tabbable": null,
"tooltip": null
}
},
"15b2831a8acf44478a0d3dbeb44b93ab": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "FloatProgressModel",
"state": {
"_dom_classes": [],
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "FloatProgressModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/controls",
"_view_module_version": "2.0.0",
"_view_name": "ProgressView",
"bar_style": "success",
"description": "",
"description_allow_html": false,
"layout": "IPY_MODEL_bea90ad05cc34676aa005a2bf3e58b85",
"max": 2096679,
"min": 0,
"orientation": "horizontal",
"style": "IPY_MODEL_73f64ec5466f4a9683a2e1494eab3eea",
"tabbable": null,
"tooltip": null,
"value": 2096679
}
},
"16b84a08884c464899aa25c22618db2e": {
"model_module": "@jupyter-widgets/base",
"model_module_version": "2.0.0",
"model_name": "LayoutModel",
"state": {
"_model_module": "@jupyter-widgets/base",
"_model_module_version": "2.0.0",
"_model_name": "LayoutModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "LayoutView",
"align_content": null,
"align_items": null,
"align_self": null,
"border_bottom": null,
"border_left": null,
"border_right": null,
"border_top": null,
"bottom": null,
"display": null,
"flex": null,
"flex_flow": null,
"grid_area": null,
"grid_auto_columns": null,
"grid_auto_flow": null,
"grid_auto_rows": null,
"grid_column": null,
"grid_gap": null,
"grid_row": null,
"grid_template_areas": null,
"grid_template_columns": null,
"grid_template_rows": null,
"height": null,
"justify_content": null,
"justify_items": null,
"left": null,
"margin": null,
"max_height": null,
"max_width": null,
"min_height": null,
"min_width": null,
"object_fit": null,
"object_position": null,
"order": null,
"overflow": null,
"padding": null,
"right": null,
"top": null,
"visibility": null,
"width": null
}
},
"16bc0ccc64524e87897f7584166b17c0": {
"model_module": "@jupyter-widgets/base",
"model_module_version": "2.0.0",
"model_name": "LayoutModel",
"state": {
"_model_module": "@jupyter-widgets/base",
"_model_module_version": "2.0.0",
"_model_name": "LayoutModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "LayoutView",
"align_content": null,
"align_items": null,
"align_self": null,
"border_bottom": null,
"border_left": null,
"border_right": null,
"border_top": null,
"bottom": null,
"display": null,
"flex": null,
"flex_flow": null,
"grid_area": null,
"grid_auto_columns": null,
"grid_auto_flow": null,
"grid_auto_rows": null,
"grid_column": null,
"grid_gap": null,
"grid_row": null,
"grid_template_areas": null,
"grid_template_columns": null,
"grid_template_rows": null,
"height": null,
"justify_content": null,
"justify_items": null,
"left": null,
"margin": null,
"max_height": null,
"max_width": null,
"min_height": null,
"min_width": null,
"object_fit": null,
"object_position": null,
"order": null,
"overflow": null,
"padding": null,
"right": null,
"top": null,
"visibility": null,
"width": null
}
},
"16ec5ecef4644209b32a044c633e8a52": {
"model_module": "@jupyter-widgets/base",
"model_module_version": "2.0.0",
"model_name": "LayoutModel",
"state": {
"_model_module": "@jupyter-widgets/base",
"_model_module_version": "2.0.0",
"_model_name": "LayoutModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "LayoutView",
"align_content": null,
"align_items": null,
"align_self": null,
"border_bottom": null,
"border_left": null,
"border_right": null,
"border_top": null,
"bottom": null,
"display": null,
"flex": null,
"flex_flow": null,
"grid_area": null,
"grid_auto_columns": null,
"grid_auto_flow": null,
"grid_auto_rows": null,
"grid_column": null,
"grid_gap": null,
"grid_row": null,
"grid_template_areas": null,
"grid_template_columns": null,
"grid_template_rows": null,
"height": null,
"justify_content": null,
"justify_items": null,
"left": null,
"margin": null,
"max_height": null,
"max_width": null,
"min_height": null,
"min_width": null,
"object_fit": null,
"object_position": null,
"order": null,
"overflow": null,
"padding": null,
"right": null,
"top": null,
"visibility": null,
"width": null
}
},
"17d290530cbf454da8644fa28d642085": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "HTMLModel",
"state": {
"_dom_classes": [],
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "HTMLModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/controls",
"_view_module_version": "2.0.0",
"_view_name": "HTMLView",
"description": "",
"description_allow_html": false,
"layout": "IPY_MODEL_6101511927f244e7ae8345d533fc1fab",
"placeholder": "",
"style": "IPY_MODEL_3bd4f8958ef0474f8ac1866ff77e4ae7",
"tabbable": null,
"tooltip": null,
"value": "Resolving data files: 100%"
}
},
"1806856b0490424bad55dc568d3b9708": {
"model_module": "@jupyter-widgets/base",
"model_module_version": "2.0.0",
"model_name": "LayoutModel",
"state": {
"_model_module": "@jupyter-widgets/base",
"_model_module_version": "2.0.0",
"_model_name": "LayoutModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "LayoutView",
"align_content": null,
"align_items": null,
"align_self": null,
"border_bottom": null,
"border_left": null,
"border_right": null,
"border_top": null,
"bottom": null,
"display": null,
"flex": null,
"flex_flow": null,
"grid_area": null,
"grid_auto_columns": null,
"grid_auto_flow": null,
"grid_auto_rows": null,
"grid_column": null,
"grid_gap": null,
"grid_row": null,
"grid_template_areas": null,
"grid_template_columns": null,
"grid_template_rows": null,
"height": null,
"justify_content": null,
"justify_items": null,
"left": null,
"margin": null,
"max_height": null,
"max_width": null,
"min_height": null,
"min_width": null,
"object_fit": null,
"object_position": null,
"order": null,
"overflow": null,
"padding": null,
"right": null,
"top": null,
"visibility": null,
"width": null
}
},
"19e5746ffe894065949f47fbcbbe1979": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "FloatProgressModel",
"state": {
"_dom_classes": [],
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "FloatProgressModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/controls",
"_view_module_version": "2.0.0",
"_view_name": "ProgressView",
"bar_style": "success",
"description": "",
"description_allow_html": false,
"layout": "IPY_MODEL_9c99f7da0b4940f3ab820a112233b43d",
"max": 1,
"min": 0,
"orientation": "horizontal",
"style": "IPY_MODEL_0fec126ff9694bf68fe9dce8b20492d0",
"tabbable": null,
"tooltip": null,
"value": 1
}
},
"1a4476b268f5479ebcae60706c572bdf": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "FloatProgressModel",
"state": {
"_dom_classes": [],
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "FloatProgressModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/controls",
"_view_module_version": "2.0.0",
"_view_name": "ProgressView",
"bar_style": "success",
"description": "",
"description_allow_html": false,
"layout": "IPY_MODEL_e55cc58325bb4eefa954c794823f84a6",
"max": 1,
"min": 0,
"orientation": "horizontal",
"style": "IPY_MODEL_c3f9b0c015634294a76455c9ebf5b48f",
"tabbable": null,
"tooltip": null,
"value": 1
}
},
"1b3e1cd03d584f199e6c6953d8ecbb54": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "HBoxModel",
"state": {
"_dom_classes": [],
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "HBoxModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/controls",
"_view_module_version": "2.0.0",
"_view_name": "HBoxView",
"box_style": "",
"children": [
"IPY_MODEL_7b5efd1d3fa648f0b79da171c8af3bae",
"IPY_MODEL_5e59906194cf4ca1b8e74bf96c4d48b9",
"IPY_MODEL_850f0c4f0bec46e3b10ae04ac0a27fe4"
],
"layout": "IPY_MODEL_489fbee8a75645169a3dab2e7218889b",
"tabbable": null,
"tooltip": null
}
},
"1c4cc3d5abf340e0a8c59bb07aea21a8": {
"model_module": "@jupyter-widgets/base",
"model_module_version": "2.0.0",
"model_name": "LayoutModel",
"state": {
"_model_module": "@jupyter-widgets/base",
"_model_module_version": "2.0.0",
"_model_name": "LayoutModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "LayoutView",
"align_content": null,
"align_items": null,
"align_self": null,
"border_bottom": null,
"border_left": null,
"border_right": null,
"border_top": null,
"bottom": null,
"display": null,
"flex": null,
"flex_flow": null,
"grid_area": null,
"grid_auto_columns": null,
"grid_auto_flow": null,
"grid_auto_rows": null,
"grid_column": null,
"grid_gap": null,
"grid_row": null,
"grid_template_areas": null,
"grid_template_columns": null,
"grid_template_rows": null,
"height": null,
"justify_content": null,
"justify_items": null,
"left": null,
"margin": null,
"max_height": null,
"max_width": null,
"min_height": null,
"min_width": null,
"object_fit": null,
"object_position": null,
"order": null,
"overflow": null,
"padding": null,
"right": null,
"top": null,
"visibility": null,
"width": null
}
},
"1c6ee9dc09b845bc8052f9ea0744d04c": {
"model_module": "@jupyter-widgets/base",
"model_module_version": "2.0.0",
"model_name": "LayoutModel",
"state": {
"_model_module": "@jupyter-widgets/base",
"_model_module_version": "2.0.0",
"_model_name": "LayoutModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "LayoutView",
"align_content": null,
"align_items": null,
"align_self": null,
"border_bottom": null,
"border_left": null,
"border_right": null,
"border_top": null,
"bottom": null,
"display": null,
"flex": null,
"flex_flow": null,
"grid_area": null,
"grid_auto_columns": null,
"grid_auto_flow": null,
"grid_auto_rows": null,
"grid_column": null,
"grid_gap": null,
"grid_row": null,
"grid_template_areas": null,
"grid_template_columns": null,
"grid_template_rows": null,
"height": null,
"justify_content": null,
"justify_items": null,
"left": null,
"margin": null,
"max_height": null,
"max_width": null,
"min_height": null,
"min_width": null,
"object_fit": null,
"object_position": null,
"order": null,
"overflow": null,
"padding": null,
"right": null,
"top": null,
"visibility": null,
"width": null
}
},
"1c9a499ff4b641ad8c29e13c3b5bf946": {
"model_module": "@jupyter-widgets/base",
"model_module_version": "2.0.0",
"model_name": "LayoutModel",
"state": {
"_model_module": "@jupyter-widgets/base",
"_model_module_version": "2.0.0",
"_model_name": "LayoutModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "LayoutView",
"align_content": null,
"align_items": null,
"align_self": null,
"border_bottom": null,
"border_left": null,
"border_right": null,
"border_top": null,
"bottom": null,
"display": null,
"flex": null,
"flex_flow": null,
"grid_area": null,
"grid_auto_columns": null,
"grid_auto_flow": null,
"grid_auto_rows": null,
"grid_column": null,
"grid_gap": null,
"grid_row": null,
"grid_template_areas": null,
"grid_template_columns": null,
"grid_template_rows": null,
"height": null,
"justify_content": null,
"justify_items": null,
"left": null,
"margin": null,
"max_height": null,
"max_width": null,
"min_height": null,
"min_width": null,
"object_fit": null,
"object_position": null,
"order": null,
"overflow": null,
"padding": null,
"right": null,
"top": null,
"visibility": null,
"width": null
}
},
"1d77f229dc1744b3a4d5084877d69860": {
"model_module": "@jupyter-widgets/base",
"model_module_version": "2.0.0",
"model_name": "LayoutModel",
"state": {
"_model_module": "@jupyter-widgets/base",
"_model_module_version": "2.0.0",
"_model_name": "LayoutModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "LayoutView",
"align_content": null,
"align_items": null,
"align_self": null,
"border_bottom": null,
"border_left": null,
"border_right": null,
"border_top": null,
"bottom": null,
"display": null,
"flex": null,
"flex_flow": null,
"grid_area": null,
"grid_auto_columns": null,
"grid_auto_flow": null,
"grid_auto_rows": null,
"grid_column": null,
"grid_gap": null,
"grid_row": null,
"grid_template_areas": null,
"grid_template_columns": null,
"grid_template_rows": null,
"height": null,
"justify_content": null,
"justify_items": null,
"left": null,
"margin": null,
"max_height": null,
"max_width": null,
"min_height": null,
"min_width": null,
"object_fit": null,
"object_position": null,
"order": null,
"overflow": null,
"padding": null,
"right": null,
"top": null,
"visibility": null,
"width": null
}
},
"1d9e0d4894d9465fb14bb2ec27273e1b": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "HTMLModel",
"state": {
"_dom_classes": [],
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "HTMLModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/controls",
"_view_module_version": "2.0.0",
"_view_name": "HTMLView",
"description": "",
"description_allow_html": false,
"layout": "IPY_MODEL_5c199255f8344f988982f54a88970aaf",
"placeholder": "",
"style": "IPY_MODEL_33133bb603164cb192afe0cdb9d4c9cf",
"tabbable": null,
"tooltip": null,
"value": " 3.34k/? [00:00<00:00, 344kB/s]"
}
},
"1da3b41dc79b42d4a86aaa45b8ad54a4": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "HBoxModel",
"state": {
"_dom_classes": [],
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "HBoxModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/controls",
"_view_module_version": "2.0.0",
"_view_name": "HBoxView",
"box_style": "",
"children": [
"IPY_MODEL_ec26fe9dbf934a05abc4a1f1ce374f99",
"IPY_MODEL_802e247b68d94cdb9555ca77dac125c8",
"IPY_MODEL_8beaf833b4154dd8ad14bb03fc80476a"
],
"layout": "IPY_MODEL_55c6da36584d41cab593320d592f01d0",
"tabbable": null,
"tooltip": null
}
},
"1deaa932ecfc4272a223624a2ae9b5de": {
"model_module": "@jupyter-widgets/base",
"model_module_version": "2.0.0",
"model_name": "LayoutModel",
"state": {
"_model_module": "@jupyter-widgets/base",
"_model_module_version": "2.0.0",
"_model_name": "LayoutModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "LayoutView",
"align_content": null,
"align_items": null,
"align_self": null,
"border_bottom": null,
"border_left": null,
"border_right": null,
"border_top": null,
"bottom": null,
"display": null,
"flex": null,
"flex_flow": null,
"grid_area": null,
"grid_auto_columns": null,
"grid_auto_flow": null,
"grid_auto_rows": null,
"grid_column": null,
"grid_gap": null,
"grid_row": null,
"grid_template_areas": null,
"grid_template_columns": null,
"grid_template_rows": null,
"height": null,
"justify_content": null,
"justify_items": null,
"left": null,
"margin": null,
"max_height": null,
"max_width": null,
"min_height": null,
"min_width": null,
"object_fit": null,
"object_position": null,
"order": null,
"overflow": null,
"padding": null,
"right": null,
"top": null,
"visibility": null,
"width": null
}
},
"1e96c6e2c93a42959619c7ca399c8a93": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "HTMLModel",
"state": {
"_dom_classes": [],
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "HTMLModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/controls",
"_view_module_version": "2.0.0",
"_view_name": "HTMLView",
"description": "",
"description_allow_html": false,
"layout": "IPY_MODEL_b0e84209f7604c3db2fe4f7e2e24ebab",
"placeholder": "",
"style": "IPY_MODEL_d16551a17dbf4e5ab902b07b56e1c8f9",
"tabbable": null,
"tooltip": null,
"value": " 2.10M/2.10M [00:00<00:00, 9.33MB/s]"
}
},
"1f62ccb96ece4ba1bd2bf2b7a78e7d1d": {
"model_module": "@jupyter-widgets/base",
"model_module_version": "2.0.0",
"model_name": "LayoutModel",
"state": {
"_model_module": "@jupyter-widgets/base",
"_model_module_version": "2.0.0",
"_model_name": "LayoutModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "LayoutView",
"align_content": null,
"align_items": null,
"align_self": null,
"border_bottom": null,
"border_left": null,
"border_right": null,
"border_top": null,
"bottom": null,
"display": null,
"flex": null,
"flex_flow": null,
"grid_area": null,
"grid_auto_columns": null,
"grid_auto_flow": null,
"grid_auto_rows": null,
"grid_column": null,
"grid_gap": null,
"grid_row": null,
"grid_template_areas": null,
"grid_template_columns": null,
"grid_template_rows": null,
"height": null,
"justify_content": null,
"justify_items": null,
"left": null,
"margin": null,
"max_height": null,
"max_width": null,
"min_height": null,
"min_width": null,
"object_fit": null,
"object_position": null,
"order": null,
"overflow": null,
"padding": null,
"right": null,
"top": null,
"visibility": null,
"width": null
}
},
"1fda7f61ebac4fd59494b1efafddf4ed": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "FloatProgressModel",
"state": {
"_dom_classes": [],
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "FloatProgressModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/controls",
"_view_module_version": "2.0.0",
"_view_name": "ProgressView",
"bar_style": "success",
"description": "",
"description_allow_html": false,
"layout": "IPY_MODEL_536f4f8f08ce464db0ad9b82a8db0a55",
"max": 265,
"min": 0,
"orientation": "horizontal",
"style": "IPY_MODEL_21f5adf3204042a68ed591baf404d8d0",
"tabbable": null,
"tooltip": null,
"value": 265
}
},
"2032e3b54123455db3e474b9c5d2757c": {
"model_module": "@jupyter-widgets/base",
"model_module_version": "2.0.0",
"model_name": "LayoutModel",
"state": {
"_model_module": "@jupyter-widgets/base",
"_model_module_version": "2.0.0",
"_model_name": "LayoutModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "LayoutView",
"align_content": null,
"align_items": null,
"align_self": null,
"border_bottom": null,
"border_left": null,
"border_right": null,
"border_top": null,
"bottom": null,
"display": null,
"flex": null,
"flex_flow": null,
"grid_area": null,
"grid_auto_columns": null,
"grid_auto_flow": null,
"grid_auto_rows": null,
"grid_column": null,
"grid_gap": null,
"grid_row": null,
"grid_template_areas": null,
"grid_template_columns": null,
"grid_template_rows": null,
"height": null,
"justify_content": null,
"justify_items": null,
"left": null,
"margin": null,
"max_height": null,
"max_width": null,
"min_height": null,
"min_width": null,
"object_fit": null,
"object_position": null,
"order": null,
"overflow": null,
"padding": null,
"right": null,
"top": null,
"visibility": null,
"width": null
}
},
"20adb4fc85f148ef9b580cc250c6d1d8": {
"model_module": "@jupyter-widgets/base",
"model_module_version": "2.0.0",
"model_name": "LayoutModel",
"state": {
"_model_module": "@jupyter-widgets/base",
"_model_module_version": "2.0.0",
"_model_name": "LayoutModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "LayoutView",
"align_content": null,
"align_items": null,
"align_self": null,
"border_bottom": null,
"border_left": null,
"border_right": null,
"border_top": null,
"bottom": null,
"display": null,
"flex": null,
"flex_flow": null,
"grid_area": null,
"grid_auto_columns": null,
"grid_auto_flow": null,
"grid_auto_rows": null,
"grid_column": null,
"grid_gap": null,
"grid_row": null,
"grid_template_areas": null,
"grid_template_columns": null,
"grid_template_rows": null,
"height": null,
"justify_content": null,
"justify_items": null,
"left": null,
"margin": null,
"max_height": null,
"max_width": null,
"min_height": null,
"min_width": null,
"object_fit": null,
"object_position": null,
"order": null,
"overflow": null,
"padding": null,
"right": null,
"top": null,
"visibility": null,
"width": null
}
},
"20d7d61ca5b44304ab0302398c355fa3": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "HTMLModel",
"state": {
"_dom_classes": [],
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "HTMLModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/controls",
"_view_module_version": "2.0.0",
"_view_name": "HTMLView",
"description": "",
"description_allow_html": false,
"layout": "IPY_MODEL_0ff65d8764014fedb4625e377053e10a",
"placeholder": "",
"style": "IPY_MODEL_caaa672e7f0e41c689e2aedc61a91e90",
"tabbable": null,
"tooltip": null,
"value": " 1371/1371 [00:15<00:00, 103.03 examples/s]"
}
},
"20f5cd5031ba4bd0a13f81e79395e7ee": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "HTMLStyleModel",
"state": {
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "HTMLStyleModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "StyleView",
"background": null,
"description_width": "",
"font_size": null,
"text_color": null
}
},
"21f5adf3204042a68ed591baf404d8d0": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "ProgressStyleModel",
"state": {
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "ProgressStyleModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "StyleView",
"bar_color": null,
"description_width": ""
}
},
"22e0d8d060234794a0b27b59a0680a53": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "HTMLStyleModel",
"state": {
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "HTMLStyleModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "StyleView",
"background": null,
"description_width": "",
"font_size": null,
"text_color": null
}
},
"22f55f822c1f477687db3b019bec40a0": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "HTMLStyleModel",
"state": {
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "HTMLStyleModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "StyleView",
"background": null,
"description_width": "",
"font_size": null,
"text_color": null
}
},
"2326fdd2f2614c1285f576fc199f1b42": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "HTMLModel",
"state": {
"_dom_classes": [],
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "HTMLModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/controls",
"_view_module_version": "2.0.0",
"_view_name": "HTMLView",
"description": "",
"description_allow_html": false,
"layout": "IPY_MODEL_f9fad5e5b63f45819bf724bb47d4845e",
"placeholder": "",
"style": "IPY_MODEL_91dadc17dc754c9e9c98463f591d14fd",
"tabbable": null,
"tooltip": null,
"value": "Computing checksums: 100%"
}
},
"2353243d97be4dd8b54c34c8d83e59b3": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "HTMLModel",
"state": {
"_dom_classes": [],
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "HTMLModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/controls",
"_view_module_version": "2.0.0",
"_view_name": "HTMLView",
"description": "",
"description_allow_html": false,
"layout": "IPY_MODEL_12389d5818c744e9baa2feca734d26a1",
"placeholder": "",
"style": "IPY_MODEL_3902b895a6634ecb9f1d481ed891337b",
"tabbable": null,
"tooltip": null,
"value": " 613/613 [00:00<00:00, 55.2kB/s]"
}
},
"23e04a006a27410f9c8f72e22e90bb35": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "HBoxModel",
"state": {
"_dom_classes": [],
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "HBoxModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/controls",
"_view_module_version": "2.0.0",
"_view_name": "HBoxView",
"box_style": "",
"children": [
"IPY_MODEL_e84163c9f9f7423f9699ee3128175a6f",
"IPY_MODEL_1fda7f61ebac4fd59494b1efafddf4ed",
"IPY_MODEL_c016fe5bd4284aaea0322b2282c771f4"
],
"layout": "IPY_MODEL_c4cf5800803b47b384fa0935dc83481a",
"tabbable": null,
"tooltip": null
}
},
"2921f9a997734756a52e11b05ba07365": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "HTMLStyleModel",
"state": {
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "HTMLStyleModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "StyleView",
"background": null,
"description_width": "",
"font_size": null,
"text_color": null
}
},
"2abad561eb734b8ea2bdb1e3fe18ad72": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "FloatProgressModel",
"state": {
"_dom_classes": [],
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "FloatProgressModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/controls",
"_view_module_version": "2.0.0",
"_view_name": "ProgressView",
"bar_style": "success",
"description": "",
"description_allow_html": false,
"layout": "IPY_MODEL_ea5bb7d0a2e74221bbc4627997e20025",
"max": 339,
"min": 0,
"orientation": "horizontal",
"style": "IPY_MODEL_90c2c47ecbe54cbabdaaef37f1b2e47f",
"tabbable": null,
"tooltip": null,
"value": 339
}
},
"2c981621578343b0834b8890c8f9ac00": {
"model_module": "@jupyter-widgets/base",
"model_module_version": "2.0.0",
"model_name": "LayoutModel",
"state": {
"_model_module": "@jupyter-widgets/base",
"_model_module_version": "2.0.0",
"_model_name": "LayoutModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "LayoutView",
"align_content": null,
"align_items": null,
"align_self": null,
"border_bottom": null,
"border_left": null,
"border_right": null,
"border_top": null,
"bottom": null,
"display": null,
"flex": null,
"flex_flow": null,
"grid_area": null,
"grid_auto_columns": null,
"grid_auto_flow": null,
"grid_auto_rows": null,
"grid_column": null,
"grid_gap": null,
"grid_row": null,
"grid_template_areas": null,
"grid_template_columns": null,
"grid_template_rows": null,
"height": null,
"justify_content": null,
"justify_items": null,
"left": null,
"margin": null,
"max_height": null,
"max_width": null,
"min_height": null,
"min_width": null,
"object_fit": null,
"object_position": null,
"order": null,
"overflow": null,
"padding": null,
"right": null,
"top": null,
"visibility": null,
"width": null
}
},
"2d45baebafd34e1db080ace860b2ee50": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "ProgressStyleModel",
"state": {
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "ProgressStyleModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "StyleView",
"bar_color": null,
"description_width": ""
}
},
"2d6682f461014dc292303a40c99d4dfe": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "FloatProgressModel",
"state": {
"_dom_classes": [],
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "FloatProgressModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/controls",
"_view_module_version": "2.0.0",
"_view_name": "ProgressView",
"bar_style": "success",
"description": "",
"description_allow_html": false,
"layout": "IPY_MODEL_79f538f4772c40f59164c873e74ea19a",
"max": 500,
"min": 0,
"orientation": "horizontal",
"style": "IPY_MODEL_accb2a8b75ff402ca2e9dfd1d218dd9c",
"tabbable": null,
"tooltip": null,
"value": 500
}
},
"2e8fc98a2c6f47fcbc248c7b3dea2ca6": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "HTMLModel",
"state": {
"_dom_classes": [],
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "HTMLModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/controls",
"_view_module_version": "2.0.0",
"_view_name": "HTMLView",
"description": "",
"description_allow_html": false,
"layout": "IPY_MODEL_ef232c2eadeb45f69a35cd6fecbf6ccd",
"placeholder": "",
"style": "IPY_MODEL_a13b092dcd9a4142a539fa73435755f8",
"tabbable": null,
"tooltip": null,
"value": "tokenizer.json: "
}
},
"2f4a2b63407b4d5b9021ff395119bfbb": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "HBoxModel",
"state": {
"_dom_classes": [],
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "HBoxModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/controls",
"_view_module_version": "2.0.0",
"_view_name": "HBoxView",
"box_style": "",
"children": [
"IPY_MODEL_5dfce204a59748c18355a283c8254a05",
"IPY_MODEL_67676fb0c80f466b9505fce8d4eb5125",
"IPY_MODEL_02d8ec7a356b40b687dd33a36bbcb68e"
],
"layout": "IPY_MODEL_3fd5383ca95642ad8fdefae6bcc1f708",
"tabbable": null,
"tooltip": null
}
},
"2fcb73ac60d24fe4a15ac03cf8e5ace1": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "FloatProgressModel",
"state": {
"_dom_classes": [],
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "FloatProgressModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/controls",
"_view_module_version": "2.0.0",
"_view_name": "ProgressView",
"bar_style": "success",
"description": "",
"description_allow_html": false,
"layout": "IPY_MODEL_c235a89aaf2e4a1fa7f8a9b9251866e5",
"max": 613,
"min": 0,
"orientation": "horizontal",
"style": "IPY_MODEL_ff2f7e13305e40e5899988f584357d59",
"tabbable": null,
"tooltip": null,
"value": 613
}
},
"30c0e62701304a329c4815647ae23b1f": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "HTMLStyleModel",
"state": {
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "HTMLStyleModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "StyleView",
"background": null,
"description_width": "",
"font_size": null,
"text_color": null
}
},
"3295e6840d42403b96cbe1eb8a5b26b1": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "HTMLStyleModel",
"state": {
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "HTMLStyleModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "StyleView",
"background": null,
"description_width": "",
"font_size": null,
"text_color": null
}
},
"33133bb603164cb192afe0cdb9d4c9cf": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "HTMLStyleModel",
"state": {
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "HTMLStyleModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "StyleView",
"background": null,
"description_width": "",
"font_size": null,
"text_color": null
}
},
"344cd0c600044103849f4e656464a091": {
"model_module": "@jupyter-widgets/base",
"model_module_version": "2.0.0",
"model_name": "LayoutModel",
"state": {
"_model_module": "@jupyter-widgets/base",
"_model_module_version": "2.0.0",
"_model_name": "LayoutModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "LayoutView",
"align_content": null,
"align_items": null,
"align_self": null,
"border_bottom": null,
"border_left": null,
"border_right": null,
"border_top": null,
"bottom": null,
"display": null,
"flex": null,
"flex_flow": null,
"grid_area": null,
"grid_auto_columns": null,
"grid_auto_flow": null,
"grid_auto_rows": null,
"grid_column": null,
"grid_gap": null,
"grid_row": null,
"grid_template_areas": null,
"grid_template_columns": null,
"grid_template_rows": null,
"height": null,
"justify_content": null,
"justify_items": null,
"left": null,
"margin": null,
"max_height": null,
"max_width": null,
"min_height": null,
"min_width": null,
"object_fit": null,
"object_position": null,
"order": null,
"overflow": null,
"padding": null,
"right": null,
"top": null,
"visibility": null,
"width": null
}
},
"346d15cbf2414d1cbba91de6ecfd5f62": {
"model_module": "@jupyter-widgets/base",
"model_module_version": "2.0.0",
"model_name": "LayoutModel",
"state": {
"_model_module": "@jupyter-widgets/base",
"_model_module_version": "2.0.0",
"_model_name": "LayoutModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "LayoutView",
"align_content": null,
"align_items": null,
"align_self": null,
"border_bottom": null,
"border_left": null,
"border_right": null,
"border_top": null,
"bottom": null,
"display": null,
"flex": null,
"flex_flow": null,
"grid_area": null,
"grid_auto_columns": null,
"grid_auto_flow": null,
"grid_auto_rows": null,
"grid_column": null,
"grid_gap": null,
"grid_row": null,
"grid_template_areas": null,
"grid_template_columns": null,
"grid_template_rows": null,
"height": null,
"justify_content": null,
"justify_items": null,
"left": null,
"margin": null,
"max_height": null,
"max_width": null,
"min_height": null,
"min_width": null,
"object_fit": null,
"object_position": null,
"order": null,
"overflow": null,
"padding": null,
"right": null,
"top": null,
"visibility": null,
"width": null
}
},
"35eb03e850d54545a42375819dcf3905": {
"model_module": "@jupyter-widgets/base",
"model_module_version": "2.0.0",
"model_name": "LayoutModel",
"state": {
"_model_module": "@jupyter-widgets/base",
"_model_module_version": "2.0.0",
"_model_name": "LayoutModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "LayoutView",
"align_content": null,
"align_items": null,
"align_self": null,
"border_bottom": null,
"border_left": null,
"border_right": null,
"border_top": null,
"bottom": null,
"display": null,
"flex": null,
"flex_flow": null,
"grid_area": null,
"grid_auto_columns": null,
"grid_auto_flow": null,
"grid_auto_rows": null,
"grid_column": null,
"grid_gap": null,
"grid_row": null,
"grid_template_areas": null,
"grid_template_columns": null,
"grid_template_rows": null,
"height": null,
"justify_content": null,
"justify_items": null,
"left": null,
"margin": null,
"max_height": null,
"max_width": null,
"min_height": null,
"min_width": null,
"object_fit": null,
"object_position": null,
"order": null,
"overflow": null,
"padding": null,
"right": null,
"top": null,
"visibility": null,
"width": null
}
},
"362b04347cc44c1e87383ab76c53a695": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "HTMLModel",
"state": {
"_dom_classes": [],
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "HTMLModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/controls",
"_view_module_version": "2.0.0",
"_view_name": "HTMLView",
"description": "",
"description_allow_html": false,
"layout": "IPY_MODEL_ced9eb5361ea4544a3353e6795ab4748",
"placeholder": "",
"style": "IPY_MODEL_20f5cd5031ba4bd0a13f81e79395e7ee",
"tabbable": null,
"tooltip": null,
"value": " 83.9k/83.9k [00:00<00:00, 420kB/s]"
}
},
"3749de0723d147bfa19896df8b9a2a7c": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "ProgressStyleModel",
"state": {
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "ProgressStyleModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "StyleView",
"bar_color": null,
"description_width": ""
}
},
"37af40fc030748beba1da714188f43a9": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "FloatProgressModel",
"state": {
"_dom_classes": [],
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "FloatProgressModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/controls",
"_view_module_version": "2.0.0",
"_view_name": "ProgressView",
"bar_style": "success",
"description": "",
"description_allow_html": false,
"layout": "IPY_MODEL_0395e3812ba24f2b9ebc17485fa58437",
"max": 632,
"min": 0,
"orientation": "horizontal",
"style": "IPY_MODEL_84338cd567a4444e8d52ed963c99a498",
"tabbable": null,
"tooltip": null,
"value": 632
}
},
"3902b895a6634ecb9f1d481ed891337b": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "HTMLStyleModel",
"state": {
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "HTMLStyleModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "StyleView",
"background": null,
"description_width": "",
"font_size": null,
"text_color": null
}
},
"3bd4f8958ef0474f8ac1866ff77e4ae7": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "HTMLStyleModel",
"state": {
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "HTMLStyleModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "StyleView",
"background": null,
"description_width": "",
"font_size": null,
"text_color": null
}
},
"3c5c8e93c810475e89aaed7555ba9102": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "HTMLModel",
"state": {
"_dom_classes": [],
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "HTMLModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/controls",
"_view_module_version": "2.0.0",
"_view_name": "HTMLView",
"description": "",
"description_allow_html": false,
"layout": "IPY_MODEL_82329a907c324c7186f33c13aa32c997",
"placeholder": "",
"style": "IPY_MODEL_3d675815e650459591570abfac4433fb",
"tabbable": null,
"tooltip": null,
"value": "README.md: "
}
},
"3d14ac7f692644eb89454650dd2dae1f": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "FloatProgressModel",
"state": {
"_dom_classes": [],
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "FloatProgressModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/controls",
"_view_module_version": "2.0.0",
"_view_name": "ProgressView",
"bar_style": "success",
"description": "",
"description_allow_html": false,
"layout": "IPY_MODEL_5bb39271f8ae47acbe6a5e1bc032bcb1",
"max": 1,
"min": 0,
"orientation": "horizontal",
"style": "IPY_MODEL_4e9502fbe0b5441aab3f652c2e26845e",
"tabbable": null,
"tooltip": null,
"value": 1
}
},
"3d5a3d499b9644428bd08c82ca5fbed3": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "HTMLModel",
"state": {
"_dom_classes": [],
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "HTMLModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/controls",
"_view_module_version": "2.0.0",
"_view_name": "HTMLView",
"description": "",
"description_allow_html": false,
"layout": "IPY_MODEL_41ef0f577c804db9a66a32a9d42a9f0e",
"placeholder": "",
"style": "IPY_MODEL_b172dc909a374a80b6dc073551c7e092",
"tabbable": null,
"tooltip": null,
"value": "Unsloth: Tokenizing ["text"] (num_proc=8): 100%"
}
},
"3d675815e650459591570abfac4433fb": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "HTMLStyleModel",
"state": {
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "HTMLStyleModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "StyleView",
"background": null,
"description_width": "",
"font_size": null,
"text_color": null
}
},
"3e3e826cd7c6447996bcaa0d60151e54": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "HTMLStyleModel",
"state": {
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "HTMLStyleModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "StyleView",
"background": null,
"description_width": "",
"font_size": null,
"text_color": null
}
},
"3e50178b631b41b0998fab4e8c97776a": {
"model_module": "@jupyter-widgets/base",
"model_module_version": "2.0.0",
"model_name": "LayoutModel",
"state": {
"_model_module": "@jupyter-widgets/base",
"_model_module_version": "2.0.0",
"_model_name": "LayoutModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "LayoutView",
"align_content": null,
"align_items": null,
"align_self": null,
"border_bottom": null,
"border_left": null,
"border_right": null,
"border_top": null,
"bottom": null,
"display": null,
"flex": null,
"flex_flow": null,
"grid_area": null,
"grid_auto_columns": null,
"grid_auto_flow": null,
"grid_auto_rows": null,
"grid_column": null,
"grid_gap": null,
"grid_row": null,
"grid_template_areas": null,
"grid_template_columns": null,
"grid_template_rows": null,
"height": null,
"justify_content": null,
"justify_items": null,
"left": null,
"margin": null,
"max_height": null,
"max_width": null,
"min_height": null,
"min_width": null,
"object_fit": null,
"object_position": null,
"order": null,
"overflow": null,
"padding": null,
"right": null,
"top": null,
"visibility": null,
"width": null
}
},
"3e8d3d4e1c6f4c3db0f1b6c87f2e1233": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "FloatProgressModel",
"state": {
"_dom_classes": [],
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "FloatProgressModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/controls",
"_view_module_version": "2.0.0",
"_view_name": "ProgressView",
"bar_style": "success",
"description": "",
"description_allow_html": false,
"layout": "IPY_MODEL_b1256f6314ff488c8a785ad87186fefd",
"max": 164,
"min": 0,
"orientation": "horizontal",
"style": "IPY_MODEL_42303097f0f94c24b91f57e19b482500",
"tabbable": null,
"tooltip": null,
"value": 164
}
},
"3f1daeb1140c489a94cee551517bed35": {
"model_module": "@jupyter-widgets/base",
"model_module_version": "2.0.0",
"model_name": "LayoutModel",
"state": {
"_model_module": "@jupyter-widgets/base",
"_model_module_version": "2.0.0",
"_model_name": "LayoutModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "LayoutView",
"align_content": null,
"align_items": null,
"align_self": null,
"border_bottom": null,
"border_left": null,
"border_right": null,
"border_top": null,
"bottom": null,
"display": null,
"flex": null,
"flex_flow": null,
"grid_area": null,
"grid_auto_columns": null,
"grid_auto_flow": null,
"grid_auto_rows": null,
"grid_column": null,
"grid_gap": null,
"grid_row": null,
"grid_template_areas": null,
"grid_template_columns": null,
"grid_template_rows": null,
"height": null,
"justify_content": null,
"justify_items": null,
"left": null,
"margin": null,
"max_height": null,
"max_width": null,
"min_height": null,
"min_width": null,
"object_fit": null,
"object_position": null,
"order": null,
"overflow": null,
"padding": null,
"right": null,
"top": null,
"visibility": null,
"width": null
}
},
"3f68c588c2fb4ac6976ba3f763287f46": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "HTMLStyleModel",
"state": {
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "HTMLStyleModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "StyleView",
"background": null,
"description_width": "",
"font_size": null,
"text_color": null
}
},
"3f7dbc14960a4c1f83c504fed871c870": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "HTMLModel",
"state": {
"_dom_classes": [],
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "HTMLModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/controls",
"_view_module_version": "2.0.0",
"_view_name": "HTMLView",
"description": "",
"description_allow_html": false,
"layout": "IPY_MODEL_16bc0ccc64524e87897f7584166b17c0",
"placeholder": "",
"style": "IPY_MODEL_ee45bf2d57a24250ba88e2edb060b41b",
"tabbable": null,
"tooltip": null,
"value": " 5.55G/5.55G [00:21<00:00, 684MB/s]"
}
},
"3fd5383ca95642ad8fdefae6bcc1f708": {
"model_module": "@jupyter-widgets/base",
"model_module_version": "2.0.0",
"model_name": "LayoutModel",
"state": {
"_model_module": "@jupyter-widgets/base",
"_model_module_version": "2.0.0",
"_model_name": "LayoutModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "LayoutView",
"align_content": null,
"align_items": null,
"align_self": null,
"border_bottom": null,
"border_left": null,
"border_right": null,
"border_top": null,
"bottom": null,
"display": null,
"flex": null,
"flex_flow": null,
"grid_area": null,
"grid_auto_columns": null,
"grid_auto_flow": null,
"grid_auto_rows": null,
"grid_column": null,
"grid_gap": null,
"grid_row": null,
"grid_template_areas": null,
"grid_template_columns": null,
"grid_template_rows": null,
"height": null,
"justify_content": null,
"justify_items": null,
"left": null,
"margin": null,
"max_height": null,
"max_width": null,
"min_height": null,
"min_width": null,
"object_fit": null,
"object_position": null,
"order": null,
"overflow": null,
"padding": null,
"right": null,
"top": null,
"visibility": null,
"width": null
}
},
"41ef0f577c804db9a66a32a9d42a9f0e": {
"model_module": "@jupyter-widgets/base",
"model_module_version": "2.0.0",
"model_name": "LayoutModel",
"state": {
"_model_module": "@jupyter-widgets/base",
"_model_module_version": "2.0.0",
"_model_name": "LayoutModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "LayoutView",
"align_content": null,
"align_items": null,
"align_self": null,
"border_bottom": null,
"border_left": null,
"border_right": null,
"border_top": null,
"bottom": null,
"display": null,
"flex": null,
"flex_flow": null,
"grid_area": null,
"grid_auto_columns": null,
"grid_auto_flow": null,
"grid_auto_rows": null,
"grid_column": null,
"grid_gap": null,
"grid_row": null,
"grid_template_areas": null,
"grid_template_columns": null,
"grid_template_rows": null,
"height": null,
"justify_content": null,
"justify_items": null,
"left": null,
"margin": null,
"max_height": null,
"max_width": null,
"min_height": null,
"min_width": null,
"object_fit": null,
"object_position": null,
"order": null,
"overflow": null,
"padding": null,
"right": null,
"top": null,
"visibility": null,
"width": null
}
},
"41efab2c12174ee8af99242ea44c7560": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "ProgressStyleModel",
"state": {
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "ProgressStyleModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "StyleView",
"bar_color": null,
"description_width": ""
}
},
"42303097f0f94c24b91f57e19b482500": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "ProgressStyleModel",
"state": {
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "ProgressStyleModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "StyleView",
"bar_color": null,
"description_width": ""
}
},
"4492af2ef3644d9f92ee65620ef5e44b": {
"model_module": "@jupyter-widgets/base",
"model_module_version": "2.0.0",
"model_name": "LayoutModel",
"state": {
"_model_module": "@jupyter-widgets/base",
"_model_module_version": "2.0.0",
"_model_name": "LayoutModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "LayoutView",
"align_content": null,
"align_items": null,
"align_self": null,
"border_bottom": null,
"border_left": null,
"border_right": null,
"border_top": null,
"bottom": null,
"display": null,
"flex": null,
"flex_flow": null,
"grid_area": null,
"grid_auto_columns": null,
"grid_auto_flow": null,
"grid_auto_rows": null,
"grid_column": null,
"grid_gap": null,
"grid_row": null,
"grid_template_areas": null,
"grid_template_columns": null,
"grid_template_rows": null,
"height": null,
"justify_content": null,
"justify_items": null,
"left": null,
"margin": null,
"max_height": null,
"max_width": null,
"min_height": null,
"min_width": null,
"object_fit": null,
"object_position": null,
"order": null,
"overflow": null,
"padding": null,
"right": null,
"top": null,
"visibility": null,
"width": null
}
},
"45040783dd4c45c98f948ced425e85c7": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "FloatProgressModel",
"state": {
"_dom_classes": [],
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "FloatProgressModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/controls",
"_view_module_version": "2.0.0",
"_view_name": "ProgressView",
"bar_style": "success",
"description": "",
"description_allow_html": false,
"layout": "IPY_MODEL_bd80656cb338404c81efd5db34737157",
"max": 1,
"min": 0,
"orientation": "horizontal",
"style": "IPY_MODEL_3749de0723d147bfa19896df8b9a2a7c",
"tabbable": null,
"tooltip": null,
"value": 1
}
},
"4626f5b148024aac881ed03a0f5255aa": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "HTMLModel",
"state": {
"_dom_classes": [],
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "HTMLModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/controls",
"_view_module_version": "2.0.0",
"_view_name": "HTMLView",
"description": "",
"description_allow_html": false,
"layout": "IPY_MODEL_e02eef7123004f49a3833585ca8e7d63",
"placeholder": "",
"style": "IPY_MODEL_22f55f822c1f477687db3b019bec40a0",
"tabbable": null,
"tooltip": null,
"value": "data/test-00000-of-00001.parquet: 100%"
}
},
"462c6bdffc6849f39ac26fb783f9f48d": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "HTMLStyleModel",
"state": {
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "HTMLStyleModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "StyleView",
"background": null,
"description_width": "",
"font_size": null,
"text_color": null
}
},
"47ef65d8a1b348548e1eaabe4a6897dd": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "HTMLModel",
"state": {
"_dom_classes": [],
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "HTMLModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/controls",
"_view_module_version": "2.0.0",
"_view_name": "HTMLView",
"description": "",
"description_allow_html": false,
"layout": "IPY_MODEL_a3434a884f7f47eb83a4f0de5366f5a7",
"placeholder": "",
"style": "IPY_MODEL_71b9cf0fb304482e81dd030dd3d69251",
"tabbable": null,
"tooltip": null,
"value": "added_tokens.json: 100%"
}
},
"489fbee8a75645169a3dab2e7218889b": {
"model_module": "@jupyter-widgets/base",
"model_module_version": "2.0.0",
"model_name": "LayoutModel",
"state": {
"_model_module": "@jupyter-widgets/base",
"_model_module_version": "2.0.0",
"_model_name": "LayoutModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "LayoutView",
"align_content": null,
"align_items": null,
"align_self": null,
"border_bottom": null,
"border_left": null,
"border_right": null,
"border_top": null,
"bottom": null,
"display": null,
"flex": null,
"flex_flow": null,
"grid_area": null,
"grid_auto_columns": null,
"grid_auto_flow": null,
"grid_auto_rows": null,
"grid_column": null,
"grid_gap": null,
"grid_row": null,
"grid_template_areas": null,
"grid_template_columns": null,
"grid_template_rows": null,
"height": null,
"justify_content": null,
"justify_items": null,
"left": null,
"margin": null,
"max_height": null,
"max_width": null,
"min_height": null,
"min_width": null,
"object_fit": null,
"object_position": null,
"order": null,
"overflow": null,
"padding": null,
"right": null,
"top": null,
"visibility": null,
"width": null
}
},
"4b42b08ba7c04b1b96d8987f3115fb38": {
"model_module": "@jupyter-widgets/base",
"model_module_version": "2.0.0",
"model_name": "LayoutModel",
"state": {
"_model_module": "@jupyter-widgets/base",
"_model_module_version": "2.0.0",
"_model_name": "LayoutModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "LayoutView",
"align_content": null,
"align_items": null,
"align_self": null,
"border_bottom": null,
"border_left": null,
"border_right": null,
"border_top": null,
"bottom": null,
"display": null,
"flex": null,
"flex_flow": null,
"grid_area": null,
"grid_auto_columns": null,
"grid_auto_flow": null,
"grid_auto_rows": null,
"grid_column": null,
"grid_gap": null,
"grid_row": null,
"grid_template_areas": null,
"grid_template_columns": null,
"grid_template_rows": null,
"height": null,
"justify_content": null,
"justify_items": null,
"left": null,
"margin": null,
"max_height": null,
"max_width": null,
"min_height": null,
"min_width": null,
"object_fit": null,
"object_position": null,
"order": null,
"overflow": null,
"padding": null,
"right": null,
"top": null,
"visibility": null,
"width": null
}
},
"4b6bc0b5e99f434580ae27b78e49a451": {
"model_module": "@jupyter-widgets/base",
"model_module_version": "2.0.0",
"model_name": "LayoutModel",
"state": {
"_model_module": "@jupyter-widgets/base",
"_model_module_version": "2.0.0",
"_model_name": "LayoutModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "LayoutView",
"align_content": null,
"align_items": null,
"align_self": null,
"border_bottom": null,
"border_left": null,
"border_right": null,
"border_top": null,
"bottom": null,
"display": null,
"flex": null,
"flex_flow": null,
"grid_area": null,
"grid_auto_columns": null,
"grid_auto_flow": null,
"grid_auto_rows": null,
"grid_column": null,
"grid_gap": null,
"grid_row": null,
"grid_template_areas": null,
"grid_template_columns": null,
"grid_template_rows": null,
"height": null,
"justify_content": null,
"justify_items": null,
"left": null,
"margin": null,
"max_height": null,
"max_width": null,
"min_height": null,
"min_width": null,
"object_fit": null,
"object_position": null,
"order": null,
"overflow": null,
"padding": null,
"right": null,
"top": null,
"visibility": null,
"width": null
}
},
"4e9502fbe0b5441aab3f652c2e26845e": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "ProgressStyleModel",
"state": {
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "ProgressStyleModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "StyleView",
"bar_color": null,
"description_width": ""
}
},
"4f2f58a661a54c13b2d7e2eb3d56594c": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "HTMLStyleModel",
"state": {
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "HTMLStyleModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "StyleView",
"background": null,
"description_width": "",
"font_size": null,
"text_color": null
}
},
"518aa2a7d0e640c3a6d2275d02ec1a29": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "ProgressStyleModel",
"state": {
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "ProgressStyleModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "StyleView",
"bar_color": null,
"description_width": ""
}
},
"5270a56277534bf79b006c356bb0a692": {
"model_module": "@jupyter-widgets/base",
"model_module_version": "2.0.0",
"model_name": "LayoutModel",
"state": {
"_model_module": "@jupyter-widgets/base",
"_model_module_version": "2.0.0",
"_model_name": "LayoutModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "LayoutView",
"align_content": null,
"align_items": null,
"align_self": null,
"border_bottom": null,
"border_left": null,
"border_right": null,
"border_top": null,
"bottom": null,
"display": null,
"flex": null,
"flex_flow": null,
"grid_area": null,
"grid_auto_columns": null,
"grid_auto_flow": null,
"grid_auto_rows": null,
"grid_column": null,
"grid_gap": null,
"grid_row": null,
"grid_template_areas": null,
"grid_template_columns": null,
"grid_template_rows": null,
"height": null,
"justify_content": null,
"justify_items": null,
"left": null,
"margin": null,
"max_height": null,
"max_width": null,
"min_height": null,
"min_width": null,
"object_fit": null,
"object_position": null,
"order": null,
"overflow": null,
"padding": null,
"right": null,
"top": null,
"visibility": null,
"width": null
}
},
"536f4f8f08ce464db0ad9b82a8db0a55": {
"model_module": "@jupyter-widgets/base",
"model_module_version": "2.0.0",
"model_name": "LayoutModel",
"state": {
"_model_module": "@jupyter-widgets/base",
"_model_module_version": "2.0.0",
"_model_name": "LayoutModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "LayoutView",
"align_content": null,
"align_items": null,
"align_self": null,
"border_bottom": null,
"border_left": null,
"border_right": null,
"border_top": null,
"bottom": null,
"display": null,
"flex": null,
"flex_flow": null,
"grid_area": null,
"grid_auto_columns": null,
"grid_auto_flow": null,
"grid_auto_rows": null,
"grid_column": null,
"grid_gap": null,
"grid_row": null,
"grid_template_areas": null,
"grid_template_columns": null,
"grid_template_rows": null,
"height": null,
"justify_content": null,
"justify_items": null,
"left": null,
"margin": null,
"max_height": null,
"max_width": null,
"min_height": null,
"min_width": null,
"object_fit": null,
"object_position": null,
"order": null,
"overflow": null,
"padding": null,
"right": null,
"top": null,
"visibility": null,
"width": null
}
},
"553ca1b5d8444ba9bbda273c5f0b2921": {
"model_module": "@jupyter-widgets/base",
"model_module_version": "2.0.0",
"model_name": "LayoutModel",
"state": {
"_model_module": "@jupyter-widgets/base",
"_model_module_version": "2.0.0",
"_model_name": "LayoutModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "LayoutView",
"align_content": null,
"align_items": null,
"align_self": null,
"border_bottom": null,
"border_left": null,
"border_right": null,
"border_top": null,
"bottom": null,
"display": null,
"flex": null,
"flex_flow": null,
"grid_area": null,
"grid_auto_columns": null,
"grid_auto_flow": null,
"grid_auto_rows": null,
"grid_column": null,
"grid_gap": null,
"grid_row": null,
"grid_template_areas": null,
"grid_template_columns": null,
"grid_template_rows": null,
"height": null,
"justify_content": null,
"justify_items": null,
"left": null,
"margin": null,
"max_height": null,
"max_width": null,
"min_height": null,
"min_width": null,
"object_fit": null,
"object_position": null,
"order": null,
"overflow": null,
"padding": null,
"right": null,
"top": null,
"visibility": null,
"width": null
}
},
"55c6da36584d41cab593320d592f01d0": {
"model_module": "@jupyter-widgets/base",
"model_module_version": "2.0.0",
"model_name": "LayoutModel",
"state": {
"_model_module": "@jupyter-widgets/base",
"_model_module_version": "2.0.0",
"_model_name": "LayoutModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "LayoutView",
"align_content": null,
"align_items": null,
"align_self": null,
"border_bottom": null,
"border_left": null,
"border_right": null,
"border_top": null,
"bottom": null,
"display": null,
"flex": null,
"flex_flow": null,
"grid_area": null,
"grid_auto_columns": null,
"grid_auto_flow": null,
"grid_auto_rows": null,
"grid_column": null,
"grid_gap": null,
"grid_row": null,
"grid_template_areas": null,
"grid_template_columns": null,
"grid_template_rows": null,
"height": null,
"justify_content": null,
"justify_items": null,
"left": null,
"margin": null,
"max_height": null,
"max_width": null,
"min_height": null,
"min_width": null,
"object_fit": null,
"object_position": null,
"order": null,
"overflow": null,
"padding": null,
"right": null,
"top": null,
"visibility": null,
"width": null
}
},
"55ebe3eac126490595aa6c5d137c1cb0": {
"model_module": "@jupyter-widgets/base",
"model_module_version": "2.0.0",
"model_name": "LayoutModel",
"state": {
"_model_module": "@jupyter-widgets/base",
"_model_module_version": "2.0.0",
"_model_name": "LayoutModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "LayoutView",
"align_content": null,
"align_items": null,
"align_self": null,
"border_bottom": null,
"border_left": null,
"border_right": null,
"border_top": null,
"bottom": null,
"display": null,
"flex": null,
"flex_flow": null,
"grid_area": null,
"grid_auto_columns": null,
"grid_auto_flow": null,
"grid_auto_rows": null,
"grid_column": null,
"grid_gap": null,
"grid_row": null,
"grid_template_areas": null,
"grid_template_columns": null,
"grid_template_rows": null,
"height": null,
"justify_content": null,
"justify_items": null,
"left": null,
"margin": null,
"max_height": null,
"max_width": null,
"min_height": null,
"min_width": null,
"object_fit": null,
"object_position": null,
"order": null,
"overflow": null,
"padding": null,
"right": null,
"top": null,
"visibility": null,
"width": null
}
},
"56442e2a723c4d28b64166ebedd08c02": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "HBoxModel",
"state": {
"_dom_classes": [],
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "HBoxModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/controls",
"_view_module_version": "2.0.0",
"_view_name": "HBoxView",
"box_style": "",
"children": [
"IPY_MODEL_47ef65d8a1b348548e1eaabe4a6897dd",
"IPY_MODEL_37af40fc030748beba1da714188f43a9",
"IPY_MODEL_05aba5434ed0466dbb8c160b88eded1b"
],
"layout": "IPY_MODEL_3f1daeb1140c489a94cee551517bed35",
"tabbable": null,
"tooltip": null
}
},
"56cc23e172d74df6bad972c4de3179f0": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "HBoxModel",
"state": {
"_dom_classes": [],
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "HBoxModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/controls",
"_view_module_version": "2.0.0",
"_view_name": "HBoxView",
"box_style": "",
"children": [
"IPY_MODEL_9a99775e68ea48a9acd62a69682b8e2b",
"IPY_MODEL_ca29a375b504402089fec49a92dd344e",
"IPY_MODEL_3f7dbc14960a4c1f83c504fed871c870"
],
"layout": "IPY_MODEL_2032e3b54123455db3e474b9c5d2757c",
"tabbable": null,
"tooltip": null
}
},
"58a8e04df60e4da68ac966f1c109ca21": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "HTMLStyleModel",
"state": {
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "HTMLStyleModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "StyleView",
"background": null,
"description_width": "",
"font_size": null,
"text_color": null
}
},
"58e9317c91964a57b440569e71e32d3d": {
"model_module": "@jupyter-widgets/base",
"model_module_version": "2.0.0",
"model_name": "LayoutModel",
"state": {
"_model_module": "@jupyter-widgets/base",
"_model_module_version": "2.0.0",
"_model_name": "LayoutModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "LayoutView",
"align_content": null,
"align_items": null,
"align_self": null,
"border_bottom": null,
"border_left": null,
"border_right": null,
"border_top": null,
"bottom": null,
"display": null,
"flex": null,
"flex_flow": null,
"grid_area": null,
"grid_auto_columns": null,
"grid_auto_flow": null,
"grid_auto_rows": null,
"grid_column": null,
"grid_gap": null,
"grid_row": null,
"grid_template_areas": null,
"grid_template_columns": null,
"grid_template_rows": null,
"height": null,
"justify_content": null,
"justify_items": null,
"left": null,
"margin": null,
"max_height": null,
"max_width": null,
"min_height": null,
"min_width": null,
"object_fit": null,
"object_position": null,
"order": null,
"overflow": null,
"padding": null,
"right": null,
"top": null,
"visibility": null,
"width": null
}
},
"59294633289c4df8b81887e1d8cda00b": {
"model_module": "@jupyter-widgets/base",
"model_module_version": "2.0.0",
"model_name": "LayoutModel",
"state": {
"_model_module": "@jupyter-widgets/base",
"_model_module_version": "2.0.0",
"_model_name": "LayoutModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "LayoutView",
"align_content": null,
"align_items": null,
"align_self": null,
"border_bottom": null,
"border_left": null,
"border_right": null,
"border_top": null,
"bottom": null,
"display": null,
"flex": null,
"flex_flow": null,
"grid_area": null,
"grid_auto_columns": null,
"grid_auto_flow": null,
"grid_auto_rows": null,
"grid_column": null,
"grid_gap": null,
"grid_row": null,
"grid_template_areas": null,
"grid_template_columns": null,
"grid_template_rows": null,
"height": null,
"justify_content": null,
"justify_items": null,
"left": null,
"margin": null,
"max_height": null,
"max_width": null,
"min_height": null,
"min_width": null,
"object_fit": null,
"object_position": null,
"order": null,
"overflow": null,
"padding": null,
"right": null,
"top": null,
"visibility": null,
"width": null
}
},
"5bb39271f8ae47acbe6a5e1bc032bcb1": {
"model_module": "@jupyter-widgets/base",
"model_module_version": "2.0.0",
"model_name": "LayoutModel",
"state": {
"_model_module": "@jupyter-widgets/base",
"_model_module_version": "2.0.0",
"_model_name": "LayoutModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "LayoutView",
"align_content": null,
"align_items": null,
"align_self": null,
"border_bottom": null,
"border_left": null,
"border_right": null,
"border_top": null,
"bottom": null,
"display": null,
"flex": null,
"flex_flow": null,
"grid_area": null,
"grid_auto_columns": null,
"grid_auto_flow": null,
"grid_auto_rows": null,
"grid_column": null,
"grid_gap": null,
"grid_row": null,
"grid_template_areas": null,
"grid_template_columns": null,
"grid_template_rows": null,
"height": null,
"justify_content": null,
"justify_items": null,
"left": null,
"margin": null,
"max_height": null,
"max_width": null,
"min_height": null,
"min_width": null,
"object_fit": null,
"object_position": null,
"order": null,
"overflow": null,
"padding": null,
"right": null,
"top": null,
"visibility": null,
"width": "20px"
}
},
"5c199255f8344f988982f54a88970aaf": {
"model_module": "@jupyter-widgets/base",
"model_module_version": "2.0.0",
"model_name": "LayoutModel",
"state": {
"_model_module": "@jupyter-widgets/base",
"_model_module_version": "2.0.0",
"_model_name": "LayoutModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "LayoutView",
"align_content": null,
"align_items": null,
"align_self": null,
"border_bottom": null,
"border_left": null,
"border_right": null,
"border_top": null,
"bottom": null,
"display": null,
"flex": null,
"flex_flow": null,
"grid_area": null,
"grid_auto_columns": null,
"grid_auto_flow": null,
"grid_auto_rows": null,
"grid_column": null,
"grid_gap": null,
"grid_row": null,
"grid_template_areas": null,
"grid_template_columns": null,
"grid_template_rows": null,
"height": null,
"justify_content": null,
"justify_items": null,
"left": null,
"margin": null,
"max_height": null,
"max_width": null,
"min_height": null,
"min_width": null,
"object_fit": null,
"object_position": null,
"order": null,
"overflow": null,
"padding": null,
"right": null,
"top": null,
"visibility": null,
"width": null
}
},
"5dfce204a59748c18355a283c8254a05": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "HTMLModel",
"state": {
"_dom_classes": [],
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "HTMLModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/controls",
"_view_module_version": "2.0.0",
"_view_name": "HTMLView",
"description": "",
"description_allow_html": false,
"layout": "IPY_MODEL_635b61d52a324447b50f3fbe4a09fe9e",
"placeholder": "",
"style": "IPY_MODEL_68729b7c3ce14cc182cbcf330141a777",
"tabbable": null,
"tooltip": null,
"value": "README.md: 100%"
}
},
"5e59906194cf4ca1b8e74bf96c4d48b9": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "FloatProgressModel",
"state": {
"_dom_classes": [],
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "FloatProgressModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/controls",
"_view_module_version": "2.0.0",
"_view_name": "ProgressView",
"bar_style": "success",
"description": "",
"description_allow_html": false,
"layout": "IPY_MODEL_d89d0facd4d54f1098f0013627ca641e",
"max": 1,
"min": 0,
"orientation": "horizontal",
"style": "IPY_MODEL_518aa2a7d0e640c3a6d2275d02ec1a29",
"tabbable": null,
"tooltip": null,
"value": 1
}
},
"6101511927f244e7ae8345d533fc1fab": {
"model_module": "@jupyter-widgets/base",
"model_module_version": "2.0.0",
"model_name": "LayoutModel",
"state": {
"_model_module": "@jupyter-widgets/base",
"_model_module_version": "2.0.0",
"_model_name": "LayoutModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "LayoutView",
"align_content": null,
"align_items": null,
"align_self": null,
"border_bottom": null,
"border_left": null,
"border_right": null,
"border_top": null,
"bottom": null,
"display": null,
"flex": null,
"flex_flow": null,
"grid_area": null,
"grid_auto_columns": null,
"grid_auto_flow": null,
"grid_auto_rows": null,
"grid_column": null,
"grid_gap": null,
"grid_row": null,
"grid_template_areas": null,
"grid_template_columns": null,
"grid_template_rows": null,
"height": null,
"justify_content": null,
"justify_items": null,
"left": null,
"margin": null,
"max_height": null,
"max_width": null,
"min_height": null,
"min_width": null,
"object_fit": null,
"object_position": null,
"order": null,
"overflow": null,
"padding": null,
"right": null,
"top": null,
"visibility": null,
"width": null
}
},
"627844bfdf834298937930f78d36c993": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "HTMLStyleModel",
"state": {
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "HTMLStyleModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "StyleView",
"background": null,
"description_width": "",
"font_size": null,
"text_color": null
}
},
"633be4b9c68d441e9275634d197e76b3": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "HTMLModel",
"state": {
"_dom_classes": [],
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "HTMLModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/controls",
"_view_module_version": "2.0.0",
"_view_name": "HTMLView",
"description": "",
"description_allow_html": false,
"layout": "IPY_MODEL_0c7ac202e53c418586224da0a225a8e2",
"placeholder": "",
"style": "IPY_MODEL_dfc2c324d7fd4d51bda2b790102adbb9",
"tabbable": null,
"tooltip": null,
"value": "Loading weights: 100%"
}
},
"635b61d52a324447b50f3fbe4a09fe9e": {
"model_module": "@jupyter-widgets/base",
"model_module_version": "2.0.0",
"model_name": "LayoutModel",
"state": {
"_model_module": "@jupyter-widgets/base",
"_model_module_version": "2.0.0",
"_model_name": "LayoutModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "LayoutView",
"align_content": null,
"align_items": null,
"align_self": null,
"border_bottom": null,
"border_left": null,
"border_right": null,
"border_top": null,
"bottom": null,
"display": null,
"flex": null,
"flex_flow": null,
"grid_area": null,
"grid_auto_columns": null,
"grid_auto_flow": null,
"grid_auto_rows": null,
"grid_column": null,
"grid_gap": null,
"grid_row": null,
"grid_template_areas": null,
"grid_template_columns": null,
"grid_template_rows": null,
"height": null,
"justify_content": null,
"justify_items": null,
"left": null,
"margin": null,
"max_height": null,
"max_width": null,
"min_height": null,
"min_width": null,
"object_fit": null,
"object_position": null,
"order": null,
"overflow": null,
"padding": null,
"right": null,
"top": null,
"visibility": null,
"width": null
}
},
"67676fb0c80f466b9505fce8d4eb5125": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "FloatProgressModel",
"state": {
"_dom_classes": [],
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "FloatProgressModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/controls",
"_view_module_version": "2.0.0",
"_view_name": "ProgressView",
"bar_style": "success",
"description": "",
"description_allow_html": false,
"layout": "IPY_MODEL_c1102dd1228c479091345ed81be516c7",
"max": 665,
"min": 0,
"orientation": "horizontal",
"style": "IPY_MODEL_09afba4727924448983c0aa091a91ed4",
"tabbable": null,
"tooltip": null,
"value": 665
}
},
"68729b7c3ce14cc182cbcf330141a777": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "HTMLStyleModel",
"state": {
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "HTMLStyleModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "StyleView",
"background": null,
"description_width": "",
"font_size": null,
"text_color": null
}
},
"6b9c83c1a4e24bb2a22e019b6889bfdc": {
"model_module": "@jupyter-widgets/base",
"model_module_version": "2.0.0",
"model_name": "LayoutModel",
"state": {
"_model_module": "@jupyter-widgets/base",
"_model_module_version": "2.0.0",
"_model_name": "LayoutModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "LayoutView",
"align_content": null,
"align_items": null,
"align_self": null,
"border_bottom": null,
"border_left": null,
"border_right": null,
"border_top": null,
"bottom": null,
"display": null,
"flex": null,
"flex_flow": null,
"grid_area": null,
"grid_auto_columns": null,
"grid_auto_flow": null,
"grid_auto_rows": null,
"grid_column": null,
"grid_gap": null,
"grid_row": null,
"grid_template_areas": null,
"grid_template_columns": null,
"grid_template_rows": null,
"height": null,
"justify_content": null,
"justify_items": null,
"left": null,
"margin": null,
"max_height": null,
"max_width": null,
"min_height": null,
"min_width": null,
"object_fit": null,
"object_position": null,
"order": null,
"overflow": null,
"padding": null,
"right": null,
"top": null,
"visibility": null,
"width": null
}
},
"6c5c2c0fa2bb4d0e94f4f65f6bd43655": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "ProgressStyleModel",
"state": {
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "ProgressStyleModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "StyleView",
"bar_color": null,
"description_width": ""
}
},
"6f0e01266b50415db0c75344c25885ae": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "HTMLModel",
"state": {
"_dom_classes": [],
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "HTMLModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/controls",
"_view_module_version": "2.0.0",
"_view_name": "HTMLView",
"description": "",
"description_allow_html": false,
"layout": "IPY_MODEL_97858455694f47049f11cfea4c8e3dd9",
"placeholder": "",
"style": "IPY_MODEL_58a8e04df60e4da68ac966f1c109ca21",
"tabbable": null,
"tooltip": null,
"value": " 6.52k/? [00:00<00:00, 489kB/s]"
}
},
"71b9cf0fb304482e81dd030dd3d69251": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "HTMLStyleModel",
"state": {
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "HTMLStyleModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "StyleView",
"background": null,
"description_width": "",
"font_size": null,
"text_color": null
}
},
"7234b29a3a1e421eb593d3c2521f3363": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "HTMLStyleModel",
"state": {
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "HTMLStyleModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "StyleView",
"background": null,
"description_width": "",
"font_size": null,
"text_color": null
}
},
"72d0d3225d0d487a97285bdabf0d4bbe": {
"model_module": "@jupyter-widgets/base",
"model_module_version": "2.0.0",
"model_name": "LayoutModel",
"state": {
"_model_module": "@jupyter-widgets/base",
"_model_module_version": "2.0.0",
"_model_name": "LayoutModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "LayoutView",
"align_content": null,
"align_items": null,
"align_self": null,
"border_bottom": null,
"border_left": null,
"border_right": null,
"border_top": null,
"bottom": null,
"display": null,
"flex": null,
"flex_flow": null,
"grid_area": null,
"grid_auto_columns": null,
"grid_auto_flow": null,
"grid_auto_rows": null,
"grid_column": null,
"grid_gap": null,
"grid_row": null,
"grid_template_areas": null,
"grid_template_columns": null,
"grid_template_rows": null,
"height": null,
"justify_content": null,
"justify_items": null,
"left": null,
"margin": null,
"max_height": null,
"max_width": null,
"min_height": null,
"min_width": null,
"object_fit": null,
"object_position": null,
"order": null,
"overflow": null,
"padding": null,
"right": null,
"top": null,
"visibility": null,
"width": null
}
},
"73f64ec5466f4a9683a2e1494eab3eea": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "ProgressStyleModel",
"state": {
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "ProgressStyleModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "StyleView",
"bar_color": null,
"description_width": ""
}
},
"74f976c9b1094de28874128c330556d1": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "HTMLStyleModel",
"state": {
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "HTMLStyleModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "StyleView",
"background": null,
"description_width": "",
"font_size": null,
"text_color": null
}
},
"7766cdc6d8c044519c2d779620b21246": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "HTMLModel",
"state": {
"_dom_classes": [],
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "HTMLModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/controls",
"_view_module_version": "2.0.0",
"_view_name": "HTMLView",
"description": "",
"description_allow_html": false,
"layout": "IPY_MODEL_4b42b08ba7c04b1b96d8987f3115fb38",
"placeholder": "",
"style": "IPY_MODEL_7eca16df19d54b2d847817735c47c2c5",
"tabbable": null,
"tooltip": null,
"value": "merges.txt: "
}
},
"777913145e8142f4b9b6173a1595b367": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "FloatProgressModel",
"state": {
"_dom_classes": [],
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "FloatProgressModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/controls",
"_view_module_version": "2.0.0",
"_view_name": "ProgressView",
"bar_style": "success",
"description": "",
"description_allow_html": false,
"layout": "IPY_MODEL_c08f735baec84172bd6848cb6432ff87",
"max": 1,
"min": 0,
"orientation": "horizontal",
"style": "IPY_MODEL_a7a44c7f4f1b4e638f003bc19e6fa14e",
"tabbable": null,
"tooltip": null,
"value": 1
}
},
"7862cfe4dbbd4c08abf00fbfef8d2636": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "HBoxModel",
"state": {
"_dom_classes": [],
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "HBoxModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/controls",
"_view_module_version": "2.0.0",
"_view_name": "HBoxView",
"box_style": "",
"children": [
"IPY_MODEL_e9dbe58a0604481ca41927407d5b85b6",
"IPY_MODEL_3e8d3d4e1c6f4c3db0f1b6c87f2e1233",
"IPY_MODEL_7ecc7e5757364c278a1550dc447f7957"
],
"layout": "IPY_MODEL_1c9a499ff4b641ad8c29e13c3b5bf946",
"tabbable": null,
"tooltip": null
}
},
"7928d28022a24464bb6603581e7ea753": {
"model_module": "@jupyter-widgets/base",
"model_module_version": "2.0.0",
"model_name": "LayoutModel",
"state": {
"_model_module": "@jupyter-widgets/base",
"_model_module_version": "2.0.0",
"_model_name": "LayoutModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "LayoutView",
"align_content": null,
"align_items": null,
"align_self": null,
"border_bottom": null,
"border_left": null,
"border_right": null,
"border_top": null,
"bottom": null,
"display": null,
"flex": null,
"flex_flow": null,
"grid_area": null,
"grid_auto_columns": null,
"grid_auto_flow": null,
"grid_auto_rows": null,
"grid_column": null,
"grid_gap": null,
"grid_row": null,
"grid_template_areas": null,
"grid_template_columns": null,
"grid_template_rows": null,
"height": null,
"justify_content": null,
"justify_items": null,
"left": null,
"margin": null,
"max_height": null,
"max_width": null,
"min_height": null,
"min_width": null,
"object_fit": null,
"object_position": null,
"order": null,
"overflow": null,
"padding": null,
"right": null,
"top": null,
"visibility": null,
"width": null
}
},
"79f538f4772c40f59164c873e74ea19a": {
"model_module": "@jupyter-widgets/base",
"model_module_version": "2.0.0",
"model_name": "LayoutModel",
"state": {
"_model_module": "@jupyter-widgets/base",
"_model_module_version": "2.0.0",
"_model_name": "LayoutModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "LayoutView",
"align_content": null,
"align_items": null,
"align_self": null,
"border_bottom": null,
"border_left": null,
"border_right": null,
"border_top": null,
"bottom": null,
"display": null,
"flex": null,
"flex_flow": null,
"grid_area": null,
"grid_auto_columns": null,
"grid_auto_flow": null,
"grid_auto_rows": null,
"grid_column": null,
"grid_gap": null,
"grid_row": null,
"grid_template_areas": null,
"grid_template_columns": null,
"grid_template_rows": null,
"height": null,
"justify_content": null,
"justify_items": null,
"left": null,
"margin": null,
"max_height": null,
"max_width": null,
"min_height": null,
"min_width": null,
"object_fit": null,
"object_position": null,
"order": null,
"overflow": null,
"padding": null,
"right": null,
"top": null,
"visibility": null,
"width": null
}
},
"79fb07f48d5641489ab2c6cb390bef50": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "HTMLModel",
"state": {
"_dom_classes": [],
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "HTMLModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/controls",
"_view_module_version": "2.0.0",
"_view_name": "HTMLView",
"description": "",
"description_allow_html": false,
"layout": "IPY_MODEL_1deaa932ecfc4272a223624a2ae9b5de",
"placeholder": "",
"style": "IPY_MODEL_74f976c9b1094de28874128c330556d1",
"tabbable": null,
"tooltip": null,
"value": " 7.03M/? [00:00<00:00, 118MB/s]"
}
},
"7abe4e7f59014837b4dae82ba423cb38": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "HTMLModel",
"state": {
"_dom_classes": [],
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "HTMLModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/controls",
"_view_module_version": "2.0.0",
"_view_name": "HTMLView",
"description": "",
"description_allow_html": false,
"layout": "IPY_MODEL_bee2385ba9374a04b1937aa60a1132c1",
"placeholder": "",
"style": "IPY_MODEL_c3585be81d2d480d912aa26d5e1815e3",
"tabbable": null,
"tooltip": null,
"value": "README.md: "
}
},
"7b5efd1d3fa648f0b79da171c8af3bae": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "HTMLModel",
"state": {
"_dom_classes": [],
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "HTMLModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/controls",
"_view_module_version": "2.0.0",
"_view_name": "HTMLView",
"description": "",
"description_allow_html": false,
"layout": "IPY_MODEL_80b71b54372c448d987f53bd5c7adeb4",
"placeholder": "",
"style": "IPY_MODEL_c4099e61027148ffa4f66a13cab7bdec",
"tabbable": null,
"tooltip": null,
"value": "vocab.json: "
}
},
"7e5ef4dc77fb41f1a8608e96d25da024": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "FloatProgressModel",
"state": {
"_dom_classes": [],
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "FloatProgressModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/controls",
"_view_module_version": "2.0.0",
"_view_name": "ProgressView",
"bar_style": "success",
"description": "",
"description_allow_html": false,
"layout": "IPY_MODEL_ab8f8816baa84571bdef26f3dce82541",
"max": 1,
"min": 0,
"orientation": "horizontal",
"style": "IPY_MODEL_2d45baebafd34e1db080ace860b2ee50",
"tabbable": null,
"tooltip": null,
"value": 1
}
},
"7eca16df19d54b2d847817735c47c2c5": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "HTMLStyleModel",
"state": {
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "HTMLStyleModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "StyleView",
"background": null,
"description_width": "",
"font_size": null,
"text_color": null
}
},
"7ecc7e5757364c278a1550dc447f7957": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "HTMLModel",
"state": {
"_dom_classes": [],
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "HTMLModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/controls",
"_view_module_version": "2.0.0",
"_view_name": "HTMLView",
"description": "",
"description_allow_html": false,
"layout": "IPY_MODEL_1f62ccb96ece4ba1bd2bf2b7a78e7d1d",
"placeholder": "",
"style": "IPY_MODEL_30c0e62701304a329c4815647ae23b1f",
"tabbable": null,
"tooltip": null,
"value": " 164/164 [00:00<00:00, 3011.29 examples/s]"
}
},
"801279e51fbc4916aacaba0adc3be1ef": {
"model_module": "@jupyter-widgets/base",
"model_module_version": "2.0.0",
"model_name": "LayoutModel",
"state": {
"_model_module": "@jupyter-widgets/base",
"_model_module_version": "2.0.0",
"_model_name": "LayoutModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "LayoutView",
"align_content": null,
"align_items": null,
"align_self": null,
"border_bottom": null,
"border_left": null,
"border_right": null,
"border_top": null,
"bottom": null,
"display": null,
"flex": null,
"flex_flow": null,
"grid_area": null,
"grid_auto_columns": null,
"grid_auto_flow": null,
"grid_auto_rows": null,
"grid_column": null,
"grid_gap": null,
"grid_row": null,
"grid_template_areas": null,
"grid_template_columns": null,
"grid_template_rows": null,
"height": null,
"justify_content": null,
"justify_items": null,
"left": null,
"margin": null,
"max_height": null,
"max_width": null,
"min_height": null,
"min_width": null,
"object_fit": null,
"object_position": null,
"order": null,
"overflow": null,
"padding": null,
"right": null,
"top": null,
"visibility": null,
"width": null
}
},
"802e247b68d94cdb9555ca77dac125c8": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "FloatProgressModel",
"state": {
"_dom_classes": [],
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "FloatProgressModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/controls",
"_view_module_version": "2.0.0",
"_view_name": "ProgressView",
"bar_style": "success",
"description": "",
"description_allow_html": false,
"layout": "IPY_MODEL_c1c9d87d48d24e74a7314dd5916b1c40",
"max": 1,
"min": 0,
"orientation": "horizontal",
"style": "IPY_MODEL_6c5c2c0fa2bb4d0e94f4f65f6bd43655",
"tabbable": null,
"tooltip": null,
"value": 1
}
},
"80b71b54372c448d987f53bd5c7adeb4": {
"model_module": "@jupyter-widgets/base",
"model_module_version": "2.0.0",
"model_name": "LayoutModel",
"state": {
"_model_module": "@jupyter-widgets/base",
"_model_module_version": "2.0.0",
"_model_name": "LayoutModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "LayoutView",
"align_content": null,
"align_items": null,
"align_self": null,
"border_bottom": null,
"border_left": null,
"border_right": null,
"border_top": null,
"bottom": null,
"display": null,
"flex": null,
"flex_flow": null,
"grid_area": null,
"grid_auto_columns": null,
"grid_auto_flow": null,
"grid_auto_rows": null,
"grid_column": null,
"grid_gap": null,
"grid_row": null,
"grid_template_areas": null,
"grid_template_columns": null,
"grid_template_rows": null,
"height": null,
"justify_content": null,
"justify_items": null,
"left": null,
"margin": null,
"max_height": null,
"max_width": null,
"min_height": null,
"min_width": null,
"object_fit": null,
"object_position": null,
"order": null,
"overflow": null,
"padding": null,
"right": null,
"top": null,
"visibility": null,
"width": null
}
},
"81db6732f3bb4650a36fd3b7628f9a14": {
"model_module": "@jupyter-widgets/base",
"model_module_version": "2.0.0",
"model_name": "LayoutModel",
"state": {
"_model_module": "@jupyter-widgets/base",
"_model_module_version": "2.0.0",
"_model_name": "LayoutModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "LayoutView",
"align_content": null,
"align_items": null,
"align_self": null,
"border_bottom": null,
"border_left": null,
"border_right": null,
"border_top": null,
"bottom": null,
"display": null,
"flex": null,
"flex_flow": null,
"grid_area": null,
"grid_auto_columns": null,
"grid_auto_flow": null,
"grid_auto_rows": null,
"grid_column": null,
"grid_gap": null,
"grid_row": null,
"grid_template_areas": null,
"grid_template_columns": null,
"grid_template_rows": null,
"height": null,
"justify_content": null,
"justify_items": null,
"left": null,
"margin": null,
"max_height": null,
"max_width": null,
"min_height": null,
"min_width": null,
"object_fit": null,
"object_position": null,
"order": null,
"overflow": null,
"padding": null,
"right": null,
"top": null,
"visibility": null,
"width": null
}
},
"82329a907c324c7186f33c13aa32c997": {
"model_module": "@jupyter-widgets/base",
"model_module_version": "2.0.0",
"model_name": "LayoutModel",
"state": {
"_model_module": "@jupyter-widgets/base",
"_model_module_version": "2.0.0",
"_model_name": "LayoutModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "LayoutView",
"align_content": null,
"align_items": null,
"align_self": null,
"border_bottom": null,
"border_left": null,
"border_right": null,
"border_top": null,
"bottom": null,
"display": null,
"flex": null,
"flex_flow": null,
"grid_area": null,
"grid_auto_columns": null,
"grid_auto_flow": null,
"grid_auto_rows": null,
"grid_column": null,
"grid_gap": null,
"grid_row": null,
"grid_template_areas": null,
"grid_template_columns": null,
"grid_template_rows": null,
"height": null,
"justify_content": null,
"justify_items": null,
"left": null,
"margin": null,
"max_height": null,
"max_width": null,
"min_height": null,
"min_width": null,
"object_fit": null,
"object_position": null,
"order": null,
"overflow": null,
"padding": null,
"right": null,
"top": null,
"visibility": null,
"width": null
}
},
"82855c61d96544e5ac5273848404c7df": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "HBoxModel",
"state": {
"_dom_classes": [],
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "HBoxModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/controls",
"_view_module_version": "2.0.0",
"_view_name": "HBoxView",
"box_style": "",
"children": [
"IPY_MODEL_17d290530cbf454da8644fa28d642085",
"IPY_MODEL_93ac5e891a0b406b9fdd39e385ccb29d",
"IPY_MODEL_ac780bd75cc547638c9c1828de4f3096"
],
"layout": "IPY_MODEL_55ebe3eac126490595aa6c5d137c1cb0",
"tabbable": null,
"tooltip": null
}
},
"84338cd567a4444e8d52ed963c99a498": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "ProgressStyleModel",
"state": {
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "ProgressStyleModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "StyleView",
"bar_color": null,
"description_width": ""
}
},
"850f0c4f0bec46e3b10ae04ac0a27fe4": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "HTMLModel",
"state": {
"_dom_classes": [],
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "HTMLModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/controls",
"_view_module_version": "2.0.0",
"_view_name": "HTMLView",
"description": "",
"description_allow_html": false,
"layout": "IPY_MODEL_20adb4fc85f148ef9b580cc250c6d1d8",
"placeholder": "",
"style": "IPY_MODEL_627844bfdf834298937930f78d36c993",
"tabbable": null,
"tooltip": null,
"value": " 2.78M/? [00:00<00:00, 38.9MB/s]"
}
},
"88dc7a14a7a1495eab116822e7d34077": {
"model_module": "@jupyter-widgets/base",
"model_module_version": "2.0.0",
"model_name": "LayoutModel",
"state": {
"_model_module": "@jupyter-widgets/base",
"_model_module_version": "2.0.0",
"_model_name": "LayoutModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "LayoutView",
"align_content": null,
"align_items": null,
"align_self": null,
"border_bottom": null,
"border_left": null,
"border_right": null,
"border_top": null,
"bottom": null,
"display": null,
"flex": null,
"flex_flow": null,
"grid_area": null,
"grid_auto_columns": null,
"grid_auto_flow": null,
"grid_auto_rows": null,
"grid_column": null,
"grid_gap": null,
"grid_row": null,
"grid_template_areas": null,
"grid_template_columns": null,
"grid_template_rows": null,
"height": null,
"justify_content": null,
"justify_items": null,
"left": null,
"margin": null,
"max_height": null,
"max_width": null,
"min_height": null,
"min_width": null,
"object_fit": null,
"object_position": null,
"order": null,
"overflow": null,
"padding": null,
"right": null,
"top": null,
"visibility": null,
"width": null
}
},
"89951752172a407a941e84134a4f2323": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "FloatProgressModel",
"state": {
"_dom_classes": [],
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "FloatProgressModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/controls",
"_view_module_version": "2.0.0",
"_view_name": "ProgressView",
"bar_style": "success",
"description": "",
"description_allow_html": false,
"layout": "IPY_MODEL_9fe997d8de164b01817df70c16a7f386",
"max": 1,
"min": 0,
"orientation": "horizontal",
"style": "IPY_MODEL_0ffba08ffb8f43248ca2207e36e20350",
"tabbable": null,
"tooltip": null,
"value": 1
}
},
"89e769e82c0643f19a723b635ee05fde": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "HTMLModel",
"state": {
"_dom_classes": [],
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "HTMLModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/controls",
"_view_module_version": "2.0.0",
"_view_name": "HTMLView",
"description": "",
"description_allow_html": false,
"layout": "IPY_MODEL_be99600cb002459c847dd57f5ac3132f",
"placeholder": "",
"style": "IPY_MODEL_2921f9a997734756a52e11b05ba07365",
"tabbable": null,
"tooltip": null,
"value": " 1/1 [00:00<00:00, 177.64it/s]"
}
},
"8ac86a4c2534485e99473cfd58296904": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "HBoxModel",
"state": {
"_dom_classes": [],
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "HBoxModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/controls",
"_view_module_version": "2.0.0",
"_view_name": "HBoxView",
"box_style": "",
"children": [
"IPY_MODEL_3d5a3d499b9644428bd08c82ca5fbed3",
"IPY_MODEL_ff6ccc01482f46bdb8310d96230067b4",
"IPY_MODEL_20d7d61ca5b44304ab0302398c355fa3"
],
"layout": "IPY_MODEL_58e9317c91964a57b440569e71e32d3d",
"tabbable": null,
"tooltip": null
}
},
"8b49986b1f9c4d529ccc45bfe774389c": {
"model_module": "@jupyter-widgets/base",
"model_module_version": "2.0.0",
"model_name": "LayoutModel",
"state": {
"_model_module": "@jupyter-widgets/base",
"_model_module_version": "2.0.0",
"_model_name": "LayoutModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "LayoutView",
"align_content": null,
"align_items": null,
"align_self": null,
"border_bottom": null,
"border_left": null,
"border_right": null,
"border_top": null,
"bottom": null,
"display": null,
"flex": null,
"flex_flow": null,
"grid_area": null,
"grid_auto_columns": null,
"grid_auto_flow": null,
"grid_auto_rows": null,
"grid_column": null,
"grid_gap": null,
"grid_row": null,
"grid_template_areas": null,
"grid_template_columns": null,
"grid_template_rows": null,
"height": null,
"justify_content": null,
"justify_items": null,
"left": null,
"margin": null,
"max_height": null,
"max_width": null,
"min_height": null,
"min_width": null,
"object_fit": null,
"object_position": null,
"order": null,
"overflow": null,
"padding": null,
"right": null,
"top": null,
"visibility": null,
"width": null
}
},
"8beaf833b4154dd8ad14bb03fc80476a": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "HTMLModel",
"state": {
"_dom_classes": [],
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "HTMLModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/controls",
"_view_module_version": "2.0.0",
"_view_name": "HTMLView",
"description": "",
"description_allow_html": false,
"layout": "IPY_MODEL_7928d28022a24464bb6603581e7ea753",
"placeholder": "",
"style": "IPY_MODEL_3295e6840d42403b96cbe1eb8a5b26b1",
"tabbable": null,
"tooltip": null,
"value": " 7.51k/? [00:00<00:00, 643kB/s]"
}
},
"90c2c47ecbe54cbabdaaef37f1b2e47f": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "ProgressStyleModel",
"state": {
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "ProgressStyleModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "StyleView",
"bar_color": null,
"description_width": ""
}
},
"91b15acc4b8743adb5970061f623ece3": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "HTMLStyleModel",
"state": {
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "HTMLStyleModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "StyleView",
"background": null,
"description_width": "",
"font_size": null,
"text_color": null
}
},
"91dadc17dc754c9e9c98463f591d14fd": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "HTMLStyleModel",
"state": {
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "HTMLStyleModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "StyleView",
"background": null,
"description_width": "",
"font_size": null,
"text_color": null
}
},
"93ac5e891a0b406b9fdd39e385ccb29d": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "FloatProgressModel",
"state": {
"_dom_classes": [],
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "FloatProgressModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/controls",
"_view_module_version": "2.0.0",
"_view_name": "ProgressView",
"bar_style": "success",
"description": "",
"description_allow_html": false,
"layout": "IPY_MODEL_346d15cbf2414d1cbba91de6ecfd5f62",
"max": 20,
"min": 0,
"orientation": "horizontal",
"style": "IPY_MODEL_41efab2c12174ee8af99242ea44c7560",
"tabbable": null,
"tooltip": null,
"value": 20
}
},
"976a9680bef541feae2f802b72b9df32": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "HTMLModel",
"state": {
"_dom_classes": [],
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "HTMLModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/controls",
"_view_module_version": "2.0.0",
"_view_name": "HTMLView",
"description": "",
"description_allow_html": false,
"layout": "IPY_MODEL_1c6ee9dc09b845bc8052f9ea0744d04c",
"placeholder": "",
"style": "IPY_MODEL_3e3e826cd7c6447996bcaa0d60151e54",
"tabbable": null,
"tooltip": null,
"value": " 500/500 [00:00<00:00, 10297.22 examples/s]"
}
},
"97858455694f47049f11cfea4c8e3dd9": {
"model_module": "@jupyter-widgets/base",
"model_module_version": "2.0.0",
"model_name": "LayoutModel",
"state": {
"_model_module": "@jupyter-widgets/base",
"_model_module_version": "2.0.0",
"_model_name": "LayoutModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "LayoutView",
"align_content": null,
"align_items": null,
"align_self": null,
"border_bottom": null,
"border_left": null,
"border_right": null,
"border_top": null,
"bottom": null,
"display": null,
"flex": null,
"flex_flow": null,
"grid_area": null,
"grid_auto_columns": null,
"grid_auto_flow": null,
"grid_auto_rows": null,
"grid_column": null,
"grid_gap": null,
"grid_row": null,
"grid_template_areas": null,
"grid_template_columns": null,
"grid_template_rows": null,
"height": null,
"justify_content": null,
"justify_items": null,
"left": null,
"margin": null,
"max_height": null,
"max_width": null,
"min_height": null,
"min_width": null,
"object_fit": null,
"object_position": null,
"order": null,
"overflow": null,
"padding": null,
"right": null,
"top": null,
"visibility": null,
"width": null
}
},
"9855ede2d613448a8f8b7fb1f6ab6289": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "HBoxModel",
"state": {
"_dom_classes": [],
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "HBoxModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/controls",
"_view_module_version": "2.0.0",
"_view_name": "HBoxView",
"box_style": "",
"children": [
"IPY_MODEL_e74824de4ae148a9a5cce7456de61ce6",
"IPY_MODEL_7e5ef4dc77fb41f1a8608e96d25da024",
"IPY_MODEL_0d01ea6df00d4345bb924e304f344fd8"
],
"layout": "IPY_MODEL_ccd6de9aac1a4b269e25a9219cdda807",
"tabbable": null,
"tooltip": null
}
},
"9899e30615e5433ab1d0f237e338cab5": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "HTMLModel",
"state": {
"_dom_classes": [],
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "HTMLModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/controls",
"_view_module_version": "2.0.0",
"_view_name": "HTMLView",
"description": "",
"description_allow_html": false,
"layout": "IPY_MODEL_1806856b0490424bad55dc568d3b9708",
"placeholder": "",
"style": "IPY_MODEL_07fbee2dd375407a8e0aba5d0932c1d4",
"tabbable": null,
"tooltip": null,
"value": "Computing checksums: 100%"
}
},
"98febc8ad16040bcad787918f12ff218": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "HBoxModel",
"state": {
"_dom_classes": [],
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "HBoxModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/controls",
"_view_module_version": "2.0.0",
"_view_name": "HBoxView",
"box_style": "",
"children": [
"IPY_MODEL_2e8fc98a2c6f47fcbc248c7b3dea2ca6",
"IPY_MODEL_1a4476b268f5479ebcae60706c572bdf",
"IPY_MODEL_79fb07f48d5641489ab2c6cb390bef50"
],
"layout": "IPY_MODEL_c87fb6446189421aa805ac3999f72c19",
"tabbable": null,
"tooltip": null
}
},
"9a99775e68ea48a9acd62a69682b8e2b": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "HTMLModel",
"state": {
"_dom_classes": [],
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "HTMLModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/controls",
"_view_module_version": "2.0.0",
"_view_name": "HTMLView",
"description": "",
"description_allow_html": false,
"layout": "IPY_MODEL_16b84a08884c464899aa25c22618db2e",
"placeholder": "",
"style": "IPY_MODEL_d127679ed10a46f6ac817e6ea29ddefb",
"tabbable": null,
"tooltip": null,
"value": "model.safetensors: 100%"
}
},
"9ab0f29e292c405482589938ce38dcea": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "HTMLStyleModel",
"state": {
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "HTMLStyleModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "StyleView",
"background": null,
"description_width": "",
"font_size": null,
"text_color": null
}
},
"9c99f7da0b4940f3ab820a112233b43d": {
"model_module": "@jupyter-widgets/base",
"model_module_version": "2.0.0",
"model_name": "LayoutModel",
"state": {
"_model_module": "@jupyter-widgets/base",
"_model_module_version": "2.0.0",
"_model_name": "LayoutModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "LayoutView",
"align_content": null,
"align_items": null,
"align_self": null,
"border_bottom": null,
"border_left": null,
"border_right": null,
"border_top": null,
"bottom": null,
"display": null,
"flex": null,
"flex_flow": null,
"grid_area": null,
"grid_auto_columns": null,
"grid_auto_flow": null,
"grid_auto_rows": null,
"grid_column": null,
"grid_gap": null,
"grid_row": null,
"grid_template_areas": null,
"grid_template_columns": null,
"grid_template_rows": null,
"height": null,
"justify_content": null,
"justify_items": null,
"left": null,
"margin": null,
"max_height": null,
"max_width": null,
"min_height": null,
"min_width": null,
"object_fit": null,
"object_position": null,
"order": null,
"overflow": null,
"padding": null,
"right": null,
"top": null,
"visibility": null,
"width": "20px"
}
},
"9d592b79075d432b905fa462dd4e1d16": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "HTMLStyleModel",
"state": {
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "HTMLStyleModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "StyleView",
"background": null,
"description_width": "",
"font_size": null,
"text_color": null
}
},
"9fd3676fe0c0467fbc8bf5cab2d03afd": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "HTMLStyleModel",
"state": {
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "HTMLStyleModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "StyleView",
"background": null,
"description_width": "",
"font_size": null,
"text_color": null
}
},
"9fe997d8de164b01817df70c16a7f386": {
"model_module": "@jupyter-widgets/base",
"model_module_version": "2.0.0",
"model_name": "LayoutModel",
"state": {
"_model_module": "@jupyter-widgets/base",
"_model_module_version": "2.0.0",
"_model_name": "LayoutModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "LayoutView",
"align_content": null,
"align_items": null,
"align_self": null,
"border_bottom": null,
"border_left": null,
"border_right": null,
"border_top": null,
"bottom": null,
"display": null,
"flex": null,
"flex_flow": null,
"grid_area": null,
"grid_auto_columns": null,
"grid_auto_flow": null,
"grid_auto_rows": null,
"grid_column": null,
"grid_gap": null,
"grid_row": null,
"grid_template_areas": null,
"grid_template_columns": null,
"grid_template_rows": null,
"height": null,
"justify_content": null,
"justify_items": null,
"left": null,
"margin": null,
"max_height": null,
"max_width": null,
"min_height": null,
"min_width": null,
"object_fit": null,
"object_position": null,
"order": null,
"overflow": null,
"padding": null,
"right": null,
"top": null,
"visibility": null,
"width": "20px"
}
},
"a13b092dcd9a4142a539fa73435755f8": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "HTMLStyleModel",
"state": {
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "HTMLStyleModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "StyleView",
"background": null,
"description_width": "",
"font_size": null,
"text_color": null
}
},
"a1a4cb2dbd864813b3f081133f340ee7": {
"model_module": "@jupyter-widgets/base",
"model_module_version": "2.0.0",
"model_name": "LayoutModel",
"state": {
"_model_module": "@jupyter-widgets/base",
"_model_module_version": "2.0.0",
"_model_name": "LayoutModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "LayoutView",
"align_content": null,
"align_items": null,
"align_self": null,
"border_bottom": null,
"border_left": null,
"border_right": null,
"border_top": null,
"bottom": null,
"display": null,
"flex": null,
"flex_flow": null,
"grid_area": null,
"grid_auto_columns": null,
"grid_auto_flow": null,
"grid_auto_rows": null,
"grid_column": null,
"grid_gap": null,
"grid_row": null,
"grid_template_areas": null,
"grid_template_columns": null,
"grid_template_rows": null,
"height": null,
"justify_content": null,
"justify_items": null,
"left": null,
"margin": null,
"max_height": null,
"max_width": null,
"min_height": null,
"min_width": null,
"object_fit": null,
"object_position": null,
"order": null,
"overflow": null,
"padding": null,
"right": null,
"top": null,
"visibility": null,
"width": null
}
},
"a3434a884f7f47eb83a4f0de5366f5a7": {
"model_module": "@jupyter-widgets/base",
"model_module_version": "2.0.0",
"model_name": "LayoutModel",
"state": {
"_model_module": "@jupyter-widgets/base",
"_model_module_version": "2.0.0",
"_model_name": "LayoutModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "LayoutView",
"align_content": null,
"align_items": null,
"align_self": null,
"border_bottom": null,
"border_left": null,
"border_right": null,
"border_top": null,
"bottom": null,
"display": null,
"flex": null,
"flex_flow": null,
"grid_area": null,
"grid_auto_columns": null,
"grid_auto_flow": null,
"grid_auto_rows": null,
"grid_column": null,
"grid_gap": null,
"grid_row": null,
"grid_template_areas": null,
"grid_template_columns": null,
"grid_template_rows": null,
"height": null,
"justify_content": null,
"justify_items": null,
"left": null,
"margin": null,
"max_height": null,
"max_width": null,
"min_height": null,
"min_width": null,
"object_fit": null,
"object_position": null,
"order": null,
"overflow": null,
"padding": null,
"right": null,
"top": null,
"visibility": null,
"width": null
}
},
"a4ce863c40f7451db3f5f6ba9090e922": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "HTMLStyleModel",
"state": {
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "HTMLStyleModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "StyleView",
"background": null,
"description_width": "",
"font_size": null,
"text_color": null
}
},
"a6c1a416f2b241ffb5c2b77e881b1e2d": {
"model_module": "@jupyter-widgets/base",
"model_module_version": "2.0.0",
"model_name": "LayoutModel",
"state": {
"_model_module": "@jupyter-widgets/base",
"_model_module_version": "2.0.0",
"_model_name": "LayoutModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "LayoutView",
"align_content": null,
"align_items": null,
"align_self": null,
"border_bottom": null,
"border_left": null,
"border_right": null,
"border_top": null,
"bottom": null,
"display": null,
"flex": null,
"flex_flow": null,
"grid_area": null,
"grid_auto_columns": null,
"grid_auto_flow": null,
"grid_auto_rows": null,
"grid_column": null,
"grid_gap": null,
"grid_row": null,
"grid_template_areas": null,
"grid_template_columns": null,
"grid_template_rows": null,
"height": null,
"justify_content": null,
"justify_items": null,
"left": null,
"margin": null,
"max_height": null,
"max_width": null,
"min_height": null,
"min_width": null,
"object_fit": null,
"object_position": null,
"order": null,
"overflow": null,
"padding": null,
"right": null,
"top": null,
"visibility": null,
"width": null
}
},
"a7028888c2bf42cea1f04274e7fc6b1c": {
"model_module": "@jupyter-widgets/base",
"model_module_version": "2.0.0",
"model_name": "LayoutModel",
"state": {
"_model_module": "@jupyter-widgets/base",
"_model_module_version": "2.0.0",
"_model_name": "LayoutModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "LayoutView",
"align_content": null,
"align_items": null,
"align_self": null,
"border_bottom": null,
"border_left": null,
"border_right": null,
"border_top": null,
"bottom": null,
"display": null,
"flex": null,
"flex_flow": null,
"grid_area": null,
"grid_auto_columns": null,
"grid_auto_flow": null,
"grid_auto_rows": null,
"grid_column": null,
"grid_gap": null,
"grid_row": null,
"grid_template_areas": null,
"grid_template_columns": null,
"grid_template_rows": null,
"height": null,
"justify_content": null,
"justify_items": null,
"left": null,
"margin": null,
"max_height": null,
"max_width": null,
"min_height": null,
"min_width": null,
"object_fit": null,
"object_position": null,
"order": null,
"overflow": null,
"padding": null,
"right": null,
"top": null,
"visibility": null,
"width": null
}
},
"a7a44c7f4f1b4e638f003bc19e6fa14e": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "ProgressStyleModel",
"state": {
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "ProgressStyleModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "StyleView",
"bar_color": null,
"description_width": ""
}
},
"a823cf08126d4bda9e86808b8c2674b0": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "HTMLModel",
"state": {
"_dom_classes": [],
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "HTMLModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/controls",
"_view_module_version": "2.0.0",
"_view_name": "HTMLView",
"description": "",
"description_allow_html": false,
"layout": "IPY_MODEL_801279e51fbc4916aacaba0adc3be1ef",
"placeholder": "",
"style": "IPY_MODEL_9ab0f29e292c405482589938ce38dcea",
"tabbable": null,
"tooltip": null,
"value": "Generating test split: 100%"
}
},
"a88df84670244523baaf6669c9adf949": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "HTMLModel",
"state": {
"_dom_classes": [],
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "HTMLModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/controls",
"_view_module_version": "2.0.0",
"_view_name": "HTMLView",
"description": "",
"description_allow_html": false,
"layout": "IPY_MODEL_5270a56277534bf79b006c356bb0a692",
"placeholder": "",
"style": "IPY_MODEL_9fd3676fe0c0467fbc8bf5cab2d03afd",
"tabbable": null,
"tooltip": null,
"value": " 1.67M/? [00:00<00:00, 67.9MB/s]"
}
},
"a91876d8ff66499fa1f37945a20eeaf1": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "ProgressStyleModel",
"state": {
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "ProgressStyleModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "StyleView",
"bar_color": null,
"description_width": ""
}
},
"ab8f8816baa84571bdef26f3dce82541": {
"model_module": "@jupyter-widgets/base",
"model_module_version": "2.0.0",
"model_name": "LayoutModel",
"state": {
"_model_module": "@jupyter-widgets/base",
"_model_module_version": "2.0.0",
"_model_name": "LayoutModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "LayoutView",
"align_content": null,
"align_items": null,
"align_self": null,
"border_bottom": null,
"border_left": null,
"border_right": null,
"border_top": null,
"bottom": null,
"display": null,
"flex": null,
"flex_flow": null,
"grid_area": null,
"grid_auto_columns": null,
"grid_auto_flow": null,
"grid_auto_rows": null,
"grid_column": null,
"grid_gap": null,
"grid_row": null,
"grid_template_areas": null,
"grid_template_columns": null,
"grid_template_rows": null,
"height": null,
"justify_content": null,
"justify_items": null,
"left": null,
"margin": null,
"max_height": null,
"max_width": null,
"min_height": null,
"min_width": null,
"object_fit": null,
"object_position": null,
"order": null,
"overflow": null,
"padding": null,
"right": null,
"top": null,
"visibility": null,
"width": "20px"
}
},
"ac780bd75cc547638c9c1828de4f3096": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "HTMLModel",
"state": {
"_dom_classes": [],
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "HTMLModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/controls",
"_view_module_version": "2.0.0",
"_view_name": "HTMLView",
"description": "",
"description_allow_html": false,
"layout": "IPY_MODEL_1c4cc3d5abf340e0a8c59bb07aea21a8",
"placeholder": "",
"style": "IPY_MODEL_3f68c588c2fb4ac6976ba3f763287f46",
"tabbable": null,
"tooltip": null,
"value": " 20/20 [00:00<00:00, 2177.39it/s]"
}
},
"accb2a8b75ff402ca2e9dfd1d218dd9c": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "ProgressStyleModel",
"state": {
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "ProgressStyleModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "StyleView",
"bar_color": null,
"description_width": ""
}
},
"b0e84209f7604c3db2fe4f7e2e24ebab": {
"model_module": "@jupyter-widgets/base",
"model_module_version": "2.0.0",
"model_name": "LayoutModel",
"state": {
"_model_module": "@jupyter-widgets/base",
"_model_module_version": "2.0.0",
"_model_name": "LayoutModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "LayoutView",
"align_content": null,
"align_items": null,
"align_self": null,
"border_bottom": null,
"border_left": null,
"border_right": null,
"border_top": null,
"bottom": null,
"display": null,
"flex": null,
"flex_flow": null,
"grid_area": null,
"grid_auto_columns": null,
"grid_auto_flow": null,
"grid_auto_rows": null,
"grid_column": null,
"grid_gap": null,
"grid_row": null,
"grid_template_areas": null,
"grid_template_columns": null,
"grid_template_rows": null,
"height": null,
"justify_content": null,
"justify_items": null,
"left": null,
"margin": null,
"max_height": null,
"max_width": null,
"min_height": null,
"min_width": null,
"object_fit": null,
"object_position": null,
"order": null,
"overflow": null,
"padding": null,
"right": null,
"top": null,
"visibility": null,
"width": null
}
},
"b1256f6314ff488c8a785ad87186fefd": {
"model_module": "@jupyter-widgets/base",
"model_module_version": "2.0.0",
"model_name": "LayoutModel",
"state": {
"_model_module": "@jupyter-widgets/base",
"_model_module_version": "2.0.0",
"_model_name": "LayoutModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "LayoutView",
"align_content": null,
"align_items": null,
"align_self": null,
"border_bottom": null,
"border_left": null,
"border_right": null,
"border_top": null,
"bottom": null,
"display": null,
"flex": null,
"flex_flow": null,
"grid_area": null,
"grid_auto_columns": null,
"grid_auto_flow": null,
"grid_auto_rows": null,
"grid_column": null,
"grid_gap": null,
"grid_row": null,
"grid_template_areas": null,
"grid_template_columns": null,
"grid_template_rows": null,
"height": null,
"justify_content": null,
"justify_items": null,
"left": null,
"margin": null,
"max_height": null,
"max_width": null,
"min_height": null,
"min_width": null,
"object_fit": null,
"object_position": null,
"order": null,
"overflow": null,
"padding": null,
"right": null,
"top": null,
"visibility": null,
"width": null
}
},
"b172dc909a374a80b6dc073551c7e092": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "HTMLStyleModel",
"state": {
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "HTMLStyleModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "StyleView",
"background": null,
"description_width": "",
"font_size": null,
"text_color": null
}
},
"b1b73a2279974bc59dc33d9c0e290895": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "HBoxModel",
"state": {
"_dom_classes": [],
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "HBoxModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/controls",
"_view_module_version": "2.0.0",
"_view_name": "HBoxView",
"box_style": "",
"children": [
"IPY_MODEL_dd60190c540b41e49c6ef6514861a7eb",
"IPY_MODEL_19e5746ffe894065949f47fbcbbe1979",
"IPY_MODEL_6f0e01266b50415db0c75344c25885ae"
],
"layout": "IPY_MODEL_81db6732f3bb4650a36fd3b7628f9a14",
"tabbable": null,
"tooltip": null
}
},
"b2334e82636746718f289b4cd8e5b797": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "HBoxModel",
"state": {
"_dom_classes": [],
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "HBoxModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/controls",
"_view_module_version": "2.0.0",
"_view_name": "HBoxView",
"box_style": "",
"children": [
"IPY_MODEL_0c8e62f2570c47be88f66afbfa755248",
"IPY_MODEL_f36cf5b205e441c0969d160090763cf9",
"IPY_MODEL_362b04347cc44c1e87383ab76c53a695"
],
"layout": "IPY_MODEL_babf4118f8e245aca816f5426b1735b2",
"tabbable": null,
"tooltip": null
}
},
"b331f05e91b3431aa0431f0c9f4f5a18": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "HTMLStyleModel",
"state": {
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "HTMLStyleModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "StyleView",
"background": null,
"description_width": "",
"font_size": null,
"text_color": null
}
},
"b4f0a16677b94b42b19466e9dcdbbacc": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "HTMLStyleModel",
"state": {
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "HTMLStyleModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "StyleView",
"background": null,
"description_width": "",
"font_size": null,
"text_color": null
}
},
"babf4118f8e245aca816f5426b1735b2": {
"model_module": "@jupyter-widgets/base",
"model_module_version": "2.0.0",
"model_name": "LayoutModel",
"state": {
"_model_module": "@jupyter-widgets/base",
"_model_module_version": "2.0.0",
"_model_name": "LayoutModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "LayoutView",
"align_content": null,
"align_items": null,
"align_self": null,
"border_bottom": null,
"border_left": null,
"border_right": null,
"border_top": null,
"bottom": null,
"display": null,
"flex": null,
"flex_flow": null,
"grid_area": null,
"grid_auto_columns": null,
"grid_auto_flow": null,
"grid_auto_rows": null,
"grid_column": null,
"grid_gap": null,
"grid_row": null,
"grid_template_areas": null,
"grid_template_columns": null,
"grid_template_rows": null,
"height": null,
"justify_content": null,
"justify_items": null,
"left": null,
"margin": null,
"max_height": null,
"max_width": null,
"min_height": null,
"min_width": null,
"object_fit": null,
"object_position": null,
"order": null,
"overflow": null,
"padding": null,
"right": null,
"top": null,
"visibility": null,
"width": null
}
},
"bd80656cb338404c81efd5db34737157": {
"model_module": "@jupyter-widgets/base",
"model_module_version": "2.0.0",
"model_name": "LayoutModel",
"state": {
"_model_module": "@jupyter-widgets/base",
"_model_module_version": "2.0.0",
"_model_name": "LayoutModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "LayoutView",
"align_content": null,
"align_items": null,
"align_self": null,
"border_bottom": null,
"border_left": null,
"border_right": null,
"border_top": null,
"bottom": null,
"display": null,
"flex": null,
"flex_flow": null,
"grid_area": null,
"grid_auto_columns": null,
"grid_auto_flow": null,
"grid_auto_rows": null,
"grid_column": null,
"grid_gap": null,
"grid_row": null,
"grid_template_areas": null,
"grid_template_columns": null,
"grid_template_rows": null,
"height": null,
"justify_content": null,
"justify_items": null,
"left": null,
"margin": null,
"max_height": null,
"max_width": null,
"min_height": null,
"min_width": null,
"object_fit": null,
"object_position": null,
"order": null,
"overflow": null,
"padding": null,
"right": null,
"top": null,
"visibility": null,
"width": null
}
},
"be99600cb002459c847dd57f5ac3132f": {
"model_module": "@jupyter-widgets/base",
"model_module_version": "2.0.0",
"model_name": "LayoutModel",
"state": {
"_model_module": "@jupyter-widgets/base",
"_model_module_version": "2.0.0",
"_model_name": "LayoutModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "LayoutView",
"align_content": null,
"align_items": null,
"align_self": null,
"border_bottom": null,
"border_left": null,
"border_right": null,
"border_top": null,
"bottom": null,
"display": null,
"flex": null,
"flex_flow": null,
"grid_area": null,
"grid_auto_columns": null,
"grid_auto_flow": null,
"grid_auto_rows": null,
"grid_column": null,
"grid_gap": null,
"grid_row": null,
"grid_template_areas": null,
"grid_template_columns": null,
"grid_template_rows": null,
"height": null,
"justify_content": null,
"justify_items": null,
"left": null,
"margin": null,
"max_height": null,
"max_width": null,
"min_height": null,
"min_width": null,
"object_fit": null,
"object_position": null,
"order": null,
"overflow": null,
"padding": null,
"right": null,
"top": null,
"visibility": null,
"width": null
}
},
"bea90ad05cc34676aa005a2bf3e58b85": {
"model_module": "@jupyter-widgets/base",
"model_module_version": "2.0.0",
"model_name": "LayoutModel",
"state": {
"_model_module": "@jupyter-widgets/base",
"_model_module_version": "2.0.0",
"_model_name": "LayoutModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "LayoutView",
"align_content": null,
"align_items": null,
"align_self": null,
"border_bottom": null,
"border_left": null,
"border_right": null,
"border_top": null,
"bottom": null,
"display": null,
"flex": null,
"flex_flow": null,
"grid_area": null,
"grid_auto_columns": null,
"grid_auto_flow": null,
"grid_auto_rows": null,
"grid_column": null,
"grid_gap": null,
"grid_row": null,
"grid_template_areas": null,
"grid_template_columns": null,
"grid_template_rows": null,
"height": null,
"justify_content": null,
"justify_items": null,
"left": null,
"margin": null,
"max_height": null,
"max_width": null,
"min_height": null,
"min_width": null,
"object_fit": null,
"object_position": null,
"order": null,
"overflow": null,
"padding": null,
"right": null,
"top": null,
"visibility": null,
"width": null
}
},
"bee2385ba9374a04b1937aa60a1132c1": {
"model_module": "@jupyter-widgets/base",
"model_module_version": "2.0.0",
"model_name": "LayoutModel",
"state": {
"_model_module": "@jupyter-widgets/base",
"_model_module_version": "2.0.0",
"_model_name": "LayoutModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "LayoutView",
"align_content": null,
"align_items": null,
"align_self": null,
"border_bottom": null,
"border_left": null,
"border_right": null,
"border_top": null,
"bottom": null,
"display": null,
"flex": null,
"flex_flow": null,
"grid_area": null,
"grid_auto_columns": null,
"grid_auto_flow": null,
"grid_auto_rows": null,
"grid_column": null,
"grid_gap": null,
"grid_row": null,
"grid_template_areas": null,
"grid_template_columns": null,
"grid_template_rows": null,
"height": null,
"justify_content": null,
"justify_items": null,
"left": null,
"margin": null,
"max_height": null,
"max_width": null,
"min_height": null,
"min_width": null,
"object_fit": null,
"object_position": null,
"order": null,
"overflow": null,
"padding": null,
"right": null,
"top": null,
"visibility": null,
"width": null
}
},
"c016fe5bd4284aaea0322b2282c771f4": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "HTMLModel",
"state": {
"_dom_classes": [],
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "HTMLModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/controls",
"_view_module_version": "2.0.0",
"_view_name": "HTMLView",
"description": "",
"description_allow_html": false,
"layout": "IPY_MODEL_d0ecbc2e5d9a484e8315f4670ff8b91b",
"placeholder": "",
"style": "IPY_MODEL_dbccc70ab8ac4369901f29901bdba53c",
"tabbable": null,
"tooltip": null,
"value": " 265/265 [00:00<00:00, 31.7kB/s]"
}
},
"c08f735baec84172bd6848cb6432ff87": {
"model_module": "@jupyter-widgets/base",
"model_module_version": "2.0.0",
"model_name": "LayoutModel",
"state": {
"_model_module": "@jupyter-widgets/base",
"_model_module_version": "2.0.0",
"_model_name": "LayoutModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "LayoutView",
"align_content": null,
"align_items": null,
"align_self": null,
"border_bottom": null,
"border_left": null,
"border_right": null,
"border_top": null,
"bottom": null,
"display": null,
"flex": null,
"flex_flow": null,
"grid_area": null,
"grid_auto_columns": null,
"grid_auto_flow": null,
"grid_auto_rows": null,
"grid_column": null,
"grid_gap": null,
"grid_row": null,
"grid_template_areas": null,
"grid_template_columns": null,
"grid_template_rows": null,
"height": null,
"justify_content": null,
"justify_items": null,
"left": null,
"margin": null,
"max_height": null,
"max_width": null,
"min_height": null,
"min_width": null,
"object_fit": null,
"object_position": null,
"order": null,
"overflow": null,
"padding": null,
"right": null,
"top": null,
"visibility": null,
"width": "20px"
}
},
"c0a5d35dad0e44fd81df4ce88ac32b9e": {
"model_module": "@jupyter-widgets/base",
"model_module_version": "2.0.0",
"model_name": "LayoutModel",
"state": {
"_model_module": "@jupyter-widgets/base",
"_model_module_version": "2.0.0",
"_model_name": "LayoutModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "LayoutView",
"align_content": null,
"align_items": null,
"align_self": null,
"border_bottom": null,
"border_left": null,
"border_right": null,
"border_top": null,
"bottom": null,
"display": null,
"flex": null,
"flex_flow": null,
"grid_area": null,
"grid_auto_columns": null,
"grid_auto_flow": null,
"grid_auto_rows": null,
"grid_column": null,
"grid_gap": null,
"grid_row": null,
"grid_template_areas": null,
"grid_template_columns": null,
"grid_template_rows": null,
"height": null,
"justify_content": null,
"justify_items": null,
"left": null,
"margin": null,
"max_height": null,
"max_width": null,
"min_height": null,
"min_width": null,
"object_fit": null,
"object_position": null,
"order": null,
"overflow": null,
"padding": null,
"right": null,
"top": null,
"visibility": null,
"width": null
}
},
"c0cb85d241934573ac8605a8f2601fa2": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "HBoxModel",
"state": {
"_dom_classes": [],
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "HBoxModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/controls",
"_view_module_version": "2.0.0",
"_view_name": "HBoxView",
"box_style": "",
"children": [
"IPY_MODEL_7766cdc6d8c044519c2d779620b21246",
"IPY_MODEL_3d14ac7f692644eb89454650dd2dae1f",
"IPY_MODEL_a88df84670244523baaf6669c9adf949"
],
"layout": "IPY_MODEL_59294633289c4df8b81887e1d8cda00b",
"tabbable": null,
"tooltip": null
}
},
"c1102dd1228c479091345ed81be516c7": {
"model_module": "@jupyter-widgets/base",
"model_module_version": "2.0.0",
"model_name": "LayoutModel",
"state": {
"_model_module": "@jupyter-widgets/base",
"_model_module_version": "2.0.0",
"_model_name": "LayoutModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "LayoutView",
"align_content": null,
"align_items": null,
"align_self": null,
"border_bottom": null,
"border_left": null,
"border_right": null,
"border_top": null,
"bottom": null,
"display": null,
"flex": null,
"flex_flow": null,
"grid_area": null,
"grid_auto_columns": null,
"grid_auto_flow": null,
"grid_auto_rows": null,
"grid_column": null,
"grid_gap": null,
"grid_row": null,
"grid_template_areas": null,
"grid_template_columns": null,
"grid_template_rows": null,
"height": null,
"justify_content": null,
"justify_items": null,
"left": null,
"margin": null,
"max_height": null,
"max_width": null,
"min_height": null,
"min_width": null,
"object_fit": null,
"object_position": null,
"order": null,
"overflow": null,
"padding": null,
"right": null,
"top": null,
"visibility": null,
"width": null
}
},
"c1c9d87d48d24e74a7314dd5916b1c40": {
"model_module": "@jupyter-widgets/base",
"model_module_version": "2.0.0",
"model_name": "LayoutModel",
"state": {
"_model_module": "@jupyter-widgets/base",
"_model_module_version": "2.0.0",
"_model_name": "LayoutModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "LayoutView",
"align_content": null,
"align_items": null,
"align_self": null,
"border_bottom": null,
"border_left": null,
"border_right": null,
"border_top": null,
"bottom": null,
"display": null,
"flex": null,
"flex_flow": null,
"grid_area": null,
"grid_auto_columns": null,
"grid_auto_flow": null,
"grid_auto_rows": null,
"grid_column": null,
"grid_gap": null,
"grid_row": null,
"grid_template_areas": null,
"grid_template_columns": null,
"grid_template_rows": null,
"height": null,
"justify_content": null,
"justify_items": null,
"left": null,
"margin": null,
"max_height": null,
"max_width": null,
"min_height": null,
"min_width": null,
"object_fit": null,
"object_position": null,
"order": null,
"overflow": null,
"padding": null,
"right": null,
"top": null,
"visibility": null,
"width": "20px"
}
},
"c235a89aaf2e4a1fa7f8a9b9251866e5": {
"model_module": "@jupyter-widgets/base",
"model_module_version": "2.0.0",
"model_name": "LayoutModel",
"state": {
"_model_module": "@jupyter-widgets/base",
"_model_module_version": "2.0.0",
"_model_name": "LayoutModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "LayoutView",
"align_content": null,
"align_items": null,
"align_self": null,
"border_bottom": null,
"border_left": null,
"border_right": null,
"border_top": null,
"bottom": null,
"display": null,
"flex": null,
"flex_flow": null,
"grid_area": null,
"grid_auto_columns": null,
"grid_auto_flow": null,
"grid_auto_rows": null,
"grid_column": null,
"grid_gap": null,
"grid_row": null,
"grid_template_areas": null,
"grid_template_columns": null,
"grid_template_rows": null,
"height": null,
"justify_content": null,
"justify_items": null,
"left": null,
"margin": null,
"max_height": null,
"max_width": null,
"min_height": null,
"min_width": null,
"object_fit": null,
"object_position": null,
"order": null,
"overflow": null,
"padding": null,
"right": null,
"top": null,
"visibility": null,
"width": null
}
},
"c3585be81d2d480d912aa26d5e1815e3": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "HTMLStyleModel",
"state": {
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "HTMLStyleModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "StyleView",
"background": null,
"description_width": "",
"font_size": null,
"text_color": null
}
},
"c3f9b0c015634294a76455c9ebf5b48f": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "ProgressStyleModel",
"state": {
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "ProgressStyleModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "StyleView",
"bar_color": null,
"description_width": ""
}
},
"c4099e61027148ffa4f66a13cab7bdec": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "HTMLStyleModel",
"state": {
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "HTMLStyleModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "StyleView",
"background": null,
"description_width": "",
"font_size": null,
"text_color": null
}
},
"c4cf5800803b47b384fa0935dc83481a": {
"model_module": "@jupyter-widgets/base",
"model_module_version": "2.0.0",
"model_name": "LayoutModel",
"state": {
"_model_module": "@jupyter-widgets/base",
"_model_module_version": "2.0.0",
"_model_name": "LayoutModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "LayoutView",
"align_content": null,
"align_items": null,
"align_self": null,
"border_bottom": null,
"border_left": null,
"border_right": null,
"border_top": null,
"bottom": null,
"display": null,
"flex": null,
"flex_flow": null,
"grid_area": null,
"grid_auto_columns": null,
"grid_auto_flow": null,
"grid_auto_rows": null,
"grid_column": null,
"grid_gap": null,
"grid_row": null,
"grid_template_areas": null,
"grid_template_columns": null,
"grid_template_rows": null,
"height": null,
"justify_content": null,
"justify_items": null,
"left": null,
"margin": null,
"max_height": null,
"max_width": null,
"min_height": null,
"min_width": null,
"object_fit": null,
"object_position": null,
"order": null,
"overflow": null,
"padding": null,
"right": null,
"top": null,
"visibility": null,
"width": null
}
},
"c87fb6446189421aa805ac3999f72c19": {
"model_module": "@jupyter-widgets/base",
"model_module_version": "2.0.0",
"model_name": "LayoutModel",
"state": {
"_model_module": "@jupyter-widgets/base",
"_model_module_version": "2.0.0",
"_model_name": "LayoutModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "LayoutView",
"align_content": null,
"align_items": null,
"align_self": null,
"border_bottom": null,
"border_left": null,
"border_right": null,
"border_top": null,
"bottom": null,
"display": null,
"flex": null,
"flex_flow": null,
"grid_area": null,
"grid_auto_columns": null,
"grid_auto_flow": null,
"grid_auto_rows": null,
"grid_column": null,
"grid_gap": null,
"grid_row": null,
"grid_template_areas": null,
"grid_template_columns": null,
"grid_template_rows": null,
"height": null,
"justify_content": null,
"justify_items": null,
"left": null,
"margin": null,
"max_height": null,
"max_width": null,
"min_height": null,
"min_width": null,
"object_fit": null,
"object_position": null,
"order": null,
"overflow": null,
"padding": null,
"right": null,
"top": null,
"visibility": null,
"width": null
}
},
"c8ab9148400f4b648bb74b12ae3d0863": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "HBoxModel",
"state": {
"_dom_classes": [],
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "HBoxModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/controls",
"_view_module_version": "2.0.0",
"_view_name": "HBoxView",
"box_style": "",
"children": [
"IPY_MODEL_7abe4e7f59014837b4dae82ba423cb38",
"IPY_MODEL_777913145e8142f4b9b6173a1595b367",
"IPY_MODEL_d82443061e4841e9b52483a79d5ad990"
],
"layout": "IPY_MODEL_2c981621578343b0834b8890c8f9ac00",
"tabbable": null,
"tooltip": null
}
},
"ca29a375b504402089fec49a92dd344e": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "FloatProgressModel",
"state": {
"_dom_classes": [],
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "FloatProgressModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/controls",
"_view_module_version": "2.0.0",
"_view_name": "ProgressView",
"bar_style": "success",
"description": "",
"description_allow_html": false,
"layout": "IPY_MODEL_4b6bc0b5e99f434580ae27b78e49a451",
"max": 5547254632,
"min": 0,
"orientation": "horizontal",
"style": "IPY_MODEL_d5ed93eb60bf417f922268d3e99439d0",
"tabbable": null,
"tooltip": null,
"value": 5547254632
}
},
"caaa672e7f0e41c689e2aedc61a91e90": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "HTMLStyleModel",
"state": {
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "HTMLStyleModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "StyleView",
"background": null,
"description_width": "",
"font_size": null,
"text_color": null
}
},
"cbfb1c98b9024eea8f0189a406549086": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "HTMLStyleModel",
"state": {
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "HTMLStyleModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "StyleView",
"background": null,
"description_width": "",
"font_size": null,
"text_color": null
}
},
"ccd6de9aac1a4b269e25a9219cdda807": {
"model_module": "@jupyter-widgets/base",
"model_module_version": "2.0.0",
"model_name": "LayoutModel",
"state": {
"_model_module": "@jupyter-widgets/base",
"_model_module_version": "2.0.0",
"_model_name": "LayoutModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "LayoutView",
"align_content": null,
"align_items": null,
"align_self": null,
"border_bottom": null,
"border_left": null,
"border_right": null,
"border_top": null,
"bottom": null,
"display": null,
"flex": null,
"flex_flow": null,
"grid_area": null,
"grid_auto_columns": null,
"grid_auto_flow": null,
"grid_auto_rows": null,
"grid_column": null,
"grid_gap": null,
"grid_row": null,
"grid_template_areas": null,
"grid_template_columns": null,
"grid_template_rows": null,
"height": null,
"justify_content": null,
"justify_items": null,
"left": null,
"margin": null,
"max_height": null,
"max_width": null,
"min_height": null,
"min_width": null,
"object_fit": null,
"object_position": null,
"order": null,
"overflow": null,
"padding": null,
"right": null,
"top": null,
"visibility": null,
"width": null
}
},
"cd759a87594141cb940102df74dcf3ce": {
"model_module": "@jupyter-widgets/base",
"model_module_version": "2.0.0",
"model_name": "LayoutModel",
"state": {
"_model_module": "@jupyter-widgets/base",
"_model_module_version": "2.0.0",
"_model_name": "LayoutModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "LayoutView",
"align_content": null,
"align_items": null,
"align_self": null,
"border_bottom": null,
"border_left": null,
"border_right": null,
"border_top": null,
"bottom": null,
"display": null,
"flex": null,
"flex_flow": null,
"grid_area": null,
"grid_auto_columns": null,
"grid_auto_flow": null,
"grid_auto_rows": null,
"grid_column": null,
"grid_gap": null,
"grid_row": null,
"grid_template_areas": null,
"grid_template_columns": null,
"grid_template_rows": null,
"height": null,
"justify_content": null,
"justify_items": null,
"left": null,
"margin": null,
"max_height": null,
"max_width": null,
"min_height": null,
"min_width": null,
"object_fit": null,
"object_position": null,
"order": null,
"overflow": null,
"padding": null,
"right": null,
"top": null,
"visibility": null,
"width": null
}
},
"ce6d1ee6cf81425cb7b6951ce530d34e": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "HTMLModel",
"state": {
"_dom_classes": [],
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "HTMLModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/controls",
"_view_module_version": "2.0.0",
"_view_name": "HTMLView",
"description": "",
"description_allow_html": false,
"layout": "IPY_MODEL_f51f28d7fec44ae5b2479bc2d42d318a",
"placeholder": "",
"style": "IPY_MODEL_d0340635e32548d3bf267d099f44e8db",
"tabbable": null,
"tooltip": null,
"value": " 339/339 [00:01<00:00, 147.24it/s]"
}
},
"ced9eb5361ea4544a3353e6795ab4748": {
"model_module": "@jupyter-widgets/base",
"model_module_version": "2.0.0",
"model_name": "LayoutModel",
"state": {
"_model_module": "@jupyter-widgets/base",
"_model_module_version": "2.0.0",
"_model_name": "LayoutModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "LayoutView",
"align_content": null,
"align_items": null,
"align_self": null,
"border_bottom": null,
"border_left": null,
"border_right": null,
"border_top": null,
"bottom": null,
"display": null,
"flex": null,
"flex_flow": null,
"grid_area": null,
"grid_auto_columns": null,
"grid_auto_flow": null,
"grid_auto_rows": null,
"grid_column": null,
"grid_gap": null,
"grid_row": null,
"grid_template_areas": null,
"grid_template_columns": null,
"grid_template_rows": null,
"height": null,
"justify_content": null,
"justify_items": null,
"left": null,
"margin": null,
"max_height": null,
"max_width": null,
"min_height": null,
"min_width": null,
"object_fit": null,
"object_position": null,
"order": null,
"overflow": null,
"padding": null,
"right": null,
"top": null,
"visibility": null,
"width": null
}
},
"cfc6bec735494c868d28e2a8ff0c6358": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "HTMLModel",
"state": {
"_dom_classes": [],
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "HTMLModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/controls",
"_view_module_version": "2.0.0",
"_view_name": "HTMLView",
"description": "",
"description_allow_html": false,
"layout": "IPY_MODEL_16ec5ecef4644209b32a044c633e8a52",
"placeholder": "",
"style": "IPY_MODEL_9d592b79075d432b905fa462dd4e1d16",
"tabbable": null,
"tooltip": null,
"value": "special_tokens_map.json: 100%"
}
},
"d0340635e32548d3bf267d099f44e8db": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "HTMLStyleModel",
"state": {
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "HTMLStyleModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "StyleView",
"background": null,
"description_width": "",
"font_size": null,
"text_color": null
}
},
"d08c32b2cbfb49c2bdbcb4f96be1c061": {
"model_module": "@jupyter-widgets/base",
"model_module_version": "2.0.0",
"model_name": "LayoutModel",
"state": {
"_model_module": "@jupyter-widgets/base",
"_model_module_version": "2.0.0",
"_model_name": "LayoutModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "LayoutView",
"align_content": null,
"align_items": null,
"align_self": null,
"border_bottom": null,
"border_left": null,
"border_right": null,
"border_top": null,
"bottom": null,
"display": null,
"flex": null,
"flex_flow": null,
"grid_area": null,
"grid_auto_columns": null,
"grid_auto_flow": null,
"grid_auto_rows": null,
"grid_column": null,
"grid_gap": null,
"grid_row": null,
"grid_template_areas": null,
"grid_template_columns": null,
"grid_template_rows": null,
"height": null,
"justify_content": null,
"justify_items": null,
"left": null,
"margin": null,
"max_height": null,
"max_width": null,
"min_height": null,
"min_width": null,
"object_fit": null,
"object_position": null,
"order": null,
"overflow": null,
"padding": null,
"right": null,
"top": null,
"visibility": null,
"width": null
}
},
"d0ecbc2e5d9a484e8315f4670ff8b91b": {
"model_module": "@jupyter-widgets/base",
"model_module_version": "2.0.0",
"model_name": "LayoutModel",
"state": {
"_model_module": "@jupyter-widgets/base",
"_model_module_version": "2.0.0",
"_model_name": "LayoutModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "LayoutView",
"align_content": null,
"align_items": null,
"align_self": null,
"border_bottom": null,
"border_left": null,
"border_right": null,
"border_top": null,
"bottom": null,
"display": null,
"flex": null,
"flex_flow": null,
"grid_area": null,
"grid_auto_columns": null,
"grid_auto_flow": null,
"grid_auto_rows": null,
"grid_column": null,
"grid_gap": null,
"grid_row": null,
"grid_template_areas": null,
"grid_template_columns": null,
"grid_template_rows": null,
"height": null,
"justify_content": null,
"justify_items": null,
"left": null,
"margin": null,
"max_height": null,
"max_width": null,
"min_height": null,
"min_width": null,
"object_fit": null,
"object_position": null,
"order": null,
"overflow": null,
"padding": null,
"right": null,
"top": null,
"visibility": null,
"width": null
}
},
"d127679ed10a46f6ac817e6ea29ddefb": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "HTMLStyleModel",
"state": {
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "HTMLStyleModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "StyleView",
"background": null,
"description_width": "",
"font_size": null,
"text_color": null
}
},
"d16551a17dbf4e5ab902b07b56e1c8f9": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "HTMLStyleModel",
"state": {
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "HTMLStyleModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "StyleView",
"background": null,
"description_width": "",
"font_size": null,
"text_color": null
}
},
"d1c30b448a094da084681f96ecc78e26": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "HTMLStyleModel",
"state": {
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "HTMLStyleModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "StyleView",
"background": null,
"description_width": "",
"font_size": null,
"text_color": null
}
},
"d579251d80f44cc5bc333217850057a1": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "HTMLStyleModel",
"state": {
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "HTMLStyleModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "StyleView",
"background": null,
"description_width": "",
"font_size": null,
"text_color": null
}
},
"d5ed93eb60bf417f922268d3e99439d0": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "ProgressStyleModel",
"state": {
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "ProgressStyleModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "StyleView",
"bar_color": null,
"description_width": ""
}
},
"d63ecee969ab462590aa00a8c963c4d1": {
"model_module": "@jupyter-widgets/base",
"model_module_version": "2.0.0",
"model_name": "LayoutModel",
"state": {
"_model_module": "@jupyter-widgets/base",
"_model_module_version": "2.0.0",
"_model_name": "LayoutModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "LayoutView",
"align_content": null,
"align_items": null,
"align_self": null,
"border_bottom": null,
"border_left": null,
"border_right": null,
"border_top": null,
"bottom": null,
"display": null,
"flex": null,
"flex_flow": null,
"grid_area": null,
"grid_auto_columns": null,
"grid_auto_flow": null,
"grid_auto_rows": null,
"grid_column": null,
"grid_gap": null,
"grid_row": null,
"grid_template_areas": null,
"grid_template_columns": null,
"grid_template_rows": null,
"height": null,
"justify_content": null,
"justify_items": null,
"left": null,
"margin": null,
"max_height": null,
"max_width": null,
"min_height": null,
"min_width": null,
"object_fit": null,
"object_position": null,
"order": null,
"overflow": null,
"padding": null,
"right": null,
"top": null,
"visibility": null,
"width": null
}
},
"d82443061e4841e9b52483a79d5ad990": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "HTMLModel",
"state": {
"_dom_classes": [],
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "HTMLModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/controls",
"_view_module_version": "2.0.0",
"_view_name": "HTMLView",
"description": "",
"description_allow_html": false,
"layout": "IPY_MODEL_553ca1b5d8444ba9bbda273c5f0b2921",
"placeholder": "",
"style": "IPY_MODEL_4f2f58a661a54c13b2d7e2eb3d56594c",
"tabbable": null,
"tooltip": null,
"value": " 4.98k/? [00:00<00:00, 512kB/s]"
}
},
"d89d0facd4d54f1098f0013627ca641e": {
"model_module": "@jupyter-widgets/base",
"model_module_version": "2.0.0",
"model_name": "LayoutModel",
"state": {
"_model_module": "@jupyter-widgets/base",
"_model_module_version": "2.0.0",
"_model_name": "LayoutModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "LayoutView",
"align_content": null,
"align_items": null,
"align_self": null,
"border_bottom": null,
"border_left": null,
"border_right": null,
"border_top": null,
"bottom": null,
"display": null,
"flex": null,
"flex_flow": null,
"grid_area": null,
"grid_auto_columns": null,
"grid_auto_flow": null,
"grid_auto_rows": null,
"grid_column": null,
"grid_gap": null,
"grid_row": null,
"grid_template_areas": null,
"grid_template_columns": null,
"grid_template_rows": null,
"height": null,
"justify_content": null,
"justify_items": null,
"left": null,
"margin": null,
"max_height": null,
"max_width": null,
"min_height": null,
"min_width": null,
"object_fit": null,
"object_position": null,
"order": null,
"overflow": null,
"padding": null,
"right": null,
"top": null,
"visibility": null,
"width": "20px"
}
},
"dbccc70ab8ac4369901f29901bdba53c": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "HTMLStyleModel",
"state": {
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "HTMLStyleModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "StyleView",
"background": null,
"description_width": "",
"font_size": null,
"text_color": null
}
},
"dd60190c540b41e49c6ef6514861a7eb": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "HTMLModel",
"state": {
"_dom_classes": [],
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "HTMLModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/controls",
"_view_module_version": "2.0.0",
"_view_name": "HTMLView",
"description": "",
"description_allow_html": false,
"layout": "IPY_MODEL_ec5e36dcdae04b4ab0b25088552baa59",
"placeholder": "",
"style": "IPY_MODEL_a4ce863c40f7451db3f5f6ba9090e922",
"tabbable": null,
"tooltip": null,
"value": "README.md: "
}
},
"dfc2c324d7fd4d51bda2b790102adbb9": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "HTMLStyleModel",
"state": {
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "HTMLStyleModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "StyleView",
"background": null,
"description_width": "",
"font_size": null,
"text_color": null
}
},
"e02eef7123004f49a3833585ca8e7d63": {
"model_module": "@jupyter-widgets/base",
"model_module_version": "2.0.0",
"model_name": "LayoutModel",
"state": {
"_model_module": "@jupyter-widgets/base",
"_model_module_version": "2.0.0",
"_model_name": "LayoutModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "LayoutView",
"align_content": null,
"align_items": null,
"align_self": null,
"border_bottom": null,
"border_left": null,
"border_right": null,
"border_top": null,
"bottom": null,
"display": null,
"flex": null,
"flex_flow": null,
"grid_area": null,
"grid_auto_columns": null,
"grid_auto_flow": null,
"grid_auto_rows": null,
"grid_column": null,
"grid_gap": null,
"grid_row": null,
"grid_template_areas": null,
"grid_template_columns": null,
"grid_template_rows": null,
"height": null,
"justify_content": null,
"justify_items": null,
"left": null,
"margin": null,
"max_height": null,
"max_width": null,
"min_height": null,
"min_width": null,
"object_fit": null,
"object_position": null,
"order": null,
"overflow": null,
"padding": null,
"right": null,
"top": null,
"visibility": null,
"width": null
}
},
"e04315fd081b4689864a012172937449": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "HBoxModel",
"state": {
"_dom_classes": [],
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "HBoxModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/controls",
"_view_module_version": "2.0.0",
"_view_name": "HBoxView",
"box_style": "",
"children": [
"IPY_MODEL_a823cf08126d4bda9e86808b8c2674b0",
"IPY_MODEL_2d6682f461014dc292303a40c99d4dfe",
"IPY_MODEL_976a9680bef541feae2f802b72b9df32"
],
"layout": "IPY_MODEL_72d0d3225d0d487a97285bdabf0d4bbe",
"tabbable": null,
"tooltip": null
}
},
"e1498785d0974658a4362fda3065c4d7": {
"model_module": "@jupyter-widgets/base",
"model_module_version": "2.0.0",
"model_name": "LayoutModel",
"state": {
"_model_module": "@jupyter-widgets/base",
"_model_module_version": "2.0.0",
"_model_name": "LayoutModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "LayoutView",
"align_content": null,
"align_items": null,
"align_self": null,
"border_bottom": null,
"border_left": null,
"border_right": null,
"border_top": null,
"bottom": null,
"display": null,
"flex": null,
"flex_flow": null,
"grid_area": null,
"grid_auto_columns": null,
"grid_auto_flow": null,
"grid_auto_rows": null,
"grid_column": null,
"grid_gap": null,
"grid_row": null,
"grid_template_areas": null,
"grid_template_columns": null,
"grid_template_rows": null,
"height": null,
"justify_content": null,
"justify_items": null,
"left": null,
"margin": null,
"max_height": null,
"max_width": null,
"min_height": null,
"min_width": null,
"object_fit": null,
"object_position": null,
"order": null,
"overflow": null,
"padding": null,
"right": null,
"top": null,
"visibility": null,
"width": null
}
},
"e159c6c46cab4593b037abb0208bdb8f": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "HBoxModel",
"state": {
"_dom_classes": [],
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "HBoxModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/controls",
"_view_module_version": "2.0.0",
"_view_name": "HBoxView",
"box_style": "",
"children": [
"IPY_MODEL_4626f5b148024aac881ed03a0f5255aa",
"IPY_MODEL_15b2831a8acf44478a0d3dbeb44b93ab",
"IPY_MODEL_1e96c6e2c93a42959619c7ca399c8a93"
],
"layout": "IPY_MODEL_cd759a87594141cb940102df74dcf3ce",
"tabbable": null,
"tooltip": null
}
},
"e2e7d7d999d34bdba7c4c154566206d4": {
"model_module": "@jupyter-widgets/base",
"model_module_version": "2.0.0",
"model_name": "LayoutModel",
"state": {
"_model_module": "@jupyter-widgets/base",
"_model_module_version": "2.0.0",
"_model_name": "LayoutModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "LayoutView",
"align_content": null,
"align_items": null,
"align_self": null,
"border_bottom": null,
"border_left": null,
"border_right": null,
"border_top": null,
"bottom": null,
"display": null,
"flex": null,
"flex_flow": null,
"grid_area": null,
"grid_auto_columns": null,
"grid_auto_flow": null,
"grid_auto_rows": null,
"grid_column": null,
"grid_gap": null,
"grid_row": null,
"grid_template_areas": null,
"grid_template_columns": null,
"grid_template_rows": null,
"height": null,
"justify_content": null,
"justify_items": null,
"left": null,
"margin": null,
"max_height": null,
"max_width": null,
"min_height": null,
"min_width": null,
"object_fit": null,
"object_position": null,
"order": null,
"overflow": null,
"padding": null,
"right": null,
"top": null,
"visibility": null,
"width": null
}
},
"e55cc58325bb4eefa954c794823f84a6": {
"model_module": "@jupyter-widgets/base",
"model_module_version": "2.0.0",
"model_name": "LayoutModel",
"state": {
"_model_module": "@jupyter-widgets/base",
"_model_module_version": "2.0.0",
"_model_name": "LayoutModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "LayoutView",
"align_content": null,
"align_items": null,
"align_self": null,
"border_bottom": null,
"border_left": null,
"border_right": null,
"border_top": null,
"bottom": null,
"display": null,
"flex": null,
"flex_flow": null,
"grid_area": null,
"grid_auto_columns": null,
"grid_auto_flow": null,
"grid_auto_rows": null,
"grid_column": null,
"grid_gap": null,
"grid_row": null,
"grid_template_areas": null,
"grid_template_columns": null,
"grid_template_rows": null,
"height": null,
"justify_content": null,
"justify_items": null,
"left": null,
"margin": null,
"max_height": null,
"max_width": null,
"min_height": null,
"min_width": null,
"object_fit": null,
"object_position": null,
"order": null,
"overflow": null,
"padding": null,
"right": null,
"top": null,
"visibility": null,
"width": "20px"
}
},
"e74824de4ae148a9a5cce7456de61ce6": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "HTMLModel",
"state": {
"_dom_classes": [],
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "HTMLModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/controls",
"_view_module_version": "2.0.0",
"_view_name": "HTMLView",
"description": "",
"description_allow_html": false,
"layout": "IPY_MODEL_c0a5d35dad0e44fd81df4ce88ac32b9e",
"placeholder": "",
"style": "IPY_MODEL_d1c30b448a094da084681f96ecc78e26",
"tabbable": null,
"tooltip": null,
"value": "config.json: "
}
},
"e84163c9f9f7423f9699ee3128175a6f": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "HTMLModel",
"state": {
"_dom_classes": [],
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "HTMLModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/controls",
"_view_module_version": "2.0.0",
"_view_name": "HTMLView",
"description": "",
"description_allow_html": false,
"layout": "IPY_MODEL_a6c1a416f2b241ffb5c2b77e881b1e2d",
"placeholder": "",
"style": "IPY_MODEL_d579251d80f44cc5bc333217850057a1",
"tabbable": null,
"tooltip": null,
"value": "generation_config.json: 100%"
}
},
"e98d1746d8e44705be02681f1dec42ad": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "HBoxModel",
"state": {
"_dom_classes": [],
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "HBoxModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/controls",
"_view_module_version": "2.0.0",
"_view_name": "HBoxView",
"box_style": "",
"children": [
"IPY_MODEL_9899e30615e5433ab1d0f237e338cab5",
"IPY_MODEL_45040783dd4c45c98f948ced425e85c7",
"IPY_MODEL_89e769e82c0643f19a723b635ee05fde"
],
"layout": "IPY_MODEL_e2e7d7d999d34bdba7c4c154566206d4",
"tabbable": null,
"tooltip": null
}
},
"e98ff8ff16ed4e8ea728ed6dcf8e466e": {
"model_module": "@jupyter-widgets/base",
"model_module_version": "2.0.0",
"model_name": "LayoutModel",
"state": {
"_model_module": "@jupyter-widgets/base",
"_model_module_version": "2.0.0",
"_model_name": "LayoutModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "LayoutView",
"align_content": null,
"align_items": null,
"align_self": null,
"border_bottom": null,
"border_left": null,
"border_right": null,
"border_top": null,
"bottom": null,
"display": null,
"flex": null,
"flex_flow": null,
"grid_area": null,
"grid_auto_columns": null,
"grid_auto_flow": null,
"grid_auto_rows": null,
"grid_column": null,
"grid_gap": null,
"grid_row": null,
"grid_template_areas": null,
"grid_template_columns": null,
"grid_template_rows": null,
"height": null,
"justify_content": null,
"justify_items": null,
"left": null,
"margin": null,
"max_height": null,
"max_width": null,
"min_height": null,
"min_width": null,
"object_fit": null,
"object_position": null,
"order": null,
"overflow": null,
"padding": null,
"right": null,
"top": null,
"visibility": null,
"width": null
}
},
"e9dbe58a0604481ca41927407d5b85b6": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "HTMLModel",
"state": {
"_dom_classes": [],
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "HTMLModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/controls",
"_view_module_version": "2.0.0",
"_view_name": "HTMLView",
"description": "",
"description_allow_html": false,
"layout": "IPY_MODEL_e98ff8ff16ed4e8ea728ed6dcf8e466e",
"placeholder": "",
"style": "IPY_MODEL_91b15acc4b8743adb5970061f623ece3",
"tabbable": null,
"tooltip": null,
"value": "Generating test split: 100%"
}
},
"ea1911017af1498782ab1809a9ebfadb": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "FloatProgressModel",
"state": {
"_dom_classes": [],
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "FloatProgressModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/controls",
"_view_module_version": "2.0.0",
"_view_name": "ProgressView",
"bar_style": "success",
"description": "",
"description_allow_html": false,
"layout": "IPY_MODEL_4492af2ef3644d9f92ee65620ef5e44b",
"max": 1,
"min": 0,
"orientation": "horizontal",
"style": "IPY_MODEL_0e517ea9eb5c48c2aa457389650f77e8",
"tabbable": null,
"tooltip": null,
"value": 1
}
},
"ea5bb7d0a2e74221bbc4627997e20025": {
"model_module": "@jupyter-widgets/base",
"model_module_version": "2.0.0",
"model_name": "LayoutModel",
"state": {
"_model_module": "@jupyter-widgets/base",
"_model_module_version": "2.0.0",
"_model_name": "LayoutModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "LayoutView",
"align_content": null,
"align_items": null,
"align_self": null,
"border_bottom": null,
"border_left": null,
"border_right": null,
"border_top": null,
"bottom": null,
"display": null,
"flex": null,
"flex_flow": null,
"grid_area": null,
"grid_auto_columns": null,
"grid_auto_flow": null,
"grid_auto_rows": null,
"grid_column": null,
"grid_gap": null,
"grid_row": null,
"grid_template_areas": null,
"grid_template_columns": null,
"grid_template_rows": null,
"height": null,
"justify_content": null,
"justify_items": null,
"left": null,
"margin": null,
"max_height": null,
"max_width": null,
"min_height": null,
"min_width": null,
"object_fit": null,
"object_position": null,
"order": null,
"overflow": null,
"padding": null,
"right": null,
"top": null,
"visibility": null,
"width": null
}
},
"ec26fe9dbf934a05abc4a1f1ce374f99": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "HTMLModel",
"state": {
"_dom_classes": [],
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "HTMLModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/controls",
"_view_module_version": "2.0.0",
"_view_name": "HTMLView",
"description": "",
"description_allow_html": false,
"layout": "IPY_MODEL_a1a4cb2dbd864813b3f081133f340ee7",
"placeholder": "",
"style": "IPY_MODEL_462c6bdffc6849f39ac26fb783f9f48d",
"tabbable": null,
"tooltip": null,
"value": "tokenizer_config.json: "
}
},
"ec5e36dcdae04b4ab0b25088552baa59": {
"model_module": "@jupyter-widgets/base",
"model_module_version": "2.0.0",
"model_name": "LayoutModel",
"state": {
"_model_module": "@jupyter-widgets/base",
"_model_module_version": "2.0.0",
"_model_name": "LayoutModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "LayoutView",
"align_content": null,
"align_items": null,
"align_self": null,
"border_bottom": null,
"border_left": null,
"border_right": null,
"border_top": null,
"bottom": null,
"display": null,
"flex": null,
"flex_flow": null,
"grid_area": null,
"grid_auto_columns": null,
"grid_auto_flow": null,
"grid_auto_rows": null,
"grid_column": null,
"grid_gap": null,
"grid_row": null,
"grid_template_areas": null,
"grid_template_columns": null,
"grid_template_rows": null,
"height": null,
"justify_content": null,
"justify_items": null,
"left": null,
"margin": null,
"max_height": null,
"max_width": null,
"min_height": null,
"min_width": null,
"object_fit": null,
"object_position": null,
"order": null,
"overflow": null,
"padding": null,
"right": null,
"top": null,
"visibility": null,
"width": null
}
},
"ee45bf2d57a24250ba88e2edb060b41b": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "HTMLStyleModel",
"state": {
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "HTMLStyleModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "StyleView",
"background": null,
"description_width": "",
"font_size": null,
"text_color": null
}
},
"ef02190a0da544a5bf6b94ea3b084f2e": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "HTMLModel",
"state": {
"_dom_classes": [],
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "HTMLModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/controls",
"_view_module_version": "2.0.0",
"_view_name": "HTMLView",
"description": "",
"description_allow_html": false,
"layout": "IPY_MODEL_d08c32b2cbfb49c2bdbcb4f96be1c061",
"placeholder": "",
"style": "IPY_MODEL_7234b29a3a1e421eb593d3c2521f3363",
"tabbable": null,
"tooltip": null,
"value": " 1/1 [00:00<00:00, 143.95it/s]"
}
},
"ef232c2eadeb45f69a35cd6fecbf6ccd": {
"model_module": "@jupyter-widgets/base",
"model_module_version": "2.0.0",
"model_name": "LayoutModel",
"state": {
"_model_module": "@jupyter-widgets/base",
"_model_module_version": "2.0.0",
"_model_name": "LayoutModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "LayoutView",
"align_content": null,
"align_items": null,
"align_self": null,
"border_bottom": null,
"border_left": null,
"border_right": null,
"border_top": null,
"bottom": null,
"display": null,
"flex": null,
"flex_flow": null,
"grid_area": null,
"grid_auto_columns": null,
"grid_auto_flow": null,
"grid_auto_rows": null,
"grid_column": null,
"grid_gap": null,
"grid_row": null,
"grid_template_areas": null,
"grid_template_columns": null,
"grid_template_rows": null,
"height": null,
"justify_content": null,
"justify_items": null,
"left": null,
"margin": null,
"max_height": null,
"max_width": null,
"min_height": null,
"min_width": null,
"object_fit": null,
"object_position": null,
"order": null,
"overflow": null,
"padding": null,
"right": null,
"top": null,
"visibility": null,
"width": null
}
},
"f36cf5b205e441c0969d160090763cf9": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "FloatProgressModel",
"state": {
"_dom_classes": [],
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "FloatProgressModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/controls",
"_view_module_version": "2.0.0",
"_view_name": "ProgressView",
"bar_style": "success",
"description": "",
"description_allow_html": false,
"layout": "IPY_MODEL_35eb03e850d54545a42375819dcf3905",
"max": 83920,
"min": 0,
"orientation": "horizontal",
"style": "IPY_MODEL_0c2d83738cfb44829888a8bcc84274a4",
"tabbable": null,
"tooltip": null,
"value": 83920
}
},
"f4b38320a9ef4e8cacecd17d926d5f27": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "HBoxModel",
"state": {
"_dom_classes": [],
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "HBoxModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/controls",
"_view_module_version": "2.0.0",
"_view_name": "HBoxView",
"box_style": "",
"children": [
"IPY_MODEL_cfc6bec735494c868d28e2a8ff0c6358",
"IPY_MODEL_2fcb73ac60d24fe4a15ac03cf8e5ace1",
"IPY_MODEL_2353243d97be4dd8b54c34c8d83e59b3"
],
"layout": "IPY_MODEL_e1498785d0974658a4362fda3065c4d7",
"tabbable": null,
"tooltip": null
}
},
"f51f28d7fec44ae5b2479bc2d42d318a": {
"model_module": "@jupyter-widgets/base",
"model_module_version": "2.0.0",
"model_name": "LayoutModel",
"state": {
"_model_module": "@jupyter-widgets/base",
"_model_module_version": "2.0.0",
"_model_name": "LayoutModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "LayoutView",
"align_content": null,
"align_items": null,
"align_self": null,
"border_bottom": null,
"border_left": null,
"border_right": null,
"border_top": null,
"bottom": null,
"display": null,
"flex": null,
"flex_flow": null,
"grid_area": null,
"grid_auto_columns": null,
"grid_auto_flow": null,
"grid_auto_rows": null,
"grid_column": null,
"grid_gap": null,
"grid_row": null,
"grid_template_areas": null,
"grid_template_columns": null,
"grid_template_rows": null,
"height": null,
"justify_content": null,
"justify_items": null,
"left": null,
"margin": null,
"max_height": null,
"max_width": null,
"min_height": null,
"min_width": null,
"object_fit": null,
"object_position": null,
"order": null,
"overflow": null,
"padding": null,
"right": null,
"top": null,
"visibility": null,
"width": null
}
},
"f9fad5e5b63f45819bf724bb47d4845e": {
"model_module": "@jupyter-widgets/base",
"model_module_version": "2.0.0",
"model_name": "LayoutModel",
"state": {
"_model_module": "@jupyter-widgets/base",
"_model_module_version": "2.0.0",
"_model_name": "LayoutModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "LayoutView",
"align_content": null,
"align_items": null,
"align_self": null,
"border_bottom": null,
"border_left": null,
"border_right": null,
"border_top": null,
"bottom": null,
"display": null,
"flex": null,
"flex_flow": null,
"grid_area": null,
"grid_auto_columns": null,
"grid_auto_flow": null,
"grid_auto_rows": null,
"grid_column": null,
"grid_gap": null,
"grid_row": null,
"grid_template_areas": null,
"grid_template_columns": null,
"grid_template_rows": null,
"height": null,
"justify_content": null,
"justify_items": null,
"left": null,
"margin": null,
"max_height": null,
"max_width": null,
"min_height": null,
"min_width": null,
"object_fit": null,
"object_position": null,
"order": null,
"overflow": null,
"padding": null,
"right": null,
"top": null,
"visibility": null,
"width": null
}
},
"ff2f7e13305e40e5899988f584357d59": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "ProgressStyleModel",
"state": {
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "ProgressStyleModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/base",
"_view_module_version": "2.0.0",
"_view_name": "StyleView",
"bar_color": null,
"description_width": ""
}
},
"ff6ccc01482f46bdb8310d96230067b4": {
"model_module": "@jupyter-widgets/controls",
"model_module_version": "2.0.0",
"model_name": "FloatProgressModel",
"state": {
"_dom_classes": [],
"_model_module": "@jupyter-widgets/controls",
"_model_module_version": "2.0.0",
"_model_name": "FloatProgressModel",
"_view_count": null,
"_view_module": "@jupyter-widgets/controls",
"_view_module_version": "2.0.0",
"_view_name": "ProgressView",
"bar_style": "success",
"description": "",
"description_allow_html": false,
"layout": "IPY_MODEL_6b9c83c1a4e24bb2a22e019b6889bfdc",
"max": 1371,
"min": 0,
"orientation": "horizontal",
"style": "IPY_MODEL_a91876d8ff66499fa1f37945a20eeaf1",
"tabbable": null,
"tooltip": null,
"value": 1371
}
}
},
"version_major": 2,
"version_minor": 0
}
}
},
"nbformat": 4,
"nbformat_minor": 5
}