update

gainlora_OT_vMF/SETUP.md

@@ -1,143 +0,0 @@
-# GainLoRA + OT-SIGN Setup Guide
-
-## Quick Start
-
-### Option 1: Using conda + pip (Recommended for GPU)
-
-```bash
-# 1. Create conda environment with CUDA support
-conda create -n gainlora \
-  python=3.10 \
-  pytorch::pytorch \
-  pytorch::pytorch-cuda=12.1 \
-  pytorch::torchvision \
-  pytorch::torchaudio \
-  -c pytorch -c nvidia
-
-# 2. Activate environment
-conda activate gainlora
-
-# 3. Install pip dependencies
-cd gainlora
-pip install -r requirements.txt
-```
-
-### Option 2: Using only pip (CPU or if CUDA already setup)
-
-```bash
-# Install all pip dependencies
-pip install -r requirements.txt
-```
-
-### Option 3: From conda environment (existing setup)
-
-```bash
-# If you already have an environment, just update pip packages
-conda activate <your_env>
-pip install -r requirements.txt
-```
-
----
-
-## Key Dependencies
-
-| Package | Purpose | Version |
-|---------|---------|---------|
-| transformers | HuggingFace models (T5, LLaMA, etc.) | 4.30.2 |
-| torch/vision/audio | PyTorch + CUDA support | 2.1.0 |
-| datasets | Dataset loading & processing | 2.14.6 |
-| accelerate | Distributed training | 0.24.1 |
-| deepspeed | ZeRO optimization | 0.11.2 |
-| loralib | LoRA layers | 0.1.2 |
-| cupy-cuda12x | GPU-accelerated arrays (for SVD) | 12.1.0 |
-| safetensors | Fast model serialization | 0.4.4 |
-
----
-
-## Troubleshooting
-
-### CUDA Version Mismatch
-If you have a different CUDA version:
-```bash
-# Change 12.1 to your CUDA version (11.8, 11.6, etc.)
-conda create -n gainlora ... pytorch::pytorch-cuda=11.8 ...
-```
-
-### CuPy Installation Fails
-CuPy requires CUDA dev toolkit. If it fails:
-```bash
-# Option 1: Install it separately
-conda install -c conda-forge cupy cuda-version=12.1
-
-# Option 2: Comment it out in requirements.txt if not using SVD GPM
-```
-
-### Out of Memory on 2×T4
-Scripts are already optimized (batch_size=8, fp16). If still OOM:
-1. Reduce `per_device_train_batch_size` in bash scripts
-2. Increase `gradient_accumulation_steps`
-
-### Kaggle/Colab Environment (Pre-built Wheels)
-
-When running on Kaggle or Google Colab, use pre-built wheels to avoid compilation:
-
-```bash
-# Clone and install (Colab/Kaggle cell)
-! git clone https://github.com/liangyanshuo/gainlora.git
-! cd gainlora && pip install -r requirements.txt --no-build-isolation
-
-# Or with uv proxy (faster) - already recommended in Colab/Kaggle
-! pip install uv
-! uv pip install -r requirements.txt
-```
-
-**Note:** `tokenizers>=0.14.1` has pre-built wheels for Python 3.12. If you still get build errors:
-- Add GPU dependencies: `! pip install --upgrade setuptools wheel`
-- Or downgrade Python: Colab uses 3.10-3.12; ensure compatibility
-
----
-
-## Running OT-SIGN + GainLoRA
-
-```bash
-# Order 1 (SuperNI) - ~10 hours on 2×T4
-bash run_ot_sign_order1_t5large.sh 0,1 google/flan-t5-large
-
-# Order 2 (SuperNI) - ~10 hours
-bash run_ot_sign_order2_t5large.sh 0,1 google/flan-t5-large
-
-# Order 3 (Long) - ~4 hours  [run this first to test]
-bash run_ot_sign_order3_t5large.sh 0,1 google/flan-t5-large
-
-# Order 4 (Long) - ~4 hours
-bash run_ot_sign_order4_t5large.sh 0,1 google/flan-t5-large
-```
-
-Results and logs:
-- Training outputs: `logs_and_outputs/ot_sign_order{1,2,3,4}_t5large/`
-- AP/FT scores: Printed in terminal + `ap_ft_result.json`
-- Compare with baseline: See `results/comparison_results.md`
-
----
-
-## Environment Verification
-
-```bash
-# Check PyTorch + CUDA
-python -c "import torch; print(f'PyTorch {torch.__version__}, CUDA {torch.cuda.is_available()}')"
-
-# Check transformers
-python -c "import transformers; print(f'Transformers {transformers.__version__}')"
-
-# Check other deps
-python -c "import cupy; import accelerate; import deepspeed; print('All deps OK')"
-```
-
----
-
-## Notes
-
-- `requirements.yaml` = Full conda environment spec (includes system libs)
-- `requirements.txt` = Python pip packages only (easier to share and modify)
-- Both methods should give identical Python environment
-- CUDA/cuDNN installation separate (via conda in setup)

gainlora_OT_vMF/requirements.txt

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:22ba1705f034261bc2483bcabe3bbf5935a041e6972f2d17e487c54fb56b92c5
-size 1136

gainlora_OT_vMF/run_ot_sign_order1_t5large.sh

