File size: 13,981 Bytes
dcc3a31
b80a86d
 
 
 
 
 
dcc3a31
 
 
b80a86d
 
 
 
 
 
 
 
 
 
 
 
0a63154
 
55036db
 
b80a86d
8978a23
5fd0620
 
 
 
a64b4b7
 
 
5fd0620
dcc3a31
b80a86d
 
 
55036db
dcc3a31
b80a86d
 
 
 
55036db
b80a86d
dcc3a31
 
 
 
 
b80a86d
 
 
dcc3a31
 
b80a86d
 
dcc3a31
 
b80a86d
 
dcc3a31
 
 
 
b80a86d
 
8978a23
 
 
 
fcfc3d2
b80a86d
 
 
 
 
 
 
 
 
 
dcc3a31
 
 
b80a86d
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
dcc3a31
 
b80a86d
 
dcc3a31
 
b80a86d
dcc3a31
b80a86d
 
 
 
 
 
 
 
 
dcc3a31
b80a86d
 
 
 
 
dcc3a31
 
b80a86d
 
 
 
a64b4b7
 
5fd0620
 
 
 
 
 
 
a64b4b7
5fd0620
a64b4b7
 
 
5fd0620
a64b4b7
 
 
 
 
 
 
 
 
 
 
 
 
5fd0620
a64b4b7
 
5fd0620
dcc3a31
5fd0620
 
b80a86d
dcc3a31
5fd0620
 
 
dcc3a31
 
a64b4b7
 
 
 
 
 
 
 
 
 
 
 
 
 
 
dcc3a31
5fd0620
55036db
 
fcfc3d2
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
dcc3a31
 
 
b80a86d
 
 
 
 
 
 
 
 
 
a64b4b7
dcc3a31
 
b80a86d
 
 
 
 
a64b4b7
 
b80a86d
a64b4b7
 
 
 
 
 
dcc3a31
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
#!/usr/bin/env bash
# End-to-end pipeline on one GPU:
#   environment -> target + baseline -> engine checks -> prompts -> generation (engine)
#   -> hidden states -> training -> official kit evaluation -> summary
# Each stage is resumable (state/<stage>.done) and logs to logs/<stage>.log. Logs and results
# are pushed to the Hugging Face dataset repo after every stage (scripts/sync.py).
# Normally started by scripts/supervise.py; can also be run directly.
set -uo pipefail

