File size: 14,687 Bytes
5f0e48f
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
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
#!/usr/bin/env bash
# Full experiment queue: two lanes, each runs its jobs in order and waits for the other lane's results. Run from code/:
#   AFTER=<run> GPU=<id> nohup bash queue.sh <1|2> [stage] > ../logs/q<lane>.log 2>&1 < /dev/null &   (GPU defaults to lane - 1)
# ../runs/<name>/DONE marks a finished run (skipped on restart); FAILED propagates to dependents.
# ../runs/<A|B>_data/DONE = target-domain data complete (written below when the dataset yaml exists; B also by fetch_insplad.sh).
# Kinds: T teacher(l) | S0 student(n) | S1 +logit KD | S2 +projection alignment | S3 LoRA K=4 + router (multi-domain)
#        S3k1 LoRA K=1 | FT full fine-tune of S2 (multi-domain) | J student trained jointly on both domains | E eval table
#        P prune S2 (30% channels) + KD recovery = S2p | S3p LoRA K=4 on S2p | Ep eval table of the pruned branch
#        P2 S3p2 Ep2 same, recovery as long as S2's own training (P's half-length recovery was still improving)
#        Lt LoRA (K=1) on target data only, no teacher (source-free: how much does the source domain forget?) | Elt its eval table
#        T2 | Tx source | target-domain teacher (l) at 2x epochs (T at 1x was still improving) | S1t S2t = S1 S2 taught by T2
#        S3x S3 distilled from per-domain experts (source: A T2 / B T, target: Tx) | S3nt S3 without any teacher | Ex Exb Ent eval tables
#        Lts S3nts <seed>: Lt / S3nt again with another seed (S2 kept) | Es <seed>: their eval table + density-card routing on that Lt
#        Lab <seed>: routing lab (route_lab.py: every routing rule and card setting) on S2 + that seed's Lt
#        Ltp S3ntp: Lt / S3nt on the pruned S2p2 | Labp their routing lab | Epsf their eval table
#        B only, three sites cn -> cnfog (same scenes, synthetic fog) -> br: Ltf LoRA on cnfog | S3nt3 joint on all three | Lab3 | E3
#        Dpl deployable card routing (deploy_route.py) on the pruned pair S2p2 + Ltp | Dfu Dfup the same with fused cards
#        (deploy_route.py --mode fused: early style + layer-10 features along the base model, threshold 0) on S2 + Lt | S2p2 + Ltp
#        Ltr <r>: Lt at LoRA rank r | Ltd <pct>: Lt on pct% of the target training images | Eabl Efr their eval tables
lane=$1 g=${GPU:-$(($1 - 1))} PY=${PY:-python}
export OMP_NUM_THREADS=8 MKL_NUM_THREADS=8 CUDA_DEVICE_ORDER=PCI_BUS_ID
mkdir -p ../logs ../runs
[ -f ../datasets/A_weather/multi.yaml ] && mkdir -p ../runs/A_data && touch ../runs/A_data/DONE
[ -f ../datasets/B_region/multi.yaml ] && mkdir -p ../runs/B_data && touch ../runs/B_data/DONE
wait_for() { for d in ${1//,/ }; do until [ -f ../runs/$d/DONE ] || [ -f ../runs/$d ]; do [ -f ../runs/$d/FAILED ] && return 1; sleep 60; done; done; }  # run name or a file in ../runs
run() {  # run <name> <deps|-> <gridkd train args...>
  local n=$1 dep=$2; shift 2; [ -f ../runs/$n/DONE ] && return; mkdir -p ../runs/$n; rm -f ../runs/$n/FAILED
  if [ "$dep" != - ] && ! wait_for $dep; then touch ../runs/$n/FAILED; return; fi
  $PY gridkd.py train "$@" device=$g project=../runs name=$n > ../logs/$n.log 2>&1 < /dev/null && touch ../runs/$n/DONE || touch ../runs/$n/FAILED
}
A=../datasets/A_weather B=../datasets/B_region
A_src="--data $A/clear.yaml" A_tgt="--data $A/fog.yaml" A_multi="--data $A/multi.yaml --domains /clear/,/fog/" A_ep=100 A_ad=50 A_doms="clear fog" A_ts=T2
B_src="--data $B/cn.yaml"    B_tgt="--data $B/br.yaml"  B_multi="--data $B/multi.yaml --domains /cn/,/br/"   B_ep=60  B_ad=30 B_doms="cn br"     B_ts=T
yn=../weights/pretrained/yolo11n.pt yl=../weights/pretrained/yolo11l.pt hp="imgsz=640 batch=16"
ad="optimizer=AdamW warmup_epochs=1 warmup_bias_lr=0.0 $hp"
evaluate() {  # evaluate <csv name> <LoRA run, merged per domain> <runs...>: every model on every domain's test split
  local out=$1 s3=$2 P="$PY gridkd.py" w="" r d; shift 2
  [ -f ../runs/$out.csv ] && return
  wait_for $(IFS=,; echo "$*") || return
  for r in "$@"; do w="$w ../runs/$r/weights/best.pt"; done
  for d in $doms; do $P merge --weights ../runs/$s3/weights/best.pt --gates $D/$d.yaml --out ../runs/${s3}_$d.pt --device $g; w="$w ../runs/${s3}_$d.pt"; done
  $P eval --weights $w --data $(for d in $doms; do echo $D/$d.yaml; done) --device $g --out ../runs/$out.csv
} > ../logs/$1.log 2>&1 < /dev/null
evalonly() {  # evalonly <csv name> <runs...>: every run on every domain's test split, nothing merged
  local out=$1 w="" r; shift
  [ -f ../runs/$out.csv ] && return
  wait_for $(IFS=,; echo "$*") || return
  for r in "$@"; do w="$w ../runs/$r/weights/best.pt"; done
  $PY gridkd.py eval --weights $w --data $(for d in $doms; do echo $D/$d.yaml; done) --device $g --out ../runs/$out.csv
} > ../logs/$1.log 2>&1 < /dev/null
seedeval() {  # seedeval <A|B> <seed>: Lt and S3nt of that seed on both domains, then density-card routing on its Lt
  local b=$1 s=$2 P="$PY" D doms; eval "D=\$$b doms=\$${b}_doms"; set -- $doms
  [ -f ../runs/${b}_eval_cards_s$s.csv ] && return
  wait_for ${b}_Lt_s$s,${b}_S3nt_s$s || return
  $P gridkd.py eval --weights ../runs/${b}_Lt_s$s/weights/best.pt ../runs/${b}_S3nt_s$s/weights/best.pt --data $D/$1.yaml $D/$2.yaml --device $g --out ../runs/${b}_eval_seed$s.csv &&
  CUDA_VISIBLE_DEVICES="" $P gridkd.py bnsw --weights ../runs/${b}_Lt_s$s/weights/best.pt --base ../runs/${b}_S2/weights/best.pt --mode cum --out ../runs/${b}_Lt_s${s}_bncum.pt &&
  $P route_cards.py --weights ../runs/${b}_Lt_s${s}_bncum.pt --src $D/$1.yaml --tgt $D/$2.yaml --k 8 --device $g --out ../runs/${b}_eval_cards_s$s.csv
} > ../logs/${1}_seedeval$2.log 2>&1 < /dev/null
lab() {  # lab <out> <deps> <models...> -- <data.yaml per site>: routing lab
  local out=$1 dep=$2 m=(); shift 2
  while [ "$1" != -- ]; do m+=("$1"); shift; done; shift
  [ -f ../runs/$out.csv ] && return
  wait_for $dep || return
  $PY route_lab.py --models "${m[@]}" --data "$@" --device $g --out ../runs/$out.csv
} > ../logs/$1.log 2>&1 < /dev/null
deploy() {  # deploy <A|B>: merge Ltp, then deploy_route.py on S2p2 + Ltp
  local b=$1 P="$PY"
  [ -f ../runs/${b}_eval_deploy_p.csv ] && return
  wait_for ${b}_Ltp || return
  $P gridkd.py merge --weights ../runs/${b}_Ltp/weights/best.pt --gates 1 --out ../runs/${b}_Ltp_merged.pt &&
  $P deploy_route.py --base ../runs/${b}_S2p2/weights/best.pt --site ../runs/${b}_Ltp_merged.pt --lora ../runs/${b}_Ltp/weights/best.pt \
    --src $D/${doms% *}.yaml --tgt $D/${doms#* }.yaml --device $g --out ../runs/${b}_eval_deploy_p.csv
} > ../logs/$1_deploy_p.log 2>&1 < /dev/null
dfused() {  # dfused <LoRA run> <base weights> <csv>: fused-card deployment
  local lt=$1 base=$2 out=$3 P="$PY"
  [ -f ../runs/$out.csv ] && return
  wait_for $lt || return
  [ -f ../runs/${lt}_merged.pt ] || $P gridkd.py merge --weights ../runs/$lt/weights/best.pt --gates 1 --out ../runs/${lt}_merged.pt
  $P deploy_route.py --mode fused --q 0 --base $base --site ../runs/${lt}_merged.pt --lora ../runs/$lt/weights/best.pt \
    --src $D/${doms% *}.yaml --tgt $D/${doms#* }.yaml --device $g --out ../runs/$out.csv
} > ../logs/$3.log 2>&1 < /dev/null
dv2() {  # dv2 <A|B> <base run> <LoRA run> <tag>: both deployment modes again, one-sync router and median latency
  local b=$1 base=$2 lt=$3 t=$4 P="$PY" m
  [ -f ../runs/${b}_eval_deploy_fused_$t.csv ] && return
  wait_for $lt || return
  for m in early fused; do
    $P deploy_route.py --mode $m --q $([ $m = fused ] && echo 0 || echo 0.05) --base ../runs/$base/weights/best.pt --site ../runs/${lt}_merged.pt \
      --lora ../runs/$lt/weights/best.pt --src $D/${doms% *}.yaml --tgt $D/${doms#* }.yaml --device $g \
      --out ../runs/${b}_eval_deploy_$([ $m = fused ] && echo fused_)$t.csv || return
  done
} > ../logs/$1_deploy_$4.log 2>&1 < /dev/null
prune() {  # S2 -> 30% channels removed (DepGraph), recovered below as S2p
  [ -f $2 ] || { wait_for ${1}_S2 && $PY gridkd.py prune --weights ../runs/${1}_S2/weights/best.pt --ratio 0.3 --out $2 > ../logs/${1}_prune.log 2>&1; }
}
job() {  # job <A|B> <kind>
  b=$1; eval "src=\$${b}_src tgt=\$${b}_tgt multi=\$${b}_multi ep=\$${b}_ep adep=\$${b}_ad doms=\$${b}_doms D=\$$b ts=\$${b}_ts"
  t="--teacher ../runs/${b}_T/weights/best.pt" t2="--teacher ../runs/${b}_T2/weights/best.pt" s2=../runs/${b}_S2/weights/best.pt
  case $2 in
    T)    run ${b}_T    -       $src --model $yl epochs=$ep $hp ;;
    S0)   run ${b}_S0   -       $src --model $yn epochs=$ep $hp ;;
    S1)   run ${b}_S1   ${b}_T  $src --model $yn $t --w-pa 0 epochs=$ep $hp ;;
    S2)   run ${b}_S2   ${b}_T  $src --model $yn $t epochs=$ep $hp ;;
    S3)   run ${b}_S3   ${b}_S2,${b}_data $multi --model $s2 $t --lora-r 4 --lora-k 4 epochs=$adep lr0=1e-3 $ad ;;
    S3k1) run ${b}_S3k1 ${b}_S2,${b}_data $multi --model $s2 $t --lora-r 4 --lora-k 1 epochs=$adep lr0=1e-3 $ad ;;
    FT)   run ${b}_FT   ${b}_S2,${b}_data $multi --model $s2 $t epochs=$adep lr0=1e-4 $ad ;;
    J)    run ${b}_J    ${b}_data $multi --model $yn epochs=$ep $hp ;;
    E)    evaluate ${b}_eval ${b}_S3 ${b}_T ${b}_S0 ${b}_S1 ${b}_S2 ${b}_S3 ${b}_S3k1 ${b}_FT ${b}_J ;;
    P)    prune $b ../runs/${b}_S2_p30.pt && run ${b}_S2p ${b}_S2 $src --model ../runs/${b}_S2_p30.pt $t epochs=$adep $hp ;;
    S3p)  run ${b}_S3p  ${b}_S2p,${b}_data $multi --model ../runs/${b}_S2p/weights/best.pt $t --lora-r 4 --lora-k 4 epochs=$adep lr0=1e-3 $ad ;;
    Ep)   evaluate ${b}_eval_prune ${b}_S3p ${b}_S2p ${b}_S3p ;;
    P2)   run ${b}_S2p2 ${b}_S2 $src --model ../runs/${b}_S2_p30.pt $t epochs=$ep $hp ;;
    S3p2) run ${b}_S3p2 ${b}_S2p2,${b}_data $multi --model ../runs/${b}_S2p2/weights/best.pt $t --lora-r 4 --lora-k 4 epochs=$adep lr0=1e-3 $ad ;;
    Ep2)  evaluate ${b}_eval_prune2 ${b}_S3p2 ${b}_S2p2 ${b}_S3p2 ;;
    Lt)   run ${b}_Lt   ${b}_S2,${b}_data $tgt --model $s2 --lora-r 4 --lora-k 1 epochs=$adep lr0=1e-3 $ad ;;
    Elt)  evaluate ${b}_eval_lt ${b}_Lt ${b}_Lt ;;
    T2)   run ${b}_T2   -       $src --model $yl epochs=$((ep*2)) $hp ;;
    S1t)  run ${b}_S1t  ${b}_T2 $src --model $yn $t2 --w-pa 0 epochs=$ep $hp ;;
    S2t)  run ${b}_S2t  ${b}_T2 $src --model $yn $t2 epochs=$ep $hp ;;
    Tx)   run ${b}_Tx   -       $tgt --model $yl epochs=$((ep*2)) $hp ;;
    S3x)  run ${b}_S3x  ${b}_S2,${b}_$ts,${b}_Tx,${b}_data $multi --model $s2 --teacher ../runs/${b}_$ts/weights/best.pt,../runs/${b}_Tx/weights/best.pt --lora-r 4 --lora-k 4 epochs=$adep lr0=1e-3 $ad ;;
    S3nt) run ${b}_S3nt ${b}_S2,${b}_data $multi --model $s2 --lora-r 4 --lora-k 4 epochs=$adep lr0=1e-3 $ad ;;
    Ex)   evaluate ${b}_eval_experts ${b}_S3x ${b}_T2 ${b}_Tx ${b}_S1t ${b}_S2t ${b}_S3x ${b}_S3nt ;;
    Exb)  evaluate ${b}_eval_experts ${b}_S3x ${b}_Tx ${b}_S3x ;;  # B has no T2 runs
    Ent)  evaluate ${b}_eval_nt ${b}_S3nt ${b}_S3nt ;;
    Lts)  run ${b}_Lt_s$3   ${b}_S2,${b}_data $tgt --model $s2 --lora-r 4 --lora-k 1 epochs=$adep lr0=1e-3 $ad seed=$3 ;;
    S3nts) run ${b}_S3nt_s$3 ${b}_S2,${b}_data $multi --model $s2 --lora-r 4 --lora-k 4 epochs=$adep lr0=1e-3 $ad seed=$3 ;;
    Es)   seedeval $b $3 ;;
    Relab) f=../runs/${b}_lab_s$3.csv; grep -q "^fused," $f 2>/dev/null || { [ -f $f ] && mv $f ${f%.csv}_v1.csv; job $b Lab $3; } ;;  # rerun labs from before the deep / fused rules
    Lab)  r=${b}_Lt$([ "$3" = 0 ] || echo _s$3); lab ${b}_lab_s$3 $r $s2 ../runs/$r/weights/best.pt -- $D/${doms% *}.yaml $D/${doms#* }.yaml ;;
    Ltp)  run ${b}_Ltp   ${b}_S2p2,${b}_data $tgt --model ../runs/${b}_S2p2/weights/best.pt --lora-r 4 --lora-k 1 epochs=$adep lr0=1e-3 $ad ;;
    S3ntp) run ${b}_S3ntp ${b}_S2p2,${b}_data $multi --model ../runs/${b}_S2p2/weights/best.pt --lora-r 4 --lora-k 4 epochs=$adep lr0=1e-3 $ad ;;
    Labp) lab ${b}_lab_p ${b}_Ltp ../runs/${b}_S2p2/weights/best.pt ../runs/${b}_Ltp/weights/best.pt -- $D/${doms% *}.yaml $D/${doms#* }.yaml ;;
    Epsf) evaluate ${b}_eval_psf ${b}_S3ntp ${b}_Ltp ${b}_S3ntp ;;
    Dpl)  deploy $b ;;
    Dfu)  dfused ${b}_Lt $s2 ${b}_eval_deploy_fused ;;
    Dv2)  dv2 $b ${b}_S2 ${b}_Lt v2 ;;
    Dv2p) dv2 $b ${b}_S2p2 ${b}_Ltp v2p ;;
    Dfup) dfused ${b}_Ltp ../runs/${b}_S2p2/weights/best.pt ${b}_eval_deploy_fusedp ;;
    Ltf)  run B_Ltf B_S2,B_data --data $B/cnfog.yaml --model ../runs/B_S2/weights/best.pt --lora-r 4 --lora-k 1 epochs=$B_ad lr0=1e-3 $ad ;;
    S3nt3) run B_S3nt3 B_S2,B_data --data $B/multi3.yaml --domains /cn/,/cnfog/,/br/ --model ../runs/B_S2/weights/best.pt --lora-r 4 --lora-k 4 epochs=$B_ad lr0=1e-3 $ad ;;
    Lab3) lab B_lab3 B_Ltf,B_Lt ../runs/B_S2/weights/best.pt ../runs/B_Ltf/weights/best.pt ../runs/B_Lt/weights/best.pt -- $B/cn.yaml $B/cnfog.yaml $B/br.yaml ;;
    E3)   doms="cn cnfog br" evaluate B_eval3 B_S3nt3 B_Ltf B_S3nt3 ;;
    Ltr)  run ${b}_Lt_r$3 ${b}_S2,${b}_data $tgt --model $s2 --lora-r $3 --lora-k 1 epochs=$adep lr0=1e-3 $ad ;;
    Ltd)  run ${b}_Lt_d$3 ${b}_S2,${b}_data $tgt --model $s2 --lora-r 4 --lora-k 1 epochs=$adep lr0=1e-3 $ad fraction=0.$3 ;;
    Eabl) evalonly ${b}_eval_abl ${b}_Lt_r1 ${b}_Lt_r2 ${b}_Lt_r8 ${b}_Lt_r16 ;;
    Efr)  evalonly ${b}_eval_frac ${b}_Lt_d10 ${b}_Lt_d25 ${b}_Lt_d50 ;;
  esac
}
[ -n "$AFTER" ] && wait_for $AFTER
case $lane:${2:-main} in
  1:main)  for j in "A T" "A S1" "A S3" "A S3k1" "A J" "A E" "B S1" "B S3" "B S3k1"; do job $j; done ;;
  2:main)  for j in "A S0" "B S0" "A S2" "A FT" "B T" "B S2" "B FT" "B J" "B E"; do job $j; done ;;
  1:prune) for j in "A P" "A S3p" "A Ep"; do job $j; done ;;  # start with AFTER=B_S3k1
  2:prune) for j in "B P" "B S3p" "B Ep"; do job $j; done ;;  # start with AFTER=B_eval.csv
  1:experts) for j in "B S3nt" "B Ent" "A T2" "A S3x" "A S1t" "A S2t" "A Ex"; do job $j; done ;;  # AFTER=A_eval_prune.csv
  2:experts) for j in "A Tx" "A S3nt" "B Tx" "B S3x" "B Exb"; do job $j; done ;;  # AFTER=B_eval_prune.csv
  1:prune2) for j in "A P2" "A S3p2" "A Ep2" "B P2" "B S3p2" "B Ep2"; do job $j; done ;;  # AFTER=A_eval_experts.csv
  2:lsl0) for j in "B Lt" "B Elt" "A Lt" "A Elt"; do job $j; done ;;
  1:seeds) for j in "B Lts 1" "B S3nts 1" "B Es 1" "A Lts 2" "A S3nts 2" "A Es 2"; do job $j; done ;;
  2:seeds) for j in "A Lts 1" "A S3nts 1" "A Es 1" "B Lts 2" "B S3nts 2" "B Es 2"; do job $j; done ;;
  1:more) for j in "A Relab 0" "A Relab 1" "A Relab 2" "A Dfu" "A Ltp" "A S3ntp" "A Labp" "A Epsf" "A Dpl" "A Dfup" "B Ltf" "B Ltr 1" "B Ltr 2" "B Ltr 8" "B Ltr 16" "B Eabl"; do job $j; done ;;  # after lane 1 seeds
  2:more) for j in "B Relab 0" "B Relab 1" "B Relab 2" "B Dfu" "B S3nt3" "B Ltp" "B S3ntp" "B Labp" "B Epsf" "B Dpl" "B Dfup" "B Lab3" "B E3" \
                   "B Ltd 10" "B Ltd 25" "B Ltd 50" "B Efr" "A Ltd 10" "A Ltd 25" "A Ltd 50" "A Efr"; do job $j; done ;;  # after lane 2 seeds
  1:tail) for j in "A Dv2" "A Dv2p"; do job $j; done ;;  # after lane 1 more
  2:tail) for j in "B Dv2" "B Dv2p"; do job $j; done ;;  # after lane 2 more
esac
echo "lane $lane ${2:-main} done"