Add files using upload-large-folder tool

LTA_openwebtext_dualt/logs/lta_owt_bert_absrope_time4_dirichlet_len128_C1_to_1024_mask1_sameT_gbs512_b32_4gpu_1m_save1k_20260525_watcher.sh

@@ -0,0 +1,87 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+cd /e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt
+export PYTHONPATH="$(pwd)${PYTHONPATH:+:$PYTHONPATH}"
+export TOKENIZERS_PARALLELISM=false
+export PYTHONUNBUFFERED=1
+
+: "${RUN_DIR:?RUN_DIR is required}"
+: "${OUT_BASE:?OUT_BASE is required}"
+: "${LOG_DIR:?LOG_DIR is required}"
+: "${TOKENIZER_PATH:?TOKENIZER_PATH is required}"
+: "${SCORER:?SCORER is required}"
+
+RUN_STEM="$(basename "${RUN_DIR}")"
+TEMP_TAG="${ENDPOINT_TEMP//./p}"
+PROCESSED_FILE="${LOG_DIR}/processed_${RUN_STEM}_steps${STEPS}_c${CMIN}_${CMAX}_gumbel_t${TEMP_TAG}_n${N_SAMPLES}.txt"
+
+mkdir -p "${OUT_BASE}" "${LOG_DIR}"
+touch "${PROCESSED_FILE}"
+
+echo "[watch-gumbel] run_dir=${RUN_DIR}"
+echo "[watch-gumbel] out_base=${OUT_BASE}"
+echo "[watch-gumbel] interval=${STEP_INTERVAL} max_len=${MAX_LEN} steps=${STEPS} c=${CMIN}->${CMAX} temp=${ENDPOINT_TEMP} top_p=${ENDPOINT_TOP_P} tau=${GUMBEL_TAU_START}->${GUMBEL_TAU_END} n=${N_SAMPLES}"
+
+while true; do
+  shopt -s nullglob
+  ckpts=("${RUN_DIR}"/step_*.pt)
+  shopt -u nullglob
+
+  if (( ${#ckpts[@]} == 0 )); then
+    echo "[watch-gumbel] $(date +%F_%T) no ckpt yet"
+    sleep "${SLEEP_SECONDS}"
+    continue
+  fi
+
+  printf "%s\n" "${ckpts[@]}" | sort | while read -r ckpt; do
+    base="$(basename "${ckpt}")"
+    step="${base#step_}"
+    step="${step%.pt}"
+    step_num=$((10#${step}))
+    if (( step_num % STEP_INTERVAL != 0 )); then
+      continue
+    fi
+    if grep -Fxq "${ckpt}" "${PROCESSED_FILE}"; then
+      continue
+    fi
+
+    out_dir="${OUT_BASE}/step_${step}"
+    log_file="${LOG_DIR}/infer_${RUN_STEM}_step_${step}.log"
+    mkdir -p "${out_dir}"
+
+    echo "[watch-gumbel] $(date +%F_%T) infer ${ckpt} -> ${out_dir}" | tee -a "${log_file}"
+    CUDA_VISIBLE_DEVICES="${WATCH_CUDA_VISIBLE_DEVICES}" python scripts/eval_lm1b_c1024_fullycoupled_sde_genppl.py \
+      --checkpoint "${ckpt}" \
+      --tokenizer_path "${TOKENIZER_PATH}" \
+      --scorer "${SCORER}" \
+      --out_dir "${out_dir}" \
+      --n_samples "${N_SAMPLES}" \
+      --max_len "${MAX_LEN}" \
+      --steps "${STEPS}" \
+      --batch_size "${DECODE_BATCH}" \
+      --score_batch "${SCORE_BATCH}" \
+      --score_max_length "${SCORE_MAX_LENGTH}" \
+      --concentration_min "${CMIN}" \
+      --concentration_max "${CMAX}" \
+      --endpoint_temp "${ENDPOINT_TEMP}" \
+      --endpoint_projection gumbel_softmax \
+      --endpoint_top_p "${ENDPOINT_TOP_P}" \
+      --gumbel_tau_start "${GUMBEL_TAU_START}" \
+      --gumbel_tau_end "${GUMBEL_TAU_END}" \
+      --model_t_mode support_t \
+      --mean_mode endpoint_only \
+      --semantic_power 1.0 \
+      --noise_init dirichlet \
+      --noise_dirichlet_concentration "${CMIN}" \
+      --sde_resample dirichlet \
+      --final_from blend_0.5 \
+      --seed 20260524 \
+      2>&1 | tee -a "${log_file}"
+
+    echo "${ckpt}" >> "${PROCESSED_FILE}"
+    echo "[watch-gumbel] $(date +%F_%T) done step_${step}" | tee -a "${log_file}"
+  done
+
+  sleep "${SLEEP_SECONDS}"
+done

LTA_openwebtext_dualt/logs/lta_owt_c1024_gpt2_cached_len128_exact100_repeat1024_4gpu_200step.log

@@ -0,0 +1,82 @@
+
+*****************************************
+Setting OMP_NUM_THREADS environment variable for each process to be 1 in default, to avoid your system being overloaded, please further tune the variable for optimal performance in your application as needed. 
+*****************************************
+[rank0]:[W512 19:39:24.800276910 ProcessGroupNCCL.cpp:4571] [PG ID 0 PG GUID 0 Rank 0]  using GPU 0 to perform barrier as devices used by this process are currently unknown. This can potentially cause a hang if this rank to GPU mapping is incorrect. Specify device_ids in barrier() to force use of a particular device, or call init_process_group() with a device_id.
+[rank1]:[W512 19:39:26.534674590 ProcessGroupNCCL.cpp:4571] [PG ID 0 PG GUID 0 Rank 1]  using GPU 1 to perform barrier as devices used by this process are currently unknown. This can potentially cause a hang if this rank to GPU mapping is incorrect. Specify device_ids in barrier() to force use of a particular device, or call init_process_group() with a device_id.
+[rank3]:[W512 19:39:27.828159040 ProcessGroupNCCL.cpp:4571] [PG ID 0 PG GUID 0 Rank 3]  using GPU 3 to perform barrier as devices used by this process are currently unknown. This can potentially cause a hang if this rank to GPU mapping is incorrect. Specify device_ids in barrier() to force use of a particular device, or call init_process_group() with a device_id.
+[rank2]:[W512 19:39:27.927014715 ProcessGroupNCCL.cpp:4571] [PG ID 0 PG GUID 0 Rank 2]  using GPU 2 to perform barrier as devices used by this process are currently unknown. This can potentially cause a hang if this rank to GPU mapping is incorrect. Specify device_ids in barrier() to force use of a particular device, or call init_process_group() with a device_id.
+{
+  "device": "cuda:0",
+  "rank": 0,
+  "world_size": 4,
+  "samples": "owt_cached_chunks:100",
+  "vocab_size": 50257,
+  "save_dir": "runs/lta_owt_c1024_gpt2_cached_len128_exact100_repeat1024_4gpu_200step",
+  "batch_size": 32,
+  "grad_accum": 4,
+  "effective_batch_size": 512,
+  "global_batch_size": 512,
+  "lr_schedule": "constant_warmup",
+  "warmup_steps": 20,
+  "adam_beta1": 0.9,
+  "adam_beta2": 0.999,
+  "adam_eps": 1e-08,
+  "model_type": "ddit",
+  "dual_t": true,
+  "corrupt_t_mode": "same",
+  "corrupt_min_t": 0.0,
+  "corrupt_max_t": 1.0,
+  "dirichlet_endpoint_mode": "categorical_dual_t",
+  "dirichlet_semantic_t_mode": "same",
+  "dirichlet_semantic_t_value": 0.0,
+  "categorical_wrong_from_full_vocab": true,
+  "simplex_bridge_sampler": "dirichlet",
+  "logistic_normal_sigma_min": 0.18,
+  "logistic_normal_sigma_max": 2.2,
+  "logistic_normal_tau_min": 0.65,
+  "logistic_normal_tau_max": 1.15,
+  "torch_compile": false,
+  "compile_mode": "max-autotune",
+  "state_format": "prob",
+  "target_loss": "hard_ce",
+  "meanflow_weight": 0.0,
+  "bridge_noise_init": "logistic_normal",
+  "noise_sigma": -1.0,
+  "wrap": true,
+  "wrap_mode": "stream",
+  "wrap_record_buffer_size": 200,
+  "owt_cached_chunks": true,
+  "owt_chunk_cache_dir": "/e2e-data/evad-tech-vla/wanghan58/data/small_benchmarks/langflow_2604_11748/openwebtext_lta_cached_chunks/gpt2_len128_train_minus_100k_exact100",
+  "owt_chunk_cache_rebuild": false,
+  "owt_chunk_cache_write_batch": 4096,
+  "owt_exact_repeat_per_chunk": 1024,
+  "online_chunk_shuffle": false,
+  "online_chunk_shuffle_buffer": 10000,
+  "openwebtext_split": "train_minus_100k",
+  "detokenizer": "auto",
+  "resolved_detokenizer": null,
+  "num_workers": 0,
+  "latest_every": 50,
+  "resume_path": ""
+}
+step=10 micro_steps=40 elapsed=5.2s lr=1.650000e-04 loss_all=10.6384 acc_all=0.5972 loss_corrupt=10.6582 acc_corrupt=0.3944 corrupt_frac=0.5412 loss=10.6582 loss_recon=10.6582 loss_meanflow=0.0000 mean_model_t=0.5116 mean_corrupt_t=0.5116 mean_loss_t_weight=1.0000 prior_center_loss_beta=0.0000 wrong_frac=0.4917 init_acc_corrupt=0.4742 init_gold_top10=0.5029 init_gold_top100=0.5308
+step=20 micro_steps=80 elapsed=4.4s lr=3.000000e-04 loss_all=9.1266 acc_all=0.0782 loss_corrupt=9.1391 acc_corrupt=0.0574 corrupt_frac=0.5459 loss=9.1391 loss_recon=9.1391 loss_meanflow=0.0000 mean_model_t=0.5069 mean_corrupt_t=0.5069 mean_loss_t_weight=1.0000 prior_center_loss_beta=0.0000 wrong_frac=0.4957 init_acc_corrupt=0.4725 init_gold_top10=0.4992 init_gold_top100=0.5266
+step=30 micro_steps=120 elapsed=4.4s lr=3.000000e-04 loss_all=7.1634 acc_all=0.0552 loss_corrupt=7.1695 acc_corrupt=0.0463 corrupt_frac=0.5441 loss=7.1695 loss_recon=7.1695 loss_meanflow=0.0000 mean_model_t=0.5013 mean_corrupt_t=0.5013 mean_loss_t_weight=1.0000 prior_center_loss_beta=0.0000 wrong_frac=0.4968 init_acc_corrupt=0.4697 init_gold_top10=0.4977 init_gold_top100=0.5260
+step=40 micro_steps=160 elapsed=4.4s lr=3.000000e-04 loss_all=6.5580 acc_all=0.1148 loss_corrupt=6.5872 acc_corrupt=0.0892 corrupt_frac=0.5593 loss=6.5872 loss_recon=6.5872 loss_meanflow=0.0000 mean_model_t=0.4933 mean_corrupt_t=0.4933 mean_loss_t_weight=1.0000 prior_center_loss_beta=0.0000 wrong_frac=0.5044 init_acc_corrupt=0.4601 init_gold_top10=0.4892 init_gold_top100=0.5202
+step=50 micro_steps=200 elapsed=4.4s lr=3.000000e-04 loss_all=6.1045 acc_all=0.1572 loss_corrupt=6.3032 acc_corrupt=0.1170 corrupt_frac=0.5444 loss=6.3032 loss_recon=6.3032 loss_meanflow=0.0000 mean_model_t=0.4978 mean_corrupt_t=0.4978 mean_loss_t_weight=1.0000 prior_center_loss_beta=0.0000 wrong_frac=0.5076 init_acc_corrupt=0.4556 init_gold_top10=0.4863 init_gold_top100=0.5171
+step=60 micro_steps=240 elapsed=6.3s lr=3.000000e-04 loss_all=5.2158 acc_all=0.2475 loss_corrupt=5.7240 acc_corrupt=0.1806 corrupt_frac=0.5518 loss=5.7240 loss_recon=5.7240 loss_meanflow=0.0000 mean_model_t=0.4948 mean_corrupt_t=0.4948 mean_loss_t_weight=1.0000 prior_center_loss_beta=0.0000 wrong_frac=0.4978 init_acc_corrupt=0.4666 init_gold_top10=0.4959 init_gold_top100=0.5253
+step=70 micro_steps=280 elapsed=4.4s lr=3.000000e-04 loss_all=3.7862 acc_all=0.4467 loss_corrupt=4.7490 acc_corrupt=0.3154 corrupt_frac=0.5588 loss=4.7490 loss_recon=4.7490 loss_meanflow=0.0000 mean_model_t=0.5086 mean_corrupt_t=0.5086 mean_loss_t_weight=1.0000 prior_center_loss_beta=0.0000 wrong_frac=0.4901 init_acc_corrupt=0.4773 init_gold_top10=0.5046 init_gold_top100=0.5324
+step=80 micro_steps=320 elapsed=4.4s lr=3.000000e-04 loss_all=2.3615 acc_all=0.6930 loss_corrupt=3.7446 acc_corrupt=0.4822 corrupt_frac=0.5547 loss=3.7446 loss_recon=3.7446 loss_meanflow=0.0000 mean_model_t=0.5120 mean_corrupt_t=0.5120 mean_loss_t_weight=1.0000 prior_center_loss_beta=0.0000 wrong_frac=0.4870 init_acc_corrupt=0.4780 init_gold_top10=0.5076 init_gold_top100=0.5345
+step=90 micro_steps=360 elapsed=4.3s lr=3.000000e-04 loss_all=1.9835 acc_all=0.7175 loss_corrupt=3.5661 acc_corrupt=0.4852 corrupt_frac=0.5486 loss=3.5661 loss_recon=3.5661 loss_meanflow=0.0000 mean_model_t=0.4835 mean_corrupt_t=0.4835 mean_loss_t_weight=1.0000 prior_center_loss_beta=0.0000 wrong_frac=0.5183 init_acc_corrupt=0.4448 init_gold_top10=0.4758 init_gold_top100=0.5060
+step=100 micro_steps=400 elapsed=4.4s lr=3.000000e-04 loss_all=1.7581 acc_all=0.7366 loss_corrupt=3.2161 acc_corrupt=0.5149 corrupt_frac=0.5428 loss=3.2161 loss_recon=3.2161 loss_meanflow=0.0000 mean_model_t=0.4994 mean_corrupt_t=0.4994 mean_loss_t_weight=1.0000 prior_center_loss_beta=0.0000 wrong_frac=0.4977 init_acc_corrupt=0.4669 init_gold_top10=0.4967 init_gold_top100=0.5264
+step=110 micro_steps=440 elapsed=8.2s lr=3.000000e-04 loss_all=1.7078 acc_all=0.7263 loss_corrupt=2.9909 acc_corrupt=0.5182 corrupt_frac=0.5686 loss=2.9909 loss_recon=2.9909 loss_meanflow=0.0000 mean_model_t=0.4964 mean_corrupt_t=0.4964 mean_loss_t_weight=1.0000 prior_center_loss_beta=0.0000 wrong_frac=0.5031 init_acc_corrupt=0.4605 init_gold_top10=0.4914 init_gold_top100=0.5207
+step=120 micro_steps=480 elapsed=4.4s lr=3.000000e-04 loss_all=1.4249 acc_all=0.7508 loss_corrupt=2.5742 acc_corrupt=0.5479 corrupt_frac=0.5513 loss=2.5742 loss_recon=2.5742 loss_meanflow=0.0000 mean_model_t=0.5146 mean_corrupt_t=0.5146 mean_loss_t_weight=1.0000 prior_center_loss_beta=0.0000 wrong_frac=0.4851 init_acc_corrupt=0.4828 init_gold_top10=0.5095 init_gold_top100=0.5358
+step=130 micro_steps=520 elapsed=4.4s lr=3.000000e-04 loss_all=1.2788 acc_all=0.7603 loss_corrupt=2.2817 acc_corrupt=0.5710 corrupt_frac=0.5575 loss=2.2817 loss_recon=2.2817 loss_meanflow=0.0000 mean_model_t=0.5137 mean_corrupt_t=0.5137 mean_loss_t_weight=1.0000 prior_center_loss_beta=0.0000 wrong_frac=0.4879 init_acc_corrupt=0.4815 init_gold_top10=0.5071 init_gold_top100=0.5336
+step=140 micro_steps=560 elapsed=4.4s lr=3.000000e-04 loss_all=1.0687 acc_all=0.7866 loss_corrupt=1.9329 acc_corrupt=0.6128 corrupt_frac=0.5491 loss=1.9329 loss_recon=1.9329 loss_meanflow=0.0000 mean_model_t=0.5159 mean_corrupt_t=0.5159 mean_loss_t_weight=1.0000 prior_center_loss_beta=0.0000 wrong_frac=0.4843 init_acc_corrupt=0.4836 init_gold_top10=0.5111 init_gold_top100=0.5365
+step=150 micro_steps=600 elapsed=4.4s lr=3.000000e-04 loss_all=0.8887 acc_all=0.8133 loss_corrupt=1.6236 acc_corrupt=0.6579 corrupt_frac=0.5443 loss=1.6236 loss_recon=1.6236 loss_meanflow=0.0000 mean_model_t=0.5080 mean_corrupt_t=0.5080 mean_loss_t_weight=1.0000 prior_center_loss_beta=0.0000 wrong_frac=0.4939 init_acc_corrupt=0.4731 init_gold_top10=0.5004 init_gold_top100=0.5300
+step=160 micro_steps=640 elapsed=6.3s lr=3.000000e-04 loss_all=0.7285 acc_all=0.8367 loss_corrupt=1.3140 acc_corrupt=0.7047 corrupt_frac=0.5513 loss=1.3140 loss_recon=1.3140 loss_meanflow=0.0000 mean_model_t=0.4908 mean_corrupt_t=0.4908 mean_loss_t_weight=1.0000 prior_center_loss_beta=0.0000 wrong_frac=0.5037 init_acc_corrupt=0.4598 init_gold_top10=0.4898 init_gold_top100=0.5208
+step=170 micro_steps=680 elapsed=4.4s lr=3.000000e-04 loss_all=0.5558 acc_all=0.8735 loss_corrupt=0.9953 acc_corrupt=0.7733 corrupt_frac=0.5542 loss=0.9953 loss_recon=0.9953 loss_meanflow=0.0000 mean_model_t=0.5036 mean_corrupt_t=0.5036 mean_loss_t_weight=1.0000 prior_center_loss_beta=0.0000 wrong_frac=0.4968 init_acc_corrupt=0.4688 init_gold_top10=0.4973 init_gold_top100=0.5265
+step=180 micro_steps=720 elapsed=4.4s lr=3.000000e-04 loss_all=0.4730 acc_all=0.8938 loss_corrupt=0.8661 acc_corrupt=0.8054 corrupt_frac=0.5428 loss=0.8661 loss_recon=0.8661 loss_meanflow=0.0000 mean_model_t=0.4963 mean_corrupt_t=0.4963 mean_loss_t_weight=1.0000 prior_center_loss_beta=0.0000 wrong_frac=0.5086 init_acc_corrupt=0.4558 init_gold_top10=0.4856 init_gold_top100=0.5150
+step=190 micro_steps=760 elapsed=4.4s lr=3.000000e-04 loss_all=0.3720 acc_all=0.9130 loss_corrupt=0.6561 acc_corrupt=0.8461 corrupt_frac=0.5595 loss=0.6561 loss_recon=0.6561 loss_meanflow=0.0000 mean_model_t=0.4869 mean_corrupt_t=0.4869 mean_loss_t_weight=1.0000 prior_center_loss_beta=0.0000 wrong_frac=0.5022 init_acc_corrupt=0.4608 init_gold_top10=0.4918 init_gold_top100=0.5221
+step=200 micro_steps=800 elapsed=4.4s lr=3.000000e-04 loss_all=0.2823 acc_all=0.9325 loss_corrupt=0.5093 acc_corrupt=0.8780 corrupt_frac=0.5526 loss=0.5093 loss_recon=0.5093 loss_meanflow=0.0000 mean_model_t=0.5022 mean_corrupt_t=0.5022 mean_loss_t_weight=1.0000 prior_center_loss_beta=0.0000 wrong_frac=0.4950 init_acc_corrupt=0.4714 init_gold_top10=0.4992 init_gold_top100=0.5276

LTA_openwebtext_dualt/logs/owt_fully_best_readability_candidates_step118k_n64.log

@@ -0,0 +1,37 @@
+[forbid_endpoint_ids] n=352 first=[94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125]
+[decode] steps24_c128_mtpost_t1p15_tpow1p0_noise0_state_anchored
+[summary] {"name": "steps24_c128_mtpost_t1p15_tpow1p0_noise0_state_anchored", "step": 119000, "n_samples": 64, "steps": 24, "concentration_max": 128.0, "temp_start": 1.15, "temp_end": 1.15, "temp_schedule": "const", "t_power": 1.0, "eta0": 0.0, "eta_schedule": "none", "noise_conc": 1.0, "final_from": "state", "final_decode": "argmax", "final_temp": 1.0, "final_top_k": 0, "final_uncertain_threshold": 0.85, "update_rule": "anchored", "model_t_mode": "post", "lock_bos": true, "lock_final_eos": false, "detok_genppl": 136.68253116492195, "sample_entropy": 4.35908630001246, "distinct_1": 0.063751220703125, "distinct_2": 0.4382025904203324, "top_token_mass": 0.1629180908203125, "tokens_scored": 52925, "readability_score": 4.840462446659439, "mean_chars": 2900.390625, "replacement_chars": 0.0}
+[decode] steps24_c128_mtpost_t1p2_tpow1p0_noise0_state_anchored
+[summary] {"name": "steps24_c128_mtpost_t1p2_tpow1p0_noise0_state_anchored", "step": 119000, "n_samples": 64, "steps": 24, "concentration_max": 128.0, "temp_start": 1.2, "temp_end": 1.2, "temp_schedule": "const", "t_power": 1.0, "eta0": 0.0, "eta_schedule": "none", "noise_conc": 1.0, "final_from": "state", "final_decode": "argmax", "final_temp": 1.0, "final_top_k": 0, "final_uncertain_threshold": 0.85, "update_rule": "anchored", "model_t_mode": "post", "lock_bos": true, "lock_final_eos": false, "detok_genppl": 163.2546320727631, "sample_entropy": 4.54139086009561, "distinct_1": 0.0656280517578125, "distinct_2": 0.4883003421309873, "top_token_mass": 0.1094512939453125, "tokens_scored": 55654, "readability_score": 4.917528211030994, "mean_chars": 2910.390625, "replacement_chars": 0.0}
+[decode] steps24_c128_mtpost_t1p25_tpow1p0_noise0_state_anchored
+[summary] {"name": "steps24_c128_mtpost_t1p25_tpow1p0_noise0_state_anchored", "step": 119000, "n_samples": 64, "steps": 24, "concentration_max": 128.0, "temp_start": 1.25, "temp_end": 1.25, "temp_schedule": "const", "t_power": 1.0, "eta0": 0.0, "eta_schedule": "none", "noise_conc": 1.0, "final_from": "state", "final_decode": "argmax", "final_temp": 1.0, "final_top_k": 0, "final_uncertain_threshold": 0.85, "update_rule": "anchored", "model_t_mode": "post", "lock_bos": true, "lock_final_eos": false, "detok_genppl": 189.34256808350023, "sample_entropy": 4.6414778024588585, "distinct_1": 0.0617218017578125, "distinct_2": 0.5090573069403714, "top_token_mass": 0.0673370361328125, "tokens_scored": 57535, "readability_score": 4.951280399958232, "mean_chars": 2813.328125, "replacement_chars": 0.0}
+[decode] steps24_c192_mtpost_t1p15_tpow1p0_noise0_state_anchored
+[summary] {"name": "steps24_c192_mtpost_t1p15_tpow1p0_noise0_state_anchored", "step": 119000, "n_samples": 64, "steps": 24, "concentration_max": 192.0, "temp_start": 1.15, "temp_end": 1.15, "temp_schedule": "const", "t_power": 1.0, "eta0": 0.0, "eta_schedule": "none", "noise_conc": 1.0, "final_from": "state", "final_decode": "argmax", "final_temp": 1.0, "final_top_k": 0, "final_uncertain_threshold": 0.85, "update_rule": "anchored", "model_t_mode": "post", "lock_bos": true, "lock_final_eos": false, "detok_genppl": 110.25318817826248, "sample_entropy": 4.265044221033497, "distinct_1": 0.0598297119140625, "distinct_2": 0.4149254643206256, "top_token_mass": 0.16619873046875, "tokens_scored": 52861, "readability_score": 4.735430141224595, "mean_chars": 3033.734375, "replacement_chars": 0.0}
+[decode] steps24_c192_mtpost_t1p2_tpow1p0_noise0_state_anchored
+[summary] {"name": "steps24_c192_mtpost_t1p2_tpow1p0_noise0_state_anchored", "step": 119000, "n_samples": 64, "steps": 24, "concentration_max": 192.0, "temp_start": 1.2, "temp_end": 1.2, "temp_schedule": "const", "t_power": 1.0, "eta0": 0.0, "eta_schedule": "none", "noise_conc": 1.0, "final_from": "state", "final_decode": "argmax", "final_temp": 1.0, "final_top_k": 0, "final_uncertain_threshold": 0.85, "update_rule": "anchored", "model_t_mode": "post", "lock_bos": true, "lock_final_eos": false, "detok_genppl": 131.94485280762137, "sample_entropy": 4.424955147711324, "distinct_1": 0.06201171875, "distinct_2": 0.44993279569892475, "top_token_mass": 0.1223602294921875, "tokens_scored": 55067, "readability_score": 4.827165218600323, "mean_chars": 2980.203125, "replacement_chars": 0.0}
+[decode] steps24_c192_mtpost_t1p25_tpow1p0_noise0_state_anchored
+[summary] {"name": "steps24_c192_mtpost_t1p25_tpow1p0_noise0_state_anchored", "step": 119000, "n_samples": 64, "steps": 24, "concentration_max": 192.0, "temp_start": 1.25, "temp_end": 1.25, "temp_schedule": "const", "t_power": 1.0, "eta0": 0.0, "eta_schedule": "none", "noise_conc": 1.0, "final_from": "state", "final_decode": "argmax", "final_temp": 1.0, "final_top_k": 0, "final_uncertain_threshold": 0.85, "update_rule": "anchored", "model_t_mode": "post", "lock_bos": true, "lock_final_eos": false, "detok_genppl": 151.26706289254133, "sample_entropy": 4.510369710188292, "distinct_1": 0.058197021484375, "distinct_2": 0.4711326979472141, "top_token_mass": 0.07073974609375, "tokens_scored": 57214, "readability_score": 4.814185932885269, "mean_chars": 2938.75, "replacement_chars": 0.0}
+[decode] steps24_c256_mtpost_t1p15_tpow1p0_noise0_state_anchored
+[summary] {"name": "steps24_c256_mtpost_t1p15_tpow1p0_noise0_state_anchored", "step": 119000, "n_samples": 64, "steps": 24, "concentration_max": 256.0, "temp_start": 1.15, "temp_end": 1.15, "temp_schedule": "const", "t_power": 1.0, "eta0": 0.0, "eta_schedule": "none", "noise_conc": 1.0, "final_from": "state", "final_decode": "argmax", "final_temp": 1.0, "final_top_k": 0, "final_uncertain_threshold": 0.85, "update_rule": "anchored", "model_t_mode": "post", "lock_bos": true, "lock_final_eos": false, "detok_genppl": 102.11866506997787, "sample_entropy": 4.237296045982029, "distinct_1": 0.056640625, "distinct_2": 0.401377688172043, "top_token_mass": 0.1682281494140625, "tokens_scored": 52687, "readability_score": 4.720412153468626, "mean_chars": 3048.765625, "replacement_chars": 0.0}
+[decode] steps24_c256_mtpost_t1p2_tpow1p0_noise0_state_anchored
+[summary] {"name": "steps24_c256_mtpost_t1p2_tpow1p0_noise0_state_anchored", "step": 119000, "n_samples": 64, "steps": 24, "concentration_max": 256.0, "temp_start": 1.2, "temp_end": 1.2, "temp_schedule": "const", "t_power": 1.0, "eta0": 0.0, "eta_schedule": "none", "noise_conc": 1.0, "final_from": "state", "final_decode": "argmax", "final_temp": 1.0, "final_top_k": 0, "final_uncertain_threshold": 0.85, "update_rule": "anchored", "model_t_mode": "post", "lock_bos": true, "lock_final_eos": false, "detok_genppl": 114.33207787651192, "sample_entropy": 4.341931888548368, "distinct_1": 0.0576934814453125, "distinct_2": 0.4300617057673509, "top_token_mass": 0.1277313232421875, "tokens_scored": 54671, "readability_score": 4.762909455773018, "mean_chars": 3029.90625, "replacement_chars": 0.0}
+[decode] steps24_c256_mtpost_t1p25_tpow1p0_noise0_state_anchored
+[summary] {"name": "steps24_c256_mtpost_t1p25_tpow1p0_noise0_state_anchored", "step": 119000, "n_samples": 64, "steps": 24, "concentration_max": 256.0, "temp_start": 1.25, "temp_end": 1.25, "temp_schedule": "const", "t_power": 1.0, "eta0": 0.0, "eta_schedule": "none", "noise_conc": 1.0, "final_from": "state", "final_decode": "argmax", "final_temp": 1.0, "final_top_k": 0, "final_uncertain_threshold": 0.85, "update_rule": "anchored", "model_t_mode": "post", "lock_bos": true, "lock_final_eos": false, "detok_genppl": 125.85656866896282, "sample_entropy": 4.40724907644453, "distinct_1": 0.0540924072265625, "distinct_2": 0.43913428641251223, "top_token_mass": 0.0737152099609375, "tokens_scored": 57069, "readability_score": 4.71464470576572, "mean_chars": 3012.046875, "replacement_chars": 0.0}
+[decode] steps32_c128_mtpost_t1p15_tpow1p0_noise0_state_anchored
+[summary] {"name": "steps32_c128_mtpost_t1p15_tpow1p0_noise0_state_anchored", "step": 119000, "n_samples": 64, "steps": 32, "concentration_max": 128.0, "temp_start": 1.15, "temp_end": 1.15, "temp_schedule": "const", "t_power": 1.0, "eta0": 0.0, "eta_schedule": "none", "noise_conc": 1.0, "final_from": "state", "final_decode": "argmax", "final_temp": 1.0, "final_top_k": 0, "final_uncertain_threshold": 0.85, "update_rule": "anchored", "model_t_mode": "post", "lock_bos": true, "lock_final_eos": false, "detok_genppl": 93.93262211506004, "sample_entropy": 4.146366887708747, "distinct_1": 0.05560302734375, "distinct_2": 0.380330522971652, "top_token_mass": 0.1920318603515625, "tokens_scored": 51644, "readability_score": 4.702144174351347, "mean_chars": 3099.6875, "replacement_chars": 0.0}
+[decode] steps32_c128_mtpost_t1p2_tpow1p0_noise0_state_anchored
+[summary] {"name": "steps32_c128_mtpost_t1p2_tpow1p0_noise0_state_anchored", "step": 119000, "n_samples": 64, "steps": 32, "concentration_max": 128.0, "temp_start": 1.2, "temp_end": 1.2, "temp_schedule": "const", "t_power": 1.0, "eta0": 0.0, "eta_schedule": "none", "noise_conc": 1.0, "final_from": "state", "final_decode": "argmax", "final_temp": 1.0, "final_top_k": 0, "final_uncertain_threshold": 0.85, "update_rule": "anchored", "model_t_mode": "post", "lock_bos": true, "lock_final_eos": false, "detok_genppl": 109.20811571250756, "sample_entropy": 4.384182287205536, "distinct_1": 0.058258056640625, "distinct_2": 0.42856488269794724, "top_token_mass": 0.1383514404296875, "tokens_scored": 54756, "readability_score": 4.786283145660528, "mean_chars": 3182.765625, "replacement_chars": 0.0}
+[decode] steps32_c128_mtpost_t1p25_tpow1p0_noise0_state_anchored
+[summary] {"name": "steps32_c128_mtpost_t1p25_tpow1p0_noise0_state_anchored", "step": 119000, "n_samples": 64, "steps": 32, "concentration_max": 128.0, "temp_start": 1.25, "temp_end": 1.25, "temp_schedule": "const", "t_power": 1.0, "eta0": 0.0, "eta_schedule": "none", "noise_conc": 1.0, "final_from": "state", "final_decode": "argmax", "final_temp": 1.0, "final_top_k": 0, "final_uncertain_threshold": 0.85, "update_rule": "anchored", "model_t_mode": "post", "lock_bos": true, "lock_final_eos": false, "detok_genppl": 132.59276083128742, "sample_entropy": 4.559239875423023, "distinct_1": 0.05767822265625, "distinct_2": 0.4616477272727273, "top_token_mass": 0.0916290283203125, "tokens_scored": 57001, "readability_score": 4.848120117898956, "mean_chars": 3095.28125, "replacement_chars": 0.0}
+[decode] steps32_c192_mtpost_t1p15_tpow1p0_noise0_state_anchored
+[summary] {"name": "steps32_c192_mtpost_t1p15_tpow1p0_noise0_state_anchored", "step": 119000, "n_samples": 64, "steps": 32, "concentration_max": 192.0, "temp_start": 1.15, "temp_end": 1.15, "temp_schedule": "const", "t_power": 1.0, "eta0": 0.0, "eta_schedule": "none", "noise_conc": 1.0, "final_from": "state", "final_decode": "argmax", "final_temp": 1.0, "final_top_k": 0, "final_uncertain_threshold": 0.85, "update_rule": "anchored", "model_t_mode": "post", "lock_bos": true, "lock_final_eos": false, "detok_genppl": 79.75199343220605, "sample_entropy": 4.116014300363699, "distinct_1": 0.0526123046875, "distinct_2": 0.37208272238514173, "top_token_mass": 0.182861328125, "tokens_scored": 52336, "readability_score": 4.568094566086867, "mean_chars": 3219.328125, "replacement_chars": 0.0}
+[decode] steps32_c192_mtpost_t1p2_tpow1p0_noise0_state_anchored
+[summary] {"name": "steps32_c192_mtpost_t1p2_tpow1p0_noise0_state_anchored", "step": 119000, "n_samples": 64, "steps": 32, "concentration_max": 192.0, "temp_start": 1.2, "temp_end": 1.2, "temp_schedule": "const", "t_power": 1.0, "eta0": 0.0, "eta_schedule": "none", "noise_conc": 1.0, "final_from": "state", "final_decode": "argmax", "final_temp": 1.0, "final_top_k": 0, "final_uncertain_threshold": 0.85, "update_rule": "anchored", "model_t_mode": "post", "lock_bos": true, "lock_final_eos": false, "detok_genppl": 87.63682490534464, "sample_entropy": 4.297251891850898, "distinct_1": 0.054412841796875, "distinct_2": 0.4047073558162268, "top_token_mass": 0.1365203857421875, "tokens_scored": 55045, "readability_score": 4.618896624567134, "mean_chars": 3343.125, "replacement_chars": 0.0}
+[decode] steps32_c192_mtpost_t1p25_tpow1p0_noise0_state_anchored
+[summary] {"name": "steps32_c192_mtpost_t1p25_tpow1p0_noise0_state_anchored", "step": 119000, "n_samples": 64, "steps": 32, "concentration_max": 192.0, "temp_start": 1.25, "temp_end": 1.25, "temp_schedule": "const", "t_power": 1.0, "eta0": 0.0, "eta_schedule": "none", "noise_conc": 1.0, "final_from": "state", "final_decode": "argmax", "final_temp": 1.0, "final_top_k": 0, "final_uncertain_threshold": 0.85, "update_rule": "anchored", "model_t_mode": "post", "lock_bos": true, "lock_final_eos": false, "detok_genppl": 116.21517241972205, "sample_entropy": 4.506314288940267, "distinct_1": 0.0568389892578125, "distinct_2": 0.44780975073313783, "top_token_mass": 0.101043701171875, "tokens_scored": 56746, "readability_score": 4.834847720277795, "mean_chars": 3265.265625, "replacement_chars": 0.0}
+[decode] steps32_c256_mtpost_t1p15_tpow1p0_noise0_state_anchored
+[summary] {"name": "steps32_c256_mtpost_t1p15_tpow1p0_noise0_state_anchored", "step": 119000, "n_samples": 64, "steps": 32, "concentration_max": 256.0, "temp_start": 1.15, "temp_end": 1.15, "temp_schedule": "const", "t_power": 1.0, "eta0": 0.0, "eta_schedule": "none", "noise_conc": 1.0, "final_from": "state", "final_decode": "argmax", "final_temp": 1.0, "final_top_k": 0, "final_uncertain_threshold": 0.85, "update_rule": "anchored", "model_t_mode": "post", "lock_bos": true, "lock_final_eos": false, "detok_genppl": 71.23326374591926, "sample_entropy": 4.056456480759734, "distinct_1": 0.04852294921875, "distinct_2": 0.35696175464320623, "top_token_mass": 0.1811981201171875, "tokens_scored": 52408, "readability_score": 4.507317547560852, "mean_chars": 3232.96875, "replacement_chars": 0.0}
+[decode] steps32_c256_mtpost_t1p2_tpow1p0_noise0_state_anchored
+[summary] {"name": "steps32_c256_mtpost_t1p2_tpow1p0_noise0_state_anchored", "step": 119000, "n_samples": 64, "steps": 32, "concentration_max": 256.0, "temp_start": 1.2, "temp_end": 1.2, "temp_schedule": "const", "t_power": 1.0, "eta0": 0.0, "eta_schedule": "none", "noise_conc": 1.0, "final_from": "state", "final_decode": "argmax", "final_temp": 1.0, "final_top_k": 0, "final_uncertain_threshold": 0.85, "update_rule": "anchored", "model_t_mode": "post", "lock_bos": true, "lock_final_eos": false, "detok_genppl": 80.57856411170884, "sample_entropy": 4.252087418800223, "distinct_1": 0.0537109375, "distinct_2": 0.3979258308895406, "top_token_mass": 0.1309356689453125, "tokens_scored": 55459, "readability_score": 4.567108589413614, "mean_chars": 3418.0625, "replacement_chars": 0.0}
+[decode] steps32_c256_mtpost_t1p25_tpow1p0_noise0_state_anchored
+[summary] {"name": "steps32_c256_mtpost_t1p25_tpow1p0_noise0_state_anchored", "step": 119000, "n_samples": 64, "steps": 32, "concentration_max": 256.0, "temp_start": 1.25, "temp_end": 1.25, "temp_schedule": "const", "t_power": 1.0, "eta0": 0.0, "eta_schedule": "none", "noise_conc": 1.0, "final_from": "state", "final_decode": "argmax", "final_temp": 1.0, "final_top_k": 0, "final_uncertain_threshold": 0.85, "update_rule": "anchored", "model_t_mode": "post", "lock_bos": true, "lock_final_eos": false, "detok_genppl": 96.34182099786459, "sample_entropy": 4.457003351165028, "distinct_1": 0.053924560546875, "distinct_2": 0.4288245356793744, "top_token_mass": 0.1002349853515625, "tokens_scored": 57271, "readability_score": 4.673838825132707, "mean_chars": 3389.4375, "replacement_chars": 0.0}

LTA_openwebtext_dualt/logs/smoke_duo_aligned_1gpu_b64_metricsbf16.log

@@ -0,0 +1,79 @@
+{
+  "device": "cuda:0",
+  "rank": 0,
+  "world_size": 1,
+  "samples": "wrapped_streaming",
+  "vocab_size": 50257,
+  "save_dir": "runs/smoke_duo_aligned_1gpu_b64_metricsbf16",
+  "batch_size": 64,
+  "grad_accum": 1,
+  "effective_batch_size": 64,
+  "global_batch_size": 64,
+  "lr_schedule": "constant_warmup",
+  "warmup_steps": 2500,
+  "adam_beta1": 0.9,
+  "adam_beta2": 0.999,
+  "adam_eps": 1e-08,
+  "model_type": "ddit",
+  "dual_t": true,
+  "corrupt_t_mode": "independent",
+  "corrupt_min_t": 0.0,
+  "corrupt_max_t": 1.0,
+  "torch_compile": false,
+  "compile_mode": "max-autotune",
+  "state_format": "prob",
+  "target_loss": "soft_ce",
+  "meanflow_weight": 0.0,
+  "bridge_noise_init": "logistic_normal",
+  "noise_sigma": -1.0,
+  "wrap": true,
+  "openwebtext_split": "train_minus_100k",
+  "num_workers": 4
+}
+Traceback (most recent call last):
+  File "/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/train.py", line 473, in <module>
+    main()
+  File "/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/train.py", line 402, in main
+    raw_loss = masked_soft_ce(logits, bridge.target_probs, bridge.corrupt_mask)
+               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+  File "/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/flowtext_lab/metrics.py", line 19, in masked_soft_ce
+    log_probs = F.log_softmax(logits, dim=-1)
+                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+  File "/usr/local/lib/python3.12/dist-packages/torch/nn/functional.py", line 2248, in log_softmax
+    ret = input.log_softmax(dim)
+          ^^^^^^^^^^^^^^^^^^^^^^
+torch.OutOfMemoryError: CUDA out of memory. Tried to allocate 12.27 GiB. GPU 0 has a total capacity of 95.22 GiB of which 8.18 GiB is free. Process 351023 has 87.04 GiB memory in use. Of the allocated memory 83.42 GiB is allocated by PyTorch, and 3.19 GiB is reserved by PyTorch but unallocated. If reserved but unallocated memory is large try setting PYTORCH_CUDA_ALLOC_CONF=expandable_segments:True to avoid fragmentation.  See documentation for Memory Management  (https://pytorch.org/docs/stable/notes/cuda.html#environment-variables)
+E0428 23:04:38.584000 293486 torch/distributed/elastic/multiprocessing/api.py:870] failed (exitcode: 1) local_rank: 0 (pid: 293553) of binary: /usr/bin/python
+Traceback (most recent call last):
+  File "<frozen runpy>", line 198, in _run_module_as_main
+  File "<frozen runpy>", line 88, in _run_code
+  File "/usr/local/lib/python3.12/dist-packages/torch/distributed/run.py", line 922, in <module>
+    main()
+  File "/usr/local/lib/python3.12/dist-packages/torch/distributed/elastic/multiprocessing/errors/__init__.py", line 355, in wrapper
+    return f(*args, **kwargs)
+           ^^^^^^^^^^^^^^^^^^
+  File "/usr/local/lib/python3.12/dist-packages/torch/distributed/run.py", line 918, in main
+    run(args)
+  File "/usr/local/lib/python3.12/dist-packages/torch/distributed/run.py", line 909, in run
+    elastic_launch(
+  File "/usr/local/lib/python3.12/dist-packages/torch/distributed/launcher/api.py", line 139, in __call__
+    return launch_agent(self._config, self._entrypoint, list(args))
+           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+  File "/usr/local/lib/python3.12/dist-packages/torch/distributed/launcher/api.py", line 270, in launch_agent
+    raise ChildFailedError(
+torch.distributed.elastic.multiprocessing.errors.ChildFailedError: 
+============================================================
+train.py FAILED
+------------------------------------------------------------
+Failures:
+  <NO_OTHER_FAILURES>
+------------------------------------------------------------
+Root Cause (first observed failure):
+[0]:
+  time      : 2026-04-28_23:04:38
+  host      : localhost
+  rank      : 0 (local_rank: 0)
+  exitcode  : 1 (pid: 293553)
+  error_file: <N/A>
+  traceback : To enable traceback see: https://pytorch.org/docs/stable/elastic/errors.html
+============================================================

LTA_openwebtext_dualt/mini_owt_logdirichlet/.venv_qwen35_uv/lib/python3.12/site-packages/numpy/f2py/tests/src/mixed/foo_fixed.f90

@@ -0,0 +1,8 @@
+      module foo_fixed
+      contains
+        subroutine bar12(a)
+!f2py intent(out) a
+          integer a
+          a = 12
+        end subroutine bar12
+      end module foo_fixed

LTA_openwebtext_dualt/mini_owt_logdirichlet/.venv_qwen35_uv/lib/python3.12/site-packages/numpy/f2py/tests/src/return_logical/foo77.f

@@ -0,0 +1,56 @@
+       function t0(value)
+         logical value
+         logical t0
+         t0 = value
+       end
+       function t1(value)
+         logical*1 value
+         logical*1 t1
+         t1 = value
+       end
+       function t2(value)
+         logical*2 value
+         logical*2 t2
+         t2 = value
+       end
+       function t4(value)
+         logical*4 value
+         logical*4 t4
+         t4 = value
+       end
+c       function t8(value)
+c         logical*8 value
+c         logical*8 t8
+c         t8 = value
+c       end
+
+       subroutine s0(t0,value)
+         logical value
+         logical t0
+cf2py    intent(out) t0
+         t0 = value
+       end
+       subroutine s1(t1,value)
+         logical*1 value
+         logical*1 t1
+cf2py    intent(out) t1
+         t1 = value
+       end
+       subroutine s2(t2,value)
+         logical*2 value
+         logical*2 t2
+cf2py    intent(out) t2
+         t2 = value
+       end
+       subroutine s4(t4,value)
+         logical*4 value
+         logical*4 t4
+cf2py    intent(out) t4
+         t4 = value
+       end
+c       subroutine s8(t8,value)
+c         logical*8 value
+c         logical*8 t8
+cf2py    intent(out) t8
+c         t8 = value
+c       end

LTA_openwebtext_dualt/mini_owt_logdirichlet/.venv_qwen35_uv/lib/python3.12/site-packages/numpy/f2py/tests/src/return_logical/foo90.f90

@@ -0,0 +1,59 @@
+module f90_return_logical
+  contains
+       function t0(value)
+         logical :: value
+         logical :: t0
+         t0 = value
+       end function t0
+       function t1(value)
+         logical(kind=1) :: value
+         logical(kind=1) :: t1
+         t1 = value
+       end function t1
+       function t2(value)
+         logical(kind=2) :: value
+         logical(kind=2) :: t2
+         t2 = value
+       end function t2
+       function t4(value)
+         logical(kind=4) :: value
+         logical(kind=4) :: t4
+         t4 = value
+       end function t4
+       function t8(value)
+         logical(kind=8) :: value
+         logical(kind=8) :: t8
+         t8 = value
+       end function t8
+
+       subroutine s0(t0,value)
+         logical :: value
+         logical :: t0
+!f2py    intent(out) t0
+         t0 = value
+       end subroutine s0
+       subroutine s1(t1,value)
+         logical(kind=1) :: value
+         logical(kind=1) :: t1
+!f2py    intent(out) t1
+         t1 = value
+       end subroutine s1
+       subroutine s2(t2,value)
+         logical(kind=2) :: value
+         logical(kind=2) :: t2
+!f2py    intent(out) t2
+         t2 = value
+       end subroutine s2
+       subroutine s4(t4,value)
+         logical(kind=4) :: value
+         logical(kind=4) :: t4
+!f2py    intent(out) t4
+         t4 = value
+       end subroutine s4
+       subroutine s8(t8,value)
+         logical(kind=8) :: value
+         logical(kind=8) :: t8
+!f2py    intent(out) t8
+         t8 = value
+       end subroutine s8
+end module f90_return_logical

LTA_openwebtext_dualt/mini_owt_logdirichlet/.venv_qwen35_uv/lib/python3.12/site-packages/numpy/f2py/tests/src/return_real/foo77.f

@@ -0,0 +1,45 @@
+       function t0(value)
+         real value
+         real t0
+         t0 = value
+       end
+       function t4(value)
+         real*4 value
+         real*4 t4
+         t4 = value
+       end
+       function t8(value)
+         real*8 value
+         real*8 t8
+         t8 = value
+       end
+       function td(value)
+         double precision value
+         double precision td
+         td = value
+       end
+
+       subroutine s0(t0,value)
+         real value
+         real t0
+cf2py    intent(out) t0
+         t0 = value
+       end
+       subroutine s4(t4,value)
+         real*4 value
+         real*4 t4
+cf2py    intent(out) t4
+         t4 = value
+       end
+       subroutine s8(t8,value)
+         real*8 value
+         real*8 t8
+cf2py    intent(out) t8
+         t8 = value
+       end
+       subroutine sd(td,value)
+         double precision value
+         double precision td
+cf2py    intent(out) td
+         td = value
+       end

LTA_openwebtext_dualt/mini_owt_logdirichlet/.venv_qwen35_uv/lib/python3.12/site-packages/numpy/f2py/tests/src/return_real/foo90.f90

@@ -0,0 +1,48 @@
+module f90_return_real
+  contains
+       function t0(value)
+         real :: value
+         real :: t0
+         t0 = value
+       end function t0
+       function t4(value)
+         real(kind=4) :: value
+         real(kind=4) :: t4
+         t4 = value
+       end function t4
+       function t8(value)
+         real(kind=8) :: value
+         real(kind=8) :: t8
+         t8 = value
+       end function t8
+       function td(value)
+         double precision :: value
+         double precision :: td
+         td = value
+       end function td
+
+       subroutine s0(t0,value)
+         real :: value
+         real :: t0
+!f2py    intent(out) t0
+         t0 = value
+       end subroutine s0
+       subroutine s4(t4,value)
+         real(kind=4) :: value
+         real(kind=4) :: t4
+!f2py    intent(out) t4
+         t4 = value
+       end subroutine s4
+       subroutine s8(t8,value)
+         real(kind=8) :: value
+         real(kind=8) :: t8
+!f2py    intent(out) t8
+         t8 = value
+       end subroutine s8
+       subroutine sd(td,value)
+         double precision :: value
+         double precision :: td
+!f2py    intent(out) td
+         td = value
+       end subroutine sd
+end module f90_return_real

LTA_openwebtext_dualt/mini_owt_logdirichlet/.venv_qwen35_uv/lib/python3.12/site-packages/transformers/models/ctrl/configuration_ctrl.py

@@ -0,0 +1,70 @@
+# Copyright 2018 Salesforce and HuggingFace Inc. team.
+# Copyright (c) 2018, NVIDIA CORPORATION.  All rights reserved.
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Salesforce CTRL configuration"""
+
+from huggingface_hub.dataclasses import strict
+
+from ...configuration_utils import PreTrainedConfig
+from ...utils import auto_docstring
+
+
+@auto_docstring(checkpoint="Salesforce/ctrl")
+@strict
+class CTRLConfig(PreTrainedConfig):
+    r"""
+    dff (`int`, *optional*, defaults to 8192):
+        Dimensionality of the inner dimension of the feed forward networks (FFN).
+
+    Examples:
+
+    ```python
+    >>> from transformers import CTRLConfig, CTRLModel
+
+    >>> # Initializing a CTRL configuration
+    >>> configuration = CTRLConfig()
+
+    >>> # Initializing a model (with random weights) from the configuration
+    >>> model = CTRLModel(configuration)
+
+    >>> # Accessing the model configuration
+    >>> configuration = model.config
+    ```"""
+
+    model_type = "ctrl"
+    keys_to_ignore_at_inference = ["past_key_values"]
+    attribute_map = {
+        "max_position_embeddings": "n_positions",
+        "hidden_size": "n_embd",
+        "num_attention_heads": "n_head",
+        "num_hidden_layers": "n_layer",
+    }
+
+    vocab_size: int = 246534
+    n_positions: int = 256
+    n_embd: int = 1280
+    dff: int = 8192
+    n_layer: int = 48
+    n_head: int = 16
+    resid_pdrop: float | int = 0.1
+    embd_pdrop: float | int = 0.1
+    layer_norm_epsilon: float = 1e-6
+    initializer_range: float = 0.02
+    use_cache: bool = True
+    pad_token_id: int | None = None
+    bos_token_id: int | None = None
+    eos_token_id: int | list[int] | None = None
+    tie_word_embeddings: bool = True
+
+
+__all__ = ["CTRLConfig"]

LTA_openwebtext_dualt/mini_owt_logdirichlet/.venv_qwen35_uv/lib/python3.12/site-packages/transformers/models/ctrl/modeling_ctrl.py

@@ -0,0 +1,683 @@
+# Copyright 2018 Salesforce and HuggingFace Inc. team.
+# Copyright (c) 2018, NVIDIA CORPORATION.  All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""PyTorch CTRL model."""
+
+import numpy as np
+import torch
+from torch import nn
+from torch.nn import BCEWithLogitsLoss, CrossEntropyLoss, MSELoss
+
+from ... import initialization as init
+from ...cache_utils import Cache, DynamicCache
+from ...generation import GenerationMixin
+from ...modeling_outputs import BaseModelOutputWithPast, CausalLMOutputWithPast, SequenceClassifierOutput
+from ...modeling_utils import PreTrainedModel
+from ...utils import (
+    auto_docstring,
+    logging,
+)
+from .configuration_ctrl import CTRLConfig
+
+
+logger = logging.get_logger(__name__)
+
+
+def angle_defn(pos, i, d_model_size):
+    angle_rates = 1 / torch.pow(10000, (2 * (i // 2)) / d_model_size)
+    return pos * angle_rates
+
+
+def positional_encoding(position, d_model_size, dtype):
+    # create the sinusoidal pattern for the positional encoding
+    angle_rads = angle_defn(
+        torch.arange(position, dtype=torch.int64).to(dtype).unsqueeze(1),
+        torch.arange(d_model_size, dtype=torch.int64).to(dtype).unsqueeze(0),
+        d_model_size,
+    )
+
+    sines = torch.sin(angle_rads[:, 0::2])
+    cosines = torch.cos(angle_rads[:, 1::2])
+
+    pos_encoding = torch.cat([sines, cosines], dim=-1)
+    return pos_encoding
+
+
+def scaled_dot_product_attention(q, k, v, mask, attention_mask=None):
+    # calculate attention
+    matmul_qk = torch.matmul(q, k.permute(0, 1, 3, 2))
+
+    dk = k.shape[-1]
+    scaled_attention_logits = matmul_qk / np.sqrt(dk)
+
+    if mask is not None:
+        nd, ns = scaled_attention_logits.size(-2), scaled_attention_logits.size(-1)
+        scaled_attention_logits += mask[ns - nd : ns, :ns] * -1e4
+
+    if attention_mask is not None:
+        # Apply the attention mask
+        scaled_attention_logits = scaled_attention_logits + attention_mask
+
+    attention_weights = torch.softmax(scaled_attention_logits, dim=-1)
+
+    output = torch.matmul(attention_weights, v)
+
+    return output, attention_weights
+
+
+class MultiHeadAttention(nn.Module):
+    def __init__(self, d_model_size, num_heads, layer_idx=None):
+        super().__init__()
+        self.num_heads = num_heads
+        self.d_model_size = d_model_size
+        self.layer_idx = layer_idx
+
+        self.depth = int(d_model_size / self.num_heads)
+
+        self.Wq = nn.Linear(d_model_size, d_model_size)
+        self.Wk = nn.Linear(d_model_size, d_model_size)
+        self.Wv = nn.Linear(d_model_size, d_model_size)
+
+        self.dense = nn.Linear(d_model_size, d_model_size)
+
+    def split_into_heads(self, x, batch_size):
+        x = x.reshape(batch_size, -1, self.num_heads, self.depth)
+        return x.permute([0, 2, 1, 3])
+
+    def forward(
+        self,
+        v,
+        k,
+        q,
+        mask,
+        layer_past=None,
+        attention_mask=None,
+        use_cache=False,
+        output_attentions=False,
+        **kwargs,
+    ):
+        batch_size = q.shape[0]
+
+        q = self.Wq(q)
+        k = self.Wk(k)
+        v = self.Wv(v)
+
+        q = self.split_into_heads(q, batch_size)
+        k = self.split_into_heads(k, batch_size)
+        v = self.split_into_heads(v, batch_size)
+
+        if layer_past is not None:
+            k, v = layer_past.update(k, v, self.layer_idx)
+
+        output = scaled_dot_product_attention(q, k, v, mask, attention_mask)
+        scaled_attention = output[0].permute([0, 2, 1, 3])
+        attn = output[1]
+        original_size_attention = scaled_attention.reshape(batch_size, -1, self.d_model_size)
+        output = self.dense(original_size_attention)
+        return output, attn
+
+
+def point_wise_feed_forward_network(d_model_size, dff):
+    return nn.Sequential(nn.Linear(d_model_size, dff), nn.ReLU(), nn.Linear(dff, d_model_size))
+
+
+class EncoderLayer(nn.Module):
+    def __init__(self, d_model_size, num_heads, dff, rate=0.1, layer_idx=None):
+        super().__init__()
+
+        self.multi_head_attention = MultiHeadAttention(d_model_size, num_heads, layer_idx=layer_idx)
+        self.ffn = point_wise_feed_forward_network(d_model_size, dff)
+
+        self.layernorm1 = nn.LayerNorm(d_model_size, eps=1e-6)
+        self.layernorm2 = nn.LayerNorm(d_model_size, eps=1e-6)
+
+        self.dropout1 = nn.Dropout(rate)
+        self.dropout2 = nn.Dropout(rate)
+
+    def forward(
+        self,
+        x,
+        mask,
+        layer_past=None,
+        attention_mask=None,
+        use_cache=False,
+        output_attentions=False,
+        **kwargs,
+    ):
+        normed = self.layernorm1(x)
+        attn_outputs = self.multi_head_attention(
+            normed,
+            normed,
+            normed,
+            mask,
+            layer_past=layer_past,
+            attention_mask=attention_mask,
+            use_cache=use_cache,
+            output_attentions=output_attentions,
+        )
+        attn_output = attn_outputs[0]
+        attn_output = self.dropout1(attn_output)
+        out1 = x + attn_output
+
+        out2 = self.layernorm2(out1)
+        ffn_output = self.ffn(out2)
+        ffn_output = self.dropout2(ffn_output)
+        out2 = out1 + ffn_output
+
+        outputs = (out2,) + attn_outputs[1:]
+        return outputs
+
+
+@auto_docstring
+class CTRLPreTrainedModel(PreTrainedModel):
+    config: CTRLConfig
+    base_model_prefix = "transformer"
+
+    def _init_weights(self, module):
+        super()._init_weights(module)
+        if isinstance(module, CTRLModel):
+            init.copy_(
+                module.pos_encoding, positional_encoding(module.config.n_positions, module.d_model_size, torch.float)
+            )
+
+
+@auto_docstring
+class CTRLModel(CTRLPreTrainedModel):
+    def __init__(self, config):
+        super().__init__(config)
+
+        self.d_model_size = config.n_embd
+        self.num_layers = config.n_layer
+
+        self.w = nn.Embedding(config.vocab_size, config.n_embd)
+
+        self.dropout = nn.Dropout(config.embd_pdrop)
+        self.h = nn.ModuleList(
+            [
+                EncoderLayer(config.n_embd, config.n_head, config.dff, config.resid_pdrop, layer_idx=i)
+                for i in range(config.n_layer)
+            ]
+        )
+        self.layernorm = nn.LayerNorm(config.n_embd, eps=config.layer_norm_epsilon)
+
+        self.register_buffer(
+            "pos_encoding", positional_encoding(config.n_positions, self.d_model_size, torch.float), persistent=False
+        )
+
+        # Initialize weights and apply final processing
+        self.post_init()
+
+    def get_input_embeddings(self):
+        return self.w
+
+    def set_input_embeddings(self, new_embeddings):
+        self.w = new_embeddings
+
+    @auto_docstring
+    def forward(
+        self,
+        input_ids: torch.LongTensor | None = None,
+        past_key_values: Cache | None = None,
+        attention_mask: torch.FloatTensor | None = None,
+        token_type_ids: torch.LongTensor | None = None,
+        position_ids: torch.LongTensor | None = None,
+        inputs_embeds: torch.FloatTensor | None = None,
+        use_cache: bool | None = None,
+        output_attentions: bool | None = None,
+        output_hidden_states: bool | None = None,
+        return_dict: bool | None = None,
+        **kwargs,  # NOOP kwargs, for now
+    ) -> tuple[torch.Tensor] | BaseModelOutputWithPast:
+        r"""
+        Example:
+
+        ```python
+        >>> from transformers import AutoTokenizer, CTRLModel
+        >>> import torch
+
+        >>> tokenizer = AutoTokenizer.from_pretrained("Salesforce/ctrl")
+        >>> model = CTRLModel.from_pretrained("Salesforce/ctrl")
+
+        >>> # CTRL was trained with control codes as the first token
+        >>> inputs = tokenizer("Opinion My dog is cute", return_tensors="pt")
+        >>> assert inputs["input_ids"][0, 0].item() in tokenizer.control_codes.values()
+
+        >>> outputs = model(**inputs)
+
+        >>> last_hidden_states = outputs.last_hidden_state
+        >>> list(last_hidden_states.shape)
+        [1, 5, 1280]
+        ```"""
+        output_attentions = output_attentions if output_attentions is not None else self.config.output_attentions
+        use_cache = use_cache if use_cache is not None else self.config.use_cache
+        output_hidden_states = (
+            output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
+        )
+        return_dict = return_dict if return_dict is not None else self.config.return_dict
+
+        if input_ids is not None and inputs_embeds is not None:
+            raise ValueError("You cannot specify both input_ids and inputs_embeds at the same time")
+        elif input_ids is not None:
+            self.warn_if_padding_and_no_attention_mask(input_ids, attention_mask)
+            input_shape = input_ids.size()
+            input_ids = input_ids.view(-1, input_shape[-1])
+            batch_size = input_ids.shape[0]
+        elif inputs_embeds is not None:
+            input_shape = inputs_embeds.size()[:-1]
+            batch_size = inputs_embeds.shape[0]
+        else:
+            raise ValueError("You have to specify either input_ids or inputs_embeds")
+
+        device = input_ids.device if input_ids is not None else inputs_embeds.device
+
+        if use_cache and past_key_values is None:
+            past_key_values = DynamicCache(config=self.config)
+
+        past_length = past_key_values.get_seq_length() if past_key_values is not None else 0
+        if position_ids is None:
+            position_ids = torch.arange(past_length, input_shape[-1] + past_length, dtype=torch.long, device=device)
+            position_ids = position_ids.unsqueeze(0)
+
+        # Attention mask.
+        if attention_mask is not None:
+            if batch_size <= 0:
+                raise ValueError("batch_size has to be defined and > 0")
+            attention_mask = attention_mask.view(batch_size, -1)
+            # We create a 3D attention mask from a 2D tensor mask.
+            # Sizes are [batch_size, 1, 1, to_seq_length]
+            # So we can broadcast to [batch_size, num_heads, from_seq_length, to_seq_length]
+            # this attention mask is more simple than the triangular masking of causal attention
+            # used in OpenAI GPT, we just need to prepare the broadcast dimension here.
+            attention_mask = attention_mask.unsqueeze(1).unsqueeze(2)
+
+            # Since attention_mask is 1.0 for positions we want to attend and 0.0 for
+            # masked positions, this operation will create a tensor which is 0.0 for
+            # positions we want to attend and the dtype's smallest value for masked positions.
+            # Since we are adding it to the raw scores before the softmax, this is
+            # effectively the same as removing these entirely.
+            attention_mask = attention_mask.to(dtype=self.dtype)  # fp16 compatibility
+            attention_mask = (1.0 - attention_mask) * torch.finfo(self.dtype).min
+
+        if token_type_ids is not None:
+            token_type_ids = token_type_ids.view(-1, input_shape[-1])
+            token_type_embeds = self.w(token_type_ids)
+            token_type_embeds *= np.sqrt(self.d_model_size)
+        else:
+            token_type_embeds = 0
+
+        if inputs_embeds is None:
+            inputs_embeds = self.w(input_ids)
+        # inputs_embeds = embedded.unsqueeze(0) if len(input_ids.shape)<2 else embedded
+        seq_len = input_shape[-1]
+        mask = torch.triu(torch.ones(seq_len + past_length, seq_len + past_length), 1).to(device)
+
+        inputs_embeds *= np.sqrt(self.d_model_size)
+
+        # `self.pos_encoding` won't be sent to the correct device along the model, so we do it manually.
+        self.pos_encoding = self.pos_encoding.to(device)
+        pos_embeds = self.pos_encoding[position_ids, :]
+
+        hidden_states = inputs_embeds + pos_embeds + token_type_embeds
+
+        hidden_states = self.dropout(hidden_states)
+
+        all_hidden_states = () if output_hidden_states else None
+        all_attentions = () if output_attentions else None
+        for i, h in enumerate(self.h):
+            if output_hidden_states:
+                all_hidden_states = all_hidden_states + (hidden_states,)
+            outputs = h(
+                hidden_states,
+                mask,
+                layer_past=past_key_values,
+                attention_mask=attention_mask,
+                use_cache=use_cache,
+                output_attentions=output_attentions,
+            )
+            hidden_states = outputs[0]
+            if output_attentions:
+                all_attentions += (outputs[1],)
+
+        hidden_states = self.layernorm(hidden_states)
+        if output_hidden_states:
+            all_hidden_states = all_hidden_states + (hidden_states,)
+
+        if not return_dict:
+            return tuple(
+                v for v in [hidden_states, past_key_values, all_hidden_states, all_attentions] if v is not None
+            )
+
+        return BaseModelOutputWithPast(
+            last_hidden_state=hidden_states,
+            past_key_values=past_key_values,
+            hidden_states=all_hidden_states,
+            attentions=all_attentions,
+        )
+
+
+@auto_docstring(
+    custom_intro="""
+    The CTRL Model transformer with a language modeling head on top (linear layer with weights tied to the input
+    embeddings).
+    """
+)
+class CTRLLMHeadModel(CTRLPreTrainedModel, GenerationMixin):
+    _tied_weights_keys = {"lm_head.weight": "transformer.w.weight"}
+
+    def __init__(self, config):
+        super().__init__(config)
+        self.transformer = CTRLModel(config)
+        self.lm_head = nn.Linear(config.n_embd, config.vocab_size, bias=True)
+
+        # Initialize weights and apply final processing
+        self.post_init()
+
+    @auto_docstring
+    def forward(
+        self,
+        input_ids: torch.LongTensor | None = None,
+        past_key_values: Cache | None = None,
+        attention_mask: torch.FloatTensor | None = None,
+        token_type_ids: torch.LongTensor | None = None,
+        position_ids: torch.LongTensor | None = None,
+        inputs_embeds: torch.FloatTensor | None = None,
+        labels: torch.LongTensor | None = None,
+        use_cache: bool | None = None,
+        output_attentions: bool | None = None,
+        output_hidden_states: bool | None = None,
+        return_dict: bool | None = None,
+        logits_to_keep: int | torch.Tensor = 0,
+        **kwargs,
+    ) -> tuple[torch.Tensor] | CausalLMOutputWithPast:
+        r"""
+        labels (`torch.LongTensor` of shape `(batch_size, sequence_length)`, *optional*):
+            Labels for language modeling. Note that the labels **are shifted** inside the model, i.e. you can set
+            `labels = input_ids` Indices are selected in `[-100, 0, ..., config.vocab_size]` All labels set to `-100`
+            are ignored (masked), the loss is only computed for labels in `[0, ..., config.vocab_size]`
+
+        Example:
+
+        ```python
+        >>> import torch
+        >>> from transformers import AutoTokenizer, CTRLLMHeadModel
+
+        >>> tokenizer = AutoTokenizer.from_pretrained("Salesforce/ctrl")
+        >>> model = CTRLLMHeadModel.from_pretrained("Salesforce/ctrl")
+
+        >>> # CTRL was trained with control codes as the first token
+        >>> inputs = tokenizer("Wikipedia The llama is", return_tensors="pt")
+        >>> assert inputs["input_ids"][0, 0].item() in tokenizer.control_codes.values()
+
+        >>> sequence_ids = model.generate(inputs["input_ids"])
+        >>> sequences = tokenizer.batch_decode(sequence_ids)
+        >>> sequences
+        ['Wikipedia The llama is a member of the family Bovidae. It is native to the Andes of Peru,']
+
+        >>> outputs = model(**inputs, labels=inputs["input_ids"])
+        >>> round(outputs.loss.item(), 2)
+        9.21
+
+        >>> list(outputs.logits.shape)
+        [1, 5, 246534]
+        ```"""
+        return_dict = return_dict if return_dict is not None else self.config.return_dict
+
+        transformer_outputs = self.transformer(
+            input_ids,
+            past_key_values=past_key_values,
+            attention_mask=attention_mask,
+            token_type_ids=token_type_ids,
+            position_ids=position_ids,
+            inputs_embeds=inputs_embeds,
+            use_cache=use_cache,
+            output_attentions=output_attentions,
+            output_hidden_states=output_hidden_states,
+            return_dict=return_dict,
+        )
+
+        hidden_states = transformer_outputs[0]
+        # Only compute necessary logits, and do not upcast them to float if we are not computing the loss
+        slice_indices = slice(-logits_to_keep, None) if isinstance(logits_to_keep, int) else logits_to_keep
+        logits = self.lm_head(hidden_states[:, slice_indices, :])
+
+        loss = None
+        if labels is not None:
+            loss = self.loss_function(
+                logits,
+                labels,
+                vocab_size=self.config.vocab_size,
+                **kwargs,
+            )
+
+        if not return_dict:
+            output = (logits,) + transformer_outputs[1:]
+            return ((loss,) + output) if loss is not None else output
+
+        return CausalLMOutputWithPast(
+            loss=loss,
+            logits=logits,
+            past_key_values=transformer_outputs.past_key_values,
+            hidden_states=transformer_outputs.hidden_states,
+            attentions=transformer_outputs.attentions,
+        )
+
+    def prepare_inputs_for_generation(
+        self, input_ids, past_key_values=None, use_cache=None, is_first_iteration=False, **kwargs
+    ):
+        # Overwritten -- `token_type_ids` are created in custom way inside model`
+
+        model_inputs = super().prepare_inputs_for_generation(
+            input_ids,
+            past_key_values=past_key_values,
+            use_cache=use_cache,
+            is_first_iteration=is_first_iteration,
+            **kwargs,
+        )
+
+        # token_type_ids are computed on CTRLModel.forward()
+        model_inputs.pop("token_type_ids", None)
+
+        return model_inputs
+
+
+@auto_docstring(
+    custom_intro="""
+    The CTRL Model transformer with a sequence classification head on top (linear layer).
+    [`CTRLForSequenceClassification`] uses the last token in order to do the classification, as other causal models
+    (e.g. GPT-2) do. Since it does classification on the last token, it requires to know the position of the last
+    token. If a `pad_token_id` is defined in the configuration, it finds the last token that is not a padding token in
+    each row. If no `pad_token_id` is defined, it simply takes the last value in each row of the batch. Since it cannot
+    guess the padding tokens when `inputs_embeds` are passed instead of `input_ids`, it does the same (take the last
+    value in each row of the batch).
+    """
+)
+class CTRLForSequenceClassification(CTRLPreTrainedModel):
+    def __init__(self, config):
+        super().__init__(config)
+        self.num_labels = config.num_labels
+        self.transformer = CTRLModel(config)
+        self.classifier = nn.Linear(config.n_embd, self.num_labels, bias=False)
+
+        # Initialize weights and apply final processing
+        self.post_init()
+
+    @auto_docstring
+    def forward(
+        self,
+        input_ids: torch.LongTensor | None = None,
+        past_key_values: Cache | None = None,
+        attention_mask: torch.FloatTensor | None = None,
+        token_type_ids: torch.LongTensor | None = None,
+        position_ids: torch.LongTensor | None = None,
+        inputs_embeds: torch.FloatTensor | None = None,
+        labels: torch.LongTensor | None = None,
+        use_cache: bool | None = None,
+        output_attentions: bool | None = None,
+        output_hidden_states: bool | None = None,
+        return_dict: bool | None = None,
+        **kwargs,
+    ) -> tuple[torch.Tensor] | SequenceClassifierOutput:
+        r"""
+        labels (`torch.LongTensor` of shape `(batch_size,)`, *optional*):
+            Labels for computing the sequence classification/regression loss. Indices should be in `[0, ...,
+            config.num_labels - 1]`. If `config.num_labels == 1` a regression loss is computed (Mean-Square loss), If
+            `config.num_labels > 1` a classification loss is computed (Cross-Entropy).
+
+        Example of single-label classification:
+
+        ```python
+        >>> import torch
+        >>> from transformers import AutoTokenizer, CTRLForSequenceClassification
+
+        >>> tokenizer = AutoTokenizer.from_pretrained("Salesforce/ctrl")
+        >>> model = CTRLForSequenceClassification.from_pretrained("Salesforce/ctrl")
+
+        >>> # CTRL was trained with control codes as the first token
+        >>> inputs = tokenizer("Opinion My dog is cute", return_tensors="pt")
+        >>> assert inputs["input_ids"][0, 0].item() in tokenizer.control_codes.values()
+
+        >>> with torch.no_grad():
+        ...     logits = model(**inputs).logits
+
+        >>> predicted_class_id = logits.argmax().item()
+        >>> model.config.id2label[predicted_class_id]
+        'LABEL_0'
+        ```
+
+        ```python
+        >>> import torch
+
+        >>> torch.manual_seed(42)  # doctest: +IGNORE_RESULT
+        >>> # To train a model on `num_labels` classes, you can pass `num_labels=num_labels` to `.from_pretrained(...)`
+        >>> num_labels = len(model.config.id2label)
+        >>> model = CTRLForSequenceClassification.from_pretrained("Salesforce/ctrl", num_labels=num_labels)
+
+        >>> labels = torch.tensor(1)
+        >>> loss = model(**inputs, labels=labels).loss
+        >>> round(loss.item(), 2)
+        0.93
+        ```
+
+        Example of multi-label classification:
+
+        ```python
+        >>> import torch
+        >>> from transformers import AutoTokenizer, CTRLForSequenceClassification
+
+        >>> tokenizer = AutoTokenizer.from_pretrained("Salesforce/ctrl")
+        >>> model = CTRLForSequenceClassification.from_pretrained(
+        ...     "Salesforce/ctrl", problem_type="multi_label_classification"
+        ... )
+
+        >>> # CTRL was trained with control codes as the first token
+        >>> inputs = tokenizer("Opinion My dog is cute", return_tensors="pt")
+        >>> assert inputs["input_ids"][0, 0].item() in tokenizer.control_codes.values()
+
+        >>> with torch.no_grad():
+        ...     logits = model(**inputs).logits
+
+        >>> predicted_class_id = logits.argmax().item()
+        >>> model.config.id2label[predicted_class_id]
+        'LABEL_0'
+        ```
+
+        ```python
+        >>> # To train a model on `num_labels` classes, you can pass `num_labels=num_labels` to `.from_pretrained(...)`
+        >>> num_labels = len(model.config.id2label)
+        >>> model = CTRLForSequenceClassification.from_pretrained("Salesforce/ctrl", num_labels=num_labels)
+
+        >>> num_labels = len(model.config.id2label)
+        >>> labels = torch.nn.functional.one_hot(torch.tensor([predicted_class_id]), num_classes=num_labels).to(
+        ...     torch.float
+        ... )
+        >>> loss = model(**inputs, labels=labels).loss
+        >>> loss.backward()  # doctest: +IGNORE_RESULT
+        ```"""
+
+        return_dict = return_dict if return_dict is not None else self.config.return_dict
+
+        transformer_outputs = self.transformer(
+            input_ids,
+            past_key_values=past_key_values,
+            attention_mask=attention_mask,
+            token_type_ids=token_type_ids,
+            position_ids=position_ids,
+            inputs_embeds=inputs_embeds,
+            use_cache=use_cache,
+            output_attentions=output_attentions,
+            output_hidden_states=output_hidden_states,
+            return_dict=return_dict,
+        )
+
+        hidden_states = transformer_outputs[0]
+        logits = self.classifier(hidden_states)
+
+        if input_ids is not None:
+            batch_size, sequence_length = input_ids.shape[:2]
+        else:
+            batch_size, sequence_length = inputs_embeds.shape[:2]
+
+        if self.config.pad_token_id is None and batch_size != 1:
+            raise ValueError("Cannot handle batch sizes > 1 if no padding token is defined.")
+        if self.config.pad_token_id is None:
+            last_non_pad_token = -1
+        elif input_ids is not None:
+            # To handle both left- and right- padding, we take the rightmost token that is not equal to pad_token_id
+            non_pad_mask = (input_ids != self.config.pad_token_id).to(logits.device, torch.int32)
+            token_indices = torch.arange(input_ids.shape[-1], device=logits.device, dtype=torch.int32)
+            last_non_pad_token = (token_indices * non_pad_mask).argmax(-1)
+        else:
+            last_non_pad_token = -1
+            logger.warning_once(
+                f"{self.__class__.__name__} will not detect padding tokens in `inputs_embeds`. Results may be "
+                "unexpected if using padding tokens in conjunction with `inputs_embeds.`"
+            )
+
+        pooled_logits = logits[torch.arange(batch_size, device=logits.device), last_non_pad_token]
+
+        loss = None
+        if labels is not None:
+            if self.config.problem_type is None:
+                if self.num_labels == 1:
+                    self.config.problem_type = "regression"
+                elif self.num_labels > 1 and (labels.dtype == torch.long or labels.dtype == torch.int):
+                    self.config.problem_type = "single_label_classification"
+                else:
+                    self.config.problem_type = "multi_label_classification"
+
+            if self.config.problem_type == "regression":
+                loss_fct = MSELoss()
+                if self.num_labels == 1:
+                    loss = loss_fct(pooled_logits.squeeze(), labels.squeeze())
+                else:
+                    loss = loss_fct(pooled_logits, labels)
+            elif self.config.problem_type == "single_label_classification":
+                loss_fct = CrossEntropyLoss()
+                loss = loss_fct(pooled_logits.view(-1, self.num_labels), labels.view(-1))
+            elif self.config.problem_type == "multi_label_classification":
+                loss_fct = BCEWithLogitsLoss()
+                loss = loss_fct(pooled_logits, labels)
+        if not return_dict:
+            output = (pooled_logits,) + transformer_outputs[2:]
+            return ((loss,) + output) if loss is not None else output
+
+        return SequenceClassifierOutput(
+            loss=loss,
+            logits=pooled_logits,
+            hidden_states=transformer_outputs.hidden_states,
+            attentions=transformer_outputs.attentions,
+        )
+
+
+__all__ = ["CTRLForSequenceClassification", "CTRLLMHeadModel", "CTRLModel", "CTRLPreTrainedModel"]

LTA_openwebtext_dualt/mini_owt_logdirichlet/.venv_qwen35_uv/lib/python3.12/site-packages/transformers/models/doge/__init__.py

@@ -0,0 +1,27 @@
+# Copyright 2025 Jingze Shi and the HuggingFace Inc. team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+from typing import TYPE_CHECKING
+
+from ...utils import _LazyModule
+from ...utils.import_utils import define_import_structure
+
+
+if TYPE_CHECKING:
+    from .configuration_doge import *
+    from .modeling_doge import *
+else:
+    import sys
+
+    _file = globals()["__file__"]
+    sys.modules[__name__] = _LazyModule(__name__, _file, define_import_structure(_file), module_spec=__spec__)

LTA_openwebtext_dualt/mini_owt_logdirichlet/.venv_qwen35_uv/lib/python3.12/site-packages/transformers/models/pp_ocrv5_server_det/__init__.py

@@ -0,0 +1,28 @@
+# Copyright 2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+from typing import TYPE_CHECKING
+
+from ...utils import _LazyModule
+from ...utils.import_utils import define_import_structure
+
+
+if TYPE_CHECKING:
+    from .configuration_pp_ocrv5_server_det import *
+    from .image_processing_pp_ocrv5_server_det import *
+    from .modeling_pp_ocrv5_server_det import *
+else:
+    import sys
+
+    _file = globals()["__file__"]
+    sys.modules[__name__] = _LazyModule(__name__, _file, define_import_structure(_file), module_spec=__spec__)

LTA_openwebtext_dualt/mini_owt_logdirichlet/.venv_qwen35_uv/lib/python3.12/site-packages/transformers/models/pp_ocrv5_server_det/configuration_pp_ocrv5_server_det.py

@@ -0,0 +1,87 @@
+#                🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨
+#           This file was automatically generated from src/transformers/models/pp_ocrv5_server_det/modular_pp_ocrv5_server_det.py.
+#               Do NOT edit this file manually as any edits will be overwritten by the generation of
+#             the file from the modular. If any change should be done, please apply the change to the
+#                          modular_pp_ocrv5_server_det.py file directly. One of our CI enforces this.
+#                🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨
+# Copyright 2026 The PaddlePaddle Team and The HuggingFace Inc. team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from huggingface_hub.dataclasses import strict
+
+from ...backbone_utils import consolidate_backbone_kwargs_to_config
+from ...configuration_utils import PreTrainedConfig
+from ...utils import auto_docstring
+from ..auto import AutoConfig
+
+
+@auto_docstring(checkpoint="PaddlePaddle/PP-OCRv5_server_det_safetensors")
+@strict
+class PPOCRV5ServerDetConfig(PreTrainedConfig):
+    r"""
+    interpolate_mode (`str`, *optional*, defaults to `"nearest"`):
+        The interpolation mode used for upsampling or downsampling feature maps in the neck network.
+    neck_out_channels (`int`, *optional*, defaults to 256):
+        The number of output channels from the neck network, responsible for feature fusion and refinement.
+    reduce_factor (`int`, *optional*, defaults to 2):
+        The channel reduction factor used in the neck blocks to balance performance and complexity.
+    intraclass_block_number (`int`, *optional*, defaults to 4):
+        The number of Intra-Class Block modules used for enhancing feature representation.
+    intraclass_block_config (`dict`, *optional*, defaults to `None`):
+        Configuration for the Intra-Class Block modules, if any, used for enhancing feature representation.
+    scale_factor (`int`, *optional*, defaults to 2):
+        The scaling factor used for spatial resolution adjustments in the feature maps.
+    scale_factor_list (`list[int]`, *optional*, defaults to `None`):
+        A list of scaling factors used for spatial resolution adjustments in the feature maps.
+    kernel_list (`list[int]`, *optional*, defaults to `[3, 2, 2]`):
+        The list of kernel sizes for convolutional layers in the head network for multi-scale feature extraction.
+    """
+
+    sub_configs = {"backbone_config": AutoConfig}
+    model_type = "pp_ocrv5_server_det"
+
+    interpolate_mode: str = "nearest"
+    backbone_config: dict | PreTrainedConfig | None = None
+    neck_out_channels: int = 256
+    reduce_factor: int = 2
+    intraclass_block_number: int = 4
+    intraclass_block_config: dict | None = None
+    scale_factor: int = 2
+    scale_factor_list: list | None = None
+    hidden_act: str = "relu"
+    kernel_list: list | None = None
+    id2label: dict[int, str] | dict[str, str] | None = None
+
+    def __post_init__(self, **kwargs):
+        self.backbone_config, kwargs = consolidate_backbone_kwargs_to_config(
+            backbone_config=self.backbone_config,
+            default_config_type="hgnet_v2",
+            default_config_kwargs={
+                "arch": "L",
+                "return_idx": [0, 1, 2, 3],
+                "freeze_stem_only": True,
+                "freeze_at": 0,
+                "freeze_norm": True,
+                "lr_mult_list": [0, 0.05, 0.05, 0.05, 0.05],
+                "out_features": ["stage1", "stage2", "stage3", "stage4"],
+            },
+            **kwargs,
+        )
+
+        # For object detection pipeline compatibility: single class "text"
+        self.id2label = {0: "text"} if self.id2label is None else self.id2label
+        super().__post_init__(**kwargs)
+
+
+__all__ = ["PPOCRV5ServerDetConfig"]

LTA_openwebtext_dualt/mini_owt_logdirichlet/.venv_qwen35_uv/lib/python3.12/site-packages/transformers/models/pp_ocrv5_server_det/modular_pp_ocrv5_server_det.py

@@ -0,0 +1,909 @@
+# Copyright 2026 The PaddlePaddle Team and The HuggingFace Inc. team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import math
+
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import torchvision.transforms.v2.functional as tvF
+from huggingface_hub.dataclasses import strict
+
+from ...activations import ACT2FN
+from ...backbone_utils import consolidate_backbone_kwargs_to_config, load_backbone
+from ...configuration_utils import PreTrainedConfig
+from ...feature_extraction_utils import BatchFeature
+from ...image_processing_backends import TorchvisionBackend
+from ...image_transforms import group_images_by_shape, reorder_images
+from ...image_utils import PILImageResampling, SizeDict
+from ...modeling_outputs import BaseModelOutputWithNoAttention
+from ...modeling_utils import PreTrainedModel
+from ...processing_utils import ImagesKwargs, Unpack
+from ...utils import (
+    TransformersKwargs,
+    auto_docstring,
+    can_return_tuple,
+    is_cv2_available,
+    logging,
+    requires_backends,
+)
+from ...utils.generic import TensorType
+from ...utils.import_utils import requires
+from ..auto import AutoConfig
+
+
+if is_cv2_available():
+    import cv2
+
+
+logger = logging.get_logger(__name__)
+
+
+@auto_docstring(checkpoint="PaddlePaddle/PP-OCRv5_server_det_safetensors")
+@strict
+class PPOCRV5ServerDetConfig(PreTrainedConfig):
+    r"""
+    interpolate_mode (`str`, *optional*, defaults to `"nearest"`):
+        The interpolation mode used for upsampling or downsampling feature maps in the neck network.
+    neck_out_channels (`int`, *optional*, defaults to 256):
+        The number of output channels from the neck network, responsible for feature fusion and refinement.
+    reduce_factor (`int`, *optional*, defaults to 2):
+        The channel reduction factor used in the neck blocks to balance performance and complexity.
+    intraclass_block_number (`int`, *optional*, defaults to 4):
+        The number of Intra-Class Block modules used for enhancing feature representation.
+    intraclass_block_config (`dict`, *optional*, defaults to `None`):
+        Configuration for the Intra-Class Block modules, if any, used for enhancing feature representation.
+    scale_factor (`int`, *optional*, defaults to 2):
+        The scaling factor used for spatial resolution adjustments in the feature maps.
+    scale_factor_list (`list[int]`, *optional*, defaults to `None`):
+        A list of scaling factors used for spatial resolution adjustments in the feature maps.
+    kernel_list (`list[int]`, *optional*, defaults to `[3, 2, 2]`):
+        The list of kernel sizes for convolutional layers in the head network for multi-scale feature extraction.
+    """
+
+    sub_configs = {"backbone_config": AutoConfig}
+    model_type = "pp_ocrv5_server_det"
+
+    interpolate_mode: str = "nearest"
+    backbone_config: dict | PreTrainedConfig | None = None
+    neck_out_channels: int = 256
+    reduce_factor: int = 2
+    intraclass_block_number: int = 4
+    intraclass_block_config: dict | None = None
+    scale_factor: int = 2
+    scale_factor_list: list | None = None
+    hidden_act: str = "relu"
+    kernel_list: list | None = None
+    id2label: dict[int, str] | dict[str, str] | None = None
+
+    def __post_init__(self, **kwargs):
+        self.backbone_config, kwargs = consolidate_backbone_kwargs_to_config(
+            backbone_config=self.backbone_config,
+            default_config_type="hgnet_v2",
+            default_config_kwargs={
+                "arch": "L",
+                "return_idx": [0, 1, 2, 3],
+                "freeze_stem_only": True,
+                "freeze_at": 0,
+                "freeze_norm": True,
+                "lr_mult_list": [0, 0.05, 0.05, 0.05, 0.05],
+                "out_features": ["stage1", "stage2", "stage3", "stage4"],
+            },
+            **kwargs,
+        )
+
+        # For object detection pipeline compatibility: single class "text"
+        self.id2label = {0: "text"} if self.id2label is None else self.id2label
+        super().__post_init__(**kwargs)
+
+
+class PPOCRV5ServerDetImageProcessorKwargs(ImagesKwargs, total=False):
+    r"""
+    limit_side_len (`int`, *optional*, defaults to `960`):
+        Maximum or minimum side length.
+    limit_type (`str`, *optional*, defaults to `max`):
+        Resizing strategy: "max", "min", or "resize_long".
+    max_side_limit (`int`, *optional* defaults to `4000`):
+        Maximum allowed side length.
+    """
+
+    limit_side_len: int
+    limit_type: str
+    max_side_limit: int
+
+
+@auto_docstring
+@requires(backends=("torch",))
+class PPOCRV5ServerDetImageProcessor(TorchvisionBackend):
+    resample = 2
+    image_mean = [0.406, 0.456, 0.485]
+    image_std = [0.225, 0.224, 0.229]
+    size = {"height": 960, "width": 960}
+    do_resize = True
+    do_rescale = True
+    do_normalize = True
+    limit_side_len = 960
+    limit_type = "max"
+    max_side_limit = 4000
+    valid_kwargs = PPOCRV5ServerDetImageProcessorKwargs
+
+    def _preprocess(
+        self,
+        images: list["torch.Tensor"],
+        do_resize: bool,
+        size: SizeDict,
+        resample: "PILImageResampling | tvF.InterpolationMode | int | None",
+        do_rescale: bool,
+        rescale_factor: float,
+        do_normalize: bool,
+        image_mean: float | list[float] | None,
+        image_std: float | list[float] | None,
+        limit_side_len: int,
+        limit_type: str,
+        max_side_limit: int,
+        disable_grouping: bool | None,
+        return_tensors: str | TensorType | None,
+        **kwargs,
+    ) -> BatchFeature:
+        target_sizes = []
+
+        # Group images by their original spatial shape to enable batched resizing (optimization for efficiency)
+        # [Key Change] Unlike the original implementation, we now track target shapes for each original shape group
+        grouped_images, grouped_images_index = group_images_by_shape(images, disable_grouping=disable_grouping)
+        # Store resized image batches mapped to their original shape keys
+        resized_images_grouped = {}
+        # [Key Change] Core addition: Mapping from original image shape to target resize shape
+        # This dict ensures consistent target shape handling across all subsequent operations (resize/processing)
+        target_shape_per_shape = {}
+        for shape, stacked_images in grouped_images.items():
+            if do_resize:
+                resize_size, target_shape = self.get_image_size(
+                    stacked_images[0], limit_side_len, limit_type, max_side_limit
+                )
+                target_shape_per_shape[shape] = target_shape
+                stacked_images = self.resize(image=stacked_images.float(), size=resize_size, resample=resample)
+            resized_images_grouped[shape] = stacked_images
+
+        resized_images = reorder_images(resized_images_grouped, grouped_images_index)
+        if do_resize:
+            target_sizes = [target_shape_per_shape[grouped_images_index[i][0]] for i in range(len(images))]
+
+        # Group images by size for further processing
+        grouped_images, grouped_images_index = group_images_by_shape(resized_images, disable_grouping=disable_grouping)
+        processed_images_grouped = {}
+        for shape, stacked_images in grouped_images.items():
+            stacked_images = self.rescale_and_normalize(
+                stacked_images, do_rescale, rescale_factor, do_normalize, image_mean, image_std
+            )
+            # BGR to RGB conversion
+            stacked_images = stacked_images[:, [2, 1, 0], :, :]
+            processed_images_grouped[shape] = stacked_images
+
+        pixel_values = reorder_images(processed_images_grouped, grouped_images_index)
+
+        return BatchFeature(
+            data={"pixel_values": pixel_values, "target_sizes": target_sizes},
+            tensor_type=return_tensors,
+        )
+
+    def _unclip(self, contour_box, unclip_ratio):
+        """
+        Expands (dilates) a detected text bounding box to recover the full text region.
+
+        Args:
+            contour_box (np.ndarray): Input contour of shape (N, 2), where N is the number of points.
+            unclip_ratio (float): Expansion ratio, typically greater than 1.0.
+
+        Returns:
+            np.ndarray: Expanded contour of shape (M, 2).
+        """
+        # --- 1. Parameter calculation ---
+        polygon = contour_box.reshape(-1, 2).astype(np.float32)
+        perimeter = cv2.arcLength(polygon, True)
+        area = cv2.contourArea(polygon)
+        offset_distance = area * unclip_ratio / perimeter
+
+        # --- 2. Determine polygon orientation and edge normals ---
+        x, y = polygon[:, 0], polygon[:, 1]
+        is_counter_clockwise = (x @ np.roll(y, -1) - y @ np.roll(x, -1)) > 0.0
+
+        edges = np.roll(polygon, -1, axis=0) - polygon
+        edge_lengths = np.linalg.norm(edges, axis=1, keepdims=True)
+        edge_directions = edges / np.maximum(edge_lengths, 1e-6)
+
+        if is_counter_clockwise:
+            normals = np.stack([edge_directions[:, 1], -edge_directions[:, 0]], axis=1)
+        else:
+            normals = np.stack([-edge_directions[:, 1], edge_directions[:, 0]], axis=1)
+
+        # --- 3. Calculate new vertices from intersecting shifted edge lines ---
+        shifted_points = polygon + offset_distance * normals
+
+        prev_shifted_points = np.roll(shifted_points, 1, axis=0)
+        prev_edge_directions = np.roll(edge_directions, 1, axis=0)
+
+        cross_product = (
+            prev_edge_directions[:, 0] * edge_directions[:, 1] - prev_edge_directions[:, 1] * edge_directions[:, 0]
+        )
+
+        is_parallel_mask = np.abs(cross_product) < 1e-6
+        cross_product_safe = np.where(is_parallel_mask, 1.0, cross_product)
+
+        vec_to_current = shifted_points - prev_shifted_points
+        intersection_param = (
+            vec_to_current[:, 0] * edge_directions[:, 1] - vec_to_current[:, 1] * edge_directions[:, 0]
+        ) / cross_product_safe
+
+        new_vertices = prev_shifted_points + prev_edge_directions * intersection_param[:, None]
+
+        # --- 4. Handle near-parallel adjacent edges with a fallback ---
+        if np.any(is_parallel_mask):
+            prev_normals = np.roll(normals, 1, axis=0)
+            fallback_points = polygon + 0.5 * offset_distance * (prev_normals + normals)
+            new_vertices[is_parallel_mask] = fallback_points[is_parallel_mask]
+
+        return np.array([new_vertices.astype(np.float32)])
+
+    def _get_mini_boxes(self, contour):
+        """
+        Computes the minimum-area bounding rectangle for a given contour and returns
+        its four corners in a consistent order (top-left, bottom-left, bottom-right, top-right).
+
+        Args:
+            contour (np.ndarray): Input contour of shape (N, 1, 2).
+
+        Returns:
+            tuple:
+                - box (list): List of four corner points in order.
+                - short_side_length (float): Length of the shorter side of the bounding rectangle.
+        """
+        bounding_box = cv2.minAreaRect(contour)
+        points = sorted(cv2.boxPoints(bounding_box), key=lambda x: x[0])
+
+        index_1, index_2, index_3, index_4 = 0, 1, 2, 3
+        if points[1][1] > points[0][1]:
+            index_1 = 0
+            index_4 = 1
+        else:
+            index_1 = 1
+            index_4 = 0
+        if points[3][1] > points[2][1]:
+            index_2 = 2
+            index_3 = 3
+        else:
+            index_2 = 3
+            index_3 = 2
+
+        box = [points[index_1], points[index_2], points[index_3], points[index_4]]
+        return box, min(bounding_box[1])
+
+    def _get_box_score(self, bitmap: np.ndarray, polygon_bounding_box: np.ndarray):
+        """
+        Computes the mean score of a bounding box region in the prediction map using
+        a fast approach with axis-aligned bounding boxes.
+
+        Args:
+            bitmap (np.ndarray): Binary or float prediction map of shape (H, W).
+            polygon_bounding_box (np.ndarray): Bounding box polygon of shape (N, 2).
+
+        Returns:
+            float: Mean score within the bounding box region.
+        """
+        height, width = bitmap.shape[:2]
+        box = polygon_bounding_box.copy()
+        xmin = max(0, min(math.floor(box[:, 0].min()), width - 1))
+        xmax = max(0, min(math.ceil(box[:, 0].max()), width - 1))
+        ymin = max(0, min(math.floor(box[:, 1].min()), height - 1))
+        ymax = max(0, min(math.ceil(box[:, 1].max()), height - 1))
+
+        mask = np.zeros((ymax - ymin + 1, xmax - xmin + 1), dtype=np.uint8)
+        box[:, 0] = box[:, 0] - xmin
+        box[:, 1] = box[:, 1] - ymin
+        cv2.fillPoly(mask, box.reshape(1, -1, 2).astype(np.int32), 1)
+        return cv2.mean(bitmap[ymin : ymax + 1, xmin : xmax + 1], mask)[0]
+
+    def _boxes_from_bitmap(
+        self,
+        prediction: np.ndarray,
+        bitmap: np.ndarray,
+        dest_width: int,
+        dest_height: int,
+        box_threshold: float,
+        unclip_ratio: float,
+        min_size: int,
+        max_candidates: int,
+    ):
+        """
+        Extracts axis-aligned or rotated bounding boxes from a binary segmentation map.
+
+        Args:
+            prediction (np.ndarray): Raw prediction map of shape (H, W).
+            bitmap (np.ndarray): Binarized segmentation map of shape (H, W).
+            dest_width (int): Original image width for scaling back.
+            dest_height (int): Original image height for scaling back.
+            box_threshold (float): Score threshold for filtering low-confidence boxes.
+            unclip_ratio (float): Expansion ratio for contour unclipping.
+            min_size (int): Minimum side length of valid boxes.
+            max_candidates (int): Maximum number of contours to process.
+
+        Returns:
+            tuple:
+                - boxes (np.ndarray): Array of boxes, each of shape (4, 2).
+                - scores (list): List of corresponding scores.
+        """
+
+        height, width = bitmap.shape
+        width_scale = dest_width / width
+        height_scale = dest_height / height
+
+        outs = cv2.findContours((bitmap * 255).astype(np.uint8), cv2.RETR_LIST, cv2.CHAIN_APPROX_SIMPLE)
+
+        contours = outs[1] if len(outs) == 3 else outs[0]
+
+        num_contours = min(len(contours), max_candidates)
+
+        boxes = []
+        scores = []
+        for index in range(num_contours):
+            contour = contours[index]
+            points, short_side_length = self._get_mini_boxes(contour)
+            if short_side_length < min_size:
+                continue
+            points = np.array(points)
+            score = self._get_box_score(prediction, points.reshape(-1, 2))
+            if box_threshold > score:
+                continue
+            box = self._unclip(points, unclip_ratio).reshape(-1, 1, 2)
+            box, short_side_length = self._get_mini_boxes(box)
+            if short_side_length < min_size + 2:
+                continue
+
+            box = np.array(box)
+            for i in range(box.shape[0]):
+                box[i, 0] = max(0, min(round(box[i, 0] * width_scale), dest_width))
+                box[i, 1] = max(0, min(round(box[i, 1] * height_scale), dest_height))
+
+            boxes.append(box.astype(np.int16))
+            scores.append(score)
+        return np.array(boxes, dtype=np.int16), scores
+
+    def get_image_size(
+        self,
+        image: "torch.Tensor",
+        limit_side_len: int,
+        limit_type: str,
+        max_side_limit: int,
+    ):
+        """
+        Computes the target size for resizing an image while preserving aspect ratio.
+
+        Args:
+            image (torch.Tensor): Input image.
+            limit_side_len (int): Maximum or minimum side length.
+            limit_type (str): Resizing strategy: "max", "min", or "resize_long".
+            max_side_limit (int): Maximum allowed side length.
+
+        Returns:
+            tuple:
+                - SizeDict: Target size.
+                - torch.Tensor: Original size.
+        """
+        _, height, width = image.shape
+        height, width = int(height), int(width)
+
+        if limit_type == "max":
+            if max(height, width) > limit_side_len:
+                ratio = float(limit_side_len) / max(height, width)
+            else:
+                ratio = 1.0
+        elif limit_type == "min":
+            if min(height, width) < limit_side_len:
+                ratio = float(limit_side_len) / min(height, width)
+            else:
+                ratio = 1.0
+        elif limit_type == "resize_long":
+            ratio = float(limit_side_len) / max(height, width)
+        else:
+            raise ValueError(f"PPOCRV5ServerDetImageProcessor does not support limit type: {limit_type}")
+
+        resize_height = int(height * ratio)
+        resize_width = int(width * ratio)
+
+        if max_side_limit is not None and max(resize_height, resize_width) > max_side_limit:
+            ratio = float(max_side_limit) / max(resize_height, resize_width)
+            resize_height = int(resize_height * ratio)
+            resize_width = int(resize_width * ratio)
+
+        resize_height = max(int(round(resize_height / 32) * 32), 32)
+        resize_width = max(int(round(resize_width / 32) * 32), 32)
+
+        return SizeDict(height=resize_height, width=resize_width), torch.tensor(
+            [height, width], dtype=torch.float32, device=image.device
+        )
+
+    def post_process_object_detection(
+        self,
+        predictions,
+        threshold: float = 0.3,
+        target_sizes: list[tuple[int, int]] | TensorType | None = None,
+        box_threshold: float = 0.6,
+        max_candidates: int = 1000,
+        min_size: int = 3,
+        unclip_ratio: float = 1.5,
+    ):
+        """
+        Converts model outputs into detected text boxes in corners format (xmin, ymin, xmax, ymax).
+
+        Args:
+            predictions: Model outputs with `logits` attribute (probability maps of shape `(batch_size, 1, H, W)`).
+            threshold (float): Binarization threshold.
+            target_sizes: Original image sizes (height, width) per image.
+            box_threshold (float): Box score threshold.
+            max_candidates (int): Maximum number of boxes.
+            min_size (int): Minimum box size.
+            unclip_ratio (float): Expansion ratio.
+
+        Returns:
+            list[dict]: List of detection results per image. Each dict contains:
+                - "boxes": `torch.Tensor` of shape `(N, 4)` in corners format (xmin, ymin, xmax, ymax)
+                - "scores": `torch.Tensor` of shape `(N,)`
+                - "labels": `torch.Tensor` of shape `(N,)` (class id 0 for text)
+        """
+        requires_backends(self, ["torch", "cv2"])
+        if target_sizes is None:
+            raise ValueError("target_sizes must be provided for post_process_object_detection")
+
+        device = predictions.last_hidden_state.device
+        results = []
+        for prediction, size in zip(predictions.last_hidden_state, target_sizes):
+            prediction = prediction[0, :, :].cpu().detach().numpy()
+            size = size.cpu().detach().numpy()
+            src_height, src_width = size
+            mask = prediction > threshold
+            boxes, scores = self._boxes_from_bitmap(
+                prediction, mask, src_width, src_height, box_threshold, unclip_ratio, min_size, max_candidates
+            )
+
+            results.append(
+                {
+                    "boxes": torch.from_numpy(boxes).to(device),
+                    "scores": torch.tensor(scores, dtype=torch.float32, device=device),
+                    "labels": torch.zeros(len(scores), dtype=torch.long, device=device),  # Single class: text
+                }
+            )
+        return results
+
+
+class PPOCRV5ServerDetIntraclassBlock(nn.Module):
+    """
+    Intra-Class Relationship Block. It uses multi-scale convolution (7x7, 5x5, 3x3)
+    and asymmetric kernels (e.g., 7x1, 1x7) to capture long-range spatial dependencies
+    within text regions.
+    """
+
+    def __init__(
+        self,
+        intraclass_block_config: dict | None = None,
+        in_channels: int = 96,
+        reduce_factor: int = 4,
+    ):
+        super().__init__()
+
+        reduced_channels = in_channels // reduce_factor
+
+        self.conv_reduce_channel = nn.Conv2d(in_channels, reduced_channels, *intraclass_block_config["reduce_channel"])
+
+        self.vertical_long_to_small_conv_longratio = nn.Conv2d(
+            reduced_channels, reduced_channels, *intraclass_block_config["vertical_long_to_small_conv_longratio"]
+        )
+        self.vertical_long_to_small_conv_midratio = nn.Conv2d(
+            reduced_channels, reduced_channels, *intraclass_block_config["vertical_long_to_small_conv_midratio"]
+        )
+        self.vertical_long_to_small_conv_shortratio = nn.Conv2d(
+            reduced_channels, reduced_channels, *intraclass_block_config["vertical_long_to_small_conv_shortratio"]
+        )
+
+        self.horizontal_small_to_long_conv_longratio = nn.Conv2d(
+            reduced_channels, reduced_channels, *intraclass_block_config["horizontal_small_to_long_conv_longratio"]
+        )
+        self.horizontal_small_to_long_conv_midratio = nn.Conv2d(
+            reduced_channels, reduced_channels, *intraclass_block_config["horizontal_small_to_long_conv_midratio"]
+        )
+        self.horizontal_small_to_long_conv_shortratio = nn.Conv2d(
+            reduced_channels, reduced_channels, *intraclass_block_config["horizontal_small_to_long_conv_shortratio"]
+        )
+
+        self.symmetric_conv_long_longratio = nn.Conv2d(
+            reduced_channels, reduced_channels, *intraclass_block_config["symmetric_conv_long_longratio"]
+        )
+        self.symmetric_conv_long_midratio = nn.Conv2d(
+            reduced_channels, reduced_channels, *intraclass_block_config["symmetric_conv_long_midratio"]
+        )
+        self.symmetric_conv_long_shortratio = nn.Conv2d(
+            reduced_channels, reduced_channels, *intraclass_block_config["symmetric_conv_long_shortratio"]
+        )
+
+        self.conv_final = PPOCRV5ServerDetConvBatchnormLayer(
+            in_channels=reduced_channels,
+            out_channels=in_channels,
+            kernel_size=intraclass_block_config["return_channel"][0],
+            stride=intraclass_block_config["return_channel"][1],
+            padding=intraclass_block_config["return_channel"][2],
+            bias=True,
+        )
+
+    def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+        residual = hidden_states
+        hidden_states = self.conv_reduce_channel(hidden_states)
+
+        hidden_states = (
+            self.symmetric_conv_long_longratio(hidden_states)
+            + self.vertical_long_to_small_conv_longratio(hidden_states)
+            + self.horizontal_small_to_long_conv_longratio(hidden_states)
+        )
+        hidden_states = (
+            self.symmetric_conv_long_midratio(hidden_states)
+            + self.vertical_long_to_small_conv_midratio(hidden_states)
+            + self.horizontal_small_to_long_conv_midratio(hidden_states)
+        )
+        hidden_states = (
+            self.symmetric_conv_long_shortratio(hidden_states)
+            + self.vertical_long_to_small_conv_shortratio(hidden_states)
+            + self.horizontal_small_to_long_conv_shortratio(hidden_states)
+        )
+
+        hidden_states = self.conv_final(hidden_states)
+
+        return residual + hidden_states
+
+
+class PPOCRV5ServerDetNeck(nn.Module):
+    """
+    Large Kernel Path Aggregation Network (Neck) for PPOCRV5 Server Detection.
+    Fuses multi-scale features from backbone stages (stage 2 to stage 5) via top-down and bottom-up paths,
+    enhanced with large kernel convolution for better spatial dependency modeling.
+    """
+
+    def __init__(self, config):
+        super().__init__()
+        self.interpolate_mode = config.interpolate_mode
+        self.scale_factor_list = config.scale_factor_list
+        self.num_backbone_stages = len(config.backbone_config.stage_out_channels)
+
+        self.input_channel_adjustment_convolution = nn.ModuleList()
+        self.input_feature_projection_convolution = nn.ModuleList()
+        self.path_aggregation_head_convolution = nn.ModuleList()
+        self.path_aggregation_lateral_convolution = nn.ModuleList()
+
+        backbone_stage_output_channels = config.backbone_config.stage_out_channels
+
+        for backbone_stage_index in range(len(backbone_stage_output_channels)):
+            channel_adjustment_convolution = nn.Conv2d(
+                in_channels=backbone_stage_output_channels[backbone_stage_index],
+                out_channels=config.neck_out_channels,
+                kernel_size=1,
+                bias=False,
+            )
+            self.input_channel_adjustment_convolution.append(channel_adjustment_convolution)
+
+            feature_projection_convolution = nn.Conv2d(
+                in_channels=config.neck_out_channels,
+                out_channels=config.neck_out_channels // 4,
+                kernel_size=9,
+                padding=4,
+                bias=False,
+            )
+            self.input_feature_projection_convolution.append(feature_projection_convolution)
+
+            if backbone_stage_index > 0:
+                pan_head_convolution = nn.Conv2d(
+                    in_channels=config.neck_out_channels // 4,
+                    out_channels=config.neck_out_channels // 4,
+                    kernel_size=3,
+                    padding=1,
+                    stride=2,
+                    bias=False,
+                )
+                self.path_aggregation_head_convolution.append(pan_head_convolution)
+
+            pan_lateral_convolution = nn.Conv2d(
+                in_channels=config.neck_out_channels // 4,
+                out_channels=config.neck_out_channels // 4,
+                kernel_size=9,
+                padding=4,
+                bias=False,
+            )
+            self.path_aggregation_lateral_convolution.append(pan_lateral_convolution)
+
+        self.intraclass_blocks = nn.ModuleList()
+        for _ in range(config.intraclass_block_number):
+            self.intraclass_blocks.append(
+                PPOCRV5ServerDetIntraclassBlock(
+                    config.intraclass_block_config, config.neck_out_channels // 4, reduce_factor=config.reduce_factor
+                )
+            )
+
+    def forward(self, backbone_stage_feature_maps: list[torch.Tensor], **kwargs) -> torch.Tensor:
+        channel_adjusted = []
+        for i, feature_map in enumerate(backbone_stage_feature_maps):
+            hidden_states = self.input_channel_adjustment_convolution[i](feature_map)
+            channel_adjusted.append(hidden_states)
+
+        top_down = [None] * self.num_backbone_stages
+        top_down[3] = channel_adjusted[3]
+        for i in range(self.num_backbone_stages - 2, -1, -1):
+            top_down[i] = channel_adjusted[i] + F.interpolate(
+                top_down[i + 1], scale_factor=2, mode=self.interpolate_mode
+            )
+
+        projected = []
+        for i in range(self.num_backbone_stages):
+            hidden_states = top_down[i] if i < self.num_backbone_stages - 1 else channel_adjusted[-1]
+            hidden_states = self.input_feature_projection_convolution[i](hidden_states)
+            projected.append(hidden_states)
+
+        bottom_up = [None] * self.num_backbone_stages
+        bottom_up[0] = projected[0]
+        for i in range(1, self.num_backbone_stages):
+            bottom_up[i] = projected[i] + self.path_aggregation_head_convolution[i - 1](bottom_up[i - 1])
+
+        lateral_refined = []
+        for i in range(self.num_backbone_stages):
+            hidden_states = projected[0] if i == 0 else bottom_up[i]
+            hidden_states = self.path_aggregation_lateral_convolution[i](hidden_states)
+            lateral_refined.append(hidden_states)
+
+        intraclass_refined = [block(feature) for block, feature in zip(self.intraclass_blocks, lateral_refined)]
+
+        upsampled = []
+        for feature, scale_factor in zip(intraclass_refined, self.scale_factor_list):
+            if scale_factor > 1:
+                hidden_states = F.interpolate(feature, scale_factor=scale_factor, mode=self.interpolate_mode)
+            else:
+                hidden_states = feature
+            upsampled.append(hidden_states)
+
+        upsampled = [
+            F.interpolate(feature, scale_factor=scale_factor, mode=self.interpolate_mode)
+            if scale_factor > 1
+            else feature
+            for feature, scale_factor in zip(intraclass_refined, self.scale_factor_list)
+        ]
+
+        return torch.cat(upsampled[::-1], dim=1)
+
+
+class PPOCRV5ServerDetConvBatchnormLayer(nn.Module):
+    """
+    A basic wrapper for Convolution-BatchNorm-Activation, typically used for head components.
+    """
+
+    def __init__(
+        self,
+        in_channels: int,
+        out_channels: int,
+        kernel_size: int,
+        stride: int = 1,
+        padding: int | str = 1,
+        groups: int = 1,
+        activation: str = "relu",
+        bias: bool = False,
+        convolution_transpose: bool = False,
+    ):
+        super().__init__()
+        if convolution_transpose:
+            self.convolution = nn.ConvTranspose2d(
+                in_channels=in_channels,
+                out_channels=out_channels,
+                kernel_size=kernel_size,
+                stride=stride,
+            )
+        else:
+            self.convolution = nn.Conv2d(
+                in_channels=in_channels,
+                out_channels=out_channels,
+                kernel_size=kernel_size,
+                stride=stride,
+                padding=padding,
+                groups=groups,
+                bias=bias,
+            )
+
+        self.norm = nn.BatchNorm2d(out_channels)
+        self.act_fn = nn.Identity() if activation is None else ACT2FN[activation]
+
+    def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+        hidden_states = self.convolution(hidden_states)
+        hidden_states = self.norm(hidden_states)
+        hidden_states = self.act_fn(hidden_states)
+        return hidden_states
+
+
+class PPOCRV5ServerDetSegmentationHead(nn.Module):
+    """
+    Standard segmentation head for generating probability maps. It uses transposed
+    convolution to upsample the feature map back to the original image size.
+    """
+
+    def __init__(
+        self,
+        config: PPOCRV5ServerDetConfig,
+    ):
+        super().__init__()
+
+        in_channels = config.neck_out_channels
+        kernel_list = config.kernel_list
+        self.conv_down = PPOCRV5ServerDetConvBatchnormLayer(
+            in_channels=in_channels,
+            out_channels=in_channels // 4,
+            kernel_size=kernel_list[0],
+            padding=int(kernel_list[0] // 2),
+        )
+        self.conv_up = PPOCRV5ServerDetConvBatchnormLayer(
+            in_channels=in_channels // 4,
+            out_channels=in_channels // 4,
+            kernel_size=kernel_list[1],
+            stride=2,
+            convolution_transpose=True,
+        )
+
+        self.conv_final = nn.ConvTranspose2d(
+            in_channels=in_channels // 4,
+            out_channels=1,
+            kernel_size=kernel_list[2],
+            stride=2,
+        )
+
+    def forward(self, hidden_states: torch.Tensor) -> tuple[torch.Tensor, torch.Tensor]:
+        hidden_states = self.conv_down(hidden_states)
+        hidden_states = self.conv_up(hidden_states)
+        feature = hidden_states
+        hidden_states = self.conv_final(hidden_states)
+        hidden_states = torch.sigmoid(hidden_states)
+        return hidden_states, feature
+
+
+class PPOCRV5ServerDetLocalModule(nn.Module):
+    """
+    Local Refinement Module that refines the initial probability map by
+    concatenating it with higher-resolution features.
+    """
+
+    def __init__(self, in_channels: int, out_channels: int, hidden_act: str):
+        super().__init__()
+        self.convolution_backbone = PPOCRV5ServerDetConvBatchnormLayer(
+            in_channels=in_channels + 1,
+            out_channels=out_channels,
+            kernel_size=3,
+            stride=1,
+            padding=1,
+            activation=hidden_act,
+        )
+        self.convolution_final = nn.Conv2d(
+            in_channels=out_channels,
+            out_channels=1,
+            kernel_size=1,
+            stride=1,
+            padding=0,
+        )
+
+    def forward(self, hidden_states: torch.Tensor, init_map: torch.Tensor) -> torch.Tensor:
+        hidden_states = torch.cat([init_map, hidden_states], dim=1)
+        # last Conv
+        hidden_states = self.convolution_backbone(hidden_states)
+        hidden_states = self.convolution_final(hidden_states)
+        return hidden_states
+
+
+class PPOCRV5ServerDetHead(nn.Module):
+    """
+    PPOCRV5ServerDetHead implements the Progressive Fusion Head with Local refinement,
+    the core detection head of PP-OCRv5.
+    """
+
+    def __init__(self, config: PPOCRV5ServerDetConfig):
+        super().__init__()
+        self.binarize_head = PPOCRV5ServerDetSegmentationHead(config)
+        self.upsample_convolution = nn.Upsample(scale_factor=config.scale_factor, mode=config.interpolate_mode)
+
+        self.local_refinement_module = PPOCRV5ServerDetLocalModule(
+            config.neck_out_channels // 4, config.neck_out_channels // 4, config.hidden_act
+        )
+
+    def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+        hidden_states, feature = self.binarize_head(hidden_states)
+        residual = hidden_states
+        feature = self.upsample_convolution(feature)
+        hidden_states = self.local_refinement_module(feature, hidden_states)
+        hidden_states = torch.sigmoid(hidden_states)
+
+        return 0.5 * (residual + hidden_states)
+
+
+class PPOCRV5ServerDetPreTrainedModel(PreTrainedModel):
+    """
+    Base class for all PPOCRV5 Server Det pre-trained models. Handles model initialization,
+    configuration, and loading of pre-trained weights, following the Transformers library conventions.
+    """
+
+    config: PPOCRV5ServerDetConfig
+    base_model_prefix = "pp_ocrv5_server_det"
+    main_input_name = "pixel_values"
+    input_modalities = ("image",)
+    _can_compile_fullgraph = True
+
+
+@auto_docstring
+class PPOCRV5ServerDetModel(PPOCRV5ServerDetPreTrainedModel):
+    def __init__(self, config: PPOCRV5ServerDetConfig):
+        super().__init__(config)
+        self.backbone = load_backbone(config)
+        self.neck = PPOCRV5ServerDetNeck(config)
+        self.post_init()
+
+    @can_return_tuple
+    @auto_docstring
+    def forward(
+        self,
+        pixel_values: torch.FloatTensor,
+        **kwargs: Unpack[TransformersKwargs],
+    ) -> tuple[torch.FloatTensor] | BaseModelOutputWithNoAttention:
+        backbone_outputs = self.backbone(pixel_values, **kwargs)
+        hidden_state = backbone_outputs.feature_maps
+        hidden_state = self.neck(hidden_state)
+
+        return BaseModelOutputWithNoAttention(
+            last_hidden_state=hidden_state,
+            hidden_states=backbone_outputs.hidden_states,
+        )
+
+
+@auto_docstring(
+    custom_intro="""
+    PPOCRV5 Server Det model for object (text) detection tasks. Wraps the core PPOCRV5ServerDetModel
+    and returns outputs compatible with the Transformers object detection API.
+    """
+)
+class PPOCRV5ServerDetForObjectDetection(PPOCRV5ServerDetPreTrainedModel):
+    _keys_to_ignore_on_load_missing = ["num_batches_tracked"]
+
+    def __init__(self, config: PPOCRV5ServerDetConfig):
+        super().__init__(config)
+        self.model = PPOCRV5ServerDetModel(config)
+        self.head = PPOCRV5ServerDetHead(config)
+        self.post_init()
+
+    @can_return_tuple
+    def forward(
+        self,
+        pixel_values: torch.FloatTensor,
+        **kwargs: Unpack[TransformersKwargs],
+    ) -> tuple[torch.FloatTensor] | BaseModelOutputWithNoAttention:
+        outputs = self.model(pixel_values, **kwargs)
+        logits = self.head(outputs.last_hidden_state)
+
+        return BaseModelOutputWithNoAttention(
+            last_hidden_state=logits,
+            hidden_states=outputs.hidden_states,
+        )
+
+
+__all__ = [
+    "PPOCRV5ServerDetForObjectDetection",
+    "PPOCRV5ServerDetImageProcessor",
+    "PPOCRV5ServerDetConfig",
+    "PPOCRV5ServerDetModel",
+    "PPOCRV5ServerDetPreTrainedModel",
+]

LTA_openwebtext_dualt/mini_owt_logdirichlet/runs/owt_t5_elftokenized_full_len1024_C1_to_1024_pow1_d768_l12_h12_gbs512_2x8gpu_50ep_lr1e3_ema0p9999_elfopt_not5_bottleneck128_unfixed_norm_stateprobadd_selfcond_ce_fast_20260609_155046/step_088000.pt

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

LTA_openwebtext_dualt/mini_owt_logdirichlet/runs/owt_t5_elftokenized_full_len1024_C1_to_1024_pow1_d768_l12_h12_gbs512_2x8gpu_50ep_lr1e3_ema0p9999_elfopt_not5_bottleneck128_unfixed_norm_stateprobadd_selfcond_ce_fast_20260609_155046/step_202000.pt

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

LTA_openwebtext_dualt/mini_owt_logdirichlet/runs/owt_t5_elftokenized_full_len1024_C1_to_1024_pow1_d768_l12_h12_gbs512_2x8gpu_50ep_lr1e3_ema0p9999_elfopt_not5_bottleneck128_unfixed_norm_stateprobadd_selfcond_ce_fast_20260609_155046/step_224000.pt

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

LTA_openwebtext_dualt/mini_owt_logdirichlet/runs/owt_t5_elftokenized_full_len1024_C1_to_1024_pow1_d768_l12_h12_gbs512_2x8gpu_50ep_lr1e3_ema0p9999_elfopt_not5_bottleneck128_unfixed_norm_stateprobadd_selfcond_ce_fast_20260609_155046/step_230000.pt

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

LTA_openwebtext_dualt/mini_owt_logdirichlet/runs/owt_t5_elftokenized_full_len1024_C1_to_1024_pow1_d768_l12_h12_gbs512_2x8gpu_50ep_lr1e3_ema0p9999_elfopt_not5_bottleneck128_unfixed_norm_stateprobadd_selfcond_ce_fast_20260609_155046/step_354000.pt

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