export EMC_ROOT="${EMC_ROOT:-$HOME/emc}"
REPO="${EMC_REPO:-$EMC_ROOT/repo}"
KIT="$EMC_ROOT/kit"; MODELS="$EMC_ROOT/models"; WORK="$EMC_ROOT/work"; DATA="$EMC_ROOT/data"
TARGET="$MODELS/target"; BASELINE="$MODELS/baseline-mtp"; PROBE="$MODELS/probe-fp8"
RUNS="$EMC_ROOT/runs"; STATE="$EMC_ROOT/state"; LOGS="$EMC_ROOT/logs"; RESULTS="$EMC_ROOT/results"
VENV="$EMC_ROOT/venv"; PY="$VENV/bin/python"; UV="${UV:-uv}"
KIT_SHA=de57e284ae1b3d72ed7e06f00e030b2ba797adf1
mkdir -p "$MODELS" "$WORK" "$DATA" "$RUNS" "$STATE" "$LOGS" "$RESULTS" "$EMC_ROOT/tmp"
export PATH="$VENV/bin:$PATH" PYTHONPATH="$REPO" PYTHONUNBUFFERED=1 PYTHONDONTWRITEBYTECODE=1
export TOKENIZERS_PARALLELISM=false HF_HUB_DISABLE_TELEMETRY=1 HF_HUB_DISABLE_PROGRESS_BARS=1
export HF_HOME="$EMC_ROOT/hf" HF_XET_CHUNK_CACHE_SIZE_BYTES=0 TMPDIR="$EMC_ROOT/tmp"
export UV_CACHE_DIR="$EMC_ROOT/uv-cache" UV_PYTHON_INSTALL_DIR="$EMC_ROOT/uv-python" UV_LINK_MODE=copy
export EMC2_HOME="$KIT" EMC_RESULTS="$RESULTS"
export XDG_CACHE_HOME="$WORK/cache" VLLM_CACHE_ROOT="$WORK/cache/vllm" VLLM_NO_USAGE_STATS=1 DO_NOT_TRACK=1
export TORCHINDUCTOR_CACHE_DIR="$WORK/cache/inductor" TRITON_CACHE_DIR="$WORK/cache/triton"
# greedy decoding only: use the built-in sampler instead of compiling FlashInfer kernels at start-up
export VLLM_USE_FLASHINFER_SAMPLER=0
[ -f "$STATE/run_id" ] || echo "${RUN_ID:-$(date +%Y%m%d-%H%M)}" > "$STATE/run_id"
if [ -n "${RUN_ID_FORCE:-}" ]; then echo "$RUN_ID_FORCE" > "$STATE/run_id"; fi   # e.g. a new run on a fresh machine
# training run name (runs/<name>), its starting weights and whether to also evaluate the bf16 variant
RUN_NAME="${RUN_NAME:-main}"; TRAIN_INIT="${TRAIN_INIT:-$BASELINE}"; EVAL_ALT="${EVAL_ALT:-1}"
case "$TRAIN_INIT" in /*) ;; *) TRAIN_INIT="$EMC_ROOT/$TRAIN_INIT" ;; esac
OUTRUN="$RUNS/$RUN_NAME"
# the previous best draft (kept unless the new one scores higher on this machine)
PREV_TAG="${PREV_TAG:-}"; PREV_SUB="${PREV_SUB:-}"
case "$PREV_SUB" in ""|/*) ;; *) PREV_SUB="$EMC_ROOT/$PREV_SUB" ;; esac
if [ "$RUN_NAME" = main ]; then EVAL_PREFIX=eval_draft; else EVAL_PREFIX="eval_$RUN_NAME"; fi

log() { echo "[$(date '+%Y-%m-%d %H:%M:%S')] $*" | tee -a "$LOGS/pipeline.log"; }
sync_hf() { if [ -x "$PY" ]; then "$PY" "$REPO/scripts/sync.py" "$@" >> "$LOGS/sync.log" 2>&1 || true; fi; }
is_done() { [ -f "$STATE/$1.done" ]; }
stats() { if [ -x "$PY" ]; then "$PY" "$REPO/scripts/sysstats.py" "$EMC_ROOT" >> "$LOGS/stats.log" 2>/dev/null || true; fi; }

stage() {  # stage <name> <required: 0|1> <function>
  local name=$1 required=$2 fn=$3 t0=$SECONDS rc
  if is_done "$name"; then log "skip  $name (done)"; return 0; fi
  log "start $name"
  stats
  ( set -e; "$fn" ) > "$LOGS/$name.log" 2>&1
  rc=$?
  if [ "$rc" = 0 ]; then
    echo $((SECONDS - t0)) > "$STATE/$name.done"; rm -f "$STATE/$name.failed"
    log "done  $name ($((SECONDS - t0))s)"
  else
    echo "exit $rc after $((SECONDS - t0))s" > "$STATE/$name.failed"
    log "FAIL  $name (exit $rc after $((SECONDS - t0))s); end of logs/$name.log:"
    tail -n 25 "$LOGS/$name.log" | sed 's/^/      /' | tee -a "$LOGS/pipeline.log"
  fi
  sync_hf
  if [ "$rc" != 0 ] && [ "$required" = 1 ]; then log "stopping: $name is required"; exit 1; fi
  return "$rc"
}

kit() {  # the official kit commands (scripts/kit.py only maps its container paths)
  env EMC_TARGET="$TARGET" EMC_SUB="${SUB:-$BASELINE}" EMC2_WORK="$WORK" EMC_TAG="${TAG:-}" \
    "$PY" "$REPO/scripts/kit.py" "$@"
}

s_env() {
  nvidia-smi || true
  df -h "$EMC_ROOT" || true; free -g || true; nproc || true
  # a Python install or environment left half-present by a machine reset is rebuilt
  for d in "$UV_PYTHON_INSTALL_DIR"/cpython-3.12*; do
    if [ -d "$d" ] && [ ! -x "$d/bin/python3.12" ]; then echo "removing incomplete $d"; rm -rf "$UV_PYTHON_INSTALL_DIR"; break; fi
  done
  if ! "$PY" -c "import sys" >/dev/null 2>&1; then rm -rf "$VENV" "$UV_CACHE_DIR"; "$UV" venv --python 3.12 "$VENV"; fi
  "$UV" pip install --python "$PY" "vllm==0.31.0" accelerate datasets
  "$UV" cache clean >/dev/null 2>&1 || true
  "$PY" - <<'EOF'
import torch, transformers, vllm
print("vllm", vllm.__version__, "| torch", torch.__version__, "cuda", torch.version.cuda,
      "| transformers", transformers.__version__)
print(torch.cuda.get_device_name(0), round(torch.cuda.mem_get_info(0)[1] / 2**30, 1), "GiB")
x = torch.randn(512, 512, device="cuda", dtype=torch.bfloat16)
print("bf16 matmul ok:", bool(torch.isfinite((x @ x).float()).all()))
EOF
}

s_download() {
  if [ ! -f "$KIT/contract.json" ]; then
    "$PY" - "https://codeload.github.com/emc2-competition/emc2-kit/tar.gz/$KIT_SHA" "$KIT" <<'EOF'
import io, sys, tarfile, urllib.request
from pathlib import Path
data = urllib.request.urlopen(sys.argv[1], timeout=300).read()
dst = Path(sys.argv[2]); dst.mkdir(parents=True, exist_ok=True)
with tarfile.open(fileobj=io.BytesIO(data)) as tf:
    ms = []
    for m in tf.getmembers():
        if "/" in m.name and m.name.split("/", 1)[1]:
            m.name = m.name.split("/", 1)[1]; ms.append(m)
    try:
        tf.extractall(dst, members=ms, filter="data")
    except TypeError:
        tf.extractall(dst, members=ms)
print("kit ready:", sorted(p.name for p in dst.iterdir()))
EOF
  fi
  local rev; rev=$("$PY" -c "import json; print(json.load(open('$KIT/target.json'))['revision'])")
  "$VENV/bin/hf" download Qwen/Qwen3.8-27B --revision "$rev" --local-dir "$TARGET" \
    || "$PY" -c "from huggingface_hub import snapshot_download as s; s('Qwen/Qwen3.8-27B', revision='$rev', local_dir='$TARGET')"
  du -sh "$TARGET"; df -h "$EMC_ROOT"
}

s_baseline() { kit prepare-baseline --models-dir "$MODELS"; SUB="$BASELINE" kit validate; }
s_checkenv() { kit check-env; }
s_probe() {
  "$PY" -m emcdraft.probe --target "$TARGET" --baseline "$BASELINE" --out "$PROBE"
  SUB="$PROBE" kit validate
}
s_smoke_fp8() {   # does the stock engine load an FP8-typed head, and what does rounding alone cost?
  SUB="$PROBE" TAG=smoke_fp8 kit eval --limit-per-domain 2
  "$PY" - "$RESULTS/smoke_fp8.json" "$KIT/data/dev/baseline.json" "$STATE/fp8_ok" <<'EOF'
import json, sys
f, b = json.load(open(sys.argv[1])), json.load(open(sys.argv[2]))
ratio = (f["acceptance_length"] - 1) / (b["acceptance_length"] - 1)
print(f"FP8 probe acceptance {f['acceptance_length']:.3f} vs published baseline {b['acceptance_length']:.3f} (ratio {ratio:.3f})")
if ratio >= 0.85:
    open(sys.argv[3], "w").write(f"{ratio:.4f}\n")
else:
    print("acceptance collapsed: FP8 storage will not be used")
EOF
}
s_smoke_base() { SUB="$BASELINE" TAG=smoke_baseline kit eval --limit-per-domain 2; }
s_prompts()  { "$PY" -m emcdraft.prompts --target "$TARGET" --kit "$KIT" --out "$DATA/prompts" --results "$RESULTS"; }
s_generate() { "$PY" -m emcdraft.gen_vllm --target "$TARGET" --prompts "$DATA/prompts" --out "$DATA/gen" --results "$RESULTS"; }
s_extract()  { "$PY" -m emcdraft.extract --target "$TARGET" --kit "$KIT" --baseline "$BASELINE" --gen "$DATA/gen" --out "$DATA" --results "$RESULTS"; }
fetch_hf() {   # fetch_hf <dataset-repo>:<folder> <destination>: a draft folder from the dataset repo
  "$PY" - "$1" "$2" <<'PYEOF'
import shutil, sys
from pathlib import Path
from huggingface_hub import snapshot_download
repo, sub = sys.argv[1].split(":", 1)
src = Path(snapshot_download(repo, repo_type="dataset", allow_patterns=[sub + "/*"])) / sub
Path(sys.argv[2]).parent.mkdir(parents=True, exist_ok=True)
shutil.copytree(src, sys.argv[2])
print("downloaded", sys.argv[1])
PYEOF
}
init_weights() {   # starting weights for training (downloaded on a fresh machine)
  if [ ! -d "$TRAIN_INIT" ] && [ -n "${TRAIN_INIT_HF:-}" ]; then fetch_hf "$TRAIN_INIT_HF" "$TRAIN_INIT"; fi
  [ -d "$TRAIN_INIT" ] || { echo "starting weights $TRAIN_INIT not found"; return 1; }
}
s_ablate() {   # short runs comparing training recipes; the best one is used by s_train
  if [ "${ABLATE:-0}" != 1 ]; then echo "no recipe comparison requested (ABLATE=${ABLATE:-0})"; return 0; fi
  local qat=""; [ -f "$STATE/fp8_ok" ] && qat="--qat"
  init_weights
  "$PY" -m emcdraft.ablate --target "$TARGET" --init "$TRAIN_INIT" --data "$DATA/train" --dev "$DATA/dev" \
    --out "$RUNS/ablate" --results "$RESULTS" --state "$STATE" --steps "${ABLATE_STEPS:-300}" $qat
}
s_train() {
  local qat=""; [ -f "$STATE/fp8_ok" ] && qat="--qat"
  local extra=""; [ -f "$STATE/train_args" ] && extra=$(cat "$STATE/train_args")
  echo "training recipe: ${extra:-defaults}"
  init_weights
  rm -rf "$OUTRUN"
  "$PY" -m emcdraft.train --target "$TARGET" --init "$TRAIN_INIT" --data "$DATA/train" --dev "$DATA/dev" --out "$OUTRUN" $qat $extra
  cat "$STATE/run_id" > "$OUTRUN/run_id"      # which run the exported folders belong to (for uploads)
  for s in "$OUTRUN"/sub_*; do SUB="$s" kit validate; done
}
primary() { if [ -d "$OUTRUN/sub_fp8" ]; then echo "$OUTRUN/sub_fp8"; else echo "$OUTRUN/sub_bf16"; fi; }
s_eval_main() { local p; p=$(primary); SUB="$p" TAG="${EVAL_PREFIX}_$(basename "$p" | sed 's/^sub_//')" kit eval; }
s_eval_baseline() { SUB="$BASELINE" TAG=eval_baseline kit eval; }
s_eval_alt() {
  if [ "$EVAL_ALT" != 1 ]; then echo "bf16 variant not evaluated (EVAL_ALT=$EVAL_ALT)"; return 0; fi
  if [ ! -d "$OUTRUN/sub_fp8" ]; then echo "only one variant"; return 0; fi
  SUB="$OUTRUN/sub_bf16" TAG="${EVAL_PREFIX}_bf16" kit eval
}
s_report() { "$PY" "$REPO/scripts/collect.py"; }
new_tag() { echo "${EVAL_PREFIX}_$(basename "$(primary)" | sed 's/^sub_//')"; }
s_eval_prev() {   # the previous best draft on this machine, when its result is not here yet
  if [ -z "$PREV_TAG" ]; then echo "no previous draft to compare with"; return 0; fi
  if [ -f "$RESULTS/$PREV_TAG.json" ]; then echo "previous draft already evaluated on this machine"; return 0; fi
  if [ ! -d "$PREV_SUB" ] && [ -n "${PREV_SUB_HF:-}" ]; then fetch_hf "$PREV_SUB_HF" "$PREV_SUB"; fi
  SUB="$PREV_SUB" TAG="$PREV_TAG" kit eval
}
s_choose() {
  "$PY" "$REPO/scripts/choose.py" --new "$(new_tag)" --new-sub "$(primary)" --prev "$PREV_TAG"     --prev-sub "$PREV_SUB" --results "$RESULTS" --state "$STATE"
}
bench() { env EMC_TARGET="$TARGET" EMC_SUB="${SUB:-}" EMC2_WORK="$WORK" "$PY" "$REPO/scripts/bench.py" "$@"; }
final_sub() { if [ -f "$STATE/final_sub" ]; then cat "$STATE/final_sub"; else primary; fi; }
s_bench_draft() { SUB="$(final_sub)" bench --tag draft --what batch,long,k; }
s_bench_baseline() { SUB="$BASELINE" bench --tag baseline --what batch,long; }
s_bench_target() { SUB="" bench --tag target_only --target-only --what batch,long; }

log "pipeline start: run $(cat "$STATE/run_id"), code $(cat "$REPO/.commit" 2>/dev/null | cut -c1-12), training run $RUN_NAME"
# a vLLM server left behind by an interrupted run would still hold the GPU
if pkill -f -- "--served-model-name target" 2>/dev/null; then log "stopped a leftover vLLM server"; sleep 20; fi
# a machine change can keep the "done" markers but lose what the stages produced: check each
# finished stage's output and run the stage again when it is gone
check_done() {   # check_done <stage> <command ...>
  local name=$1; shift
  if is_done "$name" && ! "$@" >/dev/null 2>&1; then rm -f "$STATE/$name.done"; log "redo  $name (its output is missing)"; fi
}
has_files() { compgen -G "$1" >/dev/null; }
shards_ok() {   # every shard listed by its metadata file is present and non-empty
  local d=$1 j
  has_files "$d/*.json" || return 1
  for j in "$d"/*.json; do [ -s "${j%.json}.tok.npy" ] && [ -s "${j%.json}.hid.npy" ] || return 1; done
}
check_done env "$PY" -c "import vllm, torch, transformers"
check_done download "$PY" -c "import json, os, sys; d = '$TARGET'; f = set(json.load(open(d + '/model.safetensors.index.json'))['weight_map'].values()); sys.exit(0 if os.path.isfile('$KIT/contract.json') and all(os.path.getsize(os.path.join(d, x)) > 0 for x in f) else 1)"
check_done baseline test -s "$BASELINE/model.safetensors"
check_done probe test -s "$PROBE/model.safetensors"
check_done prompts has_files "$DATA/prompts/*.jsonl"
check_done smoke_fp8 test -s "$RESULTS/smoke_fp8.json"
check_done generate has_files "$DATA/gen/*.jsonl"
check_done extract shards_ok "$DATA/train"
check_done extract shards_ok "$DATA/dev"
check_done train test -s "$OUTRUN/sub_bf16/model.safetensors"
check_done eval_main test -s "$RESULTS/$(new_tag).json"
check_done eval_baseline test -s "$RESULTS/eval_baseline.json"
stage env 1 s_env
stage download 1 s_download
stage baseline 1 s_baseline
prompts_pid=""
if ! is_done prompts; then (stage prompts 1 s_prompts) & prompts_pid=$!; fi
stage checkenv 0 s_checkenv || true
stage probe 0 s_probe || true
if is_done probe; then stage smoke_fp8 0 s_smoke_fp8 || true; fi
if ! is_done smoke_fp8; then stage smoke_base 1 s_smoke_base; fi   # engine itself must work
if [ -n "$prompts_pid" ]; then wait "$prompts_pid"; fi
is_done prompts || { log "stopping: prompts failed"; exit 1; }
stage generate 1 s_generate
stage extract 1 s_extract
stage ablate 0 s_ablate || true
stage train 1 s_train
sync_hf --submissions
stage eval_main 0 s_eval_main || true
stage report_main 0 s_report || true
stage eval_baseline 0 s_eval_baseline || true
stage report_baseline 0 s_report || true
stage eval_alt 0 s_eval_alt || true
stage eval_prev 0 s_eval_prev || true
stage choose 0 s_choose || true
stage report 0 s_report || true
if [ "${BENCH:-0}" = 1 ]; then
  stage bench_draft 0 s_bench_draft || true
  stage bench_baseline 0 s_bench_baseline || true
  stage bench_target 0 s_bench_target || true
  stage report_bench 0 s_report || true
fi
sync_hf --submissions
log "pipeline finished"