Add files using upload-large-folder tool

LTA_openwebtext_dualt/logs/lta_owt_bert_absrope_time4_dirichlet_len1024_C1_to_1024_mask1_sameT_gbs512_b32_8gpu_1m_save10k_20260526_watcher.sh

@@ -0,0 +1,117 @@
+#!/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} decode_mode=${DECODE_MODE:-sde_gumbel} 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}"
+    if [[ "${DECODE_MODE:-sde_gumbel}" == "dual_line_probe" ]]; then
+      CUDA_VISIBLE_DEVICES="${WATCH_CUDA_VISIBLE_DEVICES}" python scripts/infer_softkl_decode_probe.py \
+        --checkpoint "${ckpt}" \
+        --tokenizer_path "${TOKENIZER_PATH}" \
+        --scorer "${SCORER}" \
+        --score \
+        --out_dir "${out_dir}" \
+        --max_lens "${MAX_LEN}" \
+        --n_samples "${N_SAMPLES}" \
+        --batch_size "${DECODE_BATCH}" \
+        --steps "${STEPS}" \
+        --decode_rule dual_line_resample \
+        --c_min "${CMIN}" \
+        --c_max "${CMAX}" \
+        --input_noise_dirichlet_concentration "${CMIN}" \
+        --anchor_mode state \
+        --model_t_mode flow \
+        --time_schedule uniform \
+        --support_power 1.0 \
+        --semantic_power "${DUAL_SEMANTIC_POWER}" \
+        --early_temp "${DUAL_EARLY_TEMP}" \
+        --late_temp "${DUAL_LATE_TEMP}" \
+        --temp_end "${DUAL_TEMP_END}" \
+        --temp_power "${DUAL_TEMP_POWER}" \
+        --final_from blend \
+        --final_decode argmax \
+        --seed 20260524 \
+        2>&1 | tee -a "${log_file}"
+    else
+      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}"
+    fi
+
+    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_gpt2cached_len1024_rollout1_p05_b64_mlpckpt2_bench4gpu_20260513_161437.log

