Add files using upload-large-folder tool

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

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

LTA_openwebtext_dualt/mini_owt_logdirichlet/.venv_qwen35_uv/lib/python3.12/site-packages/transformers/models/granite_speech/configuration_granite_speech.py

@@ -0,0 +1,150 @@
+# Copyright 2025 The HuggingFace Inc. team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Config class for Granite Speech."""
+
+from huggingface_hub.dataclasses import strict
+
+from ...configuration_utils import PreTrainedConfig
+from ...utils import auto_docstring
+from ..auto import CONFIG_MAPPING, AutoConfig
+
+
+@auto_docstring(checkpoint="ibm-granite/granite-speech-3.3-2b")
+@strict
+class GraniteSpeechEncoderConfig(PreTrainedConfig):
+    r"""
+    feedforward_mult (`int`, *optional*, defaults to 4):
+        Multiplier for the up/down projections in the encoder's feedforward layers;
+        The projections will have intermediate dim of size `hidden_dim * feedforward_mult`.
+    output_dim (`int`, *optional*, defaults to 42):
+        Intermediate dimension of the feedforward projections in the conformer
+        to be added to every other encoder block's output.
+    context_size (`int`, *optional*, defaults to 200):
+        Context size to be used in conformer attention.
+    max_pos_emb (`int`, *optional*, defaults to 512):
+        Max pos embeds to be used in attention (shaw's relative positional encoding).
+    conv_expansion_factor (`int`, *optional*, defaults to 2):
+        Intermediate dimension to be used in conformer convolutions.
+
+    Example:
+
+    ```python
+    >>> from transformers import GraniteSpeechEncoderConfig, GraniteSpeechCTCEncoder
+
+    >>> # Initializing a GraniteSpeechEncoderConfig
+    >>> configuration = GraniteSpeechEncoderConfig()
+
+    >>> # Initializing a GraniteSpeechCTCEncoder (with random weights)
+    >>> model = GraniteSpeechCTCEncoder(configuration)
+
+    >>> # Accessing the model configuration
+    >>> configuration = model.config
+    ```"""
+
+    model_type = "granite_speech_encoder"
+    attribute_map = {
+        "hidden_size": "hidden_dim",
+        "num_hidden_layers": "num_layers",
+        "num_attention_heads": "num_heads",
+        "num_mel_bins": "input_dim",
+    }
+
+    input_dim: int = 160
+    num_layers: int = 10
+    hidden_dim: int = 1024
+    feedforward_mult: int = 4
+    num_heads: int = 8
+    dim_head: int | None = None
+    output_dim: int = 42
+    context_size: int = 200
+    max_pos_emb: int = 512
+    dropout: float | int = 0.1
+    conv_kernel_size: int = 15
+    conv_expansion_factor: int = 2
+
+    def __post_init__(self, **kwargs):
+        super().__post_init__(**kwargs)
+        if self.dim_head is None:
+            self.dim_head = self.hidden_dim // self.num_heads
+
+
+@auto_docstring(checkpoint="ibm-granite/granite-speech-3.3-2b")
+@strict
+class GraniteSpeechConfig(PreTrainedConfig):
+    r"""
+    projector_config (`Union[AutoConfig, dict]`, *optional*, defaults to `Blip2QFormerConfig`):
+        The config object or dictionary of the audio projector.
+    has_lora_adapter (`bool`, *optional*, defaults to `True`):
+        Indicates whether or not the model has a lora adapter that should only
+        be activate when processing audio inputs.
+    downsample_rate (`int`, *optional*, defaults to 5):
+        Downsample rate for the audio feature extractor.
+    window_size (`int`, *optional*, defaults to 15):
+        Window size for the audio feature projector.
+
+    Example:
+
+    ```python
+    >>> from transformers import GraniteSpeechConfig, GraniteSpeechForConditionalGeneration
+
+    >>> # Initializing a GraniteSpeechConfig
+    >>> configuration = GraniteSpeechConfig()
+
+    >>> # Initializing a GraniteSpeechForConditionalGeneration (with random weights)
+    >>> model = GraniteSpeechForConditionalGeneration(configuration)
+
+    >>> # Accessing the model configuration
+    >>> configuration = model.config
+    ```"""
+
+    model_type = "granite_speech"
+    attribute_map = {
+        "audio_token_id": "audio_token_index",
+    }
+    sub_configs = {
+        "text_config": AutoConfig,
+        "encoder_config": GraniteSpeechEncoderConfig,
+        "projector_config": AutoConfig,
+    }
+
+    text_config: dict | PreTrainedConfig | None = None
+    encoder_config: dict | PreTrainedConfig | None = None
+    projector_config: dict | PreTrainedConfig | None = None
+    audio_token_index: int = 49155
+    initializer_range: float = 0.02
+    has_lora_adapter: bool = True
+    downsample_rate: int = 5
+    window_size: int = 15
+
+    def __post_init__(self, **kwargs):
+        if isinstance(self.text_config, dict):
+            self.text_config["model_type"] = self.text_config.get("model_type", "granite")
+            self.text_config = CONFIG_MAPPING[self.text_config["model_type"]](**self.text_config)
+        elif self.text_config is None:
+            self.text_config = CONFIG_MAPPING["granite"]()
+
+        if isinstance(self.projector_config, dict):
+            self.projector_config["model_type"] = self.projector_config.get("model_type", "blip_2_qformer")
+            self.projector_config = CONFIG_MAPPING[self.projector_config["model_type"]](**self.projector_config)
+        elif self.projector_config is None:
+            self.projector_config = CONFIG_MAPPING["blip_2_qformer"]()
+
+        if not isinstance(self.encoder_config, GraniteSpeechEncoderConfig):
+            self.encoder_config = {} if self.encoder_config is None else self.encoder_config
+            self.encoder_config = GraniteSpeechEncoderConfig(**self.encoder_config)
+
+        super().__post_init__(**kwargs)
+
+
+__all__ = ["GraniteSpeechEncoderConfig", "GraniteSpeechConfig"]

LTA_openwebtext_dualt/mini_owt_logdirichlet/.venv_qwen35_uv/lib/python3.12/site-packages/transformers/models/granite_speech/feature_extraction_granite_speech.py

@@ -0,0 +1,184 @@
+# Copyright 2025 The HuggingFace Inc. team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Feature extractor class for Granite Speech."""
+
+import math
+from collections.abc import Sequence
+
+import numpy as np
+
+from ...feature_extraction_utils import BatchFeature, FeatureExtractionMixin
+from ...tokenization_utils_base import AudioInput
+from ...utils import is_torch_available, is_torchaudio_available, logging
+from ...utils.import_utils import requires_backends
+
+
+logger = logging.get_logger(__name__)
+
+if is_torch_available():
+    import torch
+
+if is_torchaudio_available():
+    import torchaudio
+
+
+class GraniteSpeechFeatureExtractor(FeatureExtractionMixin):
+    model_input_names = ["input_features"]
+
+    def __init__(
+        self,
+        sampling_rate: int = 16000,
+        n_fft: int = 512,
+        win_length: int = 400,
+        hop_length: int = 160,
+        n_mels: int = 80,
+        projector_window_size: int = 15,
+        projector_downsample_rate: int = 5,
+        **kwargs,
+    ):
+        super().__init__(**kwargs)
+        self.sampling_rate = sampling_rate
+        self.melspec_kwargs = {
+            "sample_rate": sampling_rate,
+            "n_fft": n_fft,
+            "win_length": win_length,
+            "hop_length": hop_length,
+            "n_mels": n_mels,
+        }
+        requires_backends(self, ["torchaudio"])
+        self.mel_filters = torchaudio.transforms.MelSpectrogram(**self.melspec_kwargs)
+        self.projector_window_size = projector_window_size
+        self.projector_downsample_rate = projector_downsample_rate
+
+    def __call__(
+        self,
+        audios: AudioInput,
+        device: str | None = "cpu",
+    ) -> BatchFeature:
+        requires_backends(self, ["torchaudio"])
+
+        speech_inputs = {}
+        batched_audio, audio_lengths = self._get_audios_and_audio_lengths(audios)
+        speech_inputs["input_features"] = self._extract_mel_spectrograms(
+            batched_audio,
+            device=device,
+        )
+        audio_embed_sizes = self._get_num_audio_features(audio_lengths)
+        speech_inputs["audio_embed_sizes"] = audio_embed_sizes
+        # TODO (@alex-jw-brooks): Currently input_features_mask is not
+        # a great name, because input_features and input_features_mask
+        # have different shapes (before/after the projector).
+        #
+        # We should align this with other multimodal models, e.g,. llava
+        # and qwen2audio and refactor this to ensure input_feature_mask
+        # has the same dimensionality as input_features, or compute it in
+        # the model based on the audio embedding sizes (since we do not
+        # have an attention mask for the audio features to infer padding from).
+        speech_inputs["input_features_mask"] = torch.arange(max(audio_embed_sizes)).view(1, -1) < torch.tensor(
+            audio_embed_sizes
+        ).view(-1, 1)
+        return BatchFeature(data=speech_inputs)
+
+    def _extract_mel_spectrograms(self, audio: "torch.Tensor", device="cpu"):
+        """
+        Compute the Mel features to be passed to the conformer encoder.
+        """
+        requires_backends(self, ["torchaudio"])
+        if device is not None:
+            melspec = self.mel_filters.to(device)
+            audio = audio.to(device)
+        else:
+            melspec = self.mel_filters
+
+        bsz = audio.shape[0]
+        with torch.no_grad():
+            # Compute mel features
+            mel = melspec(audio.float())
+            logmel = mel.transpose(-1, -2).clip_(min=1e-10).log10_()
+            mx = logmel.amax(dim=(-2, -1), keepdim=True)
+            logmel = torch.maximum(logmel, mx - 8.0).div_(4).add_(1)
+            # remove last frame if odd
+            if logmel.shape[1] % 2 == 1:
+                logmel = logmel[:, :-1]
+
+            # stacking and skipping by 2
+            audio = logmel.reshape(bsz, -1, 2 * logmel.shape[-1])
+
+        return audio
+
+    def _get_num_audio_features(self, audio_lengths: Sequence[int]) -> Sequence[int]:
+        """
+        Gets the (variable length) number of features (i.e., projector output) for the sequences
+        being considered.
+
+        Args:
+            audio_lengths (`Sequence[int]`):
+                Sequence of one or more raw audio lengths.
+        """
+        hop_length = self.melspec_kwargs["hop_length"]
+        effective_window_size = self.projector_window_size // self.projector_downsample_rate
+
+        projector_lengths = []
+        for raw_length in audio_lengths:
+            # mel sequence length computation
+            mel_length = raw_length // hop_length + 1
+            # encoder frame takes two mel features
+            encoder_length = mel_length // 2
+            nblocks = math.ceil(encoder_length / self.projector_window_size)
+            # projector output length
+            projector_length = nblocks * effective_window_size
+            projector_lengths.append(projector_length)
+
+        return projector_lengths
+
+    def _get_audios_and_audio_lengths(self, audios: AudioInput) -> Sequence["torch.Tensor", Sequence[int]]:
+        """
+        Coerces audio inputs to torch tensors and extracts audio lengths prior to stacking.
+
+        Args:
+            audios (`AudioInput`):
+                Audio sequence, numpy array, or torch tensor.
+        """
+        requires_backends(self, ["torch"])
+
+        # Coerce to PyTorch tensors if we have numpy arrays, since
+        # currently we have a dependency on torch/torchaudio anyway
+        if isinstance(audios, np.ndarray):
+            audios = torch.from_numpy(audios)
+        elif isinstance(audios, Sequence) and isinstance(audios[0], np.ndarray):
+            audios = [torch.from_numpy(arr) for arr in audios]
+
+        if isinstance(audios, torch.Tensor):
+            if audios.ndim == 1:
+                audios = audios.unsqueeze(0)
+            if not torch.is_floating_point(audios):
+                raise ValueError("Invalid audio provided. Audio should be a floating point between 0 and 1")
+
+            if audios.shape[0] > 1:
+                logger.warning("Audio samples are already collated; assuming they all have the same length")
+            lengths = [audios.shape[-1]] * audios.shape[0]
+            return audios, lengths
+
+        elif isinstance(audios, Sequence) and isinstance(audios[0], torch.Tensor):
+            if not torch.is_floating_point(audios[0]):
+                raise ValueError("Invalid audio provided. Audio should be a floating point between 0 and 1")
+            lengths = [audio.shape[-1] for audio in audios]
+            audios = [audio.squeeze(0) for audio in audios]
+            audios = torch.nn.utils.rnn.pad_sequence(audios, batch_first=True, padding_value=0.0)
+            return audios, lengths
+
+        raise TypeError("Invalid audio provided. Audio should be a one or more torch tensors or numpy arrays")
+
+
+__all__ = ["GraniteSpeechFeatureExtractor"]

LTA_openwebtext_dualt/mini_owt_logdirichlet/.venv_qwen35_uv/lib/python3.12/site-packages/transformers/models/granite_speech/modeling_granite_speech.py