@@ -1,175 +0,0 @@
-#!/bin/bash
-###############################################################################
-# OT-SIGN + GainLoRA (T5-Large) — Order 1 (SuperNI)
-# ===================================================
-# Task order: samsum → sst2 → xsum → ... → emotion (15 tasks)
-# Benchmark:  SuperNI (RougeL metric)
-# Hardware:   2× T4 16GB  |  Estimated time: ~9-10h
-# Run:        bash run_ot_sign_order1_t5large.sh [GPU_IDS] [MODEL_PATH]
-###############################################################################
-
-set -e  # exit on first error
-
-export CUDA_DEVICE_ORDER="PCI_BUS_ID"
-GPU_IDS="${1:-0,1}"
-MODEL_PATH="${2:-google/flan-t5-large}"
-
-# ── Config ──────────────────────────────────────────────────────────────────
-RUN_NAME="ot_sign_order1_t5large"
-OUTPUT_BASE="logs_and_outputs/${RUN_NAME}/outputs"
-CONFIG_PREFIX="configs/gen_script_superni_order1_t5_configs"
-GEN_DATA_DIR="generated_data/lora_gen_superni_t5"
-METRIC_TYPE="rougeL"   # RougeL for SuperNI
-KL_RATIO=0.5
-EPOCHS=50
-
-# T4 settings
-BATCH_SIZE=8
-EVAL_BATCH=4
-GRAD_ACCUM=4
-LR=0.0003
-
-# OT-SIGN
-OT_EPSILON=0.05
-OT_N_ITER=10
-DEFAULT_KAPPA=10.0
-LAMBDA_DRIFT=0.01
-LAMBDA_INV=0.001
-THRESHOLD=2.3
-
-# ── Task sequence ────────────────────────────────────────────────────────────
-TASKS=(
-  "task1572_samsum_summary"
-  "task363_sst2_polarity_classification"
-  "task1290_xsum_summarization"
-  "task181_outcome_extraction"
-  "task002_quoref_answer_generation"
-  "task1510_evalution_relation_extraction"
-  "task639_multi_woz_user_utterance_generation"
-  "task1729_personachat_generate_next"
-  "task073_commonsenseqa_answer_generation"
-  "task1590_diplomacy_text_generation"
-  "task748_glucose_reverse_cause_event_detection"
-  "task511_reddit_tifu_long_text_summarization"
-  "task591_sciq_answer_generation"
-  "task1687_sentiment140_classification"
-  "task875_emotion_classification"
-)
-TASK_ORDER=$(IFS=,; echo "${TASKS[*]}")
-T=${#TASKS[@]}
-
-mkdir -p "${OUTPUT_BASE}"
-echo "════════════════════════════════════════════════"
-echo "  OT-SIGN+GainLoRA  |  Order 1  |  T5-Large"
-echo "  GPUs: ${GPU_IDS}  |  Tasks: ${T}  |  Epochs: ${EPOCHS}"
-echo "════════════════════════════════════════════════"
-
-# ── Training loop ────────────────────────────────────────────────────────────
-PREV_LORA_PATHS=""
-
-for i in "${!TASKS[@]}"; do
-  TASK="${TASKS[$i]}"
-  TASKNUM=$((i + 1))
-  OUTDIR="${OUTPUT_BASE}/${TASKNUM}-${TASK}"
-
-  # Metric key (task 1 has no "for_task" suffix)
-  if [[ $i -eq 0 ]]; then
-    METRIC_KEY="eval_${METRIC_TYPE}"
-  else
-    METRIC_KEY="eval_${METRIC_TYPE}_for_${TASK}"
-  fi
-
-  echo ""
-  echo "──────────────────────────────────────────────"
-  echo "  Task ${TASKNUM}/${T}: ${TASK}"
-  echo "──────────────────────────────────────────────"
-
-  # Build OT-SIGN flags
-  OT_FLAGS="--use_ot_routing True \
-    --ot_epsilon ${OT_EPSILON} \
-    --ot_n_iter ${OT_N_ITER} \
-    --default_kappa ${DEFAULT_KAPPA} \
-    --lambda_drift ${LAMBDA_DRIFT} \
-    --lambda_inv ${LAMBDA_INV} \
-    --invasion_threshold ${THRESHOLD}"
-
-  # Build previous-task flags (empty for task 1)
-  PREV_FLAGS=""
-  if [[ $i -gt 0 ]]; then
-    PREV_OUTDIR="${OUTPUT_BASE}/${i}-${TASKS[$((i-1))]}/saved_weights"
-    PREV_FLAGS="--load_checkpoint_from ${PREV_OUTDIR}/trans_input.pt \
-      --previous_lora_path ${PREV_LORA_PATHS} \
-      --previous_prompt_key_path ${PREV_OUTDIR}/prompts_keys_till_now.pt \
-      --previous_vmf_signatures_path ${PREV_OUTDIR}/vmf_signatures.pt \
-      --add_instruction_replay \
-      --gen_data_dir ${GEN_DATA_DIR} \
-      --kl_ratio ${KL_RATIO} \
-      --data_replay_freq -1 \
-      --replay_after_n_epoch 0"
-  fi
-
-  CUDA_VISIBLE_DEVICES=${GPU_IDS} python src/run_t5.py \
-    --do_train \
-    --do_predict \
-    --predict_with_generate \
-    --model_name_or_path "${MODEL_PATH}" \
-    --data_dir CL_Benchmark \
-    --task_order "${TASK_ORDER}" \
-    --task_config_dir "${CONFIG_PREFIX}/${TASK}" \
-    --output_dir "${OUTDIR}" \
-    --per_device_train_batch_size ${BATCH_SIZE} \
-    --per_device_eval_batch_size ${EVAL_BATCH} \
-    --gradient_accumulation_steps ${GRAD_ACCUM} \
-    --learning_rate ${LR} \
-    --num_train_epochs ${EPOCHS} \
-    --run_name "${RUN_NAME}" \
-    --max_source_length 512 \
-    --max_target_length 50 \
-    --generation_max_length 50 \
-    --add_task_name False \
-    --add_dataset_name False \
-    --lr_scheduler_type constant \
-    --warmup_steps 0 \
-    --logging_strategy steps \
-    --logging_steps 10 \
-    --eval_strategy steps \
-    --save_strategy steps \
-    --save_total_limit 1 \
-    --load_best_model_at_end \
-    --metric_for_best_model "${METRIC_KEY}" \
-    --lora_r 4 \
-    --lora_alpha 32 \
-    --lora_dropout 0.0 \
-    --attn_temperature 1 \
-    --mlp_hidden_dim 100 \
-    --model_name gainlora_inflora \
-    --threshold 0.995 \
-    --transthreshold 0.995 \
-    --fp16 \
-    ${OT_FLAGS} \
-    ${PREV_FLAGS}
-
-  # Accumulate previous lora paths
-  if [[ -z "${PREV_LORA_PATHS}" ]]; then
-    PREV_LORA_PATHS="${OUTDIR}/saved_weights"
-  else
-    PREV_LORA_PATHS="${PREV_LORA_PATHS},${OUTDIR}/saved_weights"
-  fi
-
-  echo "  [DONE] Task ${TASKNUM}/${T}: ${TASK}"
-done
-
-# ── Final AP/FT ──────────────────────────────────────────────────────────────
-echo ""
-echo "════════════════════════════════════════════════"
-echo "  Computing AP / FT ..."
-echo "════════════════════════════════════════════════"
-python src/compute_ap_ft.py \
-  --output_base "${OUTPUT_BASE}" \
-  --task_order "${TASK_ORDER}" \
-  --method_name "${RUN_NAME}" \
-  --save
-
-echo ""
-echo "✓ All done. Results in: logs_and_outputs/${RUN_NAME}/"
-echo "  Compare with: results/comparison_results.md"

gainlora_OT_vMF/run_ot_sign_order2_t5large.sh

@@ -1,168 +0,0 @@
-#!/bin/bash
-###############################################################################
-# OT-SIGN + GainLoRA (T5-Large) — Order 2 (SuperNI)
-# ===================================================
-# Task order: glucose → commonsenseqa → diplomacy → ... → emotion (15 tasks)
-# Benchmark:  SuperNI (RougeL metric)
-# Hardware:   2× T4 16GB  |  Estimated time: ~9-10h
-# Run:        bash run_ot_sign_order2_t5large.sh [GPU_IDS] [MODEL_PATH]
-###############################################################################
-
-set -e
-
-export CUDA_DEVICE_ORDER="PCI_BUS_ID"
-GPU_IDS="${1:-0,1}"
-MODEL_PATH="${2:-google/flan-t5-large}"
-
-# ── Config ──────────────────────────────────────────────────────────────────
-RUN_NAME="ot_sign_order2_t5large"
-OUTPUT_BASE="logs_and_outputs/${RUN_NAME}/outputs"
-CONFIG_PREFIX="configs/gen_script_superni_order2_t5_configs"
-GEN_DATA_DIR="generated_data/lora_gen_superni_t5"
-METRIC_TYPE="rougeL"
-KL_RATIO=0.5
-EPOCHS=50
-
-BATCH_SIZE=8
-EVAL_BATCH=4
-GRAD_ACCUM=4
-LR=0.0003
-
-OT_EPSILON=0.05
-OT_N_ITER=10
-DEFAULT_KAPPA=10.0
-LAMBDA_DRIFT=0.01
-LAMBDA_INV=0.001
-THRESHOLD=2.3
-
-# ── Task sequence ────────────────────────────────────────────────────────────
-TASKS=(
-  "task748_glucose_reverse_cause_event_detection"
-  "task073_commonsenseqa_answer_generation"
-  "task1590_diplomacy_text_generation"
-  "task639_multi_woz_user_utterance_generation"
-  "task1572_samsum_summary"
-  "task1687_sentiment140_classification"
-  "task591_sciq_answer_generation"
-  "task363_sst2_polarity_classification"
-  "task1510_evalution_relation_extraction"
-  "task1729_personachat_generate_next"
-  "task181_outcome_extraction"
-  "task511_reddit_tifu_long_text_summarization"
-  "task002_quoref_answer_generation"
-  "task1290_xsum_summarization"
-  "task875_emotion_classification"
-)
-TASK_ORDER=$(IFS=,; echo "${TASKS[*]}")
-T=${#TASKS[@]}
-
-mkdir -p "${OUTPUT_BASE}"
-echo "════════════════════════════════════════════════"
-echo "  OT-SIGN+GainLoRA  |  Order 2  |  T5-Large"
-echo "  GPUs: ${GPU_IDS}  |  Tasks: ${T}  |  Epochs: ${EPOCHS}"
-echo "════════════════════════════════════════════════"
-
-# ── Training loop ────────────────────────────────────────────────────────────
-PREV_LORA_PATHS=""
-
-for i in "${!TASKS[@]}"; do
-  TASK="${TASKS[$i]}"
-  TASKNUM=$((i + 1))
-  OUTDIR="${OUTPUT_BASE}/${TASKNUM}-${TASK}"
-
-  if [[ $i -eq 0 ]]; then
-    METRIC_KEY="eval_${METRIC_TYPE}"
-  else
-    METRIC_KEY="eval_${METRIC_TYPE}_for_${TASK}"
-  fi
-
-  echo ""
-  echo "──────────────────────────────────────────────"
-  echo "  Task ${TASKNUM}/${T}: ${TASK}"
-  echo "──────────────────────────────────────────────"
-
-  OT_FLAGS="--use_ot_routing True \
-    --ot_epsilon ${OT_EPSILON} \
-    --ot_n_iter ${OT_N_ITER} \
-    --default_kappa ${DEFAULT_KAPPA} \
-    --lambda_drift ${LAMBDA_DRIFT} \
-    --lambda_inv ${LAMBDA_INV} \
-    --invasion_threshold ${THRESHOLD}"
-
-  PREV_FLAGS=""
-  if [[ $i -gt 0 ]]; then
-    PREV_OUTDIR="${OUTPUT_BASE}/${i}-${TASKS[$((i-1))]}/saved_weights"
-    PREV_FLAGS="--load_checkpoint_from ${PREV_OUTDIR}/trans_input.pt \
-      --previous_lora_path ${PREV_LORA_PATHS} \
-      --previous_prompt_key_path ${PREV_OUTDIR}/prompts_keys_till_now.pt \
-      --previous_vmf_signatures_path ${PREV_OUTDIR}/vmf_signatures.pt \
-      --add_instruction_replay \
-      --gen_data_dir ${GEN_DATA_DIR} \
-      --kl_ratio ${KL_RATIO} \
-      --data_replay_freq -1 \
-      --replay_after_n_epoch 0"
-  fi
-
-  CUDA_VISIBLE_DEVICES=${GPU_IDS} python src/run_t5.py \
-    --do_train \
-    --do_predict \
-    --predict_with_generate \
-    --model_name_or_path "${MODEL_PATH}" \
-    --data_dir CL_Benchmark \
-    --task_order "${TASK_ORDER}" \
-    --task_config_dir "${CONFIG_PREFIX}/${TASK}" \
-    --output_dir "${OUTDIR}" \
-    --per_device_train_batch_size ${BATCH_SIZE} \
-    --per_device_eval_batch_size ${EVAL_BATCH} \
-    --gradient_accumulation_steps ${GRAD_ACCUM} \
-    --learning_rate ${LR} \
-    --num_train_epochs ${EPOCHS} \
-    --run_name "${RUN_NAME}" \
-    --max_source_length 512 \
-    --max_target_length 50 \
-    --generation_max_length 50 \
-    --add_task_name False \
-    --add_dataset_name False \
-    --lr_scheduler_type constant \
-    --warmup_steps 0 \
-    --logging_strategy steps \
-    --logging_steps 10 \
-    --eval_strategy steps \
-    --save_strategy steps \
-    --save_total_limit 1 \
-    --load_best_model_at_end \
-    --metric_for_best_model "${METRIC_KEY}" \
-    --lora_r 4 \
-    --lora_alpha 32 \
-    --lora_dropout 0.0 \
-    --attn_temperature 1 \
-    --mlp_hidden_dim 100 \
-    --model_name gainlora_inflora \
-    --threshold 0.995 \
-    --transthreshold 0.995 \
-    --fp16 \
-    ${OT_FLAGS} \
-    ${PREV_FLAGS}
-
-  if [[ -z "${PREV_LORA_PATHS}" ]]; then
-    PREV_LORA_PATHS="${OUTDIR}/saved_weights"
-  else
-    PREV_LORA_PATHS="${PREV_LORA_PATHS},${OUTDIR}/saved_weights"
-  fi
-
-  echo "  [DONE] Task ${TASKNUM}/${T}: ${TASK}"
-done
-
-# ── Final AP/FT ──────────────────────────────────────────────────────────────
-echo ""
-echo "════════════════════════════════════════════════"
-echo "  Computing AP / FT ..."
-echo "════════════════════════════════════════════════"
-python src/compute_ap_ft.py \
-  --output_base "${OUTPUT_BASE}" \
-  --task_order "${TASK_ORDER}" \
-  --method_name "${RUN_NAME}" \
-  --save
-
-echo ""
-echo "✓ All done. Results in: logs_and_outputs/${RUN_NAME}/"

gainlora_OT_vMF/run_ot_sign_order3_t5large.sh

@@ -1,169 +0,0 @@
-#!/bin/bash
-###############################################################################
-# OT-SIGN + GainLoRA (T5-Large) — Order 3 (Long Benchmark)
-# ==========================================================
-# Task order: yelp → amazon → mnli → ... → wic (15 tasks)
-# Benchmark:  Long (Exact Match metric)
-# Hardware:   2× T4 16GB  |  Estimated time: ~3-4h
-# Run:        bash run_ot_sign_order3_t5large.sh [GPU_IDS] [MODEL_PATH]
-###############################################################################
-
-set -e
-
-export CUDA_DEVICE_ORDER="PCI_BUS_ID"
-GPU_IDS="${1:-0,1}"
-MODEL_PATH="${2:-google/flan-t5-large}"
-
-# ── Config ──────────────────────────────────────────────────────────────────
-RUN_NAME="ot_sign_order3_t5large"
-OUTPUT_BASE="logs_and_outputs/${RUN_NAME}/outputs"
-CONFIG_PREFIX="configs/gen_script_long_order3_t5_configs"
-GEN_DATA_DIR="generated_data/lora_gen_long_t5"
-METRIC_TYPE="exact_match"   # Exact Match for Long benchmark
-KL_RATIO=0.1
-EPOCHS=10                   # Long benchmark uses fewer epochs
-
-BATCH_SIZE=4
-EVAL_BATCH=16               # Long benchmark uses larger eval batch
-GRAD_ACCUM=8
-LR=0.0003
-
-OT_EPSILON=0.05
-OT_N_ITER=10
-DEFAULT_KAPPA=10.0
-LAMBDA_DRIFT=0.01
-LAMBDA_INV=0.001
-THRESHOLD=2.3
-
-# ── Task sequence ────────────────────────────────────────────────────────────
-TASKS=(
-  "yelp"
-  "amazon"
-  "mnli"
-  "cb"
-  "copa"
-  "qqp"
-  "rte"
-  "imdb"
-  "sst2"
-  "dbpedia"
-  "agnews"
-  "yahoo"
-  "multirc"
-  "boolq"
-  "wic"
-)
-TASK_ORDER=$(IFS=,; echo "${TASKS[*]}")
-T=${#TASKS[@]}
-
-mkdir -p "${OUTPUT_BASE}"
-echo "════════════════════════════════════════════════"
-echo "  OT-SIGN+GainLoRA  |  Order 3  |  T5-Large"
-echo "  GPUs: ${GPU_IDS}  |  Tasks: ${T}  |  Epochs: ${EPOCHS}"
-echo "════════════════════════════════════════════════"
-
-# ── Training loop ────────────────────────────────────────────────────────────
-PREV_LORA_PATHS=""
-
-for i in "${!TASKS[@]}"; do
-  TASK="${TASKS[$i]}"
-  TASKNUM=$((i + 1))
-  OUTDIR="${OUTPUT_BASE}/${TASKNUM}-${TASK}"
-
-  if [[ $i -eq 0 ]]; then
-    METRIC_KEY="eval_${METRIC_TYPE}"
-  else
-    METRIC_KEY="eval_${METRIC_TYPE}_for_${TASK}"
-  fi
-
-  echo ""
-  echo "──────────────────────────────────────────────"
-  echo "  Task ${TASKNUM}/${T}: ${TASK}"
-  echo "──────────────────────────────────────────────"
-
-  OT_FLAGS="--use_ot_routing True \
-    --ot_epsilon ${OT_EPSILON} \
-    --ot_n_iter ${OT_N_ITER} \
-    --default_kappa ${DEFAULT_KAPPA} \
-    --lambda_drift ${LAMBDA_DRIFT} \
-    --lambda_inv ${LAMBDA_INV} \
-    --invasion_threshold ${THRESHOLD}"
-
-  PREV_FLAGS=""
-  if [[ $i -gt 0 ]]; then
-    PREV_OUTDIR="${OUTPUT_BASE}/${i}-${TASKS[$((i-1))]}/saved_weights"
-    PREV_FLAGS="--load_checkpoint_from ${PREV_OUTDIR}/trans_input.pt \
-      --previous_lora_path ${PREV_LORA_PATHS} \
-      --previous_prompt_key_path ${PREV_OUTDIR}/prompts_keys_till_now.pt \
-      --previous_vmf_signatures_path ${PREV_OUTDIR}/vmf_signatures.pt \
-      --add_instruction_replay \
-      --gen_data_dir ${GEN_DATA_DIR} \
-      --kl_ratio ${KL_RATIO} \
-      --data_replay_freq -1 \
-      --replay_after_n_epoch 0"
-  fi
-
-  CUDA_VISIBLE_DEVICES=${GPU_IDS} torchrun --nproc_per_node=2 src/run_t5.py \
-    --do_train \
-    --do_predict \
-    --predict_with_generate \
-    --model_name_or_path "${MODEL_PATH}" \
-    --data_dir CL_Benchmark \
-    --task_order "${TASK_ORDER}" \
-    --task_config_dir "${CONFIG_PREFIX}/${TASK}" \
-    --output_dir "${OUTDIR}" \
-    --per_device_train_batch_size ${BATCH_SIZE} \
-    --per_device_eval_batch_size ${EVAL_BATCH} \
-    --gradient_accumulation_steps ${GRAD_ACCUM} \
-    --learning_rate ${LR} \
-    --num_train_epochs ${EPOCHS} \
-    --run_name "${RUN_NAME}" \
-    --max_source_length 512 \
-    --max_target_length 50 \
-    --generation_max_length 50 \
-    --add_task_name False \
-    --add_dataset_name False \
-    --lr_scheduler_type constant \
-    --warmup_steps 0 \
-    --logging_strategy steps \
-    --logging_steps 10 \
-    --eval_strategy steps \
-    --save_strategy steps \
-    --save_total_limit 1 \
-    --load_best_model_at_end \
-    --metric_for_best_model "${METRIC_KEY}" \
-    --lora_r 4 \
-    --lora_alpha 32 \
-    --lora_dropout 0.0 \
-    --attn_temperature 1 \
-    --mlp_hidden_dim 100 \
-    --model_name gainlora_inflora \
-    --threshold 0.995 \
-    --transthreshold 0.995 \
-    --fp16 \
-    --gradient_checkpointing True \
-    ${OT_FLAGS} \
-    ${PREV_FLAGS}
-
-  if [[ -z "${PREV_LORA_PATHS}" ]]; then
-    PREV_LORA_PATHS="${OUTDIR}/saved_weights"
-  else
-    PREV_LORA_PATHS="${PREV_LORA_PATHS},${OUTDIR}/saved_weights"
-  fi
-
-  echo "  [DONE] Task ${TASKNUM}/${T}: ${TASK}"
-done
-
-# ── Final AP/FT ──────────────────────────────────────────────────────────────
-echo ""
-echo "════════════════════════════════════════════════"
-echo "  Computing AP / FT ..."
-echo "════════════════════════════════════════════════"
-python src/compute_ap_ft.py \
-  --output_base "${OUTPUT_BASE}" \
-  --task_order "${TASK_ORDER}" \
-  --method_name "${RUN_NAME}" \
-  --save
-
-echo ""
-echo "✓ All done. Results in: logs_and_outputs/${RUN_NAME}/"

gainlora_OT_vMF/run_ot_sign_order4_t5large.sh

@@ -1,169 +0,0 @@
-#!/bin/bash
-###############################################################################
-# OT-SIGN + GainLoRA (T5-Large) — Order 4 (Long Benchmark)
-# ==========================================================
-# Task order: mnli → cb → wic → ... → yahoo (15 tasks)
-# Benchmark:  Long (Exact Match metric)
-# Hardware:   2× T4 16GB  |  Estimated time: ~3-4h
-# Run:        bash run_ot_sign_order4_t5large.sh [GPU_IDS] [MODEL_PATH]
-###############################################################################
-
-set -e
-
-export CUDA_DEVICE_ORDER="PCI_BUS_ID"
-GPU_IDS="${1:-0,1}"
-MODEL_PATH="${2:-google/flan-t5-large}"
-
-# ── Config ──────────────────────────────────────────────────────────────────
-RUN_NAME="ot_sign_order4_t5large"
-OUTPUT_BASE="logs_and_outputs/${RUN_NAME}/outputs"
-CONFIG_PREFIX="configs/gen_script_long_order4_t5_configs"
-GEN_DATA_DIR="generated_data/lora_gen_long_t5"
-METRIC_TYPE="exact_match"
-KL_RATIO=0.1
-EPOCHS=10
-
-BATCH_SIZE=4
-EVAL_BATCH=16
-GRAD_ACCUM=8
-LR=0.0003
-
-OT_EPSILON=0.05
-OT_N_ITER=10
-DEFAULT_KAPPA=10.0
-LAMBDA_DRIFT=0.01
-LAMBDA_INV=0.001
-THRESHOLD=2.3
-
-# ── Task sequence ────────────────────────────────────────────────────────────
-TASKS=(
-  "mnli"
-  "cb"
-  "wic"
-  "copa"
-  "qqp"
-  "boolq"
-  "rte"
-  "imdb"
-  "yelp"
-  "amazon"
-  "sst2"
-  "dbpedia"
-  "agnews"
-  "multirc"
-  "yahoo"
-)
-TASK_ORDER=$(IFS=,; echo "${TASKS[*]}")
-T=${#TASKS[@]}
-
-mkdir -p "${OUTPUT_BASE}"
-echo "════════════════════════════════════════════════"
-echo "  OT-SIGN+GainLoRA  |  Order 4  |  T5-Large"
-echo "  GPUs: ${GPU_IDS}  |  Tasks: ${T}  |  Epochs: ${EPOCHS}"
-echo "════════════════════════════════════════════════"
-
-# ── Training loop ────────────────────────────────────────────────────────────
-PREV_LORA_PATHS=""
-
-for i in "${!TASKS[@]}"; do
-  TASK="${TASKS[$i]}"
-  TASKNUM=$((i + 1))
-  OUTDIR="${OUTPUT_BASE}/${TASKNUM}-${TASK}"
-
-  if [[ $i -eq 0 ]]; then
-    METRIC_KEY="eval_${METRIC_TYPE}"
-  else
-    METRIC_KEY="eval_${METRIC_TYPE}_for_${TASK}"
-  fi
-
-  echo ""
-  echo "──────────────────────────────────────────────"
-  echo "  Task ${TASKNUM}/${T}: ${TASK}"
-  echo "──────────────────────────────────────────────"
-
-  OT_FLAGS="--use_ot_routing True \
-    --ot_epsilon ${OT_EPSILON} \
-    --ot_n_iter ${OT_N_ITER} \
-    --default_kappa ${DEFAULT_KAPPA} \
-    --lambda_drift ${LAMBDA_DRIFT} \
-    --lambda_inv ${LAMBDA_INV} \
-    --invasion_threshold ${THRESHOLD}"
-
-  PREV_FLAGS=""
-  if [[ $i -gt 0 ]]; then
-    PREV_OUTDIR="${OUTPUT_BASE}/${i}-${TASKS[$((i-1))]}/saved_weights"
-    PREV_FLAGS="--load_checkpoint_from ${PREV_OUTDIR}/trans_input.pt \
-      --previous_lora_path ${PREV_LORA_PATHS} \
-      --previous_prompt_key_path ${PREV_OUTDIR}/prompts_keys_till_now.pt \
-      --previous_vmf_signatures_path ${PREV_OUTDIR}/vmf_signatures.pt \
-      --add_instruction_replay \
-      --gen_data_dir ${GEN_DATA_DIR} \
-      --kl_ratio ${KL_RATIO} \
-      --data_replay_freq -1 \
-      --replay_after_n_epoch 0"
-  fi
-
-  CUDA_VISIBLE_DEVICES=${GPU_IDS} torchrun --nproc_per_node=2 src/run_t5.py \
-    --do_train \
-    --do_predict \
-    --predict_with_generate \
-    --model_name_or_path "${MODEL_PATH}" \
-    --data_dir CL_Benchmark \
-    --task_order "${TASK_ORDER}" \
-    --task_config_dir "${CONFIG_PREFIX}/${TASK}" \
-    --output_dir "${OUTDIR}" \
-    --per_device_train_batch_size ${BATCH_SIZE} \
-    --per_device_eval_batch_size ${EVAL_BATCH} \
-    --gradient_accumulation_steps ${GRAD_ACCUM} \
-    --learning_rate ${LR} \
-    --num_train_epochs ${EPOCHS} \
-    --run_name "${RUN_NAME}" \
-    --max_source_length 512 \
-    --max_target_length 50 \
-    --generation_max_length 50 \
-    --add_task_name False \
-    --add_dataset_name False \
-    --lr_scheduler_type constant \
-    --warmup_steps 0 \
-    --logging_strategy steps \
-    --logging_steps 10 \
-    --eval_strategy steps \
-    --save_strategy steps \
-    --save_total_limit 1 \
-    --load_best_model_at_end \
-    --metric_for_best_model "${METRIC_KEY}" \
-    --lora_r 4 \
-    --lora_alpha 32 \
-    --lora_dropout 0.0 \
-    --attn_temperature 1 \
-    --mlp_hidden_dim 100 \
-    --model_name gainlora_inflora \
-    --threshold 0.995 \
-    --transthreshold 0.995 \
-    --fp16 \
-    --gradient_checkpointing True \
-    ${OT_FLAGS} \
-    ${PREV_FLAGS}
-
-  if [[ -z "${PREV_LORA_PATHS}" ]]; then
-    PREV_LORA_PATHS="${OUTDIR}/saved_weights"
-  else
-    PREV_LORA_PATHS="${PREV_LORA_PATHS},${OUTDIR}/saved_weights"
-  fi
-
-  echo "  [DONE] Task ${TASKNUM}/${T}: ${TASK}"
-done
-
-# ── Final AP/FT ──────────────────────────────────────────────────────────────
-echo ""
-echo "════════════════════════════════════════════════"
-echo "  Computing AP / FT ..."
-echo "════════════════════════════════════════════════"
-python src/compute_ap_ft.py \
-  --output_base "${OUTPUT_BASE}" \
-  --task_order "${TASK_ORDER}" \
-  --method_name "${RUN_NAME}" \
-  --save
-
-echo ""
-echo "✓ All done. Results in: logs_and_outputs/${RUN_NAME}/"

gainlora_OT_vMF/run_ot_sign_smoke_t5.sh

@@ -1,70 +0,0 @@
-#!/bin/bash
-# Fast smoke run for early bug detection (2-5 minutes, not 30+ minutes).
-
-set -euo pipefail
-
-GPU_IDS="${1:-0}"
-MODEL_PATH="${2:-google/flan-t5-small}"
-
-RUN_NAME="ot_sign_smoke_t5"
-OUTDIR="logs_and_outputs/${RUN_NAME}/outputs"
-TASK="yelp"
-TASK_ORDER="yelp"
-CONFIG_DIR="configs/gen_script_long_order3_t5_configs/${TASK}"
-
-echo "[1/2] Running preflight checks..."
-python src/preflight_check.py
-
-echo "[2/2] Running smoke training (tiny data, tiny steps)..."
-CUDA_VISIBLE_DEVICES="${GPU_IDS}" torchrun --nproc_per_node=1 src/run_t5.py \
-  --do_train \
-  --do_eval \
-  --model_name_or_path "${MODEL_PATH}" \
-  --data_dir CL_Benchmark \
-  --task_order "${TASK_ORDER}" \
-  --task_config_dir "${CONFIG_DIR}" \
-  --output_dir "${OUTDIR}" \
-  --overwrite_output_dir True \
-  --per_device_train_batch_size 1 \
-  --per_device_eval_batch_size 1 \
-  --gradient_accumulation_steps 1 \
-  --learning_rate 3e-4 \
-  --num_train_epochs 1 \
-  --max_steps 3 \
-  --max_num_instances_per_task 8 \
-  --max_num_instances_per_eval_task 8 \
-  --max_train_samples 8 \
-  --max_eval_samples 8 \
-  --max_predict_samples 8 \
-  --run_name "${RUN_NAME}" \
-  --max_source_length 128 \
-  --max_target_length 32 \
-  --generation_max_length 32 \
-  --add_task_name False \
-  --add_dataset_name False \
-  --lr_scheduler_type constant \
-  --warmup_steps 0 \
-  --logging_strategy steps \
-  --logging_steps 1 \
-  --eval_strategy steps \
-  --eval_steps 1 \
-  --save_strategy no \
-  --lora_r 4 \
-  --lora_alpha 32 \
-  --lora_dropout 0.0 \
-  --attn_temperature 1 \
-  --mlp_hidden_dim 32 \
-  --model_name gainlora_inflora \
-  --threshold 0.995 \
-  --transthreshold 0.995 \
-  --fp16 \
-  --gradient_checkpointing True \
-  --use_ot_routing True \
-  --ot_epsilon 0.05 \
-  --ot_n_iter 5 \
-  --default_kappa 10.0 \
-  --lambda_drift 0.01 \
-  --lambda_inv 0.001 \
-  --invasion_threshold 2.3
-
-echo "Smoke run done."

gainlora_OT_vMF/run_ot_sign_t4.sh

@@ -1,488 +0,0 @@
-#!/bin/bash
-###############################################################################
-# OT-SIGN + GainLoRA (T5-Large) — Optimized for 2×T4 (16GB each)
-# ================================================================
-# Changes from original:
-#   - batch_size: 16 → 8 (T4 memory constraint)
-#   - fp16: enabled (T4 has good FP16 throughput)
-#   - gradient_accumulation: 4 (compensate for smaller batch)
-#   - OT-SIGN: use_ot_routing enabled from task 2 onward
-#   - OT-SIGN: vMF signatures saved/loaded between tasks
-#   - OT-SIGN: anti-drift + anti-invasion losses activated
-#   - num_train_epochs: 50 (reduced for faster iteration on T4)
-#   - ipdb/cupy guards already handled in code
-###############################################################################
-
-export CUDA_DEVICE_ORDER="PCI_BUS_ID"
-
-# === Configuration ===
-GPU_IDS="${1:-0,1}"         # Default: use GPU 0,1
-MODEL_PATH="${2:-google/flan-t5-large}"  # T5-Large
-RUN_NAME="ot_sign_t5_gainlora_t4"
-TASK_ORDER="task1572_samsum_summary,task363_sst2_polarity_classification,task1290_xsum_summarization,task181_outcome_extraction,task002_quoref_answer_generation,task1510_evalution_relation_extraction,task639_multi_woz_user_utterance_generation,task1729_personachat_generate_next,task073_commonsenseqa_answer_generation,task1590_diplomacy_text_generation,task748_glucose_reverse_cause_event_detection,task511_reddit_tifu_long_text_summarization,task591_sciq_answer_generation,task1687_sentiment140_classification,task875_emotion_classification"
-OUTPUT_BASE="logs_and_outputs/${RUN_NAME}/outputs"
-
-# T4-optimized hyperparameters
-BATCH_SIZE=8
-EVAL_BATCH_SIZE=4
-GRAD_ACCUM=4
-LR=0.0003
-EPOCHS=50
-MAX_SRC=512
-MAX_TGT=50
-LORA_R=4
-LORA_ALPHA=32
-
-# OT-SIGN hyperparameters
-OT_EPSILON=0.05
-OT_N_ITER=10
-DEFAULT_KAPPA=10.0
-LAMBDA_DRIFT=0.01
-LAMBDA_INV=0.001
-INVASION_THRESHOLD=2.3
-
-# Common flags
-COMMON_FLAGS="--predict_with_generate \
-   --model_name_or_path ${MODEL_PATH} \
-   --data_dir CL_Benchmark \
-   --task_order ${TASK_ORDER} \
-   --per_device_eval_batch_size ${EVAL_BATCH_SIZE} \
-   --learning_rate ${LR} \
-   --num_train_epochs ${EPOCHS} \
-   --run_name ${RUN_NAME} \
-   --max_source_length ${MAX_SRC} \
-   --max_target_length ${MAX_TGT} \
-   --generation_max_length ${MAX_TGT} \
-   --add_task_name False \
-   --add_dataset_name False \
-   --lr_scheduler_type constant \
-   --warmup_steps 0 \
-   --logging_strategy steps \
-   --logging_steps 10 \
-   --eval_strategy steps \
-   --save_strategy steps \
-   --save_total_limit 1 \
-   --load_best_model_at_end \
-   --lora_r ${LORA_R} \
-   --lora_alpha ${LORA_ALPHA} \
-   --lora_dropout 0.0 \
-   --attn_temperature 1 \
-   --mlp_hidden_dim 100 \
-   --model_name gainlora_inflora \
-   --threshold 0.995 \
-   --transthreshold 0.995 \
-   --fp16"
-
-# OT-SIGN flags (used from task 2 onward)
-OT_SIGN_FLAGS="--use_ot_routing True \
-   --ot_epsilon ${OT_EPSILON} \
-   --ot_n_iter ${OT_N_ITER} \
-   --default_kappa ${DEFAULT_KAPPA} \
-   --lambda_drift ${LAMBDA_DRIFT} \
-   --lambda_inv ${LAMBDA_INV} \
-   --invasion_threshold ${INVASION_THRESHOLD}"
-
-echo "============================================="
-echo "OT-SIGN + GainLoRA T5-Large on 2×T4"
-echo "Run: ${RUN_NAME}"
-echo "Model: ${MODEL_PATH}"
-echo "Batch: ${BATCH_SIZE} × ${GRAD_ACCUM} grad_accum"
-echo "FP16: enabled"
-echo "OT-SIGN: epsilon=${OT_EPSILON}, kappa_def=${DEFAULT_KAPPA}"
-echo "============================================="
-
-# Create output directories
-mkdir -p ${OUTPUT_BASE}
-mkdir -p logs_and_outputs/${RUN_NAME}/ot_sign_logs
-
-###############################################################################
-# Task 1: task1572_samsum_summary (NO OT routing — first task, no signatures)
-###############################################################################
-echo ""
-echo "===== Task 1/15: task1572_samsum_summary (baseline, no OT) ====="
-CUDA_VISIBLE_DEVICES=${GPU_IDS} python src/run_t5.py \
-   --do_train \
-   --do_predict \
-   ${COMMON_FLAGS} \
-   --task_config_dir configs/gen_script_superni_order1_t5_configs/task1572_samsum_summary \
-   --output_dir ${OUTPUT_BASE}/1-task1572_samsum_summary \
-   --per_device_train_batch_size ${BATCH_SIZE} \
-   --gradient_accumulation_steps ${GRAD_ACCUM} \
-   --metric_for_best_model eval_rougeL \
-   --data_replay_freq -1 \
-   --replay_after_n_epoch 0 \
-   --kl_ratio 0.5 \
-   --use_ot_routing True \
-   --ot_epsilon ${OT_EPSILON} \
-   --ot_n_iter ${OT_N_ITER} \
-   --default_kappa ${DEFAULT_KAPPA}
-
-###############################################################################
-# Task 2: task363_sst2 (OT routing with 1 signature from task 1)
-###############################################################################
-echo ""
-echo "===== Task 2/15: task363_sst2_polarity_classification (OT-SIGN active) ====="
-PREV_1="${OUTPUT_BASE}/1-task1572_samsum_summary/saved_weights"
-CUDA_VISIBLE_DEVICES=${GPU_IDS} python src/run_t5.py \
-   --do_train \
-   --do_predict \
-   ${COMMON_FLAGS} \
-   --load_checkpoint_from ${PREV_1}/trans_input.pt \
-   --previous_lora_path ${PREV_1} \
-   --previous_prompt_key_path ${PREV_1}/prompts_keys_till_now.pt \
-   --previous_vmf_signatures_path ${PREV_1}/vmf_signatures.pt \
-   --gen_data_dir generated_data/lora_gen_superni_t5 \
-   --task_config_dir configs/gen_script_superni_order1_t5_configs/task363_sst2_polarity_classification \
-   --output_dir ${OUTPUT_BASE}/2-task363_sst2_polarity_classification \
-   --per_device_train_batch_size ${BATCH_SIZE} \
-   --gradient_accumulation_steps ${GRAD_ACCUM} \
-   --metric_for_best_model eval_rougeL_for_task363_sst2_polarity_classification \
-   --add_instruction_replay \
-   --data_replay_freq -1 \
-   --replay_after_n_epoch 0 \
-   --kl_ratio 0.5 \
-   ${OT_SIGN_FLAGS}
-
-###############################################################################
-# Task 3: task1290_xsum_summarization
-###############################################################################
-echo ""
-echo "===== Task 3/15: task1290_xsum_summarization (OT-SIGN active) ====="
-PREV_2="${OUTPUT_BASE}/2-task363_sst2_polarity_classification/saved_weights"
-CUDA_VISIBLE_DEVICES=${GPU_IDS} python src/run_t5.py \
-   --do_train \
-   --do_predict \
-   ${COMMON_FLAGS} \
-   --load_checkpoint_from ${PREV_2}/trans_input.pt \
-   --previous_lora_path ${PREV_1},${PREV_2} \
-   --previous_prompt_key_path ${PREV_2}/prompts_keys_till_now.pt \
-   --previous_vmf_signatures_path ${PREV_2}/vmf_signatures.pt \
-   --gen_data_dir generated_data/lora_gen_superni_t5 \
-   --task_config_dir configs/gen_script_superni_order1_t5_configs/task1290_xsum_summarization \
-   --output_dir ${OUTPUT_BASE}/3-task1290_xsum_summarization \
-   --per_device_train_batch_size ${BATCH_SIZE} \
-   --gradient_accumulation_steps ${GRAD_ACCUM} \
-   --metric_for_best_model eval_rougeL_for_task1290_xsum_summarization \
-   --add_instruction_replay \
-   --data_replay_freq -1 \
-   --replay_after_n_epoch 0 \
-   --kl_ratio 0.5 \
-   ${OT_SIGN_FLAGS}
-
-###############################################################################
-# Task 4: task181_outcome_extraction
-###############################################################################
-echo ""
-echo "===== Task 4/15: task181_outcome_extraction (OT-SIGN active) ====="
-PREV_3="${OUTPUT_BASE}/3-task1290_xsum_summarization/saved_weights"
-CUDA_VISIBLE_DEVICES=${GPU_IDS} python src/run_t5.py \
-   --do_train \
-   --do_predict \
-   ${COMMON_FLAGS} \
-   --load_checkpoint_from ${PREV_3}/trans_input.pt \
-   --previous_lora_path ${PREV_1},${PREV_2},${PREV_3} \
-   --previous_prompt_key_path ${PREV_3}/prompts_keys_till_now.pt \
-   --previous_vmf_signatures_path ${PREV_3}/vmf_signatures.pt \
-   --gen_data_dir generated_data/lora_gen_superni_t5 \
-   --task_config_dir configs/gen_script_superni_order1_t5_configs/task181_outcome_extraction \
-   --output_dir ${OUTPUT_BASE}/4-task181_outcome_extraction \
-   --per_device_train_batch_size ${BATCH_SIZE} \
-   --gradient_accumulation_steps ${GRAD_ACCUM} \
-   --metric_for_best_model eval_rougeL_for_task181_outcome_extraction \
-   --add_instruction_replay \
-   --data_replay_freq -1 \
-   --replay_after_n_epoch 0 \
-   --kl_ratio 0.5 \
-   ${OT_SIGN_FLAGS}
-
-###############################################################################
-# Task 5: task002_quoref_answer_generation
-###############################################################################
-echo ""
-echo "===== Task 5/15: task002_quoref_answer_generation (OT-SIGN active) ====="
-PREV_4="${OUTPUT_BASE}/4-task181_outcome_extraction/saved_weights"
-CUDA_VISIBLE_DEVICES=${GPU_IDS} python src/run_t5.py \
-   --do_train \
-   --do_predict \
-   ${COMMON_FLAGS} \
-   --load_checkpoint_from ${PREV_4}/trans_input.pt \
-   --previous_lora_path ${PREV_1},${PREV_2},${PREV_3},${PREV_4} \
-   --previous_prompt_key_path ${PREV_4}/prompts_keys_till_now.pt \
-   --previous_vmf_signatures_path ${PREV_4}/vmf_signatures.pt \
-   --gen_data_dir generated_data/lora_gen_superni_t5 \
-   --task_config_dir configs/gen_script_superni_order1_t5_configs/task002_quoref_answer_generation \
-   --output_dir ${OUTPUT_BASE}/5-task002_quoref_answer_generation \
-   --per_device_train_batch_size ${BATCH_SIZE} \
-   --gradient_accumulation_steps ${GRAD_ACCUM} \
-   --metric_for_best_model eval_rougeL_for_task002_quoref_answer_generation \
-   --add_instruction_replay \
-   --data_replay_freq -1 \
-   --replay_after_n_epoch 0 \
-   --kl_ratio 0.5 \
-   ${OT_SIGN_FLAGS}
-
-###############################################################################
-# Task 6: task1510_evalution_relation_extraction
-###############################################################################
-echo ""
-echo "===== Task 6/15: task1510_evalution_relation_extraction (OT-SIGN active) ====="
-PREV_5="${OUTPUT_BASE}/5-task002_quoref_answer_generation/saved_weights"
-CUDA_VISIBLE_DEVICES=${GPU_IDS} python src/run_t5.py \
-   --do_train \
-   --do_predict \
-   ${COMMON_FLAGS} \
-   --load_checkpoint_from ${PREV_5}/trans_input.pt \
-   --previous_lora_path ${PREV_1},${PREV_2},${PREV_3},${PREV_4},${PREV_5} \
-   --previous_prompt_key_path ${PREV_5}/prompts_keys_till_now.pt \
-   --previous_vmf_signatures_path ${PREV_5}/vmf_signatures.pt \
-   --gen_data_dir generated_data/lora_gen_superni_t5 \
-   --task_config_dir configs/gen_script_superni_order1_t5_configs/task1510_evalution_relation_extraction \
-   --output_dir ${OUTPUT_BASE}/6-task1510_evalution_relation_extraction \
-   --per_device_train_batch_size ${BATCH_SIZE} \
-   --gradient_accumulation_steps ${GRAD_ACCUM} \
-   --metric_for_best_model eval_rougeL_for_task1510_evalution_relation_extraction \
-   --add_instruction_replay \
-   --data_replay_freq -1 \
-   --replay_after_n_epoch 0 \
-   --kl_ratio 0.5 \
-   ${OT_SIGN_FLAGS}
-
-###############################################################################
-# Task 7: task639_multi_woz_user_utterance_generation
-###############################################################################
-echo ""
-echo "===== Task 7/15: task639_multi_woz_user_utterance_generation (OT-SIGN active) ====="
-PREV_6="${OUTPUT_BASE}/6-task1510_evalution_relation_extraction/saved_weights"
-CUDA_VISIBLE_DEVICES=${GPU_IDS} python src/run_t5.py \
-   --do_train \
-   --do_predict \
-   ${COMMON_FLAGS} \
-   --load_checkpoint_from ${PREV_6}/trans_input.pt \
-   --previous_lora_path ${PREV_1},${PREV_2},${PREV_3},${PREV_4},${PREV_5},${PREV_6} \
-   --previous_prompt_key_path ${PREV_6}/prompts_keys_till_now.pt \
-   --previous_vmf_signatures_path ${PREV_6}/vmf_signatures.pt \
-   --gen_data_dir generated_data/lora_gen_superni_t5 \
-   --task_config_dir configs/gen_script_superni_order1_t5_configs/task639_multi_woz_user_utterance_generation \
-   --output_dir ${OUTPUT_BASE}/7-task639_multi_woz_user_utterance_generation \
-   --per_device_train_batch_size ${BATCH_SIZE} \
-   --gradient_accumulation_steps ${GRAD_ACCUM} \
-   --metric_for_best_model eval_rougeL_for_task639_multi_woz_user_utterance_generation \
-   --add_instruction_replay \
-   --data_replay_freq -1 \
-   --replay_after_n_epoch 0 \
-   --kl_ratio 0.5 \
-   ${OT_SIGN_FLAGS}
-
-###############################################################################
-# Task 8: task1729_personachat_generate_next
-###############################################################################
-echo ""
-echo "===== Task 8/15: task1729_personachat_generate_next (OT-SIGN active) ====="
-PREV_7="${OUTPUT_BASE}/7-task639_multi_woz_user_utterance_generation/saved_weights"
-CUDA_VISIBLE_DEVICES=${GPU_IDS} python src/run_t5.py \
-   --do_train \
-   --do_predict \
-   ${COMMON_FLAGS} \
-   --load_checkpoint_from ${PREV_7}/trans_input.pt \
-   --previous_lora_path ${PREV_1},${PREV_2},${PREV_3},${PREV_4},${PREV_5},${PREV_6},${PREV_7} \
-   --previous_prompt_key_path ${PREV_7}/prompts_keys_till_now.pt \
-   --previous_vmf_signatures_path ${PREV_7}/vmf_signatures.pt \
-   --gen_data_dir generated_data/lora_gen_superni_t5 \
-   --task_config_dir configs/gen_script_superni_order1_t5_configs/task1729_personachat_generate_next \
-   --output_dir ${OUTPUT_BASE}/8-task1729_personachat_generate_next \
-   --per_device_train_batch_size ${BATCH_SIZE} \
-   --gradient_accumulation_steps ${GRAD_ACCUM} \
-   --metric_for_best_model eval_rougeL_for_task1729_personachat_generate_next \
-   --add_instruction_replay \
-   --data_replay_freq -1 \
-   --replay_after_n_epoch 0 \
-   --kl_ratio 0.5 \
-   ${OT_SIGN_FLAGS}
-
-###############################################################################
-# Task 9: task073_commonsenseqa_answer_generation
-###############################################################################
-echo ""
-echo "===== Task 9/15: task073_commonsenseqa_answer_generation (OT-SIGN active) ====="
-PREV_8="${OUTPUT_BASE}/8-task1729_personachat_generate_next/saved_weights"
-CUDA_VISIBLE_DEVICES=${GPU_IDS} python src/run_t5.py \
-   --do_train \
-   --do_predict \
-   ${COMMON_FLAGS} \
-   --load_checkpoint_from ${PREV_8}/trans_input.pt \
-   --previous_lora_path ${PREV_1},${PREV_2},${PREV_3},${PREV_4},${PREV_5},${PREV_6},${PREV_7},${PREV_8} \
-   --previous_prompt_key_path ${PREV_8}/prompts_keys_till_now.pt \
-   --previous_vmf_signatures_path ${PREV_8}/vmf_signatures.pt \
-   --gen_data_dir generated_data/lora_gen_superni_t5 \
-   --task_config_dir configs/gen_script_superni_order1_t5_configs/task073_commonsenseqa_answer_generation \
-   --output_dir ${OUTPUT_BASE}/9-task073_commonsenseqa_answer_generation \
-   --per_device_train_batch_size ${BATCH_SIZE} \
-   --gradient_accumulation_steps ${GRAD_ACCUM} \
-   --metric_for_best_model eval_rougeL_for_task073_commonsenseqa_answer_generation \
-   --add_instruction_replay \
-   --data_replay_freq -1 \
-   --replay_after_n_epoch 0 \
-   --kl_ratio 0.5 \
-   ${OT_SIGN_FLAGS}
-
-###############################################################################
-# Task 10: task1590_diplomacy_text_generation
-###############################################################################
-echo ""
-echo "===== Task 10/15: task1590_diplomacy_text_generation (OT-SIGN active) ====="
-PREV_9="${OUTPUT_BASE}/9-task073_commonsenseqa_answer_generation/saved_weights"
-CUDA_VISIBLE_DEVICES=${GPU_IDS} python src/run_t5.py \
-   --do_train \
-   --do_predict \
-   ${COMMON_FLAGS} \
-   --load_checkpoint_from ${PREV_9}/trans_input.pt \
-   --previous_lora_path ${PREV_1},${PREV_2},${PREV_3},${PREV_4},${PREV_5},${PREV_6},${PREV_7},${PREV_8},${PREV_9} \
-   --previous_prompt_key_path ${PREV_9}/prompts_keys_till_now.pt \
-   --previous_vmf_signatures_path ${PREV_9}/vmf_signatures.pt \
-   --gen_data_dir generated_data/lora_gen_superni_t5 \
-   --task_config_dir configs/gen_script_superni_order1_t5_configs/task1590_diplomacy_text_generation \
-   --output_dir ${OUTPUT_BASE}/10-task1590_diplomacy_text_generation \
-   --per_device_train_batch_size ${BATCH_SIZE} \
-   --gradient_accumulation_steps ${GRAD_ACCUM} \
-   --metric_for_best_model eval_rougeL_for_task1590_diplomacy_text_generation \
-   --add_instruction_replay \
-   --data_replay_freq -1 \
-   --replay_after_n_epoch 0 \
-   --kl_ratio 0.5 \
-   ${OT_SIGN_FLAGS}
-
-###############################################################################
-# Task 11: task748_glucose_reverse_cause_event_detection
-###############################################################################
-echo ""
-echo "===== Task 11/15: task748_glucose_reverse_cause_event_detection (OT-SIGN active) ====="
-PREV_10="${OUTPUT_BASE}/10-task1590_diplomacy_text_generation/saved_weights"
-CUDA_VISIBLE_DEVICES=${GPU_IDS} python src/run_t5.py \
-   --do_train \
-   --do_predict \
-   ${COMMON_FLAGS} \
-   --load_checkpoint_from ${PREV_10}/trans_input.pt \
-   --previous_lora_path ${PREV_1},${PREV_2},${PREV_3},${PREV_4},${PREV_5},${PREV_6},${PREV_7},${PREV_8},${PREV_9},${PREV_10} \
-   --previous_prompt_key_path ${PREV_10}/prompts_keys_till_now.pt \
-   --previous_vmf_signatures_path ${PREV_10}/vmf_signatures.pt \
-   --gen_data_dir generated_data/lora_gen_superni_t5 \
-   --task_config_dir configs/gen_script_superni_order1_t5_configs/task748_glucose_reverse_cause_event_detection \
-   --output_dir ${OUTPUT_BASE}/11-task748_glucose_reverse_cause_event_detection \
-   --per_device_train_batch_size ${BATCH_SIZE} \
-   --gradient_accumulation_steps ${GRAD_ACCUM} \
-   --metric_for_best_model eval_rougeL_for_task748_glucose_reverse_cause_event_detection \
-   --add_instruction_replay \
-   --data_replay_freq -1 \
-   --replay_after_n_epoch 0 \
-   --kl_ratio 0.5 \
-   ${OT_SIGN_FLAGS}
-
-###############################################################################
-# Task 12: task511_reddit_tifu_long_text_summarization
-###############################################################################
-echo ""
-echo "===== Task 12/15: task511_reddit_tifu_long_text_summarization (OT-SIGN active) ====="
-PREV_11="${OUTPUT_BASE}/11-task748_glucose_reverse_cause_event_detection/saved_weights"
-CUDA_VISIBLE_DEVICES=${GPU_IDS} python src/run_t5.py \
-   --do_train \
-   --do_predict \
-   ${COMMON_FLAGS} \
-   --load_checkpoint_from ${PREV_11}/trans_input.pt \
-   --previous_lora_path ${PREV_1},${PREV_2},${PREV_3},${PREV_4},${PREV_5},${PREV_6},${PREV_7},${PREV_8},${PREV_9},${PREV_10},${PREV_11} \
-   --previous_prompt_key_path ${PREV_11}/prompts_keys_till_now.pt \
-   --previous_vmf_signatures_path ${PREV_11}/vmf_signatures.pt \
-   --gen_data_dir generated_data/lora_gen_superni_t5 \
-   --task_config_dir configs/gen_script_superni_order1_t5_configs/task511_reddit_tifu_long_text_summarization \
-   --output_dir ${OUTPUT_BASE}/12-task511_reddit_tifu_long_text_summarization \
-   --per_device_train_batch_size ${BATCH_SIZE} \
-   --gradient_accumulation_steps ${GRAD_ACCUM} \
-   --metric_for_best_model eval_rougeL_for_task511_reddit_tifu_long_text_summarization \
-   --add_instruction_replay \
-   --data_replay_freq -1 \
-   --replay_after_n_epoch 0 \
-   --kl_ratio 0.5 \
-   ${OT_SIGN_FLAGS}
-
-###############################################################################
-# Task 13: task591_sciq_answer_generation
-###############################################################################
-echo ""
-echo "===== Task 13/15: task591_sciq_answer_generation (OT-SIGN active) ====="
-PREV_12="${OUTPUT_BASE}/12-task511_reddit_tifu_long_text_summarization/saved_weights"
-CUDA_VISIBLE_DEVICES=${GPU_IDS} python src/run_t5.py \
-   --do_train \
-   --do_predict \
-   ${COMMON_FLAGS} \
-   --load_checkpoint_from ${PREV_12}/trans_input.pt \
-   --previous_lora_path ${PREV_1},${PREV_2},${PREV_3},${PREV_4},${PREV_5},${PREV_6},${PREV_7},${PREV_8},${PREV_9},${PREV_10},${PREV_11},${PREV_12} \
-   --previous_prompt_key_path ${PREV_12}/prompts_keys_till_now.pt \
-   --previous_vmf_signatures_path ${PREV_12}/vmf_signatures.pt \
-   --gen_data_dir generated_data/lora_gen_superni_t5 \
-   --task_config_dir configs/gen_script_superni_order1_t5_configs/task591_sciq_answer_generation \
-   --output_dir ${OUTPUT_BASE}/13-task591_sciq_answer_generation \
-   --per_device_train_batch_size ${BATCH_SIZE} \
-   --gradient_accumulation_steps ${GRAD_ACCUM} \
-   --metric_for_best_model eval_rougeL_for_task591_sciq_answer_generation \
-   --add_instruction_replay \
-   --data_replay_freq -1 \
-   --replay_after_n_epoch 0 \
-   --kl_ratio 0.5 \
-   ${OT_SIGN_FLAGS}
-
-###############################################################################
-# Task 14: task1687_sentiment140_classification
-###############################################################################
-echo ""
-echo "===== Task 14/15: task1687_sentiment140_classification (OT-SIGN active) ====="
-PREV_13="${OUTPUT_BASE}/13-task591_sciq_answer_generation/saved_weights"
-CUDA_VISIBLE_DEVICES=${GPU_IDS} python src/run_t5.py \
-   --do_train \
-   --do_predict \
-   ${COMMON_FLAGS} \
-   --load_checkpoint_from ${PREV_13}/trans_input.pt \
-   --previous_lora_path ${PREV_1},${PREV_2},${PREV_3},${PREV_4},${PREV_5},${PREV_6},${PREV_7},${PREV_8},${PREV_9},${PREV_10},${PREV_11},${PREV_12},${PREV_13} \
-   --previous_prompt_key_path ${PREV_13}/prompts_keys_till_now.pt \
-   --previous_vmf_signatures_path ${PREV_13}/vmf_signatures.pt \
-   --gen_data_dir generated_data/lora_gen_superni_t5 \
-   --task_config_dir configs/gen_script_superni_order1_t5_configs/task1687_sentiment140_classification \
-   --output_dir ${OUTPUT_BASE}/14-task1687_sentiment140_classification \
-   --per_device_train_batch_size ${BATCH_SIZE} \
-   --gradient_accumulation_steps ${GRAD_ACCUM} \
-   --metric_for_best_model eval_rougeL_for_task1687_sentiment140_classification \
-   --add_instruction_replay \
-   --data_replay_freq -1 \
-   --replay_after_n_epoch 0 \
-   --kl_ratio 0.5 \
-   ${OT_SIGN_FLAGS}
-
-###############################################################################
-# Task 15: task875_emotion_classification
-###############################################################################
-echo ""
-echo "===== Task 15/15: task875_emotion_classification (OT-SIGN active) ====="
-PREV_14="${OUTPUT_BASE}/14-task1687_sentiment140_classification/saved_weights"
-CUDA_VISIBLE_DEVICES=${GPU_IDS} python src/run_t5.py \
-   --do_train \
-   --do_predict \
-   ${COMMON_FLAGS} \
-   --load_checkpoint_from ${PREV_14}/trans_input.pt \
-   --previous_lora_path ${PREV_1},${PREV_2},${PREV_3},${PREV_4},${PREV_5},${PREV_6},${PREV_7},${PREV_8},${PREV_9},${PREV_10},${PREV_11},${PREV_12},${PREV_13},${PREV_14} \
-   --previous_prompt_key_path ${PREV_14}/prompts_keys_till_now.pt \
-   --previous_vmf_signatures_path ${PREV_14}/vmf_signatures.pt \
-   --gen_data_dir generated_data/lora_gen_superni_t5 \
-   --task_config_dir configs/gen_script_superni_order1_t5_configs/task875_emotion_classification \
-   --output_dir ${OUTPUT_BASE}/15-task875_emotion_classification \
-   --per_device_train_batch_size ${BATCH_SIZE} \
-   --gradient_accumulation_steps ${GRAD_ACCUM} \
-   --metric_for_best_model eval_rougeL_for_task875_emotion_classification \
-   --add_instruction_replay \
-   --data_replay_freq -1 \
-   --replay_after_n_epoch 0 \
-   --kl_ratio 0.5 \
-   ${OT_SIGN_FLAGS}
-
-echo ""
-echo "============================================="
-echo "OT-SIGN Training Complete!"
-echo "Logs: logs_and_outputs/${RUN_NAME}/ot_sign_logs/"
-echo "============================================="

gainlora_OT_vMF/src/__pycache__/cl_collator.cpython-312.pyc

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:7ac24a521ab05c5f986666baca176d46a7b716692db92c57ce86c0b150597b6e
-size 10116

gainlora_OT_vMF/src/__pycache__/cl_dataset.cpython-312.pyc

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:f2e7871bd4488d77a1beca52f07be680fe96e2580847792047caf3d76364750d
-size 13159

gainlora_OT_vMF/src/__pycache__/cl_trainer_gainlora_inflora.cpython-312.pyc

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:9751f103b0e86c9b3b8f269dae372351263cb0824656c821c90a8254847ee1e4
-size 90854

gainlora_OT_vMF/src/__pycache__/cl_trainer_gainlora_inflora_llama.cpython-312.pyc

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:d36384d520c11413ee49678a86ebc5bdc3671c64ea4b8ea49631c4ef5037d9d0
-size 85068

gainlora_OT_vMF/src/__pycache__/cl_trainer_gainlora_olora.cpython-312.pyc

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:370b7649906c9cf60e7fb0fd8839938433c42dbfcae79c7ff3e635313b62dcdf
-size 76727

gainlora_OT_vMF/src/__pycache__/cl_trainer_gainlora_olora_llama.cpython-312.pyc

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:f1680b3b17975f4de053e9be0f7eab2ef7902865cbe78059677cd3e02a1b63c2
-size 76991

gainlora_OT_vMF/src/__pycache__/cl_trainer_inflora.cpython-312.pyc

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:77eefddbbd5e041b41abe092f7004787fd48805b2c8608eaef3278fdab1812bd
-size 39965

gainlora_OT_vMF/src/__pycache__/cl_trainer_inflora_llama.cpython-312.pyc

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:4fa7568e94200b9196177ed47ea2c4d203ced2796d4f68df9d737b3f8c74fbd4
-size 41975

gainlora_OT_vMF/src/__pycache__/cl_trainer_olora.cpython-312.pyc

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:5d0394c51dfd84ef4fde8f259a4bd2a5bfba5fc5ded9874c7e48ec016335154e
-size 29030

gainlora_OT_vMF/src/__pycache__/cl_trainer_olora_llama.cpython-312.pyc

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:3e7defc47276232e838f31b4b8dce26c968c00b772590be8a2105a77190ffaa6
-size 29042

gainlora_OT_vMF/src/__pycache__/compat_transformers.cpython-312.pyc

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:e1dfbaa2911f50bbc0919979a7abaebff3700e1c54651e42f2c19bf2c4f8e1b5
-size 6959

gainlora_OT_vMF/src/__pycache__/llama_gainlora_inflora.cpython-312.pyc

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:4bd9b3d05288494ad72b0151d68a39e9381752a5ef49819c9f7576d87a27ac4b
-size 83793

gainlora_OT_vMF/src/__pycache__/llama_inflora.cpython-312.pyc

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:df016d6843864aa718d9b408bef534b204cdfd89b6ab8a3a65666f8dc0159245
-size 74109

gainlora_OT_vMF/src/__pycache__/ot_sign_utils.cpython-312.pyc

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:55761c6d084de04d7ee473dccb92cdffe94d819ce33435580a56fc28297df409
-size 13082

gainlora_OT_vMF/src/__pycache__/ot_sign_utils.cpython-313.pyc

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:64711cfa682645e7d2df1e923d09f0dc35d4ffb8c45807972df75a4c1c1755a1
-size 12377

gainlora_OT_vMF/src/__pycache__/run_llama.cpython-312.pyc

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:ff4021939dae2e3c66abfccb78c774324ec19de43dee71d5c8838fd7e37167c2
-size 44561

gainlora_OT_vMF/src/__pycache__/run_logger.cpython-313.pyc

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:96c719d7c1cf1f2bd4dddc4808b5f512a221ec5a4f8ebd1a0c60d4069216339f
-size 5510

gainlora_OT_vMF/src/__pycache__/run_t5.cpython-312.pyc

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:b490149aa88456c921dbecd66d0b6119a7a6be4cdb8634f4d5efcb2d0dad43e7
-size 48700

gainlora_OT_vMF/src/__pycache__/t5_gainlora_inflora.cpython-312.pyc

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:413a2c9a942c77bbc879103ca0c963de3a66d92b841aa6216a3239b44cf43665
-size 125803

gainlora_OT_vMF/src/__pycache__/t5_inflora.cpython-312.pyc

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:8279a00efc964668a6729e13dcd430f08b4eaf1c1ee5ae31fffe31da9922bb9a
-size 111402

gainlora_OT_vMF/src/compat_transformers.py

@@ -1,206 +0,0 @@
-"""
-Compatibility shims for transformers 4.x APIs removed in transformers 5.0.
-
-This module provides fallback definitions for all symbols and attributes
-that were removed from the transformers library in version 5.0, allowing
-the trainer code (originally written for transformers ~4.28) to run
-without modification on transformers 5.0+.
-
-Usage:
-    from compat_transformers import (
-        ShardedDDPOption, is_sagemaker_mp_enabled, smp_forward_backward,
-        deepspeed_init, deepspeed_load_checkpoint, HPSearchBackend,
-        patch_trainer_compat,
-    )
-    
-    # In your Trainer subclass __init__:
-    class MyTrainer(Seq2SeqTrainer):
-        def __init__(self, *args, **kwargs):
-            super().__init__(*args, **kwargs)
-            patch_trainer_compat(self)
-"""
-
-from enum import Enum
-
-# ============================================================================
-# ShardedDDPOption (removed in transformers 5.0, replaced by FSDP)
-# ============================================================================
-try:
-    from transformers.trainer import ShardedDDPOption
-except ImportError:
-    class ShardedDDPOption(str, Enum):
-        SIMPLE = "simple"
-        ZERO_DP_2 = "zero_dp_2"
-        ZERO_DP_3 = "zero_dp_3"
-        OFFLOAD = "offload"
-
-# ============================================================================
-# is_sagemaker_mp_enabled (removed in transformers 5.0)
-# ============================================================================
-try:
-    from transformers.trainer import is_sagemaker_mp_enabled
-except ImportError:
-    def is_sagemaker_mp_enabled():
-        return False
-
-# ============================================================================
-# smp_forward_backward / smp_forward_only / smp_nested_tensor_size
-# (SageMaker Model Parallel — removed in transformers 5.0)
-# ============================================================================
-try:
-    from transformers.trainer import smp_forward_backward
-except ImportError:
-    def smp_forward_backward(model, inputs, gradient_accumulation_steps=1):
-        raise RuntimeError("SageMaker Model Parallel is not available")
-
-try:
-    from transformers.trainer import smp_forward_only
-except ImportError:
-    def smp_forward_only(model, inputs):
-        raise RuntimeError("SageMaker Model Parallel is not available")
-
-try:
-    from transformers.trainer import smp_nested_tensor_size
-except ImportError:
-    def smp_nested_tensor_size(tensor):
-        return tensor.size()
-
-# ============================================================================
-# deepspeed_init (moved/changed in transformers 5.0)
-# ============================================================================
-try:
-    from transformers.integrations import deepspeed_init
-except ImportError:
-    try:
-        from transformers.deepspeed import deepspeed_init
-    except ImportError:
-        def deepspeed_init(trainer, num_training_steps, resume_from_checkpoint=None, inference=False):
-            raise RuntimeError("DeepSpeed is not available in this transformers version")
-
-# ============================================================================
-# deepspeed_load_checkpoint (moved/changed in transformers 5.0)
-# ============================================================================
-try:
-    from transformers.integrations import deepspeed_load_checkpoint
-except ImportError:
-    try:
-        from transformers.deepspeed import deepspeed_load_checkpoint
-    except ImportError:
-        def deepspeed_load_checkpoint(deepspeed_engine, checkpoint_path):
-            raise RuntimeError("DeepSpeed is not available in this transformers version")
-
-# ============================================================================
-# HPSearchBackend (removed in transformers 5.0)
-# ============================================================================
-try:
-    from transformers.trainer import HPSearchBackend
-except ImportError:
-    try:
-        from transformers.trainer_utils import HPSearchBackend
-    except ImportError:
-        class HPSearchBackend(str, Enum):
-            OPTUNA = "optuna"
-            RAY = "ray"
-            SIGOPT = "sigopt"
-            WANDB = "wandb"
-
-# ============================================================================
-# is_apex_available (removed in transformers 5.0)
-# ============================================================================
-try:
-    from transformers.utils import is_apex_available
-except ImportError:
-    def is_apex_available():
-        return False
-
-# ============================================================================
-# ALL_LAYERNORM_LAYERS (removed from transformers.trainer in 5.0)
-# ============================================================================
-try:
-    from transformers.trainer import ALL_LAYERNORM_LAYERS
-except ImportError:
-    try:
-        from transformers.pytorch_utils import ALL_LAYERNORM_LAYERS
-    except ImportError:
-        import torch.nn as _nn
-        ALL_LAYERNORM_LAYERS = [_nn.LayerNorm]
-
-# ============================================================================
-# IS_SAGEMAKER_MP_POST_1_10 (SageMaker detection constant — removed in transformers 5.0)
-# ============================================================================
-try:
-    from transformers.trainer import IS_SAGEMAKER_MP_POST_1_10
-except ImportError:
-    IS_SAGEMAKER_MP_POST_1_10 = False
-
-# ============================================================================
-# is_torch_tpu_available (removed in transformers 5.0, replaced by is_torch_xla_available)
-# ============================================================================
-try:
-    from transformers.utils import is_torch_tpu_available
-except ImportError:
-    try:
-        from transformers.utils import is_torch_xla_available as is_torch_tpu_available
-    except ImportError:
-        def is_torch_tpu_available(check_device=True):
-            return False
-
-
-def patch_trainer_compat(trainer):
-    """
-    Patch a Trainer instance with deprecated attributes that were removed
-    in transformers 5.0. Call this in __init__ after super().__init__().
-    
-    Sets safe defaults for all deprecated attributes:
-    - sharded_ddp = None  (FSDP replaces this)
-    - use_apex = False
-    - do_grad_scaling = False
-    - scaler = None
-    - deepspeed = None (the engine reference)
-    - current_flos = 0
-    - hp_name = None
-    - hp_search_backend = None
-    - is_in_train = False
-    """
-    if not hasattr(trainer, 'sharded_ddp'):
-        trainer.sharded_ddp = None
-    if not hasattr(trainer, 'fsdp'):
-        trainer.fsdp = None
-    if not hasattr(trainer, 'use_apex'):
-        trainer.use_apex = False
-    if not hasattr(trainer, 'do_grad_scaling'):
-        trainer.do_grad_scaling = False
-    if not hasattr(trainer, 'scaler'):
-        trainer.scaler = None
-    if not hasattr(trainer, 'deepspeed'):
-        trainer.deepspeed = None
-    if not hasattr(trainer, 'current_flos'):
-        trainer.current_flos = 0
-    if not hasattr(trainer, 'hp_name'):
-        trainer.hp_name = None
-    if not hasattr(trainer, 'hp_search_backend'):
-        trainer.hp_search_backend = None
-    if not hasattr(trainer, 'is_in_train'):
-        trainer.is_in_train = False
-    if not hasattr(trainer, 'is_deepspeed_enabled'):
-        trainer.is_deepspeed_enabled = False
-    if not hasattr(trainer, '_trial'):
-        trainer._trial = None
-    if not hasattr(trainer, 'model_wrapped'):
-        trainer.model_wrapped = getattr(trainer, 'model', None)
-
-def patch_args_compat(args):
-    """
-    Patch a TrainingArguments instance with deprecated attributes that were removed
-    in transformers 5.0. Call this in Trainer.__init__ to ensure args has all needed fields.
-    
-    - past_index: -1 (default, no cached predictions)
-    """
-    if not hasattr(args, 'past_index'):
-        args.past_index = -1
-
-    # GainLoRA has parameters (prompt_key, previous_prompts_keys, vmf_signatures)
-    # not used in every forward pass. Transformers 5.0 sets find_unused_parameters=False
-    # when gradient_checkpointing=True, which causes DDP reduction errors.
-    if getattr(args, 'ddp_find_unused_parameters', None) is None:
-        args.ddp_find_unused_parameters = True

gainlora_OT_vMF/src/compute_ap_ft.py

@@ -1,242 +0,0 @@
-#!/usr/bin/env python3
-"""
-compute_ap_ft.py — Compute AP and FT from training output directories
-======================================================================
-Usage:
-    python compute_ap_ft.py \\
-        --output_base logs_and_outputs/ot_sign_order1/outputs \\
-        --task_order "task1572_samsum_summary,task363_sst2_polarity_classification,..." \\
-        --method_name "OT-SIGN+GainLoRA(InfLoRA)"
-
-AP  = (1/T) * Σ_j R[T-1][j]            — avg score on ALL tasks after training last task
-FT  = (1/(T-1)) * Σ_j (R[j][j] - R[T-1][j])  — avg performance DROP from peak
-
-Result matrix R[i][j]:
-  R[i][j] = score on task j right after model was trained on task i
-  Diagonal R[i][i] = peak performance on task i
-  Last row R[T-1][j] = final performance (what we report as AP)
-
-Score file locations (HuggingFace Trainer):
-  {output_base}/{i+1}-{task_name}/predict_results.json   → has all task scores
-  {output_base}/{i+1}-{task_name}/eval_results.json     → used as fallback peak
-"""
-
-import argparse
-import json
-import os
-import re
-import sys
-
-
-# ── Metric key detection ────────────────────────────────────────────────────
-
-def _is_long_benchmark(task_list):
-    long_tasks = {'yelp', 'amazon', 'mnli', 'imdb', 'sst2', 'dbpedia', 'agnews',
-                  'yahoo', 'multirc', 'boolq', 'wic', 'copa', 'qqp', 'rte', 'cb'}
-    return any(t.lower() in long_tasks for t in task_list)
-
-
-def _get_score(metrics, task_name, is_long):
-    """Extract score for `task_name` from a metrics dict."""
-    prefix = "exact_match" if is_long else "rougeL"
-    candidates = [
-        f"predict_{prefix}_for_{task_name}",
-        f"eval_{prefix}_for_{task_name}",
-        f"predict_{prefix}",
-        f"eval_{prefix}",
-    ]
-    for key in candidates:
-        if key in metrics:
-            v = float(metrics[key])
-            # rougeL from compute_metrics is 0-1 scale → convert to %
-            if v <= 1.0 and "rouge" in key.lower():
-                v = v * 100.0
-            return round(v, 2)
-
-    # broad fallback: any key mentioning the task name
-    for k, v in metrics.items():
-        if task_name in k and isinstance(v, (int, float)):
-            v = float(v)
-            if v <= 1.0 and "rouge" in k.lower():
-                v = v * 100.0
-            return round(v, 2)
-    return None
-
-
-def _load_json_file(path):
-    if not os.path.exists(path):
-        return {}
-    with open(path) as f:
-        return json.load(f)
-
-
-# ── Result matrix builder ────────────────────────────────────────────────────
-
-def build_result_matrix(output_base, task_order, is_long):
-    """
-    R[i][j] = score on task j after training on task i.
-    R[i][i] = peak performance on task i (from predict_results when trained on i).
-    """
-    T = len(task_order)
-    R = {}
-
-    for i, task_i in enumerate(task_order):
-        # Find output directory for this task (numbered 1-based)
-        task_dir = _find_task_dir(output_base, i + 1, task_i)
-        if task_dir is None:
-            print(f"  [WARN] Directory for task {i+1} ({task_i}) not found — skipping", file=sys.stderr)
-            continue
-
-        predict_file = os.path.join(task_dir, "predict_results.json")
-        metrics = _load_json_file(predict_file)
-
-        if not metrics:
-            # Try eval_results.json as fallback
-            metrics = _load_json_file(os.path.join(task_dir, "eval_results.json"))
-
-        if not metrics:
-            print(f"  [WARN] No metrics found in {task_dir}", file=sys.stderr)
-            continue
-
-        R[i] = {}
-        # Extract score for EACH task visible at this training step (tasks 0..i)
-        for j in range(i + 1):
-            score = _get_score(metrics, task_order[j], is_long)
-            if score is not None:
-                R[i][j] = score
-
-    return R
-
-
-def _find_task_dir(output_base, task_num, task_name):
-    """Locate task output dir robustly: tries exact match, then prefix match."""
-    # Try exact name: "1-task1572_samsum_summary"
-    candidate = os.path.join(output_base, f"{task_num}-{task_name}")
-    if os.path.isdir(candidate):
-        return candidate
-
-    # Try prefix match
-    if os.path.isdir(output_base):
-        prefix = f"{task_num}-"
-        matches = [d for d in os.listdir(output_base)
-                   if d.startswith(prefix) and os.path.isdir(os.path.join(output_base, d))]
-        if matches:
-            return os.path.join(output_base, sorted(matches)[0])
-    return None
-
-
-# ── AP / FT computation ───────────────────────────────────────────────────────
-
-def compute_ap_ft(R, task_order):
-    """
-    Args:
-        R: dict {i: {j: score}} — result matrix
-        task_order: list of task names
-    Returns:
-        ap, ft as floats (already rounded to 2 dp)
-    """
-    T = len(task_order)
-    final_row = T - 1
-
-    # AP: average over final row
-    final_scores = [R.get(final_row, {}).get(j) for j in range(T)]
-    valid_final = [s for s in final_scores if s is not None]
-    ap = round(sum(valid_final) / len(valid_final), 2) if valid_final else 0.0
-
-    # FT: mean drop from diagonal to final row (exclude last task by convention)
-    drops = []
-    for j in range(T - 1):
-        diag  = R.get(j, {}).get(j)
-        final = R.get(final_row, {}).get(j)
-        if diag is not None and final is not None:
-            drops.append(diag - final)
-    ft = round(sum(drops) / len(drops), 2) if drops else 0.0
-
-    return ap, ft
-
-
-# ── Output formatter ──────────────────────────────────────────────────────────
-
-def print_comparison_table(R, task_order, method_name, ap, ft):
-    T = len(task_order)
-    final_row = T - 1
-    sep = "─" * 72
-
-    print(f"\n{'═' * 72}")
-    print(f"  {method_name}")
-    print(f"{'═' * 72}")
-    print(f"  {'#':<3} {'Task':<46} {'Peak':>6}  {'Final':>6}  {'Drop':>6}")
-    print(sep)
-
-    for j, tname in enumerate(task_order):
-        diag  = R.get(j, {}).get(j)
-        final = R.get(final_row, {}).get(j)
-        drop  = round(diag - final, 2) if diag is not None and final is not None else None
-        d_str = f"{diag:.2f}"  if diag  is not None else " ——"
-        f_str = f"{final:.2f}" if final is not None else " ——"
-        r_str = f"{drop:.2f}"  if drop  is not None else " ——"
-        print(f"  {j+1:<3} {tname:<46} {d_str:>6}  {f_str:>6}  {r_str:>6}")
-
-    print(sep)
-    print(f"  AP  = {ap:>6.2f}   │   FT = {ft:>5.2f}")
-    print(f"{'═' * 72}\n")
-
-
-def save_results_json(R, task_order, method_name, ap, ft, output_base):
-    out = {
-        "method": method_name,
-        "ap": ap,
-        "ft": ft,
-        "per_task": {}
-    }
-    T = len(task_order)
-    final_row = T - 1
-    for j, tname in enumerate(task_order):
-        out["per_task"][tname] = {
-            "peak":  R.get(j, {}).get(j),
-            "final": R.get(final_row, {}).get(j),
-        }
-
-    result_path = os.path.join(output_base, "..", "ap_ft_result.json")
-    result_path = os.path.normpath(result_path)
-    with open(result_path, 'w') as f:
-        json.dump(out, f, indent=2)
-    print(f"[compute_ap_ft] Saved results to {result_path}")
-    return result_path
-
-
-# ── Main ─────────────────────────────────────────────────────────────────────
-
-def main():
-    parser = argparse.ArgumentParser(description="Compute AP/FT from GainLoRA output directories")
-    parser.add_argument("--output_base", required=True,
-                        help="Path to the outputs/ directory containing task subdirectories")
-    parser.add_argument("--task_order", required=True,
-                        help="Comma-separated list of task names in training order")
-    parser.add_argument("--method_name", default="OT-SIGN+GainLoRA",
-                        help="Label shown in the result table")
-    parser.add_argument("--save", action="store_true",
-                        help="Also save results to ap_ft_result.json")
-    args = parser.parse_args()
-
-    task_order = [t.strip() for t in args.task_order.split(',') if t.strip()]
-    is_long = _is_long_benchmark(task_order)
-
-    print(f"[compute_ap_ft] Benchmark type: {'long' if is_long else 'superni'}")
-    print(f"[compute_ap_ft] Tasks: {len(task_order)}  |  Output base: {args.output_base}")
-
-    R = build_result_matrix(args.output_base, task_order, is_long)
-
-    if not R:
-        print("[compute_ap_ft] ERROR: No results found. Check --output_base path.", file=sys.stderr)
-        sys.exit(1)
-
-    ap, ft = compute_ap_ft(R, task_order)
-    print_comparison_table(R, task_order, args.method_name, ap, ft)
-
-    if args.save:
-        save_results_json(R, task_order, args.method_name, ap, ft, args.output_base)
-
-
-if __name__ == "__main__":
-    main()

gainlora_OT_vMF/src/ot_sign_utils.py

@@ -1,289 +0,0 @@
-"""
-OT-SIGN: Statistical Signatures + Optimal Transport Routing for GainLoRA
-=========================================================================
-Utility functions for:
-  1. vMF (von Mises-Fisher) knowledge signatures
-  2. Sinkhorn OT routing with vMF log-likelihood cost
-  3. Anti-drift and anti-invasion losses
-
-Author: OT-SIGN implementation for GainLoRA continual learning
-"""
-
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-import math
-
-
-# ============================================================================
-# 1. Sinkhorn Optimal Transport (log-domain for numerical stability)
-# ============================================================================
-
-def sinkhorn_log(C, epsilon=0.05, n_iter=10):
-    """
-    Log-domain Sinkhorn algorithm for entropic OT.
-    
-    Args:
-        C: Cost matrix of shape (B, N) — cost of assigning sample b to expert n
-        epsilon: Entropic regularization strength (lower = sharper assignment)
-        n_iter: Number of Sinkhorn iterations
-        
-    Returns:
-        Transport plan of shape (B, N), rows sum to ~1
-    """
-    B, N = C.shape
-    
-    # Log kernel: K = exp(-C / epsilon)
-    log_K = -C / epsilon  # (B, N)
-    
-    # Initialize dual variables
-    u = torch.zeros(B, device=C.device, dtype=C.dtype)
-    v = torch.zeros(N, device=C.device, dtype=C.dtype)
-    
-    for _ in range(n_iter):
-        # Update u (row normalization in log domain)
-        u = -torch.logsumexp(log_K + v.unsqueeze(0), dim=1)  # (B,)
-        # Update v (column normalization in log domain)
-        v = -torch.logsumexp(log_K + u.unsqueeze(1), dim=0)  # (N,)
-    
-    # Compute transport plan
-    log_pi = log_K + u.unsqueeze(1) + v.unsqueeze(0)  # (B, N)
-    pi = log_pi.exp()
-    
-    # Normalize rows to sum to 1 (for routing weights)
-    pi = pi / (pi.sum(dim=1, keepdim=True) + 1e-8)
-    
-    return pi  # (B, N)
-
-
-# ============================================================================
-# 2. vMF Parameter Estimation (MLE)
-# ============================================================================
-
-def compute_vmf_params(features, d_model, kappa_min=0.1, kappa_max=50.0):
-    """
-    Compute vMF MLE parameters from features on unit sphere.
-    
-    Args:
-        features: Tensor of shape (num_samples, d) — L2-normalized features
-        d_model: Feature dimension
-        kappa_min: Minimum allowed kappa (prevents numerical issues)
-        kappa_max: Maximum allowed kappa (prevents overflow)
-        
-    Returns:
-        mu: Mean direction (d,) — unit vector
-        kappa: Concentration parameter — scalar tensor
-    """
-    # Mean resultant vector
-    x_bar = features.mean(dim=0)  # (d,)
-    r_bar = x_bar.norm()  # scalar — mean resultant length
-    
-    # Mean direction
-    mu = F.normalize(x_bar, dim=0)  # (d,)
-    
-    # Concentration parameter (Banerjee et al. 2005 approximation)
-    d = d_model
-    r_bar_clamped = r_bar.clamp(min=1e-6, max=1.0 - 1e-6)
-    kappa = r_bar_clamped * (d - r_bar_clamped ** 2) / (1 - r_bar_clamped ** 2)
-    
-    # Clamp kappa for numerical stability
-    kappa = kappa.clamp(min=kappa_min, max=kappa_max)
-    
-    return mu.detach(), kappa.detach()
-
-
-# ============================================================================
-# 3. Cost Matrix Construction
-# ============================================================================
-
-def vmf_cost_matrix(x, vmf_signatures, prompt_key=None, default_kappa=10.0):
-    """
-    Build OT cost matrix from vMF signatures.
-    
-    ORDERING: Current task FIRST, then previous tasks sorted by task_id.
-    This matches GainLoRA's agg_lora_states ordering:
-      concat_q = cat([cur_lora, prev_lora_0, prev_lora_1, ...])
-    
-    For current task: C[b, 0] = -default_kappa * (prompt_key · x_b)
-    For previous tasks: C[b, t+1] = -kappa_t * (mu_t · x_b)
-    
-    Args:
-        x: Normalized input features (B, d)
-        vmf_signatures: Dict {task_id: (mu, kappa)} for previous tasks
-        prompt_key: Current task's prompt key (1, d) or None
-        default_kappa: Kappa value used for the current task's proxy
-        
-    Returns:
-        C: Cost matrix (B, N_total) where N_total = 1 + len(signatures)
-           Position 0 = current task, positions 1..N-1 = prev tasks in order
-    """
-    device = x.device
-    dtype = x.dtype
-    costs = []
-    
-    # Position 0: Cost for current task (using prompt_key as proxy direction)
-    if prompt_key is not None:
-        pk = prompt_key.squeeze()  # (d,)
-        pk = F.normalize(pk, dim=-1)
-        dot_product = (x * pk.unsqueeze(0)).sum(dim=-1)  # (B,)
-        default_kappa_t = torch.tensor(default_kappa, device=device, dtype=dtype)
-        cost_cur = -default_kappa_t * dot_product  # (B,)
-        costs.append(cost_cur)
-
-    # Positions 1..N: Cost from vMF signatures (previous tasks) — sorted by task_id
-    for task_id in sorted(vmf_signatures.keys()):
-        mu_t, kappa_t = vmf_signatures[task_id]
-        mu_t = mu_t.to(device=device, dtype=dtype)
-        kappa_t_val = kappa_t.to(device=device, dtype=dtype) if isinstance(kappa_t, torch.Tensor) else torch.tensor(kappa_t, device=device, dtype=dtype)
-        
-        # vMF negative log-likelihood (ignoring constant normalization)
-        dot_product = (x * mu_t.unsqueeze(0)).sum(dim=-1)  # (B,)
-        cost_t = -kappa_t_val * dot_product  # (B,) — lower cost = higher likelihood
-        costs.append(cost_t)
-    
-    if len(costs) == 0:
-        raise ValueError("No signatures or prompt_key provided for cost matrix")
-    
-    C = torch.stack(costs, dim=1)  # (B, N_total)
-    return C
-
-
-# ============================================================================
-# 4. Anti-Drift Loss
-# ============================================================================
-
-def compute_anti_drift_loss(model_encoder, ref_trans_input_state, input_ids, attention_mask):
-    """
-    MSE between current and reference trans_input outputs on replay data.
-    Protects the shared MLP from drifting away from old task representations.
-    
-    Args:
-        model_encoder: The model's encoder (has embed_tokens, trans_input)
-        ref_trans_input_state: Frozen state dict of trans_input from previous task
-        input_ids: Replay input token IDs (B, seq_len)
-        attention_mask: Replay attention mask (B, seq_len)
-        
-    Returns:
-        drift_loss: Scalar MSE loss
-    """
-    # Get current trans_input output
-    with torch.no_grad():
-        embeddings = model_encoder.embed_tokens(input_ids)
-    avg_emb = (attention_mask.unsqueeze(-1) * embeddings).mean(dim=1, keepdim=True)  # (B, 1, d)
-    
-    # Current trans_input output
-    medium_curr = model_encoder.trans_input[1](model_encoder.trans_input[0](avg_emb))
-    x_curr = model_encoder.trans_input[3](model_encoder.trans_input[2](medium_curr))
-    x_curr = F.normalize(x_curr, dim=-1)  # (B, 1, d)
-    
-    # Reference trans_input output (frozen copy)
-    ref_trans_input = nn.Sequential(
-        nn.Linear(model_encoder.trans_input[0].in_features, model_encoder.trans_input[0].out_features, bias=False),
-        nn.SiLU(),
-        nn.Linear(model_encoder.trans_input[2].in_features, model_encoder.trans_input[2].out_features, bias=False),
-        nn.SiLU(),
-    ).to(device=avg_emb.device, dtype=avg_emb.dtype)
-    ref_trans_input.load_state_dict(ref_trans_input_state)
-    for p in ref_trans_input.parameters():
-        p.requires_grad = False
-    
-    with torch.no_grad():
-        medium_ref = ref_trans_input[1](ref_trans_input[0](avg_emb))
-        x_ref = ref_trans_input[3](ref_trans_input[2](medium_ref))
-        x_ref = F.normalize(x_ref, dim=-1)  # (B, 1, d)
-    
-    drift_loss = F.mse_loss(x_curr, x_ref)
-    return drift_loss
-
-
-class CachedRefTransInput(nn.Module):
-    """
-    Cached frozen copy of trans_input for efficient anti-drift computation.
-    Avoids recreating nn.Sequential every step.
-    """
-    def __init__(self, trans_input_module):
-        super().__init__()
-        import copy
-        self.ref = copy.deepcopy(trans_input_module)
-        for p in self.ref.parameters():
-            p.requires_grad = False
-    
-    def forward(self, x):
-        with torch.no_grad():
-            medium = self.ref[1](self.ref[0](x))
-            out = self.ref[3](self.ref[2](medium))
-        return F.normalize(out, dim=-1)
-
-
-def compute_anti_drift_loss_cached(model_encoder, ref_trans_input_cached, input_ids, attention_mask):
-    """
-    Efficient anti-drift loss using a pre-cached frozen trans_input.
-    
-    Args:
-        model_encoder: Model encoder with embed_tokens and trans_input
-        ref_trans_input_cached: CachedRefTransInput instance
-        input_ids: Replay input IDs (B, seq_len)
-        attention_mask: Replay attention mask (B, seq_len)
-        
-    Returns:
-        Scalar MSE loss
-    """
-    with torch.no_grad():
-        embeddings = model_encoder.embed_tokens(input_ids)
-    avg_emb = (attention_mask.unsqueeze(-1) * embeddings).mean(dim=1, keepdim=True)
-    
-    # Current trans_input output
-    medium_curr = model_encoder.trans_input[1](model_encoder.trans_input[0](avg_emb))
-    x_curr = model_encoder.trans_input[3](model_encoder.trans_input[2](medium_curr))
-    x_curr = F.normalize(x_curr, dim=-1)
-    
-    # Reference output (frozen)
-    x_ref = ref_trans_input_cached(avg_emb)
-    
-    return F.mse_loss(x_curr, x_ref)
-
-
-# ============================================================================
-# 5. Anti-Invasion Loss
-# ============================================================================
-
-def compute_anti_invasion_loss(x_normalized, vmf_signatures, current_task_id, threshold=2.3):
-    """
-    Hinge loss penalizing current task features that invade old task regions.
-    
-    Args:
-        x_normalized: Current task's normalized features (B, d) or (B, 1, d)
-        vmf_signatures: Dict {task_id: (mu, kappa)}
-        current_task_id: Current task index
-        threshold: vMF log-likelihood threshold (default -log(0.1) ≈ 2.3)
-        
-    Returns:
-        invasion_loss: Scalar hinge loss
-    """
-    if x_normalized.dim() == 3:
-        x_normalized = x_normalized.squeeze(1)  # (B, d)
-    
-    device = x_normalized.device
-    dtype = x_normalized.dtype
-    invasion_loss = torch.tensor(0.0, device=device, dtype=dtype)
-    n_old_tasks = 0
-    
-    for task_id, (mu_s, kappa_s) in vmf_signatures.items():
-        if task_id >= current_task_id:
-            continue
-        
-        mu_s = mu_s.to(device=device, dtype=dtype)
-        kappa_val = kappa_s.item() if isinstance(kappa_s, torch.Tensor) else kappa_s
-        
-        # Log-likelihood of x_new under vMF(mu_s, kappa_s): kappa_s * (mu_s · x_new)
-        log_lik = kappa_val * (x_normalized * mu_s.unsqueeze(0)).sum(dim=-1)  # (B,)
-        
-        # Hinge: penalize when log_lik > threshold (feature too close to old task)
-        violation = F.relu(log_lik - threshold)  # (B,)
-        invasion_loss = invasion_loss + violation.mean()
-        n_old_tasks += 1
-    
-    if n_old_tasks > 0:
-        invasion_loss = invasion_loss / n_old_tasks
-    
-    return invasion_loss

gainlora_OT_vMF/src/preflight_check.py

@@ -1,199 +0,0 @@
-#!/usr/bin/env python3
-"""Fast preflight checks for GainLoRA training compatibility.
-
-This script catches common breakages in seconds before launching long runs:
-- Python syntax/import issues in critical source files
-- transformers/accelerate API mismatches
-- Trainer init signature mismatches (processing_class vs tokenizer)
-- Known bad patterns that caused recent runtime failures
-"""
-
-import glob
-import importlib
-import inspect
-import os
-import py_compile
-import sys
-from typing import List
-
-
-ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
-SRC_DIR = os.path.join(ROOT, "src")
-
-CRITICAL_FILES = [
-    "run_t5.py",
-    "run_llama.py",
-    "compat_transformers.py",
-    "cl_trainer_gainlora_inflora.py",
-    "cl_trainer_gainlora_inflora_llama.py",
-    "cl_trainer_gainlora_olora.py",
-    "cl_trainer_gainlora_olora_llama.py",
-]
-
-GAINLORA_TRAINERS = [
-    "cl_trainer_gainlora_inflora.py",
-    "cl_trainer_gainlora_inflora_llama.py",
-    "cl_trainer_gainlora_olora.py",
-    "cl_trainer_gainlora_olora_llama.py",
-]
-
-
-def _ok(msg: str) -> None:
-    print(f"[OK] {msg}")
-
-
-def _warn(msg: str) -> None:
-    print(f"[WARN] {msg}")
-
-
-def _fail(msg: str, failures: List[str]) -> None:
-    print(f"[FAIL] {msg}")
-    failures.append(msg)
-
-
-def check_syntax(failures: List[str]) -> None:
-    for rel in CRITICAL_FILES:
-        path = os.path.join(SRC_DIR, rel)
-        if not os.path.exists(path):
-            _fail(f"Missing file: {rel}", failures)
-            continue
-        try:
-            py_compile.compile(path, doraise=True)
-            _ok(f"Syntax compile: {rel}")
-        except Exception as exc:
-            _fail(f"Syntax error in {rel}: {exc}", failures)
-
-
-def check_core_api(failures: List[str]) -> None:
-    try:
-        import transformers
-        from transformers import Trainer
-
-        sig = inspect.signature(Trainer.__init__)
-        params = sig.parameters
-        version_str = transformers.__version__
-        major = int(version_str.split(".")[0])
-
-        if major >= 5:
-            if "processing_class" not in params:
-                _fail("transformers>=5 requires Trainer.__init__.processing_class", failures)
-            else:
-                _ok("Trainer.__init__ has processing_class (transformers>=5)")
-        else:
-            if "tokenizer" not in params:
-                _fail("transformers<5 expected Trainer.__init__.tokenizer", failures)
-            else:
-                _ok("Trainer.__init__ has tokenizer (transformers<5)")
-
-        _ok(f"transformers version: {version_str}")
-    except Exception as exc:
-        _fail(f"transformers API check failed: {exc}", failures)
-
-    try:
-        import accelerate
-        from accelerate import Accelerator
-
-        clip_sig = inspect.signature(Accelerator.clip_grad_norm_)
-        clip_params = set(clip_sig.parameters.keys())
-        if "check_grad_overflow" in clip_params:
-            _warn("Accelerator.clip_grad_norm_ supports check_grad_overflow")
-        else:
-            _ok("Accelerator.clip_grad_norm_ does not support check_grad_overflow")
-        _ok(f"accelerate version: {accelerate.__version__}")
-    except Exception as exc:
-        _fail(f"accelerate API check failed: {exc}", failures)
-
-
-def check_text_patterns(failures: List[str]) -> None:
-    # Patterns that recently caused failures in this codebase.
-    bad_patterns = {
-        "check_grad_overflow=": "Unsupported kwarg for accelerate.clip_grad_norm_ in many envs",
-    }
-
-    for rel in GAINLORA_TRAINERS:
-        path = os.path.join(SRC_DIR, rel)
-        try:
-            text = open(path, "r", encoding="utf-8").read()
-        except Exception as exc:
-            _fail(f"Cannot read {rel}: {exc}", failures)
-            continue
-
-        for pattern, reason in bad_patterns.items():
-            if pattern in text:
-                _fail(f"{rel} contains '{pattern}' ({reason})", failures)
-
-        if "self.accelerator.clip_grad_norm_(" in text:
-            _fail(
-                f"{rel} still uses self.accelerator.clip_grad_norm_ (can trigger double unscale)",
-                failures,
-            )
-        elif "nn.utils.clip_grad_norm_(" in text:
-            _ok(f"{rel} uses nn.utils.clip_grad_norm_")
-
-    # Check Trainer API migration in run scripts.
-    for rel in ["run_t5.py", "run_llama.py"]:
-        path = os.path.join(SRC_DIR, rel)
-        try:
-            text = open(path, "r", encoding="utf-8").read()
-        except Exception as exc:
-            _fail(f"Cannot read {rel}: {exc}", failures)
-            continue
-
-        if "tokenizer=tokenizer" in text:
-            _fail(f"{rel} still contains tokenizer=tokenizer (should be processing_class=tokenizer)", failures)
-        if "processing_class=tokenizer" in text:
-            _ok(f"{rel} uses processing_class=tokenizer")
-
-
-def check_custom_trainer_signatures(failures: List[str]) -> None:
-    sys.path.insert(0, SRC_DIR)
-    trainer_mods = sorted(glob.glob(os.path.join(SRC_DIR, "cl_trainer_*.py")))
-
-    for mod_path in trainer_mods:
-        mod_name = os.path.splitext(os.path.basename(mod_path))[0]
-        try:
-            mod = importlib.import_module(mod_name)
-        except Exception as exc:
-            _fail(f"Import failed for {mod_name}: {exc}", failures)
-            continue
-
-        for _, obj in inspect.getmembers(mod, inspect.isclass):
-            if obj.__module__ != mod_name:
-                continue
-            if not hasattr(obj, "__mro__"):
-                continue
-            if not any(base.__name__ == "Seq2SeqTrainer" for base in obj.__mro__):
-                continue
-
-            init_sig = inspect.signature(obj.__init__)
-            params = init_sig.parameters
-            if "processing_class" not in params:
-                _fail(f"{mod_name}.{obj.__name__}.__init__ missing processing_class", failures)
-            elif "tokenizer" in params:
-                _fail(f"{mod_name}.{obj.__name__}.__init__ still has tokenizer", failures)
-            else:
-                _ok(f"{mod_name}.{obj.__name__}.__init__ signature is compatible")
-
-
-def main() -> int:
-    failures: List[str] = []
-
-    print("== GainLoRA Preflight Check ==")
-    print(f"Root: {ROOT}")
-
-    check_syntax(failures)
-    check_core_api(failures)
-    check_text_patterns(failures)
-    check_custom_trainer_signatures(failures)
-
-    print("\n== Result ==")
-    if failures:
-        print(f"FAILED with {len(failures)} issue(s)")
-        return 1
-
-    print("PASS: no blocking issues found")
-    return 0
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())

gainlora_OT_vMF/src/run_logger.py

@@ -1,229 +0,0 @@
-"""
-OT-SIGN Run Logger
-==================
-Logs each training run with config, vMF signatures, and per-task scores.
-Computes AP (Average Performance) and FT (Forgetting) directly comparable
-to GainLoRA paper Table 1 / Table 2.
-
-Output files:
-  run_log.jsonl          — machine-readable full log
-  scores_matrix.json     — R[i][j] = score of task j after training task i
-  ap_ft_summary.md       — final AP/FT table ready for paper comparison
-"""
-
-import json
-import os
-from datetime import datetime
-
-
-# Keys used for score extraction from HuggingFace Trainer metrics
-SCORE_KEY_TEMPLATES = {
-    "superni": ["predict_rougeL_for_{task}", "eval_rougeL_for_{task}", "predict_rougeL"],
-    "long":    ["predict_exact_match_for_{task}", "eval_exact_match_for_{task}", "predict_exact_match"],
-}
-
-
-def _extract_score(metrics_dict, task_name, benchmark_type="superni"):
-    """Extract the primary score for a given task from a metrics dict."""
-    templates = SCORE_KEY_TEMPLATES.get(benchmark_type, SCORE_KEY_TEMPLATES["superni"])
-    for tmpl in templates:
-        key = tmpl.format(task=task_name)
-        if key in metrics_dict:
-            v = metrics_dict[key]
-            # rougeL is typically 0–1 from compute_metrics; multiply to get percentage
-            if v <= 1.0 and "rouge" in key.lower():
-                v = v * 100.0
-            return round(v, 2)
-    # fallback: look for any key containing the task name
-    for k, v in metrics_dict.items():
-        if task_name in k and isinstance(v, (int, float)):
-            if v <= 1.0 and "rouge" in k.lower():
-                v = v * 100.0
-            return round(v, 2)
-    return None
-
-
-class RunLogger:
-    """
-    Logs every task training run and builds the result matrix R[i][j].
-    
-    Result matrix semantics (matching GainLoRA paper Table 1):
-      R[i][j] = score on task j after model has been trained on tasks 0..i
-      AP       = (1/T) * sum_j R[T-1][j]           (final row average)
-      FT       = (1/(T-1)) * sum_j (R[j][j] - R[T-1][j])  (diagonal drop)
-    """
-
-    def __init__(self, log_dir="logs_and_outputs/ot_sign_logs", benchmark_type="superni"):
-        self.log_dir = log_dir
-        self.benchmark_type = benchmark_type  # "superni" or "long"
-        os.makedirs(log_dir, exist_ok=True)
-        self.log_file     = os.path.join(log_dir, "run_log.jsonl")
-        self.matrix_file  = os.path.join(log_dir, "scores_matrix.json")
-        self.summary_file = os.path.join(log_dir, "ap_ft_summary.md")
-
-        # In-memory score matrix: {trained_on_task_id: {eval_task_name: score}}
-        self._scores = self._load_scores_matrix()
-
-    # ------------------------------------------------------------------
-    # Public API
-    # ------------------------------------------------------------------
-
-    def log_run(self, task_name, task_id, config, vmf_signature=None, metrics=None, extra=None):
-        """Log a single task's training metadata (config, vMF, train metrics)."""
-        entry = {
-            "timestamp": datetime.now().isoformat(),
-            "task_name": task_name,
-            "task_id": task_id,
-            "config": config,
-            "vmf_signature": vmf_signature,
-            "metrics": metrics,
-            "extra": extra,
-        }
-        with open(self.log_file, 'a') as f:
-            f.write(json.dumps(entry, default=str) + "\n")
-        self._update_md_log(entry)
-        print(f"[RunLogger] Logged task {task_id}: {task_name}")
-
-    def log_predict_scores(self, trained_on_task_id, predict_metrics_dict, task_order_list):
-        """
-        After training on task `trained_on_task_id`, log prediction scores for all
-        tasks evaluated so far.
-        
-        Args:
-            trained_on_task_id: index of the just-trained task (0-based)
-            predict_metrics_dict: HF Trainer predict_results.metrics
-            task_order_list: full list of task names in sequence order
-        """
-        row = {}
-        for j, tname in enumerate(task_order_list[:trained_on_task_id + 1]):
-            score = _extract_score(predict_metrics_dict, tname, self.benchmark_type)
-            if score is not None:
-                row[tname] = score
-
-        self._scores[trained_on_task_id] = row
-        self._save_scores_matrix()
-
-        # Print progress table
-        self._print_current_scores(trained_on_task_id, task_order_list)
-
-    def print_ap_ft(self, task_order_list, method_name="OT-SIGN+GainLoRA"):
-        """
-        Compute and print AP / FT from the accumulated score matrix.
-        Prints a table directly comparable to GainLoRA paper.
-        
-        Returns:
-            (ap, ft) as floats
-        """
-        T = len(task_order_list)
-        if T not in self._scores and (T - 1) not in self._scores:
-            print("[RunLogger] Not enough data to compute AP/FT yet.")
-            return None, None
-
-        final_row_id = T - 1
-        if final_row_id not in self._scores:
-            print("[RunLogger] Final task scores not found.")
-            return None, None
-
-        final_scores = [self._scores[final_row_id].get(t) for t in task_order_list]
-        final_scores_valid = [s for s in final_scores if s is not None]
-        ap = round(sum(final_scores_valid) / len(final_scores_valid), 2) if final_scores_valid else 0.0
-
-        # FT = mean of (diagonal - final row), skip first task
-        ft_values = []
-        for j in range(T - 1):
-            tname = task_order_list[j]
-            diag = self._scores.get(j, {}).get(tname)
-            final = self._scores.get(final_row_id, {}).get(tname)
-            if diag is not None and final is not None:
-                ft_values.append(diag - final)
-        ft = round(sum(ft_values) / len(ft_values), 2) if ft_values else 0.0
-
-        # ---- Console output ----
-        sep = "-" * 60
-        print(f"\n{sep}")
-        print(f"  FINAL RESULTS — {method_name}")
-        print(sep)
-        print(f"  {'Task':<45} {'Peak':>6}  {'Final':>6}  {'Drop':>6}")
-        print(sep)
-        for j, tname in enumerate(task_order_list):
-            diag  = self._scores.get(j, {}).get(tname, "-")
-            final = self._scores.get(final_row_id, {}).get(tname, "-")
-            drop  = f"{diag - final:.2f}" if isinstance(diag, float) and isinstance(final, float) else "-"
-            diag_s  = f"{diag:.2f}"  if isinstance(diag,  float) else str(diag)
-            final_s = f"{final:.2f}" if isinstance(final, float) else str(final)
-            print(f"  {tname:<45} {diag_s:>6}  {final_s:>6}  {drop:>6}")
-        print(sep)
-        print(f"  AP  = {ap:.2f}   |   FT = {ft:.2f}")
-        print(f"{sep}\n")
-
-        # ---- File output ----
-        self._write_ap_ft_summary(task_order_list, method_name, ap, ft)
-        return ap, ft
-
-    # ------------------------------------------------------------------
-    # Internal helpers
-    # ------------------------------------------------------------------
-
-    def _load_scores_matrix(self):
-        if os.path.exists(self.matrix_file):
-            with open(self.matrix_file) as f:
-                raw = json.load(f)
-            return {int(k): v for k, v in raw.items()}
-        return {}
-
-    def _save_scores_matrix(self):
-        with open(self.matrix_file, 'w') as f:
-            json.dump({str(k): v for k, v in self._scores.items()}, f, indent=2)
-
-    def _print_current_scores(self, trained_on_task_id, task_order_list):
-        row = self._scores.get(trained_on_task_id, {})
-        tname = task_order_list[trained_on_task_id] if trained_on_task_id < len(task_order_list) else "?"
-        print(f"\n[RunLogger] After task {trained_on_task_id} ({tname}) — predict scores:")
-        for t, s in row.items():
-            print(f"  {t:<50} {s:.2f}")
-
-    def _update_md_log(self, entry):
-        """Append human-readable training info only (not the score matrix)."""
-        with open(self.log_file.replace(".jsonl", "_detail.md"), 'a') as f:
-            f.write(f"\n## Task {entry['task_id']}: {entry['task_name']}\n")
-            f.write(f"*{entry['timestamp']}*\n\n")
-            if entry.get('vmf_signature'):
-                f.write(f"- vMF kappa: `{entry['vmf_signature'].get('kappa', '?')}`  "
-                        f"mu_norm: `{entry['vmf_signature'].get('mu_norm', '?')}`\n")
-            if entry.get('metrics'):
-                f.write("| Metric | Value |\n|--------|-------|\n")
-                for k, v in entry['metrics'].items():
-                    val = f"{v:.4f}" if isinstance(v, float) else str(v)
-                    f.write(f"| `{k}` | {val} |\n")
-            f.write("\n")
-
-    def _write_ap_ft_summary(self, task_order_list, method_name, ap, ft):
-        """Write a markdown file ready to paste into the comparison table."""
-        T = len(task_order_list)
-        final_row_id = T - 1
-        with open(self.summary_file, 'a') as f:
-            f.write(f"\n## {method_name}\n")
-            f.write(f"*Generated: {datetime.now().strftime('%Y-%m-%d %H:%M')}*\n\n")
-            f.write("| Task | Peak Score (R[i,i]) | Final Score (R[T,i]) | Forgetting |\n")
-            f.write("|------|---------------------|----------------------|------------|\n")
-            for j, tname in enumerate(task_order_list):
-                diag  = self._scores.get(j, {}).get(tname, "-")
-                final = self._scores.get(final_row_id, {}).get(tname, "-")
-                drop  = f"{diag - final:.2f}" if isinstance(diag, float) and isinstance(final, float) else "-"
-                f.write(f"| {tname} | {diag} | {final} | {drop} |\n")
-            f.write(f"\n**AP = {ap:.2f}** | **FT = {ft:.2f}**\n\n")
-
-    # ---- Legacy compat ----
-    def load_all_runs(self):
-        runs = []
-        if os.path.exists(self.log_file):
-            with open(self.log_file) as f:
-                for line in f:
-                    line = line.strip()
-                    if line:
-                        runs.append(json.loads(line))
-        return runs
-
-    def get_latest_run(self):
-        runs = self.load_all_runs()
-        return runs[-1] if runs else None

gainlora_OT_vMF/src/test_ot_sign.py

@@ -1,54 +0,0 @@
-#!/usr/bin/env python
-"""Quick unit test for OT-SIGN components."""
-import torch
-import torch.nn.functional as F
-import sys
-sys.path.insert(0, '.')
-
-from ot_sign_utils import sinkhorn_log, vmf_cost_matrix, compute_vmf_params, compute_anti_invasion_loss
-
-print('=== Test 1: Sinkhorn OT ===')
-C = torch.randn(4, 3)
-weights = sinkhorn_log(C, epsilon=0.05, n_iter=10)
-print(f'Cost shape: {C.shape}, Weights shape: {weights.shape}')
-print(f'Row sums: {weights.sum(dim=1)}')
-print(f'Weights:\n{weights}')
-
-print()
-print('=== Test 2: vMF Parameter Estimation ===')
-d = 1024
-n = 100
-raw = torch.randn(n, d)
-features = F.normalize(raw, dim=-1)
-mu, kappa = compute_vmf_params(features, d)
-print(f'mu shape: {mu.shape}, norm: {mu.norm():.4f}')
-print(f'kappa: {kappa.item():.4f}')
-
-print()
-print('=== Test 3: vmf_cost_matrix ===')
-x = F.normalize(torch.randn(4, d), dim=-1)
-sigs = {0: (mu, kappa)}
-prompt_key = torch.randn(1, d)
-C2 = vmf_cost_matrix(x, sigs, prompt_key=prompt_key, default_kappa=10.0)
-print(f'Cost matrix shape: {C2.shape}')
-
-weights2 = sinkhorn_log(C2, epsilon=0.05, n_iter=10)
-print(f'OT weights shape: {weights2.shape}, row sums: {weights2.sum(dim=1)}')
-print(f'Weights:\n{weights2}')
-
-print()
-print('=== Test 4: Anti-invasion loss ===')
-x_new = F.normalize(torch.randn(8, d), dim=-1)
-sigs2 = {0: (mu, torch.tensor(5.0)), 1: (F.normalize(torch.randn(d), dim=-1), torch.tensor(8.0))}
-inv_loss = compute_anti_invasion_loss(x_new, sigs2, current_task_id=2, threshold=2.3)
-print(f'Invasion loss: {inv_loss.item():.6f}')
-
-print()
-print('=== Test 5: FP16 compatibility ===')
-C_fp16 = torch.randn(8, 5, dtype=torch.float16)
-w_fp16 = sinkhorn_log(C_fp16.float(), epsilon=0.05, n_iter=10).half()
-print(f'FP16 output: {w_fp16.shape}, dtype: {w_fp16.dtype}')
-print(f'Row sums: {w_fp16.sum(dim=1)}')
-
-print()
-print('=== All tests passed! ===')