@@ -0,0 +1,150 @@
+NCCL version 2.25.1+cuda12.8
+{
+  "device": "cuda:0",
+  "rank": 0,
+  "world_size": 4,
+  "samples": "owt_cached_chunks:8734897",
+  "vocab_size": 50257,
+  "tokenizer_vocab_size": 50257,
+  "save_dir": "runs/lta_owt_gpt2cached_len1024_rollout1_p05_b64_mlpckpt2_bench4gpu_20260513_161437",
+  "batch_size": 64,
+  "grad_accum": 1,
+  "effective_batch_size": 256,
+  "global_batch_size": 256,
+  "lr_schedule": "cosine",
+  "optimizer": "adamw",
+  "warmup_steps": 2,
+  "min_lr": 6e-05,
+  "weight_decay": 0.1,
+  "adamw_param_groups": "nanogpt",
+  "adam_beta1": 0.9,
+  "adam_beta2": 0.95,
+  "adam_eps": 1e-08,
+  "muon_momentum": 0.95,
+  "muon_ns_steps": 5,
+  "muon_update_scale": 1.0,
+  "ema_decay": 0.0,
+  "ema_start_step": 0,
+  "model_type": "ddit",
+  "dual_t": true,
+  "corrupt_t_mode": "same",
+  "corrupt_min_t": 0.0,
+  "corrupt_max_t": 1.0,
+  "prefix_block_prob": 0.0,
+  "prefix_block_len": 128,
+  "dirichlet_endpoint_mode": "categorical_dual_t",
+  "dirichlet_semantic_t_mode": "same",
+  "dirichlet_semantic_t_value": 0.0,
+  "categorical_wrong_from_full_vocab": true,
+  "categorical_wrong_from_batch_valid_tokens": false,
+  "mask_mixture_original_prob": 0.0,
+  "mask_mixture_lowk_prob": 0.0,
+  "mask_mixture_lowcorrupt_prob": 0.0,
+  "mask_mixture_block_prob": 0.0,
+  "mask_mixture_all_prob": 0.0,
+  "mask_mixture_lowk_clean_tokens": "1,2,4,8,16,32,64",
+  "mask_mixture_lowcorrupt_tokens": "1,2,4,8,16,32,64",
+  "mask_mixture_block_tokens": "64,128",
+  "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,
+  "rollout_train_prob": 0.5,
+  "rollout_train_steps": 1,
+  "rollout_train_infer_steps": 64,
+  "rollout_train_temp": 1.45,
+  "rollout_train_max_gamma": 1.0,
+  "rollout_train_corrupt_only": true,
+  "rollout_train_samplewise": false,
+  "rollout_train_compute_always": false,
+  "bridge_noise_init": "logistic_normal",
+  "noise_sigma": -1.0,
+  "allow_tf32": true,
+  "activation_checkpointing": true,
+  "activation_checkpoint_interval": 1,
+  "activation_checkpoint_scope": "mlp",
+  "ddp_static_graph": false,
+  "ddp_gradient_as_bucket_view": true,
+  "blocking_data_transfer": false,
+  "dataloader_prefetch_factor": 4,
+  "full_train_stats": false,
+  "record_pad_truncate": false,
+  "record_add_eos": false,
+  "record_add_special_tokens": false,
+  "record_pad_token": "pad",
+  "record_shuffle_buffer": 10000,
+  "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_len1024_train_minus_100k",
+  "owt_chunk_cache_rebuild": false,
+  "owt_chunk_cache_write_batch": 4096,
+  "owt_exact_repeat_per_chunk": 0,
+  "online_chunk_shuffle": false,
+  "online_chunk_shuffle_buffer": 10000,
+  "openwebtext_split": "train_minus_100k",
+  "detokenizer": "auto",
+  "resolved_detokenizer": null,
+  "num_workers": 8,
+  "latest_every": 0,
+  "resume_path": ""
+}
+[rank0]: Traceback (most recent call last):
+[rank0]:   File "/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/train.py", line 1546, in <module>
+[rank0]:     main()
+[rank0]:   File "/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/train.py", line 1465, in main
+[rank0]:     loss.backward()
+[rank0]:   File "/usr/local/lib/python3.12/dist-packages/torch/_tensor.py", line 648, in backward
+[rank0]:     torch.autograd.backward(
+[rank0]:   File "/usr/local/lib/python3.12/dist-packages/torch/autograd/__init__.py", line 347, in backward
+[rank0]:     _engine_run_backward(
+[rank0]:   File "/usr/local/lib/python3.12/dist-packages/torch/autograd/graph.py", line 823, in _engine_run_backward
+[rank0]:     return Variable._execution_engine.run_backward(  # Calls into the C++ engine to run the backward pass
+[rank0]:            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+[rank0]: RuntimeError: CUDA error: CUBLAS_STATUS_ALLOC_FAILED when calling `cublasCreate(handle)`
+[rank2]: Traceback (most recent call last):
+[rank2]:   File "/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/train.py", line 1546, in <module>
+[rank2]:     main()
+[rank2]:   File "/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/train.py", line 1465, in main
+[rank2]:     loss.backward()
+[rank2]:   File "/usr/local/lib/python3.12/dist-packages/torch/_tensor.py", line 648, in backward
+[rank2]:     torch.autograd.backward(
+[rank2]:   File "/usr/local/lib/python3.12/dist-packages/torch/autograd/__init__.py", line 347, in backward
+[rank2]:     _engine_run_backward(
+[rank2]:   File "/usr/local/lib/python3.12/dist-packages/torch/autograd/graph.py", line 823, in _engine_run_backward
+[rank2]:     return Variable._execution_engine.run_backward(  # Calls into the C++ engine to run the backward pass
+[rank2]:            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+[rank2]: RuntimeError: CUDA error: CUBLAS_STATUS_ALLOC_FAILED when calling `cublasCreate(handle)`
+[rank3]: Traceback (most recent call last):
+[rank3]:   File "/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/train.py", line 1546, in <module>
+[rank3]:     main()
+[rank3]:   File "/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/train.py", line 1465, in main
+[rank3]:     loss.backward()
+[rank3]:   File "/usr/local/lib/python3.12/dist-packages/torch/_tensor.py", line 648, in backward
+[rank3]:     torch.autograd.backward(
+[rank3]:   File "/usr/local/lib/python3.12/dist-packages/torch/autograd/__init__.py", line 347, in backward
+[rank3]:     _engine_run_backward(
+[rank3]:   File "/usr/local/lib/python3.12/dist-packages/torch/autograd/graph.py", line 823, in _engine_run_backward
+[rank3]:     return Variable._execution_engine.run_backward(  # Calls into the C++ engine to run the backward pass
+[rank3]:            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+[rank3]: RuntimeError: CUDA error: CUBLAS_STATUS_ALLOC_FAILED when calling `cublasCreate(handle)`
+[rank1]: Traceback (most recent call last):
+[rank1]:   File "/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/train.py", line 1546, in <module>
+[rank1]:     main()
+[rank1]:   File "/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/train.py", line 1465, in main
+[rank1]:     loss.backward()
+[rank1]:   File "/usr/local/lib/python3.12/dist-packages/torch/_tensor.py", line 648, in backward
+[rank1]:     torch.autograd.backward(
+[rank1]:   File "/usr/local/lib/python3.12/dist-packages/torch/autograd/__init__.py", line 347, in backward
+[rank1]:     _engine_run_backward(
+[rank1]:   File "/usr/local/lib/python3.12/dist-packages/torch/autograd/graph.py", line 823, in _engine_run_backward
+[rank1]:     return Variable._execution_engine.run_backward(  # Calls into the C++ engine to run the backward pass
+[rank1]:            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+[rank1]: RuntimeError: t() expects a tensor with <= 2 dimensions, but self is 3D

LTA_openwebtext_dualt/logs/owt_lowk64plus_cleanbridge_2k_watcher.nohup

@@ -0,0 +1,29 @@
+[watcher] start 2026-05-12T00:37:29+00:00 run_dir=runs/lta_owt_c1024_len1024_t0to1_lowk64plus_cleanbridge_buf1000_gbs128_4gpu_2k
+[watcher] poll 2026-05-12T00:46:32+00:00 step=500 last=-1
+[watcher] infer step=500 out=docs/lta_samples/metrics_20260512/owt_lowk64plus_cleanbridge_2k_rolling_sync_probe/step500_sync_probe_n16
+[watcher] done step=500
+[watcher] poll 2026-05-12T00:48:43+00:00 step=500 last=500
+[watcher] poll 2026-05-12T00:50:16+00:00 step=500 last=500
+[watcher] poll 2026-05-12T00:51:49+00:00 step=500 last=500
+[watcher] poll 2026-05-12T00:53:23+00:00 step=500 last=500
+[watcher] poll 2026-05-12T00:54:56+00:00 step=500 last=500
+[watcher] poll 2026-05-12T00:56:29+00:00 step=1000 last=500
+[watcher] infer step=1000 out=docs/lta_samples/metrics_20260512/owt_lowk64plus_cleanbridge_2k_rolling_sync_probe/step1000_sync_probe_n16
+[watcher] done step=1000
+[watcher] poll 2026-05-12T00:58:40+00:00 step=1000 last=1000
+[watcher] poll 2026-05-12T01:00:13+00:00 step=1000 last=1000
+[watcher] poll 2026-05-12T01:01:46+00:00 step=1000 last=1000
+[watcher] poll 2026-05-12T01:03:20+00:00 step=1000 last=1000
+[watcher] poll 2026-05-12T01:04:53+00:00 step=1500 last=1000
+[watcher] infer step=1500 out=docs/lta_samples/metrics_20260512/owt_lowk64plus_cleanbridge_2k_rolling_sync_probe/step1500_sync_probe_n16
+[watcher] done step=1500
+[watcher] poll 2026-05-12T01:07:04+00:00 step=1500 last=1500
+[watcher] poll 2026-05-12T01:08:37+00:00 step=1500 last=1500
+[watcher] poll 2026-05-12T01:10:10+00:00 step=1500 last=1500
+[watcher] poll 2026-05-12T01:11:44+00:00 step=1500 last=1500
+[watcher] poll 2026-05-12T01:13:17+00:00 step=1500 last=1500
+[watcher] poll 2026-05-12T01:14:50+00:00 step=1500 last=1500
+[watcher] poll 2026-05-12T01:16:23+00:00 step=2000 last=1500
+[watcher] infer step=2000 out=docs/lta_samples/metrics_20260512/owt_lowk64plus_cleanbridge_2k_rolling_sync_probe/step2000_sync_probe_n16
+[watcher] done step=2000
+[watcher] reached max step 2000; exiting

LTA_openwebtext_dualt/mini_owt_logdirichlet/.venv_qwen35_uv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/arrayprint.py

@@ -0,0 +1,37 @@
+import numpy as np
+
+AR = np.arange(10)
+AR.setflags(write=False)
+
+with np.printoptions():
+    np.set_printoptions(
+        precision=1,
+        threshold=2,
+        edgeitems=3,
+        linewidth=4,
+        suppress=False,
+        nanstr="Bob",
+        infstr="Bill",
+        formatter={},
+        sign="+",
+        floatmode="unique",
+    )
+    np.get_printoptions()
+    str(AR)
+
+    np.array2string(
+        AR,
+        max_line_width=5,
+        precision=2,
+        suppress_small=True,
+        separator=";",
+        prefix="test",
+        threshold=5,
+        floatmode="fixed",
+        suffix="?",
+        legacy="1.13",
+    )
+    np.format_float_scientific(1, precision=5)
+    np.format_float_positional(1, trim="k")
+    np.array_repr(AR)
+    np.array_str(AR)

LTA_openwebtext_dualt/mini_owt_logdirichlet/.venv_qwen35_uv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/numeric.py

@@ -0,0 +1,90 @@
+"""
+Tests for :mod:`numpy.core.numeric`.
+
+Does not include tests which fall under ``array_constructors``.
+
+"""
+
+from __future__ import annotations
+
+import numpy as np
+
+class SubClass(np.ndarray):
+    ...
+
+i8 = np.int64(1)
+
+A = np.arange(27).reshape(3, 3, 3)
+B: list[list[list[int]]] = A.tolist()
+C = np.empty((27, 27)).view(SubClass)
+
+np.count_nonzero(i8)
+np.count_nonzero(A)
+np.count_nonzero(B)
+np.count_nonzero(A, keepdims=True)
+np.count_nonzero(A, axis=0)
+
+np.isfortran(i8)
+np.isfortran(A)
+
+np.argwhere(i8)
+np.argwhere(A)
+
+np.flatnonzero(i8)
+np.flatnonzero(A)
+
+np.correlate(B[0][0], A.ravel(), mode="valid")
+np.correlate(A.ravel(), A.ravel(), mode="same")
+
+np.convolve(B[0][0], A.ravel(), mode="valid")
+np.convolve(A.ravel(), A.ravel(), mode="same")
+
+np.outer(i8, A)
+np.outer(B, A)
+np.outer(A, A)
+np.outer(A, A, out=C)
+
+np.tensordot(B, A)
+np.tensordot(A, A)
+np.tensordot(A, A, axes=0)
+np.tensordot(A, A, axes=(0, 1))
+
+np.isscalar(i8)
+np.isscalar(A)
+np.isscalar(B)
+
+np.roll(A, 1)
+np.roll(A, (1, 2))
+np.roll(B, 1)
+
+np.rollaxis(A, 0, 1)
+
+np.moveaxis(A, 0, 1)
+np.moveaxis(A, (0, 1), (1, 2))
+
+np.cross(B, A)
+np.cross(A, A)
+
+np.indices([0, 1, 2])
+np.indices([0, 1, 2], sparse=False)
+np.indices([0, 1, 2], sparse=True)
+
+np.binary_repr(1)
+
+np.base_repr(1)
+
+np.allclose(i8, A)
+np.allclose(B, A)
+np.allclose(A, A)
+
+np.isclose(i8, A)
+np.isclose(B, A)
+np.isclose(A, A)
+
+np.array_equal(i8, A)
+np.array_equal(B, A)
+np.array_equal(A, A)
+
+np.array_equiv(i8, A)
+np.array_equiv(B, A)
+np.array_equiv(A, A)

LTA_openwebtext_dualt/mini_owt_logdirichlet/.venv_qwen35_uv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/random.py

@@ -0,0 +1,1499 @@
+from __future__ import annotations
+
+from typing import Any
+import numpy as np
+
+SEED_NONE = None
+SEED_INT = 4579435749574957634658964293569
+SEED_ARR: np.ndarray[Any, np.dtype[np.int64]] = np.array([1, 2, 3, 4], dtype=np.int64)
+SEED_ARRLIKE: list[int] = [1, 2, 3, 4]
+SEED_SEED_SEQ: np.random.SeedSequence = np.random.SeedSequence(0)
+SEED_MT19937: np.random.MT19937 = np.random.MT19937(0)
+SEED_PCG64: np.random.PCG64 = np.random.PCG64(0)
+SEED_PHILOX: np.random.Philox = np.random.Philox(0)
+SEED_SFC64: np.random.SFC64 = np.random.SFC64(0)
+
+# default rng
+np.random.default_rng()
+np.random.default_rng(SEED_NONE)
+np.random.default_rng(SEED_INT)
+np.random.default_rng(SEED_ARR)
+np.random.default_rng(SEED_ARRLIKE)
+np.random.default_rng(SEED_SEED_SEQ)
+np.random.default_rng(SEED_MT19937)
+np.random.default_rng(SEED_PCG64)
+np.random.default_rng(SEED_PHILOX)
+np.random.default_rng(SEED_SFC64)
+
+# Seed Sequence
+np.random.SeedSequence(SEED_NONE)
+np.random.SeedSequence(SEED_INT)
+np.random.SeedSequence(SEED_ARR)
+np.random.SeedSequence(SEED_ARRLIKE)
+
+# Bit Generators
+np.random.MT19937(SEED_NONE)
+np.random.MT19937(SEED_INT)
+np.random.MT19937(SEED_ARR)
+np.random.MT19937(SEED_ARRLIKE)
+np.random.MT19937(SEED_SEED_SEQ)
+
+np.random.PCG64(SEED_NONE)
+np.random.PCG64(SEED_INT)
+np.random.PCG64(SEED_ARR)
+np.random.PCG64(SEED_ARRLIKE)
+np.random.PCG64(SEED_SEED_SEQ)
+
+np.random.Philox(SEED_NONE)
+np.random.Philox(SEED_INT)
+np.random.Philox(SEED_ARR)
+np.random.Philox(SEED_ARRLIKE)
+np.random.Philox(SEED_SEED_SEQ)
+
+np.random.SFC64(SEED_NONE)
+np.random.SFC64(SEED_INT)
+np.random.SFC64(SEED_ARR)
+np.random.SFC64(SEED_ARRLIKE)
+np.random.SFC64(SEED_SEED_SEQ)
+
+seed_seq: np.random.bit_generator.SeedSequence = np.random.SeedSequence(SEED_NONE)
+seed_seq.spawn(10)
+seed_seq.generate_state(3)
+seed_seq.generate_state(3, "u4")
+seed_seq.generate_state(3, "uint32")
+seed_seq.generate_state(3, "u8")
+seed_seq.generate_state(3, "uint64")
+seed_seq.generate_state(3, np.uint32)
+seed_seq.generate_state(3, np.uint64)
+
+
+def_gen: np.random.Generator = np.random.default_rng()
+
+D_arr_0p1: np.ndarray[Any, np.dtype[np.float64]] = np.array([0.1])
+D_arr_0p5: np.ndarray[Any, np.dtype[np.float64]] = np.array([0.5])
+D_arr_0p9: np.ndarray[Any, np.dtype[np.float64]] = np.array([0.9])
+D_arr_1p5: np.ndarray[Any, np.dtype[np.float64]] = np.array([1.5])
+I_arr_10: np.ndarray[Any, np.dtype[np.int_]] = np.array([10], dtype=np.int_)
+I_arr_20: np.ndarray[Any, np.dtype[np.int_]] = np.array([20], dtype=np.int_)
+D_arr_like_0p1: list[float] = [0.1]
+D_arr_like_0p5: list[float] = [0.5]
+D_arr_like_0p9: list[float] = [0.9]
+D_arr_like_1p5: list[float] = [1.5]
+I_arr_like_10: list[int] = [10]
+I_arr_like_20: list[int] = [20]
+D_2D_like: list[list[float]] = [[1, 2], [2, 3], [3, 4], [4, 5.1]]
+D_2D: np.ndarray[Any, np.dtype[np.float64]] = np.array(D_2D_like)
+
+S_out: np.ndarray[Any, np.dtype[np.float32]] = np.empty(1, dtype=np.float32)
+D_out: np.ndarray[Any, np.dtype[np.float64]] = np.empty(1)
+
+def_gen.standard_normal()
+def_gen.standard_normal(dtype=np.float32)
+def_gen.standard_normal(dtype="float32")
+def_gen.standard_normal(dtype="double")
+def_gen.standard_normal(dtype=np.float64)
+def_gen.standard_normal(size=None)
+def_gen.standard_normal(size=1)
+def_gen.standard_normal(size=1, dtype=np.float32)
+def_gen.standard_normal(size=1, dtype="f4")
+def_gen.standard_normal(size=1, dtype="float32", out=S_out)
+def_gen.standard_normal(dtype=np.float32, out=S_out)
+def_gen.standard_normal(size=1, dtype=np.float64)
+def_gen.standard_normal(size=1, dtype="float64")
+def_gen.standard_normal(size=1, dtype="f8")
+def_gen.standard_normal(out=D_out)
+def_gen.standard_normal(size=1, dtype="float64")
+def_gen.standard_normal(size=1, dtype="float64", out=D_out)
+
+def_gen.random()
+def_gen.random(dtype=np.float32)
+def_gen.random(dtype="float32")
+def_gen.random(dtype="double")
+def_gen.random(dtype=np.float64)
+def_gen.random(size=None)
+def_gen.random(size=1)
+def_gen.random(size=1, dtype=np.float32)
+def_gen.random(size=1, dtype="f4")
+def_gen.random(size=1, dtype="float32", out=S_out)
+def_gen.random(dtype=np.float32, out=S_out)
+def_gen.random(size=1, dtype=np.float64)
+def_gen.random(size=1, dtype="float64")
+def_gen.random(size=1, dtype="f8")
+def_gen.random(out=D_out)
+def_gen.random(size=1, dtype="float64")
+def_gen.random(size=1, dtype="float64", out=D_out)
+
+def_gen.standard_cauchy()
+def_gen.standard_cauchy(size=None)
+def_gen.standard_cauchy(size=1)
+
+def_gen.standard_exponential()
+def_gen.standard_exponential(method="inv")
+def_gen.standard_exponential(dtype=np.float32)
+def_gen.standard_exponential(dtype="float32")
+def_gen.standard_exponential(dtype="double")
+def_gen.standard_exponential(dtype=np.float64)
+def_gen.standard_exponential(size=None)
+def_gen.standard_exponential(size=None, method="inv")
+def_gen.standard_exponential(size=1, method="inv")
+def_gen.standard_exponential(size=1, dtype=np.float32)
+def_gen.standard_exponential(size=1, dtype="f4", method="inv")
+def_gen.standard_exponential(size=1, dtype="float32", out=S_out)
+def_gen.standard_exponential(dtype=np.float32, out=S_out)
+def_gen.standard_exponential(size=1, dtype=np.float64, method="inv")
+def_gen.standard_exponential(size=1, dtype="float64")
+def_gen.standard_exponential(size=1, dtype="f8")
+def_gen.standard_exponential(out=D_out)
+def_gen.standard_exponential(size=1, dtype="float64")
+def_gen.standard_exponential(size=1, dtype="float64", out=D_out)
+
+def_gen.zipf(1.5)
+def_gen.zipf(1.5, size=None)
+def_gen.zipf(1.5, size=1)
+def_gen.zipf(D_arr_1p5)
+def_gen.zipf(D_arr_1p5, size=1)
+def_gen.zipf(D_arr_like_1p5)
+def_gen.zipf(D_arr_like_1p5, size=1)
+
+def_gen.weibull(0.5)
+def_gen.weibull(0.5, size=None)
+def_gen.weibull(0.5, size=1)
+def_gen.weibull(D_arr_0p5)
+def_gen.weibull(D_arr_0p5, size=1)
+def_gen.weibull(D_arr_like_0p5)
+def_gen.weibull(D_arr_like_0p5, size=1)
+
+def_gen.standard_t(0.5)
+def_gen.standard_t(0.5, size=None)
+def_gen.standard_t(0.5, size=1)
+def_gen.standard_t(D_arr_0p5)
+def_gen.standard_t(D_arr_0p5, size=1)
+def_gen.standard_t(D_arr_like_0p5)
+def_gen.standard_t(D_arr_like_0p5, size=1)
+
+def_gen.poisson(0.5)
+def_gen.poisson(0.5, size=None)
+def_gen.poisson(0.5, size=1)
+def_gen.poisson(D_arr_0p5)
+def_gen.poisson(D_arr_0p5, size=1)
+def_gen.poisson(D_arr_like_0p5)
+def_gen.poisson(D_arr_like_0p5, size=1)
+
+def_gen.power(0.5)
+def_gen.power(0.5, size=None)
+def_gen.power(0.5, size=1)
+def_gen.power(D_arr_0p5)
+def_gen.power(D_arr_0p5, size=1)
+def_gen.power(D_arr_like_0p5)
+def_gen.power(D_arr_like_0p5, size=1)
+
+def_gen.pareto(0.5)
+def_gen.pareto(0.5, size=None)
+def_gen.pareto(0.5, size=1)
+def_gen.pareto(D_arr_0p5)
+def_gen.pareto(D_arr_0p5, size=1)
+def_gen.pareto(D_arr_like_0p5)
+def_gen.pareto(D_arr_like_0p5, size=1)
+
+def_gen.chisquare(0.5)
+def_gen.chisquare(0.5, size=None)
+def_gen.chisquare(0.5, size=1)
+def_gen.chisquare(D_arr_0p5)
+def_gen.chisquare(D_arr_0p5, size=1)
+def_gen.chisquare(D_arr_like_0p5)
+def_gen.chisquare(D_arr_like_0p5, size=1)
+
+def_gen.exponential(0.5)
+def_gen.exponential(0.5, size=None)
+def_gen.exponential(0.5, size=1)
+def_gen.exponential(D_arr_0p5)
+def_gen.exponential(D_arr_0p5, size=1)
+def_gen.exponential(D_arr_like_0p5)
+def_gen.exponential(D_arr_like_0p5, size=1)
+
+def_gen.geometric(0.5)
+def_gen.geometric(0.5, size=None)
+def_gen.geometric(0.5, size=1)
+def_gen.geometric(D_arr_0p5)
+def_gen.geometric(D_arr_0p5, size=1)
+def_gen.geometric(D_arr_like_0p5)
+def_gen.geometric(D_arr_like_0p5, size=1)
+
+def_gen.logseries(0.5)
+def_gen.logseries(0.5, size=None)
+def_gen.logseries(0.5, size=1)
+def_gen.logseries(D_arr_0p5)
+def_gen.logseries(D_arr_0p5, size=1)
+def_gen.logseries(D_arr_like_0p5)
+def_gen.logseries(D_arr_like_0p5, size=1)
+
+def_gen.rayleigh(0.5)
+def_gen.rayleigh(0.5, size=None)
+def_gen.rayleigh(0.5, size=1)
+def_gen.rayleigh(D_arr_0p5)
+def_gen.rayleigh(D_arr_0p5, size=1)
+def_gen.rayleigh(D_arr_like_0p5)
+def_gen.rayleigh(D_arr_like_0p5, size=1)
+
+def_gen.standard_gamma(0.5)
+def_gen.standard_gamma(0.5, size=None)
+def_gen.standard_gamma(0.5, dtype="float32")
+def_gen.standard_gamma(0.5, size=None, dtype="float32")
+def_gen.standard_gamma(0.5, size=1)
+def_gen.standard_gamma(D_arr_0p5)
+def_gen.standard_gamma(D_arr_0p5, dtype="f4")
+def_gen.standard_gamma(0.5, size=1, dtype="float32", out=S_out)
+def_gen.standard_gamma(D_arr_0p5, dtype=np.float32, out=S_out)
+def_gen.standard_gamma(D_arr_0p5, size=1)
+def_gen.standard_gamma(D_arr_like_0p5)
+def_gen.standard_gamma(D_arr_like_0p5, size=1)
+def_gen.standard_gamma(0.5, out=D_out)
+def_gen.standard_gamma(D_arr_like_0p5, out=D_out)
+def_gen.standard_gamma(D_arr_like_0p5, size=1)
+def_gen.standard_gamma(D_arr_like_0p5, size=1, out=D_out, dtype=np.float64)
+
+def_gen.vonmises(0.5, 0.5)
+def_gen.vonmises(0.5, 0.5, size=None)
+def_gen.vonmises(0.5, 0.5, size=1)
+def_gen.vonmises(D_arr_0p5, 0.5)
+def_gen.vonmises(0.5, D_arr_0p5)
+def_gen.vonmises(D_arr_0p5, 0.5, size=1)
+def_gen.vonmises(0.5, D_arr_0p5, size=1)
+def_gen.vonmises(D_arr_like_0p5, 0.5)
+def_gen.vonmises(0.5, D_arr_like_0p5)
+def_gen.vonmises(D_arr_0p5, D_arr_0p5)
+def_gen.vonmises(D_arr_like_0p5, D_arr_like_0p5)
+def_gen.vonmises(D_arr_0p5, D_arr_0p5, size=1)
+def_gen.vonmises(D_arr_like_0p5, D_arr_like_0p5, size=1)
+
+def_gen.wald(0.5, 0.5)
+def_gen.wald(0.5, 0.5, size=None)
+def_gen.wald(0.5, 0.5, size=1)
+def_gen.wald(D_arr_0p5, 0.5)
+def_gen.wald(0.5, D_arr_0p5)
+def_gen.wald(D_arr_0p5, 0.5, size=1)
+def_gen.wald(0.5, D_arr_0p5, size=1)
+def_gen.wald(D_arr_like_0p5, 0.5)
+def_gen.wald(0.5, D_arr_like_0p5)
+def_gen.wald(D_arr_0p5, D_arr_0p5)
+def_gen.wald(D_arr_like_0p5, D_arr_like_0p5)
+def_gen.wald(D_arr_0p5, D_arr_0p5, size=1)
+def_gen.wald(D_arr_like_0p5, D_arr_like_0p5, size=1)
+
+def_gen.uniform(0.5, 0.5)
+def_gen.uniform(0.5, 0.5, size=None)
+def_gen.uniform(0.5, 0.5, size=1)
+def_gen.uniform(D_arr_0p5, 0.5)
+def_gen.uniform(0.5, D_arr_0p5)
+def_gen.uniform(D_arr_0p5, 0.5, size=1)
+def_gen.uniform(0.5, D_arr_0p5, size=1)
+def_gen.uniform(D_arr_like_0p5, 0.5)
+def_gen.uniform(0.5, D_arr_like_0p5)
+def_gen.uniform(D_arr_0p5, D_arr_0p5)
+def_gen.uniform(D_arr_like_0p5, D_arr_like_0p5)
+def_gen.uniform(D_arr_0p5, D_arr_0p5, size=1)
+def_gen.uniform(D_arr_like_0p5, D_arr_like_0p5, size=1)
+
+def_gen.beta(0.5, 0.5)
+def_gen.beta(0.5, 0.5, size=None)
+def_gen.beta(0.5, 0.5, size=1)
+def_gen.beta(D_arr_0p5, 0.5)
+def_gen.beta(0.5, D_arr_0p5)
+def_gen.beta(D_arr_0p5, 0.5, size=1)
+def_gen.beta(0.5, D_arr_0p5, size=1)
+def_gen.beta(D_arr_like_0p5, 0.5)
+def_gen.beta(0.5, D_arr_like_0p5)
+def_gen.beta(D_arr_0p5, D_arr_0p5)
+def_gen.beta(D_arr_like_0p5, D_arr_like_0p5)
+def_gen.beta(D_arr_0p5, D_arr_0p5, size=1)
+def_gen.beta(D_arr_like_0p5, D_arr_like_0p5, size=1)
+
+def_gen.f(0.5, 0.5)
+def_gen.f(0.5, 0.5, size=None)
+def_gen.f(0.5, 0.5, size=1)
+def_gen.f(D_arr_0p5, 0.5)
+def_gen.f(0.5, D_arr_0p5)
+def_gen.f(D_arr_0p5, 0.5, size=1)
+def_gen.f(0.5, D_arr_0p5, size=1)
+def_gen.f(D_arr_like_0p5, 0.5)
+def_gen.f(0.5, D_arr_like_0p5)
+def_gen.f(D_arr_0p5, D_arr_0p5)
+def_gen.f(D_arr_like_0p5, D_arr_like_0p5)
+def_gen.f(D_arr_0p5, D_arr_0p5, size=1)
+def_gen.f(D_arr_like_0p5, D_arr_like_0p5, size=1)
+
+def_gen.gamma(0.5, 0.5)
+def_gen.gamma(0.5, 0.5, size=None)
+def_gen.gamma(0.5, 0.5, size=1)
+def_gen.gamma(D_arr_0p5, 0.5)
+def_gen.gamma(0.5, D_arr_0p5)
+def_gen.gamma(D_arr_0p5, 0.5, size=1)
+def_gen.gamma(0.5, D_arr_0p5, size=1)
+def_gen.gamma(D_arr_like_0p5, 0.5)
+def_gen.gamma(0.5, D_arr_like_0p5)
+def_gen.gamma(D_arr_0p5, D_arr_0p5)
+def_gen.gamma(D_arr_like_0p5, D_arr_like_0p5)
+def_gen.gamma(D_arr_0p5, D_arr_0p5, size=1)
+def_gen.gamma(D_arr_like_0p5, D_arr_like_0p5, size=1)
+
+def_gen.gumbel(0.5, 0.5)
+def_gen.gumbel(0.5, 0.5, size=None)
+def_gen.gumbel(0.5, 0.5, size=1)
+def_gen.gumbel(D_arr_0p5, 0.5)
+def_gen.gumbel(0.5, D_arr_0p5)
+def_gen.gumbel(D_arr_0p5, 0.5, size=1)
+def_gen.gumbel(0.5, D_arr_0p5, size=1)
+def_gen.gumbel(D_arr_like_0p5, 0.5)
+def_gen.gumbel(0.5, D_arr_like_0p5)
+def_gen.gumbel(D_arr_0p5, D_arr_0p5)
+def_gen.gumbel(D_arr_like_0p5, D_arr_like_0p5)
+def_gen.gumbel(D_arr_0p5, D_arr_0p5, size=1)
+def_gen.gumbel(D_arr_like_0p5, D_arr_like_0p5, size=1)
+
+def_gen.laplace(0.5, 0.5)
+def_gen.laplace(0.5, 0.5, size=None)
+def_gen.laplace(0.5, 0.5, size=1)
+def_gen.laplace(D_arr_0p5, 0.5)
+def_gen.laplace(0.5, D_arr_0p5)
+def_gen.laplace(D_arr_0p5, 0.5, size=1)
+def_gen.laplace(0.5, D_arr_0p5, size=1)
+def_gen.laplace(D_arr_like_0p5, 0.5)
+def_gen.laplace(0.5, D_arr_like_0p5)
+def_gen.laplace(D_arr_0p5, D_arr_0p5)
+def_gen.laplace(D_arr_like_0p5, D_arr_like_0p5)
+def_gen.laplace(D_arr_0p5, D_arr_0p5, size=1)
+def_gen.laplace(D_arr_like_0p5, D_arr_like_0p5, size=1)
+
+def_gen.logistic(0.5, 0.5)
+def_gen.logistic(0.5, 0.5, size=None)
+def_gen.logistic(0.5, 0.5, size=1)
+def_gen.logistic(D_arr_0p5, 0.5)
+def_gen.logistic(0.5, D_arr_0p5)
+def_gen.logistic(D_arr_0p5, 0.5, size=1)
+def_gen.logistic(0.5, D_arr_0p5, size=1)
+def_gen.logistic(D_arr_like_0p5, 0.5)
+def_gen.logistic(0.5, D_arr_like_0p5)
+def_gen.logistic(D_arr_0p5, D_arr_0p5)
+def_gen.logistic(D_arr_like_0p5, D_arr_like_0p5)
+def_gen.logistic(D_arr_0p5, D_arr_0p5, size=1)
+def_gen.logistic(D_arr_like_0p5, D_arr_like_0p5, size=1)
+
+def_gen.lognormal(0.5, 0.5)
+def_gen.lognormal(0.5, 0.5, size=None)
+def_gen.lognormal(0.5, 0.5, size=1)
+def_gen.lognormal(D_arr_0p5, 0.5)
+def_gen.lognormal(0.5, D_arr_0p5)
+def_gen.lognormal(D_arr_0p5, 0.5, size=1)
+def_gen.lognormal(0.5, D_arr_0p5, size=1)
+def_gen.lognormal(D_arr_like_0p5, 0.5)
+def_gen.lognormal(0.5, D_arr_like_0p5)
+def_gen.lognormal(D_arr_0p5, D_arr_0p5)
+def_gen.lognormal(D_arr_like_0p5, D_arr_like_0p5)
+def_gen.lognormal(D_arr_0p5, D_arr_0p5, size=1)
+def_gen.lognormal(D_arr_like_0p5, D_arr_like_0p5, size=1)
+
+def_gen.noncentral_chisquare(0.5, 0.5)
+def_gen.noncentral_chisquare(0.5, 0.5, size=None)
+def_gen.noncentral_chisquare(0.5, 0.5, size=1)
+def_gen.noncentral_chisquare(D_arr_0p5, 0.5)
+def_gen.noncentral_chisquare(0.5, D_arr_0p5)
+def_gen.noncentral_chisquare(D_arr_0p5, 0.5, size=1)
+def_gen.noncentral_chisquare(0.5, D_arr_0p5, size=1)
+def_gen.noncentral_chisquare(D_arr_like_0p5, 0.5)
+def_gen.noncentral_chisquare(0.5, D_arr_like_0p5)
+def_gen.noncentral_chisquare(D_arr_0p5, D_arr_0p5)
+def_gen.noncentral_chisquare(D_arr_like_0p5, D_arr_like_0p5)
+def_gen.noncentral_chisquare(D_arr_0p5, D_arr_0p5, size=1)
+def_gen.noncentral_chisquare(D_arr_like_0p5, D_arr_like_0p5, size=1)
+
+def_gen.normal(0.5, 0.5)
+def_gen.normal(0.5, 0.5, size=None)
+def_gen.normal(0.5, 0.5, size=1)
+def_gen.normal(D_arr_0p5, 0.5)
+def_gen.normal(0.5, D_arr_0p5)
+def_gen.normal(D_arr_0p5, 0.5, size=1)
+def_gen.normal(0.5, D_arr_0p5, size=1)
+def_gen.normal(D_arr_like_0p5, 0.5)
+def_gen.normal(0.5, D_arr_like_0p5)
+def_gen.normal(D_arr_0p5, D_arr_0p5)
+def_gen.normal(D_arr_like_0p5, D_arr_like_0p5)
+def_gen.normal(D_arr_0p5, D_arr_0p5, size=1)
+def_gen.normal(D_arr_like_0p5, D_arr_like_0p5, size=1)
+
+def_gen.triangular(0.1, 0.5, 0.9)
+def_gen.triangular(0.1, 0.5, 0.9, size=None)
+def_gen.triangular(0.1, 0.5, 0.9, size=1)
+def_gen.triangular(D_arr_0p1, 0.5, 0.9)
+def_gen.triangular(0.1, D_arr_0p5, 0.9)
+def_gen.triangular(D_arr_0p1, 0.5, D_arr_like_0p9, size=1)
+def_gen.triangular(0.1, D_arr_0p5, 0.9, size=1)
+def_gen.triangular(D_arr_like_0p1, 0.5, D_arr_0p9)
+def_gen.triangular(0.5, D_arr_like_0p5, 0.9)
+def_gen.triangular(D_arr_0p1, D_arr_0p5, 0.9)
+def_gen.triangular(D_arr_like_0p1, D_arr_like_0p5, 0.9)
+def_gen.triangular(D_arr_0p1, D_arr_0p5, D_arr_0p9, size=1)
+def_gen.triangular(D_arr_like_0p1, D_arr_like_0p5, D_arr_like_0p9, size=1)
+
+def_gen.noncentral_f(0.1, 0.5, 0.9)
+def_gen.noncentral_f(0.1, 0.5, 0.9, size=None)
+def_gen.noncentral_f(0.1, 0.5, 0.9, size=1)
+def_gen.noncentral_f(D_arr_0p1, 0.5, 0.9)
+def_gen.noncentral_f(0.1, D_arr_0p5, 0.9)
+def_gen.noncentral_f(D_arr_0p1, 0.5, D_arr_like_0p9, size=1)
+def_gen.noncentral_f(0.1, D_arr_0p5, 0.9, size=1)
+def_gen.noncentral_f(D_arr_like_0p1, 0.5, D_arr_0p9)
+def_gen.noncentral_f(0.5, D_arr_like_0p5, 0.9)
+def_gen.noncentral_f(D_arr_0p1, D_arr_0p5, 0.9)
+def_gen.noncentral_f(D_arr_like_0p1, D_arr_like_0p5, 0.9)
+def_gen.noncentral_f(D_arr_0p1, D_arr_0p5, D_arr_0p9, size=1)
+def_gen.noncentral_f(D_arr_like_0p1, D_arr_like_0p5, D_arr_like_0p9, size=1)
+
+def_gen.binomial(10, 0.5)
+def_gen.binomial(10, 0.5, size=None)
+def_gen.binomial(10, 0.5, size=1)
+def_gen.binomial(I_arr_10, 0.5)
+def_gen.binomial(10, D_arr_0p5)
+def_gen.binomial(I_arr_10, 0.5, size=1)
+def_gen.binomial(10, D_arr_0p5, size=1)
+def_gen.binomial(I_arr_like_10, 0.5)
+def_gen.binomial(10, D_arr_like_0p5)
+def_gen.binomial(I_arr_10, D_arr_0p5)
+def_gen.binomial(I_arr_like_10, D_arr_like_0p5)
+def_gen.binomial(I_arr_10, D_arr_0p5, size=1)
+def_gen.binomial(I_arr_like_10, D_arr_like_0p5, size=1)
+
+def_gen.negative_binomial(10, 0.5)
+def_gen.negative_binomial(10, 0.5, size=None)
+def_gen.negative_binomial(10, 0.5, size=1)
+def_gen.negative_binomial(I_arr_10, 0.5)
+def_gen.negative_binomial(10, D_arr_0p5)
+def_gen.negative_binomial(I_arr_10, 0.5, size=1)
+def_gen.negative_binomial(10, D_arr_0p5, size=1)
+def_gen.negative_binomial(I_arr_like_10, 0.5)
+def_gen.negative_binomial(10, D_arr_like_0p5)
+def_gen.negative_binomial(I_arr_10, D_arr_0p5)
+def_gen.negative_binomial(I_arr_like_10, D_arr_like_0p5)
+def_gen.negative_binomial(I_arr_10, D_arr_0p5, size=1)
+def_gen.negative_binomial(I_arr_like_10, D_arr_like_0p5, size=1)
+
+def_gen.hypergeometric(20, 20, 10)
+def_gen.hypergeometric(20, 20, 10, size=None)
+def_gen.hypergeometric(20, 20, 10, size=1)
+def_gen.hypergeometric(I_arr_20, 20, 10)
+def_gen.hypergeometric(20, I_arr_20, 10)
+def_gen.hypergeometric(I_arr_20, 20, I_arr_like_10, size=1)
+def_gen.hypergeometric(20, I_arr_20, 10, size=1)
+def_gen.hypergeometric(I_arr_like_20, 20, I_arr_10)
+def_gen.hypergeometric(20, I_arr_like_20, 10)
+def_gen.hypergeometric(I_arr_20, I_arr_20, 10)
+def_gen.hypergeometric(I_arr_like_20, I_arr_like_20, 10)
+def_gen.hypergeometric(I_arr_20, I_arr_20, I_arr_10, size=1)
+def_gen.hypergeometric(I_arr_like_20, I_arr_like_20, I_arr_like_10, size=1)
+
+I_int64_100: np.ndarray[Any, np.dtype[np.int64]] = np.array([100], dtype=np.int64)
+
+def_gen.integers(0, 100)
+def_gen.integers(100)
+def_gen.integers([100])
+def_gen.integers(0, [100])
+
+I_bool_low: np.ndarray[Any, np.dtype[np.bool_]] = np.array([0], dtype=np.bool_)
+I_bool_low_like: list[int] = [0]
+I_bool_high_open: np.ndarray[Any, np.dtype[np.bool_]] = np.array([1], dtype=np.bool_)
+I_bool_high_closed: np.ndarray[Any, np.dtype[np.bool_]] = np.array([1], dtype=np.bool_)
+
+def_gen.integers(2, dtype=bool)
+def_gen.integers(0, 2, dtype=bool)
+def_gen.integers(1, dtype=bool, endpoint=True)
+def_gen.integers(0, 1, dtype=bool, endpoint=True)
+def_gen.integers(I_bool_low_like, 1, dtype=bool, endpoint=True)
+def_gen.integers(I_bool_high_open, dtype=bool)
+def_gen.integers(I_bool_low, I_bool_high_open, dtype=bool)
+def_gen.integers(0, I_bool_high_open, dtype=bool)
+def_gen.integers(I_bool_high_closed, dtype=bool, endpoint=True)
+def_gen.integers(I_bool_low, I_bool_high_closed, dtype=bool, endpoint=True)
+def_gen.integers(0, I_bool_high_closed, dtype=bool, endpoint=True)
+
+def_gen.integers(2, dtype=np.bool_)
+def_gen.integers(0, 2, dtype=np.bool_)
+def_gen.integers(1, dtype=np.bool_, endpoint=True)
+def_gen.integers(0, 1, dtype=np.bool_, endpoint=True)
+def_gen.integers(I_bool_low_like, 1, dtype=np.bool_, endpoint=True)
+def_gen.integers(I_bool_high_open, dtype=np.bool_)
+def_gen.integers(I_bool_low, I_bool_high_open, dtype=np.bool_)
+def_gen.integers(0, I_bool_high_open, dtype=np.bool_)
+def_gen.integers(I_bool_high_closed, dtype=np.bool_, endpoint=True)
+def_gen.integers(I_bool_low, I_bool_high_closed, dtype=np.bool_, endpoint=True)
+def_gen.integers(0, I_bool_high_closed, dtype=np.bool_, endpoint=True)
+
+I_u1_low: np.ndarray[Any, np.dtype[np.uint8]] = np.array([0], dtype=np.uint8)
+I_u1_low_like: list[int] = [0]
+I_u1_high_open: np.ndarray[Any, np.dtype[np.uint8]] = np.array([255], dtype=np.uint8)
+I_u1_high_closed: np.ndarray[Any, np.dtype[np.uint8]] = np.array([255], dtype=np.uint8)
+
+def_gen.integers(256, dtype="u1")
+def_gen.integers(0, 256, dtype="u1")
+def_gen.integers(255, dtype="u1", endpoint=True)
+def_gen.integers(0, 255, dtype="u1", endpoint=True)
+def_gen.integers(I_u1_low_like, 255, dtype="u1", endpoint=True)
+def_gen.integers(I_u1_high_open, dtype="u1")
+def_gen.integers(I_u1_low, I_u1_high_open, dtype="u1")
+def_gen.integers(0, I_u1_high_open, dtype="u1")
+def_gen.integers(I_u1_high_closed, dtype="u1", endpoint=True)
+def_gen.integers(I_u1_low, I_u1_high_closed, dtype="u1", endpoint=True)
+def_gen.integers(0, I_u1_high_closed, dtype="u1", endpoint=True)
+
+def_gen.integers(256, dtype="uint8")
+def_gen.integers(0, 256, dtype="uint8")
+def_gen.integers(255, dtype="uint8", endpoint=True)
+def_gen.integers(0, 255, dtype="uint8", endpoint=True)
+def_gen.integers(I_u1_low_like, 255, dtype="uint8", endpoint=True)
+def_gen.integers(I_u1_high_open, dtype="uint8")
+def_gen.integers(I_u1_low, I_u1_high_open, dtype="uint8")
+def_gen.integers(0, I_u1_high_open, dtype="uint8")
+def_gen.integers(I_u1_high_closed, dtype="uint8", endpoint=True)
+def_gen.integers(I_u1_low, I_u1_high_closed, dtype="uint8", endpoint=True)
+def_gen.integers(0, I_u1_high_closed, dtype="uint8", endpoint=True)
+
+def_gen.integers(256, dtype=np.uint8)
+def_gen.integers(0, 256, dtype=np.uint8)
+def_gen.integers(255, dtype=np.uint8, endpoint=True)
+def_gen.integers(0, 255, dtype=np.uint8, endpoint=True)
+def_gen.integers(I_u1_low_like, 255, dtype=np.uint8, endpoint=True)
+def_gen.integers(I_u1_high_open, dtype=np.uint8)
+def_gen.integers(I_u1_low, I_u1_high_open, dtype=np.uint8)
+def_gen.integers(0, I_u1_high_open, dtype=np.uint8)
+def_gen.integers(I_u1_high_closed, dtype=np.uint8, endpoint=True)
+def_gen.integers(I_u1_low, I_u1_high_closed, dtype=np.uint8, endpoint=True)
+def_gen.integers(0, I_u1_high_closed, dtype=np.uint8, endpoint=True)
+
+I_u2_low: np.ndarray[Any, np.dtype[np.uint16]] = np.array([0], dtype=np.uint16)
+I_u2_low_like: list[int] = [0]
+I_u2_high_open: np.ndarray[Any, np.dtype[np.uint16]] = np.array([65535], dtype=np.uint16)
+I_u2_high_closed: np.ndarray[Any, np.dtype[np.uint16]] = np.array([65535], dtype=np.uint16)
+
+def_gen.integers(65536, dtype="u2")
+def_gen.integers(0, 65536, dtype="u2")
+def_gen.integers(65535, dtype="u2", endpoint=True)
+def_gen.integers(0, 65535, dtype="u2", endpoint=True)
+def_gen.integers(I_u2_low_like, 65535, dtype="u2", endpoint=True)
+def_gen.integers(I_u2_high_open, dtype="u2")
+def_gen.integers(I_u2_low, I_u2_high_open, dtype="u2")
+def_gen.integers(0, I_u2_high_open, dtype="u2")
+def_gen.integers(I_u2_high_closed, dtype="u2", endpoint=True)
+def_gen.integers(I_u2_low, I_u2_high_closed, dtype="u2", endpoint=True)
+def_gen.integers(0, I_u2_high_closed, dtype="u2", endpoint=True)
+
+def_gen.integers(65536, dtype="uint16")
+def_gen.integers(0, 65536, dtype="uint16")
+def_gen.integers(65535, dtype="uint16", endpoint=True)
+def_gen.integers(0, 65535, dtype="uint16", endpoint=True)
+def_gen.integers(I_u2_low_like, 65535, dtype="uint16", endpoint=True)
+def_gen.integers(I_u2_high_open, dtype="uint16")
+def_gen.integers(I_u2_low, I_u2_high_open, dtype="uint16")
+def_gen.integers(0, I_u2_high_open, dtype="uint16")
+def_gen.integers(I_u2_high_closed, dtype="uint16", endpoint=True)
+def_gen.integers(I_u2_low, I_u2_high_closed, dtype="uint16", endpoint=True)
+def_gen.integers(0, I_u2_high_closed, dtype="uint16", endpoint=True)
+
+def_gen.integers(65536, dtype=np.uint16)
+def_gen.integers(0, 65536, dtype=np.uint16)
+def_gen.integers(65535, dtype=np.uint16, endpoint=True)
+def_gen.integers(0, 65535, dtype=np.uint16, endpoint=True)
+def_gen.integers(I_u2_low_like, 65535, dtype=np.uint16, endpoint=True)
+def_gen.integers(I_u2_high_open, dtype=np.uint16)
+def_gen.integers(I_u2_low, I_u2_high_open, dtype=np.uint16)
+def_gen.integers(0, I_u2_high_open, dtype=np.uint16)
+def_gen.integers(I_u2_high_closed, dtype=np.uint16, endpoint=True)
+def_gen.integers(I_u2_low, I_u2_high_closed, dtype=np.uint16, endpoint=True)
+def_gen.integers(0, I_u2_high_closed, dtype=np.uint16, endpoint=True)
+
+I_u4_low: np.ndarray[Any, np.dtype[np.uint32]] = np.array([0], dtype=np.uint32)
+I_u4_low_like: list[int] = [0]
+I_u4_high_open: np.ndarray[Any, np.dtype[np.uint32]] = np.array([4294967295], dtype=np.uint32)
+I_u4_high_closed: np.ndarray[Any, np.dtype[np.uint32]] = np.array([4294967295], dtype=np.uint32)
+
+def_gen.integers(4294967296, dtype="u4")
+def_gen.integers(0, 4294967296, dtype="u4")
+def_gen.integers(4294967295, dtype="u4", endpoint=True)
+def_gen.integers(0, 4294967295, dtype="u4", endpoint=True)
+def_gen.integers(I_u4_low_like, 4294967295, dtype="u4", endpoint=True)
+def_gen.integers(I_u4_high_open, dtype="u4")
+def_gen.integers(I_u4_low, I_u4_high_open, dtype="u4")
+def_gen.integers(0, I_u4_high_open, dtype="u4")
+def_gen.integers(I_u4_high_closed, dtype="u4", endpoint=True)
+def_gen.integers(I_u4_low, I_u4_high_closed, dtype="u4", endpoint=True)
+def_gen.integers(0, I_u4_high_closed, dtype="u4", endpoint=True)
+
+def_gen.integers(4294967296, dtype="uint32")
+def_gen.integers(0, 4294967296, dtype="uint32")
+def_gen.integers(4294967295, dtype="uint32", endpoint=True)
+def_gen.integers(0, 4294967295, dtype="uint32", endpoint=True)
+def_gen.integers(I_u4_low_like, 4294967295, dtype="uint32", endpoint=True)
+def_gen.integers(I_u4_high_open, dtype="uint32")
+def_gen.integers(I_u4_low, I_u4_high_open, dtype="uint32")
+def_gen.integers(0, I_u4_high_open, dtype="uint32")
+def_gen.integers(I_u4_high_closed, dtype="uint32", endpoint=True)
+def_gen.integers(I_u4_low, I_u4_high_closed, dtype="uint32", endpoint=True)
+def_gen.integers(0, I_u4_high_closed, dtype="uint32", endpoint=True)
+
+def_gen.integers(4294967296, dtype=np.uint32)
+def_gen.integers(0, 4294967296, dtype=np.uint32)
+def_gen.integers(4294967295, dtype=np.uint32, endpoint=True)
+def_gen.integers(0, 4294967295, dtype=np.uint32, endpoint=True)
+def_gen.integers(I_u4_low_like, 4294967295, dtype=np.uint32, endpoint=True)
+def_gen.integers(I_u4_high_open, dtype=np.uint32)
+def_gen.integers(I_u4_low, I_u4_high_open, dtype=np.uint32)
+def_gen.integers(0, I_u4_high_open, dtype=np.uint32)
+def_gen.integers(I_u4_high_closed, dtype=np.uint32, endpoint=True)
+def_gen.integers(I_u4_low, I_u4_high_closed, dtype=np.uint32, endpoint=True)
+def_gen.integers(0, I_u4_high_closed, dtype=np.uint32, endpoint=True)
+
+I_u8_low: np.ndarray[Any, np.dtype[np.uint64]] = np.array([0], dtype=np.uint64)
+I_u8_low_like: list[int] = [0]
+I_u8_high_open: np.ndarray[Any, np.dtype[np.uint64]] = np.array([18446744073709551615], dtype=np.uint64)
+I_u8_high_closed: np.ndarray[Any, np.dtype[np.uint64]] = np.array([18446744073709551615], dtype=np.uint64)
+
+def_gen.integers(18446744073709551616, dtype="u8")
+def_gen.integers(0, 18446744073709551616, dtype="u8")
+def_gen.integers(18446744073709551615, dtype="u8", endpoint=True)
+def_gen.integers(0, 18446744073709551615, dtype="u8", endpoint=True)
+def_gen.integers(I_u8_low_like, 18446744073709551615, dtype="u8", endpoint=True)
+def_gen.integers(I_u8_high_open, dtype="u8")
+def_gen.integers(I_u8_low, I_u8_high_open, dtype="u8")
+def_gen.integers(0, I_u8_high_open, dtype="u8")
+def_gen.integers(I_u8_high_closed, dtype="u8", endpoint=True)
+def_gen.integers(I_u8_low, I_u8_high_closed, dtype="u8", endpoint=True)
+def_gen.integers(0, I_u8_high_closed, dtype="u8", endpoint=True)
+
+def_gen.integers(18446744073709551616, dtype="uint64")
+def_gen.integers(0, 18446744073709551616, dtype="uint64")
+def_gen.integers(18446744073709551615, dtype="uint64", endpoint=True)
+def_gen.integers(0, 18446744073709551615, dtype="uint64", endpoint=True)
+def_gen.integers(I_u8_low_like, 18446744073709551615, dtype="uint64", endpoint=True)
+def_gen.integers(I_u8_high_open, dtype="uint64")
+def_gen.integers(I_u8_low, I_u8_high_open, dtype="uint64")
+def_gen.integers(0, I_u8_high_open, dtype="uint64")
+def_gen.integers(I_u8_high_closed, dtype="uint64", endpoint=True)
+def_gen.integers(I_u8_low, I_u8_high_closed, dtype="uint64", endpoint=True)
+def_gen.integers(0, I_u8_high_closed, dtype="uint64", endpoint=True)
+
+def_gen.integers(18446744073709551616, dtype=np.uint64)
+def_gen.integers(0, 18446744073709551616, dtype=np.uint64)
+def_gen.integers(18446744073709551615, dtype=np.uint64, endpoint=True)
+def_gen.integers(0, 18446744073709551615, dtype=np.uint64, endpoint=True)
+def_gen.integers(I_u8_low_like, 18446744073709551615, dtype=np.uint64, endpoint=True)
+def_gen.integers(I_u8_high_open, dtype=np.uint64)
+def_gen.integers(I_u8_low, I_u8_high_open, dtype=np.uint64)
+def_gen.integers(0, I_u8_high_open, dtype=np.uint64)
+def_gen.integers(I_u8_high_closed, dtype=np.uint64, endpoint=True)
+def_gen.integers(I_u8_low, I_u8_high_closed, dtype=np.uint64, endpoint=True)
+def_gen.integers(0, I_u8_high_closed, dtype=np.uint64, endpoint=True)
+
+I_i1_low: np.ndarray[Any, np.dtype[np.int8]] = np.array([-128], dtype=np.int8)
+I_i1_low_like: list[int] = [-128]
+I_i1_high_open: np.ndarray[Any, np.dtype[np.int8]] = np.array([127], dtype=np.int8)
+I_i1_high_closed: np.ndarray[Any, np.dtype[np.int8]] = np.array([127], dtype=np.int8)
+
+def_gen.integers(128, dtype="i1")
+def_gen.integers(-128, 128, dtype="i1")
+def_gen.integers(127, dtype="i1", endpoint=True)
+def_gen.integers(-128, 127, dtype="i1", endpoint=True)
+def_gen.integers(I_i1_low_like, 127, dtype="i1", endpoint=True)
+def_gen.integers(I_i1_high_open, dtype="i1")
+def_gen.integers(I_i1_low, I_i1_high_open, dtype="i1")
+def_gen.integers(-128, I_i1_high_open, dtype="i1")
+def_gen.integers(I_i1_high_closed, dtype="i1", endpoint=True)
+def_gen.integers(I_i1_low, I_i1_high_closed, dtype="i1", endpoint=True)
+def_gen.integers(-128, I_i1_high_closed, dtype="i1", endpoint=True)
+
+def_gen.integers(128, dtype="int8")
+def_gen.integers(-128, 128, dtype="int8")
+def_gen.integers(127, dtype="int8", endpoint=True)
+def_gen.integers(-128, 127, dtype="int8", endpoint=True)
+def_gen.integers(I_i1_low_like, 127, dtype="int8", endpoint=True)
+def_gen.integers(I_i1_high_open, dtype="int8")
+def_gen.integers(I_i1_low, I_i1_high_open, dtype="int8")
+def_gen.integers(-128, I_i1_high_open, dtype="int8")
+def_gen.integers(I_i1_high_closed, dtype="int8", endpoint=True)
+def_gen.integers(I_i1_low, I_i1_high_closed, dtype="int8", endpoint=True)
+def_gen.integers(-128, I_i1_high_closed, dtype="int8", endpoint=True)
+
+def_gen.integers(128, dtype=np.int8)
+def_gen.integers(-128, 128, dtype=np.int8)
+def_gen.integers(127, dtype=np.int8, endpoint=True)
+def_gen.integers(-128, 127, dtype=np.int8, endpoint=True)
+def_gen.integers(I_i1_low_like, 127, dtype=np.int8, endpoint=True)
+def_gen.integers(I_i1_high_open, dtype=np.int8)
+def_gen.integers(I_i1_low, I_i1_high_open, dtype=np.int8)
+def_gen.integers(-128, I_i1_high_open, dtype=np.int8)
+def_gen.integers(I_i1_high_closed, dtype=np.int8, endpoint=True)
+def_gen.integers(I_i1_low, I_i1_high_closed, dtype=np.int8, endpoint=True)
+def_gen.integers(-128, I_i1_high_closed, dtype=np.int8, endpoint=True)
+
+I_i2_low: np.ndarray[Any, np.dtype[np.int16]] = np.array([-32768], dtype=np.int16)
+I_i2_low_like: list[int] = [-32768]
+I_i2_high_open: np.ndarray[Any, np.dtype[np.int16]] = np.array([32767], dtype=np.int16)
+I_i2_high_closed: np.ndarray[Any, np.dtype[np.int16]] = np.array([32767], dtype=np.int16)
+
+def_gen.integers(32768, dtype="i2")
+def_gen.integers(-32768, 32768, dtype="i2")
+def_gen.integers(32767, dtype="i2", endpoint=True)
+def_gen.integers(-32768, 32767, dtype="i2", endpoint=True)
+def_gen.integers(I_i2_low_like, 32767, dtype="i2", endpoint=True)
+def_gen.integers(I_i2_high_open, dtype="i2")
+def_gen.integers(I_i2_low, I_i2_high_open, dtype="i2")
+def_gen.integers(-32768, I_i2_high_open, dtype="i2")
+def_gen.integers(I_i2_high_closed, dtype="i2", endpoint=True)
+def_gen.integers(I_i2_low, I_i2_high_closed, dtype="i2", endpoint=True)
+def_gen.integers(-32768, I_i2_high_closed, dtype="i2", endpoint=True)
+
+def_gen.integers(32768, dtype="int16")
+def_gen.integers(-32768, 32768, dtype="int16")
+def_gen.integers(32767, dtype="int16", endpoint=True)
+def_gen.integers(-32768, 32767, dtype="int16", endpoint=True)
+def_gen.integers(I_i2_low_like, 32767, dtype="int16", endpoint=True)
+def_gen.integers(I_i2_high_open, dtype="int16")
+def_gen.integers(I_i2_low, I_i2_high_open, dtype="int16")
+def_gen.integers(-32768, I_i2_high_open, dtype="int16")
+def_gen.integers(I_i2_high_closed, dtype="int16", endpoint=True)
+def_gen.integers(I_i2_low, I_i2_high_closed, dtype="int16", endpoint=True)
+def_gen.integers(-32768, I_i2_high_closed, dtype="int16", endpoint=True)
+
+def_gen.integers(32768, dtype=np.int16)
+def_gen.integers(-32768, 32768, dtype=np.int16)
+def_gen.integers(32767, dtype=np.int16, endpoint=True)
+def_gen.integers(-32768, 32767, dtype=np.int16, endpoint=True)
+def_gen.integers(I_i2_low_like, 32767, dtype=np.int16, endpoint=True)
+def_gen.integers(I_i2_high_open, dtype=np.int16)
+def_gen.integers(I_i2_low, I_i2_high_open, dtype=np.int16)
+def_gen.integers(-32768, I_i2_high_open, dtype=np.int16)
+def_gen.integers(I_i2_high_closed, dtype=np.int16, endpoint=True)
+def_gen.integers(I_i2_low, I_i2_high_closed, dtype=np.int16, endpoint=True)
+def_gen.integers(-32768, I_i2_high_closed, dtype=np.int16, endpoint=True)
+
+I_i4_low: np.ndarray[Any, np.dtype[np.int32]] = np.array([-2147483648], dtype=np.int32)
+I_i4_low_like: list[int] = [-2147483648]
+I_i4_high_open: np.ndarray[Any, np.dtype[np.int32]] = np.array([2147483647], dtype=np.int32)
+I_i4_high_closed: np.ndarray[Any, np.dtype[np.int32]] = np.array([2147483647], dtype=np.int32)
+
+def_gen.integers(2147483648, dtype="i4")
+def_gen.integers(-2147483648, 2147483648, dtype="i4")
+def_gen.integers(2147483647, dtype="i4", endpoint=True)
+def_gen.integers(-2147483648, 2147483647, dtype="i4", endpoint=True)
+def_gen.integers(I_i4_low_like, 2147483647, dtype="i4", endpoint=True)
+def_gen.integers(I_i4_high_open, dtype="i4")
+def_gen.integers(I_i4_low, I_i4_high_open, dtype="i4")
+def_gen.integers(-2147483648, I_i4_high_open, dtype="i4")
+def_gen.integers(I_i4_high_closed, dtype="i4", endpoint=True)
+def_gen.integers(I_i4_low, I_i4_high_closed, dtype="i4", endpoint=True)
+def_gen.integers(-2147483648, I_i4_high_closed, dtype="i4", endpoint=True)
+
+def_gen.integers(2147483648, dtype="int32")
+def_gen.integers(-2147483648, 2147483648, dtype="int32")
+def_gen.integers(2147483647, dtype="int32", endpoint=True)
+def_gen.integers(-2147483648, 2147483647, dtype="int32", endpoint=True)
+def_gen.integers(I_i4_low_like, 2147483647, dtype="int32", endpoint=True)
+def_gen.integers(I_i4_high_open, dtype="int32")
+def_gen.integers(I_i4_low, I_i4_high_open, dtype="int32")
+def_gen.integers(-2147483648, I_i4_high_open, dtype="int32")
+def_gen.integers(I_i4_high_closed, dtype="int32", endpoint=True)
+def_gen.integers(I_i4_low, I_i4_high_closed, dtype="int32", endpoint=True)
+def_gen.integers(-2147483648, I_i4_high_closed, dtype="int32", endpoint=True)
+
+def_gen.integers(2147483648, dtype=np.int32)
+def_gen.integers(-2147483648, 2147483648, dtype=np.int32)
+def_gen.integers(2147483647, dtype=np.int32, endpoint=True)
+def_gen.integers(-2147483648, 2147483647, dtype=np.int32, endpoint=True)
+def_gen.integers(I_i4_low_like, 2147483647, dtype=np.int32, endpoint=True)
+def_gen.integers(I_i4_high_open, dtype=np.int32)
+def_gen.integers(I_i4_low, I_i4_high_open, dtype=np.int32)
+def_gen.integers(-2147483648, I_i4_high_open, dtype=np.int32)
+def_gen.integers(I_i4_high_closed, dtype=np.int32, endpoint=True)
+def_gen.integers(I_i4_low, I_i4_high_closed, dtype=np.int32, endpoint=True)
+def_gen.integers(-2147483648, I_i4_high_closed, dtype=np.int32, endpoint=True)
+
+I_i8_low: np.ndarray[Any, np.dtype[np.int64]] = np.array([-9223372036854775808], dtype=np.int64)
+I_i8_low_like: list[int] = [-9223372036854775808]
+I_i8_high_open: np.ndarray[Any, np.dtype[np.int64]] = np.array([9223372036854775807], dtype=np.int64)
+I_i8_high_closed: np.ndarray[Any, np.dtype[np.int64]] = np.array([9223372036854775807], dtype=np.int64)
+
+def_gen.integers(9223372036854775808, dtype="i8")
+def_gen.integers(-9223372036854775808, 9223372036854775808, dtype="i8")
+def_gen.integers(9223372036854775807, dtype="i8", endpoint=True)
+def_gen.integers(-9223372036854775808, 9223372036854775807, dtype="i8", endpoint=True)
+def_gen.integers(I_i8_low_like, 9223372036854775807, dtype="i8", endpoint=True)
+def_gen.integers(I_i8_high_open, dtype="i8")
+def_gen.integers(I_i8_low, I_i8_high_open, dtype="i8")
+def_gen.integers(-9223372036854775808, I_i8_high_open, dtype="i8")
+def_gen.integers(I_i8_high_closed, dtype="i8", endpoint=True)
+def_gen.integers(I_i8_low, I_i8_high_closed, dtype="i8", endpoint=True)
+def_gen.integers(-9223372036854775808, I_i8_high_closed, dtype="i8", endpoint=True)
+
+def_gen.integers(9223372036854775808, dtype="int64")
+def_gen.integers(-9223372036854775808, 9223372036854775808, dtype="int64")
+def_gen.integers(9223372036854775807, dtype="int64", endpoint=True)
+def_gen.integers(-9223372036854775808, 9223372036854775807, dtype="int64", endpoint=True)
+def_gen.integers(I_i8_low_like, 9223372036854775807, dtype="int64", endpoint=True)
+def_gen.integers(I_i8_high_open, dtype="int64")
+def_gen.integers(I_i8_low, I_i8_high_open, dtype="int64")
+def_gen.integers(-9223372036854775808, I_i8_high_open, dtype="int64")
+def_gen.integers(I_i8_high_closed, dtype="int64", endpoint=True)
+def_gen.integers(I_i8_low, I_i8_high_closed, dtype="int64", endpoint=True)
+def_gen.integers(-9223372036854775808, I_i8_high_closed, dtype="int64", endpoint=True)
+
+def_gen.integers(9223372036854775808, dtype=np.int64)
+def_gen.integers(-9223372036854775808, 9223372036854775808, dtype=np.int64)
+def_gen.integers(9223372036854775807, dtype=np.int64, endpoint=True)
+def_gen.integers(-9223372036854775808, 9223372036854775807, dtype=np.int64, endpoint=True)
+def_gen.integers(I_i8_low_like, 9223372036854775807, dtype=np.int64, endpoint=True)
+def_gen.integers(I_i8_high_open, dtype=np.int64)
+def_gen.integers(I_i8_low, I_i8_high_open, dtype=np.int64)
+def_gen.integers(-9223372036854775808, I_i8_high_open, dtype=np.int64)
+def_gen.integers(I_i8_high_closed, dtype=np.int64, endpoint=True)
+def_gen.integers(I_i8_low, I_i8_high_closed, dtype=np.int64, endpoint=True)
+def_gen.integers(-9223372036854775808, I_i8_high_closed, dtype=np.int64, endpoint=True)
+
+
+def_gen.bit_generator
+
+def_gen.bytes(2)
+
+def_gen.choice(5)
+def_gen.choice(5, 3)
+def_gen.choice(5, 3, replace=True)
+def_gen.choice(5, 3, p=[1 / 5] * 5)
+def_gen.choice(5, 3, p=[1 / 5] * 5, replace=False)
+
+def_gen.choice(["pooh", "rabbit", "piglet", "Christopher"])
+def_gen.choice(["pooh", "rabbit", "piglet", "Christopher"], 3)
+def_gen.choice(["pooh", "rabbit", "piglet", "Christopher"], 3, p=[1 / 4] * 4)
+def_gen.choice(["pooh", "rabbit", "piglet", "Christopher"], 3, replace=True)
+def_gen.choice(["pooh", "rabbit", "piglet", "Christopher"], 3, replace=False, p=np.array([1 / 8, 1 / 8, 1 / 2, 1 / 4]))
+
+def_gen.dirichlet([0.5, 0.5])
+def_gen.dirichlet(np.array([0.5, 0.5]))
+def_gen.dirichlet(np.array([0.5, 0.5]), size=3)
+
+def_gen.multinomial(20, [1 / 6.0] * 6)
+def_gen.multinomial(20, np.array([0.5, 0.5]))
+def_gen.multinomial(20, [1 / 6.0] * 6, size=2)
+def_gen.multinomial([[10], [20]], [1 / 6.0] * 6, size=(2, 2))
+def_gen.multinomial(np.array([[10], [20]]), np.array([0.5, 0.5]), size=(2, 2))
+
+def_gen.multivariate_hypergeometric([3, 5, 7], 2)
+def_gen.multivariate_hypergeometric(np.array([3, 5, 7]), 2)
+def_gen.multivariate_hypergeometric(np.array([3, 5, 7]), 2, size=4)
+def_gen.multivariate_hypergeometric(np.array([3, 5, 7]), 2, size=(4, 7))
+def_gen.multivariate_hypergeometric([3, 5, 7], 2, method="count")
+def_gen.multivariate_hypergeometric(np.array([3, 5, 7]), 2, method="marginals")
+
+def_gen.multivariate_normal([0.0], [[1.0]])
+def_gen.multivariate_normal([0.0], np.array([[1.0]]))
+def_gen.multivariate_normal(np.array([0.0]), [[1.0]])
+def_gen.multivariate_normal([0.0], np.array([[1.0]]))
+
+def_gen.permutation(10)
+def_gen.permutation([1, 2, 3, 4])
+def_gen.permutation(np.array([1, 2, 3, 4]))
+def_gen.permutation(D_2D, axis=1)
+def_gen.permuted(D_2D)
+def_gen.permuted(D_2D_like)
+def_gen.permuted(D_2D, axis=1)
+def_gen.permuted(D_2D, out=D_2D)
+def_gen.permuted(D_2D_like, out=D_2D)
+def_gen.permuted(D_2D_like, out=D_2D)
+def_gen.permuted(D_2D, axis=1, out=D_2D)
+
+def_gen.shuffle(np.arange(10))
+def_gen.shuffle([1, 2, 3, 4, 5])
+def_gen.shuffle(D_2D, axis=1)
+
+def_gen.__str__()
+def_gen.__repr__()
+def_gen_state: dict[str, Any]
+def_gen_state = def_gen.__getstate__()
+def_gen.__setstate__(def_gen_state)
+
+# RandomState
+random_st: np.random.RandomState = np.random.RandomState()
+
+random_st.standard_normal()
+random_st.standard_normal(size=None)
+random_st.standard_normal(size=1)
+
+random_st.random()
+random_st.random(size=None)
+random_st.random(size=1)
+
+random_st.standard_cauchy()
+random_st.standard_cauchy(size=None)
+random_st.standard_cauchy(size=1)
+
+random_st.standard_exponential()
+random_st.standard_exponential(size=None)
+random_st.standard_exponential(size=1)
+
+random_st.zipf(1.5)
+random_st.zipf(1.5, size=None)
+random_st.zipf(1.5, size=1)
+random_st.zipf(D_arr_1p5)
+random_st.zipf(D_arr_1p5, size=1)
+random_st.zipf(D_arr_like_1p5)
+random_st.zipf(D_arr_like_1p5, size=1)
+
+random_st.weibull(0.5)
+random_st.weibull(0.5, size=None)
+random_st.weibull(0.5, size=1)
+random_st.weibull(D_arr_0p5)
+random_st.weibull(D_arr_0p5, size=1)
+random_st.weibull(D_arr_like_0p5)
+random_st.weibull(D_arr_like_0p5, size=1)
+
+random_st.standard_t(0.5)
+random_st.standard_t(0.5, size=None)
+random_st.standard_t(0.5, size=1)
+random_st.standard_t(D_arr_0p5)
+random_st.standard_t(D_arr_0p5, size=1)
+random_st.standard_t(D_arr_like_0p5)
+random_st.standard_t(D_arr_like_0p5, size=1)
+
+random_st.poisson(0.5)
+random_st.poisson(0.5, size=None)
+random_st.poisson(0.5, size=1)
+random_st.poisson(D_arr_0p5)
+random_st.poisson(D_arr_0p5, size=1)
+random_st.poisson(D_arr_like_0p5)
+random_st.poisson(D_arr_like_0p5, size=1)
+
+random_st.power(0.5)
+random_st.power(0.5, size=None)
+random_st.power(0.5, size=1)
+random_st.power(D_arr_0p5)
+random_st.power(D_arr_0p5, size=1)
+random_st.power(D_arr_like_0p5)
+random_st.power(D_arr_like_0p5, size=1)
+
+random_st.pareto(0.5)
+random_st.pareto(0.5, size=None)
+random_st.pareto(0.5, size=1)
+random_st.pareto(D_arr_0p5)
+random_st.pareto(D_arr_0p5, size=1)
+random_st.pareto(D_arr_like_0p5)
+random_st.pareto(D_arr_like_0p5, size=1)
+
+random_st.chisquare(0.5)
+random_st.chisquare(0.5, size=None)
+random_st.chisquare(0.5, size=1)
+random_st.chisquare(D_arr_0p5)
+random_st.chisquare(D_arr_0p5, size=1)
+random_st.chisquare(D_arr_like_0p5)
+random_st.chisquare(D_arr_like_0p5, size=1)
+
+random_st.exponential(0.5)
+random_st.exponential(0.5, size=None)
+random_st.exponential(0.5, size=1)
+random_st.exponential(D_arr_0p5)
+random_st.exponential(D_arr_0p5, size=1)
+random_st.exponential(D_arr_like_0p5)
+random_st.exponential(D_arr_like_0p5, size=1)
+
+random_st.geometric(0.5)
+random_st.geometric(0.5, size=None)
+random_st.geometric(0.5, size=1)
+random_st.geometric(D_arr_0p5)
+random_st.geometric(D_arr_0p5, size=1)
+random_st.geometric(D_arr_like_0p5)
+random_st.geometric(D_arr_like_0p5, size=1)
+
+random_st.logseries(0.5)
+random_st.logseries(0.5, size=None)
+random_st.logseries(0.5, size=1)
+random_st.logseries(D_arr_0p5)
+random_st.logseries(D_arr_0p5, size=1)
+random_st.logseries(D_arr_like_0p5)
+random_st.logseries(D_arr_like_0p5, size=1)
+
+random_st.rayleigh(0.5)
+random_st.rayleigh(0.5, size=None)
+random_st.rayleigh(0.5, size=1)
+random_st.rayleigh(D_arr_0p5)
+random_st.rayleigh(D_arr_0p5, size=1)
+random_st.rayleigh(D_arr_like_0p5)
+random_st.rayleigh(D_arr_like_0p5, size=1)
+
+random_st.standard_gamma(0.5)
+random_st.standard_gamma(0.5, size=None)
+random_st.standard_gamma(0.5, size=1)
+random_st.standard_gamma(D_arr_0p5)
+random_st.standard_gamma(D_arr_0p5, size=1)
+random_st.standard_gamma(D_arr_like_0p5)
+random_st.standard_gamma(D_arr_like_0p5, size=1)
+random_st.standard_gamma(D_arr_like_0p5, size=1)
+
+random_st.vonmises(0.5, 0.5)
+random_st.vonmises(0.5, 0.5, size=None)
+random_st.vonmises(0.5, 0.5, size=1)
+random_st.vonmises(D_arr_0p5, 0.5)
+random_st.vonmises(0.5, D_arr_0p5)
+random_st.vonmises(D_arr_0p5, 0.5, size=1)
+random_st.vonmises(0.5, D_arr_0p5, size=1)
+random_st.vonmises(D_arr_like_0p5, 0.5)
+random_st.vonmises(0.5, D_arr_like_0p5)
+random_st.vonmises(D_arr_0p5, D_arr_0p5)
+random_st.vonmises(D_arr_like_0p5, D_arr_like_0p5)
+random_st.vonmises(D_arr_0p5, D_arr_0p5, size=1)
+random_st.vonmises(D_arr_like_0p5, D_arr_like_0p5, size=1)
+
+random_st.wald(0.5, 0.5)
+random_st.wald(0.5, 0.5, size=None)
+random_st.wald(0.5, 0.5, size=1)
+random_st.wald(D_arr_0p5, 0.5)
+random_st.wald(0.5, D_arr_0p5)
+random_st.wald(D_arr_0p5, 0.5, size=1)
+random_st.wald(0.5, D_arr_0p5, size=1)
+random_st.wald(D_arr_like_0p5, 0.5)
+random_st.wald(0.5, D_arr_like_0p5)
+random_st.wald(D_arr_0p5, D_arr_0p5)
+random_st.wald(D_arr_like_0p5, D_arr_like_0p5)
+random_st.wald(D_arr_0p5, D_arr_0p5, size=1)
+random_st.wald(D_arr_like_0p5, D_arr_like_0p5, size=1)
+
+random_st.uniform(0.5, 0.5)
+random_st.uniform(0.5, 0.5, size=None)
+random_st.uniform(0.5, 0.5, size=1)
+random_st.uniform(D_arr_0p5, 0.5)
+random_st.uniform(0.5, D_arr_0p5)
+random_st.uniform(D_arr_0p5, 0.5, size=1)
+random_st.uniform(0.5, D_arr_0p5, size=1)
+random_st.uniform(D_arr_like_0p5, 0.5)
+random_st.uniform(0.5, D_arr_like_0p5)
+random_st.uniform(D_arr_0p5, D_arr_0p5)
+random_st.uniform(D_arr_like_0p5, D_arr_like_0p5)
+random_st.uniform(D_arr_0p5, D_arr_0p5, size=1)
+random_st.uniform(D_arr_like_0p5, D_arr_like_0p5, size=1)
+
+random_st.beta(0.5, 0.5)
+random_st.beta(0.5, 0.5, size=None)
+random_st.beta(0.5, 0.5, size=1)
+random_st.beta(D_arr_0p5, 0.5)
+random_st.beta(0.5, D_arr_0p5)
+random_st.beta(D_arr_0p5, 0.5, size=1)
+random_st.beta(0.5, D_arr_0p5, size=1)
+random_st.beta(D_arr_like_0p5, 0.5)
+random_st.beta(0.5, D_arr_like_0p5)
+random_st.beta(D_arr_0p5, D_arr_0p5)
+random_st.beta(D_arr_like_0p5, D_arr_like_0p5)
+random_st.beta(D_arr_0p5, D_arr_0p5, size=1)
+random_st.beta(D_arr_like_0p5, D_arr_like_0p5, size=1)
+
+random_st.f(0.5, 0.5)
+random_st.f(0.5, 0.5, size=None)
+random_st.f(0.5, 0.5, size=1)
+random_st.f(D_arr_0p5, 0.5)
+random_st.f(0.5, D_arr_0p5)
+random_st.f(D_arr_0p5, 0.5, size=1)
+random_st.f(0.5, D_arr_0p5, size=1)
+random_st.f(D_arr_like_0p5, 0.5)
+random_st.f(0.5, D_arr_like_0p5)
+random_st.f(D_arr_0p5, D_arr_0p5)
+random_st.f(D_arr_like_0p5, D_arr_like_0p5)
+random_st.f(D_arr_0p5, D_arr_0p5, size=1)
+random_st.f(D_arr_like_0p5, D_arr_like_0p5, size=1)
+
+random_st.gamma(0.5, 0.5)
+random_st.gamma(0.5, 0.5, size=None)
+random_st.gamma(0.5, 0.5, size=1)
+random_st.gamma(D_arr_0p5, 0.5)
+random_st.gamma(0.5, D_arr_0p5)
+random_st.gamma(D_arr_0p5, 0.5, size=1)
+random_st.gamma(0.5, D_arr_0p5, size=1)
+random_st.gamma(D_arr_like_0p5, 0.5)
+random_st.gamma(0.5, D_arr_like_0p5)
+random_st.gamma(D_arr_0p5, D_arr_0p5)
+random_st.gamma(D_arr_like_0p5, D_arr_like_0p5)
+random_st.gamma(D_arr_0p5, D_arr_0p5, size=1)
+random_st.gamma(D_arr_like_0p5, D_arr_like_0p5, size=1)
+
+random_st.gumbel(0.5, 0.5)
+random_st.gumbel(0.5, 0.5, size=None)
+random_st.gumbel(0.5, 0.5, size=1)
+random_st.gumbel(D_arr_0p5, 0.5)
+random_st.gumbel(0.5, D_arr_0p5)
+random_st.gumbel(D_arr_0p5, 0.5, size=1)
+random_st.gumbel(0.5, D_arr_0p5, size=1)
+random_st.gumbel(D_arr_like_0p5, 0.5)
+random_st.gumbel(0.5, D_arr_like_0p5)
+random_st.gumbel(D_arr_0p5, D_arr_0p5)
+random_st.gumbel(D_arr_like_0p5, D_arr_like_0p5)
+random_st.gumbel(D_arr_0p5, D_arr_0p5, size=1)
+random_st.gumbel(D_arr_like_0p5, D_arr_like_0p5, size=1)
+
+random_st.laplace(0.5, 0.5)
+random_st.laplace(0.5, 0.5, size=None)
+random_st.laplace(0.5, 0.5, size=1)
+random_st.laplace(D_arr_0p5, 0.5)
+random_st.laplace(0.5, D_arr_0p5)
+random_st.laplace(D_arr_0p5, 0.5, size=1)
+random_st.laplace(0.5, D_arr_0p5, size=1)
+random_st.laplace(D_arr_like_0p5, 0.5)
+random_st.laplace(0.5, D_arr_like_0p5)
+random_st.laplace(D_arr_0p5, D_arr_0p5)
+random_st.laplace(D_arr_like_0p5, D_arr_like_0p5)
+random_st.laplace(D_arr_0p5, D_arr_0p5, size=1)
+random_st.laplace(D_arr_like_0p5, D_arr_like_0p5, size=1)
+
+random_st.logistic(0.5, 0.5)
+random_st.logistic(0.5, 0.5, size=None)
+random_st.logistic(0.5, 0.5, size=1)
+random_st.logistic(D_arr_0p5, 0.5)
+random_st.logistic(0.5, D_arr_0p5)
+random_st.logistic(D_arr_0p5, 0.5, size=1)
+random_st.logistic(0.5, D_arr_0p5, size=1)
+random_st.logistic(D_arr_like_0p5, 0.5)
+random_st.logistic(0.5, D_arr_like_0p5)
+random_st.logistic(D_arr_0p5, D_arr_0p5)
+random_st.logistic(D_arr_like_0p5, D_arr_like_0p5)
+random_st.logistic(D_arr_0p5, D_arr_0p5, size=1)
+random_st.logistic(D_arr_like_0p5, D_arr_like_0p5, size=1)
+
+random_st.lognormal(0.5, 0.5)
+random_st.lognormal(0.5, 0.5, size=None)
+random_st.lognormal(0.5, 0.5, size=1)
+random_st.lognormal(D_arr_0p5, 0.5)
+random_st.lognormal(0.5, D_arr_0p5)
+random_st.lognormal(D_arr_0p5, 0.5, size=1)
+random_st.lognormal(0.5, D_arr_0p5, size=1)
+random_st.lognormal(D_arr_like_0p5, 0.5)
+random_st.lognormal(0.5, D_arr_like_0p5)
+random_st.lognormal(D_arr_0p5, D_arr_0p5)
+random_st.lognormal(D_arr_like_0p5, D_arr_like_0p5)
+random_st.lognormal(D_arr_0p5, D_arr_0p5, size=1)
+random_st.lognormal(D_arr_like_0p5, D_arr_like_0p5, size=1)
+
+random_st.noncentral_chisquare(0.5, 0.5)
+random_st.noncentral_chisquare(0.5, 0.5, size=None)
+random_st.noncentral_chisquare(0.5, 0.5, size=1)
+random_st.noncentral_chisquare(D_arr_0p5, 0.5)
+random_st.noncentral_chisquare(0.5, D_arr_0p5)
+random_st.noncentral_chisquare(D_arr_0p5, 0.5, size=1)
+random_st.noncentral_chisquare(0.5, D_arr_0p5, size=1)
+random_st.noncentral_chisquare(D_arr_like_0p5, 0.5)
+random_st.noncentral_chisquare(0.5, D_arr_like_0p5)
+random_st.noncentral_chisquare(D_arr_0p5, D_arr_0p5)
+random_st.noncentral_chisquare(D_arr_like_0p5, D_arr_like_0p5)
+random_st.noncentral_chisquare(D_arr_0p5, D_arr_0p5, size=1)
+random_st.noncentral_chisquare(D_arr_like_0p5, D_arr_like_0p5, size=1)
+
+random_st.normal(0.5, 0.5)
+random_st.normal(0.5, 0.5, size=None)
+random_st.normal(0.5, 0.5, size=1)
+random_st.normal(D_arr_0p5, 0.5)
+random_st.normal(0.5, D_arr_0p5)
+random_st.normal(D_arr_0p5, 0.5, size=1)
+random_st.normal(0.5, D_arr_0p5, size=1)
+random_st.normal(D_arr_like_0p5, 0.5)
+random_st.normal(0.5, D_arr_like_0p5)
+random_st.normal(D_arr_0p5, D_arr_0p5)
+random_st.normal(D_arr_like_0p5, D_arr_like_0p5)
+random_st.normal(D_arr_0p5, D_arr_0p5, size=1)
+random_st.normal(D_arr_like_0p5, D_arr_like_0p5, size=1)
+
+random_st.triangular(0.1, 0.5, 0.9)
+random_st.triangular(0.1, 0.5, 0.9, size=None)
+random_st.triangular(0.1, 0.5, 0.9, size=1)
+random_st.triangular(D_arr_0p1, 0.5, 0.9)
+random_st.triangular(0.1, D_arr_0p5, 0.9)
+random_st.triangular(D_arr_0p1, 0.5, D_arr_like_0p9, size=1)
+random_st.triangular(0.1, D_arr_0p5, 0.9, size=1)
+random_st.triangular(D_arr_like_0p1, 0.5, D_arr_0p9)
+random_st.triangular(0.5, D_arr_like_0p5, 0.9)
+random_st.triangular(D_arr_0p1, D_arr_0p5, 0.9)
+random_st.triangular(D_arr_like_0p1, D_arr_like_0p5, 0.9)
+random_st.triangular(D_arr_0p1, D_arr_0p5, D_arr_0p9, size=1)
+random_st.triangular(D_arr_like_0p1, D_arr_like_0p5, D_arr_like_0p9, size=1)
+
+random_st.noncentral_f(0.1, 0.5, 0.9)
+random_st.noncentral_f(0.1, 0.5, 0.9, size=None)
+random_st.noncentral_f(0.1, 0.5, 0.9, size=1)
+random_st.noncentral_f(D_arr_0p1, 0.5, 0.9)
+random_st.noncentral_f(0.1, D_arr_0p5, 0.9)
+random_st.noncentral_f(D_arr_0p1, 0.5, D_arr_like_0p9, size=1)
+random_st.noncentral_f(0.1, D_arr_0p5, 0.9, size=1)
+random_st.noncentral_f(D_arr_like_0p1, 0.5, D_arr_0p9)
+random_st.noncentral_f(0.5, D_arr_like_0p5, 0.9)
+random_st.noncentral_f(D_arr_0p1, D_arr_0p5, 0.9)
+random_st.noncentral_f(D_arr_like_0p1, D_arr_like_0p5, 0.9)
+random_st.noncentral_f(D_arr_0p1, D_arr_0p5, D_arr_0p9, size=1)
+random_st.noncentral_f(D_arr_like_0p1, D_arr_like_0p5, D_arr_like_0p9, size=1)
+
+random_st.binomial(10, 0.5)
+random_st.binomial(10, 0.5, size=None)
+random_st.binomial(10, 0.5, size=1)
+random_st.binomial(I_arr_10, 0.5)
+random_st.binomial(10, D_arr_0p5)
+random_st.binomial(I_arr_10, 0.5, size=1)
+random_st.binomial(10, D_arr_0p5, size=1)
+random_st.binomial(I_arr_like_10, 0.5)
+random_st.binomial(10, D_arr_like_0p5)
+random_st.binomial(I_arr_10, D_arr_0p5)
+random_st.binomial(I_arr_like_10, D_arr_like_0p5)
+random_st.binomial(I_arr_10, D_arr_0p5, size=1)
+random_st.binomial(I_arr_like_10, D_arr_like_0p5, size=1)
+
+random_st.negative_binomial(10, 0.5)
+random_st.negative_binomial(10, 0.5, size=None)
+random_st.negative_binomial(10, 0.5, size=1)
+random_st.negative_binomial(I_arr_10, 0.5)
+random_st.negative_binomial(10, D_arr_0p5)
+random_st.negative_binomial(I_arr_10, 0.5, size=1)
+random_st.negative_binomial(10, D_arr_0p5, size=1)
+random_st.negative_binomial(I_arr_like_10, 0.5)
+random_st.negative_binomial(10, D_arr_like_0p5)
+random_st.negative_binomial(I_arr_10, D_arr_0p5)
+random_st.negative_binomial(I_arr_like_10, D_arr_like_0p5)
+random_st.negative_binomial(I_arr_10, D_arr_0p5, size=1)
+random_st.negative_binomial(I_arr_like_10, D_arr_like_0p5, size=1)
+
+random_st.hypergeometric(20, 20, 10)
+random_st.hypergeometric(20, 20, 10, size=None)
+random_st.hypergeometric(20, 20, 10, size=1)
+random_st.hypergeometric(I_arr_20, 20, 10)
+random_st.hypergeometric(20, I_arr_20, 10)
+random_st.hypergeometric(I_arr_20, 20, I_arr_like_10, size=1)
+random_st.hypergeometric(20, I_arr_20, 10, size=1)
+random_st.hypergeometric(I_arr_like_20, 20, I_arr_10)
+random_st.hypergeometric(20, I_arr_like_20, 10)
+random_st.hypergeometric(I_arr_20, I_arr_20, 10)
+random_st.hypergeometric(I_arr_like_20, I_arr_like_20, 10)
+random_st.hypergeometric(I_arr_20, I_arr_20, I_arr_10, size=1)
+random_st.hypergeometric(I_arr_like_20, I_arr_like_20, I_arr_like_10, size=1)
+
+random_st.randint(0, 100)
+random_st.randint(100)
+random_st.randint([100])
+random_st.randint(0, [100])
+
+random_st.randint(2, dtype=bool)
+random_st.randint(0, 2, dtype=bool)
+random_st.randint(I_bool_high_open, dtype=bool)
+random_st.randint(I_bool_low, I_bool_high_open, dtype=bool)
+random_st.randint(0, I_bool_high_open, dtype=bool)
+
+random_st.randint(2, dtype=np.bool_)
+random_st.randint(0, 2, dtype=np.bool_)
+random_st.randint(I_bool_high_open, dtype=np.bool_)
+random_st.randint(I_bool_low, I_bool_high_open, dtype=np.bool_)
+random_st.randint(0, I_bool_high_open, dtype=np.bool_)
+
+random_st.randint(256, dtype="u1")
+random_st.randint(0, 256, dtype="u1")
+random_st.randint(I_u1_high_open, dtype="u1")
+random_st.randint(I_u1_low, I_u1_high_open, dtype="u1")
+random_st.randint(0, I_u1_high_open, dtype="u1")
+
+random_st.randint(256, dtype="uint8")
+random_st.randint(0, 256, dtype="uint8")
+random_st.randint(I_u1_high_open, dtype="uint8")
+random_st.randint(I_u1_low, I_u1_high_open, dtype="uint8")
+random_st.randint(0, I_u1_high_open, dtype="uint8")
+
+random_st.randint(256, dtype=np.uint8)
+random_st.randint(0, 256, dtype=np.uint8)
+random_st.randint(I_u1_high_open, dtype=np.uint8)
+random_st.randint(I_u1_low, I_u1_high_open, dtype=np.uint8)
+random_st.randint(0, I_u1_high_open, dtype=np.uint8)
+
+random_st.randint(65536, dtype="u2")
+random_st.randint(0, 65536, dtype="u2")
+random_st.randint(I_u2_high_open, dtype="u2")
+random_st.randint(I_u2_low, I_u2_high_open, dtype="u2")
+random_st.randint(0, I_u2_high_open, dtype="u2")
+
+random_st.randint(65536, dtype="uint16")
+random_st.randint(0, 65536, dtype="uint16")
+random_st.randint(I_u2_high_open, dtype="uint16")
+random_st.randint(I_u2_low, I_u2_high_open, dtype="uint16")
+random_st.randint(0, I_u2_high_open, dtype="uint16")
+
+random_st.randint(65536, dtype=np.uint16)
+random_st.randint(0, 65536, dtype=np.uint16)
+random_st.randint(I_u2_high_open, dtype=np.uint16)
+random_st.randint(I_u2_low, I_u2_high_open, dtype=np.uint16)
+random_st.randint(0, I_u2_high_open, dtype=np.uint16)
+
+random_st.randint(4294967296, dtype="u4")
+random_st.randint(0, 4294967296, dtype="u4")
+random_st.randint(I_u4_high_open, dtype="u4")
+random_st.randint(I_u4_low, I_u4_high_open, dtype="u4")
+random_st.randint(0, I_u4_high_open, dtype="u4")
+
+random_st.randint(4294967296, dtype="uint32")
+random_st.randint(0, 4294967296, dtype="uint32")
+random_st.randint(I_u4_high_open, dtype="uint32")
+random_st.randint(I_u4_low, I_u4_high_open, dtype="uint32")
+random_st.randint(0, I_u4_high_open, dtype="uint32")
+
+random_st.randint(4294967296, dtype=np.uint32)
+random_st.randint(0, 4294967296, dtype=np.uint32)
+random_st.randint(I_u4_high_open, dtype=np.uint32)
+random_st.randint(I_u4_low, I_u4_high_open, dtype=np.uint32)
+random_st.randint(0, I_u4_high_open, dtype=np.uint32)
+
+
+random_st.randint(18446744073709551616, dtype="u8")
+random_st.randint(0, 18446744073709551616, dtype="u8")
+random_st.randint(I_u8_high_open, dtype="u8")
+random_st.randint(I_u8_low, I_u8_high_open, dtype="u8")
+random_st.randint(0, I_u8_high_open, dtype="u8")
+
+random_st.randint(18446744073709551616, dtype="uint64")
+random_st.randint(0, 18446744073709551616, dtype="uint64")
+random_st.randint(I_u8_high_open, dtype="uint64")
+random_st.randint(I_u8_low, I_u8_high_open, dtype="uint64")
+random_st.randint(0, I_u8_high_open, dtype="uint64")
+
+random_st.randint(18446744073709551616, dtype=np.uint64)
+random_st.randint(0, 18446744073709551616, dtype=np.uint64)
+random_st.randint(I_u8_high_open, dtype=np.uint64)
+random_st.randint(I_u8_low, I_u8_high_open, dtype=np.uint64)
+random_st.randint(0, I_u8_high_open, dtype=np.uint64)
+
+random_st.randint(128, dtype="i1")
+random_st.randint(-128, 128, dtype="i1")
+random_st.randint(I_i1_high_open, dtype="i1")
+random_st.randint(I_i1_low, I_i1_high_open, dtype="i1")
+random_st.randint(-128, I_i1_high_open, dtype="i1")
+
+random_st.randint(128, dtype="int8")
+random_st.randint(-128, 128, dtype="int8")
+random_st.randint(I_i1_high_open, dtype="int8")
+random_st.randint(I_i1_low, I_i1_high_open, dtype="int8")
+random_st.randint(-128, I_i1_high_open, dtype="int8")
+
+random_st.randint(128, dtype=np.int8)
+random_st.randint(-128, 128, dtype=np.int8)
+random_st.randint(I_i1_high_open, dtype=np.int8)
+random_st.randint(I_i1_low, I_i1_high_open, dtype=np.int8)
+random_st.randint(-128, I_i1_high_open, dtype=np.int8)
+
+random_st.randint(32768, dtype="i2")
+random_st.randint(-32768, 32768, dtype="i2")
+random_st.randint(I_i2_high_open, dtype="i2")
+random_st.randint(I_i2_low, I_i2_high_open, dtype="i2")
+random_st.randint(-32768, I_i2_high_open, dtype="i2")
+random_st.randint(32768, dtype="int16")
+random_st.randint(-32768, 32768, dtype="int16")
+random_st.randint(I_i2_high_open, dtype="int16")
+random_st.randint(I_i2_low, I_i2_high_open, dtype="int16")
+random_st.randint(-32768, I_i2_high_open, dtype="int16")
+random_st.randint(32768, dtype=np.int16)
+random_st.randint(-32768, 32768, dtype=np.int16)
+random_st.randint(I_i2_high_open, dtype=np.int16)
+random_st.randint(I_i2_low, I_i2_high_open, dtype=np.int16)
+random_st.randint(-32768, I_i2_high_open, dtype=np.int16)
+
+random_st.randint(2147483648, dtype="i4")
+random_st.randint(-2147483648, 2147483648, dtype="i4")
+random_st.randint(I_i4_high_open, dtype="i4")
+random_st.randint(I_i4_low, I_i4_high_open, dtype="i4")
+random_st.randint(-2147483648, I_i4_high_open, dtype="i4")
+
+random_st.randint(2147483648, dtype="int32")
+random_st.randint(-2147483648, 2147483648, dtype="int32")
+random_st.randint(I_i4_high_open, dtype="int32")
+random_st.randint(I_i4_low, I_i4_high_open, dtype="int32")
+random_st.randint(-2147483648, I_i4_high_open, dtype="int32")
+
+random_st.randint(2147483648, dtype=np.int32)
+random_st.randint(-2147483648, 2147483648, dtype=np.int32)
+random_st.randint(I_i4_high_open, dtype=np.int32)
+random_st.randint(I_i4_low, I_i4_high_open, dtype=np.int32)
+random_st.randint(-2147483648, I_i4_high_open, dtype=np.int32)
+
+random_st.randint(9223372036854775808, dtype="i8")
+random_st.randint(-9223372036854775808, 9223372036854775808, dtype="i8")
+random_st.randint(I_i8_high_open, dtype="i8")
+random_st.randint(I_i8_low, I_i8_high_open, dtype="i8")
+random_st.randint(-9223372036854775808, I_i8_high_open, dtype="i8")
+
+random_st.randint(9223372036854775808, dtype="int64")
+random_st.randint(-9223372036854775808, 9223372036854775808, dtype="int64")
+random_st.randint(I_i8_high_open, dtype="int64")
+random_st.randint(I_i8_low, I_i8_high_open, dtype="int64")
+random_st.randint(-9223372036854775808, I_i8_high_open, dtype="int64")
+
+random_st.randint(9223372036854775808, dtype=np.int64)
+random_st.randint(-9223372036854775808, 9223372036854775808, dtype=np.int64)
+random_st.randint(I_i8_high_open, dtype=np.int64)
+random_st.randint(I_i8_low, I_i8_high_open, dtype=np.int64)
+random_st.randint(-9223372036854775808, I_i8_high_open, dtype=np.int64)
+
+bg: np.random.BitGenerator = random_st._bit_generator
+
+random_st.bytes(2)
+
+random_st.choice(5)
+random_st.choice(5, 3)
+random_st.choice(5, 3, replace=True)
+random_st.choice(5, 3, p=[1 / 5] * 5)
+random_st.choice(5, 3, p=[1 / 5] * 5, replace=False)
+
+random_st.choice(["pooh", "rabbit", "piglet", "Christopher"])
+random_st.choice(["pooh", "rabbit", "piglet", "Christopher"], 3)
+random_st.choice(["pooh", "rabbit", "piglet", "Christopher"], 3, p=[1 / 4] * 4)
+random_st.choice(["pooh", "rabbit", "piglet", "Christopher"], 3, replace=True)
+random_st.choice(["pooh", "rabbit", "piglet", "Christopher"], 3, replace=False, p=np.array([1 / 8, 1 / 8, 1 / 2, 1 / 4]))
+
+random_st.dirichlet([0.5, 0.5])
+random_st.dirichlet(np.array([0.5, 0.5]))
+random_st.dirichlet(np.array([0.5, 0.5]), size=3)
+
+random_st.multinomial(20, [1 / 6.0] * 6)
+random_st.multinomial(20, np.array([0.5, 0.5]))
+random_st.multinomial(20, [1 / 6.0] * 6, size=2)
+
+random_st.multivariate_normal([0.0], [[1.0]])
+random_st.multivariate_normal([0.0], np.array([[1.0]]))
+random_st.multivariate_normal(np.array([0.0]), [[1.0]])
+random_st.multivariate_normal([0.0], np.array([[1.0]]))
+
+random_st.permutation(10)
+random_st.permutation([1, 2, 3, 4])
+random_st.permutation(np.array([1, 2, 3, 4]))
+random_st.permutation(D_2D)
+
+random_st.shuffle(np.arange(10))
+random_st.shuffle([1, 2, 3, 4, 5])
+random_st.shuffle(D_2D)
+
+np.random.RandomState(SEED_PCG64)
+np.random.RandomState(0)
+np.random.RandomState([0, 1, 2])
+random_st.__str__()
+random_st.__repr__()
+random_st_state = random_st.__getstate__()
+random_st.__setstate__(random_st_state)
+random_st.seed()
+random_st.seed(1)
+random_st.seed([0, 1])
+random_st_get_state = random_st.get_state()
+random_st_get_state_legacy = random_st.get_state(legacy=True)
+random_st.set_state(random_st_get_state)
+
+random_st.rand()
+random_st.rand(1)
+random_st.rand(1, 2)
+random_st.randn()
+random_st.randn(1)
+random_st.randn(1, 2)
+random_st.random_sample()
+random_st.random_sample(1)
+random_st.random_sample(size=(1, 2))
+
+random_st.tomaxint()
+random_st.tomaxint(1)
+random_st.tomaxint((1,))
+
+np.random.set_bit_generator(SEED_PCG64)
+np.random.get_bit_generator()

LTA_openwebtext_dualt/mini_owt_logdirichlet/.venv_qwen35_uv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/simple.py

@@ -0,0 +1,165 @@
+"""Simple expression that should pass with mypy."""
+import operator
+
+import numpy as np
+from collections.abc import Iterable
+
+# Basic checks
+array = np.array([1, 2])
+
+
+def ndarray_func(x):
+    # type: (np.ndarray) -> np.ndarray
+    return x
+
+
+ndarray_func(np.array([1, 2]))
+array == 1
+array.dtype == float
+
+# Dtype construction
+np.dtype(float)
+np.dtype(np.float64)
+np.dtype(None)
+np.dtype("float64")
+np.dtype(np.dtype(float))
+np.dtype(("U", 10))
+np.dtype((np.int32, (2, 2)))
+# Define the arguments on the previous line to prevent bidirectional
+# type inference in mypy from broadening the types.
+two_tuples_dtype = [("R", "u1"), ("G", "u1"), ("B", "u1")]
+np.dtype(two_tuples_dtype)
+
+three_tuples_dtype = [("R", "u1", 2)]
+np.dtype(three_tuples_dtype)
+
+mixed_tuples_dtype = [("R", "u1"), ("G", np.str_, 1)]
+np.dtype(mixed_tuples_dtype)
+
+shape_tuple_dtype = [("R", "u1", (2, 2))]
+np.dtype(shape_tuple_dtype)
+
+shape_like_dtype = [("R", "u1", (2, 2)), ("G", np.str_, 1)]
+np.dtype(shape_like_dtype)
+
+object_dtype = [("field1", object)]
+np.dtype(object_dtype)
+
+np.dtype((np.int32, (np.int8, 4)))
+
+# Dtype comparison
+np.dtype(float) == float
+np.dtype(float) != np.float64
+np.dtype(float) < None
+np.dtype(float) <= "float64"
+np.dtype(float) > np.dtype(float)
+np.dtype(float) >= np.dtype(("U", 10))
+
+# Iteration and indexing
+def iterable_func(x):
+    # type: (Iterable) -> Iterable
+    return x
+
+
+iterable_func(array)
+[element for element in array]
+iter(array)
+zip(array, array)
+array[1]
+array[:]
+array[...]
+array[:] = 0
+
+array_2d = np.ones((3, 3))
+array_2d[:2, :2]
+array_2d[..., 0]
+array_2d[:2, :2] = 0
+
+# Other special methods
+len(array)
+str(array)
+array_scalar = np.array(1)
+int(array_scalar)
+float(array_scalar)
+# currently does not work due to https://github.com/python/typeshed/issues/1904
+# complex(array_scalar)
+bytes(array_scalar)
+operator.index(array_scalar)
+bool(array_scalar)
+
+# comparisons
+array < 1
+array <= 1
+array == 1
+array != 1
+array > 1
+array >= 1
+1 < array
+1 <= array
+1 == array
+1 != array
+1 > array
+1 >= array
+
+# binary arithmetic
+array + 1
+1 + array
+array += 1
+
+array - 1
+1 - array
+array -= 1
+
+array * 1
+1 * array
+array *= 1
+
+nonzero_array = np.array([1, 2])
+array / 1
+1 / nonzero_array
+float_array = np.array([1.0, 2.0])
+float_array /= 1
+
+array // 1
+1 // nonzero_array
+array //= 1
+
+array % 1
+1 % nonzero_array
+array %= 1
+
+divmod(array, 1)
+divmod(1, nonzero_array)
+
+array ** 1
+1 ** array
+array **= 1
+
+array << 1
+1 << array
+array <<= 1
+
+array >> 1
+1 >> array
+array >>= 1
+
+array & 1
+1 & array
+array &= 1
+
+array ^ 1
+1 ^ array
+array ^= 1
+
+array | 1
+1 | array
+array |= 1
+
+# unary arithmetic
+-array
++array
+abs(array)
+~array
+
+# Other methods
+np.array([1, 2]).transpose()

LTA_openwebtext_dualt/mini_owt_logdirichlet/.venv_qwen35_uv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/arithmetic.pyi

@@ -0,0 +1,516 @@
+import sys
+from typing import Any
+
+import numpy as np
+import numpy.typing as npt
+from numpy._typing import _32Bit,_64Bit, _128Bit
+
+if sys.version_info >= (3, 11):
+    from typing import assert_type
+else:
+    from typing_extensions import assert_type
+
+# Can't directly import `np.float128` as it is not available on all platforms
+f16: np.floating[_128Bit]
+
+c16 = np.complex128()
+f8 = np.float64()
+i8 = np.int64()
+u8 = np.uint64()
+
+c8 = np.complex64()
+f4 = np.float32()
+i4 = np.int32()
+u4 = np.uint32()
+
+dt = np.datetime64(0, "D")
+td = np.timedelta64(0, "D")
+
+b_ = np.bool_()
+
+b = bool()
+c = complex()
+f = float()
+i = int()
+
+AR_b: npt.NDArray[np.bool_]
+AR_u: npt.NDArray[np.uint32]
+AR_i: npt.NDArray[np.int64]
+AR_f: npt.NDArray[np.float64]
+AR_c: npt.NDArray[np.complex128]
+AR_m: npt.NDArray[np.timedelta64]
+AR_M: npt.NDArray[np.datetime64]
+AR_O: npt.NDArray[np.object_]
+AR_number: npt.NDArray[np.number[Any]]
+
+AR_LIKE_b: list[bool]
+AR_LIKE_u: list[np.uint32]
+AR_LIKE_i: list[int]
+AR_LIKE_f: list[float]
+AR_LIKE_c: list[complex]
+AR_LIKE_m: list[np.timedelta64]
+AR_LIKE_M: list[np.datetime64]
+AR_LIKE_O: list[np.object_]
+
+# Array subtraction
+
+assert_type(AR_number - AR_number, npt.NDArray[np.number[Any]])
+
+assert_type(AR_b - AR_LIKE_u, npt.NDArray[np.unsignedinteger[Any]])
+assert_type(AR_b - AR_LIKE_i, npt.NDArray[np.signedinteger[Any]])
+assert_type(AR_b - AR_LIKE_f, npt.NDArray[np.floating[Any]])
+assert_type(AR_b - AR_LIKE_c, npt.NDArray[np.complexfloating[Any, Any]])
+assert_type(AR_b - AR_LIKE_m, npt.NDArray[np.timedelta64])
+assert_type(AR_b - AR_LIKE_O, Any)
+
+assert_type(AR_LIKE_u - AR_b, npt.NDArray[np.unsignedinteger[Any]])
+assert_type(AR_LIKE_i - AR_b, npt.NDArray[np.signedinteger[Any]])
+assert_type(AR_LIKE_f - AR_b, npt.NDArray[np.floating[Any]])
+assert_type(AR_LIKE_c - AR_b, npt.NDArray[np.complexfloating[Any, Any]])
+assert_type(AR_LIKE_m - AR_b, npt.NDArray[np.timedelta64])
+assert_type(AR_LIKE_M - AR_b, npt.NDArray[np.datetime64])
+assert_type(AR_LIKE_O - AR_b, Any)
+
+assert_type(AR_u - AR_LIKE_b, npt.NDArray[np.unsignedinteger[Any]])
+assert_type(AR_u - AR_LIKE_u, npt.NDArray[np.unsignedinteger[Any]])
+assert_type(AR_u - AR_LIKE_i, npt.NDArray[np.signedinteger[Any]])
+assert_type(AR_u - AR_LIKE_f, npt.NDArray[np.floating[Any]])
+assert_type(AR_u - AR_LIKE_c, npt.NDArray[np.complexfloating[Any, Any]])
+assert_type(AR_u - AR_LIKE_m, npt.NDArray[np.timedelta64])
+assert_type(AR_u - AR_LIKE_O, Any)
+
+assert_type(AR_LIKE_b - AR_u, npt.NDArray[np.unsignedinteger[Any]])
+assert_type(AR_LIKE_u - AR_u, npt.NDArray[np.unsignedinteger[Any]])
+assert_type(AR_LIKE_i - AR_u, npt.NDArray[np.signedinteger[Any]])
+assert_type(AR_LIKE_f - AR_u, npt.NDArray[np.floating[Any]])
+assert_type(AR_LIKE_c - AR_u, npt.NDArray[np.complexfloating[Any, Any]])
+assert_type(AR_LIKE_m - AR_u, npt.NDArray[np.timedelta64])
+assert_type(AR_LIKE_M - AR_u, npt.NDArray[np.datetime64])
+assert_type(AR_LIKE_O - AR_u, Any)
+
+assert_type(AR_i - AR_LIKE_b, npt.NDArray[np.signedinteger[Any]])
+assert_type(AR_i - AR_LIKE_u, npt.NDArray[np.signedinteger[Any]])
+assert_type(AR_i - AR_LIKE_i, npt.NDArray[np.signedinteger[Any]])
+assert_type(AR_i - AR_LIKE_f, npt.NDArray[np.floating[Any]])
+assert_type(AR_i - AR_LIKE_c, npt.NDArray[np.complexfloating[Any, Any]])
+assert_type(AR_i - AR_LIKE_m, npt.NDArray[np.timedelta64])
+assert_type(AR_i - AR_LIKE_O, Any)
+
+assert_type(AR_LIKE_b - AR_i, npt.NDArray[np.signedinteger[Any]])
+assert_type(AR_LIKE_u - AR_i, npt.NDArray[np.signedinteger[Any]])
+assert_type(AR_LIKE_i - AR_i, npt.NDArray[np.signedinteger[Any]])
+assert_type(AR_LIKE_f - AR_i, npt.NDArray[np.floating[Any]])
+assert_type(AR_LIKE_c - AR_i, npt.NDArray[np.complexfloating[Any, Any]])
+assert_type(AR_LIKE_m - AR_i, npt.NDArray[np.timedelta64])
+assert_type(AR_LIKE_M - AR_i, npt.NDArray[np.datetime64])
+assert_type(AR_LIKE_O - AR_i, Any)
+
+assert_type(AR_f - AR_LIKE_b, npt.NDArray[np.floating[Any]])
+assert_type(AR_f - AR_LIKE_u, npt.NDArray[np.floating[Any]])
+assert_type(AR_f - AR_LIKE_i, npt.NDArray[np.floating[Any]])
+assert_type(AR_f - AR_LIKE_f, npt.NDArray[np.floating[Any]])
+assert_type(AR_f - AR_LIKE_c, npt.NDArray[np.complexfloating[Any, Any]])
+assert_type(AR_f - AR_LIKE_O, Any)
+
+assert_type(AR_LIKE_b - AR_f, npt.NDArray[np.floating[Any]])
+assert_type(AR_LIKE_u - AR_f, npt.NDArray[np.floating[Any]])
+assert_type(AR_LIKE_i - AR_f, npt.NDArray[np.floating[Any]])
+assert_type(AR_LIKE_f - AR_f, npt.NDArray[np.floating[Any]])
+assert_type(AR_LIKE_c - AR_f, npt.NDArray[np.complexfloating[Any, Any]])
+assert_type(AR_LIKE_O - AR_f, Any)
+
+assert_type(AR_c - AR_LIKE_b, npt.NDArray[np.complexfloating[Any, Any]])
+assert_type(AR_c - AR_LIKE_u, npt.NDArray[np.complexfloating[Any, Any]])
+assert_type(AR_c - AR_LIKE_i, npt.NDArray[np.complexfloating[Any, Any]])
+assert_type(AR_c - AR_LIKE_f, npt.NDArray[np.complexfloating[Any, Any]])
+assert_type(AR_c - AR_LIKE_c, npt.NDArray[np.complexfloating[Any, Any]])
+assert_type(AR_c - AR_LIKE_O, Any)
+
+assert_type(AR_LIKE_b - AR_c, npt.NDArray[np.complexfloating[Any, Any]])
+assert_type(AR_LIKE_u - AR_c, npt.NDArray[np.complexfloating[Any, Any]])
+assert_type(AR_LIKE_i - AR_c, npt.NDArray[np.complexfloating[Any, Any]])
+assert_type(AR_LIKE_f - AR_c, npt.NDArray[np.complexfloating[Any, Any]])
+assert_type(AR_LIKE_c - AR_c, npt.NDArray[np.complexfloating[Any, Any]])
+assert_type(AR_LIKE_O - AR_c, Any)
+
+assert_type(AR_m - AR_LIKE_b, npt.NDArray[np.timedelta64])
+assert_type(AR_m - AR_LIKE_u, npt.NDArray[np.timedelta64])
+assert_type(AR_m - AR_LIKE_i, npt.NDArray[np.timedelta64])
+assert_type(AR_m - AR_LIKE_m, npt.NDArray[np.timedelta64])
+assert_type(AR_m - AR_LIKE_O, Any)
+
+assert_type(AR_LIKE_b - AR_m, npt.NDArray[np.timedelta64])
+assert_type(AR_LIKE_u - AR_m, npt.NDArray[np.timedelta64])
+assert_type(AR_LIKE_i - AR_m, npt.NDArray[np.timedelta64])
+assert_type(AR_LIKE_m - AR_m, npt.NDArray[np.timedelta64])
+assert_type(AR_LIKE_M - AR_m, npt.NDArray[np.datetime64])
+assert_type(AR_LIKE_O - AR_m, Any)
+
+assert_type(AR_M - AR_LIKE_b, npt.NDArray[np.datetime64])
+assert_type(AR_M - AR_LIKE_u, npt.NDArray[np.datetime64])
+assert_type(AR_M - AR_LIKE_i, npt.NDArray[np.datetime64])
+assert_type(AR_M - AR_LIKE_m, npt.NDArray[np.datetime64])
+assert_type(AR_M - AR_LIKE_M, npt.NDArray[np.timedelta64])
+assert_type(AR_M - AR_LIKE_O, Any)
+
+assert_type(AR_LIKE_M - AR_M, npt.NDArray[np.timedelta64])
+assert_type(AR_LIKE_O - AR_M, Any)
+
+assert_type(AR_O - AR_LIKE_b, Any)
+assert_type(AR_O - AR_LIKE_u, Any)
+assert_type(AR_O - AR_LIKE_i, Any)
+assert_type(AR_O - AR_LIKE_f, Any)
+assert_type(AR_O - AR_LIKE_c, Any)
+assert_type(AR_O - AR_LIKE_m, Any)
+assert_type(AR_O - AR_LIKE_M, Any)
+assert_type(AR_O - AR_LIKE_O, Any)
+
+assert_type(AR_LIKE_b - AR_O, Any)
+assert_type(AR_LIKE_u - AR_O, Any)
+assert_type(AR_LIKE_i - AR_O, Any)
+assert_type(AR_LIKE_f - AR_O, Any)
+assert_type(AR_LIKE_c - AR_O, Any)
+assert_type(AR_LIKE_m - AR_O, Any)
+assert_type(AR_LIKE_M - AR_O, Any)
+assert_type(AR_LIKE_O - AR_O, Any)
+
+# Array floor division
+
+assert_type(AR_b // AR_LIKE_b, npt.NDArray[np.int8])
+assert_type(AR_b // AR_LIKE_u, npt.NDArray[np.unsignedinteger[Any]])
+assert_type(AR_b // AR_LIKE_i, npt.NDArray[np.signedinteger[Any]])
+assert_type(AR_b // AR_LIKE_f, npt.NDArray[np.floating[Any]])
+assert_type(AR_b // AR_LIKE_O, Any)
+
+assert_type(AR_LIKE_b // AR_b, npt.NDArray[np.int8])
+assert_type(AR_LIKE_u // AR_b, npt.NDArray[np.unsignedinteger[Any]])
+assert_type(AR_LIKE_i // AR_b, npt.NDArray[np.signedinteger[Any]])
+assert_type(AR_LIKE_f // AR_b, npt.NDArray[np.floating[Any]])
+assert_type(AR_LIKE_O // AR_b, Any)
+
+assert_type(AR_u // AR_LIKE_b, npt.NDArray[np.unsignedinteger[Any]])
+assert_type(AR_u // AR_LIKE_u, npt.NDArray[np.unsignedinteger[Any]])
+assert_type(AR_u // AR_LIKE_i, npt.NDArray[np.signedinteger[Any]])
+assert_type(AR_u // AR_LIKE_f, npt.NDArray[np.floating[Any]])
+assert_type(AR_u // AR_LIKE_O, Any)
+
+assert_type(AR_LIKE_b // AR_u, npt.NDArray[np.unsignedinteger[Any]])
+assert_type(AR_LIKE_u // AR_u, npt.NDArray[np.unsignedinteger[Any]])
+assert_type(AR_LIKE_i // AR_u, npt.NDArray[np.signedinteger[Any]])
+assert_type(AR_LIKE_f // AR_u, npt.NDArray[np.floating[Any]])
+assert_type(AR_LIKE_m // AR_u, npt.NDArray[np.timedelta64])
+assert_type(AR_LIKE_O // AR_u, Any)
+
+assert_type(AR_i // AR_LIKE_b, npt.NDArray[np.signedinteger[Any]])
+assert_type(AR_i // AR_LIKE_u, npt.NDArray[np.signedinteger[Any]])
+assert_type(AR_i // AR_LIKE_i, npt.NDArray[np.signedinteger[Any]])
+assert_type(AR_i // AR_LIKE_f, npt.NDArray[np.floating[Any]])
+assert_type(AR_i // AR_LIKE_O, Any)
+
+assert_type(AR_LIKE_b // AR_i, npt.NDArray[np.signedinteger[Any]])
+assert_type(AR_LIKE_u // AR_i, npt.NDArray[np.signedinteger[Any]])
+assert_type(AR_LIKE_i // AR_i, npt.NDArray[np.signedinteger[Any]])
+assert_type(AR_LIKE_f // AR_i, npt.NDArray[np.floating[Any]])
+assert_type(AR_LIKE_m // AR_i, npt.NDArray[np.timedelta64])
+assert_type(AR_LIKE_O // AR_i, Any)
+
+assert_type(AR_f // AR_LIKE_b, npt.NDArray[np.floating[Any]])
+assert_type(AR_f // AR_LIKE_u, npt.NDArray[np.floating[Any]])
+assert_type(AR_f // AR_LIKE_i, npt.NDArray[np.floating[Any]])
+assert_type(AR_f // AR_LIKE_f, npt.NDArray[np.floating[Any]])
+assert_type(AR_f // AR_LIKE_O, Any)
+
+assert_type(AR_LIKE_b // AR_f, npt.NDArray[np.floating[Any]])
+assert_type(AR_LIKE_u // AR_f, npt.NDArray[np.floating[Any]])
+assert_type(AR_LIKE_i // AR_f, npt.NDArray[np.floating[Any]])
+assert_type(AR_LIKE_f // AR_f, npt.NDArray[np.floating[Any]])
+assert_type(AR_LIKE_m // AR_f, npt.NDArray[np.timedelta64])
+assert_type(AR_LIKE_O // AR_f, Any)
+
+assert_type(AR_m // AR_LIKE_u, npt.NDArray[np.timedelta64])
+assert_type(AR_m // AR_LIKE_i, npt.NDArray[np.timedelta64])
+assert_type(AR_m // AR_LIKE_f, npt.NDArray[np.timedelta64])
+assert_type(AR_m // AR_LIKE_m, npt.NDArray[np.int64])
+assert_type(AR_m // AR_LIKE_O, Any)
+
+assert_type(AR_LIKE_m // AR_m, npt.NDArray[np.int64])
+assert_type(AR_LIKE_O // AR_m, Any)
+
+assert_type(AR_O // AR_LIKE_b, Any)
+assert_type(AR_O // AR_LIKE_u, Any)
+assert_type(AR_O // AR_LIKE_i, Any)
+assert_type(AR_O // AR_LIKE_f, Any)
+assert_type(AR_O // AR_LIKE_m, Any)
+assert_type(AR_O // AR_LIKE_M, Any)
+assert_type(AR_O // AR_LIKE_O, Any)
+
+assert_type(AR_LIKE_b // AR_O, Any)
+assert_type(AR_LIKE_u // AR_O, Any)
+assert_type(AR_LIKE_i // AR_O, Any)
+assert_type(AR_LIKE_f // AR_O, Any)
+assert_type(AR_LIKE_m // AR_O, Any)
+assert_type(AR_LIKE_M // AR_O, Any)
+assert_type(AR_LIKE_O // AR_O, Any)
+
+# unary ops
+
+assert_type(-f16, np.floating[_128Bit])
+assert_type(-c16, np.complex128)
+assert_type(-c8, np.complex64)
+assert_type(-f8, np.float64)
+assert_type(-f4, np.float32)
+assert_type(-i8, np.int64)
+assert_type(-i4, np.int32)
+assert_type(-u8, np.uint64)
+assert_type(-u4, np.uint32)
+assert_type(-td, np.timedelta64)
+assert_type(-AR_f, npt.NDArray[np.float64])
+
+assert_type(+f16, np.floating[_128Bit])
+assert_type(+c16, np.complex128)
+assert_type(+c8, np.complex64)
+assert_type(+f8, np.float64)
+assert_type(+f4, np.float32)
+assert_type(+i8, np.int64)
+assert_type(+i4, np.int32)
+assert_type(+u8, np.uint64)
+assert_type(+u4, np.uint32)
+assert_type(+td, np.timedelta64)
+assert_type(+AR_f, npt.NDArray[np.float64])
+
+assert_type(abs(f16), np.floating[_128Bit])
+assert_type(abs(c16), np.float64)
+assert_type(abs(c8), np.float32)
+assert_type(abs(f8), np.float64)
+assert_type(abs(f4), np.float32)
+assert_type(abs(i8), np.int64)
+assert_type(abs(i4), np.int32)
+assert_type(abs(u8), np.uint64)
+assert_type(abs(u4), np.uint32)
+assert_type(abs(td), np.timedelta64)
+assert_type(abs(b_), np.bool_)
+
+# Time structures
+
+assert_type(dt + td, np.datetime64)
+assert_type(dt + i, np.datetime64)
+assert_type(dt + i4, np.datetime64)
+assert_type(dt + i8, np.datetime64)
+assert_type(dt - dt, np.timedelta64)
+assert_type(dt - i, np.datetime64)
+assert_type(dt - i4, np.datetime64)
+assert_type(dt - i8, np.datetime64)
+
+assert_type(td + td, np.timedelta64)
+assert_type(td + i, np.timedelta64)
+assert_type(td + i4, np.timedelta64)
+assert_type(td + i8, np.timedelta64)
+assert_type(td - td, np.timedelta64)
+assert_type(td - i, np.timedelta64)
+assert_type(td - i4, np.timedelta64)
+assert_type(td - i8, np.timedelta64)
+assert_type(td / f, np.timedelta64)
+assert_type(td / f4, np.timedelta64)
+assert_type(td / f8, np.timedelta64)
+assert_type(td / td, np.float64)
+assert_type(td // td, np.int64)
+
+# boolean
+
+assert_type(b_ / b, np.float64)
+assert_type(b_ / b_, np.float64)
+assert_type(b_ / i, np.float64)
+assert_type(b_ / i8, np.float64)
+assert_type(b_ / i4, np.float64)
+assert_type(b_ / u8, np.float64)
+assert_type(b_ / u4, np.float64)
+assert_type(b_ / f, np.float64)
+assert_type(b_ / f16, np.floating[_128Bit])
+assert_type(b_ / f8, np.float64)
+assert_type(b_ / f4, np.float32)
+assert_type(b_ / c, np.complex128)
+assert_type(b_ / c16, np.complex128)
+assert_type(b_ / c8, np.complex64)
+
+assert_type(b / b_, np.float64)
+assert_type(b_ / b_, np.float64)
+assert_type(i / b_, np.float64)
+assert_type(i8 / b_, np.float64)
+assert_type(i4 / b_, np.float64)
+assert_type(u8 / b_, np.float64)
+assert_type(u4 / b_, np.float64)
+assert_type(f / b_, np.float64)
+assert_type(f16 / b_, np.floating[_128Bit])
+assert_type(f8 / b_, np.float64)
+assert_type(f4 / b_, np.float32)
+assert_type(c / b_, np.complex128)
+assert_type(c16 / b_, np.complex128)
+assert_type(c8 / b_, np.complex64)
+
+# Complex
+
+assert_type(c16 + f16, np.complexfloating[_64Bit | _128Bit, _64Bit | _128Bit])
+assert_type(c16 + c16, np.complex128)
+assert_type(c16 + f8, np.complex128)
+assert_type(c16 + i8, np.complex128)
+assert_type(c16 + c8, np.complexfloating[_32Bit | _64Bit, _32Bit | _64Bit])
+assert_type(c16 + f4, np.complexfloating[_32Bit | _64Bit, _32Bit | _64Bit])
+assert_type(c16 + i4, np.complexfloating[_32Bit | _64Bit, _32Bit | _64Bit])
+assert_type(c16 + b_, np.complex128)
+assert_type(c16 + b, np.complex128)
+assert_type(c16 + c, np.complex128)
+assert_type(c16 + f, np.complex128)
+assert_type(c16 + AR_f, npt.NDArray[np.complexfloating[Any, Any]])
+
+assert_type(f16 + c16, np.complexfloating[_64Bit | _128Bit, _64Bit | _128Bit])
+assert_type(c16 + c16, np.complex128)
+assert_type(f8 + c16, np.complex128)
+assert_type(i8 + c16, np.complex128)
+assert_type(c8 + c16, np.complexfloating[_32Bit | _64Bit, _32Bit | _64Bit])
+assert_type(f4 + c16, np.complexfloating[_32Bit | _64Bit, _32Bit | _64Bit])
+assert_type(i4 + c16, np.complexfloating[_32Bit | _64Bit, _32Bit | _64Bit])
+assert_type(b_ + c16, np.complex128)
+assert_type(b + c16, np.complex128)
+assert_type(c + c16, np.complex128)
+assert_type(f + c16, np.complex128)
+assert_type(AR_f + c16, npt.NDArray[np.complexfloating[Any, Any]])
+
+assert_type(c8 + f16, np.complexfloating[_32Bit | _128Bit, _32Bit | _128Bit])
+assert_type(c8 + c16, np.complexfloating[_32Bit | _64Bit, _32Bit | _64Bit])
+assert_type(c8 + f8, np.complexfloating[_32Bit | _64Bit, _32Bit | _64Bit])
+assert_type(c8 + i8, np.complexfloating[_32Bit | _64Bit, _32Bit | _64Bit])
+assert_type(c8 + c8, np.complex64)
+assert_type(c8 + f4, np.complex64)
+assert_type(c8 + i4, np.complex64)
+assert_type(c8 + b_, np.complex64)
+assert_type(c8 + b, np.complex64)
+assert_type(c8 + c, np.complexfloating[_32Bit | _64Bit, _32Bit | _64Bit])
+assert_type(c8 + f, np.complexfloating[_32Bit | _64Bit, _32Bit | _64Bit])
+assert_type(c8 + AR_f, npt.NDArray[np.complexfloating[Any, Any]])
+
+assert_type(f16 + c8, np.complexfloating[_32Bit | _128Bit, _32Bit | _128Bit])
+assert_type(c16 + c8, np.complexfloating[_32Bit | _64Bit, _32Bit | _64Bit])
+assert_type(f8 + c8, np.complexfloating[_32Bit | _64Bit, _32Bit | _64Bit])
+assert_type(i8 + c8, np.complexfloating[_32Bit | _64Bit, _32Bit | _64Bit])
+assert_type(c8 + c8, np.complex64)
+assert_type(f4 + c8, np.complex64)
+assert_type(i4 + c8, np.complex64)
+assert_type(b_ + c8, np.complex64)
+assert_type(b + c8, np.complex64)
+assert_type(c + c8, np.complexfloating[_32Bit | _64Bit, _32Bit | _64Bit])
+assert_type(f + c8, np.complexfloating[_32Bit | _64Bit, _32Bit | _64Bit])
+assert_type(AR_f + c8, npt.NDArray[np.complexfloating[Any, Any]])
+
+# Float
+
+assert_type(f8 + f16, np.floating[_64Bit | _128Bit])
+assert_type(f8 + f8, np.float64)
+assert_type(f8 + i8, np.float64)
+assert_type(f8 + f4, np.floating[_32Bit | _64Bit])
+assert_type(f8 + i4, np.floating[_32Bit | _64Bit])
+assert_type(f8 + b_, np.float64)
+assert_type(f8 + b, np.float64)
+assert_type(f8 + c, np.complex128)
+assert_type(f8 + f, np.float64)
+assert_type(f8 + AR_f, npt.NDArray[np.floating[Any]])
+
+assert_type(f16 + f8, np.floating[_64Bit | _128Bit])
+assert_type(f8 + f8, np.float64)
+assert_type(i8 + f8, np.float64)
+assert_type(f4 + f8, np.floating[_32Bit | _64Bit])
+assert_type(i4 + f8, np.floating[_32Bit | _64Bit])
+assert_type(b_ + f8, np.float64)
+assert_type(b + f8, np.float64)
+assert_type(c + f8, np.complex128)
+assert_type(f + f8, np.float64)
+assert_type(AR_f + f8, npt.NDArray[np.floating[Any]])
+
+assert_type(f4 + f16, np.floating[_32Bit | _128Bit])
+assert_type(f4 + f8, np.floating[_32Bit | _64Bit])
+assert_type(f4 + i8, np.floating[_32Bit | _64Bit])
+assert_type(f4 + f4, np.float32)
+assert_type(f4 + i4, np.float32)
+assert_type(f4 + b_, np.float32)
+assert_type(f4 + b, np.float32)
+assert_type(f4 + c, np.complexfloating[_32Bit | _64Bit, _32Bit | _64Bit])
+assert_type(f4 + f, np.floating[_32Bit | _64Bit])
+assert_type(f4 + AR_f, npt.NDArray[np.floating[Any]])
+
+assert_type(f16 + f4, np.floating[_32Bit | _128Bit])
+assert_type(f8 + f4, np.floating[_32Bit | _64Bit])
+assert_type(i8 + f4, np.floating[_32Bit | _64Bit])
+assert_type(f4 + f4, np.float32)
+assert_type(i4 + f4, np.float32)
+assert_type(b_ + f4, np.float32)
+assert_type(b + f4, np.float32)
+assert_type(c + f4, np.complexfloating[_32Bit | _64Bit, _32Bit | _64Bit])
+assert_type(f + f4, np.floating[_32Bit | _64Bit])
+assert_type(AR_f + f4, npt.NDArray[np.floating[Any]])
+
+# Int
+
+assert_type(i8 + i8, np.int64)
+assert_type(i8 + u8, Any)
+assert_type(i8 + i4, np.signedinteger[_32Bit | _64Bit])
+assert_type(i8 + u4, Any)
+assert_type(i8 + b_, np.int64)
+assert_type(i8 + b, np.int64)
+assert_type(i8 + c, np.complex128)
+assert_type(i8 + f, np.float64)
+assert_type(i8 + AR_f, npt.NDArray[np.floating[Any]])
+
+assert_type(u8 + u8, np.uint64)
+assert_type(u8 + i4, Any)
+assert_type(u8 + u4, np.unsignedinteger[_32Bit | _64Bit])
+assert_type(u8 + b_, np.uint64)
+assert_type(u8 + b, np.uint64)
+assert_type(u8 + c, np.complex128)
+assert_type(u8 + f, np.float64)
+assert_type(u8 + AR_f, npt.NDArray[np.floating[Any]])
+
+assert_type(i8 + i8, np.int64)
+assert_type(u8 + i8, Any)
+assert_type(i4 + i8, np.signedinteger[_32Bit | _64Bit])
+assert_type(u4 + i8, Any)
+assert_type(b_ + i8, np.int64)
+assert_type(b + i8, np.int64)
+assert_type(c + i8, np.complex128)
+assert_type(f + i8, np.float64)
+assert_type(AR_f + i8, npt.NDArray[np.floating[Any]])
+
+assert_type(u8 + u8, np.uint64)
+assert_type(i4 + u8, Any)
+assert_type(u4 + u8, np.unsignedinteger[_32Bit | _64Bit])
+assert_type(b_ + u8, np.uint64)
+assert_type(b + u8, np.uint64)
+assert_type(c + u8, np.complex128)
+assert_type(f + u8, np.float64)
+assert_type(AR_f + u8, npt.NDArray[np.floating[Any]])
+
+assert_type(i4 + i8, np.signedinteger[_32Bit | _64Bit])
+assert_type(i4 + i4, np.int32)
+assert_type(i4 + b_, np.int32)
+assert_type(i4 + b, np.int32)
+assert_type(i4 + AR_f, npt.NDArray[np.floating[Any]])
+
+assert_type(u4 + i8, Any)
+assert_type(u4 + i4, Any)
+assert_type(u4 + u8, np.unsignedinteger[_32Bit | _64Bit])
+assert_type(u4 + u4, np.uint32)
+assert_type(u4 + b_, np.uint32)
+assert_type(u4 + b, np.uint32)
+assert_type(u4 + AR_f, npt.NDArray[np.floating[Any]])
+
+assert_type(i8 + i4, np.signedinteger[_32Bit | _64Bit])
+assert_type(i4 + i4, np.int32)
+assert_type(b_ + i4, np.int32)
+assert_type(b + i4, np.int32)
+assert_type(AR_f + i4, npt.NDArray[np.floating[Any]])
+
+assert_type(i8 + u4, Any)
+assert_type(i4 + u4, Any)
+assert_type(u8 + u4, np.unsignedinteger[_32Bit | _64Bit])
+assert_type(u4 + u4, np.uint32)
+assert_type(b_ + u4, np.uint32)
+assert_type(b + u4, np.uint32)
+assert_type(AR_f + u4, npt.NDArray[np.floating[Any]])

LTA_openwebtext_dualt/mini_owt_logdirichlet/.venv_qwen35_uv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/array_constructors.pyi

@@ -0,0 +1,221 @@
+import sys
+from typing import Any, TypeVar
+from pathlib import Path
+from collections import deque
+
+import numpy as np
+import numpy.typing as npt
+
+if sys.version_info >= (3, 11):
+    from typing import assert_type
+else:
+    from typing_extensions import assert_type
+
+_SCT = TypeVar("_SCT", bound=np.generic, covariant=True)
+
+class SubClass(np.ndarray[Any, np.dtype[_SCT]]): ...
+
+i8: np.int64
+
+A: npt.NDArray[np.float64]
+B: SubClass[np.float64]
+C: list[int]
+
+def func(i: int, j: int, **kwargs: Any) -> SubClass[np.float64]: ...
+
+assert_type(np.empty_like(A), npt.NDArray[np.float64])
+assert_type(np.empty_like(B), SubClass[np.float64])
+assert_type(np.empty_like([1, 1.0]), npt.NDArray[Any])
+assert_type(np.empty_like(A, dtype=np.int64), npt.NDArray[np.int64])
+assert_type(np.empty_like(A, dtype='c16'), npt.NDArray[Any])
+
+assert_type(np.array(A), npt.NDArray[np.float64])
+assert_type(np.array(B), npt.NDArray[np.float64])
+assert_type(np.array(B, subok=True), SubClass[np.float64])
+assert_type(np.array([1, 1.0]), npt.NDArray[Any])
+assert_type(np.array(deque([1, 2, 3])), npt.NDArray[Any])
+assert_type(np.array(A, dtype=np.int64), npt.NDArray[np.int64])
+assert_type(np.array(A, dtype='c16'), npt.NDArray[Any])
+assert_type(np.array(A, like=A), npt.NDArray[np.float64])
+
+assert_type(np.zeros([1, 5, 6]), npt.NDArray[np.float64])
+assert_type(np.zeros([1, 5, 6], dtype=np.int64), npt.NDArray[np.int64])
+assert_type(np.zeros([1, 5, 6], dtype='c16'), npt.NDArray[Any])
+
+assert_type(np.empty([1, 5, 6]), npt.NDArray[np.float64])
+assert_type(np.empty([1, 5, 6], dtype=np.int64), npt.NDArray[np.int64])
+assert_type(np.empty([1, 5, 6], dtype='c16'), npt.NDArray[Any])
+
+assert_type(np.concatenate(A), npt.NDArray[np.float64])
+assert_type(np.concatenate([A, A]), Any)
+assert_type(np.concatenate([[1], A]), npt.NDArray[Any])
+assert_type(np.concatenate([[1], [1]]), npt.NDArray[Any])
+assert_type(np.concatenate((A, A)), npt.NDArray[np.float64])
+assert_type(np.concatenate(([1], [1])), npt.NDArray[Any])
+assert_type(np.concatenate([1, 1.0]), npt.NDArray[Any])
+assert_type(np.concatenate(A, dtype=np.int64), npt.NDArray[np.int64])
+assert_type(np.concatenate(A, dtype='c16'), npt.NDArray[Any])
+assert_type(np.concatenate([1, 1.0], out=A), npt.NDArray[np.float64])
+
+assert_type(np.asarray(A), npt.NDArray[np.float64])
+assert_type(np.asarray(B), npt.NDArray[np.float64])
+assert_type(np.asarray([1, 1.0]), npt.NDArray[Any])
+assert_type(np.asarray(A, dtype=np.int64), npt.NDArray[np.int64])
+assert_type(np.asarray(A, dtype='c16'), npt.NDArray[Any])
+
+assert_type(np.asanyarray(A), npt.NDArray[np.float64])
+assert_type(np.asanyarray(B), SubClass[np.float64])
+assert_type(np.asanyarray([1, 1.0]), npt.NDArray[Any])
+assert_type(np.asanyarray(A, dtype=np.int64), npt.NDArray[np.int64])
+assert_type(np.asanyarray(A, dtype='c16'), npt.NDArray[Any])
+
+assert_type(np.ascontiguousarray(A), npt.NDArray[np.float64])
+assert_type(np.ascontiguousarray(B), npt.NDArray[np.float64])
+assert_type(np.ascontiguousarray([1, 1.0]), npt.NDArray[Any])
+assert_type(np.ascontiguousarray(A, dtype=np.int64), npt.NDArray[np.int64])
+assert_type(np.ascontiguousarray(A, dtype='c16'), npt.NDArray[Any])
+
+assert_type(np.asfortranarray(A), npt.NDArray[np.float64])
+assert_type(np.asfortranarray(B), npt.NDArray[np.float64])
+assert_type(np.asfortranarray([1, 1.0]), npt.NDArray[Any])
+assert_type(np.asfortranarray(A, dtype=np.int64), npt.NDArray[np.int64])
+assert_type(np.asfortranarray(A, dtype='c16'), npt.NDArray[Any])
+
+assert_type(np.fromstring("1 1 1", sep=" "), npt.NDArray[np.float64])
+assert_type(np.fromstring(b"1 1 1", sep=" "), npt.NDArray[np.float64])
+assert_type(np.fromstring("1 1 1", dtype=np.int64, sep=" "), npt.NDArray[np.int64])
+assert_type(np.fromstring(b"1 1 1", dtype=np.int64, sep=" "), npt.NDArray[np.int64])
+assert_type(np.fromstring("1 1 1", dtype="c16", sep=" "), npt.NDArray[Any])
+assert_type(np.fromstring(b"1 1 1", dtype="c16", sep=" "), npt.NDArray[Any])
+
+assert_type(np.fromfile("test.txt", sep=" "), npt.NDArray[np.float64])
+assert_type(np.fromfile("test.txt", dtype=np.int64, sep=" "), npt.NDArray[np.int64])
+assert_type(np.fromfile("test.txt", dtype="c16", sep=" "), npt.NDArray[Any])
+with open("test.txt") as f:
+    assert_type(np.fromfile(f, sep=" "), npt.NDArray[np.float64])
+    assert_type(np.fromfile(b"test.txt", sep=" "), npt.NDArray[np.float64])
+    assert_type(np.fromfile(Path("test.txt"), sep=" "), npt.NDArray[np.float64])
+
+assert_type(np.fromiter("12345", np.float64), npt.NDArray[np.float64])
+assert_type(np.fromiter("12345", float), npt.NDArray[Any])
+
+assert_type(np.frombuffer(A), npt.NDArray[np.float64])
+assert_type(np.frombuffer(A, dtype=np.int64), npt.NDArray[np.int64])
+assert_type(np.frombuffer(A, dtype="c16"), npt.NDArray[Any])
+
+assert_type(np.arange(False, True), npt.NDArray[np.signedinteger[Any]])
+assert_type(np.arange(10), npt.NDArray[np.signedinteger[Any]])
+assert_type(np.arange(0, 10, step=2), npt.NDArray[np.signedinteger[Any]])
+assert_type(np.arange(10.0), npt.NDArray[np.floating[Any]])
+assert_type(np.arange(start=0, stop=10.0), npt.NDArray[np.floating[Any]])
+assert_type(np.arange(np.timedelta64(0)), npt.NDArray[np.timedelta64])
+assert_type(np.arange(0, np.timedelta64(10)), npt.NDArray[np.timedelta64])
+assert_type(np.arange(np.datetime64("0"), np.datetime64("10")), npt.NDArray[np.datetime64])
+assert_type(np.arange(10, dtype=np.float64), npt.NDArray[np.float64])
+assert_type(np.arange(0, 10, step=2, dtype=np.int16), npt.NDArray[np.int16])
+assert_type(np.arange(10, dtype=int), npt.NDArray[Any])
+assert_type(np.arange(0, 10, dtype="f8"), npt.NDArray[Any])
+
+assert_type(np.require(A), npt.NDArray[np.float64])
+assert_type(np.require(B), SubClass[np.float64])
+assert_type(np.require(B, requirements=None), SubClass[np.float64])
+assert_type(np.require(B, dtype=int), np.ndarray[Any, Any])
+assert_type(np.require(B, requirements="E"), np.ndarray[Any, Any])
+assert_type(np.require(B, requirements=["ENSUREARRAY"]), np.ndarray[Any, Any])
+assert_type(np.require(B, requirements={"F", "E"}), np.ndarray[Any, Any])
+assert_type(np.require(B, requirements=["C", "OWNDATA"]), SubClass[np.float64])
+assert_type(np.require(B, requirements="W"), SubClass[np.float64])
+assert_type(np.require(B, requirements="A"), SubClass[np.float64])
+assert_type(np.require(C), np.ndarray[Any, Any])
+
+assert_type(np.linspace(0, 10), npt.NDArray[np.floating[Any]])
+assert_type(np.linspace(0, 10j), npt.NDArray[np.complexfloating[Any, Any]])
+assert_type(np.linspace(0, 10, dtype=np.int64), npt.NDArray[np.int64])
+assert_type(np.linspace(0, 10, dtype=int), npt.NDArray[Any])
+assert_type(np.linspace(0, 10, retstep=True), tuple[npt.NDArray[np.floating[Any]], np.floating[Any]])
+assert_type(np.linspace(0j, 10, retstep=True), tuple[npt.NDArray[np.complexfloating[Any, Any]], np.complexfloating[Any, Any]])
+assert_type(np.linspace(0, 10, retstep=True, dtype=np.int64), tuple[npt.NDArray[np.int64], np.int64])
+assert_type(np.linspace(0j, 10, retstep=True, dtype=int), tuple[npt.NDArray[Any], Any])
+
+assert_type(np.logspace(0, 10), npt.NDArray[np.floating[Any]])
+assert_type(np.logspace(0, 10j), npt.NDArray[np.complexfloating[Any, Any]])
+assert_type(np.logspace(0, 10, dtype=np.int64), npt.NDArray[np.int64])
+assert_type(np.logspace(0, 10, dtype=int), npt.NDArray[Any])
+
+assert_type(np.geomspace(0, 10), npt.NDArray[np.floating[Any]])
+assert_type(np.geomspace(0, 10j), npt.NDArray[np.complexfloating[Any, Any]])
+assert_type(np.geomspace(0, 10, dtype=np.int64), npt.NDArray[np.int64])
+assert_type(np.geomspace(0, 10, dtype=int), npt.NDArray[Any])
+
+assert_type(np.zeros_like(A), npt.NDArray[np.float64])
+assert_type(np.zeros_like(C), npt.NDArray[Any])
+assert_type(np.zeros_like(A, dtype=float), npt.NDArray[Any])
+assert_type(np.zeros_like(B), SubClass[np.float64])
+assert_type(np.zeros_like(B, dtype=np.int64), npt.NDArray[np.int64])
+
+assert_type(np.ones_like(A), npt.NDArray[np.float64])
+assert_type(np.ones_like(C), npt.NDArray[Any])
+assert_type(np.ones_like(A, dtype=float), npt.NDArray[Any])
+assert_type(np.ones_like(B), SubClass[np.float64])
+assert_type(np.ones_like(B, dtype=np.int64), npt.NDArray[np.int64])
+
+assert_type(np.full_like(A, i8), npt.NDArray[np.float64])
+assert_type(np.full_like(C, i8), npt.NDArray[Any])
+assert_type(np.full_like(A, i8, dtype=int), npt.NDArray[Any])
+assert_type(np.full_like(B, i8), SubClass[np.float64])
+assert_type(np.full_like(B, i8, dtype=np.int64), npt.NDArray[np.int64])
+
+assert_type(np.ones(1), npt.NDArray[np.float64])
+assert_type(np.ones([1, 1, 1]), npt.NDArray[np.float64])
+assert_type(np.ones(5, dtype=np.int64), npt.NDArray[np.int64])
+assert_type(np.ones(5, dtype=int), npt.NDArray[Any])
+
+assert_type(np.full(1, i8), npt.NDArray[Any])
+assert_type(np.full([1, 1, 1], i8), npt.NDArray[Any])
+assert_type(np.full(1, i8, dtype=np.float64), npt.NDArray[np.float64])
+assert_type(np.full(1, i8, dtype=float), npt.NDArray[Any])
+
+assert_type(np.indices([1, 2, 3]), npt.NDArray[np.int_])
+assert_type(np.indices([1, 2, 3], sparse=True), tuple[npt.NDArray[np.int_], ...])
+
+assert_type(np.fromfunction(func, (3, 5)), SubClass[np.float64])
+
+assert_type(np.identity(10), npt.NDArray[np.float64])
+assert_type(np.identity(10, dtype=np.int64), npt.NDArray[np.int64])
+assert_type(np.identity(10, dtype=int), npt.NDArray[Any])
+
+assert_type(np.atleast_1d(A), npt.NDArray[np.float64])
+assert_type(np.atleast_1d(C), npt.NDArray[Any])
+assert_type(np.atleast_1d(A, A), list[npt.NDArray[Any]])
+assert_type(np.atleast_1d(A, C), list[npt.NDArray[Any]])
+assert_type(np.atleast_1d(C, C), list[npt.NDArray[Any]])
+
+assert_type(np.atleast_2d(A), npt.NDArray[np.float64])
+
+assert_type(np.atleast_3d(A), npt.NDArray[np.float64])
+
+assert_type(np.vstack([A, A]), np.ndarray[Any, Any])
+assert_type(np.vstack([A, A], dtype=np.float64), npt.NDArray[np.float64])
+assert_type(np.vstack([A, C]), npt.NDArray[Any])
+assert_type(np.vstack([C, C]), npt.NDArray[Any])
+
+assert_type(np.hstack([A, A]), np.ndarray[Any, Any])
+assert_type(np.hstack([A, A], dtype=np.float64), npt.NDArray[np.float64])
+
+assert_type(np.stack([A, A]), Any)
+assert_type(np.stack([A, A], dtype=np.float64), npt.NDArray[np.float64])
+assert_type(np.stack([A, C]), npt.NDArray[Any])
+assert_type(np.stack([C, C]), npt.NDArray[Any])
+assert_type(np.stack([A, A], axis=0), Any)
+assert_type(np.stack([A, A], out=B), SubClass[np.float64])
+
+assert_type(np.block([[A, A], [A, A]]), npt.NDArray[Any])
+assert_type(np.block(C), npt.NDArray[Any])
+
+if sys.version_info >= (3, 12):
+    from collections.abc import Buffer
+
+    def create_array(obj: npt.ArrayLike) -> npt.NDArray[Any]: ...
+
+    buffer: Buffer
+    assert_type(create_array(buffer), npt.NDArray[Any])

LTA_openwebtext_dualt/mini_owt_logdirichlet/.venv_qwen35_uv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/datasource.pyi

@@ -0,0 +1,29 @@
+import sys
+from pathlib import Path
+from typing import IO, Any
+
+import numpy as np
+
+if sys.version_info >= (3, 11):
+    from typing import assert_type
+else:
+    from typing_extensions import assert_type
+
+path1: Path
+path2: str
+
+d1 = np.DataSource(path1)
+d2 = np.DataSource(path2)
+d3 = np.DataSource(None)
+
+assert_type(d1.abspath("..."), str)
+assert_type(d2.abspath("..."), str)
+assert_type(d3.abspath("..."), str)
+
+assert_type(d1.exists("..."), bool)
+assert_type(d2.exists("..."), bool)
+assert_type(d3.exists("..."), bool)
+
+assert_type(d1.open("...", "r"), IO[Any])
+assert_type(d2.open("...", encoding="utf8"), IO[Any])
+assert_type(d3.open("...", newline="/n"), IO[Any])

LTA_openwebtext_dualt/mini_owt_logdirichlet/.venv_qwen35_uv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/fromnumeric.pyi

@@ -0,0 +1,305 @@
+"""Tests for :mod:`core.fromnumeric`."""
+
+import sys
+from typing import Any
+
+import numpy as np
+import numpy.typing as npt
+
+if sys.version_info >= (3, 11):
+    from typing import assert_type
+else:
+    from typing_extensions import assert_type
+
+class NDArraySubclass(npt.NDArray[np.complex128]):
+    ...
+
+AR_b: npt.NDArray[np.bool_]
+AR_f4: npt.NDArray[np.float32]
+AR_c16: npt.NDArray[np.complex128]
+AR_u8: npt.NDArray[np.uint64]
+AR_i8: npt.NDArray[np.int64]
+AR_O: npt.NDArray[np.object_]
+AR_subclass: NDArraySubclass
+
+b: np.bool_
+f4: np.float32
+i8: np.int64
+f: float
+
+assert_type(np.take(b, 0), np.bool_)
+assert_type(np.take(f4, 0), np.float32)
+assert_type(np.take(f, 0), Any)
+assert_type(np.take(AR_b, 0), np.bool_)
+assert_type(np.take(AR_f4, 0), np.float32)
+assert_type(np.take(AR_b, [0]), npt.NDArray[np.bool_])
+assert_type(np.take(AR_f4, [0]), npt.NDArray[np.float32])
+assert_type(np.take([1], [0]), npt.NDArray[Any])
+assert_type(np.take(AR_f4, [0], out=AR_subclass), NDArraySubclass)
+
+assert_type(np.reshape(b, 1), npt.NDArray[np.bool_])
+assert_type(np.reshape(f4, 1), npt.NDArray[np.float32])
+assert_type(np.reshape(f, 1), npt.NDArray[Any])
+assert_type(np.reshape(AR_b, 1), npt.NDArray[np.bool_])
+assert_type(np.reshape(AR_f4, 1), npt.NDArray[np.float32])
+
+assert_type(np.choose(1, [True, True]), Any)
+assert_type(np.choose([1], [True, True]), npt.NDArray[Any])
+assert_type(np.choose([1], AR_b), npt.NDArray[np.bool_])
+assert_type(np.choose([1], AR_b, out=AR_f4), npt.NDArray[np.float32])
+
+assert_type(np.repeat(b, 1), npt.NDArray[np.bool_])
+assert_type(np.repeat(f4, 1), npt.NDArray[np.float32])
+assert_type(np.repeat(f, 1), npt.NDArray[Any])
+assert_type(np.repeat(AR_b, 1), npt.NDArray[np.bool_])
+assert_type(np.repeat(AR_f4, 1), npt.NDArray[np.float32])
+
+# TODO: array_bdd tests for np.put()
+
+assert_type(np.swapaxes([[0, 1]], 0, 0), npt.NDArray[Any])
+assert_type(np.swapaxes(AR_b, 0, 0), npt.NDArray[np.bool_])
+assert_type(np.swapaxes(AR_f4, 0, 0), npt.NDArray[np.float32])
+
+assert_type(np.transpose(b), npt.NDArray[np.bool_])
+assert_type(np.transpose(f4), npt.NDArray[np.float32])
+assert_type(np.transpose(f), npt.NDArray[Any])
+assert_type(np.transpose(AR_b), npt.NDArray[np.bool_])
+assert_type(np.transpose(AR_f4), npt.NDArray[np.float32])
+
+assert_type(np.partition(b, 0, axis=None), npt.NDArray[np.bool_])
+assert_type(np.partition(f4, 0, axis=None), npt.NDArray[np.float32])
+assert_type(np.partition(f, 0, axis=None), npt.NDArray[Any])
+assert_type(np.partition(AR_b, 0), npt.NDArray[np.bool_])
+assert_type(np.partition(AR_f4, 0), npt.NDArray[np.float32])
+
+assert_type(np.argpartition(b, 0), npt.NDArray[np.intp])
+assert_type(np.argpartition(f4, 0), npt.NDArray[np.intp])
+assert_type(np.argpartition(f, 0), npt.NDArray[np.intp])
+assert_type(np.argpartition(AR_b, 0), npt.NDArray[np.intp])
+assert_type(np.argpartition(AR_f4, 0), npt.NDArray[np.intp])
+
+assert_type(np.sort([2, 1], 0), npt.NDArray[Any])
+assert_type(np.sort(AR_b, 0), npt.NDArray[np.bool_])
+assert_type(np.sort(AR_f4, 0), npt.NDArray[np.float32])
+
+assert_type(np.argsort(AR_b, 0), npt.NDArray[np.intp])
+assert_type(np.argsort(AR_f4, 0), npt.NDArray[np.intp])
+
+assert_type(np.argmax(AR_b), np.intp)
+assert_type(np.argmax(AR_f4), np.intp)
+assert_type(np.argmax(AR_b, axis=0), Any)
+assert_type(np.argmax(AR_f4, axis=0), Any)
+assert_type(np.argmax(AR_f4, out=AR_subclass), NDArraySubclass)
+
+assert_type(np.argmin(AR_b), np.intp)
+assert_type(np.argmin(AR_f4), np.intp)
+assert_type(np.argmin(AR_b, axis=0), Any)
+assert_type(np.argmin(AR_f4, axis=0), Any)
+assert_type(np.argmin(AR_f4, out=AR_subclass), NDArraySubclass)
+
+assert_type(np.searchsorted(AR_b[0], 0), np.intp)
+assert_type(np.searchsorted(AR_f4[0], 0), np.intp)
+assert_type(np.searchsorted(AR_b[0], [0]), npt.NDArray[np.intp])
+assert_type(np.searchsorted(AR_f4[0], [0]), npt.NDArray[np.intp])
+
+assert_type(np.resize(b, (5, 5)), npt.NDArray[np.bool_])
+assert_type(np.resize(f4, (5, 5)), npt.NDArray[np.float32])
+assert_type(np.resize(f, (5, 5)), npt.NDArray[Any])
+assert_type(np.resize(AR_b, (5, 5)), npt.NDArray[np.bool_])
+assert_type(np.resize(AR_f4, (5, 5)), npt.NDArray[np.float32])
+
+assert_type(np.squeeze(b), np.bool_)
+assert_type(np.squeeze(f4), np.float32)
+assert_type(np.squeeze(f), npt.NDArray[Any])
+assert_type(np.squeeze(AR_b), npt.NDArray[np.bool_])
+assert_type(np.squeeze(AR_f4), npt.NDArray[np.float32])
+
+assert_type(np.diagonal(AR_b), npt.NDArray[np.bool_])
+assert_type(np.diagonal(AR_f4), npt.NDArray[np.float32])
+
+assert_type(np.trace(AR_b), Any)
+assert_type(np.trace(AR_f4), Any)
+assert_type(np.trace(AR_f4, out=AR_subclass), NDArraySubclass)
+
+assert_type(np.ravel(b), npt.NDArray[np.bool_])
+assert_type(np.ravel(f4), npt.NDArray[np.float32])
+assert_type(np.ravel(f), npt.NDArray[Any])
+assert_type(np.ravel(AR_b), npt.NDArray[np.bool_])
+assert_type(np.ravel(AR_f4), npt.NDArray[np.float32])
+
+assert_type(np.nonzero(b), tuple[npt.NDArray[np.intp], ...])
+assert_type(np.nonzero(f4), tuple[npt.NDArray[np.intp], ...])
+assert_type(np.nonzero(f), tuple[npt.NDArray[np.intp], ...])
+assert_type(np.nonzero(AR_b), tuple[npt.NDArray[np.intp], ...])
+assert_type(np.nonzero(AR_f4), tuple[npt.NDArray[np.intp], ...])
+
+assert_type(np.shape(b), tuple[int, ...])
+assert_type(np.shape(f4), tuple[int, ...])
+assert_type(np.shape(f), tuple[int, ...])
+assert_type(np.shape(AR_b), tuple[int, ...])
+assert_type(np.shape(AR_f4), tuple[int, ...])
+
+assert_type(np.compress([True], b), npt.NDArray[np.bool_])
+assert_type(np.compress([True], f4), npt.NDArray[np.float32])
+assert_type(np.compress([True], f), npt.NDArray[Any])
+assert_type(np.compress([True], AR_b), npt.NDArray[np.bool_])
+assert_type(np.compress([True], AR_f4), npt.NDArray[np.float32])
+
+assert_type(np.clip(b, 0, 1.0), np.bool_)
+assert_type(np.clip(f4, -1, 1), np.float32)
+assert_type(np.clip(f, 0, 1), Any)
+assert_type(np.clip(AR_b, 0, 1), npt.NDArray[np.bool_])
+assert_type(np.clip(AR_f4, 0, 1), npt.NDArray[np.float32])
+assert_type(np.clip([0], 0, 1), npt.NDArray[Any])
+assert_type(np.clip(AR_b, 0, 1, out=AR_subclass), NDArraySubclass)
+
+assert_type(np.sum(b), np.bool_)
+assert_type(np.sum(f4), np.float32)
+assert_type(np.sum(f), Any)
+assert_type(np.sum(AR_b), np.bool_)
+assert_type(np.sum(AR_f4), np.float32)
+assert_type(np.sum(AR_b, axis=0), Any)
+assert_type(np.sum(AR_f4, axis=0), Any)
+assert_type(np.sum(AR_f4, out=AR_subclass), NDArraySubclass)
+
+assert_type(np.all(b), np.bool_)
+assert_type(np.all(f4), np.bool_)
+assert_type(np.all(f), np.bool_)
+assert_type(np.all(AR_b), np.bool_)
+assert_type(np.all(AR_f4), np.bool_)
+assert_type(np.all(AR_b, axis=0), Any)
+assert_type(np.all(AR_f4, axis=0), Any)
+assert_type(np.all(AR_b, keepdims=True), Any)
+assert_type(np.all(AR_f4, keepdims=True), Any)
+assert_type(np.all(AR_f4, out=AR_subclass), NDArraySubclass)
+
+assert_type(np.any(b), np.bool_)
+assert_type(np.any(f4), np.bool_)
+assert_type(np.any(f), np.bool_)
+assert_type(np.any(AR_b), np.bool_)
+assert_type(np.any(AR_f4), np.bool_)
+assert_type(np.any(AR_b, axis=0), Any)
+assert_type(np.any(AR_f4, axis=0), Any)
+assert_type(np.any(AR_b, keepdims=True), Any)
+assert_type(np.any(AR_f4, keepdims=True), Any)
+assert_type(np.any(AR_f4, out=AR_subclass), NDArraySubclass)
+
+assert_type(np.cumsum(b), npt.NDArray[np.bool_])
+assert_type(np.cumsum(f4), npt.NDArray[np.float32])
+assert_type(np.cumsum(f), npt.NDArray[Any])
+assert_type(np.cumsum(AR_b), npt.NDArray[np.bool_])
+assert_type(np.cumsum(AR_f4), npt.NDArray[np.float32])
+assert_type(np.cumsum(f, dtype=float), npt.NDArray[Any])
+assert_type(np.cumsum(f, dtype=np.float64), npt.NDArray[np.float64])
+assert_type(np.cumsum(AR_f4, out=AR_subclass), NDArraySubclass)
+
+assert_type(np.ptp(b), np.bool_)
+assert_type(np.ptp(f4), np.float32)
+assert_type(np.ptp(f), Any)
+assert_type(np.ptp(AR_b), np.bool_)
+assert_type(np.ptp(AR_f4), np.float32)
+assert_type(np.ptp(AR_b, axis=0), Any)
+assert_type(np.ptp(AR_f4, axis=0), Any)
+assert_type(np.ptp(AR_b, keepdims=True), Any)
+assert_type(np.ptp(AR_f4, keepdims=True), Any)
+assert_type(np.ptp(AR_f4, out=AR_subclass), NDArraySubclass)
+
+assert_type(np.amax(b), np.bool_)
+assert_type(np.amax(f4), np.float32)
+assert_type(np.amax(f), Any)
+assert_type(np.amax(AR_b), np.bool_)
+assert_type(np.amax(AR_f4), np.float32)
+assert_type(np.amax(AR_b, axis=0), Any)
+assert_type(np.amax(AR_f4, axis=0), Any)
+assert_type(np.amax(AR_b, keepdims=True), Any)
+assert_type(np.amax(AR_f4, keepdims=True), Any)
+assert_type(np.amax(AR_f4, out=AR_subclass), NDArraySubclass)
+
+assert_type(np.amin(b), np.bool_)
+assert_type(np.amin(f4), np.float32)
+assert_type(np.amin(f), Any)
+assert_type(np.amin(AR_b), np.bool_)
+assert_type(np.amin(AR_f4), np.float32)
+assert_type(np.amin(AR_b, axis=0), Any)
+assert_type(np.amin(AR_f4, axis=0), Any)
+assert_type(np.amin(AR_b, keepdims=True), Any)
+assert_type(np.amin(AR_f4, keepdims=True), Any)
+assert_type(np.amin(AR_f4, out=AR_subclass), NDArraySubclass)
+
+assert_type(np.prod(AR_b), np.int_)
+assert_type(np.prod(AR_u8), np.uint64)
+assert_type(np.prod(AR_i8), np.int64)
+assert_type(np.prod(AR_f4), np.floating[Any])
+assert_type(np.prod(AR_c16), np.complexfloating[Any, Any])
+assert_type(np.prod(AR_O), Any)
+assert_type(np.prod(AR_f4, axis=0), Any)
+assert_type(np.prod(AR_f4, keepdims=True), Any)
+assert_type(np.prod(AR_f4, dtype=np.float64), np.float64)
+assert_type(np.prod(AR_f4, dtype=float), Any)
+assert_type(np.prod(AR_f4, out=AR_subclass), NDArraySubclass)
+
+assert_type(np.cumprod(AR_b), npt.NDArray[np.int_])
+assert_type(np.cumprod(AR_u8), npt.NDArray[np.uint64])
+assert_type(np.cumprod(AR_i8), npt.NDArray[np.int64])
+assert_type(np.cumprod(AR_f4), npt.NDArray[np.floating[Any]])
+assert_type(np.cumprod(AR_c16), npt.NDArray[np.complexfloating[Any, Any]])
+assert_type(np.cumprod(AR_O), npt.NDArray[np.object_])
+assert_type(np.cumprod(AR_f4, axis=0), npt.NDArray[np.floating[Any]])
+assert_type(np.cumprod(AR_f4, dtype=np.float64), npt.NDArray[np.float64])
+assert_type(np.cumprod(AR_f4, dtype=float), npt.NDArray[Any])
+assert_type(np.cumprod(AR_f4, out=AR_subclass), NDArraySubclass)
+
+assert_type(np.ndim(b), int)
+assert_type(np.ndim(f4), int)
+assert_type(np.ndim(f), int)
+assert_type(np.ndim(AR_b), int)
+assert_type(np.ndim(AR_f4), int)
+
+assert_type(np.size(b), int)
+assert_type(np.size(f4), int)
+assert_type(np.size(f), int)
+assert_type(np.size(AR_b), int)
+assert_type(np.size(AR_f4), int)
+
+assert_type(np.around(b), np.float16)
+assert_type(np.around(f), Any)
+assert_type(np.around(i8), np.int64)
+assert_type(np.around(f4), np.float32)
+assert_type(np.around(AR_b), npt.NDArray[np.float16])
+assert_type(np.around(AR_i8), npt.NDArray[np.int64])
+assert_type(np.around(AR_f4), npt.NDArray[np.float32])
+assert_type(np.around([1.5]), npt.NDArray[Any])
+assert_type(np.around(AR_f4, out=AR_subclass), NDArraySubclass)
+
+assert_type(np.mean(AR_b), np.floating[Any])
+assert_type(np.mean(AR_i8), np.floating[Any])
+assert_type(np.mean(AR_f4), np.floating[Any])
+assert_type(np.mean(AR_c16), np.complexfloating[Any, Any])
+assert_type(np.mean(AR_O), Any)
+assert_type(np.mean(AR_f4, axis=0), Any)
+assert_type(np.mean(AR_f4, keepdims=True), Any)
+assert_type(np.mean(AR_f4, dtype=float), Any)
+assert_type(np.mean(AR_f4, dtype=np.float64), np.float64)
+assert_type(np.mean(AR_f4, out=AR_subclass), NDArraySubclass)
+
+assert_type(np.std(AR_b), np.floating[Any])
+assert_type(np.std(AR_i8), np.floating[Any])
+assert_type(np.std(AR_f4), np.floating[Any])
+assert_type(np.std(AR_c16), np.floating[Any])
+assert_type(np.std(AR_O), Any)
+assert_type(np.std(AR_f4, axis=0), Any)
+assert_type(np.std(AR_f4, keepdims=True), Any)
+assert_type(np.std(AR_f4, dtype=float), Any)
+assert_type(np.std(AR_f4, dtype=np.float64), np.float64)
+assert_type(np.std(AR_f4, out=AR_subclass), NDArraySubclass)
+
+assert_type(np.var(AR_b), np.floating[Any])
+assert_type(np.var(AR_i8), np.floating[Any])
+assert_type(np.var(AR_f4), np.floating[Any])
+assert_type(np.var(AR_c16), np.floating[Any])
+assert_type(np.var(AR_O), Any)
+assert_type(np.var(AR_f4, axis=0), Any)
+assert_type(np.var(AR_f4, keepdims=True), Any)
+assert_type(np.var(AR_f4, dtype=float), Any)
+assert_type(np.var(AR_f4, dtype=np.float64), np.float64)
+assert_type(np.var(AR_f4, out=AR_subclass), NDArraySubclass)

LTA_openwebtext_dualt/mini_owt_logdirichlet/.venv_qwen35_uv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/memmap.pyi

@@ -0,0 +1,25 @@
+import sys
+from typing import Any
+
+import numpy as np
+
+if sys.version_info >= (3, 11):
+    from typing import assert_type
+else:
+    from typing_extensions import assert_type
+
+memmap_obj: np.memmap[Any, np.dtype[np.str_]]
+
+assert_type(np.memmap.__array_priority__, float)
+assert_type(memmap_obj.__array_priority__, float)
+assert_type(memmap_obj.filename, str | None)
+assert_type(memmap_obj.offset, int)
+assert_type(memmap_obj.mode, str)
+assert_type(memmap_obj.flush(), None)
+
+assert_type(np.memmap("file.txt", offset=5), np.memmap[Any, np.dtype[np.uint8]])
+assert_type(np.memmap(b"file.txt", dtype=np.float64, shape=(10, 3)), np.memmap[Any, np.dtype[np.float64]])
+with open("file.txt", "rb") as f:
+    assert_type(np.memmap(f, dtype=float, order="K"), np.memmap[Any, np.dtype[Any]])
+
+assert_type(memmap_obj.__array_finalize__(object()), None)

LTA_openwebtext_dualt/mini_owt_logdirichlet/.venv_qwen35_uv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/mod.pyi

@@ -0,0 +1,148 @@
+import sys
+from typing import Any
+
+import numpy as np
+import numpy.typing as npt
+from numpy._typing import _32Bit, _64Bit
+
+if sys.version_info >= (3, 11):
+    from typing import assert_type
+else:
+    from typing_extensions import assert_type
+
+f8 = np.float64()
+i8 = np.int64()
+u8 = np.uint64()
+
+f4 = np.float32()
+i4 = np.int32()
+u4 = np.uint32()
+
+td = np.timedelta64(0, "D")
+b_ = np.bool_()
+
+b = bool()
+f = float()
+i = int()
+
+AR_b: npt.NDArray[np.bool_]
+AR_m: npt.NDArray[np.timedelta64]
+
+# Time structures
+
+assert_type(td % td, np.timedelta64)
+assert_type(AR_m % td, npt.NDArray[np.timedelta64])
+assert_type(td % AR_m, npt.NDArray[np.timedelta64])
+
+assert_type(divmod(td, td), tuple[np.int64, np.timedelta64])
+assert_type(divmod(AR_m, td), tuple[npt.NDArray[np.int64], npt.NDArray[np.timedelta64]])
+assert_type(divmod(td, AR_m), tuple[npt.NDArray[np.int64], npt.NDArray[np.timedelta64]])
+
+# Bool
+
+assert_type(b_ % b, np.int8)
+assert_type(b_ % i, np.int_)
+assert_type(b_ % f, np.float64)
+assert_type(b_ % b_, np.int8)
+assert_type(b_ % i8, np.int64)
+assert_type(b_ % u8, np.uint64)
+assert_type(b_ % f8, np.float64)
+assert_type(b_ % AR_b, npt.NDArray[np.int8])
+
+assert_type(divmod(b_, b), tuple[np.int8, np.int8])
+assert_type(divmod(b_, i), tuple[np.int_, np.int_])
+assert_type(divmod(b_, f), tuple[np.float64, np.float64])
+assert_type(divmod(b_, b_), tuple[np.int8, np.int8])
+assert_type(divmod(b_, i8), tuple[np.int64, np.int64])
+assert_type(divmod(b_, u8), tuple[np.uint64, np.uint64])
+assert_type(divmod(b_, f8), tuple[np.float64, np.float64])
+assert_type(divmod(b_, AR_b), tuple[npt.NDArray[np.int8], npt.NDArray[np.int8]])
+
+assert_type(b % b_, np.int8)
+assert_type(i % b_, np.int_)
+assert_type(f % b_, np.float64)
+assert_type(b_ % b_, np.int8)
+assert_type(i8 % b_, np.int64)
+assert_type(u8 % b_, np.uint64)
+assert_type(f8 % b_, np.float64)
+assert_type(AR_b % b_, npt.NDArray[np.int8])
+
+assert_type(divmod(b, b_), tuple[np.int8, np.int8])
+assert_type(divmod(i, b_), tuple[np.int_, np.int_])
+assert_type(divmod(f, b_), tuple[np.float64, np.float64])
+assert_type(divmod(b_, b_), tuple[np.int8, np.int8])
+assert_type(divmod(i8, b_), tuple[np.int64, np.int64])
+assert_type(divmod(u8, b_), tuple[np.uint64, np.uint64])
+assert_type(divmod(f8, b_), tuple[np.float64, np.float64])
+assert_type(divmod(AR_b, b_), tuple[npt.NDArray[np.int8], npt.NDArray[np.int8]])
+
+# int
+
+assert_type(i8 % b, np.int64)
+assert_type(i8 % f, np.float64)
+assert_type(i8 % i8, np.int64)
+assert_type(i8 % f8, np.float64)
+assert_type(i4 % i8, np.signedinteger[_32Bit | _64Bit])
+assert_type(i4 % f8, np.floating[_32Bit | _64Bit])
+assert_type(i4 % i4, np.int32)
+assert_type(i4 % f4, np.float32)
+assert_type(i8 % AR_b, npt.NDArray[np.signedinteger[Any]])
+
+assert_type(divmod(i8, b), tuple[np.int64, np.int64])
+assert_type(divmod(i8, f), tuple[np.float64, np.float64])
+assert_type(divmod(i8, i8), tuple[np.int64, np.int64])
+assert_type(divmod(i8, f8), tuple[np.float64, np.float64])
+assert_type(divmod(i8, i4), tuple[np.signedinteger[_32Bit | _64Bit], np.signedinteger[_32Bit | _64Bit]])
+assert_type(divmod(i8, f4), tuple[np.floating[_32Bit | _64Bit], np.floating[_32Bit | _64Bit]])
+assert_type(divmod(i4, i4), tuple[np.int32, np.int32])
+assert_type(divmod(i4, f4), tuple[np.float32, np.float32])
+assert_type(divmod(i8, AR_b), tuple[npt.NDArray[np.signedinteger[Any]], npt.NDArray[np.signedinteger[Any]]])
+
+assert_type(b % i8, np.int64)
+assert_type(f % i8, np.float64)
+assert_type(i8 % i8, np.int64)
+assert_type(f8 % i8, np.float64)
+assert_type(i8 % i4, np.signedinteger[_32Bit | _64Bit])
+assert_type(f8 % i4, np.floating[_32Bit | _64Bit])
+assert_type(i4 % i4, np.int32)
+assert_type(f4 % i4, np.float32)
+assert_type(AR_b % i8, npt.NDArray[np.signedinteger[Any]])
+
+assert_type(divmod(b, i8), tuple[np.int64, np.int64])
+assert_type(divmod(f, i8), tuple[np.float64, np.float64])
+assert_type(divmod(i8, i8), tuple[np.int64, np.int64])
+assert_type(divmod(f8, i8), tuple[np.float64, np.float64])
+assert_type(divmod(i4, i8), tuple[np.signedinteger[_32Bit | _64Bit], np.signedinteger[_32Bit | _64Bit]])
+assert_type(divmod(f4, i8), tuple[np.floating[_32Bit | _64Bit], np.floating[_32Bit | _64Bit]])
+assert_type(divmod(i4, i4), tuple[np.int32, np.int32])
+assert_type(divmod(f4, i4), tuple[np.float32, np.float32])
+assert_type(divmod(AR_b, i8), tuple[npt.NDArray[np.signedinteger[Any]], npt.NDArray[np.signedinteger[Any]]])
+
+# float
+
+assert_type(f8 % b, np.float64)
+assert_type(f8 % f, np.float64)
+assert_type(i8 % f4, np.floating[_32Bit | _64Bit])
+assert_type(f4 % f4, np.float32)
+assert_type(f8 % AR_b, npt.NDArray[np.floating[Any]])
+
+assert_type(divmod(f8, b), tuple[np.float64, np.float64])
+assert_type(divmod(f8, f), tuple[np.float64, np.float64])
+assert_type(divmod(f8, f8), tuple[np.float64, np.float64])
+assert_type(divmod(f8, f4), tuple[np.floating[_32Bit | _64Bit], np.floating[_32Bit | _64Bit]])
+assert_type(divmod(f4, f4), tuple[np.float32, np.float32])
+assert_type(divmod(f8, AR_b), tuple[npt.NDArray[np.floating[Any]], npt.NDArray[np.floating[Any]]])
+
+assert_type(b % f8, np.float64)
+assert_type(f % f8, np.float64)
+assert_type(f8 % f8, np.float64)
+assert_type(f8 % f8, np.float64)
+assert_type(f4 % f4, np.float32)
+assert_type(AR_b % f8, npt.NDArray[np.floating[Any]])
+
+assert_type(divmod(b, f8), tuple[np.float64, np.float64])
+assert_type(divmod(f, f8), tuple[np.float64, np.float64])
+assert_type(divmod(f8, f8), tuple[np.float64, np.float64])
+assert_type(divmod(f4, f8), tuple[np.floating[_32Bit | _64Bit], np.floating[_32Bit | _64Bit]])
+assert_type(divmod(f4, f4), tuple[np.float32, np.float32])
+assert_type(divmod(AR_b, f8), tuple[npt.NDArray[np.floating[Any]], npt.NDArray[np.floating[Any]]])

LTA_openwebtext_dualt/mini_owt_logdirichlet/.venv_qwen35_uv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/ndarray_shape_manipulation.pyi

@@ -0,0 +1,44 @@
+import sys
+from typing import Any
+
+import numpy as np
+import numpy.typing as npt
+
+if sys.version_info >= (3, 11):
+    from typing import assert_type
+else:
+    from typing_extensions import assert_type
+
+nd: npt.NDArray[np.int64]
+
+# reshape
+assert_type(nd.reshape(), npt.NDArray[np.int64])
+assert_type(nd.reshape(4), npt.NDArray[np.int64])
+assert_type(nd.reshape(2, 2), npt.NDArray[np.int64])
+assert_type(nd.reshape((2, 2)), npt.NDArray[np.int64])
+
+assert_type(nd.reshape((2, 2), order="C"), npt.NDArray[np.int64])
+assert_type(nd.reshape(4, order="C"), npt.NDArray[np.int64])
+
+# resize does not return a value
+
+# transpose
+assert_type(nd.transpose(), npt.NDArray[np.int64])
+assert_type(nd.transpose(1, 0), npt.NDArray[np.int64])
+assert_type(nd.transpose((1, 0)), npt.NDArray[np.int64])
+
+# swapaxes
+assert_type(nd.swapaxes(0, 1), npt.NDArray[np.int64])
+
+# flatten
+assert_type(nd.flatten(), npt.NDArray[np.int64])
+assert_type(nd.flatten("C"), npt.NDArray[np.int64])
+
+# ravel
+assert_type(nd.ravel(), npt.NDArray[np.int64])
+assert_type(nd.ravel("C"), npt.NDArray[np.int64])
+
+# squeeze
+assert_type(nd.squeeze(), npt.NDArray[np.int64])
+assert_type(nd.squeeze(0), npt.NDArray[np.int64])
+assert_type(nd.squeeze((0, 2)), npt.NDArray[np.int64])

LTA_openwebtext_dualt/mini_owt_logdirichlet/.venv_qwen35_uv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/nditer.pyi

@@ -0,0 +1,55 @@
+import sys
+from typing import Any
+
+import numpy as np
+import numpy.typing as npt
+
+if sys.version_info >= (3, 11):
+    from typing import assert_type
+else:
+    from typing_extensions import assert_type
+
+nditer_obj: np.nditer
+
+assert_type(np.nditer([0, 1], flags=["c_index"]), np.nditer)
+assert_type(np.nditer([0, 1], op_flags=[["readonly", "readonly"]]), np.nditer)
+assert_type(np.nditer([0, 1], op_dtypes=np.int_), np.nditer)
+assert_type(np.nditer([0, 1], order="C", casting="no"), np.nditer)
+
+assert_type(nditer_obj.dtypes, tuple[np.dtype[Any], ...])
+assert_type(nditer_obj.finished, bool)
+assert_type(nditer_obj.has_delayed_bufalloc, bool)
+assert_type(nditer_obj.has_index, bool)
+assert_type(nditer_obj.has_multi_index, bool)
+assert_type(nditer_obj.index, int)
+assert_type(nditer_obj.iterationneedsapi, bool)
+assert_type(nditer_obj.iterindex, int)
+assert_type(nditer_obj.iterrange, tuple[int, ...])
+assert_type(nditer_obj.itersize, int)
+assert_type(nditer_obj.itviews, tuple[npt.NDArray[Any], ...])
+assert_type(nditer_obj.multi_index, tuple[int, ...])
+assert_type(nditer_obj.ndim, int)
+assert_type(nditer_obj.nop, int)
+assert_type(nditer_obj.operands, tuple[npt.NDArray[Any], ...])
+assert_type(nditer_obj.shape, tuple[int, ...])
+assert_type(nditer_obj.value, tuple[npt.NDArray[Any], ...])
+
+assert_type(nditer_obj.close(), None)
+assert_type(nditer_obj.copy(), np.nditer)
+assert_type(nditer_obj.debug_print(), None)
+assert_type(nditer_obj.enable_external_loop(), None)
+assert_type(nditer_obj.iternext(), bool)
+assert_type(nditer_obj.remove_axis(0), None)
+assert_type(nditer_obj.remove_multi_index(), None)
+assert_type(nditer_obj.reset(), None)
+
+assert_type(len(nditer_obj), int)
+assert_type(iter(nditer_obj), np.nditer)
+assert_type(next(nditer_obj), tuple[npt.NDArray[Any], ...])
+assert_type(nditer_obj.__copy__(), np.nditer)
+with nditer_obj as f:
+    assert_type(f, np.nditer)
+assert_type(nditer_obj[0], npt.NDArray[Any])
+assert_type(nditer_obj[:], tuple[npt.NDArray[Any], ...])
+nditer_obj[0] = 0
+nditer_obj[:] = [0, 1]

LTA_openwebtext_dualt/mini_owt_logdirichlet/.venv_qwen35_uv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/warnings_and_errors.pyi

@@ -0,0 +1,16 @@
+import sys
+
+import numpy as np
+
+if sys.version_info >= (3, 11):
+    from typing import assert_type
+else:
+    from typing_extensions import assert_type
+
+assert_type(np.ModuleDeprecationWarning(), np.ModuleDeprecationWarning)
+assert_type(np.VisibleDeprecationWarning(), np.VisibleDeprecationWarning)
+assert_type(np.ComplexWarning(), np.ComplexWarning)
+assert_type(np.RankWarning(), np.RankWarning)
+assert_type(np.TooHardError(), np.TooHardError)
+assert_type(np.AxisError("test"), np.AxisError)
+assert_type(np.AxisError(5, 1), np.AxisError)

LTA_openwebtext_dualt/mini_owt_logdirichlet/logs/decode1_4_uniform_online_20260610/lr2e3_online_latest_decode1_4_uniform.log

@@ -0,0 +1,51 @@
+checkpoint=runs/owt_t5_elftokenized_full_len1024_C1_to_1024_pow1_d768_l12_h12_gbs512_8gpu_50ep_lr2e3_ema0p9999_elfopt_t5embed_unfixed_norm_stateprobadd_selfcond_ce_fast_20260606_144231/step_292000.pt
+use_ema=0
+step=292000
+decode_steps=1 4
+n=64 chunk_n=8 gpu=0
+out_base=/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260610
+[2026-06-09T22:56:14+00:00] infer step=292000 decode=1 -> /e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260610/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_online_uniform_step292000_sc1p0_decode1_n64
+[2026-06-09T22:56:14+00:00] run decode=1 chunk=0 n=8 seed=123
+[2026-06-09T22:56:18+00:00] done decode=1 chunk=0
+[2026-06-09T22:56:18+00:00] run decode=1 chunk=1 n=8 seed=124
+[2026-06-09T22:56:22+00:00] done decode=1 chunk=1
+[2026-06-09T22:56:22+00:00] run decode=1 chunk=2 n=8 seed=125
+[2026-06-09T22:56:26+00:00] done decode=1 chunk=2
+[2026-06-09T22:56:26+00:00] run decode=1 chunk=3 n=8 seed=126
+[2026-06-09T22:56:30+00:00] done decode=1 chunk=3
+[2026-06-09T22:56:30+00:00] run decode=1 chunk=4 n=8 seed=127
+[2026-06-09T22:56:35+00:00] done decode=1 chunk=4
+[2026-06-09T22:56:35+00:00] run decode=1 chunk=5 n=8 seed=128
+[2026-06-09T22:56:39+00:00] done decode=1 chunk=5
+[2026-06-09T22:56:39+00:00] run decode=1 chunk=6 n=8 seed=129
+[2026-06-09T22:56:43+00:00] done decode=1 chunk=6
+[2026-06-09T22:56:43+00:00] run decode=1 chunk=7 n=8 seed=130
+[2026-06-09T22:56:47+00:00] done decode=1 chunk=7
+merged 64 samples -> /e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260610/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_online_uniform_step292000_sc1p0_decode1_n64/sc1p0/samples64.txt
+loading scorer /e2e-data/evad-tech-vla/wanghan58/models/flowtext_scorers/gpt2-large-standard dtype=fp32 device=cuda
+run	kind	ppl	mean_entropy	distinct_1	distinct_2	top_token_mass	eos_rows	eos_total	ppl_tokens	t5_tokens	path
+sc1p0	raw_full	1.096572649728622	0.11783789575524715	0.0004955050612302683	0.001132663174288546	0.9815247398598429	0	0	79304	14127	/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260610/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_online_uniform_step292000_sc1p0_decode1_n64/sc1p0
+sc1p0	pre_eos	1.096572649728622	0.11783789575524715	0.0004955050612302683	0.001132663174288546	0.9815247398598429	0	0	79304	14127	/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260610/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_online_uniform_step292000_sc1p0_decode1_n64/sc1p0
+[2026-06-09T22:57:02+00:00] infer step=292000 decode=4 -> /e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260610/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_online_uniform_step292000_sc1p0_decode4_n64
+[2026-06-09T22:57:02+00:00] run decode=4 chunk=0 n=8 seed=123
+[2026-06-09T22:57:07+00:00] done decode=4 chunk=0
+[2026-06-09T22:57:07+00:00] run decode=4 chunk=1 n=8 seed=124
+[2026-06-09T22:57:11+00:00] done decode=4 chunk=1
+[2026-06-09T22:57:11+00:00] run decode=4 chunk=2 n=8 seed=125
+[2026-06-09T22:57:16+00:00] done decode=4 chunk=2
+[2026-06-09T22:57:16+00:00] run decode=4 chunk=3 n=8 seed=126
+[2026-06-09T22:57:20+00:00] done decode=4 chunk=3
+[2026-06-09T22:57:20+00:00] run decode=4 chunk=4 n=8 seed=127
+[2026-06-09T22:57:25+00:00] done decode=4 chunk=4
+[2026-06-09T22:57:25+00:00] run decode=4 chunk=5 n=8 seed=128
+[2026-06-09T22:57:29+00:00] done decode=4 chunk=5
+[2026-06-09T22:57:29+00:00] run decode=4 chunk=6 n=8 seed=129
+[2026-06-09T22:57:34+00:00] done decode=4 chunk=6
+[2026-06-09T22:57:34+00:00] run decode=4 chunk=7 n=8 seed=130
+[2026-06-09T22:57:39+00:00] done decode=4 chunk=7
+merged 64 samples -> /e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260610/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_online_uniform_step292000_sc1p0_decode4_n64/sc1p0/samples64.txt
+loading scorer /e2e-data/evad-tech-vla/wanghan58/models/flowtext_scorers/gpt2-large-standard dtype=fp32 device=cuda
+run	kind	ppl	mean_entropy	distinct_1	distinct_2	top_token_mass	eos_rows	eos_total	ppl_tokens	t5_tokens	path
+sc1p0	raw_full	3.9144810000584296	1.655964156095804	0.002519893899204244	0.010636886920077455	0.42931034482758623	8	8	53648	37700	/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260610/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_online_uniform_step292000_sc1p0_decode4_n64/sc1p0
+sc1p0	pre_eos	4.001451443769343	1.6315027573148633	0.002560163850486431	0.010779927774483911	0.4361441237502358	0	0	52447	37107	/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260610/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_online_uniform_step292000_sc1p0_decode4_n64/sc1p0
+[2026-06-09T22:57:50+00:00] done

LTA_openwebtext_dualt/mini_owt_logdirichlet/logs/decode1_4_uniform_online_20260610/lr6e4_online_latest_decode1_4_uniform.log

@@ -0,0 +1,51 @@
+checkpoint=runs/owt_t5_elftokenized_full_len1024_C1_to_1024_pow1_d768_l12_h12_gbs512_8gpu_50ep_lr6e4_ema0p9999_elfopt_t5embed_unfixed_norm_stateprobadd_selfcond_ce_fast_20260606_144245/step_297000.pt
+use_ema=0
+step=297000
+decode_steps=1 4
+n=64 chunk_n=8 gpu=1
+out_base=/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260610
+[2026-06-09T22:56:14+00:00] infer step=297000 decode=1 -> /e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260610/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr6e4_ema0p9999_online_uniform_step297000_sc1p0_decode1_n64
+[2026-06-09T22:56:14+00:00] run decode=1 chunk=0 n=8 seed=123
+[2026-06-09T22:56:18+00:00] done decode=1 chunk=0
+[2026-06-09T22:56:18+00:00] run decode=1 chunk=1 n=8 seed=124
+[2026-06-09T22:56:23+00:00] done decode=1 chunk=1
+[2026-06-09T22:56:23+00:00] run decode=1 chunk=2 n=8 seed=125
+[2026-06-09T22:56:27+00:00] done decode=1 chunk=2
+[2026-06-09T22:56:27+00:00] run decode=1 chunk=3 n=8 seed=126
+[2026-06-09T22:56:31+00:00] done decode=1 chunk=3
+[2026-06-09T22:56:31+00:00] run decode=1 chunk=4 n=8 seed=127
+[2026-06-09T22:56:35+00:00] done decode=1 chunk=4
+[2026-06-09T22:56:35+00:00] run decode=1 chunk=5 n=8 seed=128
+[2026-06-09T22:56:40+00:00] done decode=1 chunk=5
+[2026-06-09T22:56:40+00:00] run decode=1 chunk=6 n=8 seed=129
+[2026-06-09T22:56:44+00:00] done decode=1 chunk=6
+[2026-06-09T22:56:44+00:00] run decode=1 chunk=7 n=8 seed=130
+[2026-06-09T22:56:48+00:00] done decode=1 chunk=7
+merged 64 samples -> /e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260610/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr6e4_ema0p9999_online_uniform_step297000_sc1p0_decode1_n64/sc1p0/samples64.txt
+loading scorer /e2e-data/evad-tech-vla/wanghan58/models/flowtext_scorers/gpt2-large-standard dtype=fp32 device=cuda
+run	kind	ppl	mean_entropy	distinct_1	distinct_2	top_token_mass	eos_rows	eos_total	ppl_tokens	t5_tokens	path
+sc1p0	raw_full	1.1010033551856535	0.10100969198731712	0.0004690706537672237	0.0008209217778820218	0.9846379360891234	0	0	82237	17055	/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260610/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr6e4_ema0p9999_online_uniform_step297000_sc1p0_decode1_n64/sc1p0
+sc1p0	pre_eos	1.1010033551856535	0.10100969198731712	0.0004690706537672237	0.0008209217778820218	0.9846379360891234	0	0	82237	17055	/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260610/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr6e4_ema0p9999_online_uniform_step297000_sc1p0_decode1_n64/sc1p0
+[2026-06-09T22:57:03+00:00] infer step=297000 decode=4 -> /e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260610/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr6e4_ema0p9999_online_uniform_step297000_sc1p0_decode4_n64
+[2026-06-09T22:57:03+00:00] run decode=4 chunk=0 n=8 seed=123
+[2026-06-09T22:57:08+00:00] done decode=4 chunk=0
+[2026-06-09T22:57:08+00:00] run decode=4 chunk=1 n=8 seed=124
+[2026-06-09T22:57:12+00:00] done decode=4 chunk=1
+[2026-06-09T22:57:12+00:00] run decode=4 chunk=2 n=8 seed=125
+[2026-06-09T22:57:16+00:00] done decode=4 chunk=2
+[2026-06-09T22:57:16+00:00] run decode=4 chunk=3 n=8 seed=126
+[2026-06-09T22:57:21+00:00] done decode=4 chunk=3
+[2026-06-09T22:57:21+00:00] run decode=4 chunk=4 n=8 seed=127
+[2026-06-09T22:57:25+00:00] done decode=4 chunk=4
+[2026-06-09T22:57:25+00:00] run decode=4 chunk=5 n=8 seed=128
+[2026-06-09T22:57:30+00:00] done decode=4 chunk=5
+[2026-06-09T22:57:30+00:00] run decode=4 chunk=6 n=8 seed=129
+[2026-06-09T22:57:34+00:00] done decode=4 chunk=6
+[2026-06-09T22:57:34+00:00] run decode=4 chunk=7 n=8 seed=130
+[2026-06-09T22:57:39+00:00] done decode=4 chunk=7
+merged 64 samples -> /e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260610/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr6e4_ema0p9999_online_uniform_step297000_sc1p0_decode4_n64/sc1p0/samples64.txt
+loading scorer /e2e-data/evad-tech-vla/wanghan58/models/flowtext_scorers/gpt2-large-standard dtype=fp32 device=cuda
+run	kind	ppl	mean_entropy	distinct_1	distinct_2	top_token_mass	eos_rows	eos_total	ppl_tokens	t5_tokens	path
+sc1p0	raw_full	1.862719202099405	0.4595035966522467	0.0006571908910285801	0.0022008589463387795	0.8955524988537368	4	4	38889	65430	/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260610/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr6e4_ema0p9999_online_uniform_step297000_sc1p0_decode4_n64/sc1p0
+sc1p0	pre_eos	1.8667632184252236	0.44590311903537977	0.0006596609649459231	0.002193789887088856	0.8989184628365422	0	0	38395	65185	/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260610/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr6e4_ema0p9999_online_uniform_step297000_sc1p0_decode4_n64/sc1p0
+[2026-06-09T22:57:49+00:00] done

LTA_openwebtext_dualt/mini_owt_logdirichlet/logs/infer_lr3e3_170k_logitnorm64_focused_20260612/gpu3.log

@@ -0,0 +1,352 @@
+===== START \2026-06-11T22:34:52+00:00 gpu=3 m=-0.5 s=1.4 gamma=0.25 =====
+checkpoint=runs/owt_t5_elftokenized_full_len1024_C1_to_1024_pow1_d768_l12_h12_gbs512_2x8gpu_50ep_lr3e3_ema0p9999_elfopt_not5_bottleneck128_unfixed_norm_stateprobadd_selfcond_ce_fast_20260609_230847/step_170000.pt
+use_ema=1
+step=170000
+decode_steps=64
+n=64 chunk_n=8 gpu=3
+out_base=/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260612
+[2026-06-11T22:34:52+00:00] infer step=170000 decode=64 -> /e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260612/owt_t5_not5_bottleneck128_norm_stateprobadd_selfcond_ce_fast_lr3e3_ema0p9999_logitnorm64_focused_ppl24_ent515_step170000_ema_dgamma0p25_tschedlogit_normal_mn0p5_s1p4_sc1p0_decode64_n64
+[2026-06-11T22:34:52+00:00] run decode=64 chunk=0 n=8 seed=123
+[2026-06-11T22:35:02+00:00] done decode=64 chunk=0
+[2026-06-11T22:35:02+00:00] run decode=64 chunk=1 n=8 seed=124
+[2026-06-11T22:35:12+00:00] done decode=64 chunk=1
+[2026-06-11T22:35:12+00:00] run decode=64 chunk=2 n=8 seed=125
+[2026-06-11T22:35:21+00:00] done decode=64 chunk=2
+[2026-06-11T22:35:21+00:00] run decode=64 chunk=3 n=8 seed=126
+[2026-06-11T22:35:31+00:00] done decode=64 chunk=3
+[2026-06-11T22:35:31+00:00] run decode=64 chunk=4 n=8 seed=127
+[2026-06-11T22:35:41+00:00] done decode=64 chunk=4
+[2026-06-11T22:35:41+00:00] run decode=64 chunk=5 n=8 seed=128
+[2026-06-11T22:35:50+00:00] done decode=64 chunk=5
+[2026-06-11T22:35:50+00:00] run decode=64 chunk=6 n=8 seed=129
+[2026-06-11T22:36:00+00:00] done decode=64 chunk=6
+[2026-06-11T22:36:00+00:00] run decode=64 chunk=7 n=8 seed=130
+[2026-06-11T22:36:10+00:00] done decode=64 chunk=7
+merged 64 samples -> /e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260612/owt_t5_not5_bottleneck128_norm_stateprobadd_selfcond_ce_fast_lr3e3_ema0p9999_logitnorm64_focused_ppl24_ent515_step170000_ema_dgamma0p25_tschedlogit_normal_mn0p5_s1p4_sc1p0_decode64_n64/sc1p0/samples64.txt
+loading scorer /e2e-data/evad-tech-vla/wanghan58/models/flowtext_scorers/gpt2-large-standard dtype=fp32 device=cuda
+run	kind	ppl	mean_entropy	distinct_1	distinct_2	top_token_mass	eos_rows	eos_total	ppl_tokens	t5_tokens	path
+sc1p0	raw_full	14.323413610616049	5.009203366356262	0.07500610053684724	0.4101758506565803	0.03593216203025866	62	62	64109	65568	/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260612/owt_t5_not5_bottleneck128_norm_stateprobadd_selfcond_ce_fast_lr3e3_ema0p9999_logitnorm64_focused_ppl24_ent515_step170000_ema_dgamma0p25_tschedlogit_normal_mn0p5_s1p4_sc1p0_decode64_n64/sc1p0
+sc1p0	pre_eos	16.11984853009216	5.038465452975301	0.07745990736948234	0.4236337571088741	0.03711522102145625	0	0	59907	63478	/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260612/owt_t5_not5_bottleneck128_norm_stateprobadd_selfcond_ce_fast_lr3e3_ema0p9999_logitnorm64_focused_ppl24_ent515_step170000_ema_dgamma0p25_tschedlogit_normal_mn0p5_s1p4_sc1p0_decode64_n64/sc1p0
+[2026-06-11T22:36:42+00:00] done
+===== DONE \2026-06-11T22:34:52+00:00 gpu=3 m=-0.5 s=1.4 gamma=0.25 =====
+===== START \2026-06-11T22:34:52+00:00 gpu=3 m=-0.5 s=1.6 gamma=0.25 =====
+checkpoint=runs/owt_t5_elftokenized_full_len1024_C1_to_1024_pow1_d768_l12_h12_gbs512_2x8gpu_50ep_lr3e3_ema0p9999_elfopt_not5_bottleneck128_unfixed_norm_stateprobadd_selfcond_ce_fast_20260609_230847/step_170000.pt
+use_ema=1
+step=170000
+decode_steps=64
+n=64 chunk_n=8 gpu=3
+out_base=/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260612
+[2026-06-11T22:36:42+00:00] infer step=170000 decode=64 -> /e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260612/owt_t5_not5_bottleneck128_norm_stateprobadd_selfcond_ce_fast_lr3e3_ema0p9999_logitnorm64_focused_ppl24_ent515_step170000_ema_dgamma0p25_tschedlogit_normal_mn0p5_s1p6_sc1p0_decode64_n64
+[2026-06-11T22:36:42+00:00] run decode=64 chunk=0 n=8 seed=123
+[2026-06-11T22:36:52+00:00] done decode=64 chunk=0
+[2026-06-11T22:36:52+00:00] run decode=64 chunk=1 n=8 seed=124
+[2026-06-11T22:37:02+00:00] done decode=64 chunk=1
+[2026-06-11T22:37:02+00:00] run decode=64 chunk=2 n=8 seed=125
+[2026-06-11T22:37:11+00:00] done decode=64 chunk=2
+[2026-06-11T22:37:11+00:00] run decode=64 chunk=3 n=8 seed=126
+[2026-06-11T22:37:21+00:00] done decode=64 chunk=3
+[2026-06-11T22:37:21+00:00] run decode=64 chunk=4 n=8 seed=127
+[2026-06-11T22:37:31+00:00] done decode=64 chunk=4
+[2026-06-11T22:37:31+00:00] run decode=64 chunk=5 n=8 seed=128
+[2026-06-11T22:37:41+00:00] done decode=64 chunk=5
+[2026-06-11T22:37:41+00:00] run decode=64 chunk=6 n=8 seed=129
+[2026-06-11T22:37:50+00:00] done decode=64 chunk=6
+[2026-06-11T22:37:50+00:00] run decode=64 chunk=7 n=8 seed=130
+[2026-06-11T22:38:00+00:00] done decode=64 chunk=7
+merged 64 samples -> /e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260612/owt_t5_not5_bottleneck128_norm_stateprobadd_selfcond_ce_fast_lr3e3_ema0p9999_logitnorm64_focused_ppl24_ent515_step170000_ema_dgamma0p25_tschedlogit_normal_mn0p5_s1p6_sc1p0_decode64_n64/sc1p0/samples64.txt
+loading scorer /e2e-data/evad-tech-vla/wanghan58/models/flowtext_scorers/gpt2-large-standard dtype=fp32 device=cuda
+run	kind	ppl	mean_entropy	distinct_1	distinct_2	top_token_mass	eos_rows	eos_total	ppl_tokens	t5_tokens	path
+sc1p0	raw_full	15.92467574106307	5.044005213841317	0.07881645608252456	0.42744655201355086	0.03688274430812428	63	63	63695	65532	/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260612/owt_t5_not5_bottleneck128_norm_stateprobadd_selfcond_ce_fast_lr3e3_ema0p9999_logitnorm64_focused_ppl24_ent515_step170000_ema_dgamma0p25_tschedlogit_normal_mn0p5_s1p6_sc1p0_decode64_n64/sc1p0
+sc1p0	pre_eos	17.980638543037145	5.073226190698163	0.08132027337721646	0.4410481724697249	0.03806179332934396	0	0	59610	63502	/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260612/owt_t5_not5_bottleneck128_norm_stateprobadd_selfcond_ce_fast_lr3e3_ema0p9999_logitnorm64_focused_ppl24_ent515_step170000_ema_dgamma0p25_tschedlogit_normal_mn0p5_s1p6_sc1p0_decode64_n64/sc1p0
+[2026-06-11T22:38:31+00:00] done
+===== DONE \2026-06-11T22:34:52+00:00 gpu=3 m=-0.5 s=1.6 gamma=0.25 =====
+===== START \2026-06-11T22:34:52+00:00 gpu=3 m=-0.5 s=1.8 gamma=0.25 =====
+checkpoint=runs/owt_t5_elftokenized_full_len1024_C1_to_1024_pow1_d768_l12_h12_gbs512_2x8gpu_50ep_lr3e3_ema0p9999_elfopt_not5_bottleneck128_unfixed_norm_stateprobadd_selfcond_ce_fast_20260609_230847/step_170000.pt
+use_ema=1
+step=170000
+decode_steps=64
+n=64 chunk_n=8 gpu=3
+out_base=/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260612
+[2026-06-11T22:38:31+00:00] infer step=170000 decode=64 -> /e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260612/owt_t5_not5_bottleneck128_norm_stateprobadd_selfcond_ce_fast_lr3e3_ema0p9999_logitnorm64_focused_ppl24_ent515_step170000_ema_dgamma0p25_tschedlogit_normal_mn0p5_s1p8_sc1p0_decode64_n64
+[2026-06-11T22:38:31+00:00] run decode=64 chunk=0 n=8 seed=123
+[2026-06-11T22:38:41+00:00] done decode=64 chunk=0
+[2026-06-11T22:38:41+00:00] run decode=64 chunk=1 n=8 seed=124
+[2026-06-11T22:38:51+00:00] done decode=64 chunk=1
+[2026-06-11T22:38:51+00:00] run decode=64 chunk=2 n=8 seed=125
+[2026-06-11T22:39:00+00:00] done decode=64 chunk=2
+[2026-06-11T22:39:00+00:00] run decode=64 chunk=3 n=8 seed=126
+[2026-06-11T22:39:10+00:00] done decode=64 chunk=3
+[2026-06-11T22:39:10+00:00] run decode=64 chunk=4 n=8 seed=127
+[2026-06-11T22:39:20+00:00] done decode=64 chunk=4
+[2026-06-11T22:39:20+00:00] run decode=64 chunk=5 n=8 seed=128
+[2026-06-11T22:39:29+00:00] done decode=64 chunk=5
+[2026-06-11T22:39:29+00:00] run decode=64 chunk=6 n=8 seed=129
+[2026-06-11T22:39:39+00:00] done decode=64 chunk=6
+[2026-06-11T22:39:39+00:00] run decode=64 chunk=7 n=8 seed=130
+[2026-06-11T22:39:49+00:00] done decode=64 chunk=7
+merged 64 samples -> /e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260612/owt_t5_not5_bottleneck128_norm_stateprobadd_selfcond_ce_fast_lr3e3_ema0p9999_logitnorm64_focused_ppl24_ent515_step170000_ema_dgamma0p25_tschedlogit_normal_mn0p5_s1p8_sc1p0_decode64_n64/sc1p0/samples64.txt
+loading scorer /e2e-data/evad-tech-vla/wanghan58/models/flowtext_scorers/gpt2-large-standard dtype=fp32 device=cuda
+run	kind	ppl	mean_entropy	distinct_1	distinct_2	top_token_mass	eos_rows	eos_total	ppl_tokens	t5_tokens	path
+sc1p0	raw_full	16.511156990368196	5.021153347378399	0.07948354013094638	0.43199230792710847	0.03784930482426018	64	64	63897	65523	/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260612/owt_t5_not5_bottleneck128_norm_stateprobadd_selfcond_ce_fast_lr3e3_ema0p9999_logitnorm64_focused_ppl24_ent515_step170000_ema_dgamma0p25_tschedlogit_normal_mn0p5_s1p8_sc1p0_decode64_n64/sc1p0
+sc1p0	pre_eos	19.003033006817592	5.056660543916634	0.08224998815296887	0.4470508324645373	0.03917418294975279	0	0	59441	63307	/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260612/owt_t5_not5_bottleneck128_norm_stateprobadd_selfcond_ce_fast_lr3e3_ema0p9999_logitnorm64_focused_ppl24_ent515_step170000_ema_dgamma0p25_tschedlogit_normal_mn0p5_s1p8_sc1p0_decode64_n64/sc1p0
+[2026-06-11T22:40:18+00:00] done
+===== DONE \2026-06-11T22:34:52+00:00 gpu=3 m=-0.5 s=1.8 gamma=0.25 =====
+===== START \2026-06-11T22:34:52+00:00 gpu=3 m=-0.5 s=2.0 gamma=0.25 =====
+checkpoint=runs/owt_t5_elftokenized_full_len1024_C1_to_1024_pow1_d768_l12_h12_gbs512_2x8gpu_50ep_lr3e3_ema0p9999_elfopt_not5_bottleneck128_unfixed_norm_stateprobadd_selfcond_ce_fast_20260609_230847/step_170000.pt
+use_ema=1
+step=170000
+decode_steps=64
+n=64 chunk_n=8 gpu=3
+out_base=/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260612
+[2026-06-11T22:40:18+00:00] infer step=170000 decode=64 -> /e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260612/owt_t5_not5_bottleneck128_norm_stateprobadd_selfcond_ce_fast_lr3e3_ema0p9999_logitnorm64_focused_ppl24_ent515_step170000_ema_dgamma0p25_tschedlogit_normal_mn0p5_s2p0_sc1p0_decode64_n64
+[2026-06-11T22:40:18+00:00] run decode=64 chunk=0 n=8 seed=123
+[2026-06-11T22:40:27+00:00] done decode=64 chunk=0
+[2026-06-11T22:40:27+00:00] run decode=64 chunk=1 n=8 seed=124
+[2026-06-11T22:40:37+00:00] done decode=64 chunk=1
+[2026-06-11T22:40:37+00:00] run decode=64 chunk=2 n=8 seed=125
+[2026-06-11T22:40:47+00:00] done decode=64 chunk=2
+[2026-06-11T22:40:47+00:00] run decode=64 chunk=3 n=8 seed=126
+[2026-06-11T22:40:56+00:00] done decode=64 chunk=3
+[2026-06-11T22:40:56+00:00] run decode=64 chunk=4 n=8 seed=127
+[2026-06-11T22:41:06+00:00] done decode=64 chunk=4
+[2026-06-11T22:41:06+00:00] run decode=64 chunk=5 n=8 seed=128
+[2026-06-11T22:41:16+00:00] done decode=64 chunk=5
+[2026-06-11T22:41:16+00:00] run decode=64 chunk=6 n=8 seed=129
+[2026-06-11T22:41:26+00:00] done decode=64 chunk=6
+[2026-06-11T22:41:26+00:00] run decode=64 chunk=7 n=8 seed=130
+[2026-06-11T22:41:35+00:00] done decode=64 chunk=7
+merged 64 samples -> /e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260612/owt_t5_not5_bottleneck128_norm_stateprobadd_selfcond_ce_fast_lr3e3_ema0p9999_logitnorm64_focused_ppl24_ent515_step170000_ema_dgamma0p25_tschedlogit_normal_mn0p5_s2p0_sc1p0_decode64_n64/sc1p0/samples64.txt
+loading scorer /e2e-data/evad-tech-vla/wanghan58/models/flowtext_scorers/gpt2-large-standard dtype=fp32 device=cuda
+run	kind	ppl	mean_entropy	distinct_1	distinct_2	top_token_mass	eos_rows	eos_total	ppl_tokens	t5_tokens	path
+sc1p0	raw_full	19.298351448530592	5.110950318985606	0.08453284081022087	0.4514898033947979	0.03542808297589791	62	62	63303	65513	/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260612/owt_t5_not5_bottleneck128_norm_stateprobadd_selfcond_ce_fast_lr3e3_ema0p9999_logitnorm64_focused_ppl24_ent515_step170000_ema_dgamma0p25_tschedlogit_normal_mn0p5_s2p0_sc1p0_decode64_n64/sc1p0
+sc1p0	pre_eos	22.248318536053922	5.146961055265112	0.08728895054624565	0.46623155505107833	0.036589787649961375	0	0	59118	63433	/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260612/owt_t5_not5_bottleneck128_norm_stateprobadd_selfcond_ce_fast_lr3e3_ema0p9999_logitnorm64_focused_ppl24_ent515_step170000_ema_dgamma0p25_tschedlogit_normal_mn0p5_s2p0_sc1p0_decode64_n64/sc1p0
+[2026-06-11T22:41:49+00:00] done
+===== DONE \2026-06-11T22:34:52+00:00 gpu=3 m=-0.5 s=2.0 gamma=0.25 =====
+===== START \2026-06-11T22:34:52+00:00 gpu=3 m=-0.4 s=1.4 gamma=0.25 =====
+checkpoint=runs/owt_t5_elftokenized_full_len1024_C1_to_1024_pow1_d768_l12_h12_gbs512_2x8gpu_50ep_lr3e3_ema0p9999_elfopt_not5_bottleneck128_unfixed_norm_stateprobadd_selfcond_ce_fast_20260609_230847/step_170000.pt
+use_ema=1
+step=170000
+decode_steps=64
+n=64 chunk_n=8 gpu=3
+out_base=/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260612
+[2026-06-11T22:41:49+00:00] infer step=170000 decode=64 -> /e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260612/owt_t5_not5_bottleneck128_norm_stateprobadd_selfcond_ce_fast_lr3e3_ema0p9999_logitnorm64_focused_ppl24_ent515_step170000_ema_dgamma0p25_tschedlogit_normal_mn0p4_s1p4_sc1p0_decode64_n64
+[2026-06-11T22:41:49+00:00] run decode=64 chunk=0 n=8 seed=123
+[2026-06-11T22:41:59+00:00] done decode=64 chunk=0
+[2026-06-11T22:41:59+00:00] run decode=64 chunk=1 n=8 seed=124
+[2026-06-11T22:42:09+00:00] done decode=64 chunk=1
+[2026-06-11T22:42:09+00:00] run decode=64 chunk=2 n=8 seed=125
+[2026-06-11T22:42:19+00:00] done decode=64 chunk=2
+[2026-06-11T22:42:19+00:00] run decode=64 chunk=3 n=8 seed=126
+[2026-06-11T22:42:28+00:00] done decode=64 chunk=3
+[2026-06-11T22:42:28+00:00] run decode=64 chunk=4 n=8 seed=127
+[2026-06-11T22:42:38+00:00] done decode=64 chunk=4
+[2026-06-11T22:42:38+00:00] run decode=64 chunk=5 n=8 seed=128
+[2026-06-11T22:42:48+00:00] done decode=64 chunk=5
+[2026-06-11T22:42:48+00:00] run decode=64 chunk=6 n=8 seed=129
+[2026-06-11T22:42:57+00:00] done decode=64 chunk=6
+[2026-06-11T22:42:57+00:00] run decode=64 chunk=7 n=8 seed=130
+[2026-06-11T22:43:07+00:00] done decode=64 chunk=7
+merged 64 samples -> /e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260612/owt_t5_not5_bottleneck128_norm_stateprobadd_selfcond_ce_fast_lr3e3_ema0p9999_logitnorm64_focused_ppl24_ent515_step170000_ema_dgamma0p25_tschedlogit_normal_mn0p4_s1p4_sc1p0_decode64_n64/sc1p0/samples64.txt
+loading scorer /e2e-data/evad-tech-vla/wanghan58/models/flowtext_scorers/gpt2-large-standard dtype=fp32 device=cuda
+run	kind	ppl	mean_entropy	distinct_1	distinct_2	top_token_mass	eos_rows	eos_total	ppl_tokens	t5_tokens	path
+sc1p0	raw_full	15.483493569064475	5.033153009064646	0.08120904800452095	0.43044354838709675	0.036167580529378525	64	64	63185	65473	/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260612/owt_t5_not5_bottleneck128_norm_stateprobadd_selfcond_ce_fast_lr3e3_ema0p9999_logitnorm64_focused_ppl24_ent515_step170000_ema_dgamma0p25_tschedlogit_normal_mn0p4_s1p4_sc1p0_decode64_n64/sc1p0
+sc1p0	pre_eos	17.4396064742211	5.063226024759697	0.08378514689194301	0.44411871325673397	0.037321901399571304	0	0	59110	63448	/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260612/owt_t5_not5_bottleneck128_norm_stateprobadd_selfcond_ce_fast_lr3e3_ema0p9999_logitnorm64_focused_ppl24_ent515_step170000_ema_dgamma0p25_tschedlogit_normal_mn0p4_s1p4_sc1p0_decode64_n64/sc1p0
+[2026-06-11T22:43:38+00:00] done
+===== DONE \2026-06-11T22:34:52+00:00 gpu=3 m=-0.4 s=1.4 gamma=0.25 =====
+===== START \2026-06-11T22:34:52+00:00 gpu=3 m=-0.4 s=1.6 gamma=0.25 =====
+checkpoint=runs/owt_t5_elftokenized_full_len1024_C1_to_1024_pow1_d768_l12_h12_gbs512_2x8gpu_50ep_lr3e3_ema0p9999_elfopt_not5_bottleneck128_unfixed_norm_stateprobadd_selfcond_ce_fast_20260609_230847/step_170000.pt
+use_ema=1
+step=170000
+decode_steps=64
+n=64 chunk_n=8 gpu=3
+out_base=/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260612
+[2026-06-11T22:43:38+00:00] infer step=170000 decode=64 -> /e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260612/owt_t5_not5_bottleneck128_norm_stateprobadd_selfcond_ce_fast_lr3e3_ema0p9999_logitnorm64_focused_ppl24_ent515_step170000_ema_dgamma0p25_tschedlogit_normal_mn0p4_s1p6_sc1p0_decode64_n64
+[2026-06-11T22:43:38+00:00] run decode=64 chunk=0 n=8 seed=123
+[2026-06-11T22:43:48+00:00] done decode=64 chunk=0
+[2026-06-11T22:43:48+00:00] run decode=64 chunk=1 n=8 seed=124
+[2026-06-11T22:43:58+00:00] done decode=64 chunk=1
+[2026-06-11T22:43:58+00:00] run decode=64 chunk=2 n=8 seed=125
+[2026-06-11T22:44:08+00:00] done decode=64 chunk=2
+[2026-06-11T22:44:08+00:00] run decode=64 chunk=3 n=8 seed=126
+[2026-06-11T22:44:18+00:00] done decode=64 chunk=3
+[2026-06-11T22:44:18+00:00] run decode=64 chunk=4 n=8 seed=127
+[2026-06-11T22:44:27+00:00] done decode=64 chunk=4
+[2026-06-11T22:44:27+00:00] run decode=64 chunk=5 n=8 seed=128
+[2026-06-11T22:44:37+00:00] done decode=64 chunk=5
+[2026-06-11T22:44:37+00:00] run decode=64 chunk=6 n=8 seed=129
+[2026-06-11T22:44:47+00:00] done decode=64 chunk=6
+[2026-06-11T22:44:47+00:00] run decode=64 chunk=7 n=8 seed=130
+[2026-06-11T22:44:57+00:00] done decode=64 chunk=7
+merged 64 samples -> /e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260612/owt_t5_not5_bottleneck128_norm_stateprobadd_selfcond_ce_fast_lr3e3_ema0p9999_logitnorm64_focused_ppl24_ent515_step170000_ema_dgamma0p25_tschedlogit_normal_mn0p4_s1p6_sc1p0_decode64_n64/sc1p0/samples64.txt
+loading scorer /e2e-data/evad-tech-vla/wanghan58/models/flowtext_scorers/gpt2-large-standard dtype=fp32 device=cuda
+run	kind	ppl	mean_entropy	distinct_1	distinct_2	top_token_mass	eos_rows	eos_total	ppl_tokens	t5_tokens	path
+sc1p0	raw_full	16.66348509590687	5.050779955667837	0.07936846922431547	0.43019495377856426	0.036015559453893675	63	64	63791	65555	/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260612/owt_t5_not5_bottleneck128_norm_stateprobadd_selfcond_ce_fast_lr3e3_ema0p9999_logitnorm64_focused_ppl24_ent515_step170000_ema_dgamma0p25_tschedlogit_normal_mn0p4_s1p6_sc1p0_decode64_n64/sc1p0
+sc1p0	pre_eos	19.053423138624822	5.082727122518139	0.08202589129440704	0.444621400864108	0.037228590800864096	0	0	59497	63419	/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260612/owt_t5_not5_bottleneck128_norm_stateprobadd_selfcond_ce_fast_lr3e3_ema0p9999_logitnorm64_focused_ppl24_ent515_step170000_ema_dgamma0p25_tschedlogit_normal_mn0p4_s1p6_sc1p0_decode64_n64/sc1p0
+[2026-06-11T22:45:27+00:00] done
+===== DONE \2026-06-11T22:34:52+00:00 gpu=3 m=-0.4 s=1.6 gamma=0.25 =====
+===== START \2026-06-11T22:34:52+00:00 gpu=3 m=-0.4 s=1.8 gamma=0.25 =====
+checkpoint=runs/owt_t5_elftokenized_full_len1024_C1_to_1024_pow1_d768_l12_h12_gbs512_2x8gpu_50ep_lr3e3_ema0p9999_elfopt_not5_bottleneck128_unfixed_norm_stateprobadd_selfcond_ce_fast_20260609_230847/step_170000.pt
+use_ema=1
+step=170000
+decode_steps=64
+n=64 chunk_n=8 gpu=3
+out_base=/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260612
+[2026-06-11T22:45:27+00:00] infer step=170000 decode=64 -> /e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260612/owt_t5_not5_bottleneck128_norm_stateprobadd_selfcond_ce_fast_lr3e3_ema0p9999_logitnorm64_focused_ppl24_ent515_step170000_ema_dgamma0p25_tschedlogit_normal_mn0p4_s1p8_sc1p0_decode64_n64
+[2026-06-11T22:45:27+00:00] run decode=64 chunk=0 n=8 seed=123
+[2026-06-11T22:45:37+00:00] done decode=64 chunk=0
+[2026-06-11T22:45:37+00:00] run decode=64 chunk=1 n=8 seed=124
+[2026-06-11T22:45:47+00:00] done decode=64 chunk=1
+[2026-06-11T22:45:47+00:00] run decode=64 chunk=2 n=8 seed=125
+[2026-06-11T22:45:56+00:00] done decode=64 chunk=2
+[2026-06-11T22:45:56+00:00] run decode=64 chunk=3 n=8 seed=126
+[2026-06-11T22:46:06+00:00] done decode=64 chunk=3
+[2026-06-11T22:46:06+00:00] run decode=64 chunk=4 n=8 seed=127
+[2026-06-11T22:46:16+00:00] done decode=64 chunk=4
+[2026-06-11T22:46:16+00:00] run decode=64 chunk=5 n=8 seed=128
+[2026-06-11T22:46:25+00:00] done decode=64 chunk=5
+[2026-06-11T22:46:25+00:00] run decode=64 chunk=6 n=8 seed=129
+[2026-06-11T22:46:35+00:00] done decode=64 chunk=6
+[2026-06-11T22:46:35+00:00] run decode=64 chunk=7 n=8 seed=130
+[2026-06-11T22:46:45+00:00] done decode=64 chunk=7
+merged 64 samples -> /e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260612/owt_t5_not5_bottleneck128_norm_stateprobadd_selfcond_ce_fast_lr3e3_ema0p9999_logitnorm64_focused_ppl24_ent515_step170000_ema_dgamma0p25_tschedlogit_normal_mn0p4_s1p8_sc1p0_decode64_n64/sc1p0/samples64.txt
+loading scorer /e2e-data/evad-tech-vla/wanghan58/models/flowtext_scorers/gpt2-large-standard dtype=fp32 device=cuda
+run	kind	ppl	mean_entropy	distinct_1	distinct_2	top_token_mass	eos_rows	eos_total	ppl_tokens	t5_tokens	path
+sc1p0	raw_full	17.12205216748313	5.048381543880808	0.08074211955692533	0.43983155582002104	0.0353818925269293	63	63	63840	65542	/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260612/owt_t5_not5_bottleneck128_norm_stateprobadd_selfcond_ce_fast_lr3e3_ema0p9999_logitnorm64_focused_ppl24_ent515_step170000_ema_dgamma0p25_tschedlogit_normal_mn0p4_s1p8_sc1p0_decode64_n64/sc1p0
+sc1p0	pre_eos	19.704070943129636	5.0846337107330655	0.08349244922756466	0.454836673504813	0.0365940256584242	0	0	59468	63371	/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260612/owt_t5_not5_bottleneck128_norm_stateprobadd_selfcond_ce_fast_lr3e3_ema0p9999_logitnorm64_focused_ppl24_ent515_step170000_ema_dgamma0p25_tschedlogit_normal_mn0p4_s1p8_sc1p0_decode64_n64/sc1p0
+[2026-06-11T22:47:14+00:00] done
+===== DONE \2026-06-11T22:34:52+00:00 gpu=3 m=-0.4 s=1.8 gamma=0.25 =====
+===== START \2026-06-11T22:34:52+00:00 gpu=3 m=-0.4 s=2.0 gamma=0.25 =====
+checkpoint=runs/owt_t5_elftokenized_full_len1024_C1_to_1024_pow1_d768_l12_h12_gbs512_2x8gpu_50ep_lr3e3_ema0p9999_elfopt_not5_bottleneck128_unfixed_norm_stateprobadd_selfcond_ce_fast_20260609_230847/step_170000.pt
+use_ema=1
+step=170000
+decode_steps=64
+n=64 chunk_n=8 gpu=3
+out_base=/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260612
+[2026-06-11T22:47:14+00:00] infer step=170000 decode=64 -> /e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260612/owt_t5_not5_bottleneck128_norm_stateprobadd_selfcond_ce_fast_lr3e3_ema0p9999_logitnorm64_focused_ppl24_ent515_step170000_ema_dgamma0p25_tschedlogit_normal_mn0p4_s2p0_sc1p0_decode64_n64
+[2026-06-11T22:47:14+00:00] run decode=64 chunk=0 n=8 seed=123
+[2026-06-11T22:47:24+00:00] done decode=64 chunk=0
+[2026-06-11T22:47:24+00:00] run decode=64 chunk=1 n=8 seed=124
+[2026-06-11T22:47:34+00:00] done decode=64 chunk=1
+[2026-06-11T22:47:34+00:00] run decode=64 chunk=2 n=8 seed=125
+[2026-06-11T22:47:44+00:00] done decode=64 chunk=2
+[2026-06-11T22:47:44+00:00] run decode=64 chunk=3 n=8 seed=126
+[2026-06-11T22:47:53+00:00] done decode=64 chunk=3
+[2026-06-11T22:47:53+00:00] run decode=64 chunk=4 n=8 seed=127
+[2026-06-11T22:48:03+00:00] done decode=64 chunk=4
+[2026-06-11T22:48:03+00:00] run decode=64 chunk=5 n=8 seed=128
+[2026-06-11T22:48:13+00:00] done decode=64 chunk=5
+[2026-06-11T22:48:13+00:00] run decode=64 chunk=6 n=8 seed=129
+[2026-06-11T22:48:23+00:00] done decode=64 chunk=6
+[2026-06-11T22:48:23+00:00] run decode=64 chunk=7 n=8 seed=130
+[2026-06-11T22:48:32+00:00] done decode=64 chunk=7
+merged 64 samples -> /e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260612/owt_t5_not5_bottleneck128_norm_stateprobadd_selfcond_ce_fast_lr3e3_ema0p9999_logitnorm64_focused_ppl24_ent515_step170000_ema_dgamma0p25_tschedlogit_normal_mn0p4_s2p0_sc1p0_decode64_n64/sc1p0/samples64.txt
+loading scorer /e2e-data/evad-tech-vla/wanghan58/models/flowtext_scorers/gpt2-large-standard dtype=fp32 device=cuda
+run	kind	ppl	mean_entropy	distinct_1	distinct_2	top_token_mass	eos_rows	eos_total	ppl_tokens	t5_tokens	path
+sc1p0	raw_full	19.332869239573228	5.078073205362629	0.08395001449518608	0.45138698159846197	0.03645157844947283	63	63	63394	65539	/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260612/owt_t5_not5_bottleneck128_norm_stateprobadd_selfcond_ce_fast_lr3e3_ema0p9999_logitnorm64_focused_ppl24_ent515_step170000_ema_dgamma0p25_tschedlogit_normal_mn0p4_s2p0_sc1p0_decode64_n64/sc1p0
+sc1p0	pre_eos	22.574710721942342	5.115753742175942	0.08684738163274972	0.46698768550678876	0.037716486951579545	0	0	58973	63341	/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260612/owt_t5_not5_bottleneck128_norm_stateprobadd_selfcond_ce_fast_lr3e3_ema0p9999_logitnorm64_focused_ppl24_ent515_step170000_ema_dgamma0p25_tschedlogit_normal_mn0p4_s2p0_sc1p0_decode64_n64/sc1p0
+[2026-06-11T22:49:02+00:00] done
+===== DONE \2026-06-11T22:34:52+00:00 gpu=3 m=-0.4 s=2.0 gamma=0.25 =====
+===== START \2026-06-11T22:34:52+00:00 gpu=3 m=-0.3 s=1.4 gamma=0.25 =====
+checkpoint=runs/owt_t5_elftokenized_full_len1024_C1_to_1024_pow1_d768_l12_h12_gbs512_2x8gpu_50ep_lr3e3_ema0p9999_elfopt_not5_bottleneck128_unfixed_norm_stateprobadd_selfcond_ce_fast_20260609_230847/step_170000.pt
+use_ema=1
+step=170000
+decode_steps=64
+n=64 chunk_n=8 gpu=3
+out_base=/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260612
+[2026-06-11T22:49:02+00:00] infer step=170000 decode=64 -> /e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260612/owt_t5_not5_bottleneck128_norm_stateprobadd_selfcond_ce_fast_lr3e3_ema0p9999_logitnorm64_focused_ppl24_ent515_step170000_ema_dgamma0p25_tschedlogit_normal_mn0p3_s1p4_sc1p0_decode64_n64
+[2026-06-11T22:49:02+00:00] run decode=64 chunk=0 n=8 seed=123
+[2026-06-11T22:49:11+00:00] done decode=64 chunk=0
+[2026-06-11T22:49:11+00:00] run decode=64 chunk=1 n=8 seed=124
+[2026-06-11T22:49:21+00:00] done decode=64 chunk=1
+[2026-06-11T22:49:21+00:00] run decode=64 chunk=2 n=8 seed=125
+[2026-06-11T22:49:31+00:00] done decode=64 chunk=2
+[2026-06-11T22:49:31+00:00] run decode=64 chunk=3 n=8 seed=126
+[2026-06-11T22:49:41+00:00] done decode=64 chunk=3
+[2026-06-11T22:49:41+00:00] run decode=64 chunk=4 n=8 seed=127
+[2026-06-11T22:49:50+00:00] done decode=64 chunk=4
+[2026-06-11T22:49:50+00:00] run decode=64 chunk=5 n=8 seed=128
+[2026-06-11T22:50:00+00:00] done decode=64 chunk=5
+[2026-06-11T22:50:00+00:00] run decode=64 chunk=6 n=8 seed=129
+[2026-06-11T22:50:10+00:00] done decode=64 chunk=6
+[2026-06-11T22:50:10+00:00] run decode=64 chunk=7 n=8 seed=130
+[2026-06-11T22:50:20+00:00] done decode=64 chunk=7
+merged 64 samples -> /e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260612/owt_t5_not5_bottleneck128_norm_stateprobadd_selfcond_ce_fast_lr3e3_ema0p9999_logitnorm64_focused_ppl24_ent515_step170000_ema_dgamma0p25_tschedlogit_normal_mn0p3_s1p4_sc1p0_decode64_n64/sc1p0/samples64.txt
+loading scorer /e2e-data/evad-tech-vla/wanghan58/models/flowtext_scorers/gpt2-large-standard dtype=fp32 device=cuda
+run	kind	ppl	mean_entropy	distinct_1	distinct_2	top_token_mass	eos_rows	eos_total	ppl_tokens	t5_tokens	path
+sc1p0	raw_full	16.928129598265656	5.071954158306068	0.0861945144778058	0.4528299003728378	0.03430361372144549	62	62	62556	65445	/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260612/owt_t5_not5_bottleneck128_norm_stateprobadd_selfcond_ce_fast_lr3e3_ema0p9999_logitnorm64_focused_ppl24_ent515_step170000_ema_dgamma0p25_tschedlogit_normal_mn0p3_s1p4_sc1p0_decode64_n64/sc1p0
+sc1p0	pre_eos	19.28985262070039	5.103880944521719	0.08894075347326258	0.46729325679682077	0.03540283538075789	0	0	58467	63413	/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260612/owt_t5_not5_bottleneck128_norm_stateprobadd_selfcond_ce_fast_lr3e3_ema0p9999_logitnorm64_focused_ppl24_ent515_step170000_ema_dgamma0p25_tschedlogit_normal_mn0p3_s1p4_sc1p0_decode64_n64/sc1p0
+[2026-06-11T22:50:49+00:00] done
+===== DONE \2026-06-11T22:34:52+00:00 gpu=3 m=-0.3 s=1.4 gamma=0.25 =====
+===== START \2026-06-11T22:34:52+00:00 gpu=3 m=-0.3 s=1.6 gamma=0.25 =====
+checkpoint=runs/owt_t5_elftokenized_full_len1024_C1_to_1024_pow1_d768_l12_h12_gbs512_2x8gpu_50ep_lr3e3_ema0p9999_elfopt_not5_bottleneck128_unfixed_norm_stateprobadd_selfcond_ce_fast_20260609_230847/step_170000.pt
+use_ema=1
+step=170000
+decode_steps=64
+n=64 chunk_n=8 gpu=3
+out_base=/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260612
+[2026-06-11T22:50:49+00:00] infer step=170000 decode=64 -> /e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260612/owt_t5_not5_bottleneck128_norm_stateprobadd_selfcond_ce_fast_lr3e3_ema0p9999_logitnorm64_focused_ppl24_ent515_step170000_ema_dgamma0p25_tschedlogit_normal_mn0p3_s1p6_sc1p0_decode64_n64
+[2026-06-11T22:50:49+00:00] run decode=64 chunk=0 n=8 seed=123
+[2026-06-11T22:50:59+00:00] done decode=64 chunk=0
+[2026-06-11T22:50:59+00:00] run decode=64 chunk=1 n=8 seed=124
+[2026-06-11T22:51:08+00:00] done decode=64 chunk=1
+[2026-06-11T22:51:08+00:00] run decode=64 chunk=2 n=8 seed=125
+[2026-06-11T22:51:18+00:00] done decode=64 chunk=2
+[2026-06-11T22:51:18+00:00] run decode=64 chunk=3 n=8 seed=126
+[2026-06-11T22:51:28+00:00] done decode=64 chunk=3
+[2026-06-11T22:51:28+00:00] run decode=64 chunk=4 n=8 seed=127
+[2026-06-11T22:51:37+00:00] done decode=64 chunk=4
+[2026-06-11T22:51:37+00:00] run decode=64 chunk=5 n=8 seed=128
+[2026-06-11T22:51:47+00:00] done decode=64 chunk=5
+[2026-06-11T22:51:47+00:00] run decode=64 chunk=6 n=8 seed=129
+[2026-06-11T22:51:57+00:00] done decode=64 chunk=6
+[2026-06-11T22:51:57+00:00] run decode=64 chunk=7 n=8 seed=130
+[2026-06-11T22:52:07+00:00] done decode=64 chunk=7
+merged 64 samples -> /e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260612/owt_t5_not5_bottleneck128_norm_stateprobadd_selfcond_ce_fast_lr3e3_ema0p9999_logitnorm64_focused_ppl24_ent515_step170000_ema_dgamma0p25_tschedlogit_normal_mn0p3_s1p6_sc1p0_decode64_n64/sc1p0/samples64.txt
+loading scorer /e2e-data/evad-tech-vla/wanghan58/models/flowtext_scorers/gpt2-large-standard dtype=fp32 device=cuda
+run	kind	ppl	mean_entropy	distinct_1	distinct_2	top_token_mass	eos_rows	eos_total	ppl_tokens	t5_tokens	path
+sc1p0	raw_full	17.3935578124969	5.063727260360727	0.08130180585873696	0.43846553092752033	0.03590346364621655	64	64	63426	65509	/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260612/owt_t5_not5_bottleneck128_norm_stateprobadd_selfcond_ce_fast_lr3e3_ema0p9999_logitnorm64_focused_ppl24_ent515_step170000_ema_dgamma0p25_tschedlogit_normal_mn0p3_s1p6_sc1p0_decode64_n64/sc1p0
+sc1p0	pre_eos	19.776817910921572	5.090824696528666	0.08390980287105466	0.45255278915852504	0.03706213264839823	0	0	59306	63461	/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260612/owt_t5_not5_bottleneck128_norm_stateprobadd_selfcond_ce_fast_lr3e3_ema0p9999_logitnorm64_focused_ppl24_ent515_step170000_ema_dgamma0p25_tschedlogit_normal_mn0p3_s1p6_sc1p0_decode64_n64/sc1p0
+[2026-06-11T22:52:21+00:00] done
+===== DONE \2026-06-11T22:34:52+00:00 gpu=3 m=-0.3 s=1.6 gamma=0.25 =====
+===== START \2026-06-11T22:34:52+00:00 gpu=3 m=-0.3 s=1.8 gamma=0.25 =====
+checkpoint=runs/owt_t5_elftokenized_full_len1024_C1_to_1024_pow1_d768_l12_h12_gbs512_2x8gpu_50ep_lr3e3_ema0p9999_elfopt_not5_bottleneck128_unfixed_norm_stateprobadd_selfcond_ce_fast_20260609_230847/step_170000.pt
+use_ema=1
+step=170000
+decode_steps=64
+n=64 chunk_n=8 gpu=3
+out_base=/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260612
+[2026-06-11T22:52:21+00:00] infer step=170000 decode=64 -> /e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260612/owt_t5_not5_bottleneck128_norm_stateprobadd_selfcond_ce_fast_lr3e3_ema0p9999_logitnorm64_focused_ppl24_ent515_step170000_ema_dgamma0p25_tschedlogit_normal_mn0p3_s1p8_sc1p0_decode64_n64
+[2026-06-11T22:52:21+00:00] run decode=64 chunk=0 n=8 seed=123
+[2026-06-11T22:52:31+00:00] done decode=64 chunk=0
+[2026-06-11T22:52:31+00:00] run decode=64 chunk=1 n=8 seed=124
+[2026-06-11T22:52:40+00:00] done decode=64 chunk=1
+[2026-06-11T22:52:40+00:00] run decode=64 chunk=2 n=8 seed=125
+[2026-06-11T22:52:50+00:00] done decode=64 chunk=2
+[2026-06-11T22:52:50+00:00] run decode=64 chunk=3 n=8 seed=126
+[2026-06-11T22:53:00+00:00] done decode=64 chunk=3
+[2026-06-11T22:53:00+00:00] run decode=64 chunk=4 n=8 seed=127
+[2026-06-11T22:53:09+00:00] done decode=64 chunk=4
+[2026-06-11T22:53:09+00:00] run decode=64 chunk=5 n=8 seed=128
+[2026-06-11T22:53:19+00:00] done decode=64 chunk=5
+[2026-06-11T22:53:19+00:00] run decode=64 chunk=6 n=8 seed=129
+[2026-06-11T22:53:29+00:00] done decode=64 chunk=6
+[2026-06-11T22:53:29+00:00] run decode=64 chunk=7 n=8 seed=130
+[2026-06-11T22:53:39+00:00] done decode=64 chunk=7
+merged 64 samples -> /e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260612/owt_t5_not5_bottleneck128_norm_stateprobadd_selfcond_ce_fast_lr3e3_ema0p9999_logitnorm64_focused_ppl24_ent515_step170000_ema_dgamma0p25_tschedlogit_normal_mn0p3_s1p8_sc1p0_decode64_n64/sc1p0/samples64.txt
+loading scorer /e2e-data/evad-tech-vla/wanghan58/models/flowtext_scorers/gpt2-large-standard dtype=fp32 device=cuda
+run	kind	ppl	mean_entropy	distinct_1	distinct_2	top_token_mass	eos_rows	eos_total	ppl_tokens	t5_tokens	path
+sc1p0	raw_full	17.7391049377987	5.071205544786745	0.08228292385167099	0.4488547055502144	0.035754616206317716	64	64	63672	65530	/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260612/owt_t5_not5_bottleneck128_norm_stateprobadd_selfcond_ce_fast_lr3e3_ema0p9999_logitnorm64_focused_ppl24_ent515_step170000_ema_dgamma0p25_tschedlogit_normal_mn0p3_s1p8_sc1p0_decode64_n64/sc1p0
+sc1p0	pre_eos	20.245708500544218	5.104042020201639	0.08494044242768009	0.4633746671498574	0.03691624125543581	0	0	59522	63468	/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260612/owt_t5_not5_bottleneck128_norm_stateprobadd_selfcond_ce_fast_lr3e3_ema0p9999_logitnorm64_focused_ppl24_ent515_step170000_ema_dgamma0p25_tschedlogit_normal_mn0p3_s1p8_sc1p0_decode64_n64/sc1p0
+[2026-06-11T22:53:53+00:00] done
+===== DONE \2026-06-11T22:34:52+00:00 gpu=3 m=-0.3 s=1.8 gamma=0.25 =====
+===== START \2026-06-11T22:34:52+00:00 gpu=3 m=-0.3 s=2.0 gamma=0.25 =====
+checkpoint=runs/owt_t5_elftokenized_full_len1024_C1_to_1024_pow1_d768_l12_h12_gbs512_2x8gpu_50ep_lr3e3_ema0p9999_elfopt_not5_bottleneck128_unfixed_norm_stateprobadd_selfcond_ce_fast_20260609_230847/step_170000.pt
+use_ema=1
+step=170000
+decode_steps=64
+n=64 chunk_n=8 gpu=3
+out_base=/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260612
+[2026-06-11T22:53:53+00:00] infer step=170000 decode=64 -> /e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260612/owt_t5_not5_bottleneck128_norm_stateprobadd_selfcond_ce_fast_lr3e3_ema0p9999_logitnorm64_focused_ppl24_ent515_step170000_ema_dgamma0p25_tschedlogit_normal_mn0p3_s2p0_sc1p0_decode64_n64
+[2026-06-11T22:53:53+00:00] run decode=64 chunk=0 n=8 seed=123
+[2026-06-11T22:54:03+00:00] done decode=64 chunk=0
+[2026-06-11T22:54:03+00:00] run decode=64 chunk=1 n=8 seed=124