@@ -0,0 +1,601 @@
+# Copyright 2025 The HuggingFace Inc. team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import math
+from dataclasses import dataclass
+
+import torch
+import torch.nn.functional as F
+from torch import nn
+
+from ... import initialization as init
+from ...cache_utils import Cache
+from ...generation import GenerationMixin
+from ...modeling_outputs import BaseModelOutputWithPooling, ModelOutput
+from ...modeling_utils import PreTrainedModel
+from ...processing_utils import Unpack
+from ...utils import (
+    TransformersKwargs,
+    auto_docstring,
+    can_return_tuple,
+    is_peft_available,
+    logging,
+    torch_compilable_check,
+)
+from ...utils.generic import merge_with_config_defaults
+from ...utils.output_capturing import capture_outputs
+from ..auto import AutoModel, AutoModelForCausalLM
+from .configuration_granite_speech import GraniteSpeechConfig, GraniteSpeechEncoderConfig
+
+
+logger = logging.get_logger(__name__)
+
+
+@auto_docstring(
+    custom_intro="""
+    Base class for LlavaNext causal language model (or autoregressive) outputs.
+    """
+)
+@dataclass
+class GraniteSpeechCausalLMOutputWithPast(ModelOutput):
+    r"""
+    loss (`torch.FloatTensor` of shape `(1,)`, *optional*, returned when `labels` is provided):
+        Language modeling loss (for next-token prediction).
+    logits (`torch.FloatTensor` of shape `(batch_size, sequence_length, config.vocab_size)`):
+        Prediction scores of the language modeling head (scores for each vocabulary token before SoftMax).
+    past_key_values (`Cache`, *optional*, returned when `use_cache=True` is passed or when `config.use_cache=True`):
+        It is a [`~cache_utils.Cache`] instance. For more details, see our [kv cache guide](https://huggingface.co/docs/transformers/en/kv_cache).
+
+        Contains pre-computed hidden-states (key and values in the self-attention blocks) that can be used (see
+        `past_key_values` input) to speed up sequential decoding.
+    """
+
+    loss: torch.FloatTensor | None = None
+    logits: torch.FloatTensor | None = None
+    past_key_values: Cache | None = None
+    hidden_states: tuple[torch.FloatTensor] | None = None
+    attentions: tuple[torch.FloatTensor] | None = None
+
+
+### Projector
+class GraniteSpeechEncoderProjector(nn.Module):
+    def __init__(self, config: GraniteSpeechConfig):
+        super().__init__()
+        self.hidden_size = config.projector_config.hidden_size
+        self.downsample_rate = config.downsample_rate
+        self.window_size = config.window_size
+        self.num_queries = config.window_size // config.downsample_rate
+
+        self.query = nn.Parameter(torch.zeros(1, self.num_queries, config.projector_config.hidden_size))
+        self.query.data.normal_(mean=0.0, std=1.0)
+
+        # By default, this will be a blip_2_qformer config
+        self.qformer = AutoModel.from_config(config.projector_config)
+        self.linear = nn.Linear(config.projector_config.hidden_size, config.text_config.hidden_size)
+
+    def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+        batch_size, seq_len, dim = hidden_states.size()
+        nblocks = math.ceil(seq_len / self.window_size)
+        pad = nblocks * self.window_size - seq_len
+        hidden_states = nn.functional.pad(hidden_states, (0, 0, 0, pad), "constant", 0)
+        hidden_states = hidden_states.view(batch_size * nblocks, self.window_size, dim)
+
+        query_output = self.qformer(
+            query_embeds=self.query,
+            encoder_hidden_states=hidden_states,
+            encoder_attention_mask=None,
+            return_dict=True,
+        )
+        query_proj = self.linear(
+            query_output.last_hidden_state.view(batch_size, nblocks * self.window_size // self.downsample_rate, -1)
+        )
+        return query_proj
+
+
+### Encoder - conformer is adapted from: https://github.com/lucidrains/conformer.git
+class GraniteSpeechConformerFeedForward(nn.Module):
+    """Feedforward module for conformer encoder blocks."""
+
+    def __init__(self, config: GraniteSpeechEncoderConfig):
+        super().__init__()
+        self.pre_norm = nn.LayerNorm(config.hidden_dim)
+        self.up_proj = nn.Linear(config.hidden_dim, config.hidden_dim * config.feedforward_mult)
+        self.silu = nn.SiLU()
+        self.dropout = nn.Dropout(config.dropout)
+        self.down_proj = nn.Linear(config.hidden_dim * config.feedforward_mult, config.hidden_dim)
+
+    def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+        hidden_states = self.pre_norm(hidden_states)
+        hidden_states = self.up_proj(hidden_states)
+        hidden_states = self.dropout(self.silu(hidden_states))
+        hidden_states = self.down_proj(hidden_states)
+        hidden_states = self.dropout(hidden_states)
+        return hidden_states
+
+
+class GraniteSpeechConformerAttention(nn.Module):
+    """Attention for conformer blocks using Shaw's relative positional embeddings.
+    See the following [paper](https://huggingface.co/papers/1803.02155) for more details.
+    """
+
+    def __init__(self, config: GraniteSpeechEncoderConfig):
+        super().__init__()
+
+        inner_dim = config.dim_head * config.num_heads
+        self.max_pos_emb = config.max_pos_emb
+        self.context_size = config.context_size
+        self.num_heads = config.num_heads
+        self.dim_head = config.dim_head
+        self.scale = self.dim_head**-0.5
+        self.pre_norm = nn.LayerNorm(config.hidden_dim)
+        self.to_q = nn.Linear(config.hidden_dim, inner_dim, bias=False)
+        self.to_kv = nn.Linear(config.hidden_dim, inner_dim * 2, bias=False)
+        self.to_out = nn.Linear(inner_dim, config.hidden_dim)
+        self.rel_pos_emb = nn.Embedding(2 * self.max_pos_emb + 1, self.dim_head)
+        self.dropout = nn.Dropout(config.dropout)
+
+        if self.context_size <= 0 or self.context_size > self.max_pos_emb:
+            raise ValueError("Context size is either less than 0 or exceeds the max_pos_emb")
+
+    def forward(self, hidden_states: torch.Tensor, attention_dists: torch.Tensor) -> torch.Tensor:
+        hidden_states = self.pre_norm(hidden_states)
+        bsz, num_features, _ = hidden_states.shape
+
+        num_blocks = math.ceil(num_features / self.context_size)
+        remainder = num_features % self.context_size
+        if remainder > 0:
+            # right padding to reach block size
+            hidden_states = torch.nn.functional.pad(hidden_states, (0, 0, 0, self.context_size - remainder))
+
+        query_states = self.to_q(hidden_states)
+        key_states, value_states = self.to_kv(hidden_states).chunk(2, dim=-1)
+
+        query_states = query_states.reshape(bsz, num_blocks, self.context_size, self.num_heads, -1).transpose(2, 3)
+        key_states = key_states.reshape(bsz, num_blocks, self.context_size, self.num_heads, -1).transpose(2, 3)
+        value_states = value_states.reshape(bsz, num_blocks, self.context_size, self.num_heads, -1).transpose(2, 3)
+
+        # shaw's relative positional embedding
+        rel_pos_emb = self.rel_pos_emb(attention_dists)
+        # alternative computation of `pos_attn` - for readability
+        # rel_pos_emb_expanded = rel_pos_emb.view([1, 1, 1] + list(rel_pos_emb.shape))
+        # pos_attn = torch.sum(query_states.unsqueeze(-2) * rel_pos_emb_expanded, dim=-1) * self.scale
+        # einsum implementation of pos_attn - gives x30 speedup over the alternative
+        # TODO (@avihu111) find a fast alternative to einsum
+        pos_attn = torch.einsum("b m h c d, c r d -> b m h c r", query_states, rel_pos_emb) * self.scale
+
+        if remainder > 0:
+            # masked attention in the extended block
+            mask = torch.ones(self.context_size, self.context_size, dtype=bool, device=hidden_states.device)
+            mask[:remainder, :remainder] = 0
+            mask_value = -torch.finfo(pos_attn.dtype).max
+            pos_attn[:, -1, :].masked_fill_(mask, mask_value)
+
+        with torch.nn.attention.sdpa_kernel(torch.nn.attention.SDPBackend.MATH):
+            out = F.scaled_dot_product_attention(
+                query_states, key_states, value_states, attn_mask=pos_attn, scale=self.scale
+            )
+        out = out.transpose(2, 3).reshape(bsz, hidden_states.shape[1], -1)
+        out = self.to_out(out[:, :num_features, :])
+        return self.dropout(out)
+
+
+class GraniteSpeechConformerDepthWiseConv1d(nn.Module):
+    """Wrapper for padded 1D pointwise convolution."""
+
+    def __init__(self, chan_in: int, chan_out: int, kernel_size: int):
+        super().__init__()
+        # Padding for the 1D conv is symmetric or close (i.e., offset by one).
+        pad = kernel_size // 2
+        pad_offset = (kernel_size + 1) % 2
+        self.padding = (pad, pad - pad_offset)
+
+        self.conv = nn.Conv1d(chan_in, chan_out, kernel_size, groups=chan_in, bias=False)
+
+    def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+        hidden_states = F.pad(hidden_states, self.padding)
+        return self.conv(hidden_states)
+
+
+class GraniteSpeechConformerConvModule(nn.Module):
+    """Conformer conv module consisting of several 1D/depthwise 1D convolutional layers."""
+
+    def __init__(self, config: GraniteSpeechEncoderConfig):
+        super().__init__()
+        inner_dim = config.hidden_dim * config.conv_expansion_factor
+
+        self.norm = nn.LayerNorm(config.hidden_dim)
+        self.up_conv = nn.Conv1d(config.hidden_dim, inner_dim * 2, 1)
+        self.glu = nn.GLU(dim=1)
+        self.depth_conv = GraniteSpeechConformerDepthWiseConv1d(
+            inner_dim,
+            inner_dim,
+            kernel_size=config.conv_kernel_size,
+        )
+        self.silu = nn.SiLU()
+        self.batch_norm = nn.BatchNorm1d(inner_dim)
+        self.down_conv = nn.Conv1d(inner_dim, config.hidden_dim, 1)
+        self.dropout = nn.Dropout(config.dropout)
+
+    def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+        hidden_states = self.norm(hidden_states)
+        hidden_states = self.up_conv(hidden_states.permute(0, 2, 1))
+        hidden_states = self.glu(hidden_states)
+        hidden_states = self.depth_conv(hidden_states)
+        hidden_states = self.silu(self.batch_norm(hidden_states))
+        hidden_states = self.down_conv(hidden_states).permute(0, 2, 1)
+        hidden_states = self.dropout(hidden_states)
+        return hidden_states
+
+
+class GraniteSpeechConformerBlock(nn.Module):
+    """Conformer block, consisting largely of linear layers, attention, and convolutional layers."""
+
+    def __init__(self, config: GraniteSpeechEncoderConfig):
+        super().__init__()
+        self.ff1 = GraniteSpeechConformerFeedForward(config)
+        self.attn = GraniteSpeechConformerAttention(config)
+        self.conv = GraniteSpeechConformerConvModule(config)
+        self.ff2 = GraniteSpeechConformerFeedForward(config)
+        self.post_norm = nn.LayerNorm(config.hidden_dim)
+
+    def forward(self, hidden_states: torch.Tensor, attention_dists: torch.Tensor) -> torch.Tensor:
+        hidden_states = 0.5 * self.ff1(hidden_states) + hidden_states
+        hidden_states = self.attn(hidden_states, attention_dists=attention_dists) + hidden_states
+        hidden_states = self.conv(hidden_states) + hidden_states
+        hidden_states = 0.5 * self.ff2(hidden_states) + hidden_states
+        hidden_states = self.post_norm(hidden_states)
+        return hidden_states
+
+
+@auto_docstring
+class GraniteSpeechPreTrainedModel(PreTrainedModel):
+    config: GraniteSpeechConfig
+    input_modalities = ("audio", "text")
+
+    _supports_flash_attn = False  # `blip_2_qformer` dependency does not allow for this
+    _supports_sdpa = True
+
+    @torch.no_grad()
+    def _init_weights(self, module: nn.Module):
+        """Initialize the weights."""
+        super()._init_weights(module)
+        if isinstance(module, GraniteSpeechEncoderProjector):
+            init.normal_(module.query)
+        elif isinstance(module, GraniteSpeechCTCEncoder):
+            context_size = module.config.context_size
+            seq = torch.arange(context_size)
+            relpos_dist = seq.view(-1, 1) - seq.view(1, -1)
+            attention_dists = torch.clamp(relpos_dist, -context_size, context_size) + module.config.max_pos_emb
+            init.copy_(module.attention_dists, attention_dists)
+
+
+class GraniteSpeechCTCEncoder(GraniteSpeechPreTrainedModel):
+    config: GraniteSpeechEncoderConfig
+    input_modalities = "audio"
+    _can_record_outputs = {
+        "hidden_states": GraniteSpeechConformerBlock,
+        "attentions": GraniteSpeechConformerAttention,
+    }
+
+    def __init__(self, config: GraniteSpeechEncoderConfig):
+        super().__init__(config)
+
+        # Precompute clamped relative positional encoding distances
+        seq = torch.arange(config.context_size)
+        relpos_dist = seq.view(-1, 1) - seq.view(1, -1)
+        attention_dists = torch.clamp(relpos_dist, -config.context_size, config.context_size) + config.max_pos_emb
+        self.register_buffer("attention_dists", attention_dists, persistent=False)
+        self.input_linear = nn.Linear(config.input_dim, config.hidden_dim, bias=True)
+        self.layers = nn.ModuleList([GraniteSpeechConformerBlock(config) for _ in range(config.num_layers)])
+
+        self.out = nn.Linear(config.hidden_dim, config.output_dim, bias=True)
+        self.out_mid = nn.Linear(config.output_dim, config.hidden_dim, bias=True)
+        self.num_layers = config.num_layers
+        self.post_init()
+
+    @merge_with_config_defaults
+    @capture_outputs
+    def forward(
+        self, hidden_states: torch.Tensor, **kwargs: Unpack[TransformersKwargs]
+    ) -> tuple | BaseModelOutputWithPooling:
+        hidden_states = self.input_linear(hidden_states)
+        for idx, layer in enumerate(self.layers, start=1):
+            hidden_states = layer(hidden_states, attention_dists=self.attention_dists)
+
+            if idx == self.num_layers // 2:
+                hidden_states_mid = hidden_states.clone()
+                hidden_states_mid = self.out(hidden_states_mid)
+                hidden_states += self.out_mid(nn.Softmax(dim=-1)(hidden_states_mid))
+
+        return BaseModelOutputWithPooling(last_hidden_state=hidden_states)
+
+
+@auto_docstring(
+    custom_intro="""
+    The Granite Speech model, which consists of an audio encoder, projector, and language model.
+    """
+)
+class GraniteSpeechForConditionalGeneration(GraniteSpeechPreTrainedModel, GenerationMixin):
+    _supports_attention_backend = True
+
+    def __init__(self, config: GraniteSpeechConfig):
+        super().__init__(config)
+        # NOTE: It doesn't matter when we initialize from config, but we should be careful
+        # to make sure this does not pick up the adapter_config if in the future we use
+        # from_pretrained or something similar, since that should be set by the composite
+        # model; don't need to consider it twice
+        self.language_model = AutoModelForCausalLM.from_config(config.text_config)
+
+        self.encoder = GraniteSpeechCTCEncoder(config.encoder_config)
+        self.projector = GraniteSpeechEncoderProjector(config)
+
+        if config.has_lora_adapter and not is_peft_available():
+            logger.warning(
+                "Config indicates that a lora adapter should be present, but "
+                "peft is not installed; this will cause the model to perform "
+                "incorrectly when audio inputs are provided. Please install "
+                "peft and reload the model!"
+            )
+
+        self.post_init()
+
+    def set_decoder(self, decoder):
+        self.language_model.set_decoder(decoder)
+
+    def get_decoder(self):
+        return self.language_model.get_decoder()
+
+    def set_output_embeddings(self, new_embeddings):
+        self.language_model.set_output_embeddings(new_embeddings)
+
+    def get_output_embeddings(self):
+        return self.language_model.get_output_embeddings()
+
+    @can_return_tuple
+    @auto_docstring
+    def get_audio_features(
+        self, input_features: torch.Tensor, **kwargs: Unpack[TransformersKwargs]
+    ) -> tuple | BaseModelOutputWithPooling:
+        audio_outputs = self.encoder(input_features, return_dict=True, **kwargs)
+        projected_embeds = self.projector(audio_outputs.last_hidden_state)
+        audio_outputs.pooler_output = projected_embeds
+
+        return audio_outputs
+
+    @auto_docstring
+    def forward(
+        self,
+        input_ids: torch.LongTensor | None = None,
+        input_features: torch.FloatTensor | None = None,
+        input_features_mask: torch.Tensor | None = None,
+        attention_mask: torch.Tensor | None = None,
+        position_ids: torch.LongTensor | None = None,
+        past_key_values: Cache | None = None,
+        inputs_embeds: torch.FloatTensor | None = None,
+        labels: torch.LongTensor | None = None,
+        use_cache: bool | None = None,
+        output_attentions: bool | None = None,
+        output_hidden_states: bool | None = None,
+        return_dict: bool | None = None,
+        logits_to_keep: int | torch.Tensor = 0,
+        **lm_kwargs,
+    ) -> tuple[torch.Tensor] | GraniteSpeechCausalLMOutputWithPast:
+        r"""
+        input_features_mask (`torch.Tensor`, *optional*):
+            Mask to be applied to audio features prior to scattering into the language embeddings.
+        labels (`torch.LongTensor` of shape `(batch_size, sequence_length)`, *optional*):
+            Labels for computing the masked language modeling loss. Indices should either be in `[0, ...,
+            config.vocab_size]` or -100 (see `input_ids` docstring). Tokens with indices set to `-100` are ignored
+            (masked), the loss is only computed for the tokens with labels in `[0, ..., config.vocab_size]`.
+        """
+        # TODO (@alex-jw-brooks) add an example to this docstring once models are released
+        output_attentions = output_attentions if output_attentions is not None else self.config.output_attentions
+        output_hidden_states = (
+            output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
+        )
+        return_dict = return_dict if return_dict is not None else self.config.return_dict
+
+        if (input_ids is None) ^ (inputs_embeds is not None):
+            raise ValueError("You must specify exactly one of input_ids or inputs_embeds")
+
+        if input_features is not None and inputs_embeds is not None:
+            raise ValueError(
+                "You cannot specify both input_features and inputs_embeds at the same time, and must specify either one"
+            )
+
+        if inputs_embeds is None:
+            # Get the base embeddings; set all audio tokens to 0 index
+            # to avoid out of vocabulary issues with the LLM embedding.
+            # Audio features will be masked into is_audio_idx indices later.
+            is_audio_idx = input_ids == self.config.audio_token_id
+            llm_input_ids = input_ids.clone()
+            llm_input_ids[is_audio_idx] = 0
+            inputs_embeds = self.get_input_embeddings()(llm_input_ids)
+
+        if input_features is not None:
+            if input_features.dtype != self.dtype:
+                input_features = input_features.to(self.dtype)
+            # Get the audio features from the encoder / projector
+            audio_embeds = self.get_audio_features(input_features, return_dict=True).pooler_output
+
+            # Merge the audio features into the LLM embeddings
+            inputs_embeds = self.get_merged_audio_embeddings(
+                input_ids=input_ids,
+                audio_features=audio_embeds,
+                input_features_mask=input_features_mask,
+            )
+
+        outputs = self.language_model(
+            attention_mask=attention_mask,
+            position_ids=position_ids,
+            past_key_values=past_key_values,
+            inputs_embeds=inputs_embeds,
+            use_cache=use_cache,
+            output_attentions=output_attentions,
+            output_hidden_states=output_hidden_states,
+            return_dict=return_dict,
+            logits_to_keep=logits_to_keep,
+            **lm_kwargs,
+        )
+        logits = outputs[0]
+
+        loss = None
+        if labels is not None:
+            # Shift so that tokens < n predict n
+            if attention_mask is not None:
+                # we use the input attention mask to shift the logits and labels, because it is 2D.
+                # we also crop attn mask in case it is longer, which happens in PrefixTuning with peft
+                shift_attention_mask = attention_mask[:, -(logits.shape[1] - 1) :].to(logits.device)
+                shift_logits = logits[..., :-1, :][shift_attention_mask.to(logits.device) != 0].contiguous()
+                shift_labels = labels[..., 1:][shift_attention_mask.to(labels.device) != 0].contiguous()
+            else:
+                shift_logits = logits[..., :-1, :].contiguous()
+                shift_labels = labels[..., 1:].contiguous()
+            # Flatten the tokens
+            loss_fct = nn.CrossEntropyLoss()
+            loss = loss_fct(
+                shift_logits.view(-1, shift_logits.size(-1)), shift_labels.view(-1).to(shift_logits.device)
+            )
+
+        if not return_dict:
+            output = (logits,) + outputs[1:]
+            return (loss,) + output if loss is not None else output
+
+        return GraniteSpeechCausalLMOutputWithPast(
+            loss=loss,
+            logits=logits,
+            past_key_values=outputs.past_key_values,
+            hidden_states=outputs.hidden_states,
+            attentions=outputs.attentions,
+        )
+
+    def prepare_inputs_for_generation(
+        self,
+        input_ids,
+        past_key_values=None,
+        inputs_embeds=None,
+        input_features=None,
+        attention_mask=None,
+        logits_to_keep=None,
+        is_first_iteration=False,
+        **kwargs,
+    ):
+        # Overwritten -- in specific circumstances we don't want to forward audio inputs to the model
+
+        model_inputs = self.language_model.prepare_inputs_for_generation(
+            input_ids,
+            past_key_values=past_key_values,
+            inputs_embeds=inputs_embeds,
+            attention_mask=attention_mask,
+            logits_to_keep=logits_to_keep,
+            is_first_iteration=is_first_iteration,
+            **kwargs,
+        )
+
+        # If we're in cached decoding stage, input_features should be None because
+        # input ids do not contain special audio token anymore Otherwise we need
+        # input feature values to be passed to the model
+        if is_first_iteration or not kwargs.get("use_cache", True):
+            model_inputs["input_features"] = input_features
+        return model_inputs
+
+    def get_placeholder_mask(
+        self, input_ids: torch.LongTensor, inputs_embeds: torch.FloatTensor, audio_features: torch.FloatTensor
+    ):
+        """
+        Obtains multimodal placeholder mask from `input_ids` or `inputs_embeds`, and checks that the placeholder token count is
+        equal to the length of multimodal features. If the lengths are different, an error is raised.
+        """
+        if input_ids is None:
+            special_audio_mask = inputs_embeds == self.get_input_embeddings()(
+                torch.tensor(self.config.audio_token_id, dtype=torch.long, device=inputs_embeds.device)
+            )
+            special_audio_mask = special_audio_mask.all(-1)
+        else:
+            special_audio_mask = input_ids == self.config.audio_token_id
+
+        n_audio_tokens = special_audio_mask.sum()
+        n_audio_features = audio_features.shape[0]
+        special_audio_mask = special_audio_mask.unsqueeze(-1).expand_as(inputs_embeds).to(inputs_embeds.device)
+        torch_compilable_check(
+            inputs_embeds[special_audio_mask].numel() == audio_features.numel(),
+            f"Audio features and audio tokens do not match, tokens: {n_audio_tokens}, features: {n_audio_features}",
+        )
+        return special_audio_mask
+
+    def get_merged_audio_embeddings(
+        self, input_ids: torch.Tensor, audio_features: torch.Tensor, input_features_mask: torch.Tensor | None = None
+    ) -> torch.Tensor:
+        """
+        Adds the audio token to the model's LLM vocabulary so that we can pass it
+        through the tokenizer; it's assumed that the embeddings corresponding to the
+        <|audio|> token will be clobbered with speech features.
+
+        Args:
+            input_ids (`torch.Tensor`):
+                Input IDs containing one or more audio tokens.
+            audio_features (`torch.Tensor`):
+                Audio features to be masked into the language embeddings to form multimodal embeddings.
+            input_features_mask (`torch.Tensor`, *optional*, defaults to `None`)
+                Mask to be applied to audio features prior to scattering into the language embeddings.
+        """
+        is_audio_index = input_ids == self.config.audio_token_id
+        llm_input_ids = torch.where(is_audio_index, 0, input_ids)
+        inputs_embeds = self.language_model.get_input_embeddings()(llm_input_ids)  # [bsz, # features, hidden size]
+
+        audio_features = audio_features.to(inputs_embeds.device, inputs_embeds.dtype)
+        if input_features_mask is not None:
+            audio_features = audio_features[input_features_mask]
+
+        special_audio_mask = self.get_placeholder_mask(
+            input_ids, inputs_embeds=inputs_embeds, audio_features=audio_features
+        )
+        inputs_embeds = inputs_embeds.masked_scatter(special_audio_mask, audio_features)
+        return inputs_embeds
+
+    def generate(self, *args, **kwargs) -> torch.LongTensor:
+        # This model is expected to have a lora adapter, which is only
+        # enabled when considering audio inputs. As such, we override generate
+        # to conditionally enable / disable the lora adapter based on whether
+        # or not any input features were provided.
+
+        input_features = kwargs.pop("input_features", None)
+        if is_peft_available and self._hf_peft_config_loaded:
+            if input_features is not None:
+                self.enable_adapters()
+            else:
+                self.disable_adapters()
+        return super().generate(*args, input_features=input_features, **kwargs)
+
+    def save_pretrained(self, save_directory, *args, **kwargs):
+        # overwrite save_pretrained to first save the adapter if we have one
+        if is_peft_available and self._hf_peft_config_loaded:
+            adapter_name = self._get_adapter_name()
+            self.peft_config[adapter_name].base_model_name_or_path = save_directory
+            super().save_pretrained(save_directory, *args, **kwargs)
+        # Then save the base model afterwards
+        prev_val = self._hf_peft_config_loaded
+        self._hf_peft_config_loaded = False
+        super().save_pretrained(save_directory, *args, **kwargs)
+        self._hf_peft_config_loaded = prev_val
+
+    def _get_adapter_name(self):
+        return list(self.peft_config.keys())[0]
+
+
+__all__ = [
+    "GraniteSpeechCTCEncoder",
+    "GraniteSpeechForConditionalGeneration",
+    "GraniteSpeechPreTrainedModel",
+]

LTA_openwebtext_dualt/mini_owt_logdirichlet/.venv_qwen35_uv/lib/python3.12/site-packages/transformers/models/granite_speech/processing_granite_speech.py

@@ -0,0 +1,105 @@
+# Copyright 2025 The HuggingFace Inc. team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Processor class for Granite Speech."""
+
+from typing import Union
+
+from ...feature_extraction_utils import BatchFeature
+from ...processing_utils import ProcessorMixin
+from ...tokenization_python import PreTokenizedInput, TextInput
+from ...utils import auto_docstring, is_torch_available, logging
+from ...utils.import_utils import requires_backends
+
+
+if is_torch_available():
+    import torch
+
+logger = logging.get_logger(__name__)
+
+
+@auto_docstring
+class GraniteSpeechProcessor(ProcessorMixin):
+    def __init__(
+        self,
+        audio_processor,
+        tokenizer,
+        audio_token="<|audio|>",
+        chat_template=None,
+    ):
+        r"""
+        audio_token (`str`, *optional*, defaults to `"<|audio|>"`):
+            The special token used to represent audio in the text sequence. This token serves as a placeholder
+            that will be replaced with multiple audio tokens based on the actual audio length. The number of
+            audio tokens inserted depends on the audio feature dimensions extracted by the audio processor.
+        """
+        self.audio_token = tokenizer.audio_token if hasattr(tokenizer, "audio_token") else audio_token
+        super().__init__(audio_processor, tokenizer, chat_template=chat_template)
+
+    @auto_docstring
+    def __call__(
+        self,
+        text: TextInput | PreTokenizedInput | list[TextInput] | list[PreTokenizedInput],
+        audio: Union["torch.Tensor", list["torch.Tensor"]] = None,
+        device: str = "cpu",
+        **kwargs,
+    ) -> BatchFeature:
+        requires_backends(self, ["torch"])
+
+        text = self._get_validated_text(text)
+        prompt_strings = text
+
+        if audio is not None:
+            # NOTE - we intentionally avoid throwing for potentially misaligned
+            # text / audio inputs here because some inference engines will
+            # trigger the conditions due to the way they call multimodal
+            # processors, e.g., vLLM.
+            audio_inputs = self.audio_processor(audio, device=device)
+
+            # TODO (@alex-jw-brooks); we should add a util to get_num_audio_tokens
+            # from feature lengths and call it here, rather than returning it
+            # from the feature extractor.
+            audio_embed_sizes = audio_inputs.pop("audio_embed_sizes")
+
+            # Expand the audio placeholders to match the feature dims; this
+            # is similar to how many VLMs handle image tokens, e.g., llava next
+            prompt_strings = []
+            num_replaced = 0
+            for sample in text:
+                while self.audio_token in sample:
+                    sample = sample.replace(
+                        self.audio_token,
+                        "<placeholder>" * audio_embed_sizes[num_replaced],
+                        1,
+                    )
+                    num_replaced += 1
+                prompt_strings.append(sample)
+
+            prompt_strings = [sample.replace("<placeholder>", self.audio_token) for sample in prompt_strings]
+        else:
+            audio_inputs = {}
+
+        if "padding" not in kwargs:
+            kwargs["padding"] = True
+        text_inputs = self.tokenizer(prompt_strings, **kwargs)
+        return BatchFeature(data={**text_inputs, **audio_inputs})
+
+    def _get_validated_text(self, text: str | list) -> list[str]:
+        if isinstance(text, str):
+            return [text]
+        elif isinstance(text, list) and isinstance(text[0], str):
+            return text
+        raise TypeError("Invalid text provided! Text should be a string or list of strings.")
+
+
+__all__ = ["GraniteSpeechProcessor"]

LTA_openwebtext_dualt/mini_owt_logdirichlet/.venv_qwen35_uv/lib/python3.12/site-packages/transformers/models/hyperclovax/modular_hyperclovax.py

@@ -0,0 +1,235 @@
+# Copyright 2026 NAVER CLOUD Corp. and The HuggingFace Inc. team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""HyperCLOVAX modular model definition."""
+
+import torch
+import torch.nn as nn
+from huggingface_hub.dataclasses import strict
+
+from ...cache_utils import Cache
+from ...modeling_outputs import CausalLMOutputWithPast
+from ...processing_utils import Unpack
+from ...utils import TransformersKwargs, auto_docstring, can_return_tuple
+from ..granite.configuration_granite import GraniteConfig
+from ..granite.modeling_granite import (
+    GraniteAttention,
+    GraniteDecoderLayer,
+    GraniteForCausalLM,
+    GraniteModel,
+    GranitePreTrainedModel,
+    GraniteRMSNorm,
+    GraniteRotaryEmbedding,
+)
+
+
+@auto_docstring(checkpoint="naver-hyperclovax/HyperCLOVAX-SEED-Think-14B")
+@strict
+class HyperCLOVAXConfig(GraniteConfig):
+    r"""
+    embedding_multiplier (`float`, *optional*, defaults to `1.0`):
+        Scaling factor applied to the token embedding outputs. Used in MuP to control the
+        scale of the embedding activations.
+    logits_scaling (`float`, *optional*, defaults to `1.0`):
+        Scaling factor **multiplied** to the final logits before loss computation or sampling.
+        Used in MuP to ensure consistent output scale across model sizes. Note: unlike
+        [`GraniteConfig`], this is a multiplier, not a divisor.
+    residual_multiplier (`float`, *optional*, defaults to `1.0`):
+        Scaling factor applied to each sub-layer output before adding to the residual stream.
+        Used in Maximal Update Parametrization (MuP) to stabilize training across model sizes.
+    attention_multiplier (`float`, *optional*, defaults to `head_dim ** -0.5`):
+        Scaling factor applied to attention logits before softmax, replacing the standard
+        `1 / sqrt(head_dim)` scaling. Set explicitly for MuP-based training; when `None`,
+        defaults to the standard value.
+    use_post_norm (`bool`, *optional*, defaults to `True`):
+        Whether to apply an extra RMSNorm after each sub-layer output (Peri-Layer Normalization).
+
+    ```python
+    >>> from transformers import HyperCLOVAXModel, HyperCLOVAXConfig
+
+    >>> # Initializing a HyperCLOVAX style configuration
+    >>> configuration = HyperCLOVAXConfig()
+
+    >>> # Initializing a model from the configuration
+    >>> model = HyperCLOVAXModel(configuration)
+
+    >>> # Accessing the model configuration
+    >>> configuration = model.config
+    ```"""
+
+    model_type = "hyperclovax"
+
+    head_dim: int | None = None
+
+    # MuP scaling factors: None means "resolve to the mathematically equivalent default".
+    attention_multiplier: float | None = None
+
+    # Peri-Layer Normalization
+    use_post_norm: bool = True
+
+    def __post_init__(
+        self,
+        **kwargs,
+    ):
+        if self.head_dim is None:
+            self.head_dim = self.hidden_size // self.num_attention_heads
+
+        super().__post_init__(**kwargs)
+
+        # Resolve None MuP values to their mathematically equivalent defaults.
+        if self.attention_multiplier is None:
+            self.attention_multiplier = self.head_dim**-0.5
+
+    def validate_architecture(self):
+        """Validates that `hidden_size` is divisible by `num_attention_heads`."""
+        if self.hidden_size % self.num_attention_heads != 0:
+            raise ValueError(
+                f"The hidden size ({self.hidden_size}) is not a multiple of the number of attention "
+                f"heads ({self.num_attention_heads})."
+            )
+
+
+class HyperCLOVAXRMSNorm(GraniteRMSNorm):
+    pass
+
+
+class HyperCLOVAXRotaryEmbedding(GraniteRotaryEmbedding):
+    pass
+
+
+class HyperCLOVAXAttention(GraniteAttention):
+    pass
+
+
+class HyperCLOVAXDecoderLayer(GraniteDecoderLayer):
+    def __init__(self, config: HyperCLOVAXConfig, layer_idx: int):
+        super().__init__(config, layer_idx)
+        # Optional Peri-Layer Normalization: additional RMSNorm after each sub-layer output
+        self.post_norm1 = (
+            HyperCLOVAXRMSNorm(config.hidden_size, eps=config.rms_norm_eps) if config.use_post_norm else nn.Identity()
+        )
+        self.post_norm2 = (
+            HyperCLOVAXRMSNorm(config.hidden_size, eps=config.rms_norm_eps) if config.use_post_norm else nn.Identity()
+        )
+
+    def forward(
+        self,
+        hidden_states: torch.Tensor,
+        attention_mask: torch.Tensor | None = None,
+        position_ids: torch.LongTensor | None = None,
+        past_key_values: Cache | None = None,
+        use_cache: bool | None = False,
+        position_embeddings: tuple[torch.Tensor, torch.Tensor] | None = None,
+        **kwargs: Unpack[TransformersKwargs],
+    ) -> torch.Tensor:
+        residual = hidden_states
+        hidden_states = self.input_layernorm(hidden_states)
+        # Self Attention
+        hidden_states, _ = self.self_attn(
+            hidden_states=hidden_states,
+            attention_mask=attention_mask,
+            position_ids=position_ids,
+            past_key_values=past_key_values,
+            use_cache=use_cache,
+            position_embeddings=position_embeddings,
+            **kwargs,
+        )
+        hidden_states = self.post_norm1(hidden_states)
+        hidden_states = residual + hidden_states * self.residual_multiplier
+
+        # Fully Connected
+        residual = hidden_states
+        hidden_states = self.post_attention_layernorm(hidden_states)
+        hidden_states = self.mlp(hidden_states)
+        hidden_states = self.post_norm2(hidden_states)
+        hidden_states = residual + hidden_states * self.residual_multiplier
+        return hidden_states
+
+
+@auto_docstring
+class HyperCLOVAXPreTrainedModel(GranitePreTrainedModel):
+    pass
+
+
+@auto_docstring
+class HyperCLOVAXModel(GraniteModel):
+    pass
+
+
+@auto_docstring
+class HyperCLOVAXForCausalLM(GraniteForCausalLM):
+    @can_return_tuple
+    @auto_docstring
+    def forward(
+        self,
+        input_ids: torch.LongTensor | None = None,
+        attention_mask: torch.Tensor | None = None,
+        position_ids: torch.LongTensor | None = None,
+        past_key_values: Cache | None = None,
+        inputs_embeds: torch.FloatTensor | None = None,
+        labels: torch.LongTensor | None = None,
+        use_cache: bool | None = None,
+        logits_to_keep: int | torch.Tensor = 0,
+        **kwargs: Unpack[TransformersKwargs],
+    ) -> CausalLMOutputWithPast:
+        r"""
+        Example:
+
+        ```python
+        >>> from transformers import AutoTokenizer, HyperCLOVAXForCausalLM
+
+        >>> model = HyperCLOVAXForCausalLM.from_pretrained("naver-hyperclovax/HyperCLOVAX-SEED-Think-14B")
+        >>> tokenizer = AutoTokenizer.from_pretrained("naver-hyperclovax/HyperCLOVAX-SEED-Think-14B")
+
+        >>> prompt = "Hey, are you conscious? Can you talk to me?"
+        >>> inputs = tokenizer(prompt, return_tensors="pt")
+
+        >>> # Generate
+        >>> generate_ids = model.generate(inputs.input_ids, max_length=30)
+        >>> tokenizer.batch_decode(generate_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False)[0]
+        "Hey, are you conscious? Can you talk to me? Are you okay?" The man was confused and answered, "Yes." Then the woman asked.
+        ```"""
+        outputs = self.model(
+            input_ids=input_ids,
+            attention_mask=attention_mask,
+            position_ids=position_ids,
+            past_key_values=past_key_values,
+            inputs_embeds=inputs_embeds,
+            use_cache=use_cache,
+            **kwargs,
+        )
+
+        hidden_states = outputs.last_hidden_state
+        slice_indices = slice(-logits_to_keep, None) if isinstance(logits_to_keep, int) else logits_to_keep
+        # MuP: multiply logits by logits_scaling (cf. GraniteForCausalLM which divides)
+        logits = self.lm_head(hidden_states[:, slice_indices, :]) * self.config.logits_scaling
+
+        loss = None
+        if labels is not None:
+            loss = self.loss_function(logits=logits, labels=labels, vocab_size=self.config.vocab_size, **kwargs)
+
+        return CausalLMOutputWithPast(
+            loss=loss,
+            logits=logits,
+            past_key_values=outputs.past_key_values,
+            hidden_states=outputs.hidden_states,
+            attentions=outputs.attentions,
+        )
+
+
+__all__ = [
+    "HyperCLOVAXConfig",
+    "HyperCLOVAXPreTrainedModel",
+    "HyperCLOVAXModel",
+    "HyperCLOVAXForCausalLM",
+]

LTA_openwebtext_dualt/mini_owt_logdirichlet/.venv_qwen35_uv/lib/python3.12/site-packages/transformers/models/ibert/quant_modules.py

@@ -0,0 +1,819 @@
+# Copyright 2021 The I-BERT Authors (Sehoon Kim, Amir Gholami, Zhewei Yao,
+# Michael Mahoney, Kurt Keutzer - UC Berkeley) and The HuggingFace Inc. team.
+# Copyright (c) 20121, NVIDIA CORPORATION.  All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import decimal
+
+import numpy as np
+import torch
+from torch import nn
+from torch.autograd import Function
+
+from ...utils import logging
+
+
+logger = logging.get_logger(__name__)
+
+
+class QuantEmbedding(nn.Module):
+    """
+    Quantized version of `torch.nn.Embedding`. Adds quantization-specific arguments on top of `torch.nn.Embedding`.
+
+    Args:
+        weight_bit (`int`, *optional*, defaults to `8`):
+            Bitwidth for the quantized weight.
+        momentum (`float`, *optional*, defaults to `0.95`):
+            Momentum for updating the activation quantization range.
+        quant_mode (`bool`, *optional*, defaults to `False`):
+            Whether or not the layer is quantized.
+    """
+
+    def __init__(
+        self,
+        num_embeddings,
+        embedding_dim,
+        padding_idx=None,
+        max_norm=None,
+        norm_type=2.0,
+        scale_grad_by_freq=False,
+        sparse=False,
+        _weight=None,
+        weight_bit=8,
+        momentum=0.95,
+        quant_mode=False,
+    ):
+        super().__init__()
+        self.num_ = num_embeddings
+        self.dim = embedding_dim
+        self.padding_idx = padding_idx
+        self.max_norm = max_norm
+        self.norm_type = norm_type
+        self.scale_grad_by_freq = scale_grad_by_freq
+        self.sparse = sparse
+
+        self.weight = nn.Parameter(torch.zeros([num_embeddings, embedding_dim]))
+        self.register_buffer("weight_scaling_factor", torch.zeros(1))
+        self.register_buffer("weight_integer", torch.zeros_like(self.weight))
+
+        self.weight_bit = weight_bit
+        self.momentum = momentum
+        self.quant_mode = quant_mode
+        self.percentile_mode = False
+        self.weight_function = SymmetricQuantFunction.apply
+
+    def forward(self, x, positions=None, incremental_state=None):
+        if not self.quant_mode:
+            return (
+                nn.functional.embedding(
+                    x,
+                    self.weight,
+                    self.padding_idx,
+                    self.max_norm,
+                    self.norm_type,
+                    self.scale_grad_by_freq,
+                    self.sparse,
+                ),
+                None,
+            )
+
+        w = self.weight
+        w_transform = w.data.detach()
+        w_min = w_transform.min().expand(1)
+        w_max = w_transform.max().expand(1)
+
+        self.weight_scaling_factor = symmetric_linear_quantization_params(self.weight_bit, w_min, w_max, False)
+        self.weight_integer = self.weight_function(
+            self.weight, self.weight_bit, self.percentile_mode, self.weight_scaling_factor
+        )
+
+        emb_int = nn.functional.embedding(
+            x,
+            self.weight_integer,
+            self.padding_idx,
+            self.max_norm,
+            self.norm_type,
+            self.scale_grad_by_freq,
+            self.sparse,
+        )
+        return emb_int * self.weight_scaling_factor, self.weight_scaling_factor
+
+
+class QuantAct(nn.Module):
+    """
+    Quantizes the given activation.
+
+    Args:
+        activation_bit (`int`):
+            Bitwidth for the quantized activation.
+        act_range_momentum (`float`, *optional*, defaults to `0.95`):
+            Momentum for updating the activation quantization range.
+        per_channel (`bool`, *optional*, defaults to `False`):
+            Whether to or not use channel-wise quantization.
+        channel_len (`int`, *optional*):
+            Specify the channel length when set the *per_channel* True.
+        quant_mode (`bool`, *optional*, defaults to `False`):
+            Whether or not the layer is quantized.
+    """
+
+    def __init__(self, activation_bit, act_range_momentum=0.95, per_channel=False, channel_len=None, quant_mode=False):
+        super().__init__()
+
+        self.activation_bit = activation_bit
+        self.act_range_momentum = act_range_momentum
+        self.quant_mode = quant_mode
+        self.per_channel = per_channel
+        self.percentile = False
+        self.act_function = SymmetricQuantFunction.apply
+
+        if not self.per_channel:
+            self.register_buffer("x_min", torch.zeros(1))
+            self.register_buffer("x_max", torch.zeros(1))
+            self.register_buffer("act_scaling_factor", torch.zeros(1))
+            self.x_min -= 1e-5
+            self.x_max += 1e-5
+        else:
+            raise NotImplementedError("per-channel mode is not currently supported for activation.")
+
+    def __repr__(self):
+        return (
+            f"{self.__class__.__name__}(activation_bit={self.activation_bit}, "
+            f"quant_mode: {self.quant_mode}, Act_min: {self.x_min.item():.2f}, "
+            f"Act_max: {self.x_max.item():.2f})"
+        )
+
+    def forward(
+        self,
+        x,
+        pre_act_scaling_factor=None,
+        identity=None,
+        identity_scaling_factor=None,
+        specified_min=None,
+        specified_max=None,
+    ):
+        x_act = x if identity is None else identity + x
+        # collect running stats if training
+        if self.training:
+            assert not self.percentile, "percentile mode is not currently supported for activation."
+            assert not self.per_channel, "per-channel mode is not currently supported for activation."
+            x_min = x_act.data.min()
+            x_max = x_act.data.max()
+
+            assert x_max.isnan().sum() == 0 and x_min.isnan().sum() == 0, (
+                "NaN detected when computing min/max of the activation"
+            )
+
+            # Initialization
+            if self.x_min.min() > -1.1e-5 and self.x_max.max() < 1.1e-5:
+                self.x_min = self.x_min + x_min
+                self.x_max = self.x_max + x_max
+
+            # exponential moving average (EMA)
+            # use momentum to prevent the quantized values change greatly every iteration
+            elif self.act_range_momentum == -1:
+                self.x_min = torch.min(self.x_min, x_min)
+                self.x_max = torch.max(self.x_max, x_max)
+            else:
+                self.x_min = self.x_min * self.act_range_momentum + x_min * (1 - self.act_range_momentum)
+                self.x_max = self.x_max * self.act_range_momentum + x_max * (1 - self.act_range_momentum)
+
+        if not self.quant_mode:
+            return x_act, None
+
+        x_min = self.x_min if specified_min is None else specified_min
+        x_max = self.x_max if specified_max is None else specified_max
+
+        self.act_scaling_factor = symmetric_linear_quantization_params(
+            self.activation_bit, x_min, x_max, per_channel=self.per_channel
+        )
+
+        if pre_act_scaling_factor is None:
+            # this is for the input quantization
+            quant_act_int = self.act_function(x, self.activation_bit, self.percentile, self.act_scaling_factor)
+        else:
+            quant_act_int = FixedPointMul.apply(
+                x,
+                pre_act_scaling_factor,
+                self.activation_bit,
+                self.act_scaling_factor,
+                identity,
+                identity_scaling_factor,
+            )
+
+        correct_output_scale = self.act_scaling_factor.view(-1)
+
+        return quant_act_int * correct_output_scale, self.act_scaling_factor
+
+
+class QuantLinear(nn.Module):
+    """
+    Quantized version of `torch.nn.Linear`. Adds quantization-specific arguments on top of `torch.nn.Linear`.
+
+    Args:
+        weight_bit (`int`, *optional*, defaults to `8`):
+            Bitwidth for the quantized weight.
+        bias_bit (`int`, *optional*, defaults to `32`):
+            Bitwidth for the quantized bias.
+        per_channel (`bool`, *optional*, defaults to `False`):
+            Whether or not to use channel-wise quantization.
+        quant_mode (`bool`, *optional*, defaults to `False`):
+            Whether or not the layer is quantized.
+    """
+
+    def __init__(
+        self, in_features, out_features, bias=True, weight_bit=8, bias_bit=32, per_channel=False, quant_mode=False
+    ):
+        super().__init__()
+        self.in_features = in_features
+        self.out_features = out_features
+
+        self.weight = nn.Parameter(torch.zeros([out_features, in_features]))
+        self.register_buffer("weight_integer", torch.zeros_like(self.weight))
+        self.register_buffer("fc_scaling_factor", torch.zeros(self.out_features))
+        if bias:
+            self.bias = nn.Parameter(torch.zeros(out_features))
+            self.register_buffer("bias_integer", torch.zeros_like(self.bias))
+
+        self.weight_bit = weight_bit
+        self.quant_mode = quant_mode
+        self.per_channel = per_channel
+        self.bias_bit = bias_bit
+        self.quant_mode = quant_mode
+        self.percentile_mode = False
+        self.weight_function = SymmetricQuantFunction.apply
+
+    def __repr__(self):
+        s = super().__repr__()
+        s = f"({s} weight_bit={self.weight_bit}, quant_mode={self.quant_mode})"
+        return s
+
+    def forward(self, x, prev_act_scaling_factor=None):
+        if not self.quant_mode:
+            return nn.functional.linear(x, weight=self.weight, bias=self.bias), None
+
+        # assert that prev_act_scaling_factor is a scalar tensor
+        assert prev_act_scaling_factor is not None and prev_act_scaling_factor.shape == (1,), (
+            "Input activation to the QuantLinear layer should be globally (non-channel-wise) quantized. "
+            "Please add a QuantAct layer with `per_channel = True` before this QuantAct layer"
+        )
+
+        w = self.weight
+        w_transform = w.data.detach()
+        if self.per_channel:
+            w_min, _ = torch.min(w_transform, dim=1, out=None)
+            w_max, _ = torch.max(w_transform, dim=1, out=None)
+        else:
+            w_min = w_transform.min().expand(1)
+            w_max = w_transform.max().expand(1)
+
+        self.fc_scaling_factor = symmetric_linear_quantization_params(self.weight_bit, w_min, w_max, self.per_channel)
+        self.weight_integer = self.weight_function(
+            self.weight, self.weight_bit, self.percentile_mode, self.fc_scaling_factor
+        )
+
+        bias_scaling_factor = self.fc_scaling_factor * prev_act_scaling_factor
+
+        if self.bias is not None:
+            self.bias_integer = self.weight_function(self.bias, self.bias_bit, False, bias_scaling_factor)
+
+        prev_act_scaling_factor = prev_act_scaling_factor.view(1, -1)
+        x_int = x / prev_act_scaling_factor
+
+        return (
+            nn.functional.linear(x_int, weight=self.weight_integer, bias=self.bias_integer) * bias_scaling_factor,
+            bias_scaling_factor,
+        )
+
+
+class IntGELU(nn.Module):
+    """
+    Quantized version of `torch.nn.GELU`. Adds quantization-specific arguments on top of `torch.nn.GELU`.
+
+    Args:
+        quant_mode (`bool`, *optional*, defaults to `False`):
+            Whether or not the layer is quantized.
+        force_dequant (`str`, *optional*, defaults to `"none"`):
+            Force dequantize the layer if either "gelu" or "nonlinear" is given.
+    """
+
+    def __init__(self, quant_mode=True, force_dequant="none"):
+        super().__init__()
+        self.quant_mode = quant_mode
+
+        if force_dequant in ["nonlinear", "gelu"]:
+            logger.info("Force dequantize gelu")
+            self.quant_mode = False
+
+        if not self.quant_mode:
+            self.activation_fn = nn.GELU()
+
+        self.k = 1.4142
+        self.const = 14  # dummy integer constant
+        self.coeff = [-0.2888, -1.769, 1]  # a(x+b)**2 + c
+        self.coeff[2] /= self.coeff[0]
+
+    def int_erf(self, x_int, scaling_factor):
+        b_int = torch.floor(self.coeff[1] / scaling_factor)
+        c_int = torch.floor(self.coeff[2] / scaling_factor**2)
+        sign = torch.sign(x_int)
+
+        abs_int = torch.min(torch.abs(x_int), -b_int)
+        y_int = sign * ((abs_int + b_int) ** 2 + c_int)
+        scaling_factor = scaling_factor**2 * self.coeff[0]
+
+        # avoid overflow
+        y_int = floor_ste.apply(y_int / 2**self.const)
+        scaling_factor = scaling_factor * 2**self.const
+
+        return y_int, scaling_factor
+
+    def forward(self, x, scaling_factor=None):
+        if not self.quant_mode:
+            return self.activation_fn(x), None
+
+        x_int = x / scaling_factor
+        sigmoid_int, sigmoid_scaling_factor = self.int_erf(x_int, scaling_factor / self.k)
+
+        shift_int = 1.0 // sigmoid_scaling_factor
+
+        x_int = x_int * (sigmoid_int + shift_int)
+        scaling_factor = scaling_factor * sigmoid_scaling_factor / 2
+
+        return x_int * scaling_factor, scaling_factor
+
+
+class IntSoftmax(nn.Module):
+    """
+    Quantized version of `torch.nn.Softmax`. Adds quantization-specific arguments on top of `torch.nn.Softmax`.
+
+    Args:
+        output_bit (`int`):
+            Bitwidth for the layer output activation.
+        quant_mode (`bool`, *optional*, defaults to `False`):
+            Whether or not the layer is quantized.
+        force_dequant (`str`, *optional*, defaults to `"none"`):
+            Force dequantize the layer if either "softmax" or "nonlinear" is given.
+    """
+
+    def __init__(self, output_bit, quant_mode=False, force_dequant="none"):
+        super().__init__()
+        self.output_bit = output_bit
+        self.max_bit = 32
+        self.quant_mode = quant_mode
+
+        if force_dequant in ["nonlinear", "softmax"]:
+            logger.info("Force dequantize softmax")
+            self.quant_mode = False
+
+        self.act = QuantAct(16, quant_mode=self.quant_mode)
+        self.x0 = -0.6931  # -ln2
+        self.const = 30  # dummy integer constant
+        self.coef = [0.35815147, 0.96963238, 1.0]  # ax**2 + bx + c
+        self.coef[1] /= self.coef[0]
+        self.coef[2] /= self.coef[0]
+
+    def int_polynomial(self, x_int, scaling_factor):
+        with torch.no_grad():
+            b_int = torch.floor(self.coef[1] / scaling_factor)
+            c_int = torch.floor(self.coef[2] / scaling_factor**2)
+        z = (x_int + b_int) * x_int + c_int
+        scaling_factor = self.coef[0] * scaling_factor**2
+        return z, scaling_factor
+
+    def int_exp(self, x_int, scaling_factor):
+        with torch.no_grad():
+            x0_int = torch.floor(self.x0 / scaling_factor)
+        x_int = torch.max(x_int, self.const * x0_int)
+
+        q = floor_ste.apply(x_int / x0_int)
+        r = x_int - x0_int * q
+        exp_int, exp_scaling_factor = self.int_polynomial(r, scaling_factor)
+        exp_int = torch.clamp(floor_ste.apply(exp_int * 2 ** (self.const - q)), min=0)
+        scaling_factor = exp_scaling_factor / 2**self.const
+        return exp_int, scaling_factor
+
+    def forward(self, x, scaling_factor):
+        if not self.quant_mode:
+            return nn.functional.softmax(x, dim=-1), None
+
+        x_int = x / scaling_factor
+
+        x_int_max, _ = x_int.max(dim=-1, keepdim=True)
+        x_int = x_int - x_int_max
+        exp_int, exp_scaling_factor = self.int_exp(x_int, scaling_factor)
+
+        # Avoid overflow
+        exp, exp_scaling_factor = self.act(exp_int, exp_scaling_factor)
+        exp_int = exp / exp_scaling_factor
+
+        exp_int_sum = exp_int.sum(dim=-1, keepdim=True)
+        factor = floor_ste.apply(2**self.max_bit / exp_int_sum)
+        exp_int = floor_ste.apply(exp_int * factor / 2 ** (self.max_bit - self.output_bit))
+        scaling_factor = 1 / 2**self.output_bit
+        return exp_int * scaling_factor, scaling_factor
+
+
+class IntLayerNorm(nn.Module):
+    """
+    Quantized version of `torch.nn.LayerNorm`. Adds quantization-specific arguments on top of `torch.nn.LayerNorm`.
+
+    Args:
+        output_bit (`int`, *optional*, defaults to `8`):
+            Bitwidth for the layer output activation.
+        quant_mode (`bool`, *optional*, defaults to `False`):
+            Whether or not the layer is quantized.
+        force_dequant (`str`, *optional*, defaults to `"none"`):
+            Force dequantize the layer if either "layernorm" or "nonlinear" is given.
+    """
+
+    def __init__(self, normalized_shape, eps, output_bit=8, quant_mode=False, force_dequant="none"):
+        super().__init__()
+        self.normalized_shape = normalized_shape
+        self.eps = eps
+
+        self.weight = nn.Parameter(torch.zeros(normalized_shape))
+        self.bias = nn.Parameter(torch.zeros(normalized_shape))
+
+        self.quant_mode = quant_mode
+        if force_dequant in ["nonlinear", "layernorm"]:
+            logger.info("Force dequantize layernorm")
+            self.quant_mode = False
+
+        self.register_buffer("shift", torch.zeros(1))
+        self.output_bit = output_bit
+        self.max_bit = 32
+        self.dim_sqrt = None
+        self.activation = QuantAct(self.output_bit, quant_mode=self.quant_mode)
+
+    def set_shift(self, y_int):
+        with torch.no_grad():
+            y_sq_int = y_int**2
+            var_int = torch.sum(y_sq_int, axis=2, keepdim=True)
+            shift = (torch.log2(torch.sqrt(var_int / 2**self.max_bit)).ceil()).max()
+            shift_old = self.shift
+            self.shift = torch.max(self.shift, shift)
+            logger.info(f"Dynamic shift adjustment: {int(shift_old)} -> {int(self.shift)}")
+
+    def overflow_fallback(self, y_int):
+        """
+        This fallback function is called when overflow is detected during training time, and adjusts the `self.shift`
+        to avoid overflow in the subsequent runs.
+        """
+        self.set_shift(y_int)  # adjusts `self.shift`
+        y_int_shifted = floor_ste.apply(y_int / 2**self.shift)
+        y_sq_int = y_int_shifted**2
+        var_int = torch.sum(y_sq_int, axis=2, keepdim=True)
+        return var_int
+
+    def forward(self, x, scaling_factor=None):
+        if not self.quant_mode:
+            mean = x.mean(axis=2, keepdim=True)
+            y = x - mean
+            var = torch.mean(y**2, axis=2, keepdim=True)
+            x = y / torch.sqrt(self.eps + var)
+            x = x * self.weight + self.bias
+            return x, None
+
+        # compute sqrt of the feature dimension if it is the first run
+        if self.dim_sqrt is None:
+            n = torch.tensor(x.shape[2], dtype=torch.float)
+            self.dim_sqrt = torch.sqrt(n).to(x.device)
+
+        # Normalization: computes mean and variance(std)
+        x_int = x / scaling_factor
+        mean_int = round_ste.apply(x_int.mean(axis=2, keepdim=True))
+        y_int = x_int - mean_int
+        y_int_shifted = floor_ste.apply(y_int / 2**self.shift)
+        y_sq_int = y_int_shifted**2
+        var_int = torch.sum(y_sq_int, axis=2, keepdim=True)
+
+        # overflow handling in training time
+        if self.training:
+            # if overflow is detected
+            if var_int.max() >= 2**self.max_bit:
+                var_int = self.overflow_fallback(y_int)
+                assert var_int.max() < 2**self.max_bit + 0.1, (
+                    "Error detected in overflow handling: "
+                    "`var_int` exceeds `self.max_bit` (the maximum possible bit width)"
+                )
+
+        # To be replaced with integer-sqrt kernel that produces the same output
+        std_int = floor_ste.apply(torch.sqrt(var_int)) * 2**self.shift
+        factor = floor_ste.apply(2**31 / std_int)
+        y_int = floor_ste.apply(y_int * factor / 2)
+        scaling_factor = self.dim_sqrt / 2**30
+
+        # scaling and shifting
+        bias = self.bias.data.detach() / (self.weight.data.detach())
+        bias_int = floor_ste.apply(bias / scaling_factor)
+
+        y_int = y_int + bias_int
+        scaling_factor = scaling_factor * self.weight
+        x = y_int * scaling_factor
+
+        return x, scaling_factor
+
+
+def get_percentile_min_max(input, lower_percentile, upper_percentile, output_tensor=False):
+    """
+    Calculate the percentile max and min values in a given tensor
+
+    Args:
+        input (`torch.Tensor`):
+            The target tensor to calculate percentile max and min.
+        lower_percentile (`float`):
+            If 0.1, means we return the value of the smallest 0.1% value in the tensor as percentile min.
+        upper_percentile (`float`):
+            If 99.9, means we return the value of the largest 0.1% value in the tensor as percentile max.
+        output_tensor (`bool`, *optional*, defaults to `False`):
+            If True, this function returns tensors, otherwise it returns values.
+
+    Returns:
+        `Tuple(torch.Tensor, torch.Tensor)`: Percentile min and max value of *input*
+    """
+    input_length = input.shape[0]
+
+    lower_index = round(input_length * (1 - lower_percentile * 0.01))
+    upper_index = round(input_length * upper_percentile * 0.01)
+
+    upper_bound = torch.kthvalue(input, k=upper_index).values
+
+    if lower_percentile == 0:
+        lower_bound = upper_bound * 0
+        # lower_index += 1
+    else:
+        lower_bound = -torch.kthvalue(-input, k=lower_index).values
+
+    if not output_tensor:
+        lower_bound = lower_bound.item()
+        upper_bound = upper_bound.item()
+    return lower_bound, upper_bound
+
+
+def linear_quantize(input, scale, zero_point, inplace=False):
+    """
+    Quantize single-precision input tensor to integers with the given scaling factor and zeropoint.
+
+    Args:
+        input (`torch.Tensor`):
+            Single-precision input tensor to be quantized.
+        scale (`torch.Tensor`):
+            Scaling factor for quantization.
+        zero_pint (`torch.Tensor`):
+            Shift for quantization.
+        inplace (`bool`, *optional*, defaults to `False`):
+            Whether to compute inplace or not.
+
+    Returns:
+        `torch.Tensor`: Linearly quantized value of *input* according to *scale* and *zero_point*.
+    """
+    # reshape scale and zeropoint for convolutional weights and activation
+    if len(input.shape) == 4:
+        scale = scale.view(-1, 1, 1, 1)
+        zero_point = zero_point.view(-1, 1, 1, 1)
+    # reshape scale and zeropoint for linear weights
+    elif len(input.shape) == 2:
+        scale = scale.view(-1, 1)
+        zero_point = zero_point.view(-1, 1)
+    else:
+        scale = scale.view(-1)
+        zero_point = zero_point.view(-1)
+    # quantized = float / scale + zero_point
+    if inplace:
+        input.mul_(1.0 / scale).add_(zero_point).round_()
+        return input
+    return torch.round(1.0 / scale * input + zero_point)
+
+
+def symmetric_linear_quantization_params(num_bits, saturation_min, saturation_max, per_channel=False):
+    """
+    Compute the scaling factor with the given quantization range for symmetric quantization.
+
+    Args:
+        saturation_min (`torch.Tensor`):
+            Lower bound for quantization range.
+        saturation_max (`torch.Tensor`):
+            Upper bound for quantization range.
+        per_channel (`bool`, *optional*, defaults to `False`):
+            Whether to or not use channel-wise quantization.
+
+    Returns:
+        `torch.Tensor`: Scaling factor that linearly quantizes the given range between *saturation_min* and
+        *saturation_max*.
+    """
+    # in this part, we do not need any gradient computation,
+    # in order to enforce this, we put torch.no_grad()
+    with torch.no_grad():
+        n = 2 ** (num_bits - 1) - 1
+
+        if per_channel:
+            scale, _ = torch.max(torch.stack([saturation_min.abs(), saturation_max.abs()], dim=1), dim=1)
+            scale = torch.clamp(scale, min=1e-8) / n
+
+        else:
+            scale = max(saturation_min.abs(), saturation_max.abs())
+            scale = torch.clamp(scale, min=1e-8) / n
+
+    return scale
+
+
+class SymmetricQuantFunction(Function):
+    """
+    Class to quantize the given floating-point values using symmetric quantization with given range and bitwidth.
+    """
+
+    @staticmethod
+    def forward(ctx, x, k, percentile_mode, scale):
+        """
+        Args:
+            x (`torch.Tensor`):
+                Floating point tensor to be quantized.
+            k (`int`):
+                Quantization bitwidth.
+            percentile_mode (`bool`):
+                Whether or not to use percentile calibration.
+            scale (`torch.Tensor`):
+                Pre-calculated scaling factor for *x*. Note that the current implementation of SymmetricQuantFunction
+                requires pre-calculated scaling factor.
+
+        Returns:
+            `torch.Tensor`: Symmetric-quantized value of *input*.
+        """
+        zero_point = torch.tensor(0.0, device=scale.device)
+
+        n = 2 ** (k - 1) - 1
+        new_quant_x = linear_quantize(x, scale, zero_point, inplace=False)
+        new_quant_x = torch.clamp(new_quant_x, -n, n - 1)
+
+        ctx.scale = scale
+        return new_quant_x
+
+    @staticmethod
+    def backward(ctx, grad_output):
+        scale = ctx.scale
+        if len(grad_output.shape) == 4:
+            scale = scale.view(-1, 1, 1, 1)
+        # reshape scale and zeropoint for linear weights
+        elif len(grad_output.shape) == 2:
+            scale = scale.view(-1, 1)
+        else:
+            scale = scale.view(-1)
+
+        return grad_output.clone() / scale, None, None, None, None
+
+
+class floor_ste(Function):
+    """
+    Straight-through Estimator(STE) for torch.floor()
+    """
+
+    @staticmethod
+    def forward(ctx, x):
+        return torch.floor(x)
+
+    @staticmethod
+    def backward(ctx, grad_output):
+        return grad_output.clone()
+
+
+class round_ste(Function):
+    """
+    Straight-through Estimator(STE) for torch.round()
+    """
+
+    @staticmethod
+    def forward(ctx, x):
+        return torch.round(x)
+
+    @staticmethod
+    def backward(ctx, grad_output):
+        return grad_output.clone()
+
+
+def batch_frexp(inputs, max_bit=31):
+    """
+    Decompose the scaling factor into mantissa and twos exponent.
+
+    Args:
+        scaling_factor (`torch.Tensor`):
+            Target scaling factor to decompose.
+
+    Returns:
+        ``Tuple(torch.Tensor, torch.Tensor)`: mantisa and exponent
+    """
+
+    shape_of_input = inputs.size()
+
+    # trans the input to be a 1-d tensor
+    inputs = inputs.view(-1)
+
+    output_m, output_e = np.frexp(inputs.cpu().numpy())
+    tmp_m = []
+    for m in output_m:
+        int_m_shifted = int(
+            decimal.Decimal(m * (2**max_bit)).quantize(decimal.Decimal(1), rounding=decimal.ROUND_HALF_UP)
+        )
+        tmp_m.append(int_m_shifted)
+    output_m = np.array(tmp_m)
+
+    output_e = float(max_bit) - output_e
+
+    return (
+        torch.from_numpy(output_m).to(inputs.device).view(shape_of_input),
+        torch.from_numpy(output_e).to(inputs.device).view(shape_of_input),
+    )
+
+
+class FixedPointMul(Function):
+    """
+    Function to perform fixed-point arithmetic that can match integer arithmetic on hardware.
+
+    Args:
+        pre_act (`torch.Tensor`):
+            Input tensor.
+        pre_act_scaling_factor (`torch.Tensor`):
+            Scaling factor of the input tensor *pre_act*.
+        bit_num (`int`):
+            Quantization bitwidth.
+        z_scaling_factor (`torch.Tensor`):
+            Scaling factor of the output tensor.
+        identity (`torch.Tensor`, *optional*):
+            Identity tensor, if exists.
+        identity_scaling_factor (`torch.Tensor`, *optional*):
+            Scaling factor of the identity tensor *identity*, if exists.
+
+    Returns:
+        `torch.Tensor`: Output tensor(*pre_act* if *identity* is not given, otherwise the addition of *pre_act* and
+        *identity*), whose scale is rescaled to *z_scaling_factor*.
+    """
+
+    @staticmethod
+    def forward(
+        ctx,
+        pre_act,
+        pre_act_scaling_factor,
+        bit_num,
+        z_scaling_factor,
+        identity=None,
+        identity_scaling_factor=None,
+    ):
+        if len(pre_act_scaling_factor.shape) == 3:
+            reshape = lambda x: x  # noqa: E731
+        else:
+            reshape = lambda x: x.view(1, 1, -1)  # noqa: E731
+        ctx.identity = identity
+
+        n = 2 ** (bit_num - 1) - 1
+
+        with torch.no_grad():
+            pre_act_scaling_factor = reshape(pre_act_scaling_factor)
+            if identity is not None:
+                identity_scaling_factor = reshape(identity_scaling_factor)
+
+            ctx.z_scaling_factor = z_scaling_factor
+
+            z_int = torch.round(pre_act / pre_act_scaling_factor)
+            _A = pre_act_scaling_factor.type(torch.double)
+            _B = (z_scaling_factor.type(torch.float)).type(torch.double)
+            new_scale = _A / _B
+            new_scale = reshape(new_scale)
+
+            m, e = batch_frexp(new_scale)
+
+            output = z_int.type(torch.double) * m.type(torch.double)
+            output = torch.round(output / (2.0**e))
+
+            if identity is not None:
+                # needs addition of identity activation
+                wx_int = torch.round(identity / identity_scaling_factor)
+
+                _A = identity_scaling_factor.type(torch.double)
+                _B = (z_scaling_factor.type(torch.float)).type(torch.double)
+                new_scale = _A / _B
+                new_scale = reshape(new_scale)
+
+                m1, e1 = batch_frexp(new_scale)
+                output1 = wx_int.type(torch.double) * m1.type(torch.double)
+                output1 = torch.round(output1 / (2.0**e1))
+
+                output = output1 + output
+
+            return torch.clamp(output.type(torch.float), -n - 1, n)
+
+    @staticmethod
+    def backward(ctx, grad_output):
+        identity_grad = None
+        if ctx.identity is not None:
+            identity_grad = grad_output.clone() / ctx.z_scaling_factor
+        return grad_output.clone() / ctx.z_scaling_factor, None, None, None, None, identity_grad, None

LTA_openwebtext_dualt/mini_owt_logdirichlet/.venv_qwen35_uv/lib/python3.12/site-packages/transformers/models/mobilevitv2/configuration_mobilevitv2.py

@@ -0,0 +1,82 @@
+# Copyright 2023 The HuggingFace Inc. team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""MobileViTV2 model configuration"""
+
+from huggingface_hub.dataclasses import strict
+
+from ...configuration_utils import PreTrainedConfig
+from ...utils import auto_docstring
+
+
+@auto_docstring(checkpoint="apple/mobilevitv2-1.0")
+@strict
+class MobileViTV2Config(PreTrainedConfig):
+    r"""
+    aspp_out_channels (`int`, *optional*, defaults to 512):
+        Number of output channels used in the ASPP layer for semantic segmentation.
+    atrous_rates (`list[int]`, *optional*, defaults to `[6, 12, 18]`):
+        Dilation (atrous) factors used in the ASPP layer for semantic segmentation.
+    aspp_dropout_prob (`float`, *optional*, defaults to 0.1):
+        The dropout ratio for the ASPP layer for semantic segmentation.
+    n_attn_blocks (`list[int]`, *optional*, defaults to `[2, 4, 3]`):
+        The number of attention blocks in each MobileViTV2Layer
+    base_attn_unit_dims (`list[int]`, *optional*, defaults to `[128, 192, 256]`):
+        The base multiplier for dimensions of attention blocks in each MobileViTV2Layer
+    width_multiplier (`float`, *optional*, defaults to 1.0):
+        The width multiplier for MobileViTV2.
+    ffn_multiplier (`int`, *optional*, defaults to 2):
+        The FFN multiplier for MobileViTV2.
+    ffn_dropout (`float`, *optional*, defaults to 0.0):
+        The dropout between FFN layers.
+
+    Example:
+
+    ```python
+    >>> from transformers import MobileViTV2Config, MobileViTV2Model
+
+    >>> # Initializing a mobilevitv2-small style configuration
+    >>> configuration = MobileViTV2Config()
+
+    >>> # Initializing a model from the mobilevitv2-small style configuration
+    >>> model = MobileViTV2Model(configuration)
+
+    >>> # Accessing the model configuration
+    >>> configuration = model.config
+    ```"""
+
+    model_type = "mobilevitv2"
+
+    num_channels: int = 3
+    image_size: int | list[int] | tuple[int, int] = 256
+    patch_size: int | list[int] | tuple[int, int] = 2
+    expand_ratio: float = 2.0
+    hidden_act: str = "swish"
+    conv_kernel_size: int = 3
+    output_stride: int = 32
+    classifier_dropout_prob: float | int = 0.1
+    initializer_range: float = 0.02
+    layer_norm_eps: float = 1e-5
+    aspp_out_channels: int = 512
+    atrous_rates: list[int] | tuple[int, ...] = (6, 12, 18)
+    aspp_dropout_prob: float | int = 0.1
+    semantic_loss_ignore_index: int = 255
+    n_attn_blocks: list[int] | tuple[int, ...] = (2, 4, 3)
+    base_attn_unit_dims: list[int] | tuple[int, ...] = (128, 192, 256)
+    width_multiplier: float | int = 1.0
+    ffn_multiplier: int = 2
+    attn_dropout: float | int = 0.0
+    ffn_dropout: float | int = 0.0
+
+
+__all__ = ["MobileViTV2Config"]

LTA_openwebtext_dualt/mini_owt_logdirichlet/.venv_qwen35_uv/lib/python3.12/site-packages/transformers/models/musicgen_melody/configuration_musicgen_melody.py

@@ -0,0 +1,163 @@
+# Copyright 2024 Meta AI and The HuggingFace Inc. team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Musicgen Melody model configuration"""
+
+from huggingface_hub.dataclasses import strict
+
+from ...configuration_utils import PreTrainedConfig
+from ...utils import auto_docstring
+from ..auto.configuration_auto import AutoConfig
+
+
+@auto_docstring(checkpoint="facebook/musicgen-melody")
+@strict
+class MusicgenMelodyDecoderConfig(PreTrainedConfig):
+    r"""
+    audio_channels (`int`, *optional*, defaults to 1):
+        Number of audio channels used by the model (either mono or stereo). Stereo models generate a separate
+        audio stream for the left/right output channels. Mono models generate a single audio stream output.
+    """
+
+    model_type = "musicgen_melody_decoder"
+    base_config_key = "decoder_config"
+    keys_to_ignore_at_inference = ["past_key_values"]
+
+    vocab_size: int = 2048
+    max_position_embeddings: int = 2048
+    num_hidden_layers: int = 24
+    ffn_dim: int = 4096
+    num_attention_heads: int = 16
+    layerdrop: float | int = 0.0
+    use_cache: bool = True
+    activation_function: str = "gelu"
+    hidden_size: int = 1024
+    dropout: float | int = 0.1
+    attention_dropout: float | int = 0.0
+    activation_dropout: float | int = 0.0
+    initializer_factor: float = 0.02
+    scale_embedding: bool = False
+    num_codebooks: int = 4
+    audio_channels: int = 1
+    pad_token_id: int | None = 2048
+    bos_token_id: int | None = 2048
+    eos_token_id: int | list[int] | None = None
+    tie_word_embeddings: bool = False
+    is_decoder: bool = False
+    add_cross_attention: bool = False
+
+    def validate_architecture(self):
+        """Part of `@strict`-powered validation. Validates the architecture of the config."""
+        if self.audio_channels not in [1, 2]:
+            raise ValueError(f"Expected 1 (mono) or 2 (stereo) audio channels, got {self.audio_channels} channels.")
+
+
+@auto_docstring(checkpoint="facebook/musicgen-melody")
+@strict
+class MusicgenMelodyConfig(PreTrainedConfig):
+    r"""
+    text_encoder (`Union[dict, `PretrainedConfig`]`):
+        An instance of a configuration object that defines the text encoder config.
+    audio_encoder (`Union[dict, `PretrainedConfig`]`):
+        An instance of a configuration object that defines the audio encoder config.
+    decoder (`Union[dict, `PretrainedConfig`]`):
+        An instance of a configuration object that defines the decoder config.
+    num_chroma (`int`, *optional*, defaults to 12):
+        Number of chroma bins to use.
+    chroma_length (`int`, *optional*, defaults to 235):
+        Maximum chroma duration if audio is used to condition the model. Corresponds to the maximum duration used during training.
+
+    Example:
+
+    ```python
+    >>> from transformers import (
+    ...     MusicgenMelodyConfig,
+    ...     MusicgenMelodyDecoderConfig,
+    ...     T5Config,
+    ...     EncodecConfig,
+    ...     MusicgenMelodyForConditionalGeneration,
+    ... )
+
+    >>> # Initializing text encoder, audio encoder, and decoder model configurations
+    >>> text_encoder_config = T5Config()
+    >>> audio_encoder_config = EncodecConfig()
+    >>> decoder_config = MusicgenMelodyDecoderConfig()
+
+    >>> configuration = MusicgenMelodyConfig(
+    ...     text_encoder=text_encoder_config, audio_encoder=audio_encoder_config, decoder=decoder_config
+    ... )
+
+    >>> # Initializing a MusicgenMelodyForConditionalGeneration (with random weights) from the facebook/musicgen-melody style configuration
+    >>> model = MusicgenMelodyForConditionalGeneration(configuration)
+
+    >>> # Accessing the model configuration
+    >>> configuration = model.config
+    >>> config_text_encoder = model.config.text_encoder
+    >>> config_audio_encoder = model.config.audio_encoder
+    >>> config_decoder = model.config.decoder
+
+    >>> # Saving the model, including its configuration
+    >>> model.save_pretrained("musicgen_melody-model")
+
+    >>> # loading model and config from pretrained folder
+    >>> musicgen_melody_config = MusicgenMelodyConfig.from_pretrained("musicgen_melody-model")
+    >>> model = MusicgenMelodyForConditionalGeneration.from_pretrained("musicgen_melody-model", config=musicgen_melody_config)
+    ```"""
+
+    model_type = "musicgen_melody"
+    sub_configs = {
+        "text_encoder": AutoConfig,
+        "audio_encoder": AutoConfig,
+        "decoder": MusicgenMelodyDecoderConfig,
+    }
+    has_no_defaults_at_init = True
+
+    text_encoder: dict | PreTrainedConfig = None
+    audio_encoder: dict | PreTrainedConfig = None
+    decoder: dict | PreTrainedConfig = None
+    num_chroma: int = 12
+    chroma_length: int = 235
+    initializer_factor: float = 0.02
+
+    def __post_init__(self, **kwargs):
+        if isinstance(self.text_encoder, dict):
+            text_encoder_model_type = self.text_encoder.pop("model_type")
+            self.text_encoder = AutoConfig.for_model(text_encoder_model_type, **self.text_encoder)
+        elif self.text_encoder is None:
+            raise ValueError(
+                f"A configuration of type {self.model_type} cannot be instantiated because text_encoder is not passed"
+            )
+
+        if isinstance(self.audio_encoder, dict):
+            audio_encoder_model_type = self.audio_encoder.pop("model_type")
+            self.audio_encoder = AutoConfig.for_model(audio_encoder_model_type, **self.audio_encoder)
+        elif self.audio_encoder is None:
+            raise ValueError(
+                f"A configuration of type {self.model_type} cannot be instantiated because audio_encoder is not passed"
+            )
+
+        if isinstance(self.decoder, dict):
+            self.decoder = MusicgenMelodyDecoderConfig(**self.decoder)
+        elif self.decoder is None:
+            self.decoder = MusicgenMelodyDecoderConfig()
+
+        self.is_encoder_decoder = True
+        super().__post_init__(**kwargs)
+
+    @property
+    # This is a property because you might want to change the codec model on the fly
+    def sampling_rate(self):
+        return self.audio_encoder.sampling_rate
+
+
+__all__ = ["MusicgenMelodyConfig", "MusicgenMelodyDecoderConfig"]

LTA_openwebtext_dualt/mini_owt_logdirichlet/.venv_qwen35_uv/lib/python3.12/site-packages/transformers/models/musicgen_melody/processing_musicgen_melody.py

@@ -0,0 +1,117 @@
+# Copyright 2024 Meta AI and The HuggingFace Inc. team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""
+Text/audio processor class for MusicGen Melody
+"""
+
+from typing import Any
+
+import numpy as np
+
+from ...processing_utils import ProcessorMixin
+from ...utils import auto_docstring, to_numpy
+from ...utils.import_utils import requires
+
+
+@requires(backends=("torchaudio",))
+@auto_docstring
+class MusicgenMelodyProcessor(ProcessorMixin):
+    def __init__(self, feature_extractor, tokenizer):
+        super().__init__(feature_extractor, tokenizer)
+
+    # Copied from transformers.models.musicgen.processing_musicgen.MusicgenProcessor.get_decoder_prompt_ids
+    def get_decoder_prompt_ids(self, task=None, language=None, no_timestamps=True):
+        return self.tokenizer.get_decoder_prompt_ids(task=task, language=language, no_timestamps=no_timestamps)
+
+    @auto_docstring
+    def __call__(self, *args, **kwargs):
+        if len(args) > 0:
+            kwargs["audio"] = args[0]
+        return super().__call__(*args, **kwargs)
+
+    # Copied from transformers.models.musicgen.processing_musicgen.MusicgenProcessor.batch_decode with padding_mask->attention_mask
+    def batch_decode(self, *args, **kwargs):
+        """
+        This method is used to decode either batches of audio outputs from the MusicGen model, or batches of token ids
+        from the tokenizer. In the case of decoding token ids, this method forwards all its arguments to T5Tokenizer's
+        [`~PreTrainedTokenizer.batch_decode`]. Please refer to the docstring of this method for more information.
+        """
+        audio_values = kwargs.pop("audio", None)
+        attention_mask = kwargs.pop("attention_mask", None)
+
+        if len(args) > 0:
+            audio_values = args[0]
+            args = args[1:]
+
+        if audio_values is not None:
+            return self._decode_audio(audio_values, attention_mask=attention_mask)
+        else:
+            return self.tokenizer.batch_decode(*args, **kwargs)
+
+    # Copied from transformers.models.musicgen.processing_musicgen.MusicgenProcessor._decode_audio with padding_mask->attention_mask
+    def _decode_audio(self, audio_values, attention_mask: Any = None) -> list[np.ndarray]:
+        """
+        This method strips any padding from the audio values to return a list of numpy audio arrays.
+        """
+        audio_values = to_numpy(audio_values)
+        bsz, channels, seq_len = audio_values.shape
+
+        if attention_mask is None:
+            return list(audio_values)
+
+        attention_mask = to_numpy(attention_mask)
+
+        # match the sequence length of the padding mask to the generated audio arrays by padding with the **non-padding**
+        # token (so that the generated audio values are **not** treated as padded tokens)
+        difference = seq_len - attention_mask.shape[-1]
+        padding_value = 1 - self.feature_extractor.padding_value
+        attention_mask = np.pad(attention_mask, ((0, 0), (0, difference)), "constant", constant_values=padding_value)
+
+        audio_values = audio_values.tolist()
+        for i in range(bsz):
+            sliced_audio = np.asarray(audio_values[i])[
+                attention_mask[i][None, :] != self.feature_extractor.padding_value
+            ]
+            audio_values[i] = sliced_audio.reshape(channels, -1)
+
+        return audio_values
+
+    def get_unconditional_inputs(self, num_samples=1, return_tensors="pt"):
+        """
+        Helper function to get null inputs for unconditional generation, enabling the model to be used without the
+        feature extractor or tokenizer.
+
+        Args:
+            num_samples (int, *optional*):
+                Number of audio samples to unconditionally generate.
+
+        Example:
+        ```python
+        >>> from transformers import MusicgenMelodyForConditionalGeneration, MusicgenMelodyProcessor
+
+        >>> model = MusicgenMelodyForConditionalGeneration.from_pretrained("facebook/musicgen-melody")
+
+        >>> # get the unconditional (or 'null') inputs for the model
+        >>> processor = MusicgenMelodyProcessor.from_pretrained("facebook/musicgen-melody")
+        >>> unconditional_inputs = processor.get_unconditional_inputs(num_samples=1)
+
+        >>> audio_samples = model.generate(**unconditional_inputs, max_new_tokens=256)
+        ```"""
+        inputs = self.tokenizer([""] * num_samples, return_tensors=return_tensors, return_attention_mask=True)
+        inputs["attention_mask"][:] = 0
+
+        return inputs
+
+
+__all__ = ["MusicgenMelodyProcessor"]

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

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

LTA_openwebtext_dualt/mini_owt_logdirichlet/.venv_qwen35_uv/lib/python3.12/site-packages/transformers/models/pp_ocrv5_mobile_det/configuration_pp_ocrv5_mobile_det.py

@@ -0,0 +1,76 @@
+#                🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨
+#           This file was automatically generated from src/transformers/models/pp_ocrv5_mobile_det/modular_pp_ocrv5_mobile_det.py.
+#               Do NOT edit this file manually as any edits will be overwritten by the generation of
+#             the file from the modular. If any change should be done, please apply the change to the
+#                          modular_pp_ocrv5_mobile_det.py file directly. One of our CI enforces this.
+#                🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨
+# Copyright 2026 The PaddlePaddle Team and The HuggingFace Inc. team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+from huggingface_hub.dataclasses import strict
+
+from ...backbone_utils import consolidate_backbone_kwargs_to_config
+from ...configuration_utils import PreTrainedConfig
+from ...utils import auto_docstring
+from ..auto import AutoConfig
+
+
+@auto_docstring(checkpoint="PaddlePaddle/PP-OCRv5_mobile_det_safetensors")
+@strict
+class PPOCRV5MobileDetConfig(PreTrainedConfig):
+    r"""
+    reduction (`int`, *optional*, defaults to 4):
+        The reduction factor for feature channel dimensions, used to reduce the number of model parameters and
+        computational complexity while maintaining feature representability.
+    neck_out_channels (`int`, *optional*, defaults to 96):
+        The number of output channels from the neck network, which is responsible for feature fusion and
+        refinement before passing features to the head network.
+    interpolate_mode (`str`, *optional*, defaults to `"nearest"`):
+        The interpolation mode used for upsampling or downsampling feature maps in the neck network. Supported
+        modes include `"nearest"` (nearest neighbor interpolation) and `"bilinear"`.
+    kernel_list (`List[int]`, *optional*, defaults to `[3, 2, 2]`):
+        The list of kernel sizes for convolutional layers in the head network, used for multi-scale feature
+        extraction to detect text regions of different sizes.
+    layer_list_out_channels (`List[int]`, *optional*, defaults to `[12, 18, 42, 360]`):
+        The list of output channels for each backbone stage, used to configure the input channels of the RSE layers
+        in the neck network for multi-scale feature fusion.
+    """
+
+    model_type = "pp_ocrv5_mobile_det"
+    sub_configs = {"backbone_config": AutoConfig}
+
+    backbone_config: dict | PreTrainedConfig | None = None
+    reduction: int = 4
+    neck_out_channels: int = 96
+    interpolate_mode: str = "nearest"
+    kernel_list: list[int] | tuple[int, ...] = (3, 2, 2)
+    layer_list_out_channels: list[int] | tuple[int, ...] = (12, 18, 42, 360)
+
+    def __post_init__(self, **kwargs):
+        self.backbone_config, kwargs = consolidate_backbone_kwargs_to_config(
+            backbone_config=self.backbone_config,
+            default_config_type="pp_lcnet_v3",
+            default_config_kwargs={
+                "scale": 0.75,
+                "out_features": ["stage2", "stage3", "stage4", "stage5"],
+                "out_indices": [2, 3, 4, 5],
+                "divisor": 16,
+            },
+            **kwargs,
+        )
+        super().__post_init__(**kwargs)
+
+
+__all__ = ["PPOCRV5MobileDetConfig"]

LTA_openwebtext_dualt/mini_owt_logdirichlet/logs/infer_eval_hzj_c1tov_power2_target64_late_m_gamma_20260606_193437.log

@@ -0,0 +1,88 @@
+[2026-06-06T19:34:38+00:00] ckpt=/e2e-data/evad-tech-vla/huangzhijian5/tmp/lta/20260604/owt_t5_elftokenized_full_len1024_C1_toV_power2_d768_l12_h12_gbs512_16gpu_50ep_lr3e4_elfopt_t5embed_unfixed_adaln_rope_noabspos_stateprobadd_selfcond_ce_fast_20260605_024231/step_103000.pt
+[2026-06-06T19:34:38+00:00] vocab=32100 gpu=3 n=64 chunk_n=8
+[2026-06-06T19:34:38+00:00] steps=64
+[2026-06-06T19:34:38+00:00] m=-0.55 -0.50 -0.45
+[2026-06-06T19:34:38+00:00] s=0.45 0.55 0.65
+[2026-06-06T19:34:38+00:00] gamma=1.75 2.00 2.25 2.50
+[2026-06-06T19:34:38+00:00] run steps=64 schedule=logit_normal gamma=1.75 m=-0.55 s=0.45 tag=hzj20260604_adaln_rope_noabspos_C1toV_power2_target64_late_m_gamma_ln_mn0p55_s0p45
+checkpoint=/e2e-data/evad-tech-vla/huangzhijian5/tmp/lta/20260604/owt_t5_elftokenized_full_len1024_C1_toV_power2_d768_l12_h12_gbs512_16gpu_50ep_lr3e4_elfopt_t5embed_unfixed_adaln_rope_noabspos_stateprobadd_selfcond_ce_fast_20260605_024231/step_103000.pt
+use_ema=0
+step=103000
+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_20260606
+[2026-06-06T19:34:38+00:00] infer step=103000 decode=64 -> /e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260606/hzj20260604_adaln_rope_noabspos_C1toV_power2_target64_late_m_gamma_ln_mn0p55_s0p45_step103000_dgamma1p75_tschedlogit_normal_mn0p55_s0p45_sc1p0_decode64_n64
+[2026-06-06T19:34:38+00:00] run decode=64 chunk=0 n=8 seed=123
+[2026-06-06T19:34:48+00:00] done decode=64 chunk=0
+[2026-06-06T19:34:48+00:00] run decode=64 chunk=1 n=8 seed=124
+[2026-06-06T19:34:57+00:00] done decode=64 chunk=1
+[2026-06-06T19:34:57+00:00] run decode=64 chunk=2 n=8 seed=125
+[2026-06-06T19:35:07+00:00] done decode=64 chunk=2
+[2026-06-06T19:35:07+00:00] run decode=64 chunk=3 n=8 seed=126
+[2026-06-06T19:35:17+00:00] done decode=64 chunk=3
+[2026-06-06T19:35:17+00:00] run decode=64 chunk=4 n=8 seed=127
+[2026-06-06T19:35:27+00:00] done decode=64 chunk=4
+[2026-06-06T19:35:27+00:00] run decode=64 chunk=5 n=8 seed=128
+[2026-06-06T19:35:36+00:00] done decode=64 chunk=5
+[2026-06-06T19:35:36+00:00] run decode=64 chunk=6 n=8 seed=129
+[2026-06-06T19:35:46+00:00] done decode=64 chunk=6
+[2026-06-06T19:35:46+00:00] run decode=64 chunk=7 n=8 seed=130
+[2026-06-06T19:35:56+00:00] done decode=64 chunk=7
+merged 64 samples -> /e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260606/hzj20260604_adaln_rope_noabspos_C1toV_power2_target64_late_m_gamma_ln_mn0p55_s0p45_step103000_dgamma1p75_tschedlogit_normal_mn0p55_s0p45_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	10.640914492918917	4.722297613569919	0.04774292272379495	0.30770172458645123	0.0459831675592961	64	64	63596	65350	/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260606/hzj20260604_adaln_rope_noabspos_C1toV_power2_target64_late_m_gamma_ln_mn0p55_s0p45_step103000_dgamma1p75_tschedlogit_normal_mn0p55_s0p45_sc1p0_decode64_n64/sc1p0
+sc1p0	pre_eos	12.733726105125847	4.766069615763403	0.050079478492638205	0.32281631342324985	0.030667458775549526	0	0	57413	62281	/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260606/hzj20260604_adaln_rope_noabspos_C1toV_power2_target64_late_m_gamma_ln_mn0p55_s0p45_step103000_dgamma1p75_tschedlogit_normal_mn0p55_s0p45_sc1p0_decode64_n64/sc1p0
+[2026-06-06T19:36:09+00:00] done
+[2026-06-06T19:36:09+00:00] run steps=64 schedule=logit_normal gamma=2.00 m=-0.55 s=0.45 tag=hzj20260604_adaln_rope_noabspos_C1toV_power2_target64_late_m_gamma_ln_mn0p55_s0p45
+checkpoint=/e2e-data/evad-tech-vla/huangzhijian5/tmp/lta/20260604/owt_t5_elftokenized_full_len1024_C1_toV_power2_d768_l12_h12_gbs512_16gpu_50ep_lr3e4_elfopt_t5embed_unfixed_adaln_rope_noabspos_stateprobadd_selfcond_ce_fast_20260605_024231/step_103000.pt
+use_ema=0
+step=103000
+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_20260606
+[2026-06-06T19:36:09+00:00] infer step=103000 decode=64 -> /e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260606/hzj20260604_adaln_rope_noabspos_C1toV_power2_target64_late_m_gamma_ln_mn0p55_s0p45_step103000_dgamma2p00_tschedlogit_normal_mn0p55_s0p45_sc1p0_decode64_n64
+[2026-06-06T19:36:09+00:00] run decode=64 chunk=0 n=8 seed=123
+[2026-06-06T19:36:19+00:00] done decode=64 chunk=0
+[2026-06-06T19:36:19+00:00] run decode=64 chunk=1 n=8 seed=124
+[2026-06-06T19:36:28+00:00] done decode=64 chunk=1
+[2026-06-06T19:36:28+00:00] run decode=64 chunk=2 n=8 seed=125
+[2026-06-06T19:36:38+00:00] done decode=64 chunk=2
+[2026-06-06T19:36:38+00:00] run decode=64 chunk=3 n=8 seed=126
+[2026-06-06T19:36:48+00:00] done decode=64 chunk=3
+[2026-06-06T19:36:48+00:00] run decode=64 chunk=4 n=8 seed=127
+[2026-06-06T19:36:58+00:00] done decode=64 chunk=4
+[2026-06-06T19:36:58+00:00] run decode=64 chunk=5 n=8 seed=128
+[2026-06-06T19:37:07+00:00] done decode=64 chunk=5
+[2026-06-06T19:37:07+00:00] run decode=64 chunk=6 n=8 seed=129
+[2026-06-06T19:37:17+00:00] done decode=64 chunk=6
+[2026-06-06T19:37:17+00:00] run decode=64 chunk=7 n=8 seed=130
+[2026-06-06T19:37:27+00:00] done decode=64 chunk=7
+merged 64 samples -> /e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260606/hzj20260604_adaln_rope_noabspos_C1toV_power2_target64_late_m_gamma_ln_mn0p55_s0p45_step103000_dgamma2p00_tschedlogit_normal_mn0p55_s0p45_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	10.468534585751161	4.717814945263186	0.04754263708050614	0.30462290822954075	0.04442508710801394	64	65	63758	65436	/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260606/hzj20260604_adaln_rope_noabspos_C1toV_power2_target64_late_m_gamma_ln_mn0p55_s0p45_step103000_dgamma2p00_tschedlogit_normal_mn0p55_s0p45_sc1p0_decode64_n64/sc1p0
+sc1p0	pre_eos	12.402501047712331	4.7589711220796005	0.049788678278688527	0.3190528793045483	0.02804815573770492	0	0	57774	62464	/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260606/hzj20260604_adaln_rope_noabspos_C1toV_power2_target64_late_m_gamma_ln_mn0p55_s0p45_step103000_dgamma2p00_tschedlogit_normal_mn0p55_s0p45_sc1p0_decode64_n64/sc1p0
+[2026-06-06T19:37:40+00:00] done
+[2026-06-06T19:37:40+00:00] run steps=64 schedule=logit_normal gamma=2.25 m=-0.55 s=0.45 tag=hzj20260604_adaln_rope_noabspos_C1toV_power2_target64_late_m_gamma_ln_mn0p55_s0p45
+checkpoint=/e2e-data/evad-tech-vla/huangzhijian5/tmp/lta/20260604/owt_t5_elftokenized_full_len1024_C1_toV_power2_d768_l12_h12_gbs512_16gpu_50ep_lr3e4_elfopt_t5embed_unfixed_adaln_rope_noabspos_stateprobadd_selfcond_ce_fast_20260605_024231/step_103000.pt
+use_ema=0
+step=103000
+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_20260606
+[2026-06-06T19:37:40+00:00] infer step=103000 decode=64 -> /e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260606/hzj20260604_adaln_rope_noabspos_C1toV_power2_target64_late_m_gamma_ln_mn0p55_s0p45_step103000_dgamma2p25_tschedlogit_normal_mn0p55_s0p45_sc1p0_decode64_n64
+[2026-06-06T19:37:40+00:00] run decode=64 chunk=0 n=8 seed=123
+[2026-06-06T19:37:50+00:00] done decode=64 chunk=0
+[2026-06-06T19:37:50+00:00] run decode=64 chunk=1 n=8 seed=124
+[2026-06-06T19:37:59+00:00] done decode=64 chunk=1
+[2026-06-06T19:37:59+00:00] run decode=64 chunk=2 n=8 seed=125
+[2026-06-06T19:38:09+00:00] done decode=64 chunk=2
+[2026-06-06T19:38:09+00:00] run decode=64 chunk=3 n=8 seed=126
+[2026-06-06T19:38:19+00:00] done decode=64 chunk=3
+[2026-06-06T19:38:19+00:00] run decode=64 chunk=4 n=8 seed=127
+[2026-06-06T19:38:29+00:00] done decode=64 chunk=4
+[2026-06-06T19:38:29+00:00] run decode=64 chunk=5 n=8 seed=128
+[2026-06-06T19:38:39+00:00] done decode=64 chunk=5
+[2026-06-06T19:38:39+00:00] run decode=64 chunk=6 n=8 seed=129
+Terminated

LTA_openwebtext_dualt/mini_owt_logdirichlet/logs/infer_eval_lr2e3_ema_decode32_gamma_temp_clean_20260608_155828.log

@@ -0,0 +1,497 @@
+START 2026-06-08T15:58:28+00:00 gpu=3 m=-0.9 s=0.9 g=1.25 temp=0.85
+START 2026-06-08T15:58:28+00:00 gpu=0 m=-0.8 s=1.0 g=1.25 temp=0.85
+START 2026-06-08T15:58:28+00:00 gpu=2 m=-0.7 s=1.1 g=1.50 temp=0.75
+START 2026-06-08T15:58:28+00:00 gpu=1 m=-0.8 s=1.1 g=1.50 temp=0.80
+checkpoint=/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/mini_owt_logdirichlet/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_170000.pt
+use_ema=1
+step=170000
+decode_steps=32
+n=64 chunk_n=8 gpu=3
+out_base=/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608
+checkpoint=/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/mini_owt_logdirichlet/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_170000.pt
+use_ema=1
+step=170000
+decode_steps=32
+n=64 chunk_n=8 gpu=2
+out_base=/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608
+[2026-06-08T15:58:28+00:00] infer step=170000 decode=32 -> /e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_ema_decode32_logitnorm_gamma_temp0p85_mn0p9_s0p9_step170000_ema_dgamma1p25_tschedlogit_normal_mn0p9_s0p9_sc1p0_decode32_n64
+checkpoint=/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/mini_owt_logdirichlet/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_170000.pt
+use_ema=1
+[2026-06-08T15:58:28+00:00] run decode=32 chunk=0 n=8 seed=123
+step=170000
+decode_steps=32
+n=64 chunk_n=8 gpu=1
+out_base=/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608
+checkpoint=/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/mini_owt_logdirichlet/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_170000.pt
+use_ema=1
+step=170000
+decode_steps=32
+n=64 chunk_n=8 gpu=0
+out_base=/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608
+[2026-06-08T15:58:28+00:00] infer step=170000 decode=32 -> /e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_ema_decode32_logitnorm_gamma_temp0p75_mn0p7_s1p1_step170000_ema_dgamma1p50_tschedlogit_normal_mn0p7_s1p1_sc1p0_decode32_n64
+[2026-06-08T15:58:28+00:00] run decode=32 chunk=0 n=8 seed=123
+[2026-06-08T15:58:28+00:00] infer step=170000 decode=32 -> /e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_ema_decode32_logitnorm_gamma_temp0p80_mn0p8_s1p1_step170000_ema_dgamma1p50_tschedlogit_normal_mn0p8_s1p1_sc1p0_decode32_n64
+[2026-06-08T15:58:28+00:00] infer step=170000 decode=32 -> /e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_ema_decode32_logitnorm_gamma_temp0p85_mn0p8_s1p0_step170000_ema_dgamma1p25_tschedlogit_normal_mn0p8_s1p0_sc1p0_decode32_n64
+[2026-06-08T15:58:28+00:00] run decode=32 chunk=0 n=8 seed=123
+[2026-06-08T15:58:28+00:00] run decode=32 chunk=0 n=8 seed=123
+[2026-06-08T15:58:35+00:00] done decode=32 chunk=0
+[2026-06-08T15:58:35+00:00] run decode=32 chunk=1 n=8 seed=124
+[2026-06-08T15:58:35+00:00] done decode=32 chunk=0
+[2026-06-08T15:58:35+00:00] run decode=32 chunk=1 n=8 seed=124
+[2026-06-08T15:58:35+00:00] done decode=32 chunk=0
+[2026-06-08T15:58:35+00:00] run decode=32 chunk=1 n=8 seed=124
+[2026-06-08T15:58:35+00:00] done decode=32 chunk=0
+[2026-06-08T15:58:35+00:00] run decode=32 chunk=1 n=8 seed=124
+[2026-06-08T15:58:42+00:00] done decode=32 chunk=1
+[2026-06-08T15:58:42+00:00] run decode=32 chunk=2 n=8 seed=125
+[2026-06-08T15:58:42+00:00] done decode=32 chunk=1
+[2026-06-08T15:58:42+00:00] run decode=32 chunk=2 n=8 seed=125
+[2026-06-08T15:58:42+00:00] done decode=32 chunk=1
+[2026-06-08T15:58:42+00:00] run decode=32 chunk=2 n=8 seed=125
+[2026-06-08T15:58:42+00:00] done decode=32 chunk=1
+[2026-06-08T15:58:42+00:00] run decode=32 chunk=2 n=8 seed=125
+[2026-06-08T15:58:49+00:00] done decode=32 chunk=2
+[2026-06-08T15:58:49+00:00] run decode=32 chunk=3 n=8 seed=126
+[2026-06-08T15:58:49+00:00] done decode=32 chunk=2
+[2026-06-08T15:58:49+00:00] run decode=32 chunk=3 n=8 seed=126
+[2026-06-08T15:58:49+00:00] done decode=32 chunk=2
+[2026-06-08T15:58:49+00:00] run decode=32 chunk=3 n=8 seed=126
+[2026-06-08T15:58:49+00:00] done decode=32 chunk=2
+[2026-06-08T15:58:49+00:00] run decode=32 chunk=3 n=8 seed=126
+[2026-06-08T15:58:56+00:00] done decode=32 chunk=3
+[2026-06-08T15:58:56+00:00] run decode=32 chunk=4 n=8 seed=127
+[2026-06-08T15:58:56+00:00] done decode=32 chunk=3
+[2026-06-08T15:58:56+00:00] run decode=32 chunk=4 n=8 seed=127
+[2026-06-08T15:58:56+00:00] done decode=32 chunk=3
+[2026-06-08T15:58:56+00:00] run decode=32 chunk=4 n=8 seed=127
+[2026-06-08T15:58:56+00:00] done decode=32 chunk=3
+[2026-06-08T15:58:56+00:00] run decode=32 chunk=4 n=8 seed=127
+[2026-06-08T15:59:03+00:00] done decode=32 chunk=4
+[2026-06-08T15:59:03+00:00] run decode=32 chunk=5 n=8 seed=128
+[2026-06-08T15:59:03+00:00] done decode=32 chunk=4
+[2026-06-08T15:59:03+00:00] run decode=32 chunk=5 n=8 seed=128
+[2026-06-08T15:59:03+00:00] done decode=32 chunk=4
+[2026-06-08T15:59:03+00:00] run decode=32 chunk=5 n=8 seed=128
+[2026-06-08T15:59:03+00:00] done decode=32 chunk=4
+[2026-06-08T15:59:03+00:00] run decode=32 chunk=5 n=8 seed=128
+[2026-06-08T15:59:10+00:00] done decode=32 chunk=5
+[2026-06-08T15:59:10+00:00] run decode=32 chunk=6 n=8 seed=129
+[2026-06-08T15:59:10+00:00] done decode=32 chunk=5
+[2026-06-08T15:59:10+00:00] run decode=32 chunk=6 n=8 seed=129
+[2026-06-08T15:59:10+00:00] done decode=32 chunk=5
+[2026-06-08T15:59:10+00:00] run decode=32 chunk=6 n=8 seed=129
+[2026-06-08T15:59:11+00:00] done decode=32 chunk=5
+[2026-06-08T15:59:11+00:00] run decode=32 chunk=6 n=8 seed=129
+[2026-06-08T15:59:17+00:00] done decode=32 chunk=6
+[2026-06-08T15:59:17+00:00] run decode=32 chunk=7 n=8 seed=130
+[2026-06-08T15:59:17+00:00] done decode=32 chunk=6
+[2026-06-08T15:59:17+00:00] run decode=32 chunk=7 n=8 seed=130
+[2026-06-08T15:59:17+00:00] done decode=32 chunk=6
+[2026-06-08T15:59:17+00:00] run decode=32 chunk=7 n=8 seed=130
+[2026-06-08T15:59:18+00:00] done decode=32 chunk=6
+[2026-06-08T15:59:18+00:00] run decode=32 chunk=7 n=8 seed=130
+[2026-06-08T15:59:24+00:00] done decode=32 chunk=7
+merged 64 samples -> /e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_ema_decode32_logitnorm_gamma_temp0p85_mn0p9_s0p9_step170000_ema_dgamma1p25_tschedlogit_normal_mn0p9_s0p9_sc1p0_decode32_n64/sc1p0/samples64.txt
+[2026-06-08T15:59:24+00:00] done decode=32 chunk=7
+merged 64 samples -> /e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_ema_decode32_logitnorm_gamma_temp0p75_mn0p7_s1p1_step170000_ema_dgamma1p50_tschedlogit_normal_mn0p7_s1p1_sc1p0_decode32_n64/sc1p0/samples64.txt
+[2026-06-08T15:59:24+00:00] done decode=32 chunk=7
+merged 64 samples -> /e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_ema_decode32_logitnorm_gamma_temp0p85_mn0p8_s1p0_step170000_ema_dgamma1p25_tschedlogit_normal_mn0p8_s1p0_sc1p0_decode32_n64/sc1p0/samples64.txt
+[2026-06-08T15:59:24+00:00] done decode=32 chunk=7
+merged 64 samples -> /e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_ema_decode32_logitnorm_gamma_temp0p80_mn0p8_s1p1_step170000_ema_dgamma1p50_tschedlogit_normal_mn0p8_s1p1_sc1p0_decode32_n64/sc1p0/samples64.txt
+loading scorer /e2e-data/evad-tech-vla/wanghan58/models/flowtext_scorers/gpt2-large-standard dtype=fp32 device=cuda
+loading scorer /e2e-data/evad-tech-vla/wanghan58/models/flowtext_scorers/gpt2-large-standard dtype=fp32 device=cuda
+loading scorer /e2e-data/evad-tech-vla/wanghan58/models/flowtext_scorers/gpt2-large-standard dtype=fp32 device=cuda
+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	11.070124312437377	4.65519286538899	0.06271010329441966	0.359687055911251	0.119445632907524	64	64	67706	65444	/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_ema_decode32_logitnorm_gamma_temp0p85_mn0p9_s0p9_step170000_ema_dgamma1p25_tschedlogit_normal_mn0p9_s0p9_sc1p0_decode32_n64/sc1p0
+sc1p0	pre_eos	20.785254545062855	4.884120630649559	0.07127842537741258	0.4088808588999687	0.04054687907162587	0	0	51918	57563	/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_ema_decode32_logitnorm_gamma_temp0p85_mn0p9_s0p9_step170000_ema_dgamma1p25_tschedlogit_normal_mn0p9_s0p9_sc1p0_decode32_n64/sc1p0
+run	kind	ppl	mean_entropy	distinct_1	distinct_2	top_token_mass	eos_rows	eos_total	ppl_tokens	t5_tokens	path
+sc1p0	raw_full	7.616759945116939	4.102183211058663	0.04673841490485449	0.26800367421922844	0.18381531207421808	64	64	71232	65321	/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_ema_decode32_logitnorm_gamma_temp0p75_mn0p7_s1p1_step170000_ema_dgamma1p50_tschedlogit_normal_mn0p7_s1p1_sc1p0_decode32_n64/sc1p0
+sc1p0	pre_eos	19.08605449556637	4.4509622193907346	0.05731455399061033	0.3287010084696426	0.06950234741784038	0	0	47072	53250	/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_ema_decode32_logitnorm_gamma_temp0p75_mn0p7_s1p1_step170000_ema_dgamma1p50_tschedlogit_normal_mn0p7_s1p1_sc1p0_decode32_n64/sc1p0
+run	kind	ppl	mean_entropy	distinct_1	distinct_2	top_token_mass	eos_rows	eos_total	ppl_tokens	t5_tokens	path
+sc1p0	raw_full	11.515904525941828	4.655725635809934	0.06365832772646646	0.36628182582766267	0.12335616857300141	64	64	67915	65396	/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_ema_decode32_logitnorm_gamma_temp0p85_mn0p8_s1p0_step170000_ema_dgamma1p25_tschedlogit_normal_mn0p8_s1p0_sc1p0_decode32_n64/sc1p0
+sc1p0	pre_eos	22.476401220994113	4.898247984366439	0.07267964725399459	0.4182383347303716	0.03904653802497162	0	0	51619	57265	/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_ema_decode32_logitnorm_gamma_temp0p85_mn0p8_s1p0_step170000_ema_dgamma1p25_tschedlogit_normal_mn0p8_s1p0_sc1p0_decode32_n64/sc1p0
+run	kind	ppl	mean_entropy	distinct_1	distinct_2	top_token_mass	eos_rows	eos_total	ppl_tokens	t5_tokens	path
+sc1p0	raw_full	9.135943497408824	4.400322428568748	0.05372431506849315	0.31568486553427005	0.15644875244618395	63	63	70132	65408	/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_ema_decode32_logitnorm_gamma_temp0p80_mn0p8_s1p1_step170000_ema_dgamma1p50_tschedlogit_normal_mn0p8_s1p1_sc1p0_decode32_n64/sc1p0
+sc1p0	pre_eos	19.600845303443453	4.700276763824076	0.06333471513797019	0.3721387116542302	0.04626642394967828	0	0	50263	55483	/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_ema_decode32_logitnorm_gamma_temp0p80_mn0p8_s1p1_step170000_ema_dgamma1p50_tschedlogit_normal_mn0p8_s1p1_sc1p0_decode32_n64/sc1p0
+[2026-06-08T15:59:37+00:00] done
+DONE 2026-06-08T15:59:37+00:00 gpu=3 m=-0.9 s=0.9 g=1.25 temp=0.85
+START 2026-06-08T15:59:38+00:00 gpu=3 m=-0.9 s=0.9 g=1.50 temp=0.85
+checkpoint=/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/mini_owt_logdirichlet/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_170000.pt
+use_ema=1
+step=170000
+decode_steps=32
+n=64 chunk_n=8 gpu=3
+out_base=/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608
+[2026-06-08T15:59:38+00:00] infer step=170000 decode=32 -> /e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_ema_decode32_logitnorm_gamma_temp0p85_mn0p9_s0p9_step170000_ema_dgamma1p50_tschedlogit_normal_mn0p9_s0p9_sc1p0_decode32_n64
+[2026-06-08T15:59:38+00:00] run decode=32 chunk=0 n=8 seed=123
+[2026-06-08T15:59:38+00:00] done
+DONE 2026-06-08T15:59:38+00:00 gpu=2 m=-0.7 s=1.1 g=1.50 temp=0.75
+START 2026-06-08T15:59:38+00:00 gpu=2 m=-0.7 s=1.1 g=1.50 temp=0.80
+[2026-06-08T15:59:38+00:00] done
+DONE 2026-06-08T15:59:38+00:00 gpu=0 m=-0.8 s=1.0 g=1.25 temp=0.85
+checkpoint=/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/mini_owt_logdirichlet/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_170000.pt
+use_ema=1
+step=170000
+decode_steps=32
+n=64 chunk_n=8 gpu=2
+out_base=/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608
+[2026-06-08T15:59:38+00:00] infer step=170000 decode=32 -> /e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_ema_decode32_logitnorm_gamma_temp0p80_mn0p7_s1p1_step170000_ema_dgamma1p50_tschedlogit_normal_mn0p7_s1p1_sc1p0_decode32_n64
+[2026-06-08T15:59:38+00:00] run decode=32 chunk=0 n=8 seed=123
+START 2026-06-08T15:59:38+00:00 gpu=0 m=-0.8 s=1.0 g=1.25 temp=0.90
+checkpoint=/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/mini_owt_logdirichlet/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_170000.pt
+use_ema=1
+step=170000
+decode_steps=32
+n=64 chunk_n=8 gpu=0
+out_base=/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608
+[2026-06-08T15:59:38+00:00] infer step=170000 decode=32 -> /e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_ema_decode32_logitnorm_gamma_temp0p90_mn0p8_s1p0_step170000_ema_dgamma1p25_tschedlogit_normal_mn0p8_s1p0_sc1p0_decode32_n64
+[2026-06-08T15:59:38+00:00] run decode=32 chunk=0 n=8 seed=123
+[2026-06-08T15:59:38+00:00] done
+DONE 2026-06-08T15:59:38+00:00 gpu=1 m=-0.8 s=1.1 g=1.50 temp=0.80
+START 2026-06-08T15:59:38+00:00 gpu=1 m=-0.8 s=1.1 g=1.50 temp=0.85
+checkpoint=/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/mini_owt_logdirichlet/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_170000.pt
+use_ema=1
+step=170000
+decode_steps=32
+n=64 chunk_n=8 gpu=1
+out_base=/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608
+[2026-06-08T15:59:38+00:00] infer step=170000 decode=32 -> /e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_ema_decode32_logitnorm_gamma_temp0p85_mn0p8_s1p1_step170000_ema_dgamma1p50_tschedlogit_normal_mn0p8_s1p1_sc1p0_decode32_n64
+[2026-06-08T15:59:38+00:00] run decode=32 chunk=0 n=8 seed=123
+[2026-06-08T15:59:45+00:00] done decode=32 chunk=0
+[2026-06-08T15:59:45+00:00] run decode=32 chunk=1 n=8 seed=124
+[2026-06-08T15:59:45+00:00] done decode=32 chunk=0
+[2026-06-08T15:59:45+00:00] run decode=32 chunk=1 n=8 seed=124
+[2026-06-08T15:59:45+00:00] done decode=32 chunk=0
+[2026-06-08T15:59:45+00:00] run decode=32 chunk=1 n=8 seed=124
+[2026-06-08T15:59:45+00:00] done decode=32 chunk=0
+[2026-06-08T15:59:45+00:00] run decode=32 chunk=1 n=8 seed=124
+[2026-06-08T15:59:52+00:00] done decode=32 chunk=1
+[2026-06-08T15:59:52+00:00] run decode=32 chunk=2 n=8 seed=125
+[2026-06-08T15:59:52+00:00] done decode=32 chunk=1
+[2026-06-08T15:59:52+00:00] run decode=32 chunk=2 n=8 seed=125
+[2026-06-08T15:59:52+00:00] done decode=32 chunk=1
+[2026-06-08T15:59:52+00:00] run decode=32 chunk=2 n=8 seed=125
+[2026-06-08T15:59:52+00:00] done decode=32 chunk=1
+[2026-06-08T15:59:52+00:00] run decode=32 chunk=2 n=8 seed=125
+[2026-06-08T15:59:59+00:00] done decode=32 chunk=2
+[2026-06-08T15:59:59+00:00] run decode=32 chunk=3 n=8 seed=126
+[2026-06-08T15:59:59+00:00] done decode=32 chunk=2
+[2026-06-08T15:59:59+00:00] run decode=32 chunk=3 n=8 seed=126
+[2026-06-08T15:59:59+00:00] done decode=32 chunk=2
+[2026-06-08T15:59:59+00:00] run decode=32 chunk=3 n=8 seed=126
+[2026-06-08T15:59:59+00:00] done decode=32 chunk=2
+[2026-06-08T15:59:59+00:00] run decode=32 chunk=3 n=8 seed=126
+[2026-06-08T16:00:06+00:00] done decode=32 chunk=3
+[2026-06-08T16:00:06+00:00] run decode=32 chunk=4 n=8 seed=127
+[2026-06-08T16:00:06+00:00] done decode=32 chunk=3
+[2026-06-08T16:00:06+00:00] run decode=32 chunk=4 n=8 seed=127
+[2026-06-08T16:00:06+00:00] done decode=32 chunk=3
+[2026-06-08T16:00:06+00:00] run decode=32 chunk=4 n=8 seed=127
+[2026-06-08T16:00:06+00:00] done decode=32 chunk=3
+[2026-06-08T16:00:06+00:00] run decode=32 chunk=4 n=8 seed=127
+[2026-06-08T16:00:14+00:00] done decode=32 chunk=4
+[2026-06-08T16:00:14+00:00] run decode=32 chunk=5 n=8 seed=128
+[2026-06-08T16:00:14+00:00] done decode=32 chunk=4
+[2026-06-08T16:00:14+00:00] run decode=32 chunk=5 n=8 seed=128
+[2026-06-08T16:00:14+00:00] done decode=32 chunk=4
+[2026-06-08T16:00:14+00:00] run decode=32 chunk=5 n=8 seed=128
+[2026-06-08T16:00:14+00:00] done decode=32 chunk=4
+[2026-06-08T16:00:14+00:00] run decode=32 chunk=5 n=8 seed=128
+[2026-06-08T16:00:20+00:00] done decode=32 chunk=5
+[2026-06-08T16:00:20+00:00] run decode=32 chunk=6 n=8 seed=129
+[2026-06-08T16:00:21+00:00] done decode=32 chunk=5
+[2026-06-08T16:00:21+00:00] run decode=32 chunk=6 n=8 seed=129
+[2026-06-08T16:00:21+00:00] done decode=32 chunk=5
+[2026-06-08T16:00:21+00:00] run decode=32 chunk=6 n=8 seed=129
+[2026-06-08T16:00:21+00:00] done decode=32 chunk=5
+[2026-06-08T16:00:21+00:00] run decode=32 chunk=6 n=8 seed=129
+[2026-06-08T16:00:28+00:00] done decode=32 chunk=6
+[2026-06-08T16:00:28+00:00] run decode=32 chunk=7 n=8 seed=130
+[2026-06-08T16:00:28+00:00] done decode=32 chunk=6
+[2026-06-08T16:00:28+00:00] run decode=32 chunk=7 n=8 seed=130
+[2026-06-08T16:00:28+00:00] done decode=32 chunk=6
+[2026-06-08T16:00:28+00:00] run decode=32 chunk=7 n=8 seed=130
+[2026-06-08T16:00:28+00:00] done decode=32 chunk=6
+[2026-06-08T16:00:28+00:00] run decode=32 chunk=7 n=8 seed=130
+[2026-06-08T16:00:35+00:00] done decode=32 chunk=7
+merged 64 samples -> /e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_ema_decode32_logitnorm_gamma_temp0p85_mn0p9_s0p9_step170000_ema_dgamma1p50_tschedlogit_normal_mn0p9_s0p9_sc1p0_decode32_n64/sc1p0/samples64.txt
+[2026-06-08T16:00:35+00:00] done decode=32 chunk=7
+merged 64 samples -> /e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_ema_decode32_logitnorm_gamma_temp0p80_mn0p7_s1p1_step170000_ema_dgamma1p50_tschedlogit_normal_mn0p7_s1p1_sc1p0_decode32_n64/sc1p0/samples64.txt
+[2026-06-08T16:00:35+00:00] done decode=32 chunk=7
+merged 64 samples -> /e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_ema_decode32_logitnorm_gamma_temp0p85_mn0p8_s1p1_step170000_ema_dgamma1p50_tschedlogit_normal_mn0p8_s1p1_sc1p0_decode32_n64/sc1p0/samples64.txt
+[2026-06-08T16:00:35+00:00] done decode=32 chunk=7
+merged 64 samples -> /e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_ema_decode32_logitnorm_gamma_temp0p90_mn0p8_s1p0_step170000_ema_dgamma1p25_tschedlogit_normal_mn0p8_s1p0_sc1p0_decode32_n64/sc1p0/samples64.txt
+loading scorer /e2e-data/evad-tech-vla/wanghan58/models/flowtext_scorers/gpt2-large-standard dtype=fp32 device=cuda
+loading scorer /e2e-data/evad-tech-vla/wanghan58/models/flowtext_scorers/gpt2-large-standard dtype=fp32 device=cuda
+loading scorer /e2e-data/evad-tech-vla/wanghan58/models/flowtext_scorers/gpt2-large-standard dtype=fp32 device=cuda
+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	10.265592840366459	4.457418513503148	0.05816996464808778	0.33480762755960947	0.15184488009427177	64	64	69312	65343	/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_ema_decode32_logitnorm_gamma_temp0p80_mn0p7_s1p1_step170000_ema_dgamma1p50_tschedlogit_normal_mn0p7_s1p1_sc1p0_decode32_n64/sc1p0
+sc1p0	pre_eos	23.61029622003903	4.769371750281435	0.06864533843958306	0.39515138377050363	0.046173022381993244	0	0	49321	55357	/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_ema_decode32_logitnorm_gamma_temp0p80_mn0p7_s1p1_step170000_ema_dgamma1p50_tschedlogit_normal_mn0p7_s1p1_sc1p0_decode32_n64/sc1p0
+run	kind	ppl	mean_entropy	distinct_1	distinct_2	top_token_mass	eos_rows	eos_total	ppl_tokens	t5_tokens	path
+sc1p0	raw_full	11.31552286051023	4.661387639087806	0.06216286425940924	0.3643643031784841	0.12056661725829373	64	65	67465	65441	/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_ema_decode32_logitnorm_gamma_temp0p85_mn0p9_s0p9_step170000_ema_dgamma1p50_tschedlogit_normal_mn0p9_s0p9_sc1p0_decode32_n64/sc1p0
+sc1p0	pre_eos	21.656060655786927	4.8940182649079995	0.07074766029989911	0.41471688266504303	0.03903559127439724	0	0	51527	57486	/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_ema_decode32_logitnorm_gamma_temp0p85_mn0p9_s0p9_step170000_ema_dgamma1p50_tschedlogit_normal_mn0p9_s0p9_sc1p0_decode32_n64/sc1p0
+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.082236733645013	4.883199936364426	0.07358447314128524	0.417917290705138	0.09166348284557194	63	64	66095	65435	/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_ema_decode32_logitnorm_gamma_temp0p90_mn0p8_s1p0_step170000_ema_dgamma1p25_tschedlogit_normal_mn0p8_s1p0_sc1p0_decode32_n64/sc1p0
+sc1p0	pre_eos	25.306914170301866	5.052927335103899	0.08105787683916367	0.46032895069106583	0.034359112487795024	0	0	54000	59402	/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_ema_decode32_logitnorm_gamma_temp0p90_mn0p8_s1p0_step170000_ema_dgamma1p25_tschedlogit_normal_mn0p8_s1p0_sc1p0_decode32_n64/sc1p0
+run	kind	ppl	mean_entropy	distinct_1	distinct_2	top_token_mass	eos_rows	eos_total	ppl_tokens	t5_tokens	path
+sc1p0	raw_full	11.506839533323399	4.663300880596172	0.06293738349173364	0.36525326610130643	0.1251413378968921	64	64	68240	65446	/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_ema_decode32_logitnorm_gamma_temp0p85_mn0p8_s1p1_step170000_ema_dgamma1p50_tschedlogit_normal_mn0p8_s1p1_sc1p0_decode32_n64/sc1p0
+sc1p0	pre_eos	22.610227884964743	4.913773546931558	0.07200307735347601	0.41791540627021734	0.039725835781228146	0	0	51710	57192	/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_ema_decode32_logitnorm_gamma_temp0p85_mn0p8_s1p1_step170000_ema_dgamma1p50_tschedlogit_normal_mn0p8_s1p1_sc1p0_decode32_n64/sc1p0
+[2026-06-08T16:00:48+00:00] done
+DONE 2026-06-08T16:00:48+00:00 gpu=2 m=-0.7 s=1.1 g=1.50 temp=0.80
+START 2026-06-08T16:00:48+00:00 gpu=2 m=-0.7 s=1.1 g=1.75 temp=0.80
+checkpoint=/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/mini_owt_logdirichlet/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_170000.pt
+use_ema=1
+step=170000
+decode_steps=32
+n=64 chunk_n=8 gpu=2
+out_base=/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608
+[2026-06-08T16:00:48+00:00] infer step=170000 decode=32 -> /e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_ema_decode32_logitnorm_gamma_temp0p80_mn0p7_s1p1_step170000_ema_dgamma1p75_tschedlogit_normal_mn0p7_s1p1_sc1p0_decode32_n64
+[2026-06-08T16:00:48+00:00] run decode=32 chunk=0 n=8 seed=123
+[2026-06-08T16:00:48+00:00] done
+DONE 2026-06-08T16:00:48+00:00 gpu=3 m=-0.9 s=0.9 g=1.50 temp=0.85
+START 2026-06-08T16:00:48+00:00 gpu=3 m=-1.0 s=1.0 g=1.25 temp=0.85
+[2026-06-08T16:00:48+00:00] done
+DONE 2026-06-08T16:00:48+00:00 gpu=0 m=-0.8 s=1.0 g=1.25 temp=0.90
+checkpoint=/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/mini_owt_logdirichlet/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_170000.pt
+use_ema=1
+step=170000
+decode_steps=32
+n=64 chunk_n=8 gpu=3
+out_base=/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608
+[2026-06-08T16:00:48+00:00] infer step=170000 decode=32 -> /e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_ema_decode32_logitnorm_gamma_temp0p85_mn1p0_s1p0_step170000_ema_dgamma1p25_tschedlogit_normal_mn1p0_s1p0_sc1p0_decode32_n64
+[2026-06-08T16:00:48+00:00] run decode=32 chunk=0 n=8 seed=123
+START 2026-06-08T16:00:48+00:00 gpu=0 m=-0.8 s=1.0 g=1.50 temp=0.85
+[2026-06-08T16:00:48+00:00] done
+DONE 2026-06-08T16:00:48+00:00 gpu=1 m=-0.8 s=1.1 g=1.50 temp=0.85
+checkpoint=/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/mini_owt_logdirichlet/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_170000.pt
+use_ema=1
+step=170000
+decode_steps=32
+n=64 chunk_n=8 gpu=0
+out_base=/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608
+[2026-06-08T16:00:48+00:00] infer step=170000 decode=32 -> /e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_ema_decode32_logitnorm_gamma_temp0p85_mn0p8_s1p0_step170000_ema_dgamma1p50_tschedlogit_normal_mn0p8_s1p0_sc1p0_decode32_n64
+[2026-06-08T16:00:48+00:00] run decode=32 chunk=0 n=8 seed=123
+START 2026-06-08T16:00:49+00:00 gpu=1 m=-0.8 s=1.1 g=1.75 temp=0.85
+checkpoint=/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/mini_owt_logdirichlet/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_170000.pt
+use_ema=1
+step=170000
+decode_steps=32
+n=64 chunk_n=8 gpu=1
+out_base=/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608
+[2026-06-08T16:00:49+00:00] infer step=170000 decode=32 -> /e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_ema_decode32_logitnorm_gamma_temp0p85_mn0p8_s1p1_step170000_ema_dgamma1p75_tschedlogit_normal_mn0p8_s1p1_sc1p0_decode32_n64
+[2026-06-08T16:00:49+00:00] run decode=32 chunk=0 n=8 seed=123
+[2026-06-08T16:00:55+00:00] done decode=32 chunk=0
+[2026-06-08T16:00:55+00:00] run decode=32 chunk=1 n=8 seed=124
+[2026-06-08T16:00:55+00:00] done decode=32 chunk=0
+[2026-06-08T16:00:55+00:00] run decode=32 chunk=1 n=8 seed=124
+[2026-06-08T16:00:55+00:00] done decode=32 chunk=0
+[2026-06-08T16:00:55+00:00] run decode=32 chunk=1 n=8 seed=124
+[2026-06-08T16:00:56+00:00] done decode=32 chunk=0
+[2026-06-08T16:00:56+00:00] run decode=32 chunk=1 n=8 seed=124
+[2026-06-08T16:01:02+00:00] done decode=32 chunk=1
+[2026-06-08T16:01:02+00:00] run decode=32 chunk=2 n=8 seed=125
+[2026-06-08T16:01:02+00:00] done decode=32 chunk=1
+[2026-06-08T16:01:02+00:00] run decode=32 chunk=2 n=8 seed=125
+[2026-06-08T16:01:03+00:00] done decode=32 chunk=1
+[2026-06-08T16:01:03+00:00] run decode=32 chunk=2 n=8 seed=125
+[2026-06-08T16:01:03+00:00] done decode=32 chunk=1
+[2026-06-08T16:01:03+00:00] run decode=32 chunk=2 n=8 seed=125
+[2026-06-08T16:01:09+00:00] done decode=32 chunk=2
+[2026-06-08T16:01:09+00:00] run decode=32 chunk=3 n=8 seed=126
+[2026-06-08T16:01:10+00:00] done decode=32 chunk=2
+[2026-06-08T16:01:10+00:00] run decode=32 chunk=3 n=8 seed=126
+[2026-06-08T16:01:10+00:00] done decode=32 chunk=2
+[2026-06-08T16:01:10+00:00] run decode=32 chunk=3 n=8 seed=126
+[2026-06-08T16:01:10+00:00] done decode=32 chunk=2
+[2026-06-08T16:01:10+00:00] run decode=32 chunk=3 n=8 seed=126
+[2026-06-08T16:01:16+00:00] done decode=32 chunk=3
+[2026-06-08T16:01:16+00:00] run decode=32 chunk=4 n=8 seed=127
+[2026-06-08T16:01:17+00:00] done decode=32 chunk=3
+[2026-06-08T16:01:17+00:00] run decode=32 chunk=4 n=8 seed=127
+[2026-06-08T16:01:17+00:00] done decode=32 chunk=3
+[2026-06-08T16:01:17+00:00] run decode=32 chunk=4 n=8 seed=127
+[2026-06-08T16:01:17+00:00] done decode=32 chunk=3
+[2026-06-08T16:01:17+00:00] run decode=32 chunk=4 n=8 seed=127
+[2026-06-08T16:01:23+00:00] done decode=32 chunk=4
+[2026-06-08T16:01:23+00:00] run decode=32 chunk=5 n=8 seed=128
+[2026-06-08T16:01:24+00:00] done decode=32 chunk=4
+[2026-06-08T16:01:24+00:00] run decode=32 chunk=5 n=8 seed=128
+[2026-06-08T16:01:24+00:00] done decode=32 chunk=4
+[2026-06-08T16:01:24+00:00] run decode=32 chunk=5 n=8 seed=128
+[2026-06-08T16:01:24+00:00] done decode=32 chunk=4
+[2026-06-08T16:01:24+00:00] run decode=32 chunk=5 n=8 seed=128
+[2026-06-08T16:01:30+00:00] done decode=32 chunk=5
+[2026-06-08T16:01:30+00:00] run decode=32 chunk=6 n=8 seed=129
+[2026-06-08T16:01:31+00:00] done decode=32 chunk=5
+[2026-06-08T16:01:31+00:00] run decode=32 chunk=6 n=8 seed=129
+[2026-06-08T16:01:31+00:00] done decode=32 chunk=5
+[2026-06-08T16:01:31+00:00] run decode=32 chunk=6 n=8 seed=129
+[2026-06-08T16:01:31+00:00] done decode=32 chunk=5
+[2026-06-08T16:01:31+00:00] run decode=32 chunk=6 n=8 seed=129
+[2026-06-08T16:01:37+00:00] done decode=32 chunk=6
+[2026-06-08T16:01:37+00:00] run decode=32 chunk=7 n=8 seed=130
+[2026-06-08T16:01:38+00:00] done decode=32 chunk=6
+[2026-06-08T16:01:38+00:00] run decode=32 chunk=7 n=8 seed=130
+[2026-06-08T16:01:38+00:00] done decode=32 chunk=6
+[2026-06-08T16:01:38+00:00] run decode=32 chunk=7 n=8 seed=130
+[2026-06-08T16:01:38+00:00] done decode=32 chunk=6
+[2026-06-08T16:01:38+00:00] run decode=32 chunk=7 n=8 seed=130
+[2026-06-08T16:01:44+00:00] done decode=32 chunk=7
+merged 64 samples -> /e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_ema_decode32_logitnorm_gamma_temp0p80_mn0p7_s1p1_step170000_ema_dgamma1p75_tschedlogit_normal_mn0p7_s1p1_sc1p0_decode32_n64/sc1p0/samples64.txt
+[2026-06-08T16:01:44+00:00] done decode=32 chunk=7
+merged 64 samples -> /e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_ema_decode32_logitnorm_gamma_temp0p85_mn0p8_s1p0_step170000_ema_dgamma1p50_tschedlogit_normal_mn0p8_s1p0_sc1p0_decode32_n64/sc1p0/samples64.txt
+[2026-06-08T16:01:45+00:00] done decode=32 chunk=7
+merged 64 samples -> /e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_ema_decode32_logitnorm_gamma_temp0p85_mn0p8_s1p1_step170000_ema_dgamma1p75_tschedlogit_normal_mn0p8_s1p1_sc1p0_decode32_n64/sc1p0/samples64.txt
+[2026-06-08T16:01:45+00:00] done decode=32 chunk=7
+merged 64 samples -> /e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_ema_decode32_logitnorm_gamma_temp0p85_mn1p0_s1p0_step170000_ema_dgamma1p25_tschedlogit_normal_mn1p0_s1p0_sc1p0_decode32_n64/sc1p0/samples64.txt
+loading scorer /e2e-data/evad-tech-vla/wanghan58/models/flowtext_scorers/gpt2-large-standard dtype=fp32 device=cuda
+loading scorer /e2e-data/evad-tech-vla/wanghan58/models/flowtext_scorers/gpt2-large-standard dtype=fp32 device=cuda
+loading scorer /e2e-data/evad-tech-vla/wanghan58/models/flowtext_scorers/gpt2-large-standard dtype=fp32 device=cuda
+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	9.65923362364878	4.407853696839257	0.05700694423200465	0.32760756841090904	0.16034445838049496	64	64	69914	65378	/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_ema_decode32_logitnorm_gamma_temp0p80_mn0p7_s1p1_step170000_ema_dgamma1p75_tschedlogit_normal_mn0p7_s1p1_sc1p0_decode32_n64/sc1p0
+sc1p0	pre_eos	23.005313688571082	4.745441029545589	0.06795425945176999	0.39057085537114716	0.04750962047017198	0	0	48797	54831	/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_ema_decode32_logitnorm_gamma_temp0p80_mn0p7_s1p1_step170000_ema_dgamma1p75_tschedlogit_normal_mn0p7_s1p1_sc1p0_decode32_n64/sc1p0
+run	kind	ppl	mean_entropy	distinct_1	distinct_2	top_token_mass	eos_rows	eos_total	ppl_tokens	t5_tokens	path
+sc1p0	raw_full	11.911114127538909	4.6791719450002605	0.0626051576983083	0.36976306652186547	0.12173819939429166	64	65	67949	65378	/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_ema_decode32_logitnorm_gamma_temp0p85_mn0p8_s1p1_step170000_ema_dgamma1p75_tschedlogit_normal_mn0p8_s1p1_sc1p0_decode32_n64/sc1p0
+sc1p0	pre_eos	23.161772767725143	4.918645581116644	0.0713463751438435	0.42142520879465767	0.03813160372423894	0	0	51874	57354	/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_ema_decode32_logitnorm_gamma_temp0p85_mn0p8_s1p1_step170000_ema_dgamma1p75_tschedlogit_normal_mn0p8_s1p1_sc1p0_decode32_n64/sc1p0
+run	kind	ppl	mean_entropy	distinct_1	distinct_2	top_token_mass	eos_rows	eos_total	ppl_tokens	t5_tokens	path
+sc1p0	raw_full	9.398436075113347	4.548769310645324	0.05566928412111583	0.32534335517973634	0.13061810626661371	64	64	69041	65458	/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_ema_decode32_logitnorm_gamma_temp0p85_mn1p0_s1p0_step170000_ema_dgamma1p25_tschedlogit_normal_mn1p0_s1p0_sc1p0_decode32_n64/sc1p0
+sc1p0	pre_eos	17.817930065523747	4.804120282162531	0.06408767855886285	0.37459317769998063	0.0420097107874182	0	0	51789	56844	/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_ema_decode32_logitnorm_gamma_temp0p85_mn1p0_s1p0_step170000_ema_dgamma1p25_tschedlogit_normal_mn1p0_s1p0_sc1p0_decode32_n64/sc1p0
+run	kind	ppl	mean_entropy	distinct_1	distinct_2	top_token_mass	eos_rows	eos_total	ppl_tokens	t5_tokens	path
+sc1p0	raw_full	12.232338808767638	4.690636286449728	0.0644766623845354	0.37316286111918273	0.1213678350767725	64	64	67633	65388	/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_ema_decode32_logitnorm_gamma_temp0p85_mn0p8_s1p0_step170000_ema_dgamma1p50_tschedlogit_normal_mn0p8_s1p0_sc1p0_decode32_n64/sc1p0
+sc1p0	pre_eos	24.035775235816466	4.928966073420276	0.07344741060848958	0.4251311272587868	0.03983411166097442	0	0	51611	57388	/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_ema_decode32_logitnorm_gamma_temp0p85_mn0p8_s1p0_step170000_ema_dgamma1p50_tschedlogit_normal_mn0p8_s1p0_sc1p0_decode32_n64/sc1p0
+[2026-06-08T16:01:58+00:00] done
+DONE 2026-06-08T16:01:58+00:00 gpu=2 m=-0.7 s=1.1 g=1.75 temp=0.80
+START 2026-06-08T16:01:58+00:00 gpu=2 m=-0.7 s=1.1 g=1.75 temp=0.85
+checkpoint=/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/mini_owt_logdirichlet/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_170000.pt
+use_ema=1
+step=170000
+decode_steps=32
+n=64 chunk_n=8 gpu=2
+out_base=/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608
+[2026-06-08T16:01:58+00:00] infer step=170000 decode=32 -> /e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_ema_decode32_logitnorm_gamma_temp0p85_mn0p7_s1p1_step170000_ema_dgamma1p75_tschedlogit_normal_mn0p7_s1p1_sc1p0_decode32_n64
+[2026-06-08T16:01:58+00:00] run decode=32 chunk=0 n=8 seed=123
+[2026-06-08T16:01:58+00:00] done
+DONE 2026-06-08T16:01:58+00:00 gpu=1 m=-0.8 s=1.1 g=1.75 temp=0.85
+START 2026-06-08T16:01:58+00:00 gpu=1 m=-0.8 s=1.1 g=1.75 temp=0.90
+[2026-06-08T16:01:58+00:00] done
+DONE 2026-06-08T16:01:58+00:00 gpu=3 m=-1.0 s=1.0 g=1.25 temp=0.85
+checkpoint=/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/mini_owt_logdirichlet/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_170000.pt
+use_ema=1
+step=170000
+decode_steps=32
+n=64 chunk_n=8 gpu=1
+out_base=/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608
+[2026-06-08T16:01:58+00:00] infer step=170000 decode=32 -> /e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_ema_decode32_logitnorm_gamma_temp0p90_mn0p8_s1p1_step170000_ema_dgamma1p75_tschedlogit_normal_mn0p8_s1p1_sc1p0_decode32_n64
+[2026-06-08T16:01:58+00:00] run decode=32 chunk=0 n=8 seed=123
+START 2026-06-08T16:01:58+00:00 gpu=3 m=-1.0 s=1.0 g=1.50 temp=0.85
+checkpoint=/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/mini_owt_logdirichlet/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_170000.pt
+use_ema=1
+step=170000
+decode_steps=32
+n=64 chunk_n=8 gpu=3
+out_base=/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608
+[2026-06-08T16:01:58+00:00] infer step=170000 decode=32 -> /e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_ema_decode32_logitnorm_gamma_temp0p85_mn1p0_s1p0_step170000_ema_dgamma1p50_tschedlogit_normal_mn1p0_s1p0_sc1p0_decode32_n64
+[2026-06-08T16:01:58+00:00] run decode=32 chunk=0 n=8 seed=123
+[2026-06-08T16:01:58+00:00] done
+DONE 2026-06-08T16:01:58+00:00 gpu=0 m=-0.8 s=1.0 g=1.50 temp=0.85
+START 2026-06-08T16:01:58+00:00 gpu=0 m=-0.8 s=1.0 g=1.50 temp=0.90
+checkpoint=/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/mini_owt_logdirichlet/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_170000.pt
+use_ema=1
+step=170000
+decode_steps=32
+n=64 chunk_n=8 gpu=0
+out_base=/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608
+[2026-06-08T16:01:58+00:00] infer step=170000 decode=32 -> /e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_ema_decode32_logitnorm_gamma_temp0p90_mn0p8_s1p0_step170000_ema_dgamma1p50_tschedlogit_normal_mn0p8_s1p0_sc1p0_decode32_n64
+[2026-06-08T16:01:58+00:00] run decode=32 chunk=0 n=8 seed=123
+[2026-06-08T16:02:05+00:00] done decode=32 chunk=0
+[2026-06-08T16:02:05+00:00] run decode=32 chunk=1 n=8 seed=124
+[2026-06-08T16:02:05+00:00] done decode=32 chunk=0
+[2026-06-08T16:02:05+00:00] run decode=32 chunk=1 n=8 seed=124
+[2026-06-08T16:02:05+00:00] done decode=32 chunk=0
+[2026-06-08T16:02:05+00:00] run decode=32 chunk=1 n=8 seed=124
+[2026-06-08T16:02:05+00:00] done decode=32 chunk=0
+[2026-06-08T16:02:05+00:00] run decode=32 chunk=1 n=8 seed=124
+[2026-06-08T16:02:12+00:00] done decode=32 chunk=1
+[2026-06-08T16:02:12+00:00] run decode=32 chunk=2 n=8 seed=125
+[2026-06-08T16:02:12+00:00] done decode=32 chunk=1
+[2026-06-08T16:02:12+00:00] run decode=32 chunk=2 n=8 seed=125
+[2026-06-08T16:02:12+00:00] done decode=32 chunk=1
+[2026-06-08T16:02:12+00:00] run decode=32 chunk=2 n=8 seed=125
+[2026-06-08T16:02:13+00:00] done decode=32 chunk=1
+[2026-06-08T16:02:13+00:00] run decode=32 chunk=2 n=8 seed=125
+[2026-06-08T16:02:19+00:00] done decode=32 chunk=2
+[2026-06-08T16:02:19+00:00] run decode=32 chunk=3 n=8 seed=126
+[2026-06-08T16:02:19+00:00] done decode=32 chunk=2
+[2026-06-08T16:02:19+00:00] run decode=32 chunk=3 n=8 seed=126
+[2026-06-08T16:02:19+00:00] done decode=32 chunk=2
+[2026-06-08T16:02:19+00:00] run decode=32 chunk=3 n=8 seed=126
+[2026-06-08T16:02:20+00:00] done decode=32 chunk=2
+[2026-06-08T16:02:20+00:00] run decode=32 chunk=3 n=8 seed=126
+[2026-06-08T16:02:26+00:00] done decode=32 chunk=3
+[2026-06-08T16:02:26+00:00] run decode=32 chunk=4 n=8 seed=127
+[2026-06-08T16:02:26+00:00] done decode=32 chunk=3
+[2026-06-08T16:02:26+00:00] run decode=32 chunk=4 n=8 seed=127
+[2026-06-08T16:02:26+00:00] done decode=32 chunk=3
+[2026-06-08T16:02:26+00:00] run decode=32 chunk=4 n=8 seed=127
+[2026-06-08T16:02:27+00:00] done decode=32 chunk=3
+[2026-06-08T16:02:27+00:00] run decode=32 chunk=4 n=8 seed=127
+[2026-06-08T16:02:33+00:00] done decode=32 chunk=4
+[2026-06-08T16:02:33+00:00] run decode=32 chunk=5 n=8 seed=128
+[2026-06-08T16:02:33+00:00] done decode=32 chunk=4
+[2026-06-08T16:02:33+00:00] run decode=32 chunk=5 n=8 seed=128
+[2026-06-08T16:02:33+00:00] done decode=32 chunk=4
+[2026-06-08T16:02:33+00:00] run decode=32 chunk=5 n=8 seed=128
+[2026-06-08T16:02:34+00:00] done decode=32 chunk=4
+[2026-06-08T16:02:34+00:00] run decode=32 chunk=5 n=8 seed=128
+[2026-06-08T16:02:40+00:00] done decode=32 chunk=5
+[2026-06-08T16:02:40+00:00] run decode=32 chunk=6 n=8 seed=129
+[2026-06-08T16:02:41+00:00] done decode=32 chunk=5
+[2026-06-08T16:02:41+00:00] run decode=32 chunk=6 n=8 seed=129
+[2026-06-08T16:02:41+00:00] done decode=32 chunk=5
+[2026-06-08T16:02:41+00:00] run decode=32 chunk=6 n=8 seed=129
+[2026-06-08T16:02:41+00:00] done decode=32 chunk=5
+[2026-06-08T16:02:41+00:00] run decode=32 chunk=6 n=8 seed=129
+[2026-06-08T16:02:47+00:00] done decode=32 chunk=6
+[2026-06-08T16:02:47+00:00] run decode=32 chunk=7 n=8 seed=130
+[2026-06-08T16:02:48+00:00] done decode=32 chunk=6
+[2026-06-08T16:02:48+00:00] run decode=32 chunk=7 n=8 seed=130
+[2026-06-08T16:02:48+00:00] done decode=32 chunk=6
+[2026-06-08T16:02:48+00:00] run decode=32 chunk=7 n=8 seed=130
+[2026-06-08T16:02:48+00:00] done decode=32 chunk=6
+[2026-06-08T16:02:48+00:00] run decode=32 chunk=7 n=8 seed=130
+[2026-06-08T16:02:54+00:00] done decode=32 chunk=7
+merged 64 samples -> /e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_ema_decode32_logitnorm_gamma_temp0p90_mn0p8_s1p1_step170000_ema_dgamma1p75_tschedlogit_normal_mn0p8_s1p1_sc1p0_decode32_n64/sc1p0/samples64.txt
+[2026-06-08T16:02:55+00:00] done decode=32 chunk=7
+merged 64 samples -> /e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_ema_decode32_logitnorm_gamma_temp0p90_mn0p8_s1p0_step170000_ema_dgamma1p50_tschedlogit_normal_mn0p8_s1p0_sc1p0_decode32_n64/sc1p0/samples64.txt
+[2026-06-08T16:02:55+00:00] done decode=32 chunk=7
+merged 64 samples -> /e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_ema_decode32_logitnorm_gamma_temp0p85_mn0p7_s1p1_step170000_ema_dgamma1p75_tschedlogit_normal_mn0p7_s1p1_sc1p0_decode32_n64/sc1p0/samples64.txt
+[2026-06-08T16:02:55+00:00] done decode=32 chunk=7
+merged 64 samples -> /e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_ema_decode32_logitnorm_gamma_temp0p85_mn1p0_s1p0_step170000_ema_dgamma1p50_tschedlogit_normal_mn1p0_s1p0_sc1p0_decode32_n64/sc1p0/samples64.txt
+loading scorer /e2e-data/evad-tech-vla/wanghan58/models/flowtext_scorers/gpt2-large-standard dtype=fp32 device=cuda
+loading scorer /e2e-data/evad-tech-vla/wanghan58/models/flowtext_scorers/gpt2-large-standard dtype=fp32 device=cuda
+loading scorer /e2e-data/evad-tech-vla/wanghan58/models/flowtext_scorers/gpt2-large-standard dtype=fp32 device=cuda
+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.486074998604966	4.8946929597821045	0.07252824534849944	0.4199486301369863	0.08905502300906604	64	64	65498	65409	/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_ema_decode32_logitnorm_gamma_temp0p90_mn0p8_s1p0_step170000_ema_dgamma1p50_tschedlogit_normal_mn0p8_s1p0_sc1p0_decode32_n64/sc1p0
+sc1p0	pre_eos	25.86238928675929	5.056410804556149	0.0796875	0.46144928510223626	0.03442540322580645	0	0	53696	59520	/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_ema_decode32_logitnorm_gamma_temp0p90_mn0p8_s1p0_step170000_ema_dgamma1p50_tschedlogit_normal_mn0p8_s1p0_sc1p0_decode32_n64/sc1p0
+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.756903803117893	4.851696232446399	0.06854592148709795	0.40423450278988	0.09231686437568791	64	64	65709	65416	/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_ema_decode32_logitnorm_gamma_temp0p90_mn0p8_s1p1_step170000_ema_dgamma1p75_tschedlogit_normal_mn0p8_s1p1_sc1p0_decode32_n64/sc1p0
+sc1p0	pre_eos	24.888428950838563	5.0257949792545755	0.07558208149983983	0.44577825735095766	0.03405661490735589	0	0	53471	59313	/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_ema_decode32_logitnorm_gamma_temp0p90_mn0p8_s1p1_step170000_ema_dgamma1p75_tschedlogit_normal_mn0p8_s1p1_sc1p0_decode32_n64/sc1p0
+run	kind	ppl	mean_entropy	distinct_1	distinct_2	top_token_mass	eos_rows	eos_total	ppl_tokens	t5_tokens	path
+sc1p0	raw_full	13.204415489607936	4.713728419695227	0.06590752770347727	0.3851338958180484	0.12106992739778372	64	64	67654	65425	/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_ema_decode32_logitnorm_gamma_temp0p85_mn0p7_s1p1_step170000_ema_dgamma1p75_tschedlogit_normal_mn0p7_s1p1_sc1p0_decode32_n64/sc1p0
+sc1p0	pre_eos	26.563340455933716	4.953788197129261	0.07505222841225627	0.43862184230226847	0.03835306406685237	0	0	51665	57440	/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_ema_decode32_logitnorm_gamma_temp0p85_mn0p7_s1p1_step170000_ema_dgamma1p75_tschedlogit_normal_mn0p7_s1p1_sc1p0_decode32_n64/sc1p0
+run	kind	ppl	mean_entropy	distinct_1	distinct_2	top_token_mass	eos_rows	eos_total	ppl_tokens	t5_tokens	path
+sc1p0	raw_full	9.837059525620287	4.585542370717594	0.05536020058708415	0.33337410368920756	0.12854696673189825	64	65	68814	65408	/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_ema_decode32_logitnorm_gamma_temp0p85_mn1p0_s1p0_step170000_ema_dgamma1p50_tschedlogit_normal_mn1p0_s1p0_sc1p0_decode32_n64/sc1p0
+sc1p0	pre_eos	18.724563237039497	4.838074438785817	0.0635913290939114	0.38294246815985944	0.040297930646804626	0	0	51828	56926	/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_ema_decode32_logitnorm_gamma_temp0p85_mn1p0_s1p0_step170000_ema_dgamma1p50_tschedlogit_normal_mn1p0_s1p0_sc1p0_decode32_n64/sc1p0
+[2026-06-08T16:03:08+00:00] done
+DONE 2026-06-08T16:03:08+00:00 gpu=0 m=-0.8 s=1.0 g=1.50 temp=0.90
+[2026-06-08T16:03:08+00:00] done
+DONE 2026-06-08T16:03:08+00:00 gpu=1 m=-0.8 s=1.1 g=1.75 temp=0.90
+[2026-06-08T16:03:08+00:00] done
+DONE 2026-06-08T16:03:08+00:00 gpu=2 m=-0.7 s=1.1 g=1.75 temp=0.85
+[2026-06-08T16:03:08+00:00] done
+DONE 2026-06-08T16:03:08+00:00 gpu=3 m=-1.0 s=1.0 g=1.50 temp=0.85
+ALL_DONE 2026-06-08T16:03:08+00:00

LTA_openwebtext_dualt/mini_owt_logdirichlet/logs/infer_eval_lr2e3_ema_decode32_highentropy_gamma_20260608_154300.log

@@ -0,0 +1,621 @@
+START 2026-06-08T15:43:00+00:00 gpu=1 m=-0.7 s=1.1 g=1.50
+START 2026-06-08T15:43:00+00:00 gpu=0 m=-0.7 s=1.0 g=1.50
+START 2026-06-08T15:43:00+00:00 gpu=2 m=-0.6 s=1.1 g=1.50
+START 2026-06-08T15:43:00+00:00 gpu=3 m=-0.8 s=1.1 g=1.50
+checkpoint=/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/mini_owt_logdirichlet/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_170000.pt
+use_ema=1
+step=170000
+decode_steps=32
+n=64 chunk_n=8 gpu=1
+out_base=/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608
+checkpoint=/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/mini_owt_logdirichlet/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_170000.pt
+use_ema=1
+step=170000
+decode_steps=32
+n=64 chunk_n=8 gpu=2
+out_base=/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608
+[2026-06-08T15:43:00+00:00] infer step=170000 decode=32 -> /e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_ema_decode32_logitnorm_gamma_mn0p7_s1p1_step170000_ema_dgamma1p50_tschedlogit_normal_mn0p7_s1p1_sc1p0_decode32_n64
+checkpoint=/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/mini_owt_logdirichlet/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_170000.pt
+use_ema=1
+step=170000
+decode_steps=32
+n=64 chunk_n=8 gpu=3
+out_base=/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608
+checkpoint=/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/mini_owt_logdirichlet/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_170000.pt
+use_ema=1
+step=170000
+decode_steps=32
+n=64 chunk_n=8 gpu=0
+out_base=/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608
+[2026-06-08T15:43:00+00:00] run decode=32 chunk=0 n=8 seed=123
+[2026-06-08T15:43:00+00:00] infer step=170000 decode=32 -> /e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_ema_decode32_logitnorm_gamma_mn0p6_s1p1_step170000_ema_dgamma1p50_tschedlogit_normal_mn0p6_s1p1_sc1p0_decode32_n64
+[2026-06-08T15:43:00+00:00] infer step=170000 decode=32 -> /e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_ema_decode32_logitnorm_gamma_mn0p8_s1p1_step170000_ema_dgamma1p50_tschedlogit_normal_mn0p8_s1p1_sc1p0_decode32_n64
+[2026-06-08T15:43:00+00:00] run decode=32 chunk=0 n=8 seed=123
+[2026-06-08T15:43:00+00:00] infer step=170000 decode=32 -> /e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_ema_decode32_logitnorm_gamma_mn0p7_s1p0_step170000_ema_dgamma1p50_tschedlogit_normal_mn0p7_s1p0_sc1p0_decode32_n64
+[2026-06-08T15:43:00+00:00] run decode=32 chunk=0 n=8 seed=123
+[2026-06-08T15:43:00+00:00] run decode=32 chunk=0 n=8 seed=123
+[2026-06-08T15:43:07+00:00] done decode=32 chunk=0
+[2026-06-08T15:43:07+00:00] run decode=32 chunk=1 n=8 seed=124
+[2026-06-08T15:43:07+00:00] done decode=32 chunk=0
+[2026-06-08T15:43:07+00:00] run decode=32 chunk=1 n=8 seed=124
+[2026-06-08T15:43:07+00:00] done decode=32 chunk=0
+[2026-06-08T15:43:07+00:00] run decode=32 chunk=1 n=8 seed=124
+[2026-06-08T15:43:08+00:00] done decode=32 chunk=0
+[2026-06-08T15:43:08+00:00] run decode=32 chunk=1 n=8 seed=124
+[2026-06-08T15:43:15+00:00] done decode=32 chunk=1
+[2026-06-08T15:43:15+00:00] run decode=32 chunk=2 n=8 seed=125
+[2026-06-08T15:43:15+00:00] done decode=32 chunk=1
+[2026-06-08T15:43:15+00:00] run decode=32 chunk=2 n=8 seed=125
+[2026-06-08T15:43:15+00:00] done decode=32 chunk=1
+[2026-06-08T15:43:15+00:00] run decode=32 chunk=2 n=8 seed=125
+[2026-06-08T15:43:15+00:00] done decode=32 chunk=1
+[2026-06-08T15:43:15+00:00] run decode=32 chunk=2 n=8 seed=125
+[2026-06-08T15:43:22+00:00] done decode=32 chunk=2
+[2026-06-08T15:43:22+00:00] run decode=32 chunk=3 n=8 seed=126
+[2026-06-08T15:43:22+00:00] done decode=32 chunk=2
+[2026-06-08T15:43:22+00:00] run decode=32 chunk=3 n=8 seed=126
+[2026-06-08T15:43:22+00:00] done decode=32 chunk=2
+[2026-06-08T15:43:22+00:00] run decode=32 chunk=3 n=8 seed=126
+[2026-06-08T15:43:25+00:00] done decode=32 chunk=2
+[2026-06-08T15:43:25+00:00] run decode=32 chunk=3 n=8 seed=126
+[2026-06-08T15:43:29+00:00] done decode=32 chunk=3
+[2026-06-08T15:43:29+00:00] run decode=32 chunk=4 n=8 seed=127
+[2026-06-08T15:43:29+00:00] done decode=32 chunk=3
+[2026-06-08T15:43:29+00:00] run decode=32 chunk=4 n=8 seed=127
+[2026-06-08T15:43:29+00:00] done decode=32 chunk=3
+[2026-06-08T15:43:29+00:00] run decode=32 chunk=4 n=8 seed=127
+[2026-06-08T15:43:32+00:00] done decode=32 chunk=3
+[2026-06-08T15:43:32+00:00] run decode=32 chunk=4 n=8 seed=127
+[2026-06-08T15:43:36+00:00] done decode=32 chunk=4
+[2026-06-08T15:43:36+00:00] run decode=32 chunk=5 n=8 seed=128
+[2026-06-08T15:43:36+00:00] done decode=32 chunk=4
+[2026-06-08T15:43:36+00:00] run decode=32 chunk=5 n=8 seed=128
+[2026-06-08T15:43:36+00:00] done decode=32 chunk=4
+[2026-06-08T15:43:36+00:00] run decode=32 chunk=5 n=8 seed=128
+[2026-06-08T15:43:39+00:00] done decode=32 chunk=4
+[2026-06-08T15:43:39+00:00] run decode=32 chunk=5 n=8 seed=128
+[2026-06-08T15:43:43+00:00] done decode=32 chunk=5
+[2026-06-08T15:43:43+00:00] run decode=32 chunk=6 n=8 seed=129
+[2026-06-08T15:43:43+00:00] done decode=32 chunk=5
+[2026-06-08T15:43:43+00:00] run decode=32 chunk=6 n=8 seed=129
+[2026-06-08T15:43:43+00:00] done decode=32 chunk=5
+[2026-06-08T15:43:43+00:00] run decode=32 chunk=6 n=8 seed=129
+[2026-06-08T15:43:46+00:00] done decode=32 chunk=5
+[2026-06-08T15:43:46+00:00] run decode=32 chunk=6 n=8 seed=129
+[2026-06-08T15:43:50+00:00] done decode=32 chunk=6
+[2026-06-08T15:43:50+00:00] run decode=32 chunk=7 n=8 seed=130
+[2026-06-08T15:43:50+00:00] done decode=32 chunk=6
+[2026-06-08T15:43:50+00:00] run decode=32 chunk=7 n=8 seed=130
+[2026-06-08T15:43:50+00:00] done decode=32 chunk=6
+[2026-06-08T15:43:50+00:00] run decode=32 chunk=7 n=8 seed=130
+[2026-06-08T15:43:53+00:00] done decode=32 chunk=6
+[2026-06-08T15:43:53+00:00] run decode=32 chunk=7 n=8 seed=130
+[2026-06-08T15:43:57+00:00] done decode=32 chunk=7
+merged 64 samples -> /e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_ema_decode32_logitnorm_gamma_mn0p7_s1p0_step170000_ema_dgamma1p50_tschedlogit_normal_mn0p7_s1p0_sc1p0_decode32_n64/sc1p0/samples64.txt
+[2026-06-08T15:43:57+00:00] done decode=32 chunk=7
+merged 64 samples -> /e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_ema_decode32_logitnorm_gamma_mn0p8_s1p1_step170000_ema_dgamma1p50_tschedlogit_normal_mn0p8_s1p1_sc1p0_decode32_n64/sc1p0/samples64.txt
+[2026-06-08T15:43:57+00:00] done decode=32 chunk=7
+merged 64 samples -> /e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_ema_decode32_logitnorm_gamma_mn0p7_s1p1_step170000_ema_dgamma1p50_tschedlogit_normal_mn0p7_s1p1_sc1p0_decode32_n64/sc1p0/samples64.txt
+loading scorer /e2e-data/evad-tech-vla/wanghan58/models/flowtext_scorers/gpt2-large-standard dtype=fp32 device=cuda
+loading scorer /e2e-data/evad-tech-vla/wanghan58/models/flowtext_scorers/gpt2-large-standard dtype=fp32 device=cuda
+loading scorer /e2e-data/evad-tech-vla/wanghan58/models/flowtext_scorers/gpt2-large-standard dtype=fp32 device=cuda
+[2026-06-08T15:44:00+00:00] done decode=32 chunk=7
+merged 64 samples -> /e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_ema_decode32_logitnorm_gamma_mn0p6_s1p1_step170000_ema_dgamma1p50_tschedlogit_normal_mn0p6_s1p1_sc1p0_decode32_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	25.46511276405882	5.134868781499587	0.08650021418517839	0.4963970441993177	0.046799461477265776	62	62	62420	65364	/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_ema_decode32_logitnorm_gamma_mn0p7_s1p0_step170000_ema_dgamma1p50_tschedlogit_normal_mn0p7_s1p0_sc1p0_decode32_n64/sc1p0
+sc1p0	pre_eos	34.104004896357274	5.201895706024951	0.09082145783461594	0.5212396773882587	0.026605401410600388	0	0	56145	62243	/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_ema_decode32_logitnorm_gamma_mn0p7_s1p0_step170000_ema_dgamma1p50_tschedlogit_normal_mn0p7_s1p0_sc1p0_decode32_n64/sc1p0
+run	kind	ppl	mean_entropy	distinct_1	distinct_2	top_token_mass	eos_rows	eos_total	ppl_tokens	t5_tokens	path
+sc1p0	raw_full	25.006144201418625	5.1650374072545375	0.08291937332823844	0.48743580337490827	0.04429499426824608	61	62	63095	65425	/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_ema_decode32_logitnorm_gamma_mn0p8_s1p1_step170000_ema_dgamma1p50_tschedlogit_normal_mn0p8_s1p1_sc1p0_decode32_n64/sc1p0
+sc1p0	pre_eos	32.25228971694981	5.226595784689143	0.08669180862283869	0.5095801971970533	0.0272140368819713	0	0	57370	62578	/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_ema_decode32_logitnorm_gamma_mn0p8_s1p1_step170000_ema_dgamma1p50_tschedlogit_normal_mn0p8_s1p1_sc1p0_decode32_n64/sc1p0
+[2026-06-08T15:44:10+00:00] done
+DONE 2026-06-08T15:44:10+00:00 gpu=0 m=-0.7 s=1.0 g=1.50
+run	kind	ppl	mean_entropy	distinct_1	distinct_2	top_token_mass	eos_rows	eos_total	ppl_tokens	t5_tokens	path
+sc1p0	raw_full	25.145929885629364	5.157438453787342	0.08594957828835587	0.4960966201322557	0.04749804833994092	60	60	62876	65329	/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_ema_decode32_logitnorm_gamma_mn0p7_s1p1_step170000_ema_dgamma1p50_tschedlogit_normal_mn0p7_s1p1_sc1p0_decode32_n64/sc1p0
+sc1p0	pre_eos	33.01814577641287	5.223174925266984	0.09006624641098439	0.519842160982965	0.027252458174935438	0	0	56877	62343	/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_ema_decode32_logitnorm_gamma_mn0p7_s1p1_step170000_ema_dgamma1p50_tschedlogit_normal_mn0p7_s1p1_sc1p0_decode32_n64/sc1p0
+START 2026-06-08T15:44:10+00:00 gpu=0 m=-0.7 s=1.0 g=1.75
+checkpoint=/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/mini_owt_logdirichlet/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_170000.pt
+use_ema=1
+step=170000
+decode_steps=32
+n=64 chunk_n=8 gpu=0
+out_base=/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608
+[2026-06-08T15:44:10+00:00] infer step=170000 decode=32 -> /e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_ema_decode32_logitnorm_gamma_mn0p7_s1p0_step170000_ema_dgamma1p75_tschedlogit_normal_mn0p7_s1p0_sc1p0_decode32_n64
+[2026-06-08T15:44:10+00:00] run decode=32 chunk=0 n=8 seed=123
+[2026-06-08T15:44:11+00:00] done
+DONE 2026-06-08T15:44:11+00:00 gpu=3 m=-0.8 s=1.1 g=1.50
+START 2026-06-08T15:44:11+00:00 gpu=3 m=-0.8 s=1.1 g=1.75
+checkpoint=/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/mini_owt_logdirichlet/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_170000.pt
+use_ema=1
+step=170000
+decode_steps=32
+n=64 chunk_n=8 gpu=3
+out_base=/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608
+[2026-06-08T15:44:11+00:00] infer step=170000 decode=32 -> /e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_ema_decode32_logitnorm_gamma_mn0p8_s1p1_step170000_ema_dgamma1p75_tschedlogit_normal_mn0p8_s1p1_sc1p0_decode32_n64
+[2026-06-08T15:44:11+00:00] run decode=32 chunk=0 n=8 seed=123
+[2026-06-08T15:44:11+00:00] done
+DONE 2026-06-08T15:44:11+00:00 gpu=1 m=-0.7 s=1.1 g=1.50
+START 2026-06-08T15:44:11+00:00 gpu=1 m=-0.7 s=1.1 g=1.75
+checkpoint=/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/mini_owt_logdirichlet/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_170000.pt
+use_ema=1
+step=170000
+decode_steps=32
+n=64 chunk_n=8 gpu=1
+out_base=/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608
+[2026-06-08T15:44:11+00:00] infer step=170000 decode=32 -> /e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_ema_decode32_logitnorm_gamma_mn0p7_s1p1_step170000_ema_dgamma1p75_tschedlogit_normal_mn0p7_s1p1_sc1p0_decode32_n64
+[2026-06-08T15:44:11+00:00] run decode=32 chunk=0 n=8 seed=123
+run	kind	ppl	mean_entropy	distinct_1	distinct_2	top_token_mass	eos_rows	eos_total	ppl_tokens	t5_tokens	path
+sc1p0	raw_full	29.253331389228197	5.199455862450265	0.08880255731787523	0.5156163964515142	0.044538933329254675	63	63	62271	65381	/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_ema_decode32_logitnorm_gamma_mn0p6_s1p1_step170000_ema_dgamma1p50_tschedlogit_normal_mn0p6_s1p1_sc1p0_decode32_n64/sc1p0
+sc1p0	pre_eos	39.120828645419614	5.264322928633949	0.09301990193250649	0.5401330021632882	0.025318078389898406	0	0	56290	62406	/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_ema_decode32_logitnorm_gamma_mn0p6_s1p1_step170000_ema_dgamma1p50_tschedlogit_normal_mn0p6_s1p1_sc1p0_decode32_n64/sc1p0
+[2026-06-08T15:44:16+00:00] done
+DONE 2026-06-08T15:44:16+00:00 gpu=2 m=-0.6 s=1.1 g=1.50
+START 2026-06-08T15:44:16+00:00 gpu=2 m=-0.6 s=1.1 g=1.75
+checkpoint=/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/mini_owt_logdirichlet/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_170000.pt
+use_ema=1
+step=170000
+decode_steps=32
+n=64 chunk_n=8 gpu=2
+out_base=/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608
+[2026-06-08T15:44:16+00:00] infer step=170000 decode=32 -> /e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_ema_decode32_logitnorm_gamma_mn0p6_s1p1_step170000_ema_dgamma1p75_tschedlogit_normal_mn0p6_s1p1_sc1p0_decode32_n64
+[2026-06-08T15:44:16+00:00] run decode=32 chunk=0 n=8 seed=123
+[2026-06-08T15:44:17+00:00] done decode=32 chunk=0
+[2026-06-08T15:44:17+00:00] run decode=32 chunk=1 n=8 seed=124
+[2026-06-08T15:44:18+00:00] done decode=32 chunk=0
+[2026-06-08T15:44:18+00:00] run decode=32 chunk=1 n=8 seed=124
+[2026-06-08T15:44:18+00:00] done decode=32 chunk=0
+[2026-06-08T15:44:18+00:00] run decode=32 chunk=1 n=8 seed=124
+[2026-06-08T15:44:24+00:00] done decode=32 chunk=0
+[2026-06-08T15:44:24+00:00] run decode=32 chunk=1 n=8 seed=124
+[2026-06-08T15:44:25+00:00] done decode=32 chunk=1
+[2026-06-08T15:44:25+00:00] run decode=32 chunk=2 n=8 seed=125
+[2026-06-08T15:44:25+00:00] done decode=32 chunk=1
+[2026-06-08T15:44:25+00:00] run decode=32 chunk=2 n=8 seed=125
+[2026-06-08T15:44:25+00:00] done decode=32 chunk=1
+[2026-06-08T15:44:25+00:00] run decode=32 chunk=2 n=8 seed=125
+[2026-06-08T15:44:31+00:00] done decode=32 chunk=2
+[2026-06-08T15:44:31+00:00] run decode=32 chunk=3 n=8 seed=126
+[2026-06-08T15:44:32+00:00] done decode=32 chunk=1
+[2026-06-08T15:44:32+00:00] run decode=32 chunk=2 n=8 seed=125
+[2026-06-08T15:44:32+00:00] done decode=32 chunk=2
+[2026-06-08T15:44:32+00:00] run decode=32 chunk=3 n=8 seed=126
+[2026-06-08T15:44:32+00:00] done decode=32 chunk=2
+[2026-06-08T15:44:32+00:00] run decode=32 chunk=3 n=8 seed=126
+[2026-06-08T15:44:39+00:00] done decode=32 chunk=3
+[2026-06-08T15:44:39+00:00] run decode=32 chunk=4 n=8 seed=127
+[2026-06-08T15:44:39+00:00] done decode=32 chunk=3
+[2026-06-08T15:44:39+00:00] run decode=32 chunk=4 n=8 seed=127
+[2026-06-08T15:44:39+00:00] done decode=32 chunk=3
+[2026-06-08T15:44:39+00:00] run decode=32 chunk=4 n=8 seed=127
+[2026-06-08T15:44:42+00:00] done decode=32 chunk=2
+[2026-06-08T15:44:42+00:00] run decode=32 chunk=3 n=8 seed=126
+[2026-06-08T15:44:46+00:00] done decode=32 chunk=4
+[2026-06-08T15:44:46+00:00] run decode=32 chunk=5 n=8 seed=128
+[2026-06-08T15:44:46+00:00] done decode=32 chunk=4
+[2026-06-08T15:44:46+00:00] run decode=32 chunk=5 n=8 seed=128
+[2026-06-08T15:44:46+00:00] done decode=32 chunk=4
+[2026-06-08T15:44:46+00:00] run decode=32 chunk=5 n=8 seed=128
+[2026-06-08T15:44:49+00:00] done decode=32 chunk=3
+[2026-06-08T15:44:49+00:00] run decode=32 chunk=4 n=8 seed=127
+[2026-06-08T15:44:53+00:00] done decode=32 chunk=5
+[2026-06-08T15:44:53+00:00] run decode=32 chunk=6 n=8 seed=129
+[2026-06-08T15:44:53+00:00] done decode=32 chunk=5
+[2026-06-08T15:44:53+00:00] run decode=32 chunk=6 n=8 seed=129
+[2026-06-08T15:44:53+00:00] done decode=32 chunk=5
+[2026-06-08T15:44:53+00:00] run decode=32 chunk=6 n=8 seed=129
+[2026-06-08T15:44:56+00:00] done decode=32 chunk=4
+[2026-06-08T15:44:56+00:00] run decode=32 chunk=5 n=8 seed=128
+[2026-06-08T15:45:00+00:00] done decode=32 chunk=6
+[2026-06-08T15:45:00+00:00] run decode=32 chunk=7 n=8 seed=130
+[2026-06-08T15:45:00+00:00] done decode=32 chunk=6
+[2026-06-08T15:45:00+00:00] run decode=32 chunk=7 n=8 seed=130
+[2026-06-08T15:45:00+00:00] done decode=32 chunk=6
+[2026-06-08T15:45:00+00:00] run decode=32 chunk=7 n=8 seed=130
+[2026-06-08T15:45:03+00:00] done decode=32 chunk=5
+[2026-06-08T15:45:03+00:00] run decode=32 chunk=6 n=8 seed=129
+[2026-06-08T15:45:07+00:00] done decode=32 chunk=7
+merged 64 samples -> /e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_ema_decode32_logitnorm_gamma_mn0p7_s1p0_step170000_ema_dgamma1p75_tschedlogit_normal_mn0p7_s1p0_sc1p0_decode32_n64/sc1p0/samples64.txt
+[2026-06-08T15:45:07+00:00] done decode=32 chunk=7
+merged 64 samples -> /e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_ema_decode32_logitnorm_gamma_mn0p8_s1p1_step170000_ema_dgamma1p75_tschedlogit_normal_mn0p8_s1p1_sc1p0_decode32_n64/sc1p0/samples64.txt
+[2026-06-08T15:45:07+00:00] done decode=32 chunk=7
+merged 64 samples -> /e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_ema_decode32_logitnorm_gamma_mn0p7_s1p1_step170000_ema_dgamma1p75_tschedlogit_normal_mn0p7_s1p1_sc1p0_decode32_n64/sc1p0/samples64.txt
+loading scorer /e2e-data/evad-tech-vla/wanghan58/models/flowtext_scorers/gpt2-large-standard dtype=fp32 device=cuda
+[2026-06-08T15:45:10+00:00] done decode=32 chunk=6
+[2026-06-08T15:45:10+00:00] run decode=32 chunk=7 n=8 seed=130
+loading scorer /e2e-data/evad-tech-vla/wanghan58/models/flowtext_scorers/gpt2-large-standard dtype=fp32 device=cuda
+loading scorer /e2e-data/evad-tech-vla/wanghan58/models/flowtext_scorers/gpt2-large-standard dtype=fp32 device=cuda
+[2026-06-08T15:45:18+00:00] done decode=32 chunk=7
+merged 64 samples -> /e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_ema_decode32_logitnorm_gamma_mn0p6_s1p1_step170000_ema_dgamma1p75_tschedlogit_normal_mn0p6_s1p1_sc1p0_decode32_n64/sc1p0/samples64.txt
+run	kind	ppl	mean_entropy	distinct_1	distinct_2	top_token_mass	eos_rows	eos_total	ppl_tokens	t5_tokens	path
+sc1p0	raw_full	24.674175155187978	5.093122741046169	0.08530871215030802	0.48701837399373193	0.044997157912525156	61	61	62013	65093	/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_ema_decode32_logitnorm_gamma_mn0p7_s1p0_step170000_ema_dgamma1p75_tschedlogit_normal_mn0p7_s1p0_sc1p0_decode32_n64/sc1p0
+sc1p0	pre_eos	32.57177880020669	5.155799273342083	0.08941453046502641	0.5104101251147287	0.02523186912276182	0	0	56005	62104	/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_ema_decode32_logitnorm_gamma_mn0p7_s1p0_step170000_ema_dgamma1p75_tschedlogit_normal_mn0p7_s1p0_sc1p0_decode32_n64/sc1p0
+run	kind	ppl	mean_entropy	distinct_1	distinct_2	top_token_mass	eos_rows	eos_total	ppl_tokens	t5_tokens	path
+sc1p0	raw_full	25.595100633445327	5.141551190417838	0.083746328928047	0.49122753346080306	0.04238558492413118	63	63	62390	65376	/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_ema_decode32_logitnorm_gamma_mn0p8_s1p1_step170000_ema_dgamma1p75_tschedlogit_normal_mn0p8_s1p1_sc1p0_decode32_n64/sc1p0
+sc1p0	pre_eos	33.139684495570776	5.201097427500396	0.08752518307697227	0.5134231943844838	0.02646221738991398	0	0	56687	62542	/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_ema_decode32_logitnorm_gamma_mn0p8_s1p1_step170000_ema_dgamma1p75_tschedlogit_normal_mn0p8_s1p1_sc1p0_decode32_n64/sc1p0
+run	kind	ppl	mean_entropy	distinct_1	distinct_2	top_token_mass	eos_rows	eos_total	ppl_tokens	t5_tokens	path
+sc1p0	raw_full	27.28656623661575	5.141192201769601	0.08421745587042055	0.4982240729967237	0.04099879055098823	60	61	62326	65319	/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_ema_decode32_logitnorm_gamma_mn0p7_s1p1_step170000_ema_dgamma1p75_tschedlogit_normal_mn0p7_s1p1_sc1p0_decode32_n64/sc1p0
+sc1p0	pre_eos	35.22637379554865	5.196268191770475	0.08790067431529833	0.5199821031942602	0.025198938992042442	0	0	56820	62582	/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_ema_decode32_logitnorm_gamma_mn0p7_s1p1_step170000_ema_dgamma1p75_tschedlogit_normal_mn0p7_s1p1_sc1p0_decode32_n64/sc1p0
+[2026-06-08T15:45:20+00:00] done
+DONE 2026-06-08T15:45:20+00:00 gpu=0 m=-0.7 s=1.0 g=1.75
+START 2026-06-08T15:45:20+00:00 gpu=0 m=-0.7 s=1.0 g=2.00
+checkpoint=/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/mini_owt_logdirichlet/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_170000.pt
+use_ema=1
+step=170000
+decode_steps=32
+n=64 chunk_n=8 gpu=0
+out_base=/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608
+[2026-06-08T15:45:21+00:00] infer step=170000 decode=32 -> /e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_ema_decode32_logitnorm_gamma_mn0p7_s1p0_step170000_ema_dgamma2p00_tschedlogit_normal_mn0p7_s1p0_sc1p0_decode32_n64
+[2026-06-08T15:45:21+00:00] run decode=32 chunk=0 n=8 seed=123
+loading scorer /e2e-data/evad-tech-vla/wanghan58/models/flowtext_scorers/gpt2-large-standard dtype=fp32 device=cuda
+[2026-06-08T15:45:21+00:00] done
+DONE 2026-06-08T15:45:21+00:00 gpu=3 m=-0.8 s=1.1 g=1.75
+START 2026-06-08T15:45:21+00:00 gpu=3 m=-0.8 s=1.1 g=2.00
+[2026-06-08T15:45:21+00:00] done
+DONE 2026-06-08T15:45:21+00:00 gpu=1 m=-0.7 s=1.1 g=1.75
+checkpoint=/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/mini_owt_logdirichlet/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_170000.pt
+use_ema=1
+step=170000
+decode_steps=32
+n=64 chunk_n=8 gpu=3
+out_base=/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608
+[2026-06-08T15:45:21+00:00] infer step=170000 decode=32 -> /e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_ema_decode32_logitnorm_gamma_mn0p8_s1p1_step170000_ema_dgamma2p00_tschedlogit_normal_mn0p8_s1p1_sc1p0_decode32_n64
+[2026-06-08T15:45:21+00:00] run decode=32 chunk=0 n=8 seed=123
+START 2026-06-08T15:45:21+00:00 gpu=1 m=-0.7 s=1.1 g=2.00
+checkpoint=/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/mini_owt_logdirichlet/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_170000.pt
+use_ema=1
+step=170000
+decode_steps=32
+n=64 chunk_n=8 gpu=1
+out_base=/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608
+[2026-06-08T15:45:21+00:00] infer step=170000 decode=32 -> /e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_ema_decode32_logitnorm_gamma_mn0p7_s1p1_step170000_ema_dgamma2p00_tschedlogit_normal_mn0p7_s1p1_sc1p0_decode32_n64
+[2026-06-08T15:45:21+00:00] run decode=32 chunk=0 n=8 seed=123
+[2026-06-08T15:45:27+00:00] done decode=32 chunk=0
+[2026-06-08T15:45:27+00:00] run decode=32 chunk=1 n=8 seed=124
+[2026-06-08T15:45:28+00:00] done decode=32 chunk=0
+[2026-06-08T15:45:28+00:00] run decode=32 chunk=1 n=8 seed=124
+[2026-06-08T15:45:28+00:00] done decode=32 chunk=0
+[2026-06-08T15:45:28+00:00] run decode=32 chunk=1 n=8 seed=124
+run	kind	ppl	mean_entropy	distinct_1	distinct_2	top_token_mass	eos_rows	eos_total	ppl_tokens	t5_tokens	path
+sc1p0	raw_full	28.844078229304245	5.136318742884756	0.08770261773681547	0.5041099251625567	0.04272416384241439	63	63	61485	65209	/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_ema_decode32_logitnorm_gamma_mn0p6_s1p1_step170000_ema_dgamma1p75_tschedlogit_normal_mn0p6_s1p1_sc1p0_decode32_n64/sc1p0
+sc1p0	pre_eos	38.152279786750405	5.195950655605326	0.09169339320076972	0.5270770859058035	0.024342527261064784	0	0	55756	62360	/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_ema_decode32_logitnorm_gamma_mn0p6_s1p1_step170000_ema_dgamma1p75_tschedlogit_normal_mn0p6_s1p1_sc1p0_decode32_n64/sc1p0
+[2026-06-08T15:45:34+00:00] done
+DONE 2026-06-08T15:45:34+00:00 gpu=2 m=-0.6 s=1.1 g=1.75
+START 2026-06-08T15:45:34+00:00 gpu=2 m=-0.6 s=1.1 g=2.00
+checkpoint=/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/mini_owt_logdirichlet/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_170000.pt
+use_ema=1
+step=170000
+decode_steps=32
+n=64 chunk_n=8 gpu=2
+out_base=/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608
+[2026-06-08T15:45:34+00:00] infer step=170000 decode=32 -> /e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_ema_decode32_logitnorm_gamma_mn0p6_s1p1_step170000_ema_dgamma2p00_tschedlogit_normal_mn0p6_s1p1_sc1p0_decode32_n64
+[2026-06-08T15:45:34+00:00] run decode=32 chunk=0 n=8 seed=123
+[2026-06-08T15:45:35+00:00] done decode=32 chunk=1
+[2026-06-08T15:45:35+00:00] run decode=32 chunk=2 n=8 seed=125
+[2026-06-08T15:45:35+00:00] done decode=32 chunk=1
+[2026-06-08T15:45:35+00:00] run decode=32 chunk=2 n=8 seed=125
+[2026-06-08T15:45:35+00:00] done decode=32 chunk=1
+[2026-06-08T15:45:35+00:00] run decode=32 chunk=2 n=8 seed=125
+[2026-06-08T15:45:41+00:00] done decode=32 chunk=2
+[2026-06-08T15:45:41+00:00] run decode=32 chunk=3 n=8 seed=126
+[2026-06-08T15:45:42+00:00] done decode=32 chunk=2
+[2026-06-08T15:45:42+00:00] run decode=32 chunk=3 n=8 seed=126
+[2026-06-08T15:45:42+00:00] done decode=32 chunk=2
+[2026-06-08T15:45:42+00:00] run decode=32 chunk=3 n=8 seed=126
+[2026-06-08T15:45:43+00:00] done decode=32 chunk=0
+[2026-06-08T15:45:43+00:00] run decode=32 chunk=1 n=8 seed=124
+[2026-06-08T15:45:48+00:00] done decode=32 chunk=3
+[2026-06-08T15:45:48+00:00] run decode=32 chunk=4 n=8 seed=127
+[2026-06-08T15:45:49+00:00] done decode=32 chunk=3
+[2026-06-08T15:45:49+00:00] run decode=32 chunk=4 n=8 seed=127
+[2026-06-08T15:45:49+00:00] done decode=32 chunk=3
+[2026-06-08T15:45:49+00:00] run decode=32 chunk=4 n=8 seed=127
+[2026-06-08T15:45:51+00:00] done decode=32 chunk=1
+[2026-06-08T15:45:51+00:00] run decode=32 chunk=2 n=8 seed=125
+[2026-06-08T15:45:55+00:00] done decode=32 chunk=4
+[2026-06-08T15:45:55+00:00] run decode=32 chunk=5 n=8 seed=128
+[2026-06-08T15:45:56+00:00] done decode=32 chunk=4
+[2026-06-08T15:45:56+00:00] run decode=32 chunk=5 n=8 seed=128
+[2026-06-08T15:45:56+00:00] done decode=32 chunk=4
+[2026-06-08T15:45:56+00:00] run decode=32 chunk=5 n=8 seed=128
+[2026-06-08T15:46:00+00:00] done decode=32 chunk=2
+[2026-06-08T15:46:00+00:00] run decode=32 chunk=3 n=8 seed=126
+[2026-06-08T15:46:02+00:00] done decode=32 chunk=5
+[2026-06-08T15:46:02+00:00] run decode=32 chunk=6 n=8 seed=129
+[2026-06-08T15:46:03+00:00] done decode=32 chunk=5
+[2026-06-08T15:46:03+00:00] run decode=32 chunk=6 n=8 seed=129
+[2026-06-08T15:46:03+00:00] done decode=32 chunk=5
+[2026-06-08T15:46:03+00:00] run decode=32 chunk=6 n=8 seed=129
+[2026-06-08T15:46:07+00:00] done decode=32 chunk=3
+[2026-06-08T15:46:07+00:00] run decode=32 chunk=4 n=8 seed=127
+[2026-06-08T15:46:09+00:00] done decode=32 chunk=6
+[2026-06-08T15:46:09+00:00] run decode=32 chunk=7 n=8 seed=130
+[2026-06-08T15:46:10+00:00] done decode=32 chunk=6
+[2026-06-08T15:46:10+00:00] run decode=32 chunk=7 n=8 seed=130
+[2026-06-08T15:46:10+00:00] done decode=32 chunk=6
+[2026-06-08T15:46:10+00:00] run decode=32 chunk=7 n=8 seed=130
+[2026-06-08T15:46:15+00:00] done decode=32 chunk=4
+[2026-06-08T15:46:15+00:00] run decode=32 chunk=5 n=8 seed=128
+[2026-06-08T15:46:16+00:00] done decode=32 chunk=7
+merged 64 samples -> /e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_ema_decode32_logitnorm_gamma_mn0p7_s1p0_step170000_ema_dgamma2p00_tschedlogit_normal_mn0p7_s1p0_sc1p0_decode32_n64/sc1p0/samples64.txt
+[2026-06-08T15:46:17+00:00] done decode=32 chunk=7
+merged 64 samples -> /e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_ema_decode32_logitnorm_gamma_mn0p7_s1p1_step170000_ema_dgamma2p00_tschedlogit_normal_mn0p7_s1p1_sc1p0_decode32_n64/sc1p0/samples64.txt
+[2026-06-08T15:46:17+00:00] done decode=32 chunk=7
+merged 64 samples -> /e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_ema_decode32_logitnorm_gamma_mn0p8_s1p1_step170000_ema_dgamma2p00_tschedlogit_normal_mn0p8_s1p1_sc1p0_decode32_n64/sc1p0/samples64.txt
+loading scorer /e2e-data/evad-tech-vla/wanghan58/models/flowtext_scorers/gpt2-large-standard dtype=fp32 device=cuda
+loading scorer /e2e-data/evad-tech-vla/wanghan58/models/flowtext_scorers/gpt2-large-standard dtype=fp32 device=cuda
+loading scorer /e2e-data/evad-tech-vla/wanghan58/models/flowtext_scorers/gpt2-large-standard dtype=fp32 device=cuda
+[2026-06-08T15:46:22+00:00] done decode=32 chunk=5
+[2026-06-08T15:46:22+00:00] run decode=32 chunk=6 n=8 seed=129
+[2026-06-08T15:46:28+00:00] done decode=32 chunk=6
+[2026-06-08T15:46:28+00:00] run decode=32 chunk=7 n=8 seed=130
+run	kind	ppl	mean_entropy	distinct_1	distinct_2	top_token_mass	eos_rows	eos_total	ppl_tokens	t5_tokens	path
+sc1p0	raw_full	24.084238199197365	5.021201815050668	0.07967938205949517	0.4627881314369789	0.04164048491164615	60	62	61275	65249	/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_ema_decode32_logitnorm_gamma_mn0p7_s1p0_step170000_ema_dgamma2p00_tschedlogit_normal_mn0p7_s1p0_sc1p0_decode32_n64/sc1p0
+sc1p0	pre_eos	31.02684902921224	5.073971331458516	0.0832172869147659	0.4833050549028396	0.024297719087635054	0	0	55695	62475	/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_ema_decode32_logitnorm_gamma_mn0p7_s1p0_step170000_ema_dgamma2p00_tschedlogit_normal_mn0p7_s1p0_sc1p0_decode32_n64/sc1p0
+run	kind	ppl	mean_entropy	distinct_1	distinct_2	top_token_mass	eos_rows	eos_total	ppl_tokens	t5_tokens	path
+sc1p0	raw_full	25.265202919766065	5.085413682067284	0.08192852326365475	0.48101944797780877	0.03766934346839944	58	59	61678	65252	/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_ema_decode32_logitnorm_gamma_mn0p7_s1p1_step170000_ema_dgamma2p00_tschedlogit_normal_mn0p7_s1p1_sc1p0_decode32_n64/sc1p0
+sc1p0	pre_eos	31.732081700246965	5.133858975796755	0.0851996493185622	0.5002550451111041	0.02174224914322149	0	0	56610	62735	/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_ema_decode32_logitnorm_gamma_mn0p7_s1p1_step170000_ema_dgamma2p00_tschedlogit_normal_mn0p7_s1p1_sc1p0_decode32_n64/sc1p0
+run	kind	ppl	mean_entropy	distinct_1	distinct_2	top_token_mass	eos_rows	eos_total	ppl_tokens	t5_tokens	path
+sc1p0	raw_full	23.571224444785607	5.075683824364516	0.07841185747752989	0.47367856924113433	0.04181659495628474	59	64	62232	65309	/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_ema_decode32_logitnorm_gamma_mn0p8_s1p1_step170000_ema_dgamma2p00_tschedlogit_normal_mn0p8_s1p1_sc1p0_decode32_n64/sc1p0
+sc1p0	pre_eos	30.236367449616047	5.133033762537179	0.08190427437931917	0.4948089136312009	0.024251343742001535	0	0	56611	62512	/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_ema_decode32_logitnorm_gamma_mn0p8_s1p1_step170000_ema_dgamma2p00_tschedlogit_normal_mn0p8_s1p1_sc1p0_decode32_n64/sc1p0
+[2026-06-08T15:46:30+00:00] done
+DONE 2026-06-08T15:46:30+00:00 gpu=0 m=-0.7 s=1.0 g=2.00
+START 2026-06-08T15:46:30+00:00 gpu=0 m=-0.7 s=1.0 g=2.25
+checkpoint=/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/mini_owt_logdirichlet/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_170000.pt
+use_ema=1
+step=170000
+decode_steps=32
+n=64 chunk_n=8 gpu=0
+out_base=/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608
+[2026-06-08T15:46:30+00:00] infer step=170000 decode=32 -> /e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_ema_decode32_logitnorm_gamma_mn0p7_s1p0_step170000_ema_dgamma2p25_tschedlogit_normal_mn0p7_s1p0_sc1p0_decode32_n64
+[2026-06-08T15:46:30+00:00] run decode=32 chunk=0 n=8 seed=123
+[2026-06-08T15:46:30+00:00] done
+DONE 2026-06-08T15:46:30+00:00 gpu=1 m=-0.7 s=1.1 g=2.00
+START 2026-06-08T15:46:30+00:00 gpu=1 m=-0.7 s=1.1 g=2.25
+checkpoint=/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/mini_owt_logdirichlet/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_170000.pt
+use_ema=1
+step=170000
+decode_steps=32
+n=64 chunk_n=8 gpu=1
+out_base=/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608
+[2026-06-08T15:46:31+00:00] infer step=170000 decode=32 -> /e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_ema_decode32_logitnorm_gamma_mn0p7_s1p1_step170000_ema_dgamma2p25_tschedlogit_normal_mn0p7_s1p1_sc1p0_decode32_n64
+[2026-06-08T15:46:31+00:00] run decode=32 chunk=0 n=8 seed=123
+[2026-06-08T15:46:31+00:00] done
+DONE 2026-06-08T15:46:31+00:00 gpu=3 m=-0.8 s=1.1 g=2.00
+START 2026-06-08T15:46:31+00:00 gpu=3 m=-0.8 s=1.1 g=2.25
+checkpoint=/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/mini_owt_logdirichlet/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_170000.pt
+use_ema=1
+step=170000
+decode_steps=32
+n=64 chunk_n=8 gpu=3
+out_base=/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608
+[2026-06-08T15:46:31+00:00] infer step=170000 decode=32 -> /e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_ema_decode32_logitnorm_gamma_mn0p8_s1p1_step170000_ema_dgamma2p25_tschedlogit_normal_mn0p8_s1p1_sc1p0_decode32_n64
+[2026-06-08T15:46:31+00:00] run decode=32 chunk=0 n=8 seed=123
+[2026-06-08T15:46:36+00:00] done decode=32 chunk=7
+merged 64 samples -> /e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_ema_decode32_logitnorm_gamma_mn0p6_s1p1_step170000_ema_dgamma2p00_tschedlogit_normal_mn0p6_s1p1_sc1p0_decode32_n64/sc1p0/samples64.txt
+[2026-06-08T15:46:37+00:00] done decode=32 chunk=0
+[2026-06-08T15:46:37+00:00] run decode=32 chunk=1 n=8 seed=124
+[2026-06-08T15:46:38+00:00] done decode=32 chunk=0
+[2026-06-08T15:46:38+00:00] run decode=32 chunk=1 n=8 seed=124
+[2026-06-08T15:46:38+00:00] done decode=32 chunk=0
+[2026-06-08T15:46:38+00:00] run decode=32 chunk=1 n=8 seed=124
+loading scorer /e2e-data/evad-tech-vla/wanghan58/models/flowtext_scorers/gpt2-large-standard dtype=fp32 device=cuda
+[2026-06-08T15:46:44+00:00] done decode=32 chunk=1
+[2026-06-08T15:46:44+00:00] run decode=32 chunk=2 n=8 seed=125
+[2026-06-08T15:46:45+00:00] done decode=32 chunk=1
+[2026-06-08T15:46:45+00:00] run decode=32 chunk=2 n=8 seed=125
+[2026-06-08T15:46:45+00:00] done decode=32 chunk=1
+[2026-06-08T15:46:45+00:00] run decode=32 chunk=2 n=8 seed=125
+run	kind	ppl	mean_entropy	distinct_1	distinct_2	top_token_mass	eos_rows	eos_total	ppl_tokens	t5_tokens	path
+sc1p0	raw_full	27.654694039489147	5.070332891407034	0.08547939322361459	0.4843241916682005	0.04104483335122782	61	61	61159	65197	/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_ema_decode32_logitnorm_gamma_mn0p6_s1p1_step170000_ema_dgamma2p00_tschedlogit_normal_mn0p6_s1p1_sc1p0_decode32_n64/sc1p0
+sc1p0	pre_eos	35.948430977789364	5.123739168993003	0.08920909382004483	0.5054996077426792	0.024703810438680755	0	0	55655	62460	/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_ema_decode32_logitnorm_gamma_mn0p6_s1p1_step170000_ema_dgamma2p00_tschedlogit_normal_mn0p6_s1p1_sc1p0_decode32_n64/sc1p0
+[2026-06-08T15:46:48+00:00] done
+DONE 2026-06-08T15:46:48+00:00 gpu=2 m=-0.6 s=1.1 g=2.00
+START 2026-06-08T15:46:48+00:00 gpu=2 m=-0.6 s=1.1 g=2.25
+checkpoint=/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/mini_owt_logdirichlet/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_170000.pt
+use_ema=1
+step=170000
+decode_steps=32
+n=64 chunk_n=8 gpu=2
+out_base=/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608
+[2026-06-08T15:46:48+00:00] infer step=170000 decode=32 -> /e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_ema_decode32_logitnorm_gamma_mn0p6_s1p1_step170000_ema_dgamma2p25_tschedlogit_normal_mn0p6_s1p1_sc1p0_decode32_n64
+[2026-06-08T15:46:48+00:00] run decode=32 chunk=0 n=8 seed=123
+[2026-06-08T15:46:51+00:00] done decode=32 chunk=2
+[2026-06-08T15:46:51+00:00] run decode=32 chunk=3 n=8 seed=126
+[2026-06-08T15:46:52+00:00] done decode=32 chunk=2
+[2026-06-08T15:46:52+00:00] run decode=32 chunk=3 n=8 seed=126
+[2026-06-08T15:46:52+00:00] done decode=32 chunk=2
+[2026-06-08T15:46:52+00:00] run decode=32 chunk=3 n=8 seed=126
+[2026-06-08T15:46:55+00:00] done decode=32 chunk=0
+[2026-06-08T15:46:55+00:00] run decode=32 chunk=1 n=8 seed=124
+[2026-06-08T15:46:58+00:00] done decode=32 chunk=3
+[2026-06-08T15:46:58+00:00] run decode=32 chunk=4 n=8 seed=127
+[2026-06-08T15:46:59+00:00] done decode=32 chunk=3
+[2026-06-08T15:46:59+00:00] run decode=32 chunk=4 n=8 seed=127
+[2026-06-08T15:46:59+00:00] done decode=32 chunk=3
+[2026-06-08T15:46:59+00:00] run decode=32 chunk=4 n=8 seed=127
+[2026-06-08T15:47:02+00:00] done decode=32 chunk=1
+[2026-06-08T15:47:02+00:00] run decode=32 chunk=2 n=8 seed=125
+[2026-06-08T15:47:05+00:00] done decode=32 chunk=4
+[2026-06-08T15:47:05+00:00] run decode=32 chunk=5 n=8 seed=128
+[2026-06-08T15:47:06+00:00] done decode=32 chunk=4
+[2026-06-08T15:47:06+00:00] run decode=32 chunk=5 n=8 seed=128
+[2026-06-08T15:47:06+00:00] done decode=32 chunk=4
+[2026-06-08T15:47:06+00:00] run decode=32 chunk=5 n=8 seed=128
+[2026-06-08T15:47:08+00:00] done decode=32 chunk=2
+[2026-06-08T15:47:08+00:00] run decode=32 chunk=3 n=8 seed=126
+[2026-06-08T15:47:12+00:00] done decode=32 chunk=5
+[2026-06-08T15:47:12+00:00] run decode=32 chunk=6 n=8 seed=129
+[2026-06-08T15:47:13+00:00] done decode=32 chunk=5
+[2026-06-08T15:47:13+00:00] run decode=32 chunk=6 n=8 seed=129
+[2026-06-08T15:47:13+00:00] done decode=32 chunk=5
+[2026-06-08T15:47:13+00:00] run decode=32 chunk=6 n=8 seed=129
+[2026-06-08T15:47:15+00:00] done decode=32 chunk=3
+[2026-06-08T15:47:15+00:00] run decode=32 chunk=4 n=8 seed=127
+[2026-06-08T15:47:19+00:00] done decode=32 chunk=6
+[2026-06-08T15:47:19+00:00] run decode=32 chunk=7 n=8 seed=130
+[2026-06-08T15:47:20+00:00] done decode=32 chunk=6
+[2026-06-08T15:47:20+00:00] run decode=32 chunk=7 n=8 seed=130
+[2026-06-08T15:47:20+00:00] done decode=32 chunk=6
+[2026-06-08T15:47:20+00:00] run decode=32 chunk=7 n=8 seed=130
+[2026-06-08T15:47:22+00:00] done decode=32 chunk=4
+[2026-06-08T15:47:22+00:00] run decode=32 chunk=5 n=8 seed=128
+[2026-06-08T15:47:26+00:00] done decode=32 chunk=7
+merged 64 samples -> /e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_ema_decode32_logitnorm_gamma_mn0p7_s1p0_step170000_ema_dgamma2p25_tschedlogit_normal_mn0p7_s1p0_sc1p0_decode32_n64/sc1p0/samples64.txt
+[2026-06-08T15:47:27+00:00] done decode=32 chunk=7
+merged 64 samples -> /e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_ema_decode32_logitnorm_gamma_mn0p8_s1p1_step170000_ema_dgamma2p25_tschedlogit_normal_mn0p8_s1p1_sc1p0_decode32_n64/sc1p0/samples64.txt
+[2026-06-08T15:47:27+00:00] done decode=32 chunk=7
+merged 64 samples -> /e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_ema_decode32_logitnorm_gamma_mn0p7_s1p1_step170000_ema_dgamma2p25_tschedlogit_normal_mn0p7_s1p1_sc1p0_decode32_n64/sc1p0/samples64.txt
+[2026-06-08T15:47:29+00:00] done decode=32 chunk=5
+[2026-06-08T15:47:29+00:00] run decode=32 chunk=6 n=8 seed=129
+loading scorer /e2e-data/evad-tech-vla/wanghan58/models/flowtext_scorers/gpt2-large-standard dtype=fp32 device=cuda
+loading scorer /e2e-data/evad-tech-vla/wanghan58/models/flowtext_scorers/gpt2-large-standard dtype=fp32 device=cuda
+loading scorer /e2e-data/evad-tech-vla/wanghan58/models/flowtext_scorers/gpt2-large-standard dtype=fp32 device=cuda
+[2026-06-08T15:47:36+00:00] done decode=32 chunk=6
+[2026-06-08T15:47:36+00:00] run decode=32 chunk=7 n=8 seed=130
+run	kind	ppl	mean_entropy	distinct_1	distinct_2	top_token_mass	eos_rows	eos_total	ppl_tokens	t5_tokens	path
+sc1p0	raw_full	23.693922238882447	4.992047445144883	0.0808761454511965	0.4573432799164978	0.03932523906736865	61	61	60941	65149	/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_ema_decode32_logitnorm_gamma_mn0p7_s1p0_step170000_ema_dgamma2p25_tschedlogit_normal_mn0p7_s1p0_sc1p0_decode32_n64/sc1p0
+sc1p0	pre_eos	29.9730855295806	5.037358073108425	0.08425295077247864	0.4764814074370252	0.023462239708281356	0	0	55662	62526	/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_ema_decode32_logitnorm_gamma_mn0p7_s1p0_step170000_ema_dgamma2p25_tschedlogit_normal_mn0p7_s1p0_sc1p0_decode32_n64/sc1p0
+run	kind	ppl	mean_entropy	distinct_1	distinct_2	top_token_mass	eos_rows	eos_total	ppl_tokens	t5_tokens	path
+sc1p0	raw_full	24.966059279759392	5.049597169111026	0.08053794075299452	0.47283449490694646	0.03861471065772141	62	65	61350	65286	/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_ema_decode32_logitnorm_gamma_mn0p7_s1p1_step170000_ema_dgamma2p25_tschedlogit_normal_mn0p7_s1p1_sc1p0_decode32_n64/sc1p0
+sc1p0	pre_eos	31.579606134977716	5.097047145475261	0.08384370015948964	0.4922726040287724	0.0235725677830941	0	0	56138	62700	/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_ema_decode32_logitnorm_gamma_mn0p7_s1p1_step170000_ema_dgamma2p25_tschedlogit_normal_mn0p7_s1p1_sc1p0_decode32_n64/sc1p0
+run	kind	ppl	mean_entropy	distinct_1	distinct_2	top_token_mass	eos_rows	eos_total	ppl_tokens	t5_tokens	path
+sc1p0	raw_full	23.697902145866742	5.041513487854978	0.07807826233682563	0.4658383187605461	0.03982144774585449	60	61	61816	65191	/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_ema_decode32_logitnorm_gamma_mn0p8_s1p1_step170000_ema_dgamma2p25_tschedlogit_normal_mn0p8_s1p1_sc1p0_decode32_n64/sc1p0
+sc1p0	pre_eos	29.48738932880424	5.089198636767547	0.0812009444196286	0.4844375668043967	0.022876651139046647	0	0	56767	62684	/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_ema_decode32_logitnorm_gamma_mn0p8_s1p1_step170000_ema_dgamma2p25_tschedlogit_normal_mn0p8_s1p1_sc1p0_decode32_n64/sc1p0
+[2026-06-08T15:47:39+00:00] done
+DONE 2026-06-08T15:47:39+00:00 gpu=0 m=-0.7 s=1.0 g=2.25
+START 2026-06-08T15:47:40+00:00 gpu=0 m=-0.7 s=1.0 g=2.50
+checkpoint=/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/mini_owt_logdirichlet/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_170000.pt
+use_ema=1
+step=170000
+decode_steps=32
+n=64 chunk_n=8 gpu=0
+out_base=/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608
+[2026-06-08T15:47:40+00:00] infer step=170000 decode=32 -> /e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_ema_decode32_logitnorm_gamma_mn0p7_s1p0_step170000_ema_dgamma2p50_tschedlogit_normal_mn0p7_s1p0_sc1p0_decode32_n64
+[2026-06-08T15:47:40+00:00] run decode=32 chunk=0 n=8 seed=123
+[2026-06-08T15:47:40+00:00] done
+DONE 2026-06-08T15:47:40+00:00 gpu=1 m=-0.7 s=1.1 g=2.25
+START 2026-06-08T15:47:40+00:00 gpu=1 m=-0.7 s=1.1 g=2.50
+[2026-06-08T15:47:40+00:00] done
+DONE 2026-06-08T15:47:40+00:00 gpu=3 m=-0.8 s=1.1 g=2.25
+checkpoint=/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/mini_owt_logdirichlet/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_170000.pt
+use_ema=1
+step=170000
+decode_steps=32
+n=64 chunk_n=8 gpu=1
+out_base=/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608
+[2026-06-08T15:47:40+00:00] infer step=170000 decode=32 -> /e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_ema_decode32_logitnorm_gamma_mn0p7_s1p1_step170000_ema_dgamma2p50_tschedlogit_normal_mn0p7_s1p1_sc1p0_decode32_n64
+[2026-06-08T15:47:40+00:00] run decode=32 chunk=0 n=8 seed=123
+START 2026-06-08T15:47:40+00:00 gpu=3 m=-0.8 s=1.1 g=2.50
+checkpoint=/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/mini_owt_logdirichlet/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_170000.pt
+use_ema=1
+step=170000
+decode_steps=32
+n=64 chunk_n=8 gpu=3
+out_base=/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608
+[2026-06-08T15:47:40+00:00] infer step=170000 decode=32 -> /e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_ema_decode32_logitnorm_gamma_mn0p8_s1p1_step170000_ema_dgamma2p50_tschedlogit_normal_mn0p8_s1p1_sc1p0_decode32_n64
+[2026-06-08T15:47:40+00:00] run decode=32 chunk=0 n=8 seed=123
+[2026-06-08T15:47:43+00:00] done decode=32 chunk=7
+merged 64 samples -> /e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_ema_decode32_logitnorm_gamma_mn0p6_s1p1_step170000_ema_dgamma2p25_tschedlogit_normal_mn0p6_s1p1_sc1p0_decode32_n64/sc1p0/samples64.txt
+loading scorer /e2e-data/evad-tech-vla/wanghan58/models/flowtext_scorers/gpt2-large-standard dtype=fp32 device=cuda
+[2026-06-08T15:47:46+00:00] done decode=32 chunk=0
+[2026-06-08T15:47:46+00:00] run decode=32 chunk=1 n=8 seed=124
+[2026-06-08T15:47:47+00:00] done decode=32 chunk=0
+[2026-06-08T15:47:47+00:00] run decode=32 chunk=1 n=8 seed=124
+[2026-06-08T15:47:47+00:00] done decode=32 chunk=0
+[2026-06-08T15:47:47+00:00] run decode=32 chunk=1 n=8 seed=124
+[2026-06-08T15:47:54+00:00] done decode=32 chunk=1
+[2026-06-08T15:47:54+00:00] run decode=32 chunk=2 n=8 seed=125
+[2026-06-08T15:47:54+00:00] done decode=32 chunk=1
+[2026-06-08T15:47:54+00:00] run decode=32 chunk=2 n=8 seed=125
+[2026-06-08T15:47:54+00:00] done decode=32 chunk=1
+[2026-06-08T15:47:54+00:00] run decode=32 chunk=2 n=8 seed=125
+run	kind	ppl	mean_entropy	distinct_1	distinct_2	top_token_mass	eos_rows	eos_total	ppl_tokens	t5_tokens	path
+sc1p0	raw_full	25.174531009473792	5.0388563023984165	0.08290306270970906	0.4709045780474352	0.04130597986793118	61	62	61316	65269	/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_ema_decode32_logitnorm_gamma_mn0p6_s1p1_step170000_ema_dgamma2p25_tschedlogit_normal_mn0p6_s1p1_sc1p0_decode32_n64/sc1p0
+sc1p0	pre_eos	32.537291715453534	5.092185114167868	0.08654476812081073	0.49161734122540396	0.022572027323191118	0	0	55766	62511	/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_ema_decode32_logitnorm_gamma_mn0p6_s1p1_step170000_ema_dgamma2p25_tschedlogit_normal_mn0p6_s1p1_sc1p0_decode32_n64/sc1p0
+[2026-06-08T15:47:55+00:00] done
+DONE 2026-06-08T15:47:55+00:00 gpu=2 m=-0.6 s=1.1 g=2.25
+START 2026-06-08T15:47:55+00:00 gpu=2 m=-0.6 s=1.1 g=2.50
+checkpoint=/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/mini_owt_logdirichlet/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_170000.pt
+use_ema=1
+step=170000
+decode_steps=32
+n=64 chunk_n=8 gpu=2
+out_base=/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608
+[2026-06-08T15:47:55+00:00] infer step=170000 decode=32 -> /e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_ema_decode32_logitnorm_gamma_mn0p6_s1p1_step170000_ema_dgamma2p50_tschedlogit_normal_mn0p6_s1p1_sc1p0_decode32_n64
+[2026-06-08T15:47:55+00:00] run decode=32 chunk=0 n=8 seed=123
+[2026-06-08T15:48:01+00:00] done decode=32 chunk=2
+[2026-06-08T15:48:01+00:00] run decode=32 chunk=3 n=8 seed=126
+[2026-06-08T15:48:01+00:00] done decode=32 chunk=2
+[2026-06-08T15:48:01+00:00] run decode=32 chunk=3 n=8 seed=126
+[2026-06-08T15:48:01+00:00] done decode=32 chunk=2
+[2026-06-08T15:48:01+00:00] run decode=32 chunk=3 n=8 seed=126
+[2026-06-08T15:48:02+00:00] done decode=32 chunk=0
+[2026-06-08T15:48:02+00:00] run decode=32 chunk=1 n=8 seed=124
+[2026-06-08T15:48:07+00:00] done decode=32 chunk=3
+[2026-06-08T15:48:07+00:00] run decode=32 chunk=4 n=8 seed=127
+[2026-06-08T15:48:08+00:00] done decode=32 chunk=3
+[2026-06-08T15:48:08+00:00] run decode=32 chunk=4 n=8 seed=127
+[2026-06-08T15:48:08+00:00] done decode=32 chunk=3
+[2026-06-08T15:48:08+00:00] run decode=32 chunk=4 n=8 seed=127
+[2026-06-08T15:48:09+00:00] done decode=32 chunk=1
+[2026-06-08T15:48:09+00:00] run decode=32 chunk=2 n=8 seed=125
+[2026-06-08T15:48:15+00:00] done decode=32 chunk=4
+[2026-06-08T15:48:15+00:00] run decode=32 chunk=5 n=8 seed=128
+[2026-06-08T15:48:15+00:00] done decode=32 chunk=4
+[2026-06-08T15:48:15+00:00] run decode=32 chunk=5 n=8 seed=128
+[2026-06-08T15:48:15+00:00] done decode=32 chunk=4
+[2026-06-08T15:48:15+00:00] run decode=32 chunk=5 n=8 seed=128
+[2026-06-08T15:48:16+00:00] done decode=32 chunk=2
+[2026-06-08T15:48:16+00:00] run decode=32 chunk=3 n=8 seed=126
+[2026-06-08T15:48:22+00:00] done decode=32 chunk=5
+[2026-06-08T15:48:22+00:00] run decode=32 chunk=6 n=8 seed=129
+[2026-06-08T15:48:22+00:00] done decode=32 chunk=5
+[2026-06-08T15:48:22+00:00] run decode=32 chunk=6 n=8 seed=129
+[2026-06-08T15:48:22+00:00] done decode=32 chunk=5
+[2026-06-08T15:48:22+00:00] run decode=32 chunk=6 n=8 seed=129
+[2026-06-08T15:48:23+00:00] done decode=32 chunk=3
+[2026-06-08T15:48:23+00:00] run decode=32 chunk=4 n=8 seed=127
+[2026-06-08T15:48:29+00:00] done decode=32 chunk=6
+[2026-06-08T15:48:29+00:00] run decode=32 chunk=7 n=8 seed=130
+[2026-06-08T15:48:29+00:00] done decode=32 chunk=6
+[2026-06-08T15:48:29+00:00] run decode=32 chunk=7 n=8 seed=130
+[2026-06-08T15:48:29+00:00] done decode=32 chunk=6
+[2026-06-08T15:48:29+00:00] run decode=32 chunk=7 n=8 seed=130
+[2026-06-08T15:48:30+00:00] done decode=32 chunk=4
+[2026-06-08T15:48:30+00:00] run decode=32 chunk=5 n=8 seed=128
+[2026-06-08T15:48:36+00:00] done decode=32 chunk=7
+merged 64 samples -> /e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_ema_decode32_logitnorm_gamma_mn0p8_s1p1_step170000_ema_dgamma2p50_tschedlogit_normal_mn0p8_s1p1_sc1p0_decode32_n64/sc1p0/samples64.txt
+[2026-06-08T15:48:36+00:00] done decode=32 chunk=7
+merged 64 samples -> /e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_ema_decode32_logitnorm_gamma_mn0p7_s1p0_step170000_ema_dgamma2p50_tschedlogit_normal_mn0p7_s1p0_sc1p0_decode32_n64/sc1p0/samples64.txt
+[2026-06-08T15:48:36+00:00] done decode=32 chunk=7
+merged 64 samples -> /e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_ema_decode32_logitnorm_gamma_mn0p7_s1p1_step170000_ema_dgamma2p50_tschedlogit_normal_mn0p7_s1p1_sc1p0_decode32_n64/sc1p0/samples64.txt
+[2026-06-08T15:48:37+00:00] done decode=32 chunk=5
+[2026-06-08T15:48:37+00:00] run decode=32 chunk=6 n=8 seed=129
+loading scorer /e2e-data/evad-tech-vla/wanghan58/models/flowtext_scorers/gpt2-large-standard dtype=fp32 device=cuda
+loading scorer /e2e-data/evad-tech-vla/wanghan58/models/flowtext_scorers/gpt2-large-standard dtype=fp32 device=cuda
+loading scorer /e2e-data/evad-tech-vla/wanghan58/models/flowtext_scorers/gpt2-large-standard dtype=fp32 device=cuda
+[2026-06-08T15:48:44+00:00] done decode=32 chunk=6
+[2026-06-08T15:48:44+00:00] run decode=32 chunk=7 n=8 seed=130
+run	kind	ppl	mean_entropy	distinct_1	distinct_2	top_token_mass	eos_rows	eos_total	ppl_tokens	t5_tokens	path
+sc1p0	raw_full	22.183295482418455	4.971469676607801	0.07550173751970975	0.45124154190012555	0.03667927070097821	57	58	61603	65323	/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_ema_decode32_logitnorm_gamma_mn0p8_s1p1_step170000_ema_dgamma2p50_tschedlogit_normal_mn0p8_s1p1_sc1p0_decode32_n64/sc1p0
+sc1p0	pre_eos	27.258200674732276	5.015244897536482	0.07842638383131649	0.46868937442356007	0.02238936505160049	0	0	56696	62887	/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_ema_decode32_logitnorm_gamma_mn0p8_s1p1_step170000_ema_dgamma2p50_tschedlogit_normal_mn0p8_s1p1_sc1p0_decode32_n64/sc1p0
+run	kind	ppl	mean_entropy	distinct_1	distinct_2	top_token_mass	eos_rows	eos_total	ppl_tokens	t5_tokens	path
+sc1p0	raw_full	23.524054834667172	5.024235190682451	0.07921960489815937	0.46242030407062285	0.038222808012383334	59	60	61266	65249	/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_ema_decode32_logitnorm_gamma_mn0p7_s1p1_step170000_ema_dgamma2p50_tschedlogit_normal_mn0p7_s1p1_sc1p0_decode32_n64/sc1p0
+sc1p0	pre_eos	29.52189721859362	5.071457529805532	0.08244413608306618	0.48121092254689296	0.02309520391725282	0	0	56124	62697	/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_ema_decode32_logitnorm_gamma_mn0p7_s1p1_step170000_ema_dgamma2p50_tschedlogit_normal_mn0p7_s1p1_sc1p0_decode32_n64/sc1p0
+run	kind	ppl	mean_entropy	distinct_1	distinct_2	top_token_mass	eos_rows	eos_total	ppl_tokens	t5_tokens	path
+sc1p0	raw_full	21.952656805572055	4.916800291360432	0.07723084941670627	0.4411791758646063	0.03832416108411387	59	60	60448	65233	/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_ema_decode32_logitnorm_gamma_mn0p7_s1p0_step170000_ema_dgamma2p50_tschedlogit_normal_mn0p7_s1p0_sc1p0_decode32_n64/sc1p0
+sc1p0	pre_eos	27.51050197844278	4.959951572644155	0.08038677559356651	0.45914378261077693	0.021939622159816187	0	0	55288	62672	/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_ema_decode32_logitnorm_gamma_mn0p7_s1p0_step170000_ema_dgamma2p50_tschedlogit_normal_mn0p7_s1p0_sc1p0_decode32_n64/sc1p0
+[2026-06-08T15:48:49+00:00] done
+DONE 2026-06-08T15:48:49+00:00 gpu=3 m=-0.8 s=1.1 g=2.50
+[2026-06-08T15:48:49+00:00] done
+DONE 2026-06-08T15:48:49+00:00 gpu=1 m=-0.7 s=1.1 g=2.50
+[2026-06-08T15:48:49+00:00] done
+DONE 2026-06-08T15:48:49+00:00 gpu=0 m=-0.7 s=1.0 g=2.50
+[2026-06-08T15:48:51+00:00] done decode=32 chunk=7
+merged 64 samples -> /e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_ema_decode32_logitnorm_gamma_mn0p6_s1p1_step170000_ema_dgamma2p50_tschedlogit_normal_mn0p6_s1p1_sc1p0_decode32_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	25.56861985862191	5.007517763619101	0.0820928699544695	0.46860340334202055	0.0398736796921709	61	61	60569	65231	/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_ema_decode32_logitnorm_gamma_mn0p6_s1p1_step170000_ema_dgamma2p50_tschedlogit_normal_mn0p6_s1p1_sc1p0_decode32_n64/sc1p0
+sc1p0	pre_eos	32.81872528504946	5.056879901669754	0.08556953123751379	0.48847653752717046	0.021624126963831928	0	0	55207	62569	/e2e-data/evad-tech-vla/wanghan58/workspace/LTA_openwebtext_dualt/docs/lta_samples/metrics_20260608/owt_t5_elftokenized_full_pow1_unfixed_norm_stateprobadd_selfcond_ce_fast_lr2e3_ema0p9999_ema_decode32_logitnorm_gamma_mn0p6_s1p1_step170000_ema_dgamma2p50_tschedlogit_normal_mn0p6_s1p1_sc1p0_decode32_n64/sc1p0
+[2026-06-08T15:49:03+00:00] done
+DONE 2026-06-08T15:49:03+00:00 gpu=2 m=-0.6 s=1.1 g=2.50
+ALL_DONE 2026-06-08T15:49:03+00:00

LTA_openwebtext_dualt/mini_owt_logdirichlet/logs/length_diag_len512_d256_l3_h4_4gpu_steps40000_20260526_221958.log

@@ -0,0 +1,426 @@
+W0526 22:29:48.987000 1918781 torch/distributed/run.py:792] 
+W0526 22:29:48.987000 1918781 torch/distributed/run.py:792] *****************************************
+W0526 22:29:48.987000 1918781 torch/distributed/run.py:792] Setting OMP_NUM_THREADS environment variable for each process to be 1 in default, to avoid your system being overloaded, please further tune the variable for optimal performance in your application as needed. 
+W0526 22:29:48.987000 1918781 torch/distributed/run.py:792] *****************************************
+{
+  "cache_path": "../mini_owt_fit/cache/owt_t5_len512_from_payload1022_appendeos1.pt",
+  "tokenizer_path": "/e2e-data/evad-tech-vla/wanghan58/models/hf/t5-small/tokenizer.json",
+  "out_dir": "runs/length_diag_len512_d256_l3_h4_4gpu_steps40000_20260526_221958",
+  "subset_size": 0,
+  "resume": "",
+  "steps": 40000,
+  "batch_size": 8,
+  "grad_accum": 1,
+  "lr": 0.0003,
+  "log_every": 100,
+  "save_every": 1000,
+  "dim": 256,
+  "layers": 3,
+  "heads": 4,
+  "mlp_dim": 1024,
+  "time_tokens": 4,
+  "c_min": 1.0,
+  "c_max": 1024.0,
+  "seed": 1234
+}
+[data] rows=2860537 length=512 vocab=32100 seen=8013769 dropped=5153232 bos=1:</s> eos=1:</s>
+step=100 loss=7.2286 {'pos0_bos_p': 0.5428104996681213, 'pos0_bos_top1': 4, 'last_eos_p': 0.5332822203636169, 'last_eos_top1': 4}
+step=200 loss=7.2465 {'pos0_bos_p': 0.9345881342887878, 'pos0_bos_top1': 4, 'last_eos_p': 0.933324933052063, 'last_eos_top1': 4}
+step=300 loss=6.9267 {'pos0_bos_p': 0.8070314526557922, 'pos0_bos_top1': 4, 'last_eos_p': 0.811517596244812, 'last_eos_top1': 4}
+step=400 loss=6.8439 {'pos0_bos_p': 0.9430739879608154, 'pos0_bos_top1': 4, 'last_eos_p': 0.9447622299194336, 'last_eos_top1': 4}
+step=500 loss=6.7029 {'pos0_bos_p': 0.97152179479599, 'pos0_bos_top1': 4, 'last_eos_p': 0.9706050157546997, 'last_eos_top1': 4}
+step=600 loss=6.0849 {'pos0_bos_p': 0.9864975810050964, 'pos0_bos_top1': 4, 'last_eos_p': 0.9877360463142395, 'last_eos_top1': 4}
+step=700 loss=5.8156 {'pos0_bos_p': 0.9878588318824768, 'pos0_bos_top1': 4, 'last_eos_p': 0.9911380410194397, 'last_eos_top1': 4}
+step=800 loss=5.4763 {'pos0_bos_p': 0.9893057942390442, 'pos0_bos_top1': 4, 'last_eos_p': 0.9928054213523865, 'last_eos_top1': 4}
+step=900 loss=5.1360 {'pos0_bos_p': 0.9925646781921387, 'pos0_bos_top1': 4, 'last_eos_p': 0.9953165054321289, 'last_eos_top1': 4}
+step=1000 loss=5.8050 {'pos0_bos_p': 0.995136559009552, 'pos0_bos_top1': 4, 'last_eos_p': 0.9971464276313782, 'last_eos_top1': 4}
+step=1100 loss=5.2770 {'pos0_bos_p': 0.9963133931159973, 'pos0_bos_top1': 4, 'last_eos_p': 0.9977411031723022, 'last_eos_top1': 4}
+step=1200 loss=4.6809 {'pos0_bos_p': 0.9968127608299255, 'pos0_bos_top1': 4, 'last_eos_p': 0.997734546661377, 'last_eos_top1': 4}
+step=1300 loss=5.6375 {'pos0_bos_p': 0.9968425035476685, 'pos0_bos_top1': 4, 'last_eos_p': 0.9973317384719849, 'last_eos_top1': 4}
+step=1400 loss=4.9622 {'pos0_bos_p': 0.9977274537086487, 'pos0_bos_top1': 4, 'last_eos_p': 0.99802565574646, 'last_eos_top1': 4}
+step=1500 loss=5.1946 {'pos0_bos_p': 0.9980510473251343, 'pos0_bos_top1': 4, 'last_eos_p': 0.9982170462608337, 'last_eos_top1': 4}
+step=1600 loss=6.0009 {'pos0_bos_p': 0.9980791807174683, 'pos0_bos_top1': 4, 'last_eos_p': 0.9982757568359375, 'last_eos_top1': 4}
+step=1700 loss=5.1194 {'pos0_bos_p': 0.9980650544166565, 'pos0_bos_top1': 4, 'last_eos_p': 0.9980505704879761, 'last_eos_top1': 4}
+step=1800 loss=4.3220 {'pos0_bos_p': 0.9983502626419067, 'pos0_bos_top1': 4, 'last_eos_p': 0.9984796643257141, 'last_eos_top1': 4}
+step=1900 loss=5.5107 {'pos0_bos_p': 0.9984862208366394, 'pos0_bos_top1': 4, 'last_eos_p': 0.9985274076461792, 'last_eos_top1': 4}
+step=2000 loss=5.0794 {'pos0_bos_p': 0.9985483288764954, 'pos0_bos_top1': 4, 'last_eos_p': 0.998536229133606, 'last_eos_top1': 4}
+step=2100 loss=4.9547 {'pos0_bos_p': 0.9988847374916077, 'pos0_bos_top1': 4, 'last_eos_p': 0.9987375140190125, 'last_eos_top1': 4}
+step=2200 loss=4.3467 {'pos0_bos_p': 0.998736560344696, 'pos0_bos_top1': 4, 'last_eos_p': 0.9987230896949768, 'last_eos_top1': 4}
+step=2300 loss=4.4955 {'pos0_bos_p': 0.9987422823905945, 'pos0_bos_top1': 4, 'last_eos_p': 0.998599112033844, 'last_eos_top1': 4}
+step=2400 loss=3.3878 {'pos0_bos_p': 0.9988105297088623, 'pos0_bos_top1': 4, 'last_eos_p': 0.9988264441490173, 'last_eos_top1': 4}
+step=2500 loss=4.5579 {'pos0_bos_p': 0.9988901019096375, 'pos0_bos_top1': 4, 'last_eos_p': 0.9989213943481445, 'last_eos_top1': 4}
+step=2600 loss=4.2367 {'pos0_bos_p': 0.9987167119979858, 'pos0_bos_top1': 4, 'last_eos_p': 0.9987905621528625, 'last_eos_top1': 4}
+step=2700 loss=4.6436 {'pos0_bos_p': 0.9987780451774597, 'pos0_bos_top1': 4, 'last_eos_p': 0.9989808201789856, 'last_eos_top1': 4}
+step=2800 loss=4.6348 {'pos0_bos_p': 0.9989067316055298, 'pos0_bos_top1': 4, 'last_eos_p': 0.9989762306213379, 'last_eos_top1': 4}
+step=2900 loss=2.7339 {'pos0_bos_p': 0.9991104006767273, 'pos0_bos_top1': 4, 'last_eos_p': 0.9992275238037109, 'last_eos_top1': 4}
+step=3000 loss=3.8760 {'pos0_bos_p': 0.9992281198501587, 'pos0_bos_top1': 4, 'last_eos_p': 0.9992320537567139, 'last_eos_top1': 4}
+step=3100 loss=5.5894 {'pos0_bos_p': 0.999041736125946, 'pos0_bos_top1': 4, 'last_eos_p': 0.9991102814674377, 'last_eos_top1': 4}
+step=3200 loss=3.0852 {'pos0_bos_p': 0.9992801547050476, 'pos0_bos_top1': 4, 'last_eos_p': 0.9992904663085938, 'last_eos_top1': 4}
+step=3300 loss=3.7114 {'pos0_bos_p': 0.9994068145751953, 'pos0_bos_top1': 4, 'last_eos_p': 0.9994370341300964, 'last_eos_top1': 4}
+step=3400 loss=4.9119 {'pos0_bos_p': 0.9992316961288452, 'pos0_bos_top1': 4, 'last_eos_p': 0.9992997646331787, 'last_eos_top1': 4}
+step=3500 loss=3.7738 {'pos0_bos_p': 0.9994509816169739, 'pos0_bos_top1': 4, 'last_eos_p': 0.999451220035553, 'last_eos_top1': 4}
+step=3600 loss=3.1688 {'pos0_bos_p': 0.9995419979095459, 'pos0_bos_top1': 4, 'last_eos_p': 0.9995504021644592, 'last_eos_top1': 4}
+step=3700 loss=3.4367 {'pos0_bos_p': 0.9995220899581909, 'pos0_bos_top1': 4, 'last_eos_p': 0.9994497895240784, 'last_eos_top1': 4}
+step=3800 loss=4.2707 {'pos0_bos_p': 0.9995793700218201, 'pos0_bos_top1': 4, 'last_eos_p': 0.999500036239624, 'last_eos_top1': 4}
+step=3900 loss=5.4563 {'pos0_bos_p': 0.9995649456977844, 'pos0_bos_top1': 4, 'last_eos_p': 0.9995518326759338, 'last_eos_top1': 4}
+step=4000 loss=3.7971 {'pos0_bos_p': 0.99954754114151, 'pos0_bos_top1': 4, 'last_eos_p': 0.9994538426399231, 'last_eos_top1': 4}
+step=4100 loss=4.5064 {'pos0_bos_p': 0.9994913339614868, 'pos0_bos_top1': 4, 'last_eos_p': 0.999367892742157, 'last_eos_top1': 4}
+step=4200 loss=4.0607 {'pos0_bos_p': 0.9996055960655212, 'pos0_bos_top1': 4, 'last_eos_p': 0.9994733929634094, 'last_eos_top1': 4}
+step=4300 loss=3.7961 {'pos0_bos_p': 0.9996304512023926, 'pos0_bos_top1': 4, 'last_eos_p': 0.9995335340499878, 'last_eos_top1': 4}
+step=4400 loss=3.4871 {'pos0_bos_p': 0.9996232986450195, 'pos0_bos_top1': 4, 'last_eos_p': 0.9994897842407227, 'last_eos_top1': 4}
+step=4500 loss=5.6084 {'pos0_bos_p': 0.9997205138206482, 'pos0_bos_top1': 4, 'last_eos_p': 0.9996069073677063, 'last_eos_top1': 4}
+step=4600 loss=4.5265 {'pos0_bos_p': 0.9996204376220703, 'pos0_bos_top1': 4, 'last_eos_p': 0.9995194673538208, 'last_eos_top1': 4}
+step=4700 loss=4.3960 {'pos0_bos_p': 0.9995934367179871, 'pos0_bos_top1': 4, 'last_eos_p': 0.9994602799415588, 'last_eos_top1': 4}
+step=4800 loss=4.3798 {'pos0_bos_p': 0.9996843338012695, 'pos0_bos_top1': 4, 'last_eos_p': 0.9995966553688049, 'last_eos_top1': 4}
+step=4900 loss=3.1587 {'pos0_bos_p': 0.9995962977409363, 'pos0_bos_top1': 4, 'last_eos_p': 0.9995177984237671, 'last_eos_top1': 4}
+step=5000 loss=3.6261 {'pos0_bos_p': 0.9996069073677063, 'pos0_bos_top1': 4, 'last_eos_p': 0.999462902545929, 'last_eos_top1': 4}
+step=5100 loss=2.9708 {'pos0_bos_p': 0.9997046589851379, 'pos0_bos_top1': 4, 'last_eos_p': 0.9996020197868347, 'last_eos_top1': 4}
+step=5200 loss=2.9540 {'pos0_bos_p': 0.9997428059577942, 'pos0_bos_top1': 4, 'last_eos_p': 0.9996951818466187, 'last_eos_top1': 4}
+step=5300 loss=2.1556 {'pos0_bos_p': 0.9995536208152771, 'pos0_bos_top1': 4, 'last_eos_p': 0.9994271993637085, 'last_eos_top1': 4}
+step=5400 loss=3.9129 {'pos0_bos_p': 0.999637246131897, 'pos0_bos_top1': 4, 'last_eos_p': 0.9995465874671936, 'last_eos_top1': 4}
+step=5500 loss=3.9672 {'pos0_bos_p': 0.999707043170929, 'pos0_bos_top1': 4, 'last_eos_p': 0.9995854496955872, 'last_eos_top1': 4}
+step=5600 loss=4.4603 {'pos0_bos_p': 0.9995802044868469, 'pos0_bos_top1': 4, 'last_eos_p': 0.9994596838951111, 'last_eos_top1': 4}
+step=5700 loss=5.7201 {'pos0_bos_p': 0.9995546936988831, 'pos0_bos_top1': 4, 'last_eos_p': 0.9994540810585022, 'last_eos_top1': 4}
+step=5800 loss=4.4626 {'pos0_bos_p': 0.9996980428695679, 'pos0_bos_top1': 4, 'last_eos_p': 0.9996355772018433, 'last_eos_top1': 4}
+step=5900 loss=4.9022 {'pos0_bos_p': 0.9997143149375916, 'pos0_bos_top1': 4, 'last_eos_p': 0.9996024966239929, 'last_eos_top1': 4}
+step=6000 loss=3.7093 {'pos0_bos_p': 0.9997084736824036, 'pos0_bos_top1': 4, 'last_eos_p': 0.9996448755264282, 'last_eos_top1': 4}
+step=6100 loss=3.3708 {'pos0_bos_p': 0.9996343851089478, 'pos0_bos_top1': 4, 'last_eos_p': 0.999545156955719, 'last_eos_top1': 4}
+step=6200 loss=2.4102 {'pos0_bos_p': 0.9995823502540588, 'pos0_bos_top1': 4, 'last_eos_p': 0.9993222951889038, 'last_eos_top1': 4}
+step=6300 loss=2.7949 {'pos0_bos_p': 0.9996278285980225, 'pos0_bos_top1': 4, 'last_eos_p': 0.9994744658470154, 'last_eos_top1': 4}
+step=6400 loss=4.2763 {'pos0_bos_p': 0.9997265934944153, 'pos0_bos_top1': 4, 'last_eos_p': 0.9995526671409607, 'last_eos_top1': 4}
+step=6500 loss=4.4179 {'pos0_bos_p': 0.9996315240859985, 'pos0_bos_top1': 4, 'last_eos_p': 0.9994361996650696, 'last_eos_top1': 4}
+step=6600 loss=4.1307 {'pos0_bos_p': 0.9997672438621521, 'pos0_bos_top1': 4, 'last_eos_p': 0.9997032284736633, 'last_eos_top1': 4}
+step=6700 loss=4.3737 {'pos0_bos_p': 0.9997279047966003, 'pos0_bos_top1': 4, 'last_eos_p': 0.9996656179428101, 'last_eos_top1': 4}
+step=6800 loss=4.0470 {'pos0_bos_p': 0.9997683167457581, 'pos0_bos_top1': 4, 'last_eos_p': 0.9996935129165649, 'last_eos_top1': 4}
+step=6900 loss=4.2110 {'pos0_bos_p': 0.9998550415039062, 'pos0_bos_top1': 4, 'last_eos_p': 0.9997884631156921, 'last_eos_top1': 4}
+step=7000 loss=4.4686 {'pos0_bos_p': 0.999649167060852, 'pos0_bos_top1': 4, 'last_eos_p': 0.9994753003120422, 'last_eos_top1': 4}
+step=7100 loss=3.6474 {'pos0_bos_p': 0.999688982963562, 'pos0_bos_top1': 4, 'last_eos_p': 0.9995796084403992, 'last_eos_top1': 4}
+step=7200 loss=4.1826 {'pos0_bos_p': 0.9997484087944031, 'pos0_bos_top1': 4, 'last_eos_p': 0.99967360496521, 'last_eos_top1': 4}
+step=7300 loss=3.4323 {'pos0_bos_p': 0.9998325109481812, 'pos0_bos_top1': 4, 'last_eos_p': 0.9997714161872864, 'last_eos_top1': 4}
+step=7400 loss=4.1477 {'pos0_bos_p': 0.9998434782028198, 'pos0_bos_top1': 4, 'last_eos_p': 0.9997803568840027, 'last_eos_top1': 4}
+step=7500 loss=5.0766 {'pos0_bos_p': 0.999788224697113, 'pos0_bos_top1': 4, 'last_eos_p': 0.9997649788856506, 'last_eos_top1': 4}
+step=7600 loss=3.9548 {'pos0_bos_p': 0.9998218417167664, 'pos0_bos_top1': 4, 'last_eos_p': 0.9997718930244446, 'last_eos_top1': 4}
+step=7700 loss=4.4614 {'pos0_bos_p': 0.999830961227417, 'pos0_bos_top1': 4, 'last_eos_p': 0.999794065952301, 'last_eos_top1': 4}
+step=7800 loss=4.4111 {'pos0_bos_p': 0.9998483657836914, 'pos0_bos_top1': 4, 'last_eos_p': 0.9998329877853394, 'last_eos_top1': 4}
+step=7900 loss=4.5222 {'pos0_bos_p': 0.9998506307601929, 'pos0_bos_top1': 4, 'last_eos_p': 0.999809205532074, 'last_eos_top1': 4}
+step=8000 loss=5.7780 {'pos0_bos_p': 0.9998194575309753, 'pos0_bos_top1': 4, 'last_eos_p': 0.9998052716255188, 'last_eos_top1': 4}
+step=8100 loss=2.6718 {'pos0_bos_p': 0.9999194145202637, 'pos0_bos_top1': 4, 'last_eos_p': 0.9998979568481445, 'last_eos_top1': 4}
+step=8200 loss=4.0481 {'pos0_bos_p': 0.9999116659164429, 'pos0_bos_top1': 4, 'last_eos_p': 0.999881386756897, 'last_eos_top1': 4}
+step=8300 loss=3.3655 {'pos0_bos_p': 0.9999097585678101, 'pos0_bos_top1': 4, 'last_eos_p': 0.9998917579650879, 'last_eos_top1': 4}
+step=8400 loss=3.7296 {'pos0_bos_p': 0.9999042749404907, 'pos0_bos_top1': 4, 'last_eos_p': 0.9998965263366699, 'last_eos_top1': 4}
+step=8500 loss=3.5417 {'pos0_bos_p': 0.9998849630355835, 'pos0_bos_top1': 4, 'last_eos_p': 0.999854564666748, 'last_eos_top1': 4}
+step=8600 loss=3.1565 {'pos0_bos_p': 0.9999438524246216, 'pos0_bos_top1': 4, 'last_eos_p': 0.9999411106109619, 'last_eos_top1': 4}
+step=8700 loss=3.1316 {'pos0_bos_p': 0.9998975992202759, 'pos0_bos_top1': 4, 'last_eos_p': 0.9998869895935059, 'last_eos_top1': 4}
+step=8800 loss=3.5621 {'pos0_bos_p': 0.9999427795410156, 'pos0_bos_top1': 4, 'last_eos_p': 0.9999337196350098, 'last_eos_top1': 4}
+step=8900 loss=3.7180 {'pos0_bos_p': 0.9999264478683472, 'pos0_bos_top1': 4, 'last_eos_p': 0.9999213218688965, 'last_eos_top1': 4}
+step=9000 loss=3.6814 {'pos0_bos_p': 0.9999386072158813, 'pos0_bos_top1': 4, 'last_eos_p': 0.9999340772628784, 'last_eos_top1': 4}
+step=9100 loss=3.7906 {'pos0_bos_p': 0.9999289512634277, 'pos0_bos_top1': 4, 'last_eos_p': 0.9999256134033203, 'last_eos_top1': 4}
+step=9200 loss=4.0621 {'pos0_bos_p': 0.9999411106109619, 'pos0_bos_top1': 4, 'last_eos_p': 0.9999372959136963, 'last_eos_top1': 4}
+step=9300 loss=4.2759 {'pos0_bos_p': 0.9999549388885498, 'pos0_bos_top1': 4, 'last_eos_p': 0.999943733215332, 'last_eos_top1': 4}
+step=9400 loss=3.6376 {'pos0_bos_p': 0.9999439716339111, 'pos0_bos_top1': 4, 'last_eos_p': 0.9999396800994873, 'last_eos_top1': 4}
+step=9500 loss=2.0153 {'pos0_bos_p': 0.9999303817749023, 'pos0_bos_top1': 4, 'last_eos_p': 0.9999210834503174, 'last_eos_top1': 4}
+step=9600 loss=3.4315 {'pos0_bos_p': 0.9999560117721558, 'pos0_bos_top1': 4, 'last_eos_p': 0.9999523162841797, 'last_eos_top1': 4}
+step=9700 loss=2.5703 {'pos0_bos_p': 0.9999544620513916, 'pos0_bos_top1': 4, 'last_eos_p': 0.9999518394470215, 'last_eos_top1': 4}
+step=9800 loss=3.4693 {'pos0_bos_p': 0.9999334812164307, 'pos0_bos_top1': 4, 'last_eos_p': 0.9999330043792725, 'last_eos_top1': 4}
+step=9900 loss=1.5927 {'pos0_bos_p': 0.999937891960144, 'pos0_bos_top1': 4, 'last_eos_p': 0.9999226331710815, 'last_eos_top1': 4}
+step=10000 loss=3.3874 {'pos0_bos_p': 0.9999411106109619, 'pos0_bos_top1': 4, 'last_eos_p': 0.9999414682388306, 'last_eos_top1': 4}
+step=10100 loss=3.3689 {'pos0_bos_p': 0.9999592304229736, 'pos0_bos_top1': 4, 'last_eos_p': 0.9999591112136841, 'last_eos_top1': 4}
+step=10200 loss=4.1073 {'pos0_bos_p': 0.9999493360519409, 'pos0_bos_top1': 4, 'last_eos_p': 0.9999523162841797, 'last_eos_top1': 4}
+step=10300 loss=3.7001 {'pos0_bos_p': 0.999954342842102, 'pos0_bos_top1': 4, 'last_eos_p': 0.9999641180038452, 'last_eos_top1': 4}
+step=10400 loss=4.8470 {'pos0_bos_p': 0.9999337196350098, 'pos0_bos_top1': 4, 'last_eos_p': 0.999946117401123, 'last_eos_top1': 4}
+step=10500 loss=4.0317 {'pos0_bos_p': 0.9999614953994751, 'pos0_bos_top1': 4, 'last_eos_p': 0.9999667406082153, 'last_eos_top1': 4}
+step=10600 loss=3.7106 {'pos0_bos_p': 0.9999603033065796, 'pos0_bos_top1': 4, 'last_eos_p': 0.9999661445617676, 'last_eos_top1': 4}
+step=10700 loss=2.7635 {'pos0_bos_p': 0.9999673366546631, 'pos0_bos_top1': 4, 'last_eos_p': 0.9999743700027466, 'last_eos_top1': 4}
+step=10800 loss=5.1715 {'pos0_bos_p': 0.9999655485153198, 'pos0_bos_top1': 4, 'last_eos_p': 0.999974250793457, 'last_eos_top1': 4}
+step=10900 loss=2.7226 {'pos0_bos_p': 0.9999657869338989, 'pos0_bos_top1': 4, 'last_eos_p': 0.9999701976776123, 'last_eos_top1': 4}
+step=11000 loss=2.6103 {'pos0_bos_p': 0.9999561309814453, 'pos0_bos_top1': 4, 'last_eos_p': 0.9999657869338989, 'last_eos_top1': 4}
+step=11100 loss=4.4516 {'pos0_bos_p': 0.999974250793457, 'pos0_bos_top1': 4, 'last_eos_p': 0.9999798536300659, 'last_eos_top1': 4}
+step=11200 loss=3.0512 {'pos0_bos_p': 0.999976396560669, 'pos0_bos_top1': 4, 'last_eos_p': 0.9999821186065674, 'last_eos_top1': 4}
+step=11300 loss=4.1645 {'pos0_bos_p': 0.9999775886535645, 'pos0_bos_top1': 4, 'last_eos_p': 0.9999806880950928, 'last_eos_top1': 4}
+step=11400 loss=4.1301 {'pos0_bos_p': 0.9999711513519287, 'pos0_bos_top1': 4, 'last_eos_p': 0.9999808073043823, 'last_eos_top1': 4}
+step=11500 loss=5.3245 {'pos0_bos_p': 0.9999810457229614, 'pos0_bos_top1': 4, 'last_eos_p': 0.999987006187439, 'last_eos_top1': 4}
+step=11600 loss=4.5307 {'pos0_bos_p': 0.9999774694442749, 'pos0_bos_top1': 4, 'last_eos_p': 0.9999873638153076, 'last_eos_top1': 4}
+step=11700 loss=3.4433 {'pos0_bos_p': 0.99997878074646, 'pos0_bos_top1': 4, 'last_eos_p': 0.9999884366989136, 'last_eos_top1': 4}
+step=11800 loss=3.7900 {'pos0_bos_p': 0.9999762773513794, 'pos0_bos_top1': 4, 'last_eos_p': 0.9999876022338867, 'last_eos_top1': 4}
+step=11900 loss=3.9122 {'pos0_bos_p': 0.999985933303833, 'pos0_bos_top1': 4, 'last_eos_p': 0.9999918937683105, 'last_eos_top1': 4}
+step=12000 loss=4.4534 {'pos0_bos_p': 0.9999825954437256, 'pos0_bos_top1': 4, 'last_eos_p': 0.9999908208847046, 'last_eos_top1': 4}
+step=12100 loss=3.4544 {'pos0_bos_p': 0.9999829530715942, 'pos0_bos_top1': 4, 'last_eos_p': 0.9999910593032837, 'last_eos_top1': 4}
+step=12200 loss=3.1251 {'pos0_bos_p': 0.9999877214431763, 'pos0_bos_top1': 4, 'last_eos_p': 0.9999922513961792, 'last_eos_top1': 4}
+step=12300 loss=4.2182 {'pos0_bos_p': 0.9999727010726929, 'pos0_bos_top1': 4, 'last_eos_p': 0.9999866485595703, 'last_eos_top1': 4}
+step=12400 loss=4.5856 {'pos0_bos_p': 0.9999867677688599, 'pos0_bos_top1': 4, 'last_eos_p': 0.9999927282333374, 'last_eos_top1': 4}
+step=12500 loss=4.9507 {'pos0_bos_p': 0.9999876022338867, 'pos0_bos_top1': 4, 'last_eos_p': 0.9999927282333374, 'last_eos_top1': 4}
+step=12600 loss=5.4264 {'pos0_bos_p': 0.9999899864196777, 'pos0_bos_top1': 4, 'last_eos_p': 0.9999946355819702, 'last_eos_top1': 4}
+step=12700 loss=4.2056 {'pos0_bos_p': 0.9999881982803345, 'pos0_bos_top1': 4, 'last_eos_p': 0.9999939203262329, 'last_eos_top1': 4}
+step=12800 loss=5.5941 {'pos0_bos_p': 0.9999889135360718, 'pos0_bos_top1': 4, 'last_eos_p': 0.9999945163726807, 'last_eos_top1': 4}
+step=12900 loss=3.6401 {'pos0_bos_p': 0.9999880790710449, 'pos0_bos_top1': 4, 'last_eos_p': 0.9999946355819702, 'last_eos_top1': 4}
+step=13000 loss=4.2919 {'pos0_bos_p': 0.9999892711639404, 'pos0_bos_top1': 4, 'last_eos_p': 0.9999949932098389, 'last_eos_top1': 4}
+step=13100 loss=4.0788 {'pos0_bos_p': 0.9999911785125732, 'pos0_bos_top1': 4, 'last_eos_p': 0.9999958276748657, 'last_eos_top1': 4}
+step=13200 loss=5.2596 {'pos0_bos_p': 0.9999916553497314, 'pos0_bos_top1': 4, 'last_eos_p': 0.9999959468841553, 'last_eos_top1': 4}
+step=13300 loss=3.0710 {'pos0_bos_p': 0.999987006187439, 'pos0_bos_top1': 4, 'last_eos_p': 0.9999946355819702, 'last_eos_top1': 4}
+step=13400 loss=3.9736 {'pos0_bos_p': 0.9999927282333374, 'pos0_bos_top1': 4, 'last_eos_p': 0.9999963045120239, 'last_eos_top1': 4}
+step=13500 loss=3.2135 {'pos0_bos_p': 0.9999939203262329, 'pos0_bos_top1': 4, 'last_eos_p': 0.9999967813491821, 'last_eos_top1': 4}
+step=13600 loss=3.4537 {'pos0_bos_p': 0.9999946355819702, 'pos0_bos_top1': 4, 'last_eos_p': 0.9999972581863403, 'last_eos_top1': 4}
+step=13700 loss=3.4531 {'pos0_bos_p': 0.9999916553497314, 'pos0_bos_top1': 4, 'last_eos_p': 0.9999961853027344, 'last_eos_top1': 4}
+step=13800 loss=3.6901 {'pos0_bos_p': 0.9999891519546509, 'pos0_bos_top1': 4, 'last_eos_p': 0.999995231628418, 'last_eos_top1': 4}
+step=13900 loss=3.8962 {'pos0_bos_p': 0.9999955892562866, 'pos0_bos_top1': 4, 'last_eos_p': 0.9999979734420776, 'last_eos_top1': 4}
+step=14000 loss=4.0519 {'pos0_bos_p': 0.9999951124191284, 'pos0_bos_top1': 4, 'last_eos_p': 0.9999979734420776, 'last_eos_top1': 4}
+step=14100 loss=4.3229 {'pos0_bos_p': 0.9999957084655762, 'pos0_bos_top1': 4, 'last_eos_p': 0.9999978542327881, 'last_eos_top1': 4}
+step=14200 loss=2.6693 {'pos0_bos_p': 0.999995231628418, 'pos0_bos_top1': 4, 'last_eos_p': 0.9999974966049194, 'last_eos_top1': 4}
+step=14300 loss=4.6166 {'pos0_bos_p': 0.9999951124191284, 'pos0_bos_top1': 4, 'last_eos_p': 0.9999972581863403, 'last_eos_top1': 4}
+step=14400 loss=2.4148 {'pos0_bos_p': 0.9999942779541016, 'pos0_bos_top1': 4, 'last_eos_p': 0.9999971389770508, 'last_eos_top1': 4}
+step=14500 loss=4.1042 {'pos0_bos_p': 0.9999959468841553, 'pos0_bos_top1': 4, 'last_eos_p': 0.9999978542327881, 'last_eos_top1': 4}
+step=14600 loss=3.7968 {'pos0_bos_p': 0.9999959468841553, 'pos0_bos_top1': 4, 'last_eos_p': 0.9999978542327881, 'last_eos_top1': 4}
+step=14700 loss=4.6907 {'pos0_bos_p': 0.9999935626983643, 'pos0_bos_top1': 4, 'last_eos_p': 0.9999970197677612, 'last_eos_top1': 4}
+step=14800 loss=3.1424 {'pos0_bos_p': 0.9999955892562866, 'pos0_bos_top1': 4, 'last_eos_p': 0.9999978542327881, 'last_eos_top1': 4}
+step=14900 loss=4.0253 {'pos0_bos_p': 0.9999946355819702, 'pos0_bos_top1': 4, 'last_eos_p': 0.9999974966049194, 'last_eos_top1': 4}
+step=15000 loss=3.8020 {'pos0_bos_p': 0.9999943971633911, 'pos0_bos_top1': 4, 'last_eos_p': 0.9999973773956299, 'last_eos_top1': 4}
+step=15100 loss=3.0508 {'pos0_bos_p': 0.9999954700469971, 'pos0_bos_top1': 4, 'last_eos_p': 0.9999979734420776, 'last_eos_top1': 4}
+step=15200 loss=3.1176 {'pos0_bos_p': 0.9999957084655762, 'pos0_bos_top1': 4, 'last_eos_p': 0.9999979734420776, 'last_eos_top1': 4}
+step=15300 loss=4.1332 {'pos0_bos_p': 0.999997615814209, 'pos0_bos_top1': 4, 'last_eos_p': 0.9999988079071045, 'last_eos_top1': 4}
+step=15400 loss=4.4994 {'pos0_bos_p': 0.9999977350234985, 'pos0_bos_top1': 4, 'last_eos_p': 0.999998927116394, 'last_eos_top1': 4}
+step=15500 loss=5.0983 {'pos0_bos_p': 0.9999973773956299, 'pos0_bos_top1': 4, 'last_eos_p': 0.9999986886978149, 'last_eos_top1': 4}
+step=15600 loss=2.6699 {'pos0_bos_p': 0.9999970197677612, 'pos0_bos_top1': 4, 'last_eos_p': 0.9999986886978149, 'last_eos_top1': 4}
+step=15700 loss=4.9188 {'pos0_bos_p': 0.9999954700469971, 'pos0_bos_top1': 4, 'last_eos_p': 0.9999980926513672, 'last_eos_top1': 4}
+step=15800 loss=3.7380 {'pos0_bos_p': 0.9999970197677612, 'pos0_bos_top1': 4, 'last_eos_p': 0.9999986886978149, 'last_eos_top1': 4}
+step=15900 loss=3.2097 {'pos0_bos_p': 0.999996542930603, 'pos0_bos_top1': 4, 'last_eos_p': 0.9999984502792358, 'last_eos_top1': 4}
+step=16000 loss=1.9593 {'pos0_bos_p': 0.9999974966049194, 'pos0_bos_top1': 4, 'last_eos_p': 0.9999988079071045, 'last_eos_top1': 4}
+step=16100 loss=3.5015 {'pos0_bos_p': 0.9999978542327881, 'pos0_bos_top1': 4, 'last_eos_p': 0.9999990463256836, 'last_eos_top1': 4}
+step=16200 loss=3.9477 {'pos0_bos_p': 0.9999983310699463, 'pos0_bos_top1': 4, 'last_eos_p': 0.9999991655349731, 'last_eos_top1': 4}
+step=16300 loss=4.8705 {'pos0_bos_p': 0.9999983310699463, 'pos0_bos_top1': 4, 'last_eos_p': 0.9999991655349731, 'last_eos_top1': 4}
+step=16400 loss=2.9789 {'pos0_bos_p': 0.9999983310699463, 'pos0_bos_top1': 4, 'last_eos_p': 0.9999991655349731, 'last_eos_top1': 4}
+step=16500 loss=3.7352 {'pos0_bos_p': 0.9999978542327881, 'pos0_bos_top1': 4, 'last_eos_p': 0.9999990463256836, 'last_eos_top1': 4}
+step=16600 loss=2.6939 {'pos0_bos_p': 0.9999974966049194, 'pos0_bos_top1': 4, 'last_eos_p': 0.9999988079071045, 'last_eos_top1': 4}
+step=16700 loss=4.8267 {'pos0_bos_p': 0.9999979734420776, 'pos0_bos_top1': 4, 'last_eos_p': 0.9999990463256836, 'last_eos_top1': 4}
+step=16800 loss=4.1134 {'pos0_bos_p': 0.9999974966049194, 'pos0_bos_top1': 4, 'last_eos_p': 0.999998927116394, 'last_eos_top1': 4}
+step=16900 loss=2.8157 {'pos0_bos_p': 0.9999982118606567, 'pos0_bos_top1': 4, 'last_eos_p': 0.9999990463256836, 'last_eos_top1': 4}
+step=17000 loss=4.6236 {'pos0_bos_p': 0.999997615814209, 'pos0_bos_top1': 4, 'last_eos_p': 0.9999990463256836, 'last_eos_top1': 4}
+step=17100 loss=3.6429 {'pos0_bos_p': 0.9999984502792358, 'pos0_bos_top1': 4, 'last_eos_p': 0.9999990463256836, 'last_eos_top1': 4}
+step=17200 loss=4.5208 {'pos0_bos_p': 0.9999985694885254, 'pos0_bos_top1': 4, 'last_eos_p': 0.9999994039535522, 'last_eos_top1': 4}
+step=17300 loss=3.1830 {'pos0_bos_p': 0.9999985694885254, 'pos0_bos_top1': 4, 'last_eos_p': 0.9999994039535522, 'last_eos_top1': 4}
+step=17400 loss=4.9940 {'pos0_bos_p': 0.9999984502792358, 'pos0_bos_top1': 4, 'last_eos_p': 0.9999992847442627, 'last_eos_top1': 4}
+step=17500 loss=3.6772 {'pos0_bos_p': 0.9999985694885254, 'pos0_bos_top1': 4, 'last_eos_p': 0.9999994039535522, 'last_eos_top1': 4}
+step=17600 loss=3.7944 {'pos0_bos_p': 0.9999985694885254, 'pos0_bos_top1': 4, 'last_eos_p': 0.9999995231628418, 'last_eos_top1': 4}
+step=17700 loss=4.0918 {'pos0_bos_p': 0.9999988079071045, 'pos0_bos_top1': 4, 'last_eos_p': 0.9999995231628418, 'last_eos_top1': 4}
+step=17800 loss=3.2173 {'pos0_bos_p': 0.9999985694885254, 'pos0_bos_top1': 4, 'last_eos_p': 0.9999991655349731, 'last_eos_top1': 4}
+step=17900 loss=4.0957 {'pos0_bos_p': 0.9999991655349731, 'pos0_bos_top1': 4, 'last_eos_p': 0.9999996423721313, 'last_eos_top1': 4}
+step=18000 loss=4.4046 {'pos0_bos_p': 0.9999990463256836, 'pos0_bos_top1': 4, 'last_eos_p': 0.9999996423721313, 'last_eos_top1': 4}
+step=18100 loss=2.9804 {'pos0_bos_p': 0.999998927116394, 'pos0_bos_top1': 4, 'last_eos_p': 0.9999995231628418, 'last_eos_top1': 4}
+step=18200 loss=3.6672 {'pos0_bos_p': 0.9999990463256836, 'pos0_bos_top1': 4, 'last_eos_p': 0.9999996423721313, 'last_eos_top1': 4}
+step=18300 loss=3.3652 {'pos0_bos_p': 0.9999990463256836, 'pos0_bos_top1': 4, 'last_eos_p': 0.9999995231628418, 'last_eos_top1': 4}
+step=18400 loss=3.5859 {'pos0_bos_p': 0.9999990463256836, 'pos0_bos_top1': 4, 'last_eos_p': 0.9999995231628418, 'last_eos_top1': 4}
+step=18500 loss=2.2786 {'pos0_bos_p': 0.9999991655349731, 'pos0_bos_top1': 4, 'last_eos_p': 0.9999996423721313, 'last_eos_top1': 4}
+step=18600 loss=4.7997 {'pos0_bos_p': 0.9999994039535522, 'pos0_bos_top1': 4, 'last_eos_p': 0.9999997615814209, 'last_eos_top1': 4}
+step=18700 loss=4.2439 {'pos0_bos_p': 0.9999992847442627, 'pos0_bos_top1': 4, 'last_eos_p': 0.9999996423721313, 'last_eos_top1': 4}
+step=18800 loss=3.2865 {'pos0_bos_p': 0.9999994039535522, 'pos0_bos_top1': 4, 'last_eos_p': 0.9999997615814209, 'last_eos_top1': 4}
+step=18900 loss=1.8950 {'pos0_bos_p': 0.9999992847442627, 'pos0_bos_top1': 4, 'last_eos_p': 0.9999996423721313, 'last_eos_top1': 4}
+step=19000 loss=4.7360 {'pos0_bos_p': 0.9999995231628418, 'pos0_bos_top1': 4, 'last_eos_p': 0.9999997615814209, 'last_eos_top1': 4}
+step=19100 loss=3.6240 {'pos0_bos_p': 0.9999995231628418, 'pos0_bos_top1': 4, 'last_eos_p': 0.9999997615814209, 'last_eos_top1': 4}
+step=19200 loss=3.2649 {'pos0_bos_p': 0.9999995231628418, 'pos0_bos_top1': 4, 'last_eos_p': 0.9999998807907104, 'last_eos_top1': 4}
+step=19300 loss=3.2856 {'pos0_bos_p': 0.9999994039535522, 'pos0_bos_top1': 4, 'last_eos_p': 0.9999997615814209, 'last_eos_top1': 4}
+step=19400 loss=5.0505 {'pos0_bos_p': 0.9999995231628418, 'pos0_bos_top1': 4, 'last_eos_p': 0.9999998807907104, 'last_eos_top1': 4}
+step=19500 loss=2.7518 {'pos0_bos_p': 0.9999995231628418, 'pos0_bos_top1': 4, 'last_eos_p': 0.9999997615814209, 'last_eos_top1': 4}
+step=19600 loss=2.5953 {'pos0_bos_p': 0.9999995231628418, 'pos0_bos_top1': 4, 'last_eos_p': 0.9999998807907104, 'last_eos_top1': 4}
+step=19700 loss=3.8035 {'pos0_bos_p': 0.9999994039535522, 'pos0_bos_top1': 4, 'last_eos_p': 0.9999997615814209, 'last_eos_top1': 4}
+step=19800 loss=3.9915 {'pos0_bos_p': 0.9999995231628418, 'pos0_bos_top1': 4, 'last_eos_p': 0.9999997615814209, 'last_eos_top1': 4}
+step=19900 loss=2.7122 {'pos0_bos_p': 0.9999995231628418, 'pos0_bos_top1': 4, 'last_eos_p': 0.9999997615814209, 'last_eos_top1': 4}
+step=20000 loss=3.9600 {'pos0_bos_p': 0.9999995231628418, 'pos0_bos_top1': 4, 'last_eos_p': 0.9999998807907104, 'last_eos_top1': 4}
+step=20100 loss=4.2352 {'pos0_bos_p': 0.9999995231628418, 'pos0_bos_top1': 4, 'last_eos_p': 0.9999997615814209, 'last_eos_top1': 4}
+step=20200 loss=4.5069 {'pos0_bos_p': 0.9999995231628418, 'pos0_bos_top1': 4, 'last_eos_p': 0.9999998807907104, 'last_eos_top1': 4}
+step=20300 loss=4.1250 {'pos0_bos_p': 0.9999995231628418, 'pos0_bos_top1': 4, 'last_eos_p': 0.9999998807907104, 'last_eos_top1': 4}
+step=20400 loss=4.6128 {'pos0_bos_p': 0.9999997615814209, 'pos0_bos_top1': 4, 'last_eos_p': 0.9999998807907104, 'last_eos_top1': 4}
+step=20500 loss=3.9495 {'pos0_bos_p': 0.9999997615814209, 'pos0_bos_top1': 4, 'last_eos_p': 0.9999998807907104, 'last_eos_top1': 4}
+step=20600 loss=3.8951 {'pos0_bos_p': 0.9999997615814209, 'pos0_bos_top1': 4, 'last_eos_p': 0.9999998807907104, 'last_eos_top1': 4}
+step=20700 loss=3.7932 {'pos0_bos_p': 0.9999996423721313, 'pos0_bos_top1': 4, 'last_eos_p': 0.9999998807907104, 'last_eos_top1': 4}
+step=20800 loss=4.3201 {'pos0_bos_p': 0.9999997615814209, 'pos0_bos_top1': 4, 'last_eos_p': 0.9999998807907104, 'last_eos_top1': 4}
+step=20900 loss=3.1443 {'pos0_bos_p': 0.9999997615814209, 'pos0_bos_top1': 4, 'last_eos_p': 0.9999998807907104, 'last_eos_top1': 4}
+step=21000 loss=3.8003 {'pos0_bos_p': 0.9999995231628418, 'pos0_bos_top1': 4, 'last_eos_p': 0.9999998807907104, 'last_eos_top1': 4}
+step=21100 loss=4.8338 {'pos0_bos_p': 0.9999997615814209, 'pos0_bos_top1': 4, 'last_eos_p': 0.9999998807907104, 'last_eos_top1': 4}
+step=21200 loss=3.0632 {'pos0_bos_p': 0.9999998807907104, 'pos0_bos_top1': 4, 'last_eos_p': 0.9999998807907104, 'last_eos_top1': 4}
+step=21300 loss=3.6978 {'pos0_bos_p': 0.9999998807907104, 'pos0_bos_top1': 4, 'last_eos_p': 0.9999998807907104, 'last_eos_top1': 4}
+step=21400 loss=3.0338 {'pos0_bos_p': 0.9999997615814209, 'pos0_bos_top1': 4, 'last_eos_p': 0.9999998807907104, 'last_eos_top1': 4}
+step=21500 loss=3.1772 {'pos0_bos_p': 0.9999997615814209, 'pos0_bos_top1': 4, 'last_eos_p': 0.9999998807907104, 'last_eos_top1': 4}
+step=21600 loss=4.2128 {'pos0_bos_p': 0.9999997615814209, 'pos0_bos_top1': 4, 'last_eos_p': 0.9999998807907104, 'last_eos_top1': 4}
+step=21700 loss=3.5384 {'pos0_bos_p': 0.9999998807907104, 'pos0_bos_top1': 4, 'last_eos_p': 0.9999998807907104, 'last_eos_top1': 4}
+step=21800 loss=3.7746 {'pos0_bos_p': 0.9999998807907104, 'pos0_bos_top1': 4, 'last_eos_p': 0.9999998807907104, 'last_eos_top1': 4}
+step=21900 loss=3.0834 {'pos0_bos_p': 0.9999998807907104, 'pos0_bos_top1': 4, 'last_eos_p': 0.9999998807907104, 'last_eos_top1': 4}
+step=22000 loss=2.2712 {'pos0_bos_p': 0.9999997615814209, 'pos0_bos_top1': 4, 'last_eos_p': 0.9999998807907104, 'last_eos_top1': 4}
+step=22100 loss=4.6802 {'pos0_bos_p': 0.9999997615814209, 'pos0_bos_top1': 4, 'last_eos_p': 0.9999998807907104, 'last_eos_top1': 4}
+step=22200 loss=3.7010 {'pos0_bos_p': 0.9999998807907104, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=22300 loss=5.3411 {'pos0_bos_p': 0.9999998807907104, 'pos0_bos_top1': 4, 'last_eos_p': 0.9999998807907104, 'last_eos_top1': 4}
+step=22400 loss=3.5518 {'pos0_bos_p': 0.9999998807907104, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=22500 loss=2.9982 {'pos0_bos_p': 0.9999998807907104, 'pos0_bos_top1': 4, 'last_eos_p': 0.9999998807907104, 'last_eos_top1': 4}
+step=22600 loss=2.4500 {'pos0_bos_p': 0.9999998807907104, 'pos0_bos_top1': 4, 'last_eos_p': 0.9999998807907104, 'last_eos_top1': 4}
+step=22700 loss=5.2073 {'pos0_bos_p': 0.9999998807907104, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=22800 loss=2.8913 {'pos0_bos_p': 0.9999998807907104, 'pos0_bos_top1': 4, 'last_eos_p': 0.9999998807907104, 'last_eos_top1': 4}
+step=22900 loss=3.3146 {'pos0_bos_p': 0.9999998807907104, 'pos0_bos_top1': 4, 'last_eos_p': 0.9999998807907104, 'last_eos_top1': 4}
+step=23000 loss=2.5090 {'pos0_bos_p': 0.9999998807907104, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=23100 loss=2.8887 {'pos0_bos_p': 0.9999998807907104, 'pos0_bos_top1': 4, 'last_eos_p': 0.9999998807907104, 'last_eos_top1': 4}
+step=23200 loss=3.2819 {'pos0_bos_p': 0.9999998807907104, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=23300 loss=2.7361 {'pos0_bos_p': 0.9999998807907104, 'pos0_bos_top1': 4, 'last_eos_p': 0.9999998807907104, 'last_eos_top1': 4}
+step=23400 loss=2.9181 {'pos0_bos_p': 0.9999998807907104, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=23500 loss=3.8536 {'pos0_bos_p': 0.9999998807907104, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=23600 loss=2.5306 {'pos0_bos_p': 0.9999998807907104, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=23700 loss=3.2676 {'pos0_bos_p': 0.9999998807907104, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=23800 loss=5.7259 {'pos0_bos_p': 0.9999998807907104, 'pos0_bos_top1': 4, 'last_eos_p': 0.9999998807907104, 'last_eos_top1': 4}
+step=23900 loss=3.2549 {'pos0_bos_p': 1.0, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=24000 loss=3.6277 {'pos0_bos_p': 0.9999998807907104, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=24100 loss=4.6905 {'pos0_bos_p': 0.9999998807907104, 'pos0_bos_top1': 4, 'last_eos_p': 0.9999998807907104, 'last_eos_top1': 4}
+step=24200 loss=3.6648 {'pos0_bos_p': 0.9999998807907104, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=24300 loss=3.8566 {'pos0_bos_p': 0.9999998807907104, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=24400 loss=1.6065 {'pos0_bos_p': 0.9999998807907104, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=24500 loss=5.0927 {'pos0_bos_p': 0.9999998807907104, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=24600 loss=3.0332 {'pos0_bos_p': 0.9999998807907104, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=24700 loss=3.7795 {'pos0_bos_p': 1.0, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=24800 loss=3.5548 {'pos0_bos_p': 1.0, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=24900 loss=4.0945 {'pos0_bos_p': 0.9999998807907104, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=25000 loss=2.8422 {'pos0_bos_p': 0.9999998807907104, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=25100 loss=3.7774 {'pos0_bos_p': 1.0, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=25200 loss=4.0649 {'pos0_bos_p': 0.9999998807907104, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=25300 loss=3.4325 {'pos0_bos_p': 0.9999998807907104, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=25400 loss=3.8478 {'pos0_bos_p': 0.9999998807907104, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=25500 loss=3.3991 {'pos0_bos_p': 0.9999998807907104, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=25600 loss=4.8604 {'pos0_bos_p': 0.9999998807907104, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=25700 loss=3.8625 {'pos0_bos_p': 0.9999998807907104, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=25800 loss=3.8016 {'pos0_bos_p': 1.0, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=25900 loss=4.0737 {'pos0_bos_p': 0.9999998807907104, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=26000 loss=3.2858 {'pos0_bos_p': 0.9999998807907104, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=26100 loss=3.6148 {'pos0_bos_p': 0.9999998807907104, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=26200 loss=2.8513 {'pos0_bos_p': 1.0, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=26300 loss=4.9424 {'pos0_bos_p': 1.0, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=26400 loss=3.0131 {'pos0_bos_p': 1.0, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=26500 loss=3.8076 {'pos0_bos_p': 1.0, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=26600 loss=2.7533 {'pos0_bos_p': 0.9999998807907104, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=26700 loss=3.6372 {'pos0_bos_p': 0.9999998807907104, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=26800 loss=3.0565 {'pos0_bos_p': 0.9999998807907104, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=26900 loss=3.8349 {'pos0_bos_p': 1.0, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=27000 loss=3.7991 {'pos0_bos_p': 1.0, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=27100 loss=5.2449 {'pos0_bos_p': 1.0, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=27200 loss=3.9875 {'pos0_bos_p': 1.0, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=27300 loss=3.6670 {'pos0_bos_p': 1.0, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=27400 loss=3.2276 {'pos0_bos_p': 1.0, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=27500 loss=4.0619 {'pos0_bos_p': 1.0, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=27600 loss=3.6381 {'pos0_bos_p': 1.0, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=27700 loss=4.5759 {'pos0_bos_p': 1.0, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=27800 loss=4.0042 {'pos0_bos_p': 1.0, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=27900 loss=4.4435 {'pos0_bos_p': 1.0, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=28000 loss=3.4984 {'pos0_bos_p': 1.0, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=28100 loss=4.9265 {'pos0_bos_p': 1.0, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=28200 loss=3.2198 {'pos0_bos_p': 1.0, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=28300 loss=3.2884 {'pos0_bos_p': 1.0, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=28400 loss=4.2905 {'pos0_bos_p': 1.0, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=28500 loss=3.4917 {'pos0_bos_p': 1.0, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=28600 loss=2.5980 {'pos0_bos_p': 1.0, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=28700 loss=3.4720 {'pos0_bos_p': 1.0, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=28800 loss=3.8127 {'pos0_bos_p': 1.0, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=28900 loss=2.7859 {'pos0_bos_p': 1.0, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=29000 loss=3.4502 {'pos0_bos_p': 1.0, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=29100 loss=2.6192 {'pos0_bos_p': 1.0, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=29200 loss=4.2777 {'pos0_bos_p': 1.0, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=29300 loss=3.7046 {'pos0_bos_p': 1.0, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=29400 loss=3.5094 {'pos0_bos_p': 1.0, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=29500 loss=3.4194 {'pos0_bos_p': 1.0, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=29600 loss=2.7286 {'pos0_bos_p': 1.0, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=29700 loss=4.2490 {'pos0_bos_p': 1.0, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=29800 loss=2.8553 {'pos0_bos_p': 1.0, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=29900 loss=4.7261 {'pos0_bos_p': 1.0, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=30000 loss=4.9260 {'pos0_bos_p': 1.0, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=30100 loss=4.4800 {'pos0_bos_p': 1.0, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=30200 loss=4.8204 {'pos0_bos_p': 1.0, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=30300 loss=2.4167 {'pos0_bos_p': 1.0, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=30400 loss=3.9363 {'pos0_bos_p': 1.0, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=30500 loss=4.8588 {'pos0_bos_p': 1.0, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=30600 loss=3.8416 {'pos0_bos_p': 1.0, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=30700 loss=4.4112 {'pos0_bos_p': 1.0, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=30800 loss=5.0078 {'pos0_bos_p': 1.0, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=30900 loss=3.1361 {'pos0_bos_p': 1.0, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=31000 loss=3.5256 {'pos0_bos_p': 1.0, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=31100 loss=3.3403 {'pos0_bos_p': 1.0, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=31200 loss=2.8258 {'pos0_bos_p': 1.0, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=31300 loss=3.8257 {'pos0_bos_p': 1.0, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=31400 loss=3.0869 {'pos0_bos_p': 1.0, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=31500 loss=3.5630 {'pos0_bos_p': 1.0, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=31600 loss=3.4906 {'pos0_bos_p': 1.0, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=31700 loss=3.2383 {'pos0_bos_p': 1.0, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=31800 loss=2.6435 {'pos0_bos_p': 1.0, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=31900 loss=2.1873 {'pos0_bos_p': 1.0, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=32000 loss=3.5377 {'pos0_bos_p': 1.0, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=32100 loss=3.9001 {'pos0_bos_p': 1.0, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=32200 loss=4.8171 {'pos0_bos_p': 1.0, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=32300 loss=2.9041 {'pos0_bos_p': 1.0, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=32400 loss=3.3583 {'pos0_bos_p': 1.0, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=32500 loss=5.0818 {'pos0_bos_p': 1.0, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=32600 loss=3.9250 {'pos0_bos_p': 1.0, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=32700 loss=3.8959 {'pos0_bos_p': 1.0, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=32800 loss=2.7571 {'pos0_bos_p': 1.0, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=32900 loss=4.3879 {'pos0_bos_p': 1.0, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=33000 loss=3.1456 {'pos0_bos_p': 1.0, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=33100 loss=3.0963 {'pos0_bos_p': 1.0, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=33200 loss=1.3667 {'pos0_bos_p': 1.0, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=33300 loss=3.5215 {'pos0_bos_p': 1.0, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=33400 loss=4.7629 {'pos0_bos_p': 1.0, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=33500 loss=2.6271 {'pos0_bos_p': 1.0, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=33600 loss=5.5837 {'pos0_bos_p': 1.0, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=33700 loss=3.5993 {'pos0_bos_p': 1.0, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=33800 loss=2.7794 {'pos0_bos_p': 1.0, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=33900 loss=4.8024 {'pos0_bos_p': 1.0, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=34000 loss=3.1191 {'pos0_bos_p': 1.0, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=34100 loss=2.6783 {'pos0_bos_p': 1.0, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=34200 loss=3.3623 {'pos0_bos_p': 1.0, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=34300 loss=3.6658 {'pos0_bos_p': 1.0, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=34400 loss=2.9384 {'pos0_bos_p': 1.0, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=34500 loss=3.4232 {'pos0_bos_p': 1.0, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=34600 loss=4.5297 {'pos0_bos_p': 1.0, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=34700 loss=3.3632 {'pos0_bos_p': 1.0, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=34800 loss=3.7718 {'pos0_bos_p': 1.0, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=34900 loss=3.9872 {'pos0_bos_p': 1.0, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=35000 loss=3.1732 {'pos0_bos_p': 1.0, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=35100 loss=4.0472 {'pos0_bos_p': 1.0, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=35200 loss=3.4436 {'pos0_bos_p': 1.0, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=35300 loss=2.3598 {'pos0_bos_p': 1.0, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=35400 loss=3.1265 {'pos0_bos_p': 1.0, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=35500 loss=2.6121 {'pos0_bos_p': 1.0, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=35600 loss=3.8555 {'pos0_bos_p': 1.0, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=35700 loss=2.8491 {'pos0_bos_p': 1.0, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=35800 loss=3.9213 {'pos0_bos_p': 1.0, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=35900 loss=3.4718 {'pos0_bos_p': 0.9999998807907104, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=36000 loss=2.8358 {'pos0_bos_p': 1.0, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=36100 loss=4.6380 {'pos0_bos_p': 1.0, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=36200 loss=2.6441 {'pos0_bos_p': 1.0, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=36300 loss=1.8894 {'pos0_bos_p': 1.0, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=36400 loss=3.9225 {'pos0_bos_p': 1.0, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=36500 loss=4.5444 {'pos0_bos_p': 1.0, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=36600 loss=4.9017 {'pos0_bos_p': 1.0, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=36700 loss=4.6413 {'pos0_bos_p': 1.0, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=36800 loss=3.9479 {'pos0_bos_p': 1.0, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=36900 loss=2.8298 {'pos0_bos_p': 1.0, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=37000 loss=3.2175 {'pos0_bos_p': 1.0, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=37100 loss=2.5712 {'pos0_bos_p': 1.0, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=37200 loss=4.5805 {'pos0_bos_p': 1.0, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=37300 loss=4.0394 {'pos0_bos_p': 1.0, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=37400 loss=3.7896 {'pos0_bos_p': 1.0, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=37500 loss=3.2821 {'pos0_bos_p': 1.0, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=37600 loss=4.8827 {'pos0_bos_p': 1.0, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=37700 loss=2.0136 {'pos0_bos_p': 1.0, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=37800 loss=3.6534 {'pos0_bos_p': 1.0, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=37900 loss=4.7675 {'pos0_bos_p': 1.0, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=38000 loss=3.3963 {'pos0_bos_p': 1.0, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=38100 loss=3.3622 {'pos0_bos_p': 1.0, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=38200 loss=3.2168 {'pos0_bos_p': 1.0, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=38300 loss=3.8776 {'pos0_bos_p': 1.0, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=38400 loss=3.2291 {'pos0_bos_p': 1.0, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=38500 loss=3.8847 {'pos0_bos_p': 1.0, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=38600 loss=3.2540 {'pos0_bos_p': 1.0, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=38700 loss=3.5459 {'pos0_bos_p': 1.0, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=38800 loss=4.2170 {'pos0_bos_p': 1.0, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=38900 loss=5.0072 {'pos0_bos_p': 1.0, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=39000 loss=3.3840 {'pos0_bos_p': 1.0, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=39100 loss=3.5639 {'pos0_bos_p': 1.0, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=39200 loss=3.8849 {'pos0_bos_p': 1.0, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=39300 loss=1.9756 {'pos0_bos_p': 1.0, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=39400 loss=3.5273 {'pos0_bos_p': 1.0, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=39500 loss=3.2726 {'pos0_bos_p': 1.0, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=39600 loss=3.5488 {'pos0_bos_p': 1.0, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=39700 loss=3.9291 {'pos0_bos_p': 1.0, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=39800 loss=3.7669 {'pos0_bos_p': 1.0, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=39900 loss=3.1963 {'pos0_bos_p': 1.0, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}
+step=40000 loss=5.6825 {'pos0_bos_p': 1.0, 'pos0_bos_top1': 4, 'last_eos_p': 1.0, 'last_eos_top1': 4}

LTA_openwebtext_dualt/mini_owt_logdirichlet/logs/qwen35_owt_worst20_20260528_013940.log

@@ -0,0 +1,24 @@
+[qwen local clean] loading model=/e2e-data/embodied-research-data/large_model/huggingface/hub/models--Qwen--Qwen3.5-4B/snapshots/851bf6e806efd8d0a36b00ddf55e13ccb7b8cd0a dtype=bfloat16
+[transformers] The fast path is not available because one of the required library is not installed. Falling back to torch implementation. To install follow https://github.com/fla-org/flash-linear-attention#installation and https://github.com/Dao-AILab/causal-conv1d
+
+[qwen local clean] completed=1 kept=1 rejected=0 decision=keep reason=Interview transcript with minor formatting artifacts removed.
+[qwen local clean] completed=2 kept=2 rejected=0 decision=keep reason=Standard interview transcript with minor formatting noise and repeated punctuation.
+[qwen local clean] completed=3 kept=2 rejected=1 decision=reject reason=llm_reject
+[qwen local clean] completed=4 kept=2 rejected=2 decision=reject reason=llm_reject
+[qwen local clean] completed=5 kept=2 rejected=3 decision=reject reason=llm_reject
+[qwen local clean] completed=6 kept=2 rejected=4 decision=reject reason=llm_reject
+[qwen local clean] completed=7 kept=3 rejected=4 decision=keep reason=Coherent political commentary excerpt with minor formatting artifacts to remove.
+[qwen local clean] completed=8 kept=4 rejected=4 decision=keep reason=Coherent political commentary with minor formatting artifacts (line breaks, spacing) that can be normalized.
+[qwen local clean] completed=9 kept=4 rejected=5 decision=reject reason=llm_reject
+[qwen local clean] completed=10 kept=4 rejected=6 decision=reject reason=llm_reject
+[qwen local clean] completed=11 kept=5 rejected=6 decision=keep reason=Coherent political commentary with no extraction artifacts; only minor whitespace normalization needed.
+[qwen local clean] completed=12 kept=5 rejected=7 decision=reject reason=llm_reject
+[qwen local clean] completed=13 kept=5 rejected=8 decision=reject reason=llm_reject
+[qwen local clean] completed=14 kept=6 rejected=8 decision=keep reason=Coherent sports analysis text with minor formatting artifacts to remove.
+[qwen local clean] completed=15 kept=6 rejected=9 decision=reject reason=llm_reject
+[qwen local clean] completed=16 kept=7 rejected=9 decision=keep reason=Coherent news article with minor punctuation and spacing artifacts to fix.
+[qwen local clean] completed=17 kept=8 rejected=9 decision=keep reason=Coherent news article excerpt with minor punctuation normalization needed.
+[qwen local clean] completed=18 kept=9 rejected=9 decision=keep reason=Coherent news excerpt with minor artifact to remove.
+[qwen local clean] completed=19 kept=10 rejected=9 decision=keep reason=Coherent political commentary with minor extraction artifacts (HTML entities, broken words, repeated punctuation) that c
+[qwen local clean] completed=20 kept=11 rejected=9 decision=keep reason=Coherent political commentary with minor punctuation normalization needed.
+[qwen local clean] summary={"data_path": "/e2e-data/evad-tech-vla/wanghan58/data/small_benchmarks/langflow_2604_11748/openwebtext", "input_jsonl": "cache/qwen35_worst20_input.jsonl", "model_path": "/e2e-data/embodied-research-data/large_model/huggingface/hub/models--Qwen--Qwen3.5-4B/snapshots/851bf6e806efd8d0a36b00ddf55e13ccb7b8cd0a", "completed_chunks": 20, "kept_chunks": 11, "rejected_chunks": 9, "accepted_jsonl": "cache/qwen35_owt_worst20/accepted.jsonl", "rejected_jsonl": "cache/qwen35_owt_worst20/rejected.jsonl", "audit_jsonl": "cache/qwen35_owt_worst20/audit.jsonl", "max_edit_ratio": 0.5}

LTA_openwebtext_dualt/mini_owt_logdirichlet/runs/owt_t5_elftokenized_full_len1024_C1_to_1024_pow1_d768_l12_h12_gbs512_8gpu_50ep_lr3e4_elfopt_t5embed_unfixed_stateprobadd_selfcond_ce_fast_20260531_230026/step_226000.pt

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