qmdr 1.0.0

package/finetune/Justfile

@@ -0,0 +1,43 @@
+set shell := ["bash", "-uc"]
+
+validate:
+    uv run dataset/validate_schema.py
+    uv run dataset/score_data.py
+    for f in data/*.jsonl; do \
+      uv run dataset/analyze_data.py --input "$f" --show-examples 0; \
+    done
+
+score:
+    uv run dataset/score_data.py
+
+schema:
+    uv run dataset/validate_schema.py
+
+analyze:
+    for f in data/*.jsonl; do \
+      uv run dataset/analyze_data.py --input "$f" --show-examples 0; \
+    done
+
+prepare:
+    QMD_BASE_MODEL=Qwen/Qwen3-1.7B uv run dataset/prepare_data.py --seed 42
+
+train-local:
+    just prepare
+    HF_TOKEN=${HF_TOKEN} uv run torchrun --standalone --nproc_per_node auto \
+      train.py sft --config configs/sft_local.yaml |& tee /tmp/qmd-sft-train.log
+
+grpo-local:
+    CUDA_VISIBLE_DEVICES=1,2,3 HF_TOKEN=${HF_TOKEN} uv run torchrun --standalone --nproc_per_node 3 \
+      train.py grpo --config configs/grpo.yaml |& tee /tmp/qmd-grpo-train.log
+
+gepa-local:
+    UV_CACHE_DIR=/tmp/uv-cache LITELLM_CACHE_DIR=/tmp/litellm-cache OLLAMA_API_BASE=http://localhost:11434 \
+      uv run python gepa/dspy_gepa.py \
+      --input data/qmd_expansion_v2.jsonl \
+      --model ollama/glm-4.7-flash:Q8_0 \
+      --reflection-model ollama/glm-4.7-flash:Q8_0 \
+      --max-metric-calls 100 --limit 20 \
+      --valset data/qmd_expansion_handcrafted.jsonl --val-limit 20 \
+      --max-tokens 512 --reflection-max-tokens 512 \
+      --emit gepa/gepa_outputs_glm.jsonl \
+      --save-prompt gepa/best_prompt_glm.txt

package/finetune/Modelfile

@@ -0,0 +1,16 @@
+FROM /home/tobi/src/github.com/tobi/qmd/finetune/outputs/sft/gguf/sft-q4_k_m.gguf
+
+PARAMETER temperature 0.0
+PARAMETER top_p 1.0
+PARAMETER top_k 0
+PARAMETER repeat_penalty 1.1
+PARAMETER num_ctx 4096
+
+TEMPLATE """<|im_start|>system
+You are a helpful assistant.
+<|im_end|>
+<|im_start|>user
+/no_think Expand this search query: {{ .Prompt }}
+<|im_end|>
+<|im_start|>assistant
+"""

package/finetune/README.md

@@ -0,0 +1,299 @@
+---
+license: mit
+language:
+  - en
+base_model: Qwen/Qwen3-1.7B
+tags:
+  - query-expansion
+  - search
+  - gguf
+  - qwen3
+pipeline_tag: text-generation
+---
+
+# QMD Query Expansion Fine-Tuning
+
+Train small language models to expand search queries for [QMD](https://github.com/tobi/qmd)'s hybrid retrieval pipeline.
+
+## What This Does
+
+Given a raw search query like `"auth config"`, the trained model produces structured expansions:
+
+```
+hyde: Authentication can be configured by setting the AUTH_SECRET environment variable.
+lex: authentication configuration
+lex: auth settings setup
+vec: how to configure authentication settings
+vec: authentication configuration options
+```
+
+These feed into QMD's three search backends:
+- **`lex:`** lines go to BM25 full-text search (short, keyword-focused)
+- **`vec:`** lines go to vector similarity search (natural language phrases)
+- **`hyde:`** is a hypothetical document passage for embedding-based retrieval ([HyDE](https://arxiv.org/abs/2212.10496) technique)
+
+## Quick Start
+
+### Cloud training via HuggingFace Jobs (no GPU needed)
+
+```bash
+# 1. SFT: teach the model the output format (~45 min on A10G, ~$1.50)
+hf jobs uv run --flavor a10g-large --secrets HF_TOKEN --timeout 2h jobs/sft.py
+
+# 2. GRPO: RL refinement on top of SFT (~20 min on A10G, ~$0.50)
+hf jobs uv run --flavor a10g-large --secrets HF_TOKEN --timeout 4h jobs/grpo.py
+
+# 3. Evaluate against test queries (needs local GPU or use eval job)
+uv run eval.py --model tobil/qmd-query-expansion-1.7B-grpo \
+               --sft-model tobil/qmd-query-expansion-1.7B-sft
+
+# 4. Convert to GGUF for local deployment (Ollama, llama.cpp)
+uv run convert_gguf.py --size 1.7B
+```
+
+### Local training (if you have a GPU)
+
+```bash
+uv run train.py sft  --config configs/sft.yaml
+uv run train.py grpo --config configs/grpo.yaml
+```
+
+### Monitoring HF Jobs
+
+```bash
+hf jobs ps                           # list running jobs
+hf jobs inspect <job-id>             # check status
+hf jobs logs <job-id>                # stream logs
+hf jobs cancel <job-id>              # cancel a job
+```
+
+## Prompt Format
+
+All tools use the same prompt — **Qwen3 chat template with `/no_think`**:
+
+```
+<|im_start|>user
+/no_think Expand this search query: {query}<|im_end|>
+<|im_start|>assistant
+```
+
+The `/no_think` directive suppresses Qwen3's chain-of-thought mode, producing
+direct `lex:/vec:/hyde:` output without `<think>` blocks.
+
+## File Structure
+
+```
+finetune/
+├── reward.py          # Scoring/reward function (single source of truth)
+├── train.py           # Unified SFT + GRPO training (two subcommands)
+├── eval.py            # Generate expansions and score them
+├── convert_gguf.py    # GGUF conversion for Ollama/llama.cpp
+├── jobs/
+│   ├── sft.py         # Self-contained SFT for HuggingFace Jobs
+│   ├── grpo.py        # Self-contained GRPO for HuggingFace Jobs
+│   ├── eval.py        # Self-contained eval for HuggingFace Jobs
+│   ├── eval_common.py # Shared eval utilities
+│   └── quantize.py    # GGUF quantization for HuggingFace Jobs
+├── configs/
+│   ├── sft.yaml       # SFT hyperparameters for Qwen3-1.7B
+│   └── grpo.yaml      # GRPO hyperparameters for Qwen3-1.7B
+├── evals/
+│   └── queries.txt    # 31 test queries across 8 categories
+├── data/
+│   └── qmd_expansion_v2.jsonl  # Source training data (1,000 high-quality examples)
+├── dataset/
+│   ├── generate_data.py         # Generate data via Claude API
+│   ├── generate_data_offline.py # Generate from existing HF dataset
+│   ├── prepare_data.py          # Format for Qwen3 chat template
+│   └── clean_data.py            # Detect technical term misinterpretations
+├── SCORING.md         # Detailed scoring rubric reference
+└── README.md          # This file
+```
+
+## Training Pipeline
+
+### Stage 1: SFT (Supervised Fine-Tuning)
+
+Teaches the model the `lex:/vec:/hyde:` output format from labeled examples.
+
+| Parameter | Value |
+|-----------|-------|
+| Base model | `Qwen/Qwen3-1.7B` |
+| Method | LoRA (rank 16, alpha 32) |
+| Target modules | All projection layers (q/k/v/o/gate/up/down) |
+| Dataset | ~2,290 examples (train split) |
+| Effective batch size | 16 (4 × 4 gradient accumulation) |
+| Epochs | 5 |
+| Learning rate | 2e-4 (cosine schedule) |
+
+```bash
+uv run train.py sft --config configs/sft.yaml
+uv run train.py sft --config configs/sft.yaml --dry-run  # preview config
+```
+
+### Stage 2: GRPO (Group Relative Policy Optimization)
+
+Reinforcement learning on top of the merged SFT weights. The model generates
+multiple expansions per query, they are scored by the reward function, and the
+model is updated to prefer higher-scoring outputs.
+
+| Parameter | Value |
+|-----------|-------|
+| Base | Merged SFT checkpoint |
+| Method | LoRA (rank 4, alpha 8) — smaller for RL stability |
+| Target modules | q_proj, v_proj only |
+| Reward | `reward.py` (rule-based, 5 dimensions) |
+| KL beta | 0.04 — prevents drift from SFT checkpoint |
+| Generations per prompt | 4 |
+| Max steps | 200 |
+| Learning rate | 5e-7 |
+
+**Important:** `beta > 0` is critical. With `beta=0` the model experiences
+catastrophic drift and scores drop to 0%.
+
+```bash
+uv run train.py grpo --config configs/grpo.yaml
+uv run train.py grpo --config configs/grpo.yaml --dry-run  # test reward function
+```
+
+## Evaluation
+
+`eval.py` generates expansions from a model and scores them against test queries:
+
+```bash
+# Evaluate an SFT model
+uv run eval.py --model tobil/qmd-query-expansion-1.7B-sft
+
+# Evaluate a GRPO model (needs SFT adapter merged first)
+uv run eval.py --model tobil/qmd-query-expansion-1.7B-grpo \
+               --sft-model tobil/qmd-query-expansion-1.7B-sft
+
+# Verbose output with deduction details
+uv run eval.py --model tobil/qmd-query-expansion-1.7B-sft -v
+
+# Save detailed scores to JSON
+uv run eval.py --model tobil/qmd-query-expansion-1.7B-sft -o scores.json
+
+# Score an existing JSONL file (backwards compat with old run.py output)
+uv run eval.py --score-only evals/results_old.jsonl
+```
+
+## Reward Function
+
+`reward.py` is the single source of truth for scoring. It is used both as the
+GRPO reward signal during training and for evaluation.
+
+Five scoring dimensions (max 120 without hyde, 140 with):
+
+| Dimension | Points | What It Measures |
+|-----------|--------|------------------|
+| **Format** | 0-30 | Has lex/vec lines, no invalid lines |
+| **Diversity** | 0-30 | Multiple expansion types, diverse content, no query echoes |
+| **HyDE** | 0-20 | Present, 50-200 chars, single line, not repetitive |
+| **Quality** | 0-20 | Lex shorter than vec, natural language, preserves key terms |
+| **Entity** | -45 to +20 | Named entities preserved in lex and vec lines |
+| **Think bonus** | 0-20 | Reward for NOT using `<think>` mode |
+
+**Hard failures** (instant 0.0):
+- Chat template leakage (`<|im_start|>`, `<|im_end|>`, etc.)
+- Any line without a valid `lex:`, `vec:`, or `hyde:` prefix
+
+```bash
+# Self-test the reward function
+uv run reward.py
+```
+
+## GGUF Conversion
+
+Merges base + SFT + GRPO adapters into a single model and produces
+quantized GGUF files for deployment:
+
+```bash
+# Use preset for 1.7B
+uv run convert_gguf.py --size 1.7B
+
+# Use preset for 4B
+uv run convert_gguf.py --size 4B
+
+# Custom models
+uv run convert_gguf.py --base Qwen/Qwen3-1.7B \
+                       --sft tobil/qmd-query-expansion-1.7B-sft \
+                       --grpo tobil/qmd-query-expansion-1.7B-grpo \
+                       --output tobil/qmd-query-expansion-1.7B-gguf
+```
+
+### Using with Ollama
+
+```bash
+huggingface-cli download tobil/qmd-query-expansion-1.7B-gguf \
+    qmd-query-expansion-1.7B-q4_k_m.gguf --local-dir .
+
+echo 'FROM ./qmd-query-expansion-1.7B-q4_k_m.gguf' > Modelfile
+ollama create qmd-expand -f Modelfile
+ollama run qmd-expand
+```
+
+## Data Pipeline
+
+The training data (1,000 examples in `data/qmd_expansion_v2.jsonl`) was generated
+from two sources and cleaned for quality. To regenerate:
+
+```bash
+# Generate from existing HuggingFace dataset (bulk, no API needed)
+uv run dataset/generate_data_offline.py
+
+# Generate via Claude API (higher quality, needs ANTHROPIC_API_KEY)
+uv run dataset/generate_data.py --count 100
+
+# Detect and fix technical term misinterpretations
+uv run dataset/clean_data.py
+
+# Format for Qwen3 chat template, add short-query augmentation, split train/val
+uv run dataset/prepare_data.py
+```
+
+## Architecture Notes
+
+The two-stage training approach (SFT → GRPO) is standard for structured-output models:
+
+1. **SFT** establishes format compliance and basic query understanding. It uses
+   a large LoRA (rank 16, all projection layers) because it needs to learn a
+   new output format from scratch.
+
+2. **GRPO** refines quality within the learned format. It uses a small LoRA
+   (rank 4, q/v only) and KL regularization to make incremental improvements
+   without losing what SFT taught.
+
+The reward function is entirely rule-based (no LLM judge) which makes it fast,
+deterministic, and suitable as an RL signal. See `SCORING.md` for the full rubric.
+
+## Training Results (Qwen3-1.7B, v2)
+
+### SFT
+
+| Metric | Value |
+|--------|-------|
+| Final train loss | 0.472 |
+| Final eval loss | 0.304 |
+| Token accuracy (train) | 97.4% |
+| Token accuracy (eval) | 93.8% |
+| Epochs | 5 |
+| Hardware | A10G (24 GB VRAM) |
+
+### GRPO
+
+| Metric | Value |
+|--------|-------|
+| Mean reward | 0.757 |
+| Final loss | 0.0005 |
+| KL divergence | 0.00048 |
+| Mean completion length | ~58 tokens |
+| Training time | ~19 min (200 steps) |
+| Hardware | A10G (24 GB VRAM) |
+
+### Evaluation Scores
+
+| Model | Average Score | Excellent (30) |
+|-------|--------------|-----------------|
+| SFT | 92.0% | 30/30 |
+| GRPO | 91.7% | 30/30 |

package/finetune/SCORING.md

@@ -0,0 +1,286 @@
+# QMD Query Expansion Scoring
+
+## Goal
+
+Transform a random typed query into a great set of retrieval-optimized expansions.
+
+**Input:** `"auth config"`
+**Output:**
+```
+hyde: Authentication can be configured by setting the AUTH_SECRET environment variable and enabling the auth middleware in your application's config file.
+lex: authentication configuration
+lex: auth settings setup
+vec: how to configure authentication settings
+vec: authentication configuration options
+```
+
+## Output Format
+
+| Prefix | Purpose | Required | Count |
+|--------|---------|----------|-------|
+| `lex:` | BM25 keyword variations (shorter, keyword-focused) | Yes | 1-3 |
+| `vec:` | Semantic reformulations (natural language) | Yes | 1-3 |
+| `hyde:` | Hypothetical document passage | Optional | 0-1 |
+
+## Scoring Criteria
+
+### 1. Format Compliance (0-30 points)
+
+| Criterion | Points | Deduction |
+|-----------|--------|-----------|
+| Has at least one `lex:` line | +10 | -10 if missing |
+| Has at least one `vec:` line | +10 | -10 if missing |
+| All lines have valid prefix (`lex:`, `vec:`, `hyde:`) | +10 | -5 per invalid line |
+| No garbage/prose outside of prefixed lines | - | -10 if present |
+
+### 2. Diversity & Coverage (0-30 points)
+
+| Criterion | Points | Deduction |
+|-----------|--------|-----------|
+| 2+ different types present (lex + vec) | +10 | -10 if only one type |
+| 2+ total expansions | +5 | -5 if only one |
+| Multiple lex: lines are diverse (edit distance > 3) | +5 | -2 per duplicate pair |
+| Multiple vec: lines are diverse (edit distance > 5) | +5 | -2 per duplicate pair |
+| lex/vec not identical to original query | +5 | -5 per line that equals query |
+
+### 3. Hyde Quality (0-20 points, optional bonus)
+
+| Criterion | Points | Deduction |
+|-----------|--------|-----------|
+| Hyde present and well-formed | +5 | - |
+| Hyde is concise (50-200 chars) | +5 | -3 if too short, -5 if too long |
+| Hyde has no newlines | +5 | -5 if contains newlines |
+| Hyde has no excessive repetition | +5 | -3 if word repeats 3+ times |
+
+### 4. Content Quality (0-20 points)
+
+| Criterion | Points | Deduction |
+|-----------|--------|-----------|
+| Base relevance | +5 | Subjective |
+| Lex lines preserve key terms from query | +5 | -5 if lex is generic |
+| Lex lines are keyword-focused (shorter) | +5 | -2 if lex is longer than vec |
+| Vec lines are natural language (complete phrases) | +5 | -2 if vec is just keywords |
+
+### 5. Named Entity Preservation (0-20 points, CRITICAL)
+
+Named entities are proper nouns, brand names, technical terms, and acronyms that MUST appear in lex queries. This prevents generic expansions that lose the specific topic.
+
+| Criterion | Points | Deduction |
+|-----------|--------|-----------|
+| All lex lines contain at least one entity | +15 | - |
+| Some lex lines contain entities | +5 | - |
+| NO lex lines contain entities | - | **-30 HEAVY PENALTY** |
+| Generic filler phrases in lex | - | -15 per phrase |
+| Entities also in vec lines | +5 | - |
+
+**Named Entity Detection:**
+- All-caps acronyms: `TDS`, `API`, `GPU`, `AWS`
+- Capitalized proper nouns: `React`, `Docker`, `Kubernetes`
+- Technical terms: `node.js`, `C++`, `.NET`
+- CamelCase: `JavaScript`, `TypeScript`
+- Compound names: `TDS motorsports` → both words are entities
+
+**Generic Filler Phrases (BANNED in lex):**
+- "find information about"
+- "search for", "look up"
+- "get information", "learn about"
+- "details about", "guide to"
+
+**Examples:**
+
+| Query | Bad Lex (Score: 0.30) | Good Lex (Score: 1.00) |
+|-------|----------------------|------------------------|
+| `who is TDS motorsports` | `lex: find information about` | `lex: TDS motorsports history` |
+| | `lex: company details` | `lex: TDS motorsports founders` |
+| `how to use React hooks` | `lex: programming tutorial` | `lex: React hooks tutorial` |
+| | `lex: how to code` | `lex: useEffect useState hooks` |
+
+**Key Rule**: If a query mentions a specific entity (brand, product, technology), EVERY lex line should include that entity or a direct variation of it.
+
+## Score Calculation
+
+```
+Total Score = Format + Diversity + Hyde + Quality + Entity
+Max Score = 120 (100 without hyde)
+Normalized = Total / Max (0.0 - 1.0)
+```
+
+**Rating:**
+- 0.80-1.00: Excellent
+- 0.60-0.79: Good
+- 0.40-0.59: Acceptable
+- 0.20-0.39: Poor
+- 0.00-0.19: Failed
+
+**Note:** Entity score can go negative, heavily penalizing outputs that miss named entities.
+
+## Examples
+
+### Good Example (Score: 85/100)
+
+**Query:** `"react hooks"`
+
+**Output:**
+```
+hyde: React Hooks allow you to use state and lifecycle features in functional components without writing a class.
+lex: react hooks tutorial
+lex: usestate useeffect
+vec: how to use react hooks in functional components
+vec: react hooks best practices guide
+```
+
+**Scoring:**
+- Format: 30/30 (all prefixes valid)
+- Diversity: 28/30 (2 types, 4 expansions, good diversity)
+- Hyde: 17/20 (present, good length, no repetition)
+- Quality: 10/20 (relevant, good structure)
+
+### Bad Example (Score: 15/100)
+
+**Query:** `"auth"`
+
+**Output:**
+```
+auth is an important concept that relates to authentication.
+The answer should be in Chinese.
+The answer should be in Chinese.
+```
+
+**Scoring:**
+- Format: 0/30 (no valid prefixes)
+- Diversity: 0/30 (no valid expansions)
+- Hyde: 0/20 (N/A)
+- Quality: 15/20 (some relevance but wrong format)
+
+### Medium Example (Score: 55/100)
+
+**Query:** `"docker networking"`
+
+**Output:**
+```
+hyde: Docker networking is an important concept. Docker networking is used for container communication. Docker networking configuration is essential.
+lex: docker networking
+vec: docker networking
+```
+
+**Scoring:**
+- Format: 30/30 (valid prefixes)
+- Diversity: 10/30 (lex=vec=query, no diversity)
+- Hyde: 5/20 (too repetitive - "docker networking" 3x)
+- Quality: 10/20 (relevant but low effort)
+
+## Heuristics
+
+### Repetition Detection
+
+```python
+def word_repetition_score(text):
+    words = text.lower().split()
+    counts = Counter(words)
+    # Deduct for words appearing 3+ times (excluding stopwords)
+    stopwords = {'the', 'a', 'an', 'is', 'are', 'to', 'for', 'of', 'in', 'and', 'or'}
+    repeated = sum(1 for w, c in counts.items() if c >= 3 and w not in stopwords)
+    return max(0, 5 - repeated * 2)
+```
+
+### Diversity Check (Simple)
+
+```python
+def is_diverse(a, b, min_distance=3):
+    """Check if two strings are sufficiently different."""
+    a, b = a.lower().strip(), b.lower().strip()
+    if a == b:
+        return False
+    # Simple: check if one is not a substring of the other
+    if a in b or b in a:
+        return False
+    # Check edit distance (simplified)
+    return len(set(a.split()) ^ set(b.split())) >= min_distance
+```
+
+### Query Echo Detection
+
+```python
+def echoes_query(expansion, query):
+    """Check if expansion is just echoing the query."""
+    exp = expansion.lower().strip()
+    q = query.lower().strip()
+    return exp == q or exp in q or q in exp
+```
+
+### Named Entity Extraction
+
+```python
+KEY_TERM_STOPWORDS = {'what', 'is', 'how', 'to', 'the', 'a', 'an', 'in', 'on', 'for', 'of',
+                      'and', 'or', 'with', 'my', 'your', 'do', 'does', 'can', 'i', 'me', 'we',
+                      'who', 'where', 'when', 'why', 'which', 'find', 'get', 'show', 'tell'}
+
+def extract_named_entities(query: str) -> set:
+    """Extract named entities using simple heuristics."""
+    entities = set()
+    words = query.split()
+    prev_was_entity = False
+
+    for i, word in enumerate(words):
+        clean = word.strip('.,!?:;()[]"\'')
+        if not clean:
+            prev_was_entity = False
+            continue
+
+        is_entity = False
+
+        # All-caps acronyms: TDS, API, GPU
+        if clean.isupper() and len(clean) >= 2:
+            entities.add(clean.lower())
+            is_entity = True
+        # Capitalized proper nouns (not first word)
+        elif i > 0 and clean[0].isupper() and clean.lower() not in KEY_TERM_STOPWORDS:
+            entities.add(clean.lower())
+            is_entity = True
+        # Technical terms: node.js, C++
+        elif any(c in clean for c in '.+-#@') and len(clean) >= 2:
+            entities.add(clean.lower())
+            is_entity = True
+        # CamelCase: JavaScript
+        elif len(clean) > 1 and any(c.isupper() for c in clean[1:]) and clean[0].isupper():
+            entities.add(clean.lower())
+            is_entity = True
+        # Word following an entity (compound names: TDS motorsports)
+        elif prev_was_entity and clean.lower() not in KEY_TERM_STOPWORDS:
+            entities.add(clean.lower())
+            is_entity = True
+
+        prev_was_entity = is_entity
+
+    return entities
+```
+
+### Generic Phrase Detection
+
+```python
+GENERIC_LEX_PHRASES = {
+    'find information about', 'search for', 'look up', 'get information',
+    'learn about', 'information on', 'details about', 'find out about',
+    'what is', 'how to', 'guide to', 'help with'
+}
+
+def lex_is_generic(lex_line: str) -> bool:
+    """Check if lex line is a useless generic filler."""
+    lex_lower = lex_line.lower().strip()
+    for phrase in GENERIC_LEX_PHRASES:
+        if phrase in lex_lower:
+            # Check if there's specific content beyond the generic phrase
+            remaining = lex_lower
+            for word in phrase.split():
+                remaining = remaining.replace(word, '', 1).strip()
+            if len(remaining) < 3:  # Nothing specific left
+                return True
+    return False
+```
+
+## Training Data Requirements
+
+1. **EOM tokens**: Ensure training examples end with proper end-of-message tokens
+2. **Diverse examples**: Include varied query types (short, long, technical, casual)
+3. **Quality hyde**: Hyde passages should be informative, not template-y
+4. **No repetition**: Avoid "This is important. This is very important." patterns

package/finetune/configs/accelerate_multi_gpu.yaml

@@ -0,0 +1,17 @@
+compute_environment: LOCAL_MACHINE
+debug: false
+distributed_type: MULTI_GPU
+downcast_bf16: 'no'
+enable_cpu_affinity: false
+gpu_ids: all
+machine_rank: 0
+main_training_function: main
+mixed_precision: bf16
+num_machines: 1
+num_processes: 4
+rdzv_backend: static
+same_network: true
+tpu_env: []
+tpu_use_cluster: false
+tpu_use_sudo: false
+use_cpu: false