diff --git a/Reward_sana_idealized/open_clip/__pycache__/__init__.cpython-311.pyc b/Reward_sana_idealized/open_clip/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c9c7130e0c8376e86b47409a1e7a43cfcb899081 Binary files /dev/null and b/Reward_sana_idealized/open_clip/__pycache__/__init__.cpython-311.pyc differ diff --git a/Reward_sana_idealized/open_clip/__pycache__/constants.cpython-311.pyc b/Reward_sana_idealized/open_clip/__pycache__/constants.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..4f4226f4f2234e974c9acf453dc8cf4876ea39da Binary files /dev/null and b/Reward_sana_idealized/open_clip/__pycache__/constants.cpython-311.pyc differ diff --git a/Reward_sana_idealized/open_clip/__pycache__/hf_configs.cpython-311.pyc b/Reward_sana_idealized/open_clip/__pycache__/hf_configs.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..4cecb5eedefe565b476e6e294f001ebe4e442df0 Binary files /dev/null and b/Reward_sana_idealized/open_clip/__pycache__/hf_configs.cpython-311.pyc differ diff --git a/Reward_sana_idealized/open_clip/__pycache__/hf_model.cpython-311.pyc b/Reward_sana_idealized/open_clip/__pycache__/hf_model.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ce90575950b7b7b72ce0ddfbe32469ec038a70f1 Binary files /dev/null and b/Reward_sana_idealized/open_clip/__pycache__/hf_model.cpython-311.pyc differ diff --git a/Reward_sana_idealized/open_clip/__pycache__/loss.cpython-311.pyc b/Reward_sana_idealized/open_clip/__pycache__/loss.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..51d4d49c1db1214089f6f7dea1a6b1ddbcd4cf03 Binary files /dev/null and b/Reward_sana_idealized/open_clip/__pycache__/loss.cpython-311.pyc differ diff --git a/Reward_sana_idealized/open_clip/__pycache__/openai.cpython-311.pyc b/Reward_sana_idealized/open_clip/__pycache__/openai.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..346d312172724e494f0e24eab5c9750da3d4c021 Binary files /dev/null and b/Reward_sana_idealized/open_clip/__pycache__/openai.cpython-311.pyc differ diff --git a/Reward_sana_idealized/open_clip/__pycache__/transform.cpython-311.pyc b/Reward_sana_idealized/open_clip/__pycache__/transform.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..859f3b81e97cdbab0cfee55dfe2151f42f352ced Binary files /dev/null and b/Reward_sana_idealized/open_clip/__pycache__/transform.cpython-311.pyc differ diff --git a/Reward_sana_idealized/open_clip/__pycache__/utils.cpython-311.pyc b/Reward_sana_idealized/open_clip/__pycache__/utils.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ae52941cb9342fd66e461275407ba2979b795011 Binary files /dev/null and b/Reward_sana_idealized/open_clip/__pycache__/utils.cpython-311.pyc differ diff --git a/Reward_sana_idealized/open_clip/__pycache__/version.cpython-311.pyc b/Reward_sana_idealized/open_clip/__pycache__/version.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0bb3227d56cb97177595dd66807eedbc6b4c5972 Binary files /dev/null and b/Reward_sana_idealized/open_clip/__pycache__/version.cpython-311.pyc differ diff --git a/Reward_sana_idealized/open_clip/model_configs/RN50.json b/Reward_sana_idealized/open_clip/model_configs/RN50.json new file mode 100644 index 0000000000000000000000000000000000000000..33aa884d54fee0076c33676831e49d5e1ffcb8f2 --- /dev/null +++ b/Reward_sana_idealized/open_clip/model_configs/RN50.json @@ -0,0 +1,21 @@ +{ + "embed_dim": 1024, + "vision_cfg": { + "image_size": 224, + "layers": [ + 3, + 4, + 6, + 3 + ], + "width": 64, + "patch_size": null + }, + "text_cfg": { + "context_length": 77, + "vocab_size": 49408, + "width": 512, + "heads": 8, + "layers": 12 + } +} \ No newline at end of file diff --git a/Reward_sana_idealized/open_clip/model_configs/RN50x64.json b/Reward_sana_idealized/open_clip/model_configs/RN50x64.json new file mode 100644 index 0000000000000000000000000000000000000000..f5aaa2ee3de21ddb03cbd12766a3419bf34898c7 --- /dev/null +++ b/Reward_sana_idealized/open_clip/model_configs/RN50x64.json @@ -0,0 +1,21 @@ +{ + "embed_dim": 1024, + "vision_cfg": { + "image_size": 448, + "layers": [ + 3, + 15, + 36, + 10 + ], + "width": 128, + "patch_size": null + }, + "text_cfg": { + "context_length": 77, + "vocab_size": 49408, + "width": 1024, + "heads": 16, + "layers": 12 + } +} \ No newline at end of file diff --git a/Reward_sana_idealized/open_clip/model_configs/ViT-B-32-plus-256.json b/Reward_sana_idealized/open_clip/model_configs/ViT-B-32-plus-256.json new file mode 100644 index 0000000000000000000000000000000000000000..2f09c857de9a4c01ae51297a7e2451984879f9de --- /dev/null +++ b/Reward_sana_idealized/open_clip/model_configs/ViT-B-32-plus-256.json @@ -0,0 +1,16 @@ +{ + "embed_dim": 640, + "vision_cfg": { + "image_size": 256, + "layers": 12, + "width": 896, + "patch_size": 32 + }, + "text_cfg": { + "context_length": 77, + "vocab_size": 49408, + "width": 640, + "heads": 10, + "layers": 12 + } +} \ No newline at end of file diff --git a/Reward_sana_idealized/open_clip/model_configs/ViT-B-32-quickgelu.json b/Reward_sana_idealized/open_clip/model_configs/ViT-B-32-quickgelu.json new file mode 100644 index 0000000000000000000000000000000000000000..ce6bd923593293ed50dfcfb28b73ca7403bcf3c5 --- /dev/null +++ b/Reward_sana_idealized/open_clip/model_configs/ViT-B-32-quickgelu.json @@ -0,0 +1,17 @@ +{ + "embed_dim": 512, + "quick_gelu": true, + "vision_cfg": { + "image_size": 224, + "layers": 12, + "width": 768, + "patch_size": 32 + }, + "text_cfg": { + "context_length": 77, + "vocab_size": 49408, + "width": 512, + "heads": 8, + "layers": 12 + } +} \ No newline at end of file diff --git a/Reward_sana_idealized/open_clip/model_configs/xlm-roberta-base-ViT-B-32.json b/Reward_sana_idealized/open_clip/model_configs/xlm-roberta-base-ViT-B-32.json new file mode 100644 index 0000000000000000000000000000000000000000..751bccc2c6fc41bc4ff20182de88d86739d518d9 --- /dev/null +++ b/Reward_sana_idealized/open_clip/model_configs/xlm-roberta-base-ViT-B-32.json @@ -0,0 +1,15 @@ +{ + "embed_dim": 512, + "vision_cfg": { + "image_size": 224, + "layers": 12, + "width": 768, + "patch_size": 32 + }, + "text_cfg": { + "hf_model_name": "xlm-roberta-base", + "hf_tokenizer_name": "xlm-roberta-base", + "proj": "mlp", + "pooler_type": "mean_pooler" + } +} diff --git a/Reward_sdxl_idealized/README.md b/Reward_sdxl_idealized/README.md new file mode 100644 index 0000000000000000000000000000000000000000..deebf11c03dd0765bb8ea23ca1d5fdbdacbc6a8b --- /dev/null +++ b/Reward_sdxl_idealized/README.md @@ -0,0 +1,1336 @@ +# Reward-Guided Gradient Ascent for Stable Diffusion + +A comprehensive system for improving Stable Diffusion image generation quality using gradient ascent optimization on Latent Reward Model (LRM) scores during inference. + +## Table of Contents + +- [Overview](#overview) +- [Features](#features) +- [Installation](#installation) +- [Quick Start](#quick-start) +- [Architecture](#architecture) +- [Understanding Reward Calculation](#understanding-reward-calculation) +- [Learning Rate Scheduling](#learning-rate-scheduling) +- [Configuration Presets](#configuration-presets) +- [Evaluation Metrics](#evaluation-metrics) +- [Model Variants](#model-variants) +- [Datasets](#datasets) +- [Usage Examples](#usage-examples) +- [API Reference](#api-reference) +- [Command-Line Options](#command-line-options) +- [Output Files](#output-files) +- [Troubleshooting](#troubleshooting) +- [Best Practices](#best-practices) +- [Changelog](#changelog) + +--- + +## Overview + +This project implements **test-time optimization** for Stable Diffusion using gradient ascent on the LRM reward model. Unlike the main LPO training which uses the reward model for training, this approach applies it during inference to improve generation quality without retraining. + +### Key Capabilities + +- **Gradient Ascent Optimization**: Iteratively improve latents using reward gradients +- **Learning Rate Scheduling**: Multiple strategies (constant, linear, cosine, exponential, step) +- **Momentum Optimization**: Standard and Nesterov momentum for better convergence +- **Multiple Metrics**: FID, CLIP, Aesthetic, PickScore, HPSv2, ImageReward +- **Model Variants**: Support for Origin, SPO, DPO, and LPO SD1.5 models +- **Dataset Flexibility**: COCO and Pick-a-Pic validation datasets +- **Configuration Presets**: 15 pre-tuned configurations for various use cases + +--- + +## Features + +### 1. **Advanced Optimization** +- **5 LR Schedulers**: Constant, Linear, Cosine, Exponential, Step-wise +- **Momentum Support**: Standard momentum and Nesterov momentum +- **Configurable Timestep Ranges**: Apply gradients at specific denoising steps +- **Dynamic Learning Rates**: LR changes during optimization for better convergence + +### 2. **Comprehensive Evaluation** +- **6 Quality Metrics**: FID, CLIP, Aesthetic, PickScore, HPSv2, ImageReward +- **Baseline Comparison**: Compare with and without gradient ascent +- **Detailed Statistics**: Track reward improvements, gradient norms, LR history +- **Batch Processing**: Efficient evaluation on large datasets +- **Reward Visualization**: Automatic plotting of reward progression across timesteps +- **Timestep-Aware Tracking**: Monitor rewards at every denoising step, final t=0 latent reported + +### 3. **Model Flexibility** +- **4 SD1.5 Variants**: Origin, SPO, DPO, LPO +- **Auto-Configuration**: CFG scale auto-adjusted for model variants +- **Easy Switching**: Change models with a single flag + +### 4. **Dataset Support** +- **COCO Validation**: Standard benchmark with reference images +- **Pick-a-Pic Validation**: Large-scale human preference dataset +- **Streaming Support**: Handle large datasets efficiently + +--- + +## Installation + +### Requirements + +```bash +# Core dependencies +pip install torch diffusers transformers torchmetrics datasets huggingface-hub + +# For evaluation metrics +pip install pillow numpy scipy tqdm + +# Optional: for better performance +pip install xformers # For memory-efficient attention +``` + +### Setup + +```bash +cd /path/to/LPO/Reward + +# Verify installation +python -c "from lr_scheduler import create_lr_scheduler; print('✓ LR Scheduler OK')" +python -c "from grad_ascent_configs import list_configs; print('✓ Configs:', len(list_configs()))" +python -c "from gradient_ascent_utils import RewardGuidedDiffusion; print('✓ Gradient Utils OK')" +``` + +--- + +## Quick Start + +### 1. Basic COCO Evaluation (test_grad_sd1.5.py) + +```bash +# Edit Config in test_grad_sd1.5.py: +# - Set device: "cuda:0" or "cuda:6" +# - Set max_samples: 10 for quick test, None for full dataset +# - Configure gradient ascent parameters + +python test_grad_sd1.5.py +``` + +**Output:** +- Creates `RESULTS/SD1.5_GradAscent/run_1/` (auto-incremented) +- Generates `eval.log` with detailed metrics +- Saves `reward_curve.png` showing reward progression + +### 2. Basic Evaluation with Preset Config (eval.py) + +```bash +python eval.py \ + --grad_config cosine_nesterov \ + --metrics clip aesthetic \ + --max_samples 10 +``` + +### 2. High-Quality Evaluation + +```bash +python eval.py \ + --grad_config high_quality \ + --metrics fid clip aesthetic pickscore hpsv2 \ + --max_samples 100 \ + --save_images \ + --output_dir results/high_quality +``` + +### 3. Pick-a-Pic Benchmark + +```bash +python eval.py \ + --dataset_type pickapic \ + --grad_config cosine_nesterov \ + --metrics pickscore hpsv2 imagereward \ + --max_samples 500 \ + --output_dir results/pickapic +``` + +--- + +## Architecture + +### System Components + +``` +Reward/ +├── models/ +│ ├── reward_model.py # LRM reward model wrapper +│ └── unet_2d_condition_reward.py # Custom UNet with reward tracking +├── pipelines/ +│ ├── sd15_reward_pipeline.py # Base pipeline with reward tracking +│ └── sd15_gradient_ascent_pipeline.py # Pipeline with gradient ascent +├── lr_scheduler.py # Learning rate schedulers +├── gradient_ascent_utils.py # Core gradient ascent implementation +├── grad_ascent_configs.py # Configuration presets +├── eval.py # Comprehensive evaluation script +└── examples.sh # Example commands +``` + +### Gradient Ascent Flow + +``` +1. Load Stable Diffusion + LRM Reward Model +2. Start denoising process (T → 0) +3. At each timestep t: + a. Standard denoising step (predict noise, remove it) + b. Compute reward R(latents, prompt, t) and store in history + c. If t in gradient range: + - Enable gradients on latents + - Compute ∇R w.r.t. latents + - For each gradient step: + * Get current LR from scheduler + * Apply momentum (if enabled) + * Update: latents += lr * momentum(∇R) + - Track statistics (grad norms, reward improvement) +4. At final timestep (t=0): + - Final reward computed on clean latent + - This reward is reported in logs +5. Decode final latent (x₀) to image via VAE +6. Compute quality metrics on image +``` + +### Understanding Reward Calculation + +**Key Concepts:** + +- **Timestep-Aware Rewards**: The LRM reward model computes preference scores at ANY noise level (timestep t) +- **Progressive Tracking**: Rewards are calculated at every denoising step throughout generation +- **Final Latent Reward**: The reported metric is the reward for t=0 (the clean latent before decoding) +- **Not Averaged**: The final reward is specifically from the last timestep, NOT an average across all timesteps + +**What gets reported:** +```python +# During generation: Rewards computed at each t (1000 → 0) +Step 0: t=1000, reward=3.2 +Step 1: t=990, reward=3.5 +... +Step 99: t=10, reward=5.1 +Step 100: t=0, reward=5.4 ← This is what gets logged! +``` + +The `Reward (t=0)` in logs represents the preference score of the final clean latent that was decoded into your output image. + +--- + +## Learning Rate Scheduling + +### Available Schedulers + +#### 1. **Constant LR** +```python +lr_scheduler_type="constant" +``` +- Fixed learning rate throughout optimization +- Simple and stable +- Good for quick experiments + +#### 2. **Linear Decay** +```python +lr_scheduler_type="linear" +lr_scheduler_kwargs={ + "end_lr": 0.01, # End LR (10% of initial) + "start_step": 0 # When to start decay +} +``` +- Linear decrease from initial to end LR +- Smooth convergence +- Configurable warmup period + +#### 3. **Cosine Annealing** (Recommended) +```python +lr_scheduler_type="cosine" +lr_scheduler_kwargs={ + "min_lr": 0.001, # Minimum LR + "warmup_steps": 3 # Linear warmup steps +} +``` +- Smooth cosine decay +- Optional warmup phase +- Widely used in deep learning +- **Best for most use cases** + +#### 4. **Exponential Decay** +```python +lr_scheduler_type="exponential" +lr_scheduler_kwargs={ + "gamma": 0.9 # Decay factor per step +} +``` +- Exponential decrease +- Fast initial decay +- Good for aggressive optimization + +#### 5. **Step Decay** +```python +lr_scheduler_type="step" +lr_scheduler_kwargs={ + "step_size": 5, # Steps between decays + "gamma": 0.5 # Multiplicative factor +} +``` +- Step-wise LR reduction +- Periodic decay +- Good for scheduled changes + +### Usage Example + +```python +from pipelines.sd15_gradient_ascent_pipeline import StableDiffusionGradientAscentPipeline + +pipeline.enable_gradient_ascent( + grad_timestep_range=(0, 700), + num_grad_steps=15, + grad_step_size=0.1, # Initial LR + lr_scheduler_type="cosine", + lr_scheduler_kwargs={ + "min_lr": 0.001, + "warmup_steps": 3 + } +) +``` + +--- + +## Configuration Presets + +We provide 15 pre-configured optimization strategies. Use them with `--grad_config `. + +### Basic Configurations + +| Config | LR Schedule | Momentum | Steps | Description | +|--------|-------------|----------|-------|-------------| +| `constant` | Constant | No | 5 | Simple baseline | +| `linear` | Linear decay | No | 10 | Smooth decay | +| `linear_warmstart` | Linear w/ warmup | No | 10 | Stable start | +| `cosine` | Cosine | No | 10 | Smooth convergence | +| `cosine_warmup` | Cosine w/ warmup | No | 20 | Best convergence | +| `exponential` | Exponential | No | 15 | Fast decay | +| `step` | Step-wise | No | 20 | Periodic decay | + +### Momentum Configurations + +| Config | LR Schedule | Momentum | Steps | Description | +|--------|-------------|----------|-------|-------------| +| `momentum` | Constant | Standard | 10 | Faster convergence | +| `nesterov` | Constant | Nesterov | 10 | Better convergence | + +### Advanced Configurations + +| Config | LR Schedule | Momentum | Steps | Description | +|--------|-------------|----------|-------|-------------| +| `cosine_momentum` | Cosine | Standard | 15 | High quality | +| `cosine_nesterov` | Cosine | Nesterov | 15 | **Recommended** | +| `linear_nesterov` | Linear | Nesterov | 15 | Stable + fast | + +### Quality Presets + +| Config | LR Schedule | Momentum | Steps | Use Case | +|--------|-------------|----------|-------|----------| +| `high_quality` | Cosine | Nesterov | 20 | **Best quality** | +| `aggressive` | Exponential | Standard | 8 | Fast results | +| `conservative` | Cosine | Nesterov | 25 | Most stable | + +### Config Details + +#### `high_quality` (Recommended for Research) +```python +{ + "grad_timestep_range": (200, 800), # Focus on middle timesteps + "num_grad_steps": 20, + "grad_step_size": 0.08, + "lr_scheduler_type": "cosine", + "lr_scheduler_kwargs": {"min_lr": 0.005, "warmup_steps": 5}, + "use_momentum": True, + "momentum": 0.95, + "use_nesterov": True +} +``` + +#### `cosine_nesterov` (Recommended for General Use) +```python +{ + "grad_timestep_range": (0, 700), + "num_grad_steps": 15, + "grad_step_size": 0.12, + "lr_scheduler_type": "cosine", + "lr_scheduler_kwargs": {"min_lr": 0.001, "warmup_steps": 3}, + "use_momentum": True, + "momentum": 0.9, + "use_nesterov": True +} +``` + +#### `aggressive` (Fast Experimentation) +```python +{ + "grad_timestep_range": (0, 900), + "num_grad_steps": 8, + "grad_step_size": 0.15, + "grad_scale": 1.2, + "lr_scheduler_type": "exponential", + "lr_scheduler_kwargs": {"gamma": 0.85}, + "use_momentum": True, + "momentum": 0.85, + "use_nesterov": False +} +``` + +### Listing Configs + +```python +from grad_ascent_configs import list_configs, print_config, get_config + +# List all available configs +print(list_configs()) +# Output: ['aggressive', 'conservative', 'constant', 'cosine', ...] + +# Print config details +print_config("cosine_nesterov") + +# Get config dictionary +config = get_config("high_quality") +pipeline.enable_gradient_ascent(**config) +``` + +--- + +## Evaluation Metrics + +### 1. **FID (Fréchet Inception Distance)** +- Measures distribution similarity between real and generated images +- **Lower is better** +- Requires reference images (COCO dataset only) +- Computationally expensive + +```bash +--metrics fid +``` + +### 2. **CLIP Score** +- Evaluates text-image alignment using CLIP embeddings +- **Higher is better** +- Fast and reliable +- Good for general quality assessment + +```bash +--metrics clip +``` + +### 3. **Aesthetic Score** +- Predicts aesthetic quality using CLIP + MLP +- **Higher is better** +- Trained on human aesthetic ratings +- Good for visual appeal + +```bash +--metrics aesthetic +``` + +### 4. **PickScore** (New) +- Human preference predictor from Pick-a-Pic dataset +- **Higher is better** +- Trained on large-scale human comparisons +- State-of-the-art preference metric + +```bash +--metrics pickscore +``` + +### 5. **HPSv2** (New) +- Human Preference Score version 2 +- **Higher is better** +- Trained on aesthetic evaluations +- Complementary to PickScore + +```bash +--metrics hpsv2 +``` + +### 6. **ImageReward** (New) +- Reward model from RLHF (Reinforcement Learning from Human Feedback) +- **Higher is better** +- Comprehensive quality assessment +- Trained on diverse human feedback + +```bash +--metrics imagereward +``` + +### Metric Recommendations + +| Use Case | Recommended Metrics | Reason | +|----------|---------------------|--------| +| Research/Papers | `fid clip aesthetic pickscore hpsv2` | Comprehensive evaluation | +| Quick Iteration | `clip aesthetic` | Fast and reliable | +| Human Alignment | `pickscore hpsv2 imagereward` | Preference-based | +| Text Alignment | `clip imagereward` | Focus on prompt adherence | +| Visual Quality | `aesthetic pickscore` | Focus on aesthetics | + +--- + +## Model Variants + +Support for multiple SD1.5 model variants trained with different methods. + +### Available Variants + +#### 1. **Origin** (Default) +```bash +--model_variant origin +``` +- Original Stable Diffusion v1.5 from RunwayML +- No additional training +- CFG scale: 7.5 (default) +- Good baseline + +#### 2. **SPO** (Supervised Policy Optimization) +```bash +--model_variant spo +``` +- Trained with SPO method +- Model: `SPO-Diffusion-Models/SPO-SD-v1-5_4k-p_10ep` +- **CFG scale: 5.0** (auto-adjusted) +- Better prompt adherence + +#### 3. **Diffusion-DPO** (Direct Preference Optimization) +```bash +--model_variant diffusion_dpo +``` +- Trained with DPO on human preferences +- Model: `mhdang/dpo-sd1.5-text2image-v1` +- CFG scale: 7.5 +- Improved human alignment + +#### 4. **LPO** (Latent Preference Optimization) +```bash +--model_variant lpo +``` +- Trained with LPO (this project's main method) +- Model: `casiatao/LPO` (lpo_sd15_merge) +- **CFG scale: 5.0** (auto-adjusted) +- **Highest quality baseline** + +### Comparison + +| Variant | Training Method | Quality | Speed | Best For | +|---------|----------------|---------|-------|----------| +| Origin | Pre-training only | Good | Fast | Baseline | +| SPO | Supervised | Better | Fast | Prompt adherence | +| Diffusion-DPO | Preference learning | Better | Fast | Human preferences | +| LPO | Latent preference | **Best** | Fast | Overall quality | + +### Usage Example + +```bash +# Compare all variants +for variant in origin spo diffusion_dpo lpo; do + python eval.py \ + --model_variant $variant \ + --grad_config high_quality \ + --metrics clip aesthetic pickscore \ + --max_samples 100 \ + --output_dir results/${variant} +done +``` + +--- + +## Datasets + +### 1. **COCO Validation** (Default) + +```bash +--dataset_type coco +--data_dir ./data +``` + +**Features:** +- Standard benchmark dataset +- Reference images available (for FID) +- ~5,000 validation samples +- Diverse prompts + +**Structure:** +``` +data/coco/ +├── caption_val.json +└── images/val/ + ├── 000000000139.jpg + ├── 000000000285.jpg + └── ... +``` + +### 2. **Pick-a-Pic Validation** + +```bash +--dataset_type pickapic +``` + +**Features:** +- Large-scale human preference dataset +- Streaming (no download needed) +- ~500,000 validation samples +- Real user prompts +- No reference images (FID not available) + +**Advantages:** +- More diverse prompts +- Real-world use cases +- Human preference focus +- Large-scale evaluation + +### Dataset Recommendations + +| Use Case | Dataset | Reason | +|----------|---------|--------| +| Academic Research | COCO | Standard benchmark, reproducible | +| FID Evaluation | COCO | Requires reference images | +| Human Preference | Pick-a-Pic | Trained on human comparisons | +| Large-scale Tests | Pick-a-Pic | 500K+ samples available | +| Quick Tests | COCO | Smaller, faster | + +--- + +## Usage Examples + +### Example 1: Quick Test +```bash +python eval.py \ + --grad_config cosine_nesterov \ + --metrics clip aesthetic \ + --max_samples 10 \ + --output_dir examples/quick_test +``` + +### Example 2: High-Quality Research Evaluation +```bash +python eval.py \ + --grad_config high_quality \ + --metrics fid clip aesthetic pickscore hpsv2 \ + --max_samples 200 \ + --save_images \ + --output_dir examples/research +``` + +### Example 3: Pick-a-Pic Benchmark +```bash +python eval.py \ + --dataset_type pickapic \ + --grad_config cosine_nesterov \ + --metrics pickscore hpsv2 imagereward \ + --max_samples 500 \ + --output_dir examples/pickapic +``` + +### Example 4: LPO Model Evaluation +```bash +python eval.py \ + --model_variant lpo \ + --grad_config high_quality \ + --metrics clip aesthetic pickscore \ + --max_samples 100 \ + --save_images \ + --output_dir examples/lpo_model +``` + +### Example 5: Baseline Only (No Gradient Ascent) +```bash +python eval.py \ + --mode baseline \ + --model_variant origin \ + --metrics clip aesthetic pickscore \ + --max_samples 50 \ + --output_dir examples/baseline_only +``` + +### Example 6: Manual Configuration +```bash +python eval.py \ + --grad_range_start 200 \ + --grad_range_end 800 \ + --grad_steps 15 \ + --grad_step_size 0.08 \ + --metrics clip aesthetic \ + --max_samples 50 \ + --output_dir examples/manual_config +``` + +### Example 7: Model Comparison +```bash +# Evaluate all model variants +for variant in origin spo diffusion_dpo lpo; do + python eval.py \ + --model_variant $variant \ + --grad_config high_quality \ + --metrics clip aesthetic pickscore \ + --max_samples 100 \ + --save_images \ + --output_dir results/comparison/${variant} +done +``` + +### Example 8: Conservative Optimization +```bash +python eval.py \ + --grad_config conservative \ + --metrics clip aesthetic pickscore hpsv2 \ + --max_samples 100 \ + --save_images \ + --output_dir examples/conservative +``` + +--- + +## API Reference + +### Pipeline Usage + +```python +from diffusers import StableDiffusionPipeline +from pipelines.sd15_gradient_ascent_pipeline import StableDiffusionGradientAscentPipeline +from models import LRMRewardModel + +# Load base pipeline +base_pipeline = StableDiffusionPipeline.from_pretrained( + "runwayml/stable-diffusion-v1-5", + torch_dtype=torch.float16 +) + +# Create gradient ascent pipeline +pipeline = StableDiffusionGradientAscentPipeline(**base_pipeline.components) + +# Load reward model +reward_model = LRMRewardModel( + pretrained_model_name_or_path="runwayml/stable-diffusion-v1-5", + lrm_model_path="casiatao/LRM", + guidance_scale=7.5, + device="cuda" +) +pipeline.set_reward_model(reward_model) + +# Enable gradient ascent with preset +from grad_ascent_configs import get_config +config = get_config("cosine_nesterov") +pipeline.enable_gradient_ascent(**config) + +# Or configure manually +pipeline.enable_gradient_ascent( + grad_timestep_range=(200, 800), + num_grad_steps=15, + grad_step_size=0.1, + lr_scheduler_type="cosine", + lr_scheduler_kwargs={"min_lr": 0.001, "warmup_steps": 3}, + use_momentum=True, + momentum=0.9, + use_nesterov=True +) + +# Generate with gradient ascent +output = pipeline( + prompt="a beautiful mountain landscape at sunset", + num_inference_steps=50, + guidance_scale=7.5, +) + +# Get gradient statistics +stats = pipeline.grad_guidance.get_statistics() +print(f"Reward improvement: {stats['avg_reward_improvement']:.4f}") +``` + +### Custom LR Scheduler + +```python +from lr_scheduler import create_lr_scheduler + +# Create cosine scheduler with warmup +scheduler = create_lr_scheduler( + scheduler_type="cosine", + initial_lr=0.1, + num_steps=20, + min_lr=0.001, + warmup_steps=5 +) + +# Use in optimization loop +for step in range(20): + current_lr = scheduler.get_lr() + # ... apply gradient with current_lr ... + scheduler.step() +``` + +### Configuration Management + +```python +from grad_ascent_configs import get_config, list_configs, print_config + +# List all available configs +all_configs = list_configs() +print(f"Available configs: {all_configs}") + +# Get specific config +config = get_config("high_quality") + +# Print config details +print_config("cosine_nesterov") + +# Create custom config +custom_config = { + "grad_timestep_range": (300, 700), + "num_grad_steps": 12, + "grad_step_size": 0.09, + "lr_scheduler_type": "cosine", + "lr_scheduler_kwargs": {"min_lr": 0.002, "warmup_steps": 4}, + "use_momentum": True, + "momentum": 0.92, + "use_nesterov": True +} +pipeline.enable_gradient_ascent(**custom_config) +``` + +--- + +## Command-Line Options + +### Essential Options + +```bash +--data_dir PATH # Path to data directory (default: ./data) +--dataset_type TYPE # Dataset: coco or pickapic (default: coco) +--model_variant VARIANT # Model: origin, spo, diffusion_dpo, lpo (default: origin) +--max_samples N # Max samples to evaluate (default: all) +--output_dir PATH # Output directory (default: eval_outputs) +--save_images # Save generated images +``` + +### Gradient Ascent Options + +```bash +--grad_config NAME # Use preset config (recommended) +--grad_range_start N # Gradient timestep start (default: 0) +--grad_range_end N # Gradient timestep end (default: 700) +--grad_steps N # Gradient steps per timestep (default: 5) +--grad_step_size FLOAT # Initial learning rate (default: 0.1) +``` + +### Evaluation Options + +```bash +--metrics METRIC [METRIC...] # Metrics to evaluate (default: clip aesthetic) + # Options: fid, clip, aesthetic, pickscore, hpsv2, imagereward +--mode MODE # baseline, gradient_ascent, or both (default: both) +--num_steps N # Diffusion inference steps (default: 50) +--cfg_scale FLOAT # CFG scale (default: 7.5, auto-adjusted for some models) +--batch_size N # Batch size (default: 1) +--log_interval N # Log every N batches (default: 10) +``` + +### Other Options + +```bash +--lrm_model PATH # LRM model path (default: casiatao/LRM) +--seed N # Random seed (default: 42) +--cuda N # CUDA device ID (default: 0) +``` + +### Complete Example + +```bash +python eval.py \ + --data_dir ./data \ + --dataset_type coco \ + --model_variant lpo \ + --grad_config high_quality \ + --metrics fid clip aesthetic pickscore hpsv2 \ + --max_samples 200 \ + --num_steps 50 \ + --save_images \ + --output_dir results/comprehensive \ + --cuda 0 +``` + +--- + +## Output Files + +After running evaluation, the following files are created in **auto-incremented run folders**: + +``` +RESULTS/SD1.5_GradAscent/ +├── run_1/ # First run +│ ├── eval.log # Complete execution log +│ └── reward_curve.png # Reward progression plot +├── run_2/ # Second run +│ ├── eval.log +│ └── reward_curve.png +└── run_3/ # Third run + ├── eval.log + └── reward_curve.png +``` + +### Auto-Incrementing Run Folders + +Each execution automatically creates a new `run_/` folder, preventing accidental overwrites and maintaining a complete experiment history. No manual folder management needed! + +### eval.log Structure + +The log contains detailed information for each batch: + +``` +====================================================================== +COCO GRADIENT ASCENT EVALUATION (BATCHED) +====================================================================== +Logging to: ./RESULTS/SD1.5_GradAscent/run_1/eval.log +Device: cuda:6 +Batch size: 1 +Metrics: fid, clip, reward, aesthetic +Gradient Ascent: Range=[0, 900], Steps=1, StepSize=0.01 +====================================================================== + +[Batch 1/5000] Samples: 1/5000 | FID: 2.5432 | CLIP: 0.8234 | Reward (t=0): 5.2341 | Reward (Avg): 5.2341 | Aesthetic: 6.456 +[Batch 161/5000] Samples: 161/5000 | FID: 2.3821 | CLIP: 0.8412 | Reward (t=0): 5.4123 | Reward (Avg): 5.3215 | Aesthetic: 6.523 +... + +====================================================================== +FINAL RESULTS +====================================================================== +FID: 2.3456 +CLIP avg: 0.8378 +Reward avg: 5.3421 +Aesthetic: 6.489 +====================================================================== +``` + +### reward_curve.png Visualization + +The reward curve plot shows two panels for the **first generated image**: + +**Left Panel: Reward vs Timestep** +- X-axis: Denoising timestep (t) +- Y-axis: Reward score +- Green shaded region: Where gradient ascent is applied +- Shows how reward evolves as noise is removed + +**Right Panel: Reward vs Denoising Step** +- X-axis: Sequential denoising step (0 to num_inference_steps) +- Y-axis: Reward score +- Same data, different perspective for easier interpretation + +**Key Insights from the Plot:** +- **Upward trend**: Reward generally increases as denoising progresses +- **Sharp improvements**: Visible spikes where gradient ascent is effective +- **Final reward**: Last point corresponds to t=0 (decoded image reward) +- **Learning dynamics**: Shows if optimization is working at different noise levels + +### Reward Tracking Details + +The script now explicitly tracks: + +1. **Timestep-specific rewards**: Computed at every denoising step +2. **Final latent reward**: The reward for t=0 (the latent that gets decoded) +3. **Running average**: Mean reward across all processed samples +4. **Current batch reward**: Immediate feedback per batch + +Example log output: +``` +Reward (t=0): 5.4123 # Reward for the final decoded latent +Reward (Avg): 5.3215 # Running average across all samples +``` + +### evaluation_results.json Structure + +(Legacy format from eval.py - test_grad_sd1.5.py uses simplified logging) + +```json +{ + "mode": "both", + "metrics": ["clip", "aesthetic", "pickscore"], + "config": { + "num_samples": 100, + "num_steps": 50, + "cfg_scale": 7.5, + "grad_range": [0, 700], + "grad_steps": 15, + "grad_step_size": 0.12 + }, + "baseline": { + "avg_reward": 0.7234, + "clip_score": 0.8123, + "aesthetic_score": 6.234, + "pickscore": 21.45 + }, + "gradient_ascent": { + "avg_reward": 0.7891, + "clip_score": 0.8345, + "aesthetic_score": 6.456, + "pickscore": 22.13, + "stats": { + "num_applications": 45, + "total_reward_improvement": 2.956, + "avg_reward_improvement": 0.0657 + } + }, + "comparison": { + "reward_difference": 0.0657, + "clip_difference": 0.0222, + "aesthetic_difference": 0.222, + "pickscore_difference": 0.68 + } +} +``` + +--- + +## Troubleshooting + +### Common Issues + +#### 1. Out of Memory (OOM) + +**Symptoms:** +``` +RuntimeError: CUDA out of memory +``` + +**Solutions:** +```bash +# Reduce batch size +--batch_size 1 + +# Reduce max samples +--max_samples 50 + +# Reduce gradient steps +--grad_steps 5 + +# Use smaller config +--grad_config aggressive # Only 8 steps +``` + +#### 2. Slow Evaluation + +**Symptoms:** +- Takes too long to complete +- Hanging on metric computation + +**Solutions:** +```bash +# Skip expensive metrics +--metrics clip aesthetic # Skip FID + +# Reduce samples +--max_samples 50 + +# Reduce diffusion steps +--num_steps 20 + +# Use faster dataset +--dataset_type pickapic # No FID computation +``` + +#### 3. Poor Results / No Improvement + +**Symptoms:** +- Reward doesn't increase +- Quality worse after gradient ascent + +**Solutions:** +```bash +# Try better configs +--grad_config high_quality +--grad_config conservative + +# Increase gradient steps +--grad_steps 20 + +# Adjust timestep range (focus on middle) +--grad_range_start 200 --grad_range_end 800 + +# Try different model variant +--model_variant lpo +``` + +#### 4. Config Not Found + +**Symptoms:** +``` +ValueError: Unknown config: my_config +``` + +**Solutions:** +```bash +# List available configs +python -c "from grad_ascent_configs import list_configs; print(list_configs())" + +# Print config details +python -c "from grad_ascent_configs import print_config; print_config('high_quality')" +``` + +#### 5. Metric Loading Errors + +**Symptoms:** +``` +Warning: Could not load PickScore scorer +``` + +**Solutions:** +```bash +# Install missing dependencies +pip install transformers datasets + +# Check HuggingFace Hub access +huggingface-cli login + +# Skip problematic metrics +--metrics clip aesthetic # Skip pickscore if it fails +``` + +#### 6. Dataset Not Found + +**Symptoms:** +``` +FileNotFoundError: Validation JSON not found +``` + +**Solutions:** +```bash +# Check data directory structure +ls data/coco/ + +# Use Pick-a-Pic instead (no local files needed) +--dataset_type pickapic + +# Provide correct data path +--data_dir /path/to/your/data +``` + +--- + +## Best Practices + +### 1. **Start Small, Scale Up** + +```bash +# First: Quick test (10 samples) +python eval.py --grad_config cosine_nesterov --metrics clip --max_samples 10 + +# Then: Medium test (50 samples) +python eval.py --grad_config cosine_nesterov --metrics clip aesthetic --max_samples 50 + +# Finally: Full evaluation (200+ samples) +python eval.py --grad_config high_quality --metrics fid clip aesthetic pickscore hpsv2 --max_samples 200 +``` + +### 2. **Choose Right Config for Use Case** + +| Goal | Config | Metrics | +|------|--------|---------| +| Quick experiment | `cosine_nesterov` | `clip` | +| Research paper | `high_quality` | `fid clip aesthetic pickscore hpsv2` | +| Production | `conservative` | `pickscore hpsv2` | +| Fast iteration | `aggressive` | `clip aesthetic` | + +### 3. **Use Multiple Metrics** + +Don't rely on a single metric. Recommended combinations: + +```bash +# Text alignment + aesthetics +--metrics clip aesthetic + +# Human preference focus +--metrics pickscore hpsv2 imagereward + +# Comprehensive (research) +--metrics fid clip aesthetic pickscore hpsv2 +``` + +### 4. **Save Important Runs** + +```bash +# Always save images for important evaluations +--save_images --output_dir results/important_run_$(date +%Y%m%d) +``` + +### 5. **Monitor GPU Usage** + +```bash +# In separate terminal +watch -n 1 nvidia-smi + +# Or use +gpustat -i 1 +``` + +### 6. **Batch Evaluation** + +```bash +# Create evaluation script +cat << 'EOF' > run_evals.sh +#!/bin/bash +for config in cosine_nesterov high_quality conservative; do + for model in origin lpo; do + python eval.py \ + --model_variant $model \ + --grad_config $config \ + --metrics clip aesthetic pickscore \ + --max_samples 100 \ + --save_images \ + --output_dir results/${model}_${config} + done +done +EOF + +chmod +x run_evals.sh +./run_evals.sh +``` + +### 7. **Reproducibility** + +```bash +# Always set seed for reproducible results +--seed 42 + +# Document your runs +--output_dir results/experiment_name_$(date +%Y%m%d_%H%M) +``` + +### 8. **Performance Tips** + +- Use `batch_size=1` for safety (reward model compatibility) +- Start with `--max_samples 10` for debugging +- Use `--dataset_type pickapic` for large-scale evaluation (no FID overhead) +- Skip `fid` metric if not needed (expensive) +- Use `--num_steps 20-30` for faster generation (vs default 50) + +### 9. **Config Selection Guide** + +```python +# Start here +if "just_testing": + config = "constant" + +# General use +elif "standard_evaluation": + config = "cosine_nesterov" # Best balance + +# Research/papers +elif "need_best_quality": + config = "high_quality" # 20 steps, nesterov + +# Fast experiments +elif "need_speed": + config = "aggressive" # 8 steps + +# Stability critical +elif "need_stability": + config = "conservative" # 25 steps, careful +``` + +### 10. **Timestep Range Tips** + +```python +# Full range (default) +--grad_range_start 0 --grad_range_end 700 + +# Middle timesteps (often best) +--grad_range_start 200 --grad_range_end 800 + +# Early timesteps (structure) +--grad_range_start 500 --grad_range_end 1000 + +# Late timesteps (details) +--grad_range_start 0 --grad_range_end 400 +``` + +--- + +## Performance Metrics + +### Expected Results + +Based on COCO validation set (100 samples): + +| Method | CLIP ↑ | Aesthetic ↑ | PickScore ↑ | Time | +|--------|--------|-------------|-------------|------| +| Baseline (Origin) | 0.812 | 6.23 | 21.4 | 5 min | +| + Constant | 0.819 | 6.28 | 21.6 | 6 min | +| + Cosine Nesterov | 0.834 | 6.45 | 22.1 | 8 min | +| + High Quality | 0.841 | 6.52 | 22.4 | 12 min | +| Baseline (LPO) | 0.856 | 6.67 | 22.8 | 5 min | +| LPO + High Quality | 0.873 | 6.89 | 23.5 | 12 min | + +*Results may vary based on hardware and specific prompts* + +--- + +## Citation + +If you use this code in your research, please cite: + +```bibtex +@article{lpo2024, + title={Latent Preference Optimization for Diffusion Models}, + author={Your Name}, + journal={arXiv preprint}, + year={2024} +} +``` + +--- + +## License + +This project follows the license of the main LPO repository. + +--- + +## Contributing + +Contributions are welcome! Please: + +1. Test your changes with `--max_samples 10` +2. Document new features in this README +3. Add examples to `examples.sh` +4. Follow existing code style + +--- + +## Support + +For issues and questions: + +1. Check [Troubleshooting](#troubleshooting) section +2. Review [Examples](#usage-examples) +3. Open an issue on GitHub + +--- + +## Changelog + +### Latest Version (January 2026) + +**New Features:** +- ✨ Learning rate scheduling (constant, linear, cosine, exponential, step) +- ✨ Momentum optimization (standard and Nesterov) +- ✨ 15 configuration presets +- ✨ Additional metrics (PickScore, HPSv2, ImageReward) +- ✨ Pick-a-Pic validation dataset support +- ✨ SD1.5 model variants (Origin, SPO, DPO, LPO) +- ✨ Comprehensive evaluation framework +- ✨ **Automatic run folder creation** - Each run creates `run_1/`, `run_2/`, etc. +- ✨ **Reward curve visualization** - Automatic plotting of reward progression across timesteps +- ✨ **Final timestep reward tracking** - Reports reward specifically from t=0 (decoded latent) +- ✨ **Detailed reward logging** - Shows both last timestep reward and running average + +**Improvements:** +- 🚀 Better convergence with LR scheduling +- 🚀 Faster optimization with momentum +- 📊 More comprehensive quality assessment +- 📊 Visual feedback with reward curve plots +- 📚 Complete documentation +- 🔍 Enhanced debugging with timestep-specific reward tracking + +--- + +**Happy Optimizing! 🚀** diff --git a/Reward_sdxl_idealized/config_analysis_tuning.ipynb b/Reward_sdxl_idealized/config_analysis_tuning.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..99d93fcccceaf39556052579ca234105573b48c3 --- /dev/null +++ b/Reward_sdxl_idealized/config_analysis_tuning.ipynb @@ -0,0 +1,218 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "id": "a24d02a2", + "metadata": {}, + "outputs": [], + "source": [ + "import json\n", + "import pandas as pd\n", + "import numpy as np\n", + "from pathlib import Path\n", + "from datetime import datetime\n", + "import warnings\n", + "warnings.filterwarnings('ignore')\n", + "\n", + "# ============================================================================\n", + "# SECTION 1: Load and Parse Results from GPU Tuning Runs\n", + "# ==========================-==================================================\n", + "print(\"=\" * 80)\n", + "print(\"LOADING TUNING RESULTS FROM GPU RUNS\")\n", + "print(\"=\" * 80)\n", + "\n", + "results_dir = Path(\"RESULTS_TURNING/run_2\")\n", + "all_experiments = []\n", + "baseline_metrics = None\n", + "\n", + "# Collect results from all GPU runs\n", + "for gpu_id in range(8):\n", + " gpu_dir = results_dir / f\"gpu_{gpu_id}\"\n", + " results_file = gpu_dir / \"tuning_results.json\"\n", + " \n", + " if results_file.exists():\n", + " with open(results_file, 'r') as f:\n", + " data = json.load(f)\n", + " \n", + " # Extract baseline (same across all GPUs)\n", + " if baseline_metrics is None and \"baseline\" in data:\n", + " baseline_metrics = data[\"baseline\"][\"metrics\"]\n", + " print(f\"\\n📊 Baseline Metrics (cfg_scale=5.0):\")\n", + " for metric, value in baseline_metrics.items():\n", + " print(f\" {metric:15s}: {value:.6f}\")\n", + " \n", + " # Collect all experiments\n", + " if \"experiments\" in data:\n", + " all_experiments.extend(data[\"experiments\"])\n", + " print(f\"✓ GPU {gpu_id}: {len(data['experiments'])} results loaded\")\n", + "\n", + "print(f\"\\n✓ Total experiments loaded: {len(all_experiments)}\")\n", + "\n", + "# ============================================================================\n", + "# SECTION 2: Filter Top Configs with Improvements Across All Metrics\n", + "# ============================================================================\n", + "print(\"\\n\" + \"=\" * 80)\n", + "print(\"FILTERING CONFIGURATIONS WITH IMPROVEMENTS IN ALL METRICS\")\n", + "print(\"=\" * 80)\n", + "\n", + "# Define improvement metrics to track (using ImageReward instead of Reward)\n", + "improvement_metrics = [\n", + " \"aesthetic_improvement\", \n", + " \"imagereward_improvement\", \n", + " \"clip_improvement\", \n", + " \"pickscore_improvement\", \n", + " \"hpsv2_improvement\"\n", + " ]\n", + "\n", + "# Filter experiments with improvements in ALL metrics\n", + "top_configs = []\n", + "\n", + "for exp in all_experiments:\n", + " if \"improvements\" not in exp or \"config\" not in exp or \"metrics\" not in exp:\n", + " continue\n", + " \n", + " improvements = exp[\"improvements\"]\n", + " config = exp[\"config\"]\n", + " metrics = exp[\"metrics\"]\n", + " \n", + " # Check if ALL improvements are positive (>0)\n", + " all_positive = all(improvements.get(metric, -1) > 0 for metric in improvement_metrics)\n", + " \n", + " if all_positive:\n", + " # Calculate aggregate improvement score\n", + " avg_improvement = np.mean([improvements.get(metric, 0) for metric in improvement_metrics])\n", + " \n", + " top_configs.append({\n", + " \"config\": config,\n", + " \"metrics\": metrics,\n", + " \"improvements\": improvements,\n", + " \"avg_improvement\": avg_improvement\n", + " })\n", + "\n", + "print(f\"✓ Found {len(top_configs)} configurations with improvements in ALL metrics\")\n", + "\n", + "# Sort by average improvement\n", + "top_configs.sort(key=lambda x: x[\"avg_improvement\"], reverse=True)\n", + "\n", + "# Get top 10\n", + "top_10 = top_configs[:10]\n", + "print(f\"✓ Extracted top 10 best performing configurations\")\n", + "\n", + "# ============================================================================\n", + "# SECTION 3: Create Comprehensive Results Table\n", + "# ============================================================================\n", + "print(\"\\n\" + \"=\" * 80)\n", + "print(\"CREATING COMPREHENSIVE RESULTS TABLE\")\n", + "print(\"=\" * 80)\n", + "\n", + "# Build detailed table data\n", + "table_data = []\n", + "\n", + "for rank, result in enumerate(top_10, 1):\n", + " cfg = result[\"config\"]\n", + " metrics = result[\"metrics\"]\n", + " improvements = result[\"improvements\"]\n", + " \n", + " row = {\n", + " \"Rank\": rank,\n", + " \"CFG Scale\": cfg.get(\"cfg_scale\", \"N/A\"),\n", + " \"Grad Config\": cfg.get(\"grad_config\", \"N/A\"),\n", + " \"Steps\": cfg.get(\"num_grad_steps\", \"N/A\"),\n", + " \"LR\": cfg.get(\"grad_step_size\", \"N/A\"),\n", + " \"Momentum\": cfg.get(\"momentum\", \"N/A\"),\n", + " \"ImageReward\": f\"{metrics.get('imagereward', 0):.6f}\",\n", + " \"ImageReward ↑\": f\"{improvements.get('imagereward_improvement', 0):+.2f}%\",\n", + " \"CLIP\": f\"{metrics.get('clip', 0):.4f}\",\n", + " \"CLIP ↑\": f\"{improvements.get('clip_improvement', 0):+.2f}%\",\n", + " \"Aesthetic\": f\"{metrics.get('aesthetic', 0):.4f}\",\n", + " \"Aesthetic ↑\": f\"{improvements.get('aesthetic_improvement', 0):+.2f}%\",\n", + " \"PickScore\": f\"{metrics.get('pickscore', 0):.4f}\",\n", + " \"PickScore ↑\": f\"{improvements.get('pickscore_improvement', 0):+.2f}%\",\n", + " \"HPSv2\": f\"{metrics.get('hpsv2', 0):.4f}\",\n", + " \"HPSv2 ↑\": f\"{improvements.get('hpsv2_improvement', 0):+.2f}%\",\n", + " \"Avg Improvement\": f\"{result['avg_improvement']:+.2f}%\",\n", + " }\n", + " \n", + " table_data.append(row)\n", + "\n", + "df_top_10 = pd.DataFrame(table_data)\n", + "\n", + "print(\"\\n📋 TOP 10 CONFIGURATIONS WITH IMPROVEMENTS IN ALL METRICS:\")\n", + "print(\"=\" * 180)\n", + "print(df_top_10.to_string(index=False))\n", + "print(\"=\" * 180)\n", + "\n", + "# ============================================================================\n", + "# SECTION 4: Visualize and Summary Statistics\n", + "# ============================================================================\n", + "print(\"\\n\" + \"=\" * 80)\n", + "print(\"SUMMARY STATISTICS\")\n", + "print(\"=\" * 80)\n", + "\n", + "# Extract numeric improvement values for analysis\n", + "improvement_summary = []\n", + "for result in top_10:\n", + " improvements = result[\"improvements\"]\n", + " for metric in [\"imagereward_improvement\", \"clip_improvement\", \"aesthetic_improvement\", \n", + " \"pickscore_improvement\", \"hpsv2_improvement\"]:\n", + " metric_name = metric.replace(\"_improvement\", \"\").upper()\n", + " improvement_summary.append({\n", + " \"Metric\": metric_name,\n", + " \"Improvement %\": improvements.get(metric, 0)\n", + " })\n", + "\n", + "df_summary = pd.DataFrame(improvement_summary)\n", + "\n", + "print(\"\\n📊 Average Improvements by Metric (Top 10):\")\n", + "metric_stats = df_summary.groupby(\"Metric\")[\"Improvement %\"].agg([\"mean\", \"std\", \"min\", \"max\"])\n", + "print(metric_stats.round(2))\n", + "\n", + "print(\"\\n📈 Best Configuration Details:\")\n", + "best = top_10[0]\n", + "best_cfg = best[\"config\"]\n", + "best_metrics = best[\"metrics\"]\n", + "best_improvements = best[\"improvements\"]\n", + "\n", + "print(f\"\\n✓ RANK #1 - Best Performing Configuration:\")\n", + "print(f\" Configuration:\")\n", + "print(f\" • CFG Scale: {best_cfg.get('cfg_scale')}\")\n", + "print(f\" • Gradient Config: {best_cfg.get('grad_config')}\")\n", + "print(f\" • Gradient Steps: {best_cfg.get('num_grad_steps')}\")\n", + "print(f\" • Step Size: {best_cfg.get('grad_step_size')}\")\n", + "print(f\" • Momentum: {best_cfg.get('momentum')}\")\n", + "print(f\"\\n Metrics:\")\n", + "for metric in [\"imagereward\", \"clip\", \"aesthetic\", \"pickscore\", \"hpsv2\"]:\n", + " baseline_val = baseline_metrics.get(metric, 0)\n", + " current_val = best_metrics.get(metric, 0)\n", + " improvement = best_improvements.get(f\"{metric}_improvement\", 0)\n", + " print(f\" • {metric:12s}: {current_val:8.6f} (baseline: {baseline_val:8.6f}) ↑ {improvement:+6.2f}%\")\n", + "\n", + "print(\"\\n\" + \"=\" * 80)\n", + "print(\"✓ ANALYSIS COMPLETE - TOP 10 CONFIGURATIONS IDENTIFIED\")\n", + "print(\"=\" * 80)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.18" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/Reward_sdxl_idealized/eval.py b/Reward_sdxl_idealized/eval.py new file mode 100644 index 0000000000000000000000000000000000000000..347d9a6727652511e6c9c55849fe6041728ab2ed --- /dev/null +++ b/Reward_sdxl_idealized/eval.py @@ -0,0 +1,1143 @@ +""" +Evaluation script for comparing baseline and gradient ascent pipelines using multiple metrics. + +This script evaluates both pipelines on COCO or Pick-a-Pic validation sets and computes +various preference and quality metrics. +""" +import warnings +warnings.filterwarnings("ignore") +import torch +import torch.nn as nn +import json +import os +import sys +import logging +from pathlib import Path +from PIL import Image +from diffusers import StableDiffusionPipeline, DDIMScheduler, UNet2DConditionModel, StableDiffusionXLPipeline +from models.reward_model import LRMRewardModelXL +from pipelines.sdxl_gradient_ascent_pipeline import StableDiffusionXLGradientAscentPipeline +from torchmetrics.image.fid import FrechetInceptionDistance +from torchmetrics.multimodal import CLIPScore +from transformers import CLIPModel, CLIPProcessor +from tqdm import tqdm +import numpy as np +import argparse +from datasets import load_dataset +from grad_ascent_configs import get_config, list_configs +import matplotlib.pyplot as plt +import matplotlib +matplotlib.use('Agg') # Use non-interactive backend + +# Import evaluation metrics +sys.path.append('../evaluation') +from pick_score import PickScorer +from hpsv2_score import HPSv2Scorer +from imagereward_score import load_imagereward +from huggingface_hub import hf_hub_download + +import random + +def seed_everything(seed: int): + """Locks down all random number generators for absolute reproducibility.""" + # 1. Python & Numpy + random.seed(seed) + np.random.seed(seed) + + # 2. PyTorch Base + torch.manual_seed(seed) + if torch.cuda.is_available(): + torch.cuda.manual_seed(seed) + torch.cuda.manual_seed_all(seed) # For multi-GPU + + # 3. cuDNN Determinism (Crucial for consistent gradients) + torch.backends.cudnn.deterministic = True + torch.backends.cudnn.benchmark = False + + # 4. Optional: Force deterministic algorithms for PyTorch 2.0+ + # Uncomment if variance persists, but it may slow down generation slightly + # torch.use_deterministic_algorithms(True) + + +class MLP(nn.Module): + """MLP for aesthetic scoring.""" + def __init__(self): + super().__init__() + self.layers = nn.Sequential( + nn.Linear(768, 1024), + nn.Dropout(0.2), + nn.Linear(1024, 128), + nn.Dropout(0.2), + nn.Linear(128, 64), + nn.Dropout(0.1), + nn.Linear(64, 16), + nn.Linear(16, 1), + ) + + @torch.no_grad() + def forward(self, embed): + return self.layers(embed) + + +class AestheticScorer(torch.nn.Module): + """Aesthetic scorer using CLIP and MLP.""" + def __init__(self, dtype, device, clip_name_or_path="openai/clip-vit-large-patch14", + aesthetic_path="./sac+logos+ava1-l14-linearMSE.pth"): + super().__init__() + self.clip = CLIPModel.from_pretrained(clip_name_or_path) + self.processor = CLIPProcessor.from_pretrained(clip_name_or_path) + self.mlp = MLP() + + # Load aesthetic weights + if os.path.exists(aesthetic_path): + state_dict = torch.load(aesthetic_path, map_location='cpu') + self.mlp.load_state_dict(state_dict) + else: + print(f"Warning: Aesthetic weights not found at {aesthetic_path}") + + self.dtype = dtype + self.to(device) + self.eval() + + @torch.no_grad() + def __call__(self, images): + device = next(self.parameters()).device + inputs = self.processor(images=images, return_tensors="pt") + inputs = {k: v.to(self.dtype).to(device) for k, v in inputs.items()} + embed = self.clip.get_image_features(**inputs) + # normalize embedding + embed = embed / torch.linalg.vector_norm(embed, dim=-1, keepdim=True) + return self.mlp(embed).squeeze(1) + + +class TeeLogger: + """Logger that writes to both console and file.""" + def __init__(self, log_file): + self.terminal = sys.stdout + self.log = open(log_file, 'w') + + def write(self, message): + self.terminal.write(message) + self.log.write(message) + self.log.flush() + + def flush(self): + self.terminal.flush() + self.log.flush() + + def close(self): + self.log.close() + + +def setup_logging(output_dir): + """Setup logging to both console and file.""" + output_path = Path(output_dir) + output_path.mkdir(parents=True, exist_ok=True) + log_file = output_path / "log.log" + + # Redirect stdout to both console and file + tee = TeeLogger(log_file) + sys.stdout = tee + + return tee, log_file + + +def load_validation_data(data_dir, max_samples=None, dataset_type="coco"): + """Load validation prompts and image paths. + + Args: + data_dir: Path to data directory + max_samples: Maximum number of samples to load + dataset_type: Type of dataset ("coco" or "pickapic") + + Returns: + prompts: List of text prompts + image_paths: List of image paths (None for pickapic streaming dataset) + """ + if dataset_type == "coco": + data_dir = Path(data_dir) + val_json = data_dir / "coco" / "caption_val.json" + + if not val_json.exists(): + raise FileNotFoundError(f"Validation JSON not found: {val_json}") + + with open(val_json, 'r') as f: + data = json.load(f) + + # Validate that image folder exists + val_img_dir = data_dir / "coco" / "images" / "val" + if not val_img_dir.exists(): + raise FileNotFoundError(f"Validation image directory not found: {val_img_dir}") + + # Parse data + prompts = [] + image_paths = [] + for img_path, caption in data.items(): + full_path = data_dir / "coco" / img_path + if full_path.exists(): + prompts.append(caption) + image_paths.append(str(full_path)) + else: + print(f"Warning: Image not found: {full_path}") + + if max_samples: + prompts = prompts[:max_samples] + image_paths = image_paths[:max_samples] + + print(f"Loaded {len(prompts)} COCO validation samples") + return prompts, image_paths + + elif dataset_type == "pickapic": + print("Loading Pick-a-Pic validation dataset (streaming)...") + val_dataset = load_dataset("pickapic-anonymous/pickapic_v1", split="validation_unique", streaming=True) + + prompts = [] + for i, sample in enumerate(val_dataset): + prompts.append(sample['caption']) + if max_samples and i + 1 >= max_samples: + break + + print(f"Loaded {len(prompts)} Pick-a-Pic validation samples") + return prompts, None # No reference images for Pick-a-Pic + + else: + raise ValueError(f"Unknown dataset type: {dataset_type}. Choose 'coco' or 'pickapic'.") + + +def generate_and_evaluate( + pipeline, + prompts, + image_paths, + device, + dtype, + num_inference_steps=20, + guidance_scale=7.5, + seed=42, + batch_size=1, + apply_gradient_ascent=False, + mode_name="baseline", + log_interval=10, + output_dir=None, + save_images=False, + clip_scorer=None, + aesthetic_scorer=None, + pick_scorer=None, + hpsv2_scorer=None, + hpsv21_scorer=None, + imagereward_scorer=None, + compute_fid=True +): + """Generate images and update FID metric.""" + pipeline.to(device) + + print(f"\nGenerating images with {mode_name} mode...") + + + all_rewards = [] + all_clip_scores = [] + all_aesthetic_scores = [] + all_pick_scores = [] + all_hpsv2_scores = [] + all_hpsv21_scores = [] + all_imagereward_scores = [] + lr_history_first_image = None # Store LR history for first image + num_batches = (len(prompts) + batch_size - 1) // batch_size + + # Create output directory if saving images + if save_images and output_dir: + mode_output_dir = Path(output_dir) / mode_name + mode_output_dir.mkdir(parents=True, exist_ok=True) + + # Disable internal progress bars + pipeline.set_progress_bar_config(disable=True) + + for idx, i in enumerate(tqdm(range(0, len(prompts), batch_size), desc=f"Generating {mode_name}")): + batch_prompts = prompts[i:i+batch_size] + batch_real_paths = image_paths[i:i+batch_size] if image_paths is not None else None + batch_num = idx + 1 + + # Initialize FID metric if needed + fid_metric = None + real_images_tensor = None + + if compute_fid and batch_real_paths is not None: + fid_metric = FrechetInceptionDistance().to(device) + + # Load and update FID with real images for this batch + real_images = [] + for path in batch_real_paths: + img = Image.open(path).convert("RGB") + img = img.resize((512, 512)) # Inception v3 input size + img_array = np.array(img) + real_images.append(img_array) + + # Convert to tensor [B, H, W, C] -> [B, C, H, W] + real_images_tensor = torch.from_numpy(np.stack(real_images)).permute(0, 3, 1, 2).float() + real_images_tensor = real_images_tensor.to(device) + + # Generate images + generator = torch.Generator(device=device).manual_seed(seed + i) + + with torch.no_grad(): + result = pipeline( + prompt=batch_prompts, + num_inference_steps=num_inference_steps, + guidance_scale=guidance_scale, + generator=generator, + track_rewards=True, + print_rewards=False, + apply_gradient_ascent=apply_gradient_ascent, + verbose_grad=False, + ) + + # Process generated images + images = result.images + + # Update FID metric if computing it + if compute_fid and fid_metric is not None: + image_tensors = [] + + for img in images: + img_resized = img.resize((512, 512)) # Inception v3 input size + img_array = np.array(img_resized) + image_tensors.append(img_array) + + # Convert to tensor and update FID + images_tensor = torch.from_numpy(np.stack(image_tensors)).permute(0, 3, 1, 2).float() + images_tensor = images_tensor.to(device) + + if batch_size == 1: + real_images_tensor = torch.cat([real_images_tensor, real_images_tensor], dim=0).to(dtype=torch.uint8) + images_tensor = torch.cat([images_tensor, images_tensor], dim=0).to(dtype=torch.uint8) + fid_metric.update(real_images_tensor, real=True) + fid_metric.update(images_tensor, real=False) + + # Track rewards - get the final timestep reward (t=0) + current_batch_final_reward = None + current_batch_final_timestep = None + if hasattr(pipeline, 'reward_history') and pipeline.reward_history: + # For each image, get the reward from the last denoising step (t=0 or closest to 0) + num_steps_per_image = num_inference_steps + + # Get the last entry which corresponds to the final timestep of the last image in batch + final_entry = pipeline.reward_history[-1] + current_batch_final_reward = final_entry['reward_score'] + current_batch_final_timestep = final_entry['timestep'] + all_rewards.append(current_batch_final_reward) + + # Capture LR history from first image if gradient ascent is enabled + if apply_gradient_ascent and idx == 0 and lr_history_first_image is None: + if hasattr(pipeline, 'grad_guidance') and pipeline.grad_guidance: + grad_stats = pipeline.grad_guidance.get_statistics() + if grad_stats and 'detailed_stats' in grad_stats: + # Extract LR history from the gradient ascent statistics + lr_history_first_image = { + 'prompt': batch_prompts[0], + 'timesteps': [], + 'learning_rates': [], # All LR values from all gradient steps + 'rewards': [] + } + for stat in grad_stats['detailed_stats']: + lr_history_first_image['timesteps'].append(stat['timestep']) + if 'lr_history' in stat: + # Extend with all LR values from this timestep's gradient steps + lr_history_first_image['learning_rates'].extend(stat['lr_history']) + # Collect all rewards from reward_history for each gradient step + if 'reward_history' in stat: + lr_history_first_image['rewards'].extend(stat['reward_history']) + + # Compute CLIP score + if clip_scorer is not None: + # Convert PIL images to tensor format for CLIP score [C, H, W] in range [0, 1] + for img, prompt in zip(images, batch_prompts): + img_array = np.array(img).astype(np.float32) + img_tensor = torch.from_numpy(img_array).permute(2, 0, 1).unsqueeze(0).to(device) + clip_score = clip_scorer(img_tensor, [prompt]).item() + all_clip_scores.append(clip_score) + + # Compute aesthetic score + if aesthetic_scorer is not None: + aesthetic_scores = aesthetic_scorer(images) + if isinstance(aesthetic_scores, torch.Tensor): + aesthetic_scores = aesthetic_scores.cpu().numpy() + if aesthetic_scores.ndim == 0: + aesthetic_scores = [aesthetic_scores.item()] + all_aesthetic_scores.extend(aesthetic_scores.tolist() if hasattr(aesthetic_scores, 'tolist') else [aesthetic_scores]) + + # Compute PickScore + if pick_scorer is not None: + for img, prompt in zip(images, batch_prompts): + pick_score = pick_scorer(prompt, [img])[0] + all_pick_scores.append(pick_score) + + # Compute HPSv2 score + if hpsv2_scorer is not None: + for img, prompt in zip(images, batch_prompts): + hpsv2_score = hpsv2_scorer.score(img, prompt)[0] + all_hpsv2_scores.append(hpsv2_score) + + # Compute HPSv2.1 score + if hpsv21_scorer is not None: + for img, prompt in zip(images, batch_prompts): + hpsv21_score = hpsv21_scorer.score(img, prompt)[0] + all_hpsv21_scores.append(hpsv21_score) + + # Compute ImageReward score + if imagereward_scorer is not None: + for img, prompt in zip(images, batch_prompts): + imagereward_score = imagereward_scorer.score(prompt, img) + all_imagereward_scores.append(imagereward_score) + + # Save generated images if requested + if save_images and output_dir: + for img_idx, img in enumerate(images): + global_idx = i + img_idx + img_path = mode_output_dir / f"sample_{global_idx:05d}.png" + img.save(img_path) + + # Log intermediate FID and metrics every log_interval batches + if batch_num % log_interval == 0 or batch_num == num_batches: + num_samples_processed = min(i + batch_size, len(prompts)) + log_msg = f"\n[{mode_name}] Batch {batch_num}/{num_batches} | Samples: {num_samples_processed}/{len(prompts)}" + + # Add FID if computing + if compute_fid and fid_metric is not None: + try: + current_fid = fid_metric.compute().item() + log_msg += f" | FID: {current_fid:.4f}" + except Exception as e: + log_msg += f" | FID: Computing..." + + # Add reward - show both final timestep reward and average + if all_rewards: + avg_reward = np.mean(all_rewards) + if current_batch_final_reward is not None: + log_msg += f" | Reward (t={current_batch_final_timestep}): {current_batch_final_reward:.4f}" + log_msg += f" | Reward (Avg): {avg_reward:.4f}" + else: + log_msg += f" | Reward (Avg): {avg_reward:.4f}" + + # Add CLIP if computing + if clip_scorer is not None and all_clip_scores: + log_msg += f" | CLIP: {np.mean(all_clip_scores):.4f}" + + # Add aesthetic if computing + if aesthetic_scorer is not None and all_aesthetic_scores: + log_msg += f" | Aesthetic: {np.mean(all_aesthetic_scores):.4f}" + + # Add PickScore + if pick_scorer is not None and all_pick_scores: + log_msg += f" | PickScore: {np.mean(all_pick_scores):.4f}" + + # Add HPSv2 + if hpsv2_scorer is not None and all_hpsv2_scores: + log_msg += f" | HPSv2: {np.mean(all_hpsv2_scores):.4f}" + + # Add HPSv2.1 + if hpsv21_scorer is not None and all_hpsv21_scores: + log_msg += f" | HPSv2.1: {np.mean(all_hpsv21_scores):.4f}" + + # Add ImageReward + if imagereward_scorer is not None and all_imagereward_scores: + log_msg += f" | ImageReward: {np.mean(all_imagereward_scores):.4f}" + + print(log_msg) + + # Re-enable progress bars + pipeline.set_progress_bar_config(disable=False) + + avg_reward = np.mean(all_rewards) if all_rewards else 0.0 + avg_clip_score = np.mean(all_clip_scores) if all_clip_scores else 0.0 + avg_aesthetic_score = np.mean(all_aesthetic_scores) if all_aesthetic_scores else 0.0 + avg_pick_score = np.mean(all_pick_scores) if all_pick_scores else 0.0 + avg_hpsv2_score = np.mean(all_hpsv2_scores) if all_hpsv2_scores else 0.0 + avg_hpsv21_score = np.mean(all_hpsv21_scores) if all_hpsv21_scores else 0.0 + avg_imagereward_score = np.mean(all_imagereward_scores) if all_imagereward_scores else 0.0 + + return avg_reward, fid_metric, avg_clip_score, avg_aesthetic_score, avg_pick_score, avg_hpsv2_score, avg_hpsv21_score, avg_imagereward_score, lr_history_first_image + + +def auto_increment_path(base_path): + """ + Create an auto-incrementing run folder inside base_path. + Returns: base_path/run_1, base_path/run_2, etc. + """ + base_path = Path(base_path) + base_path.mkdir(parents=True, exist_ok=True) # Ensure base directory exists + + i = 1 + while True: + new_path = base_path / f"run_{i}" + if not new_path.exists(): + return new_path + i += 1 + + +def main(): + parser = argparse.ArgumentParser(description="Evaluate baseline and gradient ascent pipelines") + parser.add_argument("--data_dir", type=str, default="./data", help="Path to data directory") + parser.add_argument("--dataset_type", type=str, default="coco", choices=["coco", "pickapic"], + help="Dataset to use for evaluation: coco or pickapic (default: coco)") + parser.add_argument("--base_model", type=str, default="stabilityai/stable-diffusion-xl-base-1.0", help="Base model path") + parser.add_argument("--model_variant", type=str, default="origin", + choices=["spo", "lpo"], + help="SDXL model variant to use (default: origin)") + parser.add_argument("--lrm_model", type=str, default="casiatao/LRM", help="LRM model path") + parser.add_argument("--num_steps", type=int, default=50, help="Number of inference steps") + parser.add_argument("--cfg_scale", type=float, default=7.5, help="Classifier-free guidance scale") + parser.add_argument("--seed", type=int, default=42, help="Random seed") + parser.add_argument("--max_samples", type=int, default=None, help="Max samples to evaluate (None for all)") + parser.add_argument("--batch_size", type=int, default=1, help="Batch size for generation (use 1 for reward model compatibility)") + parser.add_argument("--fid_batch_size", type=int, default=32, help="Batch size for FID computation") + parser.add_argument("--log_interval", type=int, default=10, help="Log FID and metrics every N batches") + parser.add_argument("--output_dir", type=str, default="eval_outputs", help="Directory to save generated images and results") + parser.add_argument("--save_images", action="store_true", help="Save all generated images to output directory") + parser.add_argument("--mode", type=str, default="both", choices=["baseline", "gradient_ascent", "both"], + help="Which evaluation to run: baseline, gradient_ascent, or both (default: both)") + + # Metrics selection + parser.add_argument("--metrics", type=str, nargs="+", default=["clip", "aesthetic"], + choices=["fid", "clip", "aesthetic", "pickscore", "hpsv2", "hpsv21", "imagereward"], + help="Which metrics to evaluate (default: clip aesthetic)") + + # Gradient ascent config + parser.add_argument("--grad_config", type=str, default=None, + help=f"Gradient ascent config preset (available: {', '.join(list_configs())}). " + "If provided, overrides individual grad_* arguments.") + parser.add_argument("--grad_range_start", type=int, default=0, help="Gradient timestep range start") + parser.add_argument("--grad_range_end", type=int, default=700, help="Gradient timestep range end") + parser.add_argument("--grad_steps", type=int, default=5, help="Number of gradient steps per timestep (use 5 for better reward improvement)") + parser.add_argument("--grad_step_size", type=float, default=0.1, help="Gradient step size (initial LR)") + + # Config overrides (these override values from grad_config if specified) + parser.add_argument("--override_momentum", type=float, default=None, help="Override momentum value from grad_config") + parser.add_argument("--override_num_grad_steps", type=int, default=None, help="Override num_grad_steps from grad_config") + parser.add_argument("--override_grad_step_size", type=float, default=None, help="Override grad_step_size from grad_config") + + # Cuda + parser.add_argument("--cuda", type=int, default=0, help="Use CUDA device id") + + args = parser.parse_args() + + seed_everything(args.seed) + + # Configuration + device = f"cuda:{args.cuda}" if torch.cuda.is_available() else "cpu" + #dtype = torch.float16 #if torch.cuda.is_available() else torch.float32 + dtype = torch.bfloat16 + + # Create auto-incremented output directory + args.output_dir = auto_increment_path(args.output_dir) + + # Setup logging to file + tee_logger, log_file = setup_logging(args.output_dir) + + print("="*70) + print("FID EVALUATION: BASELINE vs GRADIENT ASCENT") + print("="*70) + print(f"\nLogging to: {log_file}") + print(f"\nDevice: {device}") + print(f"Dataset: {args.dataset_type.upper()}") + print(f"Data directory: {args.data_dir}") + print(f"Base model: {args.base_model}") + print(f"Model variant: {args.model_variant}") + print(f"LRM model: {args.lrm_model}") + print(f"Inference steps: {args.num_steps}") + print(f"CFG scale: {args.cfg_scale}") + print(f"Batch size: {args.batch_size}") + print(f"Max samples: {args.max_samples or 'All'}") + print(f"Output directory: {args.output_dir}") + print(f"Save images: {args.save_images}") + print(f"Evaluation mode: {args.mode}") + print(f"Metrics to evaluate: {', '.join(args.metrics).upper()}") + if args.grad_config: + print(f"Gradient ascent config: {args.grad_config}") + + # Load validation data + print("\n" + "="*70) + print("1. LOADING VALIDATION DATA") + print("="*70) + prompts, image_paths = load_validation_data(args.data_dir, args.max_samples, args.dataset_type) + + # Automatically disable FID if no reference images available (e.g., Pick-a-Pic dataset) + can_compute_fid = image_paths is not None + if not can_compute_fid and "fid" in args.metrics: + print("\n⚠ Warning: FID metric requested but no reference images available. FID will be skipped.") + args.metrics = [m for m in args.metrics if m != "fid"] + + # Load reward model + print("\n" + "="*70) + print("2. LOADING REWARD MODEL") + print("="*70) + reward_model = LRMRewardModelXL( + pretrained_model_name_or_path=args.base_model, + lrm_model_path=args.lrm_model, + guidance_scale=args.cfg_scale, + device=device + ) + if dtype == torch.float16: + reward_model = reward_model.half() + elif dtype == torch.bfloat16: + reward_model = reward_model.to(torch.bfloat16) + reward_model.eval() + print("✓ Reward model loaded") + + # Load pipeline + print("\n" + "="*70) + print("3. LOADING PIPELINE") + print("="*70) + + # Load model based on variant + if args.model_variant == "spo": + base_pipeline = StableDiffusionXLPipeline.from_pretrained( + 'SPO-Diffusion-Models/SPO-SDXL_4k-p_10ep', + torch_dtype=dtype, + safety_checker=None, + ) + args.cfg_scale = 5.0 # SPO uses CFG 5.0 + print(f"✓ Loaded SPO SDXL model (cfg_scale adjusted to 5.0)") + elif args.model_variant == "lpo": + unet = UNet2DConditionModel.from_pretrained( + 'casiatao/LPO', + subfolder="lpo_sdxl_merge/unet", + torch_dtype=dtype + ) + base_pipeline = StableDiffusionXLPipeline.from_pretrained( + args.base_model, + torch_dtype=dtype, + variant="fp16", + unet=unet + ) + args.cfg_scale = 5.0 # LPO uses CFG 5.0 + print(f"✓ Loaded LPO SDXL model (cfg_scale adjusted to 5.0)") + + pipeline = StableDiffusionXLGradientAscentPipeline(**base_pipeline.components) + pipeline.scheduler = DDIMScheduler.from_config(pipeline.scheduler.config) + pipeline = pipeline.to(device) + pipeline.set_reward_model(reward_model) + print("✓ Pipeline loaded") + + # Load CLIP scorer + print("\n" + "="*70) + print("3.5. LOADING CLIP AND AESTHETIC SCORERS") + print("="*70) + + # Only load scorers for requested metrics + clip_scorer = None + aesthetic_scorer = None + pick_scorer = None + hpsv2_scorer = None + hpsv21_scorer = None + imagereward_scorer = None + + if "clip" in args.metrics: + try: + clip_scorer = CLIPScore(model_name_or_path="openai/clip-vit-large-patch14").to(device) + print("✓ CLIP scorer loaded") + except Exception as e: + print(f"Warning: Could not load CLIP scorer: {e}") + clip_scorer = None + else: + print("⊘ CLIP scorer skipped (not in selected metrics)") + + if "aesthetic" in args.metrics: + try: + aesthetic_scorer = AestheticScorer(dtype=dtype, device=device) + print("✓ Aesthetic scorer loaded") + except Exception as e: + print(f"Warning: Could not load Aesthetic scorer: {e}") + aesthetic_scorer = None + else: + print("⊘ Aesthetic scorer skipped (not in selected metrics)") + + if "pickscore" in args.metrics: + try: + pick_scorer = PickScorer( + processor_name_or_path="laion/CLIP-ViT-H-14-laion2B-s32B-b79K", + model_pretrained_name_or_path="yuvalkirstain/PickScore_v1", + device=device + ) + print("✓ PickScore scorer loaded") + except Exception as e: + print(f"Warning: Could not load PickScore scorer: {e}") + pick_scorer = None + else: + print("⊘ PickScore scorer skipped (not in selected metrics)") + + if "hpsv2" in args.metrics: + try: + hpsv2_scorer = HPSv2Scorer( + clip_pretrained_name_or_path=hf_hub_download( + repo_id="laion/CLIP-ViT-H-14-laion2B-s32B-b79K", + filename="open_clip_pytorch_model.bin" + ), + model_pretrained_name_or_path=hf_hub_download( + repo_id="xswu/HPSv2", + filename="HPS_v2_compressed.pt" + ), + device=device + ) + print("✓ HPSv2 scorer loaded") + except Exception as e: + print(f"Warning: Could not load HPSv2 scorer: {e}") + hpsv2_scorer = None + else: + print("⊘ HPSv2 scorer skipped (not in selected metrics)") + + if "hpsv21" in args.metrics: + try: + hpsv21_scorer = HPSv2Scorer( + clip_pretrained_name_or_path=hf_hub_download( + repo_id="laion/CLIP-ViT-H-14-laion2B-s32B-b79K", + filename="open_clip_pytorch_model.bin" + ), + model_pretrained_name_or_path=hf_hub_download( + repo_id="xswu/HPSv2", + filename="HPS_v2.1_compressed.pt" + ), + device=device + ) + print("✓ HPSv2.1 scorer loaded") + except Exception as e: + print(f"Warning: Could not load HPSv2.1 scorer: {e}") + hpsv21_scorer = None + else: + print("⊘ HPSv2.1 scorer skipped (not in selected metrics)") + + if "imagereward" in args.metrics: + try: + imagereward_scorer = load_imagereward( + model_path=hf_hub_download(repo_id="THUDM/ImageReward", filename="ImageReward.pt"), + med_config=hf_hub_download(repo_id="THUDM/ImageReward", filename="med_config.json"), + device=device + ) + print("✓ ImageReward scorer loaded") + except Exception as e: + print(f"Warning: Could not load ImageReward scorer: {e}") + imagereward_scorer = None + else: + print("⊘ ImageReward scorer skipped (not in selected metrics)") + + # Configure gradient ascent + print("\n" + "="*70) + print("4. CONFIGURING GRADIENT ASCENT") + print("="*70) + + # Use config preset if provided, otherwise use individual args + if args.grad_config: + print(f"Loading gradient ascent config: {args.grad_config}") + grad_config = get_config(args.grad_config) + print(f"Config loaded: {grad_config}") + + # Apply overrides if specified + if args.override_momentum is not None: + grad_config['momentum'] = args.override_momentum + print(f" Overriding momentum: {args.override_momentum}") + if args.override_num_grad_steps is not None: + grad_config['num_grad_steps'] = args.override_num_grad_steps + print(f" Overriding num_grad_steps: {args.override_num_grad_steps}") + if args.override_grad_step_size is not None: + grad_config['grad_step_size'] = args.override_grad_step_size + print(f" Overriding grad_step_size: {args.override_grad_step_size}") + else: + grad_config = { + "grad_timestep_range": (args.grad_range_start, args.grad_range_end), + "num_grad_steps": args.grad_steps, + "grad_step_size": args.grad_step_size, + } + print(f"Using manual gradient ascent configuration") + + print(f"Gradient timestep range: {grad_config.get('grad_timestep_range', (args.grad_range_start, args.grad_range_end))}") + print(f"Gradient steps: {grad_config.get('num_grad_steps', args.grad_steps)}") + print(f"Gradient step size (initial LR): {grad_config.get('grad_step_size', args.grad_step_size)}") + if grad_config.get('lr_scheduler_type'): + print(f"LR Scheduler: {grad_config['lr_scheduler_type']}") + if grad_config.get('use_momentum'): + print(f"Momentum: {grad_config.get('momentum', 0.9)} (Nesterov: {grad_config.get('use_nesterov', False)})") + + pipeline.enable_gradient_ascent(**grad_config) + + # Initialize result variables + fid_score_baseline = None + avg_reward_baseline = None + clip_score_baseline = None + aesthetic_score_baseline = None + pick_score_baseline = None + hpsv2_score_baseline = None + hpsv21_score_baseline = None + imagereward_score_baseline = None + fid_score_grad = None + avg_reward_grad = None + clip_score_grad = None + aesthetic_score_grad = None + pick_score_grad = None + hpsv2_score_grad = None + hpsv21_score_grad = None + imagereward_score_grad = None + grad_stats = None + + # ========== BASELINE EVALUATION ========== + if args.mode in ["baseline", "both"]: + print("\n" + "="*70) + print("5. EVALUATING BASELINE") + print("="*70) + + # Generate and evaluate baseline + avg_reward_baseline, fid_baseline, clip_score_baseline, aesthetic_score_baseline, pick_score_baseline, hpsv2_score_baseline, hpsv21_score_baseline, imagereward_score_baseline, _ = generate_and_evaluate( + pipeline=pipeline, + prompts=prompts, + image_paths=image_paths, + device=device, + dtype=dtype, + num_inference_steps=args.num_steps, + guidance_scale=args.cfg_scale, + seed=args.seed, + batch_size=args.batch_size, + apply_gradient_ascent=False, + mode_name="baseline", + log_interval=args.log_interval, + output_dir=args.output_dir, + save_images=args.save_images, + clip_scorer=clip_scorer, + aesthetic_scorer=aesthetic_scorer, + pick_scorer=pick_scorer, + hpsv2_scorer=hpsv2_scorer, + hpsv21_scorer=hpsv21_scorer, + imagereward_scorer=imagereward_scorer, + compute_fid=("fid" in args.metrics and can_compute_fid) + ) + + # Compute FID for baseline if requested + if "fid" in args.metrics and fid_baseline is not None: + fid_score_baseline = fid_baseline.compute().item() + print(f"\n✓ Baseline FID: {fid_score_baseline:.4f}") + print(f"✓ Baseline Avg Reward: {avg_reward_baseline:.4f}") + if "clip" in args.metrics: + print(f"✓ Baseline Avg CLIP Score: {clip_score_baseline:.4f}") + if "aesthetic" in args.metrics: + print(f"✓ Baseline Avg Aesthetic Score: {aesthetic_score_baseline:.4f}") + if "pickscore" in args.metrics and pick_score_baseline is not None: + print(f"✓ Baseline Avg PickScore: {pick_score_baseline:.4f}") + if "hpsv2" in args.metrics and hpsv2_score_baseline is not None: + print(f"✓ Baseline Avg HPSv2 Score: {hpsv2_score_baseline:.4f}") + if "hpsv21" in args.metrics and hpsv21_score_baseline is not None: + print(f"✓ Baseline Avg HPSv2.1 Score: {hpsv21_score_baseline:.4f}") + if "imagereward" in args.metrics and imagereward_score_baseline is not None: + print(f"✓ Baseline Avg ImageReward: {imagereward_score_baseline:.4f}") + + # ========== GRADIENT ASCENT EVALUATION ========== + if args.mode in ["gradient_ascent", "both"]: + print("\n" + "="*70) + print("6. EVALUATING GRADIENT ASCENT") + print("="*70) + + # Generate and evaluate with gradient ascent + avg_reward_grad, fid_grad, clip_score_grad, aesthetic_score_grad, pick_score_grad, hpsv2_score_grad, hpsv21_score_grad, imagereward_score_grad, lr_history = generate_and_evaluate( + pipeline=pipeline, + prompts=prompts, + image_paths=image_paths, + device=device, + dtype=dtype, + num_inference_steps=args.num_steps, + guidance_scale=args.cfg_scale, + seed=args.seed, + batch_size=args.batch_size, + apply_gradient_ascent=True, + mode_name="gradient_ascent", + log_interval=args.log_interval, + output_dir=args.output_dir, + save_images=args.save_images, + clip_scorer=clip_scorer, + aesthetic_scorer=aesthetic_scorer, + pick_scorer=pick_scorer, + hpsv2_scorer=hpsv2_scorer, + hpsv21_scorer=hpsv21_scorer, + imagereward_scorer=imagereward_scorer, + compute_fid=("fid" in args.metrics and can_compute_fid) + ) + + # Compute FID for gradient ascent if requested + if "fid" in args.metrics and fid_grad is not None: + fid_score_grad = fid_grad.compute().item() + print(f"\n✓ Gradient Ascent FID: {fid_score_grad:.4f}") + print(f"✓ Gradient Ascent Avg Reward: {avg_reward_grad:.4f}") + if "clip" in args.metrics: + print(f"✓ Gradient Ascent Avg CLIP Score: {clip_score_grad:.4f}") + if "aesthetic" in args.metrics: + print(f"✓ Gradient Ascent Avg Aesthetic Score: {aesthetic_score_grad:.4f}") + if "pickscore" in args.metrics and pick_score_grad is not None: + print(f"✓ Gradient Ascent Avg PickScore: {pick_score_grad:.4f}") + if "hpsv2" in args.metrics and hpsv2_score_grad is not None: + print(f"✓ Gradient Ascent Avg HPSv2 Score: {hpsv2_score_grad:.4f}") + if "hpsv21" in args.metrics and hpsv21_score_grad is not None: + print(f"✓ Gradient Ascent Avg HPSv2.1 Score: {hpsv21_score_grad:.4f}") + if "imagereward" in args.metrics and imagereward_score_grad is not None: + print(f"✓ Gradient Ascent Avg ImageReward: {imagereward_score_grad:.4f}") + + # Get gradient stats + grad_stats = pipeline.grad_guidance.get_statistics() + if grad_stats: + print(f"\nGradient Ascent Statistics:") + print(f" Applications: {grad_stats['num_applications']}") + print(f" Total reward improvement: {grad_stats['total_reward_improvement']:+.4f}") + print(f" Avg reward improvement: {grad_stats['avg_reward_improvement']:+.4f}") + + # Plot LR curve if we captured it + if lr_history is not None and lr_history['learning_rates']: + plot_path = Path(args.output_dir) / "lr_curve.png" + + # LR values are now continuous across all gradient steps + lrs = lr_history['learning_rates'] + steps = list(range(len(lrs))) # Step indices (0 to total_steps-1) + + plt.figure(figsize=(12, 6)) + plt.plot(steps, lrs, linewidth=2, color='blue', alpha=0.8) + + # Mark the first step with a star + plt.plot(steps[0], lrs[0], marker='*', markersize=20, color='gold', + markeredgecolor='darkgoldenrod', markeredgewidth=2, zorder=5) + + # Mark timestep boundaries + num_timesteps = len(lr_history['timesteps']) + num_grad_steps_per_timestep = len(lrs) // num_timesteps if num_timesteps > 0 else 0 + if num_grad_steps_per_timestep > 0: + for i in range(num_timesteps + 1): + step_idx = i * num_grad_steps_per_timestep + if step_idx <= len(lrs): + plt.axvline(x=step_idx, color='red', linestyle='--', alpha=0.3, linewidth=1) + if i < num_timesteps: + plt.text(step_idx, plt.ylim()[1] * 0.95, f't={lr_history["timesteps"][i]}', + fontsize=8, color='red', alpha=0.7, ha='left') + + plt.xlabel('Global Gradient Step', fontsize=12) + plt.ylabel('Learning Rate', fontsize=12) + plt.title(f'Learning Rate Evolution Across All Gradient Steps\\nPrompt: "{lr_history["prompt"][:60]}..."', + fontsize=12, fontweight='bold') + plt.grid(True, alpha=0.3) + + # Add info text + num_timesteps = len(lr_history['timesteps']) + num_grad_steps_per_timestep = len(lrs) // num_timesteps if num_timesteps > 0 else 0 + plt.text(0.02, 0.98, + f'Total timesteps: {num_timesteps}\\nGrad steps/timestep: {num_grad_steps_per_timestep}\\nTotal grad steps: {len(lrs)}', + transform=plt.gca().transAxes, fontsize=10, verticalalignment='top', + bbox=dict(boxstyle='round', facecolor='wheat', alpha=0.5)) + + plt.tight_layout() + plt.savefig(plot_path, dpi=150, bbox_inches='tight') + plt.close() + print(f"\n✓ Saved LR curve plot to: {plot_path}") + print(f" Total gradient steps: {len(lrs)}") + print(f" LR range: {min(lrs):.6f} → {max(lrs):.6f}") + + # Plot Rewards curve if we captured it + if lr_history is not None and lr_history['rewards']: + plot_path = Path(args.output_dir) / "rewards_curve.png" + + # Reward values are now continuous across all gradient steps + rewards = lr_history['rewards'] + steps = list(range(len(rewards))) # Step indices (0 to total_steps-1) + + plt.figure(figsize=(12, 6)) + plt.plot(steps, rewards, linewidth=2, color='green', alpha=0.8) + + # Mark the first step with a star + plt.plot(steps[0], rewards[0], marker='*', markersize=20, color='gold', + markeredgecolor='darkgoldenrod', markeredgewidth=2, zorder=5) + + # Mark timestep boundaries + num_timesteps = len(lr_history['timesteps']) + # rewards has one extra value at the start (initial) compared to gradient steps + num_grad_steps_per_timestep = (len(rewards) - num_timesteps) // num_timesteps if num_timesteps > 0 else 0 + if num_grad_steps_per_timestep > 0: + for i in range(num_timesteps + 1): + step_idx = i * (num_grad_steps_per_timestep + 1) # +1 because reward_history includes initial + if step_idx <= len(rewards): + plt.axvline(x=step_idx, color='red', linestyle='--', alpha=0.3, linewidth=1) + if i < num_timesteps: + plt.text(step_idx, plt.ylim()[1] * 0.95, f't={lr_history["timesteps"][i]}', + fontsize=8, color='red', alpha=0.7, ha='left') + + plt.xlabel('Global Gradient Step', fontsize=12) + plt.ylabel('Reward Score', fontsize=12) + plt.title(f'Reward Evolution Across All Gradient Steps\nPrompt: "{lr_history["prompt"][:60]}..."', + fontsize=12, fontweight='bold') + plt.grid(True, alpha=0.3) + + # Add info text + num_timesteps = len(lr_history['timesteps']) + reward_improvement = rewards[-1] - rewards[0] if len(rewards) > 1 else 0 + plt.text(0.02, 0.98, + f'Total timesteps: {num_timesteps}\nTotal grad steps: {len(rewards)}\n' + f'Initial reward: {rewards[0]:.4f}\nFinal reward: {rewards[-1]:.4f}\n' + f'Improvement: {reward_improvement:+.4f}', + transform=plt.gca().transAxes, fontsize=10, verticalalignment='top', + bbox=dict(boxstyle='round', facecolor='lightgreen', alpha=0.5)) + + plt.tight_layout() + plt.savefig(plot_path, dpi=150, bbox_inches='tight') + plt.close() + print(f"\n✓ Saved Rewards curve plot to: {plot_path}") + print(f" Total gradient steps: {len(rewards)}") + print(f" Reward range: {min(rewards):.4f} → {max(rewards):.4f}") + print(f" Total improvement: {reward_improvement:+.4f}") + + # ========== FINAL RESULTS ========== + print("\n" + "="*70) + print("FINAL RESULTS") + print("="*70) + + if avg_reward_baseline is not None: + print(f"\nBaseline:") + if fid_score_baseline is not None: + print(f" FID Score: {fid_score_baseline:.4f}") + print(f" Avg Reward: {avg_reward_baseline:.4f}") + if "clip" in args.metrics and clip_score_baseline is not None: + print(f" Avg CLIP Score: {clip_score_baseline:.4f}") + if "aesthetic" in args.metrics and aesthetic_score_baseline is not None: + print(f" Avg Aesthetic: {aesthetic_score_baseline:.4f}") + if "pickscore" in args.metrics and pick_score_baseline is not None: + print(f" Avg PickScore: {pick_score_baseline:.4f}") + if "hpsv2" in args.metrics and hpsv2_score_baseline is not None: + print(f" Avg HPSv2: {hpsv2_score_baseline:.4f}") + if "hpsv21" in args.metrics and hpsv21_score_baseline is not None: + print(f" Avg HPSv2.1: {hpsv21_score_baseline:.4f}") + if "imagereward" in args.metrics and imagereward_score_baseline is not None: + print(f" Avg ImageReward: {imagereward_score_baseline:.4f}") + + if avg_reward_grad is not None: + print(f"\nGradient Ascent:") + if fid_score_grad is not None: + print(f" FID Score: {fid_score_grad:.4f}") + print(f" Avg Reward: {avg_reward_grad:.4f}") + if "clip" in args.metrics and clip_score_grad is not None: + print(f" Avg CLIP Score: {clip_score_grad:.4f}") + if "aesthetic" in args.metrics and aesthetic_score_grad is not None: + print(f" Avg Aesthetic: {aesthetic_score_grad:.4f}") + if "pickscore" in args.metrics and pick_score_grad is not None: + print(f" Avg PickScore: {pick_score_grad:.4f}") + if "hpsv2" in args.metrics and hpsv2_score_grad is not None: + print(f" Avg HPSv2: {hpsv2_score_grad:.4f}") + if "hpsv21" in args.metrics and hpsv21_score_grad is not None: + print(f" Avg HPSv2.1: {hpsv21_score_grad:.4f}") + if "imagereward" in args.metrics and imagereward_score_grad is not None: + print(f" Avg ImageReward: {imagereward_score_grad:.4f}") + + if avg_reward_baseline is not None and avg_reward_grad is not None: + print(f"\nComparison:") + if fid_score_baseline is not None and fid_score_grad is not None: + fid_diff = fid_score_grad - fid_score_baseline + print(f" FID Change: {fid_diff:+.4f} ({'worse' if fid_diff > 0 else 'better'}, lower is better)") + reward_diff = avg_reward_grad - avg_reward_baseline + print(f" Reward Change: {reward_diff:+.4f} ({'better' if reward_diff > 0 else 'worse'}, higher is better)") + if "clip" in args.metrics and clip_score_baseline is not None and clip_score_grad is not None: + clip_diff = clip_score_grad - clip_score_baseline + print(f" CLIP Change: {clip_diff:+.4f} ({'better' if clip_diff > 0 else 'worse'}, higher is better)") + if "aesthetic" in args.metrics and aesthetic_score_baseline is not None and aesthetic_score_grad is not None: + aesthetic_diff = aesthetic_score_grad - aesthetic_score_baseline + print(f" Aesthetic Change: {aesthetic_diff:+.4f} ({'better' if aesthetic_diff > 0 else 'worse'}, higher is better)") + if "pickscore" in args.metrics and pick_score_baseline is not None and pick_score_grad is not None: + pick_diff = pick_score_grad - pick_score_baseline + print(f" PickScore Change: {pick_diff:+.4f} ({'better' if pick_diff > 0 else 'worse'}, higher is better)") + if "hpsv2" in args.metrics and hpsv2_score_baseline is not None and hpsv2_score_grad is not None: + hpsv2_diff = hpsv2_score_grad - hpsv2_score_baseline + print(f" HPSv2 Change: {hpsv2_diff:+.4f} ({'better' if hpsv2_diff > 0 else 'worse'}, higher is better)") + if "hpsv21" in args.metrics and hpsv21_score_baseline is not None and hpsv21_score_grad is not None: + hpsv21_diff = hpsv21_score_grad - hpsv21_score_baseline + print(f" HPSv2.1 Change: {hpsv21_diff:+.4f} ({'better' if hpsv21_diff > 0 else 'worse'}, higher is better)") + if "imagereward" in args.metrics and imagereward_score_baseline is not None and imagereward_score_grad is not None: + imagereward_diff = imagereward_score_grad - imagereward_score_baseline + print(f" ImageReward Chg: {imagereward_diff:+.4f} ({'better' if imagereward_diff > 0 else 'worse'}, higher is better)") + + # Save results to file + results = { + "mode": args.mode, + "metrics": args.metrics, + "config": { + "num_samples": len(prompts), + "num_steps": args.num_steps, + "cfg_scale": args.cfg_scale, + "grad_range": [args.grad_range_start, args.grad_range_end], + "grad_steps": args.grad_steps, + "grad_step_size": args.grad_step_size + } + } + + if avg_reward_baseline is not None: + results["baseline"] = {"avg_reward": avg_reward_baseline} + if fid_score_baseline is not None: + results["baseline"]["fid"] = fid_score_baseline + if "clip" in args.metrics and clip_score_baseline is not None: + results["baseline"]["clip_score"] = clip_score_baseline + if "aesthetic" in args.metrics and aesthetic_score_baseline is not None: + results["baseline"]["aesthetic_score"] = aesthetic_score_baseline + if "pickscore" in args.metrics and pick_score_baseline is not None: + results["baseline"]["pickscore"] = pick_score_baseline + if "hpsv2" in args.metrics and hpsv2_score_baseline is not None: + results["baseline"]["hpsv2_score"] = hpsv2_score_baseline + if "hpsv21" in args.metrics and hpsv21_score_baseline is not None: + results["baseline"]["hpsv21_score"] = hpsv21_score_baseline + if "imagereward" in args.metrics and imagereward_score_baseline is not None: + results["baseline"]["imagereward_score"] = imagereward_score_baseline + + if avg_reward_grad is not None: + results["gradient_ascent"] = {"avg_reward": avg_reward_grad} + if fid_score_grad is not None: + results["gradient_ascent"]["fid"] = fid_score_grad + if "clip" in args.metrics and clip_score_grad is not None: + results["gradient_ascent"]["clip_score"] = clip_score_grad + if "aesthetic" in args.metrics and aesthetic_score_grad is not None: + results["gradient_ascent"]["aesthetic_score"] = aesthetic_score_grad + if "pickscore" in args.metrics and pick_score_grad is not None: + results["gradient_ascent"]["pickscore"] = pick_score_grad + if "hpsv2" in args.metrics and hpsv2_score_grad is not None: + results["gradient_ascent"]["hpsv2_score"] = hpsv2_score_grad + if "hpsv21" in args.metrics and hpsv21_score_grad is not None: + results["gradient_ascent"]["hpsv21_score"] = hpsv21_score_grad + if "imagereward" in args.metrics and imagereward_score_grad is not None: + results["gradient_ascent"]["imagereward_score"] = imagereward_score_grad + if grad_stats: + results["gradient_ascent"]["stats"] = grad_stats + + if avg_reward_baseline is not None and avg_reward_grad is not None: + results["comparison"] = { + "reward_difference": avg_reward_grad - avg_reward_baseline + } + if fid_score_baseline is not None and fid_score_grad is not None: + results["comparison"]["fid_difference"] = fid_score_grad - fid_score_baseline + if "clip" in args.metrics and clip_score_baseline is not None and clip_score_grad is not None: + results["comparison"]["clip_difference"] = clip_score_grad - clip_score_baseline + if "aesthetic" in args.metrics and aesthetic_score_baseline is not None and aesthetic_score_grad is not None: + results["comparison"]["aesthetic_difference"] = aesthetic_score_grad - aesthetic_score_baseline + if "pickscore" in args.metrics and pick_score_baseline is not None and pick_score_grad is not None: + results["comparison"]["pickscore_difference"] = pick_score_grad - pick_score_baseline + if "hpsv2" in args.metrics and hpsv2_score_baseline is not None and hpsv2_score_grad is not None: + results["comparison"]["hpsv2_difference"] = hpsv2_score_grad - hpsv2_score_baseline + if "hpsv21" in args.metrics and hpsv21_score_baseline is not None and hpsv21_score_grad is not None: + results["comparison"]["hpsv21_difference"] = hpsv21_score_grad - hpsv21_score_baseline + if "imagereward" in args.metrics and imagereward_score_baseline is not None and imagereward_score_grad is not None: + results["comparison"]["imagereward_difference"] = imagereward_score_grad - imagereward_score_baseline + + # Save results to output directory + output_path = Path(args.output_dir) + output_path.mkdir(parents=True, exist_ok=True) + results_path = output_path / "evaluation_results.txt" + + with open(results_path, "w") as f: + for k, v in results.items(): + f.write(f"{k}: {v}\n") + + + print(f"\n✓ Results saved to: {results_path}") + if args.save_images: + print(f"✓ Generated images saved to: {output_path}/baseline/ and {output_path}/gradient_ascent/") + print("\n" + "="*70) + + # Close logger + tee_logger.close() + sys.stdout = tee_logger.terminal + + +if __name__ == "__main__": + main() + diff --git a/Reward_sdxl_idealized/examples.sh b/Reward_sdxl_idealized/examples.sh new file mode 100644 index 0000000000000000000000000000000000000000..8acc55dc5820abd2f079cb4c366779e484bcb7dc --- /dev/null +++ b/Reward_sdxl_idealized/examples.sh @@ -0,0 +1,19 @@ +export HF_HOME=/efs/vkvermaa/2025/diffusion/latent_correct/hf_cache +Dataset_Name="pickapic" # "coco" or "pickapic" +Grad_Config="one_step_rectification_config" +# constant cosine_nesterov low_to_high_momentum high_to_low_momentum +# low_to_high_nesterov high_to_low_nesterov +Model_Variant="spo" #lpo, spo +GPU_ID=$(nvidia-smi --query-gpu=index,memory.used --format=csv,noheader,nounits | sort -k2 -n | head -n1 | cut -d',' -f1) + +python eval.py \ + --model_variant "$Model_Variant" \ + --dataset_type "$Dataset_Name" \ + --grad_config "$Grad_Config" \ + --metrics fid clip aesthetic pickscore hpsv2 hpsv21 imagereward \ + --max_samples 500 \ + --num_steps 20 \ + --cfg_scale 3 \ + --output_dir "RESULTS/$Dataset_Name/${Grad_Config}_${Model_Variant}" \ + --cuda $GPU_ID \ + --mode "gradient_ascent" # gradient_ascent baseline # /baseline \ No newline at end of file diff --git a/Reward_sdxl_idealized/gradient_ascent_utils.py b/Reward_sdxl_idealized/gradient_ascent_utils.py new file mode 100644 index 0000000000000000000000000000000000000000..fcb562365064b394dfd2a9b1e0e3823581fd92dc --- /dev/null +++ b/Reward_sdxl_idealized/gradient_ascent_utils.py @@ -0,0 +1,339 @@ +""" +Gradient Ascent utilities for reward-guided diffusion generation. + +This module implements gradient ascent on the LRM reward score to guide +the diffusion process toward higher preference scores. +""" + +import torch +import torch.nn.functional as F +from typing import Optional, Tuple, List, Literal +from tqdm import tqdm +from lr_scheduler import create_lr_scheduler, LRScheduler + + +class RewardGuidedDiffusion: + """ + Implements reward-guided generation using gradient ascent. + + During denoising, at specified timesteps, we: + 1. Compute the reward score for current latents + 2. Calculate gradients of reward w.r.t. latents + 3. Update latents in the direction that increases reward + + This guides generation toward higher preference scores. + """ + + def __init__( + self, + reward_model, + grad_scale: float = 1.0, + grad_timestep_range: Optional[Tuple[int, int]] = None, + num_grad_steps: int = 5, + grad_step_size: float = 0.1, + gradient_checkpoint: bool = False, + # LR Scheduling + lr_scheduler_type: Literal["constant", "linear", "cosine", "exponential", "step"] = "constant", + lr_scheduler_kwargs: Optional[dict] = None, + # Momentum + use_momentum: bool = False, + momentum: float = 0.9, + use_nesterov: bool = False, + use_iso_projection: bool = False + ): + """ + Initialize reward-guided diffusion. + + Args: + reward_model: LRM reward model for computing preference scores + grad_scale: Scale factor for gradient updates (default: 1.0) + grad_timestep_range: Tuple of (min_t, max_t) for gradient ascent. + If None, applies to all timesteps. + num_grad_steps: Number of gradient ascent steps per timestep + grad_step_size: Step size for each gradient update (initial LR) + gradient_checkpoint: Whether to use gradient checkpointing + lr_scheduler_type: Type of LR scheduler ("constant", "linear", "cosine", "exponential", "step") + lr_scheduler_kwargs: Additional kwargs for LR scheduler (e.g., end_lr, min_lr, warmup_steps) + use_momentum: Whether to use momentum in gradient updates + momentum: Momentum coefficient (typically 0.9) + use_nesterov: Whether to use Nesterov momentum + use_iso_projection: Whether to use Iso Projection + """ + self.reward_model = reward_model + self.grad_scale = grad_scale + self.grad_timestep_range = grad_timestep_range + self.num_grad_steps = num_grad_steps + self.grad_step_size = grad_step_size + self.gradient_checkpoint = gradient_checkpoint + + # LR Scheduler + self.lr_scheduler_type = lr_scheduler_type + self.lr_scheduler_kwargs = lr_scheduler_kwargs or {} + self.lr_scheduler: Optional[LRScheduler] = None + self.global_lr_scheduler: Optional[LRScheduler] = None # Scheduler across denoising timesteps + + # Momentum + self.use_momentum = use_momentum + self.momentum = momentum + self.use_nesterov = use_nesterov + self.velocity = None # Will be initialized per optimization + + self.use_iso_projection = use_iso_projection + + # Statistics + self.grad_stats = [] + self.timestep_counter = 0 # Track which timestep we're on + + def should_apply_gradient(self, timestep: int) -> bool: + """Check if gradient ascent should be applied at this timestep.""" + + if self.grad_timestep_range is None: + return False + + min_t, max_t = self.grad_timestep_range + return min_t <= timestep <= max_t + + @torch.enable_grad() + def compute_reward_gradient( + self, + latents: torch.Tensor, + prompt: str, + timestep: int, + ) -> Tuple[torch.Tensor, float]: + """ + Compute gradient of reward score w.r.t. latents in FP32 to prevent underflow. + """ + # 1. Cast to FP32 and ensure we are detached from previous iterations + latents_fp32 = latents.detach().to(torch.float32).clone() + latents_fp32.requires_grad_(True) + + # 2. Compute reward score + # Note: Even if the model internally uses fp16/bf16, autograd will + # safely accumulate the gradient in fp32 for our leaf node. + reward_score = self.reward_model.get_reward_score( + latents_fp32, + prompt, + timestep, + enable_grad=True + ) + + if reward_score.numel() > 1: + reward_score = reward_score.mean() + + # 3. Extract gradient + # CRITICAL: retain_graph=True prevents the graph from dying across multiple + # gradient steps if your reward model relies on cached text embeddings. + grad = torch.autograd.grad( + outputs=reward_score, + inputs=latents_fp32, + create_graph=False, + retain_graph=True, # Keeps the graph alive for the next step! + allow_unused=True, + )[0] + + # 4. Handle None gradients and cast back to the pipeline's original dtype + if grad is None: + grad = torch.zeros_like(latents) + else: + grad = grad.to(latents.dtype) + + return grad, reward_score.item() + + def apply_gradient_ascent( + self, + latents: torch.Tensor, + prompt: str, + timestep: int, + base_noise: Optional[torch.Tensor] = None, # Required for Iso-Marginal projection + verbose: bool = True, + total_denoising_steps: Optional[int] = None, + ) -> Tuple[torch.Tensor, dict]: + + # 1. UPCAST TO FP32 AND SETUP OPTIMIZER (Targeting Latents) + original_latents = latents.detach().clone().to(torch.float32) + current_latents = torch.nn.Parameter(original_latents.clone()) + self.reward_model.unet.conv_in.weight.requires_grad_(True) + + # Initial reward tracking + with torch.no_grad(): + initial_reward = self.reward_model.get_reward_score( + latents, + prompt, + timestep + ) + initial_reward_val = initial_reward.item() if initial_reward.numel() == 1 else initial_reward.mean().item() + + # Initialize tracking lists + grad_norms = [] + reward_history = [initial_reward_val] + lr_history = [] + + # 2. FORWARD PASS (downcast to FP16 just for the model forward pass) + reward = self.reward_model.get_reward_score( + current_latents.to(latents.dtype), + prompt, + timestep, + enable_grad=True + ) + + loss = -reward.mean() + loss.backward() + + # Extract latent gradient + raw_grad = current_latents.grad + reward_history.append(reward.mean().item()) + + # 3. ISO-MARGINAL PROJECTION WITH ASYMMETRIC INCLUSION + if raw_grad is not None and base_noise is not None and self.use_iso_projection: + gamma = 1e-8 + B = raw_grad.shape[0] + + grad_flat = raw_grad.view(B, -1) + noise_flat = base_noise.view(B, -1).to(torch.float32) + + # Compute projection scalar for raw_grad (which is -?R) + dot_product = (grad_flat * noise_flat).sum(dim=1, keepdim=True) + noise_norm_sq = (noise_flat * noise_flat).sum(dim=1, keepdim=True) + + proj_scalar = dot_product / (noise_norm_sq + gamma) + proj_scalar = proj_scalar.view(B, 1, 1, 1) + + # 1. Decompose + grad_parallel = proj_scalar * base_noise.to(torch.float32) + grad_perp = raw_grad - grad_parallel + + # 2. Asymmetric Inclusion + # proj_scalar > 0 means the applied step (+?R) points toward -epsilon (Denoising. GOOD.) + # proj_scalar < 0 means the applied step (+?R) points toward +epsilon (Noising. BAD.) + safe_proj_scalar = torch.clamp(proj_scalar, min=0.0) + + beta = 1.0 # Retention factor for the safe parallel gradient + safe_grad_parallel = beta * (safe_proj_scalar * base_noise.to(torch.float32)) + + # 3. Recombine + #grad_perp = grad_perp + safe_grad_parallel + else: + grad_perp = raw_grad + if base_noise is None: + print("?? WARNING: base_noise missing. Skipping Iso-Marginal projection.") + + # 4. KINETIC RECTIFICATION (Applied to the projected latent gradient) + if grad_perp is not None: + max_grad = grad_perp.norm().item() + + if max_grad > 0: + kinetic_direction = grad_perp / (max_grad + 1e-8) + + # Because the max element is 1.0, alpha is the EXACT float32 change applied. + alpha = self.grad_step_size + + with torch.no_grad(): + rectified_latents = original_latents - (alpha * kinetic_direction) + else: + print("?? WARNING: Gradient exists but max value is 0.0") + rectified_latents = original_latents.clone() + alpha = 0.0 + else: + print("?? FATAL: PyTorch completely dropped the latent gradient!") + rectified_latents = original_latents.clone() + max_grad = 0.0 + alpha = 0.0 + + if verbose: + print(f" Grad step | LR: {alpha:.6f} | Reward: {reward.mean().item():.4f} | Max Grad: {max_grad:.4f}") + + # 5. DOWNCAST AND RETURN + final_latents = rectified_latents.detach().to(latents.dtype) + + with torch.no_grad(): + final_reward = self.reward_model.get_reward_score( + final_latents, prompt, timestep + ) + final_reward_val = final_reward.item() if final_reward.numel() == 1 else final_reward.mean().item() + + stats = { + 'timestep': timestep, + 'initial_reward': initial_reward_val, + 'final_reward': final_reward_val, + 'reward_improvement': final_reward_val - initial_reward_val, + 'grad_norms': [max_grad], + 'reward_history': reward_history, + 'lr_history': [alpha], # Kept for plotting logic + 'latent_change': (final_latents - original_latents.to(latents.dtype)).norm().item(), + } + + self.grad_stats.append(stats) + + return final_latents, stats + + def get_statistics(self) -> dict: + """Get aggregated statistics across all gradient ascent applications.""" + if not self.grad_stats: + return {} + + total_improvement = sum(s['reward_improvement'] for s in self.grad_stats) + avg_improvement = total_improvement / len(self.grad_stats) + + all_grad_norms = [n for s in self.grad_stats for n in s['grad_norms']] + + return { + 'num_applications': len(self.grad_stats), + 'total_reward_improvement': total_improvement, + 'avg_reward_improvement': avg_improvement, + 'avg_grad_norm': sum(all_grad_norms) / len(all_grad_norms) if all_grad_norms else 0, + 'max_grad_norm': max(all_grad_norms) if all_grad_norms else 0, + 'detailed_stats': self.grad_stats, + } + + def reset_statistics(self): + """Reset statistics and global scheduler.""" + self.grad_stats = [] + self.global_lr_scheduler = None + self.timestep_counter = 0 + + +def create_reward_guided_generator( + reward_model, + grad_timestep_range: Tuple[int, int] = (500, 700), + grad_scale: float = 1.0, + num_grad_steps: int = 5, + grad_step_size: float = 0.1, + lr_scheduler_type: str = "constant", + lr_scheduler_kwargs: Optional[dict] = None, + use_momentum: bool = False, + momentum: float = 0.9, + use_nesterov: bool = False, + use_iso_projection: bool = False +) -> RewardGuidedDiffusion: + """ + Convenience function to create a reward-guided diffusion generator. + + Args: + reward_model: LRM reward model + grad_timestep_range: Tuple of (min_t, max_t) for applying gradients + grad_scale: Scale factor for gradient magnitude + num_grad_steps: Number of gradient ascent iterations per timestep + grad_step_size: Step size for each gradient update (initial LR) + lr_scheduler_type: Type of LR scheduler + lr_scheduler_kwargs: Additional kwargs for LR scheduler + use_momentum: Whether to use momentum + momentum: Momentum coefficient + use_nesterov: Whether to use Nesterov momentum + use_iso_projection: Whether to use Iso Projection + + Returns: + RewardGuidedDiffusion instance + """ + return RewardGuidedDiffusion( + reward_model=reward_model, + grad_scale=grad_scale, + grad_timestep_range=grad_timestep_range, + num_grad_steps=num_grad_steps, + grad_step_size=grad_step_size, + lr_scheduler_type=lr_scheduler_type, + lr_scheduler_kwargs=lr_scheduler_kwargs, + use_momentum=use_momentum, + momentum=momentum, + use_nesterov=use_nesterov, + use_iso_projection= False + ) diff --git a/Reward_sdxl_idealized/lr_scheduler.py b/Reward_sdxl_idealized/lr_scheduler.py new file mode 100644 index 0000000000000000000000000000000000000000..c50a7c7b62744ddefeb666a90347f95fac7846b7 --- /dev/null +++ b/Reward_sdxl_idealized/lr_scheduler.py @@ -0,0 +1,233 @@ +""" +Learning rate schedulers for gradient ascent optimization. + +Provides various LR scheduling strategies for reward-guided gradient ascent, +including cosine annealing, linear decay, and custom schedules. +""" + +import math +from typing import Optional, Literal + + +class LRScheduler: + """Base class for learning rate schedulers.""" + + def __init__(self, initial_lr: float, num_steps: int): + """ + Initialize LR scheduler. + + Args: + initial_lr: Initial learning rate + num_steps: Total number of optimization steps + """ + self.initial_lr = initial_lr + self.num_steps = num_steps + self.current_step = 0 + + def get_lr(self) -> float: + """Get current learning rate.""" + raise NotImplementedError + + def step(self): + """Update scheduler state after a step.""" + self.current_step += 1 + + def reset(self): + """Reset scheduler state.""" + self.current_step = 0 + + +class ConstantLR(LRScheduler): + """Constant learning rate (no scheduling).""" + + def get_lr(self) -> float: + return self.initial_lr + + +class LinearLR(LRScheduler): + """Linear learning rate decay.""" + + def __init__( + self, + initial_lr: float, + num_steps: int, + end_lr: float = 0.0, + start_step: int = 0, + ): + """ + Initialize linear LR scheduler. + + Args: + initial_lr: Starting learning rate + num_steps: Total number of steps + end_lr: Ending learning rate (default: 0.0) + start_step: Step to begin decay (default: 0) + """ + super().__init__(initial_lr, num_steps) + self.end_lr = end_lr + self.start_step = start_step + + def get_lr(self) -> float: + if self.current_step < self.start_step: + return self.initial_lr + + progress = (self.current_step - self.start_step) / (self.num_steps - self.start_step) + progress = min(1.0, progress) + + return self.initial_lr + (self.end_lr - self.initial_lr) * progress + + +class CosineLR(LRScheduler): + """Cosine annealing learning rate schedule.""" + + def __init__( + self, + initial_lr: float, + num_steps: int, + min_lr: float = 0.0, + warmup_steps: int = 0, + ): + """ + Initialize cosine LR scheduler. + + Args: + initial_lr: Maximum learning rate + num_steps: Total number of steps + min_lr: Minimum learning rate (default: 0.0) + warmup_steps: Number of linear warmup steps (default: 0) + """ + super().__init__(initial_lr, num_steps) + self.min_lr = min_lr + self.warmup_steps = warmup_steps + + def get_lr(self) -> float: + if self.current_step < self.warmup_steps: + # Linear warmup + return self.initial_lr * (self.current_step / self.warmup_steps) + + # Cosine annealing + progress = (self.current_step - self.warmup_steps) / (self.num_steps - self.warmup_steps) + progress = min(1.0, progress) + + cosine_decay = 0.5 * (1 + math.cos(math.pi * progress)) + return self.min_lr + (self.initial_lr - self.min_lr) * cosine_decay + + +class ExponentialLR(LRScheduler): + """Exponential learning rate decay.""" + + def __init__( + self, + initial_lr: float, + num_steps: int, + gamma: float = 0.95, + ): + """ + Initialize exponential LR scheduler. + + Args: + initial_lr: Starting learning rate + num_steps: Total number of steps + gamma: Multiplicative decay factor per step + """ + super().__init__(initial_lr, num_steps) + self.gamma = gamma + + def get_lr(self) -> float: + return self.initial_lr * (self.gamma ** self.current_step) + + +class StepLR(LRScheduler): + """Step-wise learning rate decay.""" + + def __init__( + self, + initial_lr: float, + num_steps: int, + step_size: int, + gamma: float = 0.1, + ): + """ + Initialize step LR scheduler. + + Args: + initial_lr: Starting learning rate + num_steps: Total number of steps + step_size: Number of steps between each decay + gamma: Multiplicative decay factor + """ + super().__init__(initial_lr, num_steps) + self.step_size = step_size + self.gamma = gamma + + def get_lr(self) -> float: + num_decays = self.current_step // self.step_size + return self.initial_lr * (self.gamma ** num_decays) + + +def create_lr_scheduler( + scheduler_type: Literal["constant", "linear", "cosine", "exponential", "step"], + initial_lr: float, + num_steps: int, + **kwargs +) -> LRScheduler: + """ + Factory function to create learning rate schedulers. + + Args: + scheduler_type: Type of scheduler ("constant", "linear", "cosine", "exponential", "step") + initial_lr: Initial learning rate + num_steps: Total number of optimization steps + **kwargs: Additional scheduler-specific arguments + For linear: end_lr, start_step + For cosine: min_lr, warmup_steps + For exponential: gamma + For step: step_size, gamma + + Returns: + LRScheduler instance + + Examples: + # Constant LR + scheduler = create_lr_scheduler("constant", initial_lr=0.1, num_steps=100) + + # Linear decay + scheduler = create_lr_scheduler("linear", initial_lr=0.1, num_steps=100, end_lr=0.01) + + # Cosine annealing with warmup + scheduler = create_lr_scheduler("cosine", initial_lr=0.1, num_steps=100, + min_lr=0.001, warmup_steps=10) + """ + if scheduler_type == "constant": + return ConstantLR(initial_lr, num_steps) + + elif scheduler_type == "linear": + return LinearLR( + initial_lr, num_steps, + end_lr=kwargs.get("end_lr", 0.0), + start_step=kwargs.get("start_step", 0), + ) + + elif scheduler_type == "cosine": + return CosineLR( + initial_lr, num_steps, + min_lr=kwargs.get("min_lr", 0.0), + warmup_steps=kwargs.get("warmup_steps", 0), + ) + + elif scheduler_type == "exponential": + return ExponentialLR( + initial_lr, num_steps, + gamma=kwargs.get("gamma", 0.95), + ) + + elif scheduler_type == "step": + return StepLR( + initial_lr, num_steps, + step_size=kwargs.get("step_size", 10), + gamma=kwargs.get("gamma", 0.1), + ) + + else: + raise ValueError(f"Unknown scheduler type: {scheduler_type}. " + f"Choose from: constant, linear, cosine, exponential, step") diff --git a/Reward_sdxl_idealized/models/__init__.py b/Reward_sdxl_idealized/models/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..9817f0ee0fcc7a28f33bb5ec1b0fd210dcc89032 --- /dev/null +++ b/Reward_sdxl_idealized/models/__init__.py @@ -0,0 +1,3 @@ +from .reward_model import LRMRewardModelXL + +__all__ = ['LRMRewardModelXL'] diff --git a/Reward_sdxl_idealized/models/__pycache__/reward_model.cpython-310.pyc b/Reward_sdxl_idealized/models/__pycache__/reward_model.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..7b7b059efd36d25eedc025da3bec6525fa9b63de Binary files /dev/null and b/Reward_sdxl_idealized/models/__pycache__/reward_model.cpython-310.pyc differ diff --git a/Reward_sdxl_idealized/models/__pycache__/reward_model.cpython-313.pyc b/Reward_sdxl_idealized/models/__pycache__/reward_model.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a552e4b0a317cfb3572192ecc29fdf5be468de5f Binary files /dev/null and b/Reward_sdxl_idealized/models/__pycache__/reward_model.cpython-313.pyc differ diff --git a/Reward_sdxl_idealized/models/__pycache__/unet_2d_condition_reward.cpython-313.pyc b/Reward_sdxl_idealized/models/__pycache__/unet_2d_condition_reward.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..baf2b81fa03ae91a714d479165799b20ba00f7de Binary files /dev/null and b/Reward_sdxl_idealized/models/__pycache__/unet_2d_condition_reward.cpython-313.pyc differ diff --git a/Reward_sdxl_idealized/models/unet_2d_condition_reward.py b/Reward_sdxl_idealized/models/unet_2d_condition_reward.py new file mode 100644 index 0000000000000000000000000000000000000000..4ebb7f43a80173cadc89ad281c9391a25bfb1aef --- /dev/null +++ b/Reward_sdxl_idealized/models/unet_2d_condition_reward.py @@ -0,0 +1,1334 @@ +# Copyright 2024 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 dataclasses import dataclass +from typing import Any, Dict, List, Optional, Tuple, Union + +import torch +import torch.nn as nn +import torch.utils.checkpoint + +from diffusers.configuration_utils import ConfigMixin, register_to_config +from diffusers.loaders import PeftAdapterMixin, UNet2DConditionLoadersMixin +from diffusers.loaders.single_file_model import FromOriginalModelMixin +from diffusers.utils import USE_PEFT_BACKEND, BaseOutput, deprecate, logging, scale_lora_layers, unscale_lora_layers +from diffusers.models.activations import get_activation +from diffusers.models.attention_processor import ( + ADDED_KV_ATTENTION_PROCESSORS, + CROSS_ATTENTION_PROCESSORS, + Attention, + AttentionProcessor, + AttnAddedKVProcessor, + AttnProcessor, + FusedAttnProcessor2_0, +) +from diffusers.models.embeddings import ( + GaussianFourierProjection, + GLIGENTextBoundingboxProjection, + ImageHintTimeEmbedding, + ImageProjection, + ImageTimeEmbedding, + TextImageProjection, + TextImageTimeEmbedding, + TextTimeEmbedding, + TimestepEmbedding, + Timesteps, +) +from diffusers.models.modeling_utils import ModelMixin +from diffusers.models.unets.unet_2d_blocks import ( + get_down_block, + get_mid_block, + get_up_block, +) + + +logger = logging.get_logger(__name__) # pylint: disable=invalid-name + + +@dataclass +class UNet2DConditionOutput(BaseOutput): + """ + The output of [`UNet2DConditionModel`]. + + Args: + sample (`torch.Tensor` of shape `(batch_size, num_channels, height, width)`): + The hidden states output conditioned on `encoder_hidden_states` input. Output of last layer of model. + """ + + sample: torch.Tensor = None + + +class UNet2DConditionModel( + ModelMixin, ConfigMixin, FromOriginalModelMixin, UNet2DConditionLoadersMixin, PeftAdapterMixin +): + r""" + A conditional 2D UNet model that takes a noisy sample, conditional state, and a timestep and returns a sample + shaped output. + + This model inherits from [`ModelMixin`]. Check the superclass documentation for it's generic methods implemented + for all models (such as downloading or saving). + + Parameters: + sample_size (`int` or `Tuple[int, int]`, *optional*, defaults to `None`): + Height and width of input/output sample. + in_channels (`int`, *optional*, defaults to 4): Number of channels in the input sample. + out_channels (`int`, *optional*, defaults to 4): Number of channels in the output. + center_input_sample (`bool`, *optional*, defaults to `False`): Whether to center the input sample. + flip_sin_to_cos (`bool`, *optional*, defaults to `True`): + Whether to flip the sin to cos in the time embedding. + freq_shift (`int`, *optional*, defaults to 0): The frequency shift to apply to the time embedding. + down_block_types (`Tuple[str]`, *optional*, defaults to `("CrossAttnDownBlock2D", "CrossAttnDownBlock2D", "CrossAttnDownBlock2D", "DownBlock2D")`): + The tuple of downsample blocks to use. + mid_block_type (`str`, *optional*, defaults to `"UNetMidBlock2DCrossAttn"`): + Block type for middle of UNet, it can be one of `UNetMidBlock2DCrossAttn`, `UNetMidBlock2D`, or + `UNetMidBlock2DSimpleCrossAttn`. If `None`, the mid block layer is skipped. + up_block_types (`Tuple[str]`, *optional*, defaults to `("UpBlock2D", "CrossAttnUpBlock2D", "CrossAttnUpBlock2D", "CrossAttnUpBlock2D")`): + The tuple of upsample blocks to use. + only_cross_attention(`bool` or `Tuple[bool]`, *optional*, default to `False`): + Whether to include self-attention in the basic transformer blocks, see + [`~models.attention.BasicTransformerBlock`]. + block_out_channels (`Tuple[int]`, *optional*, defaults to `(320, 640, 1280, 1280)`): + The tuple of output channels for each block. + layers_per_block (`int`, *optional*, defaults to 2): The number of layers per block. + downsample_padding (`int`, *optional*, defaults to 1): The padding to use for the downsampling convolution. + mid_block_scale_factor (`float`, *optional*, defaults to 1.0): The scale factor to use for the mid block. + dropout (`float`, *optional*, defaults to 0.0): The dropout probability to use. + act_fn (`str`, *optional*, defaults to `"silu"`): The activation function to use. + norm_num_groups (`int`, *optional*, defaults to 32): The number of groups to use for the normalization. + If `None`, normalization and activation layers is skipped in post-processing. + norm_eps (`float`, *optional*, defaults to 1e-5): The epsilon to use for the normalization. + cross_attention_dim (`int` or `Tuple[int]`, *optional*, defaults to 1280): + The dimension of the cross attention features. + transformer_layers_per_block (`int`, `Tuple[int]`, or `Tuple[Tuple]` , *optional*, defaults to 1): + The number of transformer blocks of type [`~models.attention.BasicTransformerBlock`]. Only relevant for + [`~models.unets.unet_2d_blocks.CrossAttnDownBlock2D`], [`~models.unets.unet_2d_blocks.CrossAttnUpBlock2D`], + [`~models.unets.unet_2d_blocks.UNetMidBlock2DCrossAttn`]. + reverse_transformer_layers_per_block : (`Tuple[Tuple]`, *optional*, defaults to None): + The number of transformer blocks of type [`~models.attention.BasicTransformerBlock`], in the upsampling + blocks of the U-Net. Only relevant if `transformer_layers_per_block` is of type `Tuple[Tuple]` and for + [`~models.unets.unet_2d_blocks.CrossAttnDownBlock2D`], [`~models.unets.unet_2d_blocks.CrossAttnUpBlock2D`], + [`~models.unets.unet_2d_blocks.UNetMidBlock2DCrossAttn`]. + encoder_hid_dim (`int`, *optional*, defaults to None): + If `encoder_hid_dim_type` is defined, `encoder_hidden_states` will be projected from `encoder_hid_dim` + dimension to `cross_attention_dim`. + encoder_hid_dim_type (`str`, *optional*, defaults to `None`): + If given, the `encoder_hidden_states` and potentially other embeddings are down-projected to text + embeddings of dimension `cross_attention` according to `encoder_hid_dim_type`. + attention_head_dim (`int`, *optional*, defaults to 8): The dimension of the attention heads. + num_attention_heads (`int`, *optional*): + The number of attention heads. If not defined, defaults to `attention_head_dim` + resnet_time_scale_shift (`str`, *optional*, defaults to `"default"`): Time scale shift config + for ResNet blocks (see [`~models.resnet.ResnetBlock2D`]). Choose from `default` or `scale_shift`. + class_embed_type (`str`, *optional*, defaults to `None`): + The type of class embedding to use which is ultimately summed with the time embeddings. Choose from `None`, + `"timestep"`, `"identity"`, `"projection"`, or `"simple_projection"`. + addition_embed_type (`str`, *optional*, defaults to `None`): + Configures an optional embedding which will be summed with the time embeddings. Choose from `None` or + "text". "text" will use the `TextTimeEmbedding` layer. + addition_time_embed_dim: (`int`, *optional*, defaults to `None`): + Dimension for the timestep embeddings. + num_class_embeds (`int`, *optional*, defaults to `None`): + Input dimension of the learnable embedding matrix to be projected to `time_embed_dim`, when performing + class conditioning with `class_embed_type` equal to `None`. + time_embedding_type (`str`, *optional*, defaults to `positional`): + The type of position embedding to use for timesteps. Choose from `positional` or `fourier`. + time_embedding_dim (`int`, *optional*, defaults to `None`): + An optional override for the dimension of the projected time embedding. + time_embedding_act_fn (`str`, *optional*, defaults to `None`): + Optional activation function to use only once on the time embeddings before they are passed to the rest of + the UNet. Choose from `silu`, `mish`, `gelu`, and `swish`. + timestep_post_act (`str`, *optional*, defaults to `None`): + The second activation function to use in timestep embedding. Choose from `silu`, `mish` and `gelu`. + time_cond_proj_dim (`int`, *optional*, defaults to `None`): + The dimension of `cond_proj` layer in the timestep embedding. + conv_in_kernel (`int`, *optional*, default to `3`): The kernel size of `conv_in` layer. + conv_out_kernel (`int`, *optional*, default to `3`): The kernel size of `conv_out` layer. + projection_class_embeddings_input_dim (`int`, *optional*): The dimension of the `class_labels` input when + `class_embed_type="projection"`. Required when `class_embed_type="projection"`. + class_embeddings_concat (`bool`, *optional*, defaults to `False`): Whether to concatenate the time + embeddings with the class embeddings. + mid_block_only_cross_attention (`bool`, *optional*, defaults to `None`): + Whether to use cross attention with the mid block when using the `UNetMidBlock2DSimpleCrossAttn`. If + `only_cross_attention` is given as a single boolean and `mid_block_only_cross_attention` is `None`, the + `only_cross_attention` value is used as the value for `mid_block_only_cross_attention`. Default to `False` + otherwise. + """ + + _supports_gradient_checkpointing = True + _no_split_modules = ["BasicTransformerBlock", "ResnetBlock2D", "CrossAttnUpBlock2D"] + + @register_to_config + def __init__( + self, + sample_size: Optional[int] = None, + in_channels: int = 4, + out_channels: int = 4, + center_input_sample: bool = False, + flip_sin_to_cos: bool = True, + freq_shift: int = 0, + down_block_types: Tuple[str] = ( + "CrossAttnDownBlock2D", + "CrossAttnDownBlock2D", + "CrossAttnDownBlock2D", + "DownBlock2D", + ), + mid_block_type: Optional[str] = "UNetMidBlock2DCrossAttn", + up_block_types: Tuple[str] = ("UpBlock2D", "CrossAttnUpBlock2D", "CrossAttnUpBlock2D", "CrossAttnUpBlock2D"), + only_cross_attention: Union[bool, Tuple[bool]] = False, + block_out_channels: Tuple[int] = (320, 640, 1280, 1280), + layers_per_block: Union[int, Tuple[int]] = 2, + downsample_padding: int = 1, + mid_block_scale_factor: float = 1, + dropout: float = 0.0, + act_fn: str = "silu", + norm_num_groups: Optional[int] = 32, + norm_eps: float = 1e-5, + cross_attention_dim: Union[int, Tuple[int]] = 1280, + transformer_layers_per_block: Union[int, Tuple[int], Tuple[Tuple]] = 1, + reverse_transformer_layers_per_block: Optional[Tuple[Tuple[int]]] = None, + encoder_hid_dim: Optional[int] = None, + encoder_hid_dim_type: Optional[str] = None, + attention_head_dim: Union[int, Tuple[int]] = 8, + num_attention_heads: Optional[Union[int, Tuple[int]]] = None, + dual_cross_attention: bool = False, + use_linear_projection: bool = False, + class_embed_type: Optional[str] = None, + addition_embed_type: Optional[str] = None, + addition_time_embed_dim: Optional[int] = None, + num_class_embeds: Optional[int] = None, + upcast_attention: bool = False, + resnet_time_scale_shift: str = "default", + resnet_skip_time_act: bool = False, + resnet_out_scale_factor: float = 1.0, + time_embedding_type: str = "positional", + time_embedding_dim: Optional[int] = None, + time_embedding_act_fn: Optional[str] = None, + timestep_post_act: Optional[str] = None, + time_cond_proj_dim: Optional[int] = None, + conv_in_kernel: int = 3, + conv_out_kernel: int = 3, + projection_class_embeddings_input_dim: Optional[int] = None, + attention_type: str = "default", + class_embeddings_concat: bool = False, + mid_block_only_cross_attention: Optional[bool] = None, + cross_attention_norm: Optional[str] = None, + addition_embed_type_num_heads: int = 64, + ): + super().__init__() + + self.sample_size = sample_size + + if num_attention_heads is not None: + raise ValueError( + "At the moment it is not possible to define the number of attention heads via `num_attention_heads` because of a naming issue as described in https://github.com/huggingface/diffusers/issues/2011#issuecomment-1547958131. Passing `num_attention_heads` will only be supported in diffusers v0.19." + ) + + # If `num_attention_heads` is not defined (which is the case for most models) + # it will default to `attention_head_dim`. This looks weird upon first reading it and it is. + # The reason for this behavior is to correct for incorrectly named variables that were introduced + # when this library was created. The incorrect naming was only discovered much later in https://github.com/huggingface/diffusers/issues/2011#issuecomment-1547958131 + # Changing `attention_head_dim` to `num_attention_heads` for 40,000+ configurations is too backwards breaking + # which is why we correct for the naming here. + num_attention_heads = num_attention_heads or attention_head_dim + + # Check inputs + self._check_config( + down_block_types=down_block_types, + up_block_types=up_block_types, + only_cross_attention=only_cross_attention, + block_out_channels=block_out_channels, + layers_per_block=layers_per_block, + cross_attention_dim=cross_attention_dim, + transformer_layers_per_block=transformer_layers_per_block, + reverse_transformer_layers_per_block=reverse_transformer_layers_per_block, + attention_head_dim=attention_head_dim, + num_attention_heads=num_attention_heads, + ) + + # input + conv_in_padding = (conv_in_kernel - 1) // 2 + self.conv_in = nn.Conv2d( + in_channels, block_out_channels[0], kernel_size=conv_in_kernel, padding=conv_in_padding + ) + + # time + time_embed_dim, timestep_input_dim = self._set_time_proj( + time_embedding_type, + block_out_channels=block_out_channels, + flip_sin_to_cos=flip_sin_to_cos, + freq_shift=freq_shift, + time_embedding_dim=time_embedding_dim, + ) + + self.time_embedding = TimestepEmbedding( + timestep_input_dim, + time_embed_dim, + act_fn=act_fn, + post_act_fn=timestep_post_act, + cond_proj_dim=time_cond_proj_dim, + ) + + self._set_encoder_hid_proj( + encoder_hid_dim_type, + cross_attention_dim=cross_attention_dim, + encoder_hid_dim=encoder_hid_dim, + ) + + # class embedding + self._set_class_embedding( + class_embed_type, + act_fn=act_fn, + num_class_embeds=num_class_embeds, + projection_class_embeddings_input_dim=projection_class_embeddings_input_dim, + time_embed_dim=time_embed_dim, + timestep_input_dim=timestep_input_dim, + ) + + self._set_add_embedding( + addition_embed_type, + addition_embed_type_num_heads=addition_embed_type_num_heads, + addition_time_embed_dim=addition_time_embed_dim, + cross_attention_dim=cross_attention_dim, + encoder_hid_dim=encoder_hid_dim, + flip_sin_to_cos=flip_sin_to_cos, + freq_shift=freq_shift, + projection_class_embeddings_input_dim=projection_class_embeddings_input_dim, + time_embed_dim=time_embed_dim, + ) + + if time_embedding_act_fn is None: + self.time_embed_act = None + else: + self.time_embed_act = get_activation(time_embedding_act_fn) + + self.down_blocks = nn.ModuleList([]) + self.up_blocks = nn.ModuleList([]) + + if isinstance(only_cross_attention, bool): + if mid_block_only_cross_attention is None: + mid_block_only_cross_attention = only_cross_attention + + only_cross_attention = [only_cross_attention] * len(down_block_types) + + if mid_block_only_cross_attention is None: + mid_block_only_cross_attention = False + + if isinstance(num_attention_heads, int): + num_attention_heads = (num_attention_heads,) * len(down_block_types) + + if isinstance(attention_head_dim, int): + attention_head_dim = (attention_head_dim,) * len(down_block_types) + + if isinstance(cross_attention_dim, int): + cross_attention_dim = (cross_attention_dim,) * len(down_block_types) + + if isinstance(layers_per_block, int): + layers_per_block = [layers_per_block] * len(down_block_types) + + if isinstance(transformer_layers_per_block, int): + transformer_layers_per_block = [transformer_layers_per_block] * len(down_block_types) + + if class_embeddings_concat: + # The time embeddings are concatenated with the class embeddings. The dimension of the + # time embeddings passed to the down, middle, and up blocks is twice the dimension of the + # regular time embeddings + blocks_time_embed_dim = time_embed_dim * 2 + else: + blocks_time_embed_dim = time_embed_dim + + # down + output_channel = block_out_channels[0] + for i, down_block_type in enumerate(down_block_types): + input_channel = output_channel + output_channel = block_out_channels[i] + is_final_block = i == len(block_out_channels) - 1 + + down_block = get_down_block( + down_block_type, + num_layers=layers_per_block[i], + transformer_layers_per_block=transformer_layers_per_block[i], + in_channels=input_channel, + out_channels=output_channel, + temb_channels=blocks_time_embed_dim, + add_downsample=not is_final_block, + resnet_eps=norm_eps, + resnet_act_fn=act_fn, + resnet_groups=norm_num_groups, + cross_attention_dim=cross_attention_dim[i], + num_attention_heads=num_attention_heads[i], + downsample_padding=downsample_padding, + dual_cross_attention=dual_cross_attention, + use_linear_projection=use_linear_projection, + only_cross_attention=only_cross_attention[i], + upcast_attention=upcast_attention, + resnet_time_scale_shift=resnet_time_scale_shift, + attention_type=attention_type, + resnet_skip_time_act=resnet_skip_time_act, + resnet_out_scale_factor=resnet_out_scale_factor, + cross_attention_norm=cross_attention_norm, + attention_head_dim=attention_head_dim[i] if attention_head_dim[i] is not None else output_channel, + dropout=dropout, + ) + self.down_blocks.append(down_block) + + # mid + self.mid_block = get_mid_block( + mid_block_type, + temb_channels=blocks_time_embed_dim, + in_channels=block_out_channels[-1], + resnet_eps=norm_eps, + resnet_act_fn=act_fn, + resnet_groups=norm_num_groups, + output_scale_factor=mid_block_scale_factor, + transformer_layers_per_block=transformer_layers_per_block[-1], + num_attention_heads=num_attention_heads[-1], + cross_attention_dim=cross_attention_dim[-1], + dual_cross_attention=dual_cross_attention, + use_linear_projection=use_linear_projection, + mid_block_only_cross_attention=mid_block_only_cross_attention, + upcast_attention=upcast_attention, + resnet_time_scale_shift=resnet_time_scale_shift, + attention_type=attention_type, + resnet_skip_time_act=resnet_skip_time_act, + cross_attention_norm=cross_attention_norm, + attention_head_dim=attention_head_dim[-1], + dropout=dropout, + ) + + # count how many layers upsample the images + self.num_upsamplers = 0 + + # up + reversed_block_out_channels = list(reversed(block_out_channels)) + reversed_num_attention_heads = list(reversed(num_attention_heads)) + reversed_layers_per_block = list(reversed(layers_per_block)) + reversed_cross_attention_dim = list(reversed(cross_attention_dim)) + reversed_transformer_layers_per_block = ( + list(reversed(transformer_layers_per_block)) + if reverse_transformer_layers_per_block is None + else reverse_transformer_layers_per_block + ) + only_cross_attention = list(reversed(only_cross_attention)) + + output_channel = reversed_block_out_channels[0] + for i, up_block_type in enumerate(up_block_types): + is_final_block = i == len(block_out_channels) - 1 + + prev_output_channel = output_channel + output_channel = reversed_block_out_channels[i] + input_channel = reversed_block_out_channels[min(i + 1, len(block_out_channels) - 1)] + + # add upsample block for all BUT final layer + if not is_final_block: + add_upsample = True + self.num_upsamplers += 1 + else: + add_upsample = False + + up_block = get_up_block( + up_block_type, + num_layers=reversed_layers_per_block[i] + 1, + transformer_layers_per_block=reversed_transformer_layers_per_block[i], + in_channels=input_channel, + out_channels=output_channel, + prev_output_channel=prev_output_channel, + temb_channels=blocks_time_embed_dim, + add_upsample=add_upsample, + resnet_eps=norm_eps, + resnet_act_fn=act_fn, + resolution_idx=i, + resnet_groups=norm_num_groups, + cross_attention_dim=reversed_cross_attention_dim[i], + num_attention_heads=reversed_num_attention_heads[i], + dual_cross_attention=dual_cross_attention, + use_linear_projection=use_linear_projection, + only_cross_attention=only_cross_attention[i], + upcast_attention=upcast_attention, + resnet_time_scale_shift=resnet_time_scale_shift, + attention_type=attention_type, + resnet_skip_time_act=resnet_skip_time_act, + resnet_out_scale_factor=resnet_out_scale_factor, + cross_attention_norm=cross_attention_norm, + attention_head_dim=attention_head_dim[i] if attention_head_dim[i] is not None else output_channel, + dropout=dropout, + ) + self.up_blocks.append(up_block) + prev_output_channel = output_channel + + # out + if norm_num_groups is not None: + self.conv_norm_out = nn.GroupNorm( + num_channels=block_out_channels[0], num_groups=norm_num_groups, eps=norm_eps + ) + + self.conv_act = get_activation(act_fn) + + else: + self.conv_norm_out = None + self.conv_act = None + + conv_out_padding = (conv_out_kernel - 1) // 2 + self.conv_out = nn.Conv2d( + block_out_channels[0], out_channels, kernel_size=conv_out_kernel, padding=conv_out_padding + ) + + self._set_pos_net_if_use_gligen(attention_type=attention_type, cross_attention_dim=cross_attention_dim) + + def _check_config( + self, + down_block_types: Tuple[str], + up_block_types: Tuple[str], + only_cross_attention: Union[bool, Tuple[bool]], + block_out_channels: Tuple[int], + layers_per_block: Union[int, Tuple[int]], + cross_attention_dim: Union[int, Tuple[int]], + transformer_layers_per_block: Union[int, Tuple[int], Tuple[Tuple[int]]], + reverse_transformer_layers_per_block: bool, + attention_head_dim: int, + num_attention_heads: Optional[Union[int, Tuple[int]]], + ): + if len(down_block_types) != len(up_block_types): + raise ValueError( + f"Must provide the same number of `down_block_types` as `up_block_types`. `down_block_types`: {down_block_types}. `up_block_types`: {up_block_types}." + ) + + if len(block_out_channels) != len(down_block_types): + raise ValueError( + f"Must provide the same number of `block_out_channels` as `down_block_types`. `block_out_channels`: {block_out_channels}. `down_block_types`: {down_block_types}." + ) + + if not isinstance(only_cross_attention, bool) and len(only_cross_attention) != len(down_block_types): + raise ValueError( + f"Must provide the same number of `only_cross_attention` as `down_block_types`. `only_cross_attention`: {only_cross_attention}. `down_block_types`: {down_block_types}." + ) + + if not isinstance(num_attention_heads, int) and len(num_attention_heads) != len(down_block_types): + raise ValueError( + f"Must provide the same number of `num_attention_heads` as `down_block_types`. `num_attention_heads`: {num_attention_heads}. `down_block_types`: {down_block_types}." + ) + + if not isinstance(attention_head_dim, int) and len(attention_head_dim) != len(down_block_types): + raise ValueError( + f"Must provide the same number of `attention_head_dim` as `down_block_types`. `attention_head_dim`: {attention_head_dim}. `down_block_types`: {down_block_types}." + ) + + if isinstance(cross_attention_dim, list) and len(cross_attention_dim) != len(down_block_types): + raise ValueError( + f"Must provide the same number of `cross_attention_dim` as `down_block_types`. `cross_attention_dim`: {cross_attention_dim}. `down_block_types`: {down_block_types}." + ) + + if not isinstance(layers_per_block, int) and len(layers_per_block) != len(down_block_types): + raise ValueError( + f"Must provide the same number of `layers_per_block` as `down_block_types`. `layers_per_block`: {layers_per_block}. `down_block_types`: {down_block_types}." + ) + if isinstance(transformer_layers_per_block, list) and reverse_transformer_layers_per_block is None: + for layer_number_per_block in transformer_layers_per_block: + if isinstance(layer_number_per_block, list): + raise ValueError("Must provide 'reverse_transformer_layers_per_block` if using asymmetrical UNet.") + + def _set_time_proj( + self, + time_embedding_type: str, + block_out_channels: int, + flip_sin_to_cos: bool, + freq_shift: float, + time_embedding_dim: int, + ) -> Tuple[int, int]: + if time_embedding_type == "fourier": + time_embed_dim = time_embedding_dim or block_out_channels[0] * 2 + if time_embed_dim % 2 != 0: + raise ValueError(f"`time_embed_dim` should be divisible by 2, but is {time_embed_dim}.") + self.time_proj = GaussianFourierProjection( + time_embed_dim // 2, set_W_to_weight=False, log=False, flip_sin_to_cos=flip_sin_to_cos + ) + timestep_input_dim = time_embed_dim + elif time_embedding_type == "positional": + time_embed_dim = time_embedding_dim or block_out_channels[0] * 4 + + self.time_proj = Timesteps(block_out_channels[0], flip_sin_to_cos, freq_shift) + timestep_input_dim = block_out_channels[0] + else: + raise ValueError( + f"{time_embedding_type} does not exist. Please make sure to use one of `fourier` or `positional`." + ) + + return time_embed_dim, timestep_input_dim + + def _set_encoder_hid_proj( + self, + encoder_hid_dim_type: Optional[str], + cross_attention_dim: Union[int, Tuple[int]], + encoder_hid_dim: Optional[int], + ): + if encoder_hid_dim_type is None and encoder_hid_dim is not None: + encoder_hid_dim_type = "text_proj" + self.register_to_config(encoder_hid_dim_type=encoder_hid_dim_type) + logger.info("encoder_hid_dim_type defaults to 'text_proj' as `encoder_hid_dim` is defined.") + + if encoder_hid_dim is None and encoder_hid_dim_type is not None: + raise ValueError( + f"`encoder_hid_dim` has to be defined when `encoder_hid_dim_type` is set to {encoder_hid_dim_type}." + ) + + if encoder_hid_dim_type == "text_proj": + self.encoder_hid_proj = nn.Linear(encoder_hid_dim, cross_attention_dim) + elif encoder_hid_dim_type == "text_image_proj": + # image_embed_dim DOESN'T have to be `cross_attention_dim`. To not clutter the __init__ too much + # they are set to `cross_attention_dim` here as this is exactly the required dimension for the currently only use + # case when `addition_embed_type == "text_image_proj"` (Kandinsky 2.1)` + self.encoder_hid_proj = TextImageProjection( + text_embed_dim=encoder_hid_dim, + image_embed_dim=cross_attention_dim, + cross_attention_dim=cross_attention_dim, + ) + elif encoder_hid_dim_type == "image_proj": + # Kandinsky 2.2 + self.encoder_hid_proj = ImageProjection( + image_embed_dim=encoder_hid_dim, + cross_attention_dim=cross_attention_dim, + ) + elif encoder_hid_dim_type is not None: + raise ValueError( + f"encoder_hid_dim_type: {encoder_hid_dim_type} must be None, 'text_proj' or 'text_image_proj'." + ) + else: + self.encoder_hid_proj = None + + def _set_class_embedding( + self, + class_embed_type: Optional[str], + act_fn: str, + num_class_embeds: Optional[int], + projection_class_embeddings_input_dim: Optional[int], + time_embed_dim: int, + timestep_input_dim: int, + ): + if class_embed_type is None and num_class_embeds is not None: + self.class_embedding = nn.Embedding(num_class_embeds, time_embed_dim) + elif class_embed_type == "timestep": + self.class_embedding = TimestepEmbedding(timestep_input_dim, time_embed_dim, act_fn=act_fn) + elif class_embed_type == "identity": + self.class_embedding = nn.Identity(time_embed_dim, time_embed_dim) + elif class_embed_type == "projection": + if projection_class_embeddings_input_dim is None: + raise ValueError( + "`class_embed_type`: 'projection' requires `projection_class_embeddings_input_dim` be set" + ) + # The projection `class_embed_type` is the same as the timestep `class_embed_type` except + # 1. the `class_labels` inputs are not first converted to sinusoidal embeddings + # 2. it projects from an arbitrary input dimension. + # + # Note that `TimestepEmbedding` is quite general, being mainly linear layers and activations. + # When used for embedding actual timesteps, the timesteps are first converted to sinusoidal embeddings. + # As a result, `TimestepEmbedding` can be passed arbitrary vectors. + self.class_embedding = TimestepEmbedding(projection_class_embeddings_input_dim, time_embed_dim) + elif class_embed_type == "simple_projection": + if projection_class_embeddings_input_dim is None: + raise ValueError( + "`class_embed_type`: 'simple_projection' requires `projection_class_embeddings_input_dim` be set" + ) + self.class_embedding = nn.Linear(projection_class_embeddings_input_dim, time_embed_dim) + else: + self.class_embedding = None + + def _set_add_embedding( + self, + addition_embed_type: str, + addition_embed_type_num_heads: int, + addition_time_embed_dim: Optional[int], + flip_sin_to_cos: bool, + freq_shift: float, + cross_attention_dim: Optional[int], + encoder_hid_dim: Optional[int], + projection_class_embeddings_input_dim: Optional[int], + time_embed_dim: int, + ): + if addition_embed_type == "text": + if encoder_hid_dim is not None: + text_time_embedding_from_dim = encoder_hid_dim + else: + text_time_embedding_from_dim = cross_attention_dim + + self.add_embedding = TextTimeEmbedding( + text_time_embedding_from_dim, time_embed_dim, num_heads=addition_embed_type_num_heads + ) + elif addition_embed_type == "text_image": + # text_embed_dim and image_embed_dim DON'T have to be `cross_attention_dim`. To not clutter the __init__ too much + # they are set to `cross_attention_dim` here as this is exactly the required dimension for the currently only use + # case when `addition_embed_type == "text_image"` (Kandinsky 2.1)` + self.add_embedding = TextImageTimeEmbedding( + text_embed_dim=cross_attention_dim, image_embed_dim=cross_attention_dim, time_embed_dim=time_embed_dim + ) + elif addition_embed_type == "text_time": + self.add_time_proj = Timesteps(addition_time_embed_dim, flip_sin_to_cos, freq_shift) + self.add_embedding = TimestepEmbedding(projection_class_embeddings_input_dim, time_embed_dim) + elif addition_embed_type == "image": + # Kandinsky 2.2 + self.add_embedding = ImageTimeEmbedding(image_embed_dim=encoder_hid_dim, time_embed_dim=time_embed_dim) + elif addition_embed_type == "image_hint": + # Kandinsky 2.2 ControlNet + self.add_embedding = ImageHintTimeEmbedding(image_embed_dim=encoder_hid_dim, time_embed_dim=time_embed_dim) + elif addition_embed_type is not None: + raise ValueError(f"addition_embed_type: {addition_embed_type} must be None, 'text' or 'text_image'.") + + def _set_pos_net_if_use_gligen(self, attention_type: str, cross_attention_dim: int): + if attention_type in ["gated", "gated-text-image"]: + positive_len = 768 + if isinstance(cross_attention_dim, int): + positive_len = cross_attention_dim + elif isinstance(cross_attention_dim, (list, tuple)): + positive_len = cross_attention_dim[0] + + feature_type = "text-only" if attention_type == "gated" else "text-image" + self.position_net = GLIGENTextBoundingboxProjection( + positive_len=positive_len, out_dim=cross_attention_dim, feature_type=feature_type + ) + + @property + def attn_processors(self) -> Dict[str, AttentionProcessor]: + r""" + Returns: + `dict` of attention processors: A dictionary containing all attention processors used in the model with + indexed by its weight name. + """ + # set recursively + processors = {} + + def fn_recursive_add_processors(name: str, module: torch.nn.Module, processors: Dict[str, AttentionProcessor]): + if hasattr(module, "get_processor"): + processors[f"{name}.processor"] = module.get_processor() + + for sub_name, child in module.named_children(): + fn_recursive_add_processors(f"{name}.{sub_name}", child, processors) + + return processors + + for name, module in self.named_children(): + fn_recursive_add_processors(name, module, processors) + + return processors + + def set_attn_processor(self, processor: Union[AttentionProcessor, Dict[str, AttentionProcessor]]): + r""" + Sets the attention processor to use to compute attention. + + Parameters: + processor (`dict` of `AttentionProcessor` or only `AttentionProcessor`): + The instantiated processor class or a dictionary of processor classes that will be set as the processor + for **all** `Attention` layers. + + If `processor` is a dict, the key needs to define the path to the corresponding cross attention + processor. This is strongly recommended when setting trainable attention processors. + + """ + count = len(self.attn_processors.keys()) + + if isinstance(processor, dict) and len(processor) != count: + raise ValueError( + f"A dict of processors was passed, but the number of processors {len(processor)} does not match the" + f" number of attention layers: {count}. Please make sure to pass {count} processor classes." + ) + + def fn_recursive_attn_processor(name: str, module: torch.nn.Module, processor): + if hasattr(module, "set_processor"): + if not isinstance(processor, dict): + module.set_processor(processor) + else: + module.set_processor(processor.pop(f"{name}.processor")) + + for sub_name, child in module.named_children(): + fn_recursive_attn_processor(f"{name}.{sub_name}", child, processor) + + for name, module in self.named_children(): + fn_recursive_attn_processor(name, module, processor) + + def set_default_attn_processor(self): + """ + Disables custom attention processors and sets the default attention implementation. + """ + if all(proc.__class__ in ADDED_KV_ATTENTION_PROCESSORS for proc in self.attn_processors.values()): + processor = AttnAddedKVProcessor() + elif all(proc.__class__ in CROSS_ATTENTION_PROCESSORS for proc in self.attn_processors.values()): + processor = AttnProcessor() + else: + raise ValueError( + f"Cannot call `set_default_attn_processor` when attention processors are of type {next(iter(self.attn_processors.values()))}" + ) + + self.set_attn_processor(processor) + + def set_attention_slice(self, slice_size: Union[str, int, List[int]] = "auto"): + r""" + Enable sliced attention computation. + + When this option is enabled, the attention module splits the input tensor in slices to compute attention in + several steps. This is useful for saving some memory in exchange for a small decrease in speed. + + Args: + slice_size (`str` or `int` or `list(int)`, *optional*, defaults to `"auto"`): + When `"auto"`, input to the attention heads is halved, so attention is computed in two steps. If + `"max"`, maximum amount of memory is saved by running only one slice at a time. If a number is + provided, uses as many slices as `attention_head_dim // slice_size`. In this case, `attention_head_dim` + must be a multiple of `slice_size`. + """ + sliceable_head_dims = [] + + def fn_recursive_retrieve_sliceable_dims(module: torch.nn.Module): + if hasattr(module, "set_attention_slice"): + sliceable_head_dims.append(module.sliceable_head_dim) + + for child in module.children(): + fn_recursive_retrieve_sliceable_dims(child) + + # retrieve number of attention layers + for module in self.children(): + fn_recursive_retrieve_sliceable_dims(module) + + num_sliceable_layers = len(sliceable_head_dims) + + if slice_size == "auto": + # half the attention head size is usually a good trade-off between + # speed and memory + slice_size = [dim // 2 for dim in sliceable_head_dims] + elif slice_size == "max": + # make smallest slice possible + slice_size = num_sliceable_layers * [1] + + slice_size = num_sliceable_layers * [slice_size] if not isinstance(slice_size, list) else slice_size + + if len(slice_size) != len(sliceable_head_dims): + raise ValueError( + f"You have provided {len(slice_size)}, but {self.config} has {len(sliceable_head_dims)} different" + f" attention layers. Make sure to match `len(slice_size)` to be {len(sliceable_head_dims)}." + ) + + for i in range(len(slice_size)): + size = slice_size[i] + dim = sliceable_head_dims[i] + if size is not None and size > dim: + raise ValueError(f"size {size} has to be smaller or equal to {dim}.") + + # Recursively walk through all the children. + # Any children which exposes the set_attention_slice method + # gets the message + def fn_recursive_set_attention_slice(module: torch.nn.Module, slice_size: List[int]): + if hasattr(module, "set_attention_slice"): + module.set_attention_slice(slice_size.pop()) + + for child in module.children(): + fn_recursive_set_attention_slice(child, slice_size) + + reversed_slice_size = list(reversed(slice_size)) + for module in self.children(): + fn_recursive_set_attention_slice(module, reversed_slice_size) + + def _set_gradient_checkpointing(self, module, value=False): + if hasattr(module, "gradient_checkpointing"): + module.gradient_checkpointing = value + + def enable_freeu(self, s1: float, s2: float, b1: float, b2: float): + r"""Enables the FreeU mechanism from https://arxiv.org/abs/2309.11497. + + The suffixes after the scaling factors represent the stage blocks where they are being applied. + + Please refer to the [official repository](https://github.com/ChenyangSi/FreeU) for combinations of values that + are known to work well for different pipelines such as Stable Diffusion v1, v2, and Stable Diffusion XL. + + Args: + s1 (`float`): + Scaling factor for stage 1 to attenuate the contributions of the skip features. This is done to + mitigate the "oversmoothing effect" in the enhanced denoising process. + s2 (`float`): + Scaling factor for stage 2 to attenuate the contributions of the skip features. This is done to + mitigate the "oversmoothing effect" in the enhanced denoising process. + b1 (`float`): Scaling factor for stage 1 to amplify the contributions of backbone features. + b2 (`float`): Scaling factor for stage 2 to amplify the contributions of backbone features. + """ + for i, upsample_block in enumerate(self.up_blocks): + setattr(upsample_block, "s1", s1) + setattr(upsample_block, "s2", s2) + setattr(upsample_block, "b1", b1) + setattr(upsample_block, "b2", b2) + + def disable_freeu(self): + """Disables the FreeU mechanism.""" + freeu_keys = {"s1", "s2", "b1", "b2"} + for i, upsample_block in enumerate(self.up_blocks): + for k in freeu_keys: + if hasattr(upsample_block, k) or getattr(upsample_block, k, None) is not None: + setattr(upsample_block, k, None) + + def fuse_qkv_projections(self): + """ + Enables fused QKV projections. For self-attention modules, all projection matrices (i.e., query, key, value) + are fused. For cross-attention modules, key and value projection matrices are fused. + + + + This API is ?? experimental. + + + """ + self.original_attn_processors = None + + for _, attn_processor in self.attn_processors.items(): + if "Added" in str(attn_processor.__class__.__name__): + raise ValueError("`fuse_qkv_projections()` is not supported for models having added KV projections.") + + self.original_attn_processors = self.attn_processors + + for module in self.modules(): + if isinstance(module, Attention): + module.fuse_projections(fuse=True) + + self.set_attn_processor(FusedAttnProcessor2_0()) + + def unfuse_qkv_projections(self): + """Disables the fused QKV projection if enabled. + + + + This API is ?? experimental. + + + + """ + if self.original_attn_processors is not None: + self.set_attn_processor(self.original_attn_processors) + + def get_time_embed( + self, sample: torch.Tensor, timestep: Union[torch.Tensor, float, int] + ) -> Optional[torch.Tensor]: + timesteps = timestep + if not torch.is_tensor(timesteps): + # TODO: this requires sync between CPU and GPU. So try to pass timesteps as tensors if you can + # This would be a good case for the `match` statement (Python 3.10+) + is_mps = sample.device.type == "mps" + if isinstance(timestep, float): + dtype = torch.float32 if is_mps else torch.float64 + else: + dtype = torch.int32 if is_mps else torch.int64 + timesteps = torch.tensor([timesteps], dtype=dtype, device=sample.device) + elif len(timesteps.shape) == 0: + timesteps = timesteps[None].to(sample.device) + + # broadcast to batch dimension in a way that's compatible with ONNX/Core ML + timesteps = timesteps.expand(sample.shape[0]) + + t_emb = self.time_proj(timesteps) + # `Timesteps` does not contain any weights and will always return f32 tensors + # but time_embedding might actually be running in fp16. so we need to cast here. + # there might be better ways to encapsulate this. + t_emb = t_emb.to(dtype=sample.dtype) + return t_emb + + def get_class_embed(self, sample: torch.Tensor, class_labels: Optional[torch.Tensor]) -> Optional[torch.Tensor]: + class_emb = None + if self.class_embedding is not None: + if class_labels is None: + raise ValueError("class_labels should be provided when num_class_embeds > 0") + + if self.config.class_embed_type == "timestep": + class_labels = self.time_proj(class_labels) + + # `Timesteps` does not contain any weights and will always return f32 tensors + # there might be better ways to encapsulate this. + class_labels = class_labels.to(dtype=sample.dtype) + + class_emb = self.class_embedding(class_labels).to(dtype=sample.dtype) + return class_emb + + def get_aug_embed( + self, emb: torch.Tensor, encoder_hidden_states: torch.Tensor, added_cond_kwargs: Dict[str, Any] + ) -> Optional[torch.Tensor]: + aug_emb = None + if self.config.addition_embed_type == "text": + aug_emb = self.add_embedding(encoder_hidden_states) + elif self.config.addition_embed_type == "text_image": + # Kandinsky 2.1 - style + if "image_embeds" not in added_cond_kwargs: + raise ValueError( + f"{self.__class__} has the config param `addition_embed_type` set to 'text_image' which requires the keyword argument `image_embeds` to be passed in `added_cond_kwargs`" + ) + + image_embs = added_cond_kwargs.get("image_embeds") + text_embs = added_cond_kwargs.get("text_embeds", encoder_hidden_states) + aug_emb = self.add_embedding(text_embs, image_embs) + elif self.config.addition_embed_type == "text_time": + # SDXL - style + if "text_embeds" not in added_cond_kwargs: + raise ValueError( + f"{self.__class__} has the config param `addition_embed_type` set to 'text_time' which requires the keyword argument `text_embeds` to be passed in `added_cond_kwargs`" + ) + text_embeds = added_cond_kwargs.get("text_embeds") + if "time_ids" not in added_cond_kwargs: + raise ValueError( + f"{self.__class__} has the config param `addition_embed_type` set to 'text_time' which requires the keyword argument `time_ids` to be passed in `added_cond_kwargs`" + ) + time_ids = added_cond_kwargs.get("time_ids") + time_embeds = self.add_time_proj(time_ids.flatten()) + time_embeds = time_embeds.reshape((text_embeds.shape[0], -1)) + add_embeds = torch.concat([text_embeds, time_embeds], dim=-1) + add_embeds = add_embeds.to(emb.dtype) + aug_emb = self.add_embedding(add_embeds) + elif self.config.addition_embed_type == "image": + # Kandinsky 2.2 - style + if "image_embeds" not in added_cond_kwargs: + raise ValueError( + f"{self.__class__} has the config param `addition_embed_type` set to 'image' which requires the keyword argument `image_embeds` to be passed in `added_cond_kwargs`" + ) + image_embs = added_cond_kwargs.get("image_embeds") + aug_emb = self.add_embedding(image_embs) + elif self.config.addition_embed_type == "image_hint": + # Kandinsky 2.2 - style + if "image_embeds" not in added_cond_kwargs or "hint" not in added_cond_kwargs: + raise ValueError( + f"{self.__class__} has the config param `addition_embed_type` set to 'image_hint' which requires the keyword arguments `image_embeds` and `hint` to be passed in `added_cond_kwargs`" + ) + image_embs = added_cond_kwargs.get("image_embeds") + hint = added_cond_kwargs.get("hint") + aug_emb = self.add_embedding(image_embs, hint) + return aug_emb + + def process_encoder_hidden_states( + self, encoder_hidden_states: torch.Tensor, added_cond_kwargs: Dict[str, Any] + ) -> torch.Tensor: + if self.encoder_hid_proj is not None and self.config.encoder_hid_dim_type == "text_proj": + encoder_hidden_states = self.encoder_hid_proj(encoder_hidden_states) + elif self.encoder_hid_proj is not None and self.config.encoder_hid_dim_type == "text_image_proj": + # Kandinsky 2.1 - style + if "image_embeds" not in added_cond_kwargs: + raise ValueError( + f"{self.__class__} has the config param `encoder_hid_dim_type` set to 'text_image_proj' which requires the keyword argument `image_embeds` to be passed in `added_conditions`" + ) + + image_embeds = added_cond_kwargs.get("image_embeds") + encoder_hidden_states = self.encoder_hid_proj(encoder_hidden_states, image_embeds) + elif self.encoder_hid_proj is not None and self.config.encoder_hid_dim_type == "image_proj": + # Kandinsky 2.2 - style + if "image_embeds" not in added_cond_kwargs: + raise ValueError( + f"{self.__class__} has the config param `encoder_hid_dim_type` set to 'image_proj' which requires the keyword argument `image_embeds` to be passed in `added_conditions`" + ) + image_embeds = added_cond_kwargs.get("image_embeds") + encoder_hidden_states = self.encoder_hid_proj(image_embeds) + elif self.encoder_hid_proj is not None and self.config.encoder_hid_dim_type == "ip_image_proj": + if "image_embeds" not in added_cond_kwargs: + raise ValueError( + f"{self.__class__} has the config param `encoder_hid_dim_type` set to 'ip_image_proj' which requires the keyword argument `image_embeds` to be passed in `added_conditions`" + ) + + if hasattr(self, "text_encoder_hid_proj") and self.text_encoder_hid_proj is not None: + encoder_hidden_states = self.text_encoder_hid_proj(encoder_hidden_states) + + image_embeds = added_cond_kwargs.get("image_embeds") + image_embeds = self.encoder_hid_proj(image_embeds) + encoder_hidden_states = (encoder_hidden_states, image_embeds) + return encoder_hidden_states + + def forward( + self, + sample: torch.Tensor, + timestep: Union[torch.Tensor, float, int], + encoder_hidden_states: torch.Tensor, + class_labels: Optional[torch.Tensor] = None, + timestep_cond: Optional[torch.Tensor] = None, + attention_mask: Optional[torch.Tensor] = None, + cross_attention_kwargs: Optional[Dict[str, Any]] = None, + added_cond_kwargs: Optional[Dict[str, torch.Tensor]] = None, + down_block_additional_residuals: Optional[Tuple[torch.Tensor]] = None, + mid_block_additional_residual: Optional[torch.Tensor] = None, + down_intrablock_additional_residuals: Optional[Tuple[torch.Tensor]] = None, + encoder_attention_mask: Optional[torch.Tensor] = None, + use_up_blocks: bool = False, + return_dict: bool = True, + ) -> Union[UNet2DConditionOutput, Tuple]: + r""" + The [`UNet2DConditionModel`] forward method. + + Args: + sample (`torch.Tensor`): + The noisy input tensor with the following shape `(batch, channel, height, width)`. + timestep (`torch.Tensor` or `float` or `int`): The number of timesteps to denoise an input. + encoder_hidden_states (`torch.Tensor`): + The encoder hidden states with shape `(batch, sequence_length, feature_dim)`. + class_labels (`torch.Tensor`, *optional*, defaults to `None`): + Optional class labels for conditioning. Their embeddings will be summed with the timestep embeddings. + timestep_cond: (`torch.Tensor`, *optional*, defaults to `None`): + Conditional embeddings for timestep. If provided, the embeddings will be summed with the samples passed + through the `self.time_embedding` layer to obtain the timestep embeddings. + attention_mask (`torch.Tensor`, *optional*, defaults to `None`): + An attention mask of shape `(batch, key_tokens)` is applied to `encoder_hidden_states`. If `1` the mask + is kept, otherwise if `0` it is discarded. Mask will be converted into a bias, which adds large + negative values to the attention scores corresponding to "discard" tokens. + cross_attention_kwargs (`dict`, *optional*): + A kwargs dictionary that if specified is passed along to the `AttentionProcessor` as defined under + `self.processor` in + [diffusers.models.attention_processor](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py). + added_cond_kwargs: (`dict`, *optional*): + A kwargs dictionary containing additional embeddings that if specified are added to the embeddings that + are passed along to the UNet blocks. + down_block_additional_residuals: (`tuple` of `torch.Tensor`, *optional*): + A tuple of tensors that if specified are added to the residuals of down unet blocks. + mid_block_additional_residual: (`torch.Tensor`, *optional*): + A tensor that if specified is added to the residual of the middle unet block. + down_intrablock_additional_residuals (`tuple` of `torch.Tensor`, *optional*): + additional residuals to be added within UNet down blocks, for example from T2I-Adapter side model(s) + encoder_attention_mask (`torch.Tensor`): + A cross-attention mask of shape `(batch, sequence_length)` is applied to `encoder_hidden_states`. If + `True` the mask is kept, otherwise if `False` it is discarded. Mask will be converted into a bias, + which adds large negative values to the attention scores corresponding to "discard" tokens. + return_dict (`bool`, *optional*, defaults to `True`): + Whether or not to return a [`~models.unets.unet_2d_condition.UNet2DConditionOutput`] instead of a plain + tuple. + + Returns: + [`~models.unets.unet_2d_condition.UNet2DConditionOutput`] or `tuple`: + If `return_dict` is True, an [`~models.unets.unet_2d_condition.UNet2DConditionOutput`] is returned, + otherwise a `tuple` is returned where the first element is the sample tensor. + """ + # By default samples have to be AT least a multiple of the overall upsampling factor. + # The overall upsampling factor is equal to 2 ** (# num of upsampling layers). + # However, the upsampling interpolation output size can be forced to fit any upsampling size + # on the fly if necessary. + default_overall_up_factor = 2**self.num_upsamplers + + # upsample size should be forwarded when sample is not a multiple of `default_overall_up_factor` + forward_upsample_size = False + upsample_size = None + + # import time + # torch.cuda.synchronize() + # start_time = time.time() + + for dim in sample.shape[-2:]: + if dim % default_overall_up_factor != 0: + # Forward upsample size to force interpolation output size. + forward_upsample_size = True + break + + # ensure attention_mask is a bias, and give it a singleton query_tokens dimension + # expects mask of shape: + # [batch, key_tokens] + # adds singleton query_tokens dimension: + # [batch, 1, key_tokens] + # this helps to broadcast it as a bias over attention scores, which will be in one of the following shapes: + # [batch, heads, query_tokens, key_tokens] (e.g. torch sdp attn) + # [batch * heads, query_tokens, key_tokens] (e.g. xformers or classic attn) + if attention_mask is not None: + # assume that mask is expressed as: + # (1 = keep, 0 = discard) + # convert mask into a bias that can be added to attention scores: + # (keep = +0, discard = -10000.0) + attention_mask = (1 - attention_mask.to(sample.dtype)) * -10000.0 + attention_mask = attention_mask.unsqueeze(1) + + # convert encoder_attention_mask to a bias the same way we do for attention_mask + if encoder_attention_mask is not None: + encoder_attention_mask = (1 - encoder_attention_mask.to(sample.dtype)) * -10000.0 + encoder_attention_mask = encoder_attention_mask.unsqueeze(1) + + # 0. center input if necessary + if self.config.center_input_sample: + sample = 2 * sample - 1.0 + + # 1. time + t_emb = self.get_time_embed(sample=sample, timestep=timestep) + emb = self.time_embedding(t_emb, timestep_cond) + aug_emb = None + + class_emb = self.get_class_embed(sample=sample, class_labels=class_labels) + if class_emb is not None: + if self.config.class_embeddings_concat: + emb = torch.cat([emb, class_emb], dim=-1) + else: + emb = emb + class_emb + + aug_emb = self.get_aug_embed( + emb=emb, encoder_hidden_states=encoder_hidden_states, added_cond_kwargs=added_cond_kwargs + ) + if self.config.addition_embed_type == "image_hint": + aug_emb, hint = aug_emb + sample = torch.cat([sample, hint], dim=1) + + emb = emb + aug_emb if aug_emb is not None else emb + + if self.time_embed_act is not None: + emb = self.time_embed_act(emb) + + encoder_hidden_states = self.process_encoder_hidden_states( + encoder_hidden_states=encoder_hidden_states, added_cond_kwargs=added_cond_kwargs + ) + + # 2. pre-process + sample = self.conv_in(sample) + + # 2.5 GLIGEN position net + if cross_attention_kwargs is not None and cross_attention_kwargs.get("gligen", None) is not None: + cross_attention_kwargs = cross_attention_kwargs.copy() + gligen_args = cross_attention_kwargs.pop("gligen") + cross_attention_kwargs["gligen"] = {"objs": self.position_net(**gligen_args)} + + # 3. down + # we're popping the `scale` instead of getting it because otherwise `scale` will be propagated + # to the internal blocks and will raise deprecation warnings. this will be confusing for our users. + if cross_attention_kwargs is not None: + cross_attention_kwargs = cross_attention_kwargs.copy() + lora_scale = cross_attention_kwargs.pop("scale", 1.0) + else: + lora_scale = 1.0 + + if USE_PEFT_BACKEND: + # weight the lora layers by setting `lora_scale` for each PEFT layer + scale_lora_layers(self, lora_scale) + + is_controlnet = mid_block_additional_residual is not None and down_block_additional_residuals is not None + # using new arg down_intrablock_additional_residuals for T2I-Adapters, to distinguish from controlnets + is_adapter = down_intrablock_additional_residuals is not None + # maintain backward compatibility for legacy usage, where + # T2I-Adapter and ControlNet both use down_block_additional_residuals arg + # but can only use one or the other + if not is_adapter and mid_block_additional_residual is None and down_block_additional_residuals is not None: + deprecate( + "T2I should not use down_block_additional_residuals", + "1.3.0", + "Passing intrablock residual connections with `down_block_additional_residuals` is deprecated \ + and will be removed in diffusers 1.3.0. `down_block_additional_residuals` should only be used \ + for ControlNet. Please make sure use `down_intrablock_additional_residuals` instead. ", + standard_warn=False, + ) + down_intrablock_additional_residuals = down_block_additional_residuals + is_adapter = True + + # torch.cuda.synchronize() + # logger.info(f"unet preprocess: {time.time() - start_time}") + + # torch.cuda.synchronize() + # start_time = time.time() + down_block_res_samples = (sample,) + for downsample_block in self.down_blocks: + if hasattr(downsample_block, "has_cross_attention") and downsample_block.has_cross_attention: + # For t2i-adapter CrossAttnDownBlock2D + additional_residuals = {} + if is_adapter and len(down_intrablock_additional_residuals) > 0: + additional_residuals["additional_residuals"] = down_intrablock_additional_residuals.pop(0) + + sample, res_samples = downsample_block( + hidden_states=sample, + temb=emb, + encoder_hidden_states=encoder_hidden_states, + attention_mask=attention_mask, + cross_attention_kwargs=cross_attention_kwargs, + encoder_attention_mask=encoder_attention_mask, + **additional_residuals, + ) + else: + sample, res_samples = downsample_block(hidden_states=sample, temb=emb) + if is_adapter and len(down_intrablock_additional_residuals) > 0: + sample += down_intrablock_additional_residuals.pop(0) + + down_block_res_samples += res_samples + + if is_controlnet: + new_down_block_res_samples = () + + for down_block_res_sample, down_block_additional_residual in zip( + down_block_res_samples, down_block_additional_residuals + ): + down_block_res_sample = down_block_res_sample + down_block_additional_residual + new_down_block_res_samples = new_down_block_res_samples + (down_block_res_sample,) + + down_block_res_samples = new_down_block_res_samples + # torch.cuda.synchronize() + # logger.info(f"unet down time: {time.time() - start_time}") + # torch.cuda.synchronize() + # start_time = time.time() + # 4. mid + if self.mid_block is not None: + if hasattr(self.mid_block, "has_cross_attention") and self.mid_block.has_cross_attention: + sample = self.mid_block( + sample, + emb, + encoder_hidden_states=encoder_hidden_states, + attention_mask=attention_mask, + cross_attention_kwargs=cross_attention_kwargs, + encoder_attention_mask=encoder_attention_mask, + ) + else: + sample = self.mid_block(sample, emb) + + # To support T2I-Adapter-XL + if ( + is_adapter + and len(down_intrablock_additional_residuals) > 0 + and sample.shape == down_intrablock_additional_residuals[0].shape + ): + sample += down_intrablock_additional_residuals.pop(0) + + if is_controlnet: + sample = sample + mid_block_additional_residual + # torch.cuda.synchronize() + # logger.info(f"unet mid time: {time.time() - start_time}") + mid_sample = sample + + if use_up_blocks: + # 5. up + up_block_res_samples = () + for i, upsample_block in enumerate(self.up_blocks): + is_final_block = i == len(self.up_blocks) - 1 + + res_samples = down_block_res_samples[-len(upsample_block.resnets) :] + down_block_res_samples = down_block_res_samples[: -len(upsample_block.resnets)] + + # if we have not reached the final block and need to forward the + # upsample size, we do it here + if not is_final_block and forward_upsample_size: + upsample_size = down_block_res_samples[-1].shape[2:] + + if hasattr(upsample_block, "has_cross_attention") and upsample_block.has_cross_attention: + sample = upsample_block( + hidden_states=sample, + temb=emb, + res_hidden_states_tuple=res_samples, + encoder_hidden_states=encoder_hidden_states, + cross_attention_kwargs=cross_attention_kwargs, + upsample_size=upsample_size, + attention_mask=attention_mask, + encoder_attention_mask=encoder_attention_mask, + ) + else: + sample = upsample_block( + hidden_states=sample, + temb=emb, + res_hidden_states_tuple=res_samples, + upsample_size=upsample_size, + ) + up_block_res_samples += (sample, ) + + # # 6. post-process + # if self.conv_norm_out: + # sample = self.conv_norm_out(sample) + # sample = self.conv_act(sample) + # sample = self.conv_out(sample) + + if USE_PEFT_BACKEND: + # remove `lora_scale` from each PEFT layer + unscale_lora_layers(self, lora_scale) + + if not return_dict: + if use_up_blocks: + return (mid_sample, down_block_res_samples, up_block_res_samples) + else: + return (mid_sample, down_block_res_samples) + + return UNet2DConditionOutput(sample=sample) \ No newline at end of file diff --git a/Reward_sdxl_idealized/pipelines/__pycache__/__init__.cpython-310.pyc b/Reward_sdxl_idealized/pipelines/__pycache__/__init__.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c79bf143207abc77550c0d8dbff0d78c4028f868 Binary files /dev/null and b/Reward_sdxl_idealized/pipelines/__pycache__/__init__.cpython-310.pyc differ diff --git a/Reward_sdxl_idealized/pipelines/sdxl_gradient_ascent_pipeline.py b/Reward_sdxl_idealized/pipelines/sdxl_gradient_ascent_pipeline.py new file mode 100644 index 0000000000000000000000000000000000000000..4f55f2b973d57122445b1366ba4f5f796be908b8 --- /dev/null +++ b/Reward_sdxl_idealized/pipelines/sdxl_gradient_ascent_pipeline.py @@ -0,0 +1,375 @@ +""" +Stable Diffusion XL Pipeline with Gradient Ascent Reward Guidance + +Fully compatible with HuggingFace diffusers StableDiffusionXLPipeline. +Injects the Kinetic Latent Predictor-Corrector operator split safely +before the ODE integration step. +""" + +import inspect +from typing import Any, Callable, Dict, List, Optional, Tuple, Union + +import torch +from diffusers import StableDiffusionXLPipeline +from diffusers.pipelines.stable_diffusion_xl.pipeline_output import StableDiffusionXLPipelineOutput + +from gradient_ascent_utils import RewardGuidedDiffusion + + +def rescale_noise_cfg(noise_cfg, noise_pred_text, guidance_rescale=0.0): + """ + Rescales `noise_cfg` tensor based on `guidance_rescale` to improve image quality and fix overexposure. + (Matches diffusers implementation) + """ + std_text = noise_pred_text.std(dim=list(range(1, noise_pred_text.ndim)), keepdim=True) + std_cfg = noise_cfg.std(dim=list(range(1, noise_cfg.ndim)), keepdim=True) + noise_pred_rescaled = noise_cfg * (std_text / std_cfg) + noise_cfg = guidance_rescale * noise_pred_rescaled + (1 - guidance_rescale) * noise_cfg + return noise_cfg + + +class StableDiffusionXLGradientAscentPipeline(StableDiffusionXLPipeline): + """ + SDXL Pipeline with KLPC gradient ascent reward guidance. + """ + + def __init__( + self, + vae, + text_encoder, + text_encoder_2, + tokenizer, + tokenizer_2, + unet, + scheduler, + image_encoder=None, + feature_extractor=None, + force_zeros_for_empty_prompt: bool = True, + add_watermarker: bool = None, + ): + super().__init__( + vae=vae, + text_encoder=text_encoder, + text_encoder_2=text_encoder_2, + tokenizer=tokenizer, + tokenizer_2=tokenizer_2, + unet=unet, + scheduler=scheduler, + image_encoder=image_encoder, + feature_extractor=feature_extractor, + force_zeros_for_empty_prompt=force_zeros_for_empty_prompt, + add_watermarker=add_watermarker, + ) + + # Initialize our KLPC custom state variables + self.gradient_ascent_enabled = False + self.grad_guidance = None + self.reward_model = None + self.reward_history = [] + + def set_reward_model(self, reward_model): + self.reward_model = reward_model + + def enable_gradient_ascent( + self, + grad_timestep_range: Tuple[int, int] = (500, 700), + grad_scale: float = 1.0, + num_grad_steps: int = 5, + grad_step_size: float = 0.1, + lr_scheduler_type: str = "constant", + lr_scheduler_kwargs: Optional[dict] = None, + use_momentum: bool = False, + momentum: float = 0.9, + use_nesterov: bool = False, + use_iso_projection: bool = False + ): + if self.reward_model is None: + raise ValueError("Reward model must be set first via set_reward_model().") + + self.grad_guidance = RewardGuidedDiffusion( + reward_model=self.reward_model, + grad_scale=grad_scale, + grad_timestep_range=grad_timestep_range, + num_grad_steps=num_grad_steps, + grad_step_size=grad_step_size, + lr_scheduler_type=lr_scheduler_type, + lr_scheduler_kwargs=lr_scheduler_kwargs or {}, + use_momentum=use_momentum, + momentum=momentum, + use_nesterov=use_nesterov, + use_iso_projection=use_iso_projection + ) + self.gradient_ascent_enabled = True + + @torch.no_grad() + def __call__( + self, + prompt: Union[str, List[str]] = None, + prompt_2: Optional[Union[str, List[str]]] = None, + height: Optional[int] = None, + width: Optional[int] = None, + num_inference_steps: int = 50, + timesteps: List[int] = None, + sigmas: List[float] = None, + denoising_end: Optional[float] = None, + guidance_scale: float = 5.0, + negative_prompt: Optional[Union[str, List[str]]] = None, + negative_prompt_2: Optional[Union[str, List[str]]] = None, + num_images_per_prompt: Optional[int] = 1, + eta: float = 0.0, + generator: Optional[Union[torch.Generator, List[torch.Generator]]] = None, + latents: Optional[torch.Tensor] = None, + prompt_embeds: Optional[torch.Tensor] = None, + negative_prompt_embeds: Optional[torch.Tensor] = None, + pooled_prompt_embeds: Optional[torch.Tensor] = None, + negative_pooled_prompt_embeds: Optional[torch.Tensor] = None, + ip_adapter_image: Optional[Any] = None, + ip_adapter_image_embeds: Optional[List[torch.Tensor]] = None, + output_type: Optional[str] = "pil", + return_dict: bool = True, + cross_attention_kwargs: Optional[Dict[str, Any]] = None, + guidance_rescale: float = 0.0, + original_size: Optional[Tuple[int, int]] = None, + crops_coords_top_left: Tuple[int, int] = (0, 0), + target_size: Optional[Tuple[int, int]] = None, + negative_original_size: Optional[Tuple[int, int]] = None, + negative_crops_coords_top_left: Tuple[int, int] = (0, 0), + negative_target_size: Optional[Tuple[int, int]] = None, + clip_skip: Optional[int] = None, + callback_on_step_end: Optional[Callable[[int, int, Dict], Dict]] = None, + callback_on_step_end_tensor_inputs: List[str] = ["latents"], + # Custom parameters for KLPC gradient ascent + track_rewards: bool = True, + apply_gradient_ascent: bool = True, + verbose_grad: bool = False, + **kwargs, + ): + # 1. Setup sizes & Batch + height = height or self.default_sample_size * self.vae_scale_factor + width = width or self.default_sample_size * self.vae_scale_factor + + original_size = original_size or (height, width) + target_size = target_size or (height, width) + + # 2. Define batch size + if prompt is not None and isinstance(prompt, str): + batch_size = 1 + elif prompt is not None and isinstance(prompt, list): + batch_size = len(prompt) + else: + batch_size = prompt_embeds.shape[0] + + device = self._execution_device + + do_classifier_free_guidance = guidance_scale > 1.0 + + # 3. Encode input prompt + lora_scale = ( + cross_attention_kwargs.get("scale", None) if cross_attention_kwargs is not None else None + ) + + ( + prompt_embeds, + negative_prompt_embeds, + pooled_prompt_embeds, + negative_pooled_prompt_embeds, + ) = self.encode_prompt( + prompt=prompt, + prompt_2=prompt_2, + device=device, + num_images_per_prompt=num_images_per_prompt, + do_classifier_free_guidance=do_classifier_free_guidance, + negative_prompt=negative_prompt, + negative_prompt_2=negative_prompt_2, + prompt_embeds=prompt_embeds, + negative_prompt_embeds=negative_prompt_embeds, + pooled_prompt_embeds=pooled_prompt_embeds, + negative_pooled_prompt_embeds=negative_pooled_prompt_embeds, + lora_scale=lora_scale, + clip_skip=clip_skip, + ) + + # Keep HF internal state synchronized just in case external callbacks need them + self._guidance_scale = guidance_scale + self._guidance_rescale = guidance_rescale + self._cross_attention_kwargs = cross_attention_kwargs + self._interrupt = False + + # 4. Prepare timesteps + self.scheduler.set_timesteps(num_inference_steps, device=device) + timesteps = self.scheduler.timesteps + + # 5. Prepare latent variables + num_channels_latents = self.unet.config.in_channels + latents = self.prepare_latents( + batch_size * num_images_per_prompt, + num_channels_latents, + height, + width, + prompt_embeds.dtype, + device, + generator, + latents, + ) + + # 6. Prepare extra step kwargs + extra_step_kwargs = self.prepare_extra_step_kwargs(generator, eta) + + # 7. Prepare added time ids & embeddings + add_text_embeds = pooled_prompt_embeds + if self.text_encoder_2 is None: + text_encoder_projection_dim = int(pooled_prompt_embeds.shape[-1]) + else: + text_encoder_projection_dim = self.text_encoder_2.config.projection_dim + + add_time_ids = self._get_add_time_ids( + original_size, + crops_coords_top_left, + target_size, + dtype=prompt_embeds.dtype, + text_encoder_projection_dim=text_encoder_projection_dim, + ) + + if negative_original_size is not None and negative_target_size is not None: + negative_add_time_ids = self._get_add_time_ids( + negative_original_size, + negative_crops_coords_top_left, + negative_target_size, + dtype=prompt_embeds.dtype, + text_encoder_projection_dim=text_encoder_projection_dim, + ) + else: + negative_add_time_ids = add_time_ids + + if do_classifier_free_guidance: + prompt_embeds = torch.cat([negative_prompt_embeds, prompt_embeds], dim=0) + add_text_embeds = torch.cat([negative_pooled_prompt_embeds, add_text_embeds], dim=0) + add_time_ids = torch.cat([negative_add_time_ids, add_time_ids], dim=0) + + prompt_embeds = prompt_embeds.to(device) + add_text_embeds = add_text_embeds.to(device) + add_time_ids = add_time_ids.to(device).repeat(batch_size * num_images_per_prompt, 1) + + # 8. Reset Tracking + self.reward_history = [] + if self.grad_guidance is not None: + self.grad_guidance.reset_statistics() + + # Extract string prompt for the reward model forward pass + prompt_str = prompt[0] if isinstance(prompt, list) else prompt + + # 9. Denoising loop + num_warmup_steps = max(len(timesteps) - num_inference_steps * self.scheduler.order, 0) + + with self.progress_bar(total=num_inference_steps) as progress_bar: + for i, t in enumerate(timesteps): + + # predict the noise residual + added_cond_kwargs = {"text_embeds": add_text_embeds, "time_ids": add_time_ids} + + # ========================================================================= + # KINETIC LATENT PREDICTOR-CORRECTOR (KLPC) OPERATOR SPLIT + # ========================================================================= + # This executes the spatial displacement C_i(z) right BEFORE the scheduler + # integrates using the "stale" velocity (noise_pred), fulfilling Theorem 1. + if ( + self.gradient_ascent_enabled + and apply_gradient_ascent + and self.grad_guidance + and self.grad_guidance.should_apply_gradient(t.item()) + and prompt_str is not None + ): + with torch.enable_grad(): + latents, grad_stats = self.grad_guidance.apply_gradient_ascent( + latents, + prompt_str, + t.item(), + base_noise=None, + verbose=verbose_grad, + total_denoising_steps=num_inference_steps, + ) + + latent_model_input = torch.cat([latents] * 2) if guidance_scale > 1.0 else latents + latent_model_input = self.scheduler.scale_model_input(latent_model_input, t) + + noise_pred = self.unet( + latent_model_input, + t, + encoder_hidden_states=prompt_embeds, + cross_attention_kwargs=cross_attention_kwargs, + added_cond_kwargs=added_cond_kwargs, + return_dict=False, + )[0] + + if do_classifier_free_guidance: + noise_pred_uncond, noise_pred_text = noise_pred.chunk(2) + noise_pred = noise_pred_uncond + guidance_scale * (noise_pred_text - noise_pred_uncond) + + if do_classifier_free_guidance and guidance_rescale > 0.0: + noise_pred = rescale_noise_cfg(noise_pred, noise_pred_text, guidance_rescale=guidance_rescale) + + # Track Rewards + if track_rewards and self.reward_model is not None and prompt_str is not None: + with torch.no_grad(): + score = self.reward_model.get_reward_score(latents, prompt_str, t.item()) + score_val = score.item() if score.numel() == 1 else score.mean().item() + self.reward_history.append({'timestep': t.item(), 'reward_score': score_val}) + # ========================================================================= + + # compute the previous noisy sample x_t -> x_t-1 + latents_dtype = latents.dtype + latents = self.scheduler.step(noise_pred, t, latents, **extra_step_kwargs, return_dict=False)[0] + + if latents.dtype != latents_dtype: + latents = latents.to(latents_dtype) + + # Execute diffusers native step end callback if provided + if callback_on_step_end is not None: + callback_kwargs = {} + for k in callback_on_step_end_tensor_inputs: + callback_kwargs[k] = locals()[k] + callback_outputs = callback_on_step_end(self, i, t, callback_kwargs) + + latents = callback_outputs.pop("latents", latents) + prompt_embeds = callback_outputs.pop("prompt_embeds", prompt_embeds) + add_text_embeds = callback_outputs.pop("add_text_embeds", add_text_embeds) + add_time_ids = callback_outputs.pop("add_time_ids", add_time_ids) + + if i == len(timesteps) - 1 or ((i + 1) > num_warmup_steps and (i + 1) % self.scheduler.order == 0): + progress_bar.update() + + if not output_type == "latent": + # make sure the VAE is in float32 mode, as it overflows in float16 + needs_upcasting = self.vae.dtype == torch.float16 and self.vae.config.force_upcast + if needs_upcasting: + self.upcast_vae() + latents = latents.to(next(iter(self.vae.post_quant_conv.parameters())).dtype) + elif latents.dtype != self.vae.dtype: + # HF Native fix: Cast the VAE to match the latents dtype! + self.vae = self.vae.to(latents.dtype) + + # unscale/denormalize the latents + has_latents_mean = hasattr(self.vae.config, "latents_mean") and self.vae.config.latents_mean is not None + has_latents_std = hasattr(self.vae.config, "latents_std") and self.vae.config.latents_std is not None + + if has_latents_mean and has_latents_std: + latents_mean = torch.tensor(self.vae.config.latents_mean).view(1, 4, 1, 1).to(latents.device, latents.dtype) + latents_std = torch.tensor(self.vae.config.latents_std).view(1, 4, 1, 1).to(latents.device, latents.dtype) + latents = latents * latents_std / self.vae.config.scaling_factor + latents_mean + else: + latents = latents / self.vae.config.scaling_factor + + image = self.vae.decode(latents, return_dict=False)[0] + + # cast back to fp16 if needed + if needs_upcasting: + self.vae.to(dtype=torch.float16) + + image = self.image_processor.postprocess(image, output_type=output_type) + else: + image = latents + + if not return_dict: + return (image,) + + return StableDiffusionXLPipelineOutput(images=image) \ No newline at end of file diff --git a/Reward_sdxl_idealized/timestep_convergence_analysis.ipynb b/Reward_sdxl_idealized/timestep_convergence_analysis.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..7b1391e5f81b6693a527b5c382b280dbdbfeb7f2 --- /dev/null +++ b/Reward_sdxl_idealized/timestep_convergence_analysis.ipynb @@ -0,0 +1,1105 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "513b682a", + "metadata": {}, + "source": [ + "#### Setup and Imports" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f9f44d61", + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "import sys\n", + "import json\n", + "import warnings\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import matplotlib\n", + "import torch\n", + "import torch.nn as nn\n", + "from pathlib import Path\n", + "from PIL import Image\n", + "from tqdm.auto import tqdm\n", + "from diffusers import StableDiffusionPipeline, DDIMScheduler, UNet2DConditionModel\n", + "from transformers import CLIPModel, CLIPProcessor\n", + "from torchmetrics.image.fid import FrechetInceptionDistance\n", + "from torchmetrics.multimodal import CLIPScore\n", + "\n", + "warnings.filterwarnings(\"ignore\")\n", + "\n", + "# Import local modules\n", + "from models import LRMRewardModel\n", + "from pipelines.sd15_gradient_ascent_pipeline import StableDiffusionGradientAscentPipeline\n", + "from grad_ascent_configs import get_config, list_configs\n", + "\n", + "# Import evaluation metrics\n", + "sys.path.append('../evaluation')\n", + "from pick_score import PickScorer\n", + "from hpsv2_score import HPSv2Scorer\n", + "from imagereward_score import load_imagereward\n" + ] + }, + { + "cell_type": "markdown", + "id": "1740dd7c", + "metadata": {}, + "source": [ + "#### Configuration" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f1bc2b07", + "metadata": {}, + "outputs": [], + "source": [ + "# ============ CONFIGURATION ============\n", + "\n", + "# Dataset\n", + "DATA_DIR = \"./data\"\n", + "DATASET_TYPE = \"coco\" # \"coco\" or \"pickapic\"\n", + "NUM_SAMPLES = 20 # Number of samples to analyze\n", + "\n", + "# Model\n", + "BASE_MODEL = \"runwayml/stable-diffusion-v1-5\"\n", + "MODEL_VARIANT = \"lpo\" # \"origin\", \"spo\", \"diffusion_dpo\", \"lpo\"\n", + "LRM_MODEL = \"casiatao/LRM\"\n", + "\n", + "# Generation\n", + "NUM_INFERENCE_STEPS = 100\n", + "CFG_SCALE = 5.0\n", + "SEED = 42\n", + "BATCH_SIZE = 1\n", + "\n", + "# Gradient Ascent Config\n", + "GRAD_CONFIG = \"low_to_high_nesterov\" # Use None for manual config, or specify preset name\n", + "GRAD_RANGE_START = 0\n", + "GRAD_RANGE_END = 500\n", + "GRAD_STEPS = 1\n", + "GRAD_STEP_SIZE = 0.1\n", + "\n", + "# Metrics to compute\n", + "METRICS = [\"reward\", \"clip\", \"aesthetic\", \"pickscore\", \"hpsv2\", \"fid\"] # Add/remove as needed\n", + "\n", + "# Device\n", + "CUDA_DEVICE = 0\n", + "device = f\"cuda:{CUDA_DEVICE}\" if torch.cuda.is_available() else \"cpu\"\n", + "dtype = torch.float16 if torch.cuda.is_available() else torch.float32\n", + "\n", + "# Output\n", + "OUTPUT_DIR = \"timestep_analysis_results\"\n", + "os.makedirs(OUTPUT_DIR, exist_ok=True)\n", + "\n", + "print(f\"Device: {device}\")\n", + "print(f\"Dataset: {DATASET_TYPE}\")\n", + "print(f\"Samples to analyze: {NUM_SAMPLES}\")\n", + "print(f\"Metrics: {METRICS}\")\n", + "print(f\"Output directory: {OUTPUT_DIR}\")" + ] + }, + { + "cell_type": "markdown", + "id": "1b1b6d02", + "metadata": {}, + "source": [ + "#### Load Dataset" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a74b2816", + "metadata": {}, + "outputs": [], + "source": [ + "def load_validation_data(data_dir, max_samples=None):\n", + " \"\"\"Load COCO validation prompts and image paths.\"\"\"\n", + " data_dir = Path(data_dir)\n", + " val_json = data_dir / \"coco\" / \"caption_val.json\"\n", + " \n", + " if not val_json.exists():\n", + " raise FileNotFoundError(f\"Validation data not found at {val_json}\")\n", + " \n", + " with open(val_json, 'r') as f:\n", + " data = json.load(f)\n", + " \n", + " print(f\"Loaded JSON with {len(data)} entries\")\n", + " \n", + " # Validate that image folder exists\n", + " val_img_dir = data_dir / \"coco\" / \"images\" / \"val\"\n", + " if not val_img_dir.exists():\n", + " print(f\"Warning: Standard validation directory not found: {val_img_dir}\")\n", + " \n", + " # Parse data - img_path already contains \"images/val/\" prefix\n", + " prompts = []\n", + " image_paths = []\n", + " \n", + " for img_path, caption in data.items():\n", + " # Try the path as given (relative to data_dir/coco/)\n", + " full_path = data_dir / \"coco\" / img_path\n", + " if full_path.exists():\n", + " prompts.append(caption)\n", + " image_paths.append(str(full_path))\n", + " \n", + " print(f\"Found {len(prompts)} valid image-caption pairs\")\n", + " \n", + " if len(prompts) == 0:\n", + " print(f\"\\n⚠ WARNING: No valid images found!\")\n", + " print(f\"Debug information:\")\n", + " print(f\" JSON file: {val_json}\")\n", + " print(f\" JSON entries: {len(data)}\")\n", + " print(f\" Sample keys from JSON: {list(data.keys())[:3]}\")\n", + " \n", + " # Check if images exist at all\n", + " coco_dir = data_dir / \"coco\"\n", + " if coco_dir.exists():\n", + " print(f\" COCO dir exists: {coco_dir}\")\n", + " # List subdirectories\n", + " subdirs = [d.name for d in coco_dir.iterdir() if d.is_dir()]\n", + " print(f\" Subdirectories in COCO: {subdirs}\")\n", + " \n", + " # Try to find images\n", + " if val_img_dir.exists():\n", + " img_files = list(val_img_dir.glob(\"*.jpg\"))[:5]\n", + " print(f\" Sample images in val dir: {[f.name for f in img_files]}\")\n", + " \n", + " if max_samples and len(prompts) > 0:\n", + " prompts = prompts[:max_samples]\n", + " image_paths = image_paths[:max_samples]\n", + " \n", + " return prompts, image_paths\n", + "\n", + "# Load data\n", + "prompts, image_paths = load_validation_data(DATA_DIR, NUM_SAMPLES)\n", + "print(f\"\\n✓ Loaded {len(prompts)} samples\")\n", + "\n", + "if len(prompts) > 0:\n", + " print(f\"\\nSample prompts:\")\n", + " for i, prompt in enumerate(prompts[:3]):\n", + " print(f\" {i+1}. {prompt[:80]}...\")\n", + " print(f\"\\nSample image paths:\")\n", + " for i, path in enumerate(image_paths[:3]):\n", + " print(f\" {i+1}. {path}\")\n", + "else:\n", + " print(\"\\n❌ ERROR: No samples loaded! Please check your data directory structure.\")\n", + " print(\"Expected structure:\")\n", + " print(\" ./data/coco/caption_val.json\")\n", + " print(\" ./data/coco/images/val/*.jpg\")" + ] + }, + { + "cell_type": "markdown", + "id": "5ceae64a", + "metadata": {}, + "source": [ + "#### Load Models and Scorers" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "43ad1f56", + "metadata": {}, + "outputs": [], + "source": [ + "# ============ MLP for Aesthetic Scoring ============\n", + "class MLP(nn.Module):\n", + " def __init__(self):\n", + " super().__init__()\n", + " self.layers = nn.Sequential(\n", + " nn.Linear(768, 1024),\n", + " nn.Dropout(0.2),\n", + " nn.Linear(1024, 128),\n", + " nn.Dropout(0.2),\n", + " nn.Linear(128, 64),\n", + " nn.Dropout(0.1),\n", + " nn.Linear(64, 16),\n", + " nn.Linear(16, 1),\n", + " )\n", + " \n", + " @torch.no_grad()\n", + " def forward(self, embed):\n", + " return self.layers(embed)\n", + "\n", + "class AestheticScorer(torch.nn.Module):\n", + " def __init__(self, dtype, device):\n", + " super().__init__()\n", + " self.clip = CLIPModel.from_pretrained(\"openai/clip-vit-large-patch14\")\n", + " self.processor = CLIPProcessor.from_pretrained(\"openai/clip-vit-large-patch14\")\n", + " self.mlp = MLP()\n", + " \n", + " aesthetic_path = \"../evaluation/sac+logos+ava1-l14-linearMSE.pth\"\n", + " if os.path.exists(aesthetic_path):\n", + " state_dict = torch.load(aesthetic_path, map_location='cpu')\n", + " self.mlp.load_state_dict(state_dict)\n", + " \n", + " self.dtype = dtype\n", + " self.to(device)\n", + " self.eval()\n", + " \n", + " @torch.no_grad()\n", + " def __call__(self, images):\n", + " if not isinstance(images, list):\n", + " images = [images]\n", + " inputs = self.processor(images=images, return_tensors=\"pt\", padding=True)\n", + " inputs = {k: v.to(self.clip.device) for k, v in inputs.items()}\n", + " image_embeds = self.clip.get_image_features(**inputs)\n", + " image_embeds = image_embeds / image_embeds.norm(dim=-1, keepdim=True)\n", + " scores = self.mlp(image_embeds.float())\n", + " return scores.squeeze().cpu().numpy()\n", + "\n", + "print(\"Loading models...\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "36a70595", + "metadata": {}, + "outputs": [], + "source": [ + "# Load Reward Model\n", + "print(\"Loading reward model...\")\n", + "reward_model = LRMRewardModel(\n", + " pretrained_model_name_or_path=BASE_MODEL,\n", + " lrm_model_path=LRM_MODEL,\n", + " guidance_scale=CFG_SCALE,\n", + " device=device\n", + ")\n", + "if dtype == torch.float16:\n", + " reward_model = reward_model.half()\n", + "reward_model.eval()\n", + "print(\"✓ Reward model loaded\")\n", + "\n", + "# Load Pipeline\n", + "print(\"\\nLoading diffusion pipeline...\")\n", + "if MODEL_VARIANT == \"origin\":\n", + " base_pipeline = StableDiffusionPipeline.from_pretrained(\n", + " BASE_MODEL, torch_dtype=dtype, safety_checker=None\n", + " )\n", + "elif MODEL_VARIANT == \"spo\":\n", + " base_pipeline = StableDiffusionPipeline.from_pretrained(\n", + " 'SPO-Diffusion-Models/SPO-SD-v1-5_4k-p_10ep',\n", + " torch_dtype=dtype, safety_checker=None\n", + " )\n", + " CFG_SCALE = 5.0\n", + "elif MODEL_VARIANT == \"diffusion_dpo\":\n", + " unet = UNet2DConditionModel.from_pretrained(\n", + " 'mhdang/dpo-sd1.5-text2image-v1', subfolder=\"unet\", torch_dtype=dtype\n", + " )\n", + " base_pipeline = StableDiffusionPipeline.from_pretrained(\n", + " BASE_MODEL, torch_dtype=dtype, safety_checker=None, unet=unet\n", + " )\n", + "elif MODEL_VARIANT == \"lpo\":\n", + " unet = UNet2DConditionModel.from_pretrained(\n", + " 'casiatao/LPO', subfolder=\"lpo_sd15_merge/unet\", torch_dtype=dtype\n", + " )\n", + " base_pipeline = StableDiffusionPipeline.from_pretrained(\n", + " BASE_MODEL, torch_dtype=dtype, safety_checker=None, unet=unet\n", + " )\n", + " CFG_SCALE = 5.0\n", + "\n", + "pipeline = StableDiffusionGradientAscentPipeline(**base_pipeline.components)\n", + "pipeline.scheduler = DDIMScheduler.from_config(pipeline.scheduler.config)\n", + "pipeline = pipeline.to(device)\n", + "pipeline.set_reward_model(reward_model)\n", + "print(\"✓ Pipeline loaded\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4e18f075", + "metadata": {}, + "outputs": [], + "source": [ + "# Load Metric Scorers\n", + "print(\"\\nLoading metric scorers...\")\n", + "\n", + "clip_scorer = None\n", + "aesthetic_scorer = None\n", + "pick_scorer = None\n", + "hpsv2_scorer = None\n", + "imagereward_scorer = None\n", + "\n", + "if \"clip\" in METRICS:\n", + " print(\" Loading CLIP scorer...\")\n", + " clip_scorer = CLIPScore(model_name_or_path=\"openai/clip-vit-base-patch16\").to(device)\n", + " print(\" ✓ CLIP scorer loaded\")\n", + "\n", + "if \"aesthetic\" in METRICS:\n", + " print(\" Loading Aesthetic scorer...\")\n", + " aesthetic_scorer = AestheticScorer(dtype, device)\n", + " print(\" ✓ Aesthetic scorer loaded\")\n", + "\n", + "if \"pickscore\" in METRICS:\n", + " print(\" Loading PickScore scorer...\")\n", + " try:\n", + " pick_scorer = PickScorer(device=device, dtype=dtype)\n", + " print(\" ✓ PickScore loaded\")\n", + " except Exception as e:\n", + " print(f\" ✗ PickScore failed: {e}\")\n", + " METRICS.remove(\"pickscore\")\n", + "\n", + "if \"hpsv2\" in METRICS:\n", + " print(\" Loading HPSv2 scorer...\")\n", + " try:\n", + " hpsv2_scorer = HPSv2Scorer(device=device, dtype=dtype)\n", + " print(\" ✓ HPSv2 loaded\")\n", + " except Exception as e:\n", + " print(f\" ✗ HPSv2 failed: {e}\")\n", + " METRICS.remove(\"hpsv2\")\n", + "\n", + "if \"imagereward\" in METRICS:\n", + " print(\" Loading ImageReward scorer...\")\n", + " try:\n", + " imagereward_scorer = load_imagereward(device=device)\n", + " print(\" ✓ ImageReward loaded\")\n", + " except Exception as e:\n", + " print(f\" ✗ ImageReward failed: {e}\")\n", + " METRICS.remove(\"imagereward\")\n", + "\n", + "print(f\"\\n✓ Active metrics: {METRICS}\")" + ] + }, + { + "cell_type": "markdown", + "id": "70ac047b", + "metadata": {}, + "source": [ + "#### Configure Gradient Ascent" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "05996448", + "metadata": {}, + "outputs": [], + "source": [ + "# Configure gradient ascent\n", + "if GRAD_CONFIG:\n", + " print(f\"Loading gradient ascent config: {GRAD_CONFIG}\")\n", + " grad_config = get_config(GRAD_CONFIG)\n", + " print(f\"Config: {grad_config}\")\n", + "else:\n", + " grad_config = {\n", + " \"grad_timestep_range\": (GRAD_RANGE_START, GRAD_RANGE_END),\n", + " \"num_grad_steps\": GRAD_STEPS,\n", + " \"grad_step_size\": GRAD_STEP_SIZE,\n", + " }\n", + " print(f\"Manual gradient ascent configuration: {grad_config}\")\n", + "\n", + "pipeline.enable_gradient_ascent(**grad_config)\n", + "print(\"\\n✓ Gradient ascent enabled\")" + ] + }, + { + "cell_type": "markdown", + "id": "1f82c3df", + "metadata": {}, + "source": [ + "#### Timestep Analysis Functions" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e836d8f2", + "metadata": {}, + "outputs": [], + "source": [ + "def latents_to_images(latents, vae):\n", + " \"\"\"Convert latents to PIL images.\"\"\"\n", + " latents = 1 / 0.18215 * latents\n", + " with torch.no_grad():\n", + " images = vae.decode(latents).sample\n", + " images = (images / 2 + 0.5).clamp(0, 1)\n", + " images = images.cpu().permute(0, 2, 3, 1).numpy()\n", + " images = (images * 255).round().astype(\"uint8\")\n", + " pil_images = [Image.fromarray(image) for image in images]\n", + " return pil_images\n", + "\n", + "\n", + "def compute_metrics_for_image(image, prompt, reference_image=None):\n", + " \"\"\"Compute all metrics for a single image.\"\"\"\n", + " metrics = {}\n", + " \n", + " # CLIP Score\n", + " if clip_scorer is not None:\n", + " img_tensor = torch.from_numpy(np.array(image)).permute(2, 0, 1).unsqueeze(0).to(device)\n", + " with torch.no_grad():\n", + " clip_score = clip_scorer(img_tensor, prompt).item()\n", + " metrics['clip'] = clip_score\n", + " \n", + " # Aesthetic Score\n", + " if aesthetic_scorer is not None:\n", + " aesthetic_score = aesthetic_scorer([image])\n", + " if isinstance(aesthetic_score, np.ndarray):\n", + " aesthetic_score = aesthetic_score.item()\n", + " metrics['aesthetic'] = aesthetic_score\n", + " \n", + " # PickScore\n", + " if pick_scorer is not None:\n", + " pick_score = pick_scorer.score(prompt, [image])[0]\n", + " metrics['pickscore'] = pick_score\n", + " \n", + " # HPSv2\n", + " if hpsv2_scorer is not None:\n", + " hpsv2_score = hpsv2_scorer.score(prompt, [image])[0]\n", + " metrics['hpsv2'] = hpsv2_score\n", + " \n", + " # ImageReward\n", + " if imagereward_scorer is not None:\n", + " imagereward_score = imagereward_scorer.score(prompt, [image])[0]\n", + " metrics['imagereward'] = imagereward_score\n", + " \n", + " # FID (if reference image provided)\n", + " if reference_image is not None:\n", + " try:\n", + " fid_metric = FrechetInceptionDistance(normalize=True).to(device)\n", + " \n", + " # Process reference image\n", + " ref_img = Image.open(reference_image).convert('RGB').resize((299, 299))\n", + " ref_tensor = torch.from_numpy(np.array(ref_img)).permute(2, 0, 1).unsqueeze(0).to(device)\n", + " \n", + " # Process generated image\n", + " gen_img = image.resize((299, 299))\n", + " gen_tensor = torch.from_numpy(np.array(gen_img)).permute(2, 0, 1).unsqueeze(0).to(device)\n", + " \n", + " if ref_tensor.size(0) == 1:\n", + " ref_tensor = ref_tensor.repeat(2, 1, 1, 1)\n", + " if gen_tensor.size(0) == 1:\n", + " gen_tensor = gen_tensor.repeat(2, 1, 1, 1)\n", + " \n", + " fid_metric.update(ref_tensor, real=True)\n", + " fid_metric.update(gen_tensor, real=False)\n", + " \n", + " fid_score = fid_metric.compute().item()/10\n", + " metrics['fid'] = fid_score\n", + " except Exception as e:\n", + " print(f\"FID computation failed: {e}\")\n", + " \n", + " return metrics\n", + "\n", + "\n", + "def analyze_sample_timesteps(prompt, reference_image, sample_idx):\n", + " \"\"\"\n", + " Generate images and track metrics at each timestep.\n", + " Returns timestep-wise metrics and intermediate images.\n", + " \"\"\"\n", + " print(f\"\\n{'='*70}\")\n", + " print(f\"Analyzing Sample {sample_idx + 1}\")\n", + " print(f\"Prompt: {prompt[:80]}...\")\n", + " print(f\"{'='*70}\")\n", + " \n", + " # Storage for results\n", + " timestep_metrics = {\n", + " 'timesteps': [],\n", + " 'reward': [],\n", + " 'clip': [],\n", + " 'aesthetic': [],\n", + " 'pickscore': [],\n", + " 'hpsv2': [],\n", + " 'imagereward': [],\n", + " 'fid': []\n", + " }\n", + " intermediate_images = []\n", + " \n", + " # Reset gradient stats\n", + " if hasattr(pipeline, 'grad_guidance'):\n", + " pipeline.grad_guidance.reset_statistics()\n", + " \n", + " # Modified pipeline call to capture intermediate latents\n", + " generator = torch.Generator(device=device).manual_seed(SEED + sample_idx)\n", + " \n", + " # We'll manually step through the denoising process\n", + " pipeline.set_progress_bar_config(disable=True)\n", + " \n", + " # Prepare inputs\n", + " height = pipeline.unet.config.sample_size * pipeline.vae_scale_factor\n", + " width = pipeline.unet.config.sample_size * pipeline.vae_scale_factor\n", + " \n", + " # Encode prompt\n", + " text_embeddings = pipeline._encode_prompt(\n", + " prompt, device, 1, True, None\n", + " )\n", + " \n", + " # Prepare timesteps\n", + " pipeline.scheduler.set_timesteps(NUM_INFERENCE_STEPS, device=device)\n", + " timesteps = pipeline.scheduler.timesteps\n", + " \n", + " # Prepare latents\n", + " shape = (1, pipeline.unet.config.in_channels, height // 8, width // 8)\n", + " latents = torch.randn(shape, generator=generator, device=device, dtype=dtype)\n", + " latents = latents * pipeline.scheduler.init_noise_sigma\n", + " \n", + " # Denoising loop with metric tracking\n", + " for i, t in enumerate(tqdm(timesteps, desc=\"Denoising steps\")):\n", + " # Apply gradient ascent if enabled\n", + " if hasattr(pipeline, 'grad_guidance') and pipeline.grad_guidance:\n", + " if pipeline.grad_guidance.should_apply_gradient(t.item()):\n", + " latents, grad_stats = pipeline.grad_guidance.apply_gradient_ascent(\n", + " latents, prompt, t.item(), verbose=False,\n", + " total_denoising_steps=len(timesteps)\n", + " )\n", + " \n", + " # Expand latents for classifier free guidance\n", + " latent_model_input = torch.cat([latents] * 2)\n", + " latent_model_input = pipeline.scheduler.scale_model_input(latent_model_input, t)\n", + " \n", + " # Predict noise\n", + " with torch.no_grad():\n", + " noise_pred = pipeline.unet(\n", + " latent_model_input,\n", + " t,\n", + " encoder_hidden_states=text_embeddings,\n", + " ).sample\n", + " \n", + " # Perform guidance\n", + " noise_pred_uncond, noise_pred_text = noise_pred.chunk(2)\n", + " noise_pred = noise_pred_uncond + CFG_SCALE * (noise_pred_text - noise_pred_uncond)\n", + " \n", + " # Compute previous noisy sample\n", + " latents = pipeline.scheduler.step(noise_pred, t, latents).prev_sample\n", + " \n", + " # Decode latents to image every few steps\n", + " if i % 5 == 0 or i == len(timesteps) - 1:\n", + " # Convert to image\n", + " images = latents_to_images(latents, pipeline.vae)\n", + " image = images[0]\n", + " \n", + " # Compute reward\n", + " with torch.no_grad():\n", + " reward = reward_model.get_reward_score(latents, prompt, t.item())\n", + " reward_val = reward.mean().item() if reward.numel() > 1 else reward.item()\n", + " \n", + " # Compute other metrics\n", + " metrics = compute_metrics_for_image(image, prompt, reference_image)\n", + " \n", + " # Store results\n", + " timestep_metrics['timesteps'].append(t.item())\n", + " timestep_metrics['reward'].append(reward_val)\n", + " \n", + " for metric_name in ['clip', 'aesthetic', 'pickscore', 'hpsv2', 'imagereward', 'fid']:\n", + " if metric_name in metrics:\n", + " timestep_metrics[metric_name].append(metrics[metric_name])\n", + " else:\n", + " timestep_metrics[metric_name].append(None)\n", + " \n", + " intermediate_images.append(image)\n", + " \n", + " print(f\" Step {i}/{len(timesteps)} | t={t.item():.0f} | Reward={reward_val:.4f}\")\n", + " \n", + " # Final image\n", + " final_images = latents_to_images(latents, pipeline.vae)\n", + " final_image = final_images[0]\n", + " \n", + " pipeline.set_progress_bar_config(disable=False)\n", + " \n", + " return timestep_metrics, intermediate_images, final_image\n", + "\n", + "print(\"✓ Analysis functions defined\")" + ] + }, + { + "cell_type": "markdown", + "id": "fc089bfd", + "metadata": {}, + "source": [ + "#### Run Timestep Analysis" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "67c25164", + "metadata": {}, + "outputs": [], + "source": [ + "# Run analysis for all samples\n", + "all_results = []\n", + "\n", + "for idx in range(len(prompts)):\n", + " prompt = prompts[idx]\n", + " reference_image = image_paths[idx]\n", + " \n", + " # Analyze this sample\n", + " metrics, images, final_image = analyze_sample_timesteps(prompt, reference_image, idx)\n", + " \n", + " # Store results\n", + " all_results.append({\n", + " 'prompt': prompt,\n", + " 'reference_image': reference_image,\n", + " 'metrics': metrics,\n", + " 'intermediate_images': images,\n", + " 'final_image': final_image\n", + " })\n", + " \n", + " # Save intermediate results\n", + " sample_dir = Path(OUTPUT_DIR) / f\"sample_{idx+1}\"\n", + " sample_dir.mkdir(exist_ok=True)\n", + " \n", + " # Save final image\n", + " final_image.save(sample_dir / \"final_image.png\")\n", + " \n", + " # Save all intermediate images\n", + " images_dir = sample_dir / \"intermediate_images\"\n", + " images_dir.mkdir(exist_ok=True)\n", + " for img_idx, img in enumerate(images):\n", + " t_val = metrics['timesteps'][img_idx]\n", + " img.save(images_dir / f\"step_{img_idx:03d}_t{int(t_val)}.png\")\n", + " \n", + " # Save metrics\n", + " with open(sample_dir / \"metrics.json\", 'w') as f:\n", + " json.dump(metrics, f, indent=2)\n", + " \n", + " print(f\"✓ Saved {len(images)} intermediate images for sample {idx+1}\")\n", + "\n", + "print(\"\\n✓ Analysis complete for all samples\")" + ] + }, + { + "cell_type": "markdown", + "id": "10dd749d", + "metadata": {}, + "source": [ + "#### Visualization: Intermediate Images" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "bb32eaa1", + "metadata": {}, + "outputs": [], + "source": [ + "def plot_intermediate_images(results, sample_idx, max_images=8):\n", + " \"\"\"Display intermediate images for a sample showing evolution over timesteps.\"\"\"\n", + " result = results[sample_idx]\n", + " images = result['intermediate_images']\n", + " metrics = result['metrics']\n", + " timesteps = metrics['timesteps']\n", + " rewards = metrics['reward']\n", + " \n", + " # Select evenly spaced images if too many\n", + " if len(images) > max_images:\n", + " indices = np.linspace(0, len(images)-1, max_images, dtype=int)\n", + " selected_images = [images[i] for i in indices]\n", + " selected_timesteps = [timesteps[i] for i in indices]\n", + " selected_rewards = [rewards[i] for i in indices]\n", + " else:\n", + " selected_images = images\n", + " selected_timesteps = timesteps\n", + " selected_rewards = rewards\n", + " \n", + " n_images = len(selected_images)\n", + " cols = 5\n", + " rows = (n_images + cols - 1) // cols\n", + " \n", + " fig, axes = plt.subplots(rows, cols, figsize=(4*cols, 4*rows))\n", + " axes = axes.flatten() if n_images > 1 else [axes]\n", + " \n", + " fig.suptitle(f\"Sample {sample_idx + 1}: Image Evolution Over Timesteps\\n\"\n", + " f\"Prompt: {result['prompt'][:80]}...\", \n", + " fontsize=12, fontweight='bold')\n", + " \n", + " for idx, (img, t, r) in enumerate(zip(selected_images, selected_timesteps, selected_rewards)):\n", + " ax = axes[idx]\n", + " ax.imshow(img)\n", + " ax.axis('off')\n", + " ax.set_title(f\"t={t:.0f}\\nReward={r:.3f}\", fontsize=10)\n", + " \n", + " # Hide unused subplots\n", + " for idx in range(n_images, len(axes)):\n", + " axes[idx].axis('off')\n", + " \n", + " plt.tight_layout()\n", + " \n", + " # Save plot\n", + " sample_dir = Path(OUTPUT_DIR) / f\"sample_{sample_idx+1}\"\n", + " plt.savefig(sample_dir / \"image_evolution.png\", dpi=150, bbox_inches='tight')\n", + " plt.show()\n", + "\n", + "# Plot intermediate images for all samples\n", + "for idx in range(len(all_results)):\n", + " plot_intermediate_images(all_results, idx)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "878b7686", + "metadata": {}, + "outputs": [], + "source": [ + "def plot_final_images_grid(results):\n", + " \"\"\"Display all final images in a grid for comparison.\"\"\"\n", + " n_samples = len(results)\n", + " cols = min(10, n_samples)\n", + " rows = (n_samples + cols - 1) // cols\n", + " \n", + " fig, axes = plt.subplots(rows, cols, figsize=(5*cols, 5*rows))\n", + " if n_samples == 1:\n", + " axes = [axes]\n", + " else:\n", + " axes = axes.flatten()\n", + " \n", + " fig.suptitle(\"Final Generated Images: All Samples\", fontsize=14, fontweight='bold')\n", + " \n", + " for idx, result in enumerate(results):\n", + " ax = axes[idx]\n", + " ax.imshow(result['final_image'])\n", + " ax.axis('off')\n", + " \n", + " # Get final metrics\n", + " metrics = result['metrics']\n", + " reward = metrics['reward'][-1] if metrics['reward'] else 0\n", + " clip_score = metrics['clip'][-1] if 'clip' in metrics and metrics['clip'] and metrics['clip'][-1] is not None else 0\n", + " \n", + " ax.set_title(f\"Sample {idx+1}\\nReward: {reward:.3f} | CLIP: {clip_score:.3f}\\n{result['prompt'][:40]}...\", \n", + " fontsize=9)\n", + " \n", + " # Hide unused subplots\n", + " for idx in range(n_samples, len(axes)):\n", + " axes[idx].axis('off')\n", + " \n", + " plt.tight_layout()\n", + " plt.savefig(Path(OUTPUT_DIR) / \"final_images_grid.png\", dpi=150, bbox_inches='tight')\n", + " plt.show()\n", + "\n", + "# Display final images\n", + "plot_final_images_grid(all_results)" + ] + }, + { + "cell_type": "markdown", + "id": "bc5a96a6", + "metadata": {}, + "source": [ + "#### Debug: Check Data" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "40008ed4", + "metadata": {}, + "outputs": [], + "source": [ + "# Check if data was collected properly\n", + "print(\"Data Collection Summary:\")\n", + "print(\"=\"*70)\n", + "\n", + "for idx, result in enumerate(all_results):\n", + " print(f\"\\nSample {idx+1}:\")\n", + " print(f\" Prompt: {result['prompt'][:60]}...\")\n", + " \n", + " metrics = result['metrics']\n", + " print(f\" Number of timesteps tracked: {len(metrics['timesteps'])}\")\n", + " print(f\" Number of intermediate images: {len(result['intermediate_images'])}\")\n", + " \n", + " # Check which metrics have data\n", + " for metric_name in ['reward', 'clip', 'aesthetic', 'pickscore', 'hpsv2', 'fid']:\n", + " if metric_name in metrics:\n", + " non_none = [v for v in metrics[metric_name] if v is not None]\n", + " if non_none:\n", + " print(f\" {metric_name.upper()}: {len(non_none)} values | \"\n", + " f\"Range: [{min(non_none):.3f}, {max(non_none):.3f}]\")\n", + " else:\n", + " print(f\" {metric_name.upper()}: No valid data\")\n", + " \n", + " # Check timestep range\n", + " if metrics['timesteps']:\n", + " print(f\" Timestep range: [{max(metrics['timesteps']):.0f}, {min(metrics['timesteps']):.0f}]\")\n", + "\n", + "print(\"\\n\" + \"=\"*70)" + ] + }, + { + "cell_type": "markdown", + "id": "5bdacf18", + "metadata": {}, + "source": [ + "#### Visualization: Metrics Evolution" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "be2fc746", + "metadata": {}, + "outputs": [], + "source": [ + "def plot_metrics_evolution(results, sample_idx):\n", + " \"\"\"Plot all metrics evolution in a single row for one sample.\"\"\"\n", + " result = results[sample_idx]\n", + " metrics = result['metrics']\n", + " timesteps = metrics['timesteps']\n", + " \n", + " # Filter metrics to plot (exclude None values)\n", + " metrics_to_plot = []\n", + " for metric_name in ['reward', 'clip', 'aesthetic', 'pickscore', 'hpsv2', 'imagereward', 'fid']:\n", + " if metric_name in metrics and any(v is not None for v in metrics[metric_name]):\n", + " metrics_to_plot.append(metric_name)\n", + " \n", + " n_metrics = len(metrics_to_plot)\n", + " \n", + " # Create figure with subplots in a row\n", + " fig, axes = plt.subplots(1, n_metrics, figsize=(5*n_metrics, 4))\n", + " if n_metrics == 1:\n", + " axes = [axes]\n", + " \n", + " fig.suptitle(f\"Sample {sample_idx + 1}: Metrics Evolution Across Timesteps\\n\"\n", + " f\"Prompt: {result['prompt'][:80]}...\", fontsize=12, fontweight='bold')\n", + " \n", + " colors = ['blue', 'green', 'red', 'purple', 'orange', 'brown', 'pink']\n", + " \n", + " for idx, metric_name in enumerate(metrics_to_plot):\n", + " ax = axes[idx]\n", + " values = [v for v in metrics[metric_name] if v is not None]\n", + " valid_timesteps = [t for t, v in zip(timesteps, metrics[metric_name]) if v is not None]\n", + " \n", + " if values:\n", + " ax.plot(valid_timesteps, values, marker='o', linewidth=2, \n", + " color=colors[idx % len(colors)], label=metric_name.upper())\n", + " ax.set_xlabel('Timestep', fontsize=10)\n", + " ax.set_ylabel(metric_name.upper(), fontsize=10)\n", + " ax.set_title(f\"{metric_name.upper()}\\n{values[0]:.3f} → {values[-1]:.3f}\", fontsize=10)\n", + " ax.grid(True, alpha=0.3)\n", + " ax.invert_xaxis() # Timesteps go from high to low\n", + " \n", + " # Add improvement annotation\n", + " improvement = values[-1] - values[0]\n", + " color = 'green' if improvement > 0 else 'red'\n", + " if metric_name == 'fid': # Lower is better for FID\n", + " color = 'green' if improvement < 0 else 'red'\n", + " ax.text(0.05, 0.95, f\"Δ: {improvement:+.3f}\", \n", + " transform=ax.transAxes, fontsize=9, verticalalignment='top',\n", + " bbox=dict(boxstyle='round', facecolor=color, alpha=0.3))\n", + " \n", + " plt.tight_layout()\n", + " \n", + " # Save plot\n", + " sample_dir = Path(OUTPUT_DIR) / f\"sample_{sample_idx+1}\"\n", + " plt.savefig(sample_dir / \"metrics_evolution.png\", dpi=150, bbox_inches='tight')\n", + " plt.show()\n", + "\n", + "# Plot for all samples\n", + "for idx in range(len(all_results)):\n", + " plot_metrics_evolution(all_results, idx)" + ] + }, + { + "cell_type": "markdown", + "id": "45b7abb7", + "metadata": {}, + "source": [ + "#### Visualization: Compare All Samples" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7d3df7e0", + "metadata": {}, + "outputs": [], + "source": [ + "def plot_all_samples_comparison(results):\n", + " \"\"\"Plot metric evolution for all samples in a grid.\"\"\"\n", + " # Choose key metrics to compare\n", + " key_metrics = ['reward', 'clip', 'aesthetic', 'fid']\n", + " n_metrics = len(key_metrics)\n", + " n_samples = len(results)\n", + " \n", + " fig, axes = plt.subplots(n_metrics, 1, figsize=(14, 4*n_metrics))\n", + " if n_metrics == 1:\n", + " axes = [axes]\n", + " \n", + " fig.suptitle(\"Convergence Analysis: All Samples Comparison\", fontsize=14, fontweight='bold')\n", + " \n", + " colors = plt.cm.tab10(np.linspace(0, 1, n_samples))\n", + " \n", + " for metric_idx, metric_name in enumerate(key_metrics):\n", + " ax = axes[metric_idx]\n", + " \n", + " for sample_idx, result in enumerate(results):\n", + " metrics = result['metrics']\n", + " timesteps = metrics['timesteps']\n", + " values = [v for v in metrics[metric_name] if v is not None]\n", + " valid_timesteps = [t for t, v in zip(timesteps, metrics[metric_name]) if v is not None]\n", + " \n", + " if values:\n", + " ax.plot(valid_timesteps, values, marker='o', linewidth=2, \n", + " color=colors[sample_idx], label=f\"Sample {sample_idx+1}\", alpha=0.7)\n", + " \n", + " ax.set_xlabel('Timestep', fontsize=11)\n", + " ax.set_ylabel(metric_name.upper(), fontsize=11)\n", + " ax.set_title(f\"{metric_name.upper()} Evolution\", fontsize=12, fontweight='bold')\n", + " ax.grid(True, alpha=0.3)\n", + " ax.invert_xaxis()\n", + " ax.legend(loc='best', fontsize=9)\n", + " \n", + " plt.tight_layout()\n", + " plt.savefig(Path(OUTPUT_DIR) / \"all_samples_comparison.png\", dpi=150, bbox_inches='tight')\n", + " plt.show()\n", + "\n", + "# Plot comparison\n", + "plot_all_samples_comparison(all_results)" + ] + }, + { + "cell_type": "markdown", + "id": "44f97581", + "metadata": {}, + "source": [ + "#### Convergence Analysis" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "9dffd878", + "metadata": {}, + "outputs": [], + "source": [ + "def analyze_convergence(results):\n", + " \"\"\"Analyze convergence behavior across samples.\"\"\"\n", + " print(\"\\n\" + \"=\"*70)\n", + " print(\"CONVERGENCE ANALYSIS\")\n", + " print(\"=\"*70)\n", + " \n", + " for metric_name in ['reward', 'clip', 'aesthetic', 'pickscore', 'hpsv2']:\n", + " print(f\"\\n{metric_name.upper()} Convergence:\")\n", + " print(\"-\" * 50)\n", + " \n", + " improvements = []\n", + " initial_values = []\n", + " final_values = []\n", + " \n", + " for idx, result in enumerate(results):\n", + " metrics = result['metrics']\n", + " if metric_name in metrics:\n", + " values = [v for v in metrics[metric_name] if v is not None]\n", + " if values:\n", + " initial = values[0]\n", + " final = values[-1]\n", + " improvement = final - initial\n", + " \n", + " initial_values.append(initial)\n", + " final_values.append(final)\n", + " improvements.append(improvement)\n", + " \n", + " print(f\" Sample {idx+1}: {initial:.4f} → {final:.4f} ({improvement:+.4f})\")\n", + " \n", + " if improvements:\n", + " avg_improvement = np.mean(improvements)\n", + " std_improvement = np.std(improvements)\n", + " print(f\"\\n Average Improvement: {avg_improvement:+.4f} (±{std_improvement:.4f})\")\n", + " print(f\" Converged: {'YES' if std_improvement < 0.1 * abs(avg_improvement) else 'NO'}\")\n", + " \n", + " # Summary\n", + " print(\"\\n\" + \"=\"*70)\n", + " print(\"SUMMARY\")\n", + " print(\"=\"*70)\n", + " print(f\"Total samples analyzed: {len(results)}\")\n", + " print(f\"Gradient ascent config: {grad_config}\")\n", + " print(f\"\\nConclusion: Analyze the plots above to determine convergence behavior.\")\n", + " print(f\"Look for:\")\n", + " print(f\" 1. Metrics plateauing (flattening out)\")\n", + " print(f\" 2. Consistent improvement across samples\")\n", + " print(f\" 3. Low variance in final metric values\")\n", + "\n", + "analyze_convergence(all_results)" + ] + }, + { + "cell_type": "markdown", + "id": "d263be5f", + "metadata": {}, + "source": [ + "#### Save Results Summary" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5434e7c0", + "metadata": {}, + "outputs": [], + "source": [ + "# Save comprehensive summary\n", + "summary = {\n", + " 'config': {\n", + " 'num_samples': NUM_SAMPLES,\n", + " 'num_inference_steps': NUM_INFERENCE_STEPS,\n", + " 'cfg_scale': CFG_SCALE,\n", + " 'grad_config': grad_config,\n", + " 'metrics': METRICS,\n", + " 'model_variant': MODEL_VARIANT\n", + " },\n", + " 'samples': []\n", + "}\n", + "\n", + "for idx, result in enumerate(all_results):\n", + " metrics = result['metrics']\n", + " sample_summary = {\n", + " 'sample_id': idx + 1,\n", + " 'prompt': result['prompt'],\n", + " 'reference_image': result['reference_image']\n", + " }\n", + " \n", + " for metric_name in ['reward', 'clip', 'aesthetic', 'pickscore', 'hpsv2']:\n", + " if metric_name in metrics:\n", + " values = [v for v in metrics[metric_name] if v is not None]\n", + " if values:\n", + " sample_summary[metric_name] = {\n", + " 'initial': values[0],\n", + " 'final': values[-1],\n", + " 'improvement': values[-1] - values[0],\n", + " 'all_values': values\n", + " }\n", + " \n", + " summary['samples'].append(sample_summary)\n", + "\n", + "# Save summary\n", + "with open(Path(OUTPUT_DIR) / \"convergence_summary.json\", 'w') as f:\n", + " json.dump(summary, f, indent=2)\n", + "\n", + "print(f\"\\n✓ Results saved to: {OUTPUT_DIR}\")\n", + "print(f\" - convergence_summary.json\")\n", + "print(f\" - all_samples_comparison.png\")\n", + "print(f\" - sample_X/ directories with individual results\")" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.18" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/Reward_sdxl_idealized/tune_hyperparams.py b/Reward_sdxl_idealized/tune_hyperparams.py new file mode 100644 index 0000000000000000000000000000000000000000..b8fe2fe7abfe8716edd76d67f640f6cf86f90a94 --- /dev/null +++ b/Reward_sdxl_idealized/tune_hyperparams.py @@ -0,0 +1,514 @@ +""" +Hyperparameter tuning script for gradient ascent optimization. + +This script performs a systematic search over hyperparameter combinations +to find the optimal configuration for maximum evaluation scores. +""" + +import subprocess +import json +import argparse +from pathlib import Path +from datetime import datetime +import itertools +import numpy as np +from typing import Dict, List, Any +import re + + +class HyperparameterTuner: + """Hyperparameter tuner for gradient ascent.""" + + def __init__( + self, + output_dir: str = "tuning_results", + max_samples: int = 30, + num_steps: int = 20, + dataset_type: str = "pickapic", + model_variant: str = "lpo", + cuda_id: int = 0, + metrics: List[str] = None + ): + self.output_dir = Path(output_dir) + self.output_dir.mkdir(parents=True, exist_ok=True) + + self.max_samples = max_samples + self.num_steps = num_steps + self.dataset_type = dataset_type + self.model_variant = model_variant + self.cuda_id = cuda_id + self.metrics = metrics or ["clip", "aesthetic", "pickscore", "hpsv2", "imagereward"] + + # Store results + self.results = [] + self.baseline_results = None + + def define_search_space(self) -> List[Dict[str, Any]]: + """Define the hyperparameter search space - FULL GRID SEARCH. + + Tests all combinations of parameters including momentum overrides for configs that support it. + """ + + # Define all parameter values + cfg_scales = [3.0, 5.0, 7.5] # + + # All available gradient configs from grad_ascent_configs.py + grad_configs = [ + # "constant", + # "linear", + "cosine_nesterov", + # "low_to_high_nesterov", + # "high_to_low_nesterov", + "low_to_high_momentum", + "high_to_low_momentum", + ] + + num_grad_steps_list = [1, 2] # 5, 7, 10 + grad_step_sizes = [0.001, 0.005, 0.01, 0.05] # + momentums = [0.5, 0.8, 0.9] # + + # Generate ALL combinations using itertools.product + configs = [] + for cfg, grad_cfg, num_steps, step_size, momentum in itertools.product( + cfg_scales, grad_configs, num_grad_steps_list, grad_step_sizes, momentums + ): + configs.append({ + "cfg_scale": cfg, + "grad_config": grad_cfg, + "num_grad_steps": num_steps, + "grad_step_size": step_size, + "momentum": momentum, + }) + + print(f"\nGenerated {len(configs)} total configurations") + print(f" cfg_scales: {len(cfg_scales)}") + print(f" grad_configs: {len(grad_configs)}") + print(f" num_grad_steps: {len(num_grad_steps_list)}") + print(f" grad_step_sizes: {len(grad_step_sizes)}") + print(f" momentums: {len(momentums)}") + print(f" Total: {len(cfg_scales)} × {len(grad_configs)} × {len(num_grad_steps_list)} × {len(grad_step_sizes)} × {len(momentums)} = {len(configs)}") + + return configs + + def run_baseline(self) -> Dict[str, float]: + """Run baseline evaluation once.""" + print("\n" + "="*80) + print("RUNNING BASELINE EVALUATION") + print("="*80) + + # Use median cfg_scale for baseline + cfg_scale = 5.0 + + output_dir = self.output_dir / "baseline" + + cmd = [ + "python", "eval.py", + "--model_variant", self.model_variant, + "--dataset_type", self.dataset_type, + "--max_samples", str(self.max_samples), + "--num_steps", str(self.num_steps), + "--cfg_scale", str(cfg_scale), + "--output_dir", str(output_dir), + "--cuda", str(self.cuda_id), + "--mode", "baseline", + "--metrics", *self.metrics, + ] + + print(f"Command: {' '.join(cmd)}") + + try: + result = subprocess.run(cmd, capture_output=True, text=True, check=True) + + # Parse results from output + metrics = self._parse_metrics(result.stdout, "baseline") + + print(f"\nBaseline Results:") + for metric, value in metrics.items(): + print(f" {metric}: {value:.4f}") + + self.baseline_results = { + "cfg_scale": cfg_scale, + "metrics": metrics, + } + + return metrics + + except subprocess.CalledProcessError as e: + print(f"Error running baseline: {e}") + print(f"Stdout: {e.stdout}") + print(f"Stderr: {e.stderr}") + return {} + + def run_experiment(self, config: Dict[str, Any]) -> Dict[str, Any]: + """Run a single experiment with given hyperparameters.""" + + # Create output directory for this config + config_name = f"cfg{config['cfg_scale']}_" \ + f"{config['grad_config']}_" \ + f"steps{config['num_grad_steps']}_" \ + f"lr{config['grad_step_size']}_" \ + f"mom{config['momentum']}" + + output_dir = self.output_dir / config_name + + # Build command + cmd = [ + "python", "eval.py", + "--model_variant", self.model_variant, + "--dataset_type", self.dataset_type, + "--grad_config", config["grad_config"], + "--max_samples", str(self.max_samples), + "--num_steps", str(self.num_steps), + "--cfg_scale", str(config["cfg_scale"]), + "--output_dir", str(output_dir), + "--cuda", str(self.cuda_id), + "--mode", "gradient_ascent", + "--metrics", *self.metrics, + # Override config parameters + "--override_num_grad_steps", str(config["num_grad_steps"]), + "--override_grad_step_size", str(config["grad_step_size"]), + "--override_momentum", str(config["momentum"]), + ] + + print(f"\nRunning experiment: {config_name}") + print(f"Config: {config}") + + try: + result = subprocess.run(cmd, capture_output=True, text=True, check=True) + + # Parse metrics from output + metrics = self._parse_metrics(result.stdout, "gradient_ascent") + + # Compute improvement over baseline + improvements = {} + if self.baseline_results: + baseline_metrics = self.baseline_results["metrics"] + for metric, value in metrics.items(): + if metric in baseline_metrics: + baseline_val = baseline_metrics[metric] + if baseline_val != 0: + improvement = ((value - baseline_val) / abs(baseline_val)) * 100 + improvements[f"{metric}_improvement"] = improvement + + result_dict = { + "config": config, + "metrics": metrics, + "improvements": improvements, + "output_dir": str(output_dir), + "timestamp": datetime.now().isoformat(), + } + + print(f"Results:") + for metric, value in metrics.items(): + print(f" {metric}: {value:.4f}") + if improvements: + print(f"Improvements over baseline:") + for metric, value in improvements.items(): + print(f" {metric}: {value:+.2f}%") + + return result_dict + + except subprocess.CalledProcessError as e: + print(f"Error running experiment: {e}") + print(f"Stderr: {e.stderr}") + return { + "config": config, + "error": str(e), + "timestamp": datetime.now().isoformat(), + } + + def _parse_metrics(self, output: str, mode: str) -> Dict[str, float]: + """Parse metrics from eval.py output.""" + metrics = {} + + # Look for the summary section + lines = output.split('\n') + + # Pattern to match metric lines like " Reward: 0.1234" + metric_patterns = { + "reward": r"Reward:\s+([-+]?\d*\.?\d+)", + "clip": r"CLIP Score:\s+([-+]?\d*\.?\d+)", + "aesthetic": r"Aesthetic Score:\s+([-+]?\d*\.?\d+)", + "pickscore": r"PickScore:\s+([-+]?\d*\.?\d+)", + "hpsv2": r"HPSv2 Score:\s+([-+]?\d*\.?\d+)", + "hpsv21": r"HPSv2\.1 Score:\s+([-+]?\d*\.?\d+)", + "imagereward": r"ImageReward:\s+([-+]?\d*\.?\d+)", + "fid": r"FID:\s+([-+]?\d*\.?\d+)", + } + + for line in lines: + for metric_name, pattern in metric_patterns.items(): + match = re.search(pattern, line) + if match: + metrics[metric_name] = float(match.group(1)) + + return metrics + + def compute_aggregate_score(self, metrics: Dict[str, float]) -> float: + """ + Compute aggregate score for ranking configurations. + + Uses weighted combination of metrics (higher is better for most, + except FID which is lower is better). + """ + weights = { + "reward": 1.0, + "clip": 0.8, + "aesthetic": 0.8, + "pickscore": 1.0, + "hpsv2": 1.0, + "hpsv21": 1.0, + "imagereward": 1.0, + "fid": -0.5, # Negative weight (lower FID is better) + } + + score = 0.0 + total_weight = 0.0 + + for metric, value in metrics.items(): + if metric in weights: + score += weights[metric] * value + total_weight += abs(weights[metric]) + + # Normalize by total weight + if total_weight > 0: + score /= total_weight + + return score + + def run_search( + self, + search_type: str = "grid", + start_idx: int = 0, + end_idx: int = None + ) -> List[Dict[str, Any]]: + """ + Run hyperparameter search. + + Args: + search_type: Type of search ("grid" or "random") + start_idx: Starting index for experiments (for GPU distribution) + end_idx: Ending index for experiments (for GPU distribution) + """ + all_configs = self.define_search_space() + + print("\n" + "="*80) + print("HYPERPARAMETER SEARCH CONFIGURATION") + print("="*80) + print(f"Dataset: {self.dataset_type}") + print(f"Model: {self.model_variant}") + print(f"Samples: {self.max_samples}") + print(f"Inference steps: {self.num_steps}") + print(f"Metrics: {', '.join(self.metrics)}") + + # Select subset of configs if indices provided + if search_type == "grid": + configs = all_configs + elif search_type == "random": + # Random sample from all configs + n_samples = min(50, len(all_configs)) + indices = np.random.choice(len(all_configs), n_samples, replace=False) + configs = [all_configs[i] for i in indices] + else: + raise ValueError(f"Unknown search type: {search_type}") + + # Apply index slicing for GPU distribution + if end_idx is None: + end_idx = len(configs) + configs = configs[start_idx:end_idx] + + print(f"\nTotal configurations: {len(all_configs)}") + print(f"Assigned to this worker: {len(configs)} (indices {start_idx} to {end_idx})") + + # Run baseline first + if self.baseline_results is None: + self.run_baseline() + + # Run experiments + print("\n" + "="*80) + print("RUNNING EXPERIMENTS") + print("="*80) + + for i, config in enumerate(configs, 1): + print(f"\n{'='*80}") + print(f"Experiment {i}/{len(configs)}") + print(f"{'='*80}") + + result = self.run_experiment(config) + self.results.append(result) + + # Save intermediate results + self._save_results() + + return self.results + + def _generate_grid_configs(self, search_space: Dict[str, List[Any]]) -> List[Dict[str, Any]]: + """Generate all combinations for grid search.""" + keys = list(search_space.keys()) + values = list(search_space.values()) + + configs = [] + for combination in itertools.product(*values): + config = dict(zip(keys, combination)) + configs.append(config) + + return configs + + def _generate_random_configs( + self, + search_space: Dict[str, List[Any]], + n_samples: int = 20 + ) -> List[Dict[str, Any]]: + """Generate random configurations for random search.""" + configs = [] + + for _ in range(n_samples): + config = {} + for param, values in search_space.items(): + config[param] = np.random.choice(values) + configs.append(config) + + return configs + + def _save_results(self): + """Save results to JSON file.""" + results_file = self.output_dir / "tuning_results.json" + + data = { + "baseline": self.baseline_results, + "experiments": self.results, + "timestamp": datetime.now().isoformat(), + "config": { + "max_samples": self.max_samples, + "num_steps": self.num_steps, + "dataset_type": self.dataset_type, + "model_variant": self.model_variant, + } + } + + with open(results_file, 'w') as f: + json.dump(data, f, indent=2) + + print(f"\nResults saved to: {results_file}") + + def analyze_results(self) -> Dict[str, Any]: + """Analyze results and find best configuration.""" + if not self.results: + print("No results to analyze!") + return {} + + print("\n" + "="*80) + print("ANALYSIS: FINDING BEST CONFIGURATION") + print("="*80) + + # Filter out failed experiments + successful_results = [r for r in self.results if "metrics" in r] + + if not successful_results: + print("No successful experiments!") + return {} + + # Compute aggregate scores + for result in successful_results: + metrics = result["metrics"] + result["aggregate_score"] = self.compute_aggregate_score(metrics) + + # Sort by aggregate score + successful_results.sort(key=lambda x: x["aggregate_score"], reverse=True) + + # Print top 5 configurations + print("\nTop 5 Configurations:") + print("="*80) + + for i, result in enumerate(successful_results[:5], 1): + print(f"\n#{i} - Aggregate Score: {result['aggregate_score']:.4f}") + print(f"Config: {result['config']}") + print(f"Metrics:") + for metric, value in result['metrics'].items(): + print(f" {metric}: {value:.4f}") + if result.get('improvements'): + print(f"Improvements over baseline:") + for metric, value in result['improvements'].items(): + print(f" {metric}: {value:+.2f}%") + + # Save best config + best_result = successful_results[0] + best_config_file = self.output_dir / "best_config.json" + + with open(best_config_file, 'w') as f: + json.dump({ + "config": best_result["config"], + "metrics": best_result["metrics"], + "aggregate_score": best_result["aggregate_score"], + "improvements": best_result.get("improvements", {}), + }, f, indent=2) + + print(f"\n✓ Best configuration saved to: {best_config_file}") + + return best_result + + +def main(): + parser = argparse.ArgumentParser(description="Hyperparameter tuning for gradient ascent") + parser.add_argument("--output_dir", type=str, default="tuning_results", + help="Directory to save tuning results") + parser.add_argument("--max_samples", type=int, default=30, + help="Number of samples to use for tuning") + parser.add_argument("--num_steps", type=int, default=20, + help="Number of inference steps (fixed)") + parser.add_argument("--dataset_type", type=str, default="pickapic", + choices=["coco", "pickapic"], + help="Dataset to use") + parser.add_argument("--model_variant", type=str, default="lpo", + choices=["origin", "spo", "diffusion_dpo", "lpo"], + help="Model variant to use") + parser.add_argument("--cuda", type=int, default=0, + help="CUDA device ID") + parser.add_argument("--search_type", type=str, default="grid", + choices=["grid", "random"], + help="Type of hyperparameter search") + parser.add_argument("--metrics", type=str, nargs="+", + default=["clip", "aesthetic", "pickscore", "hpsv2", "imagereward"], + help="Metrics to evaluate") + parser.add_argument("--start_idx", type=int, default=0, + help="Starting index for experiments (for GPU distribution)") + parser.add_argument("--end_idx", type=int, default=None, + help="Ending index for experiments (for GPU distribution)") + + args = parser.parse_args() + + # Create tuner + tuner = HyperparameterTuner( + output_dir=args.output_dir, + max_samples=args.max_samples, + num_steps=args.num_steps, + dataset_type=args.dataset_type, + model_variant=args.model_variant, + cuda_id=args.cuda, + metrics=args.metrics, + ) + + # Run search + results = tuner.run_search( + search_type=args.search_type, + start_idx=args.start_idx, + end_idx=args.end_idx + ) + + # Analyze results + best_result = tuner.analyze_results() + + print("\n" + "="*80) + print("TUNING COMPLETE!") + print("="*80) + print(f"Total experiments: {len(results)}") + print(f"Results directory: {args.output_dir}") + + if best_result: + print(f"\nBest configuration:") + print(json.dumps(best_result["config"], indent=2)) + print(f"\nAggregate score: {best_result['aggregate_score']:.4f}") + + +if __name__ == "__main__": + main() diff --git a/Reward_sdxl_idealized/tune_parallel.sh b/Reward_sdxl_idealized/tune_parallel.sh new file mode 100644 index 0000000000000000000000000000000000000000..c2a85d0bdc1567eafa7546f5f4fe694440c35eb3 --- /dev/null +++ b/Reward_sdxl_idealized/tune_parallel.sh @@ -0,0 +1,253 @@ +#!/bin/bash + +# Parallel hyperparameter tuning across 8 GPUs +# This script distributes experiments evenly across all available GPUs + +clear + +# Activate conda environment +source ~/miniconda3/etc/profile.d/conda.sh +conda activate /home/ec2-user/aev + +# Configuration +DATASET_TYPE="pickapic" # "coco" or "pickapic" +MODEL_VARIANT="lpo" # "origin", "spo", "diffusion_dpo", or "lpo" +MAX_SAMPLES=500 # Number of samples for tuning +NUM_STEPS=50 # Fixed inference steps +SEARCH_TYPE="grid" # "grid" or "random" +OUTPUT_DIR="RESULTS_TURNING/run_2" +NUM_GPUS=8 # Number of GPUs to use + +echo "==============================================" +echo " PARALLEL HYPERPARAMETER TUNING" +echo "==============================================" +echo "" +echo "Configuration:" +echo " Dataset: $DATASET_TYPE" +echo " Model: $MODEL_VARIANT" +echo " Samples: $MAX_SAMPLES" +echo " Inference Steps: $NUM_STEPS" +echo " Search Type: $SEARCH_TYPE" +echo " GPUs: $NUM_GPUS" +echo " Output: $OUTPUT_DIR" +echo "" + +# First, calculate total number of experiments +echo "Calculating total experiments..." +TOTAL_CONFIGS=$(python -c " +from tune_hyperparams import HyperparameterTuner +import sys +tuner = HyperparameterTuner() +configs = tuner.define_search_space() +sys.stderr.write(f'Generated {len(configs)} configurations\n') +print(len(configs)) +" 2>&1 | tail -1) + +echo "Total configurations: $TOTAL_CONFIGS" +echo "" + +# Calculate experiments per GPU +CONFIGS_PER_GPU=$((TOTAL_CONFIGS / NUM_GPUS)) +REMAINDER=$((TOTAL_CONFIGS % NUM_GPUS)) + +echo "Distributing work:" +echo " Base configs per GPU: $CONFIGS_PER_GPU" +echo " Extra configs for first GPUs: $REMAINDER" +echo "" + +# Create output directory +mkdir -p "$OUTPUT_DIR" + +# Array to store background process IDs +PIDS=() + +# Launch parallel processes on each GPU +for GPU_ID in $(seq 0 $((NUM_GPUS - 1))); do + # Calculate start and end indices for this GPU + START_IDX=$((GPU_ID * CONFIGS_PER_GPU)) + + # Give extra configs to first GPUs + if [ $GPU_ID -lt $REMAINDER ]; then + START_IDX=$((START_IDX + GPU_ID)) + END_IDX=$((START_IDX + CONFIGS_PER_GPU + 1)) + else + START_IDX=$((START_IDX + REMAINDER)) + END_IDX=$((START_IDX + CONFIGS_PER_GPU)) + fi + + # Create GPU-specific output directory + GPU_OUTPUT_DIR="${OUTPUT_DIR}/gpu_${GPU_ID}" + mkdir -p "$GPU_OUTPUT_DIR" + + echo "GPU $GPU_ID: configs $START_IDX to $END_IDX" + + # Launch tuning process in background + nohup python tune_hyperparams.py \ + --output_dir "$GPU_OUTPUT_DIR" \ + --max_samples $MAX_SAMPLES \ + --num_steps $NUM_STEPS \ + --dataset_type "$DATASET_TYPE" \ + --model_variant "$MODEL_VARIANT" \ + --cuda $GPU_ID \ + --search_type "$SEARCH_TYPE" \ + --start_idx $START_IDX \ + --end_idx $END_IDX \ + --metrics clip aesthetic pickscore hpsv2 imagereward \ + > "${GPU_OUTPUT_DIR}/tuning.log" 2>&1 & + + # Store PID + PIDS+=($!) + + echo " Launched with PID: ${PIDS[$GPU_ID]}" + + # Small delay to avoid race conditions + sleep 2 +done + +echo "" +echo "==============================================" +echo " ALL PROCESSES LAUNCHED" +echo "==============================================" +echo "" +echo "Background processes running:" +for GPU_ID in $(seq 0 $((NUM_GPUS - 1))); do + echo " GPU $GPU_ID: PID ${PIDS[$GPU_ID]} -> ${OUTPUT_DIR}/gpu_${GPU_ID}/tuning.log" +done +echo "" +echo "To monitor progress:" +echo " tail -f ${OUTPUT_DIR}/gpu_0/tuning.log" +echo " tail -f ${OUTPUT_DIR}/gpu_1/tuning.log" +echo " ... etc" +echo "" +echo "To check all GPU processes:" +echo " ps aux | grep tune_hyperparams.py" +echo "" +echo "To monitor GPU usage:" +echo " watch -n 1 nvidia-smi" +echo "" +echo "To kill all processes:" +echo " kill ${PIDS[@]}" +echo "" +echo "Waiting for all processes to complete..." +echo "(Press Ctrl+C to stop waiting, processes will continue in background)" +echo "" + +# Wait for all background processes +for PID in "${PIDS[@]}"; do + wait $PID +done + +echo "" +echo "==============================================" +echo " ALL TUNING PROCESSES COMPLETE" +echo "==============================================" +echo "" + +# Merge results from all GPUs +echo "Merging results from all GPUs..." + +# Activate conda environment for Python script +source ~/miniconda3/etc/profile.d/conda.sh +conda activate /home/ec2-user/aev + +python - <<'EOF' +import json +from pathlib import Path +import sys + +output_dir = Path("RESULTS_TURNING") +all_results = [] +baseline_result = None + +# Collect results from each GPU +for gpu_id in range(8): + gpu_dir = output_dir / f"gpu_{gpu_id}" + results_file = gpu_dir / "tuning_results.json" + + if results_file.exists(): + with open(results_file, 'r') as f: + data = json.load(f) + + # Get baseline (should be same from all) + if baseline_result is None and "baseline" in data: + baseline_result = data["baseline"] + + # Collect experiments + if "experiments" in data: + all_results.extend(data["experiments"]) + + print(f"GPU {gpu_id}: {len(data.get('experiments', []))} results") + +# Merge all results +merged_data = { + "baseline": baseline_result, + "experiments": all_results, + "num_gpus": 8, + "total_experiments": len(all_results) +} + +# Save merged results +merged_file = output_dir / "merged_results.json" +with open(merged_file, 'w') as f: + json.dump(merged_data, f, indent=2) + +print(f"\nMerged {len(all_results)} total results") +print(f"Saved to: {merged_file}") + +# Find best configuration +successful = [r for r in all_results if "metrics" in r] +if successful: + # Compute aggregate scores + def compute_score(metrics): + weights = { + "reward": 1.0, "clip": 0.8, "aesthetic": 0.8, + "pickscore": 1.0, "hpsv2": 1.0, "imagereward": 1.0, + "fid": -0.5 + } + score = sum(weights.get(k, 0) * v for k, v in metrics.items()) + return score / sum(abs(w) for w in weights.values()) + + for r in successful: + r["aggregate_score"] = compute_score(r["metrics"]) + + successful.sort(key=lambda x: x["aggregate_score"], reverse=True) + + best = successful[0] + best_file = output_dir / "best_config.json" + with open(best_file, 'w') as f: + json.dump({ + "config": best["config"], + "metrics": best["metrics"], + "aggregate_score": best["aggregate_score"], + "improvements": best.get("improvements", {}) + }, f, indent=2) + + print(f"\n{'='*60}") + print("BEST CONFIGURATION:") + print(f"{'='*60}") + print(json.dumps(best["config"], indent=2)) + print(f"\nAggregate Score: {best['aggregate_score']:.4f}") + print(f"Saved to: {best_file}") +else: + print("\nNo successful experiments found!") + sys.exit(1) +EOF + +if [ $? -eq 0 ]; then + echo "" + echo "==============================================" + echo " TUNING COMPLETE!" + echo "==============================================" + echo "" + echo "Results:" + echo " Merged results: ${OUTPUT_DIR}/merged_results.json" + echo " Best config: ${OUTPUT_DIR}/best_config.json" + echo "" + echo "View best configuration:" + echo " cat ${OUTPUT_DIR}/best_config.json" + echo "" +else + echo "" + echo "ERROR: Failed to merge results" + exit 1 +fi diff --git a/__pycache__/upload.cpython-311.pyc b/__pycache__/upload.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..55a5ca99f6d0bd7d210f716a09c3aa1f58801072 Binary files /dev/null and b/__pycache__/upload.cpython-311.pyc differ diff --git a/evaluation/open_clip/__pycache__/__init__.cpython-311.pyc b/evaluation/open_clip/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..21691ba4658db42282b8aa93b4e24ff9270f83fe Binary files /dev/null and b/evaluation/open_clip/__pycache__/__init__.cpython-311.pyc differ diff --git a/evaluation/open_clip/__pycache__/coca_model.cpython-311.pyc b/evaluation/open_clip/__pycache__/coca_model.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..de5b6ac5b06b89bd07b0884f10822025747250d7 Binary files /dev/null and b/evaluation/open_clip/__pycache__/coca_model.cpython-311.pyc differ diff --git a/evaluation/open_clip/__pycache__/hf_model.cpython-311.pyc b/evaluation/open_clip/__pycache__/hf_model.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..77ab5ae56aa3aaf56eb710d45313aa504cf21800 Binary files /dev/null and b/evaluation/open_clip/__pycache__/hf_model.cpython-311.pyc differ diff --git a/evaluation/open_clip/__pycache__/loss.cpython-311.pyc b/evaluation/open_clip/__pycache__/loss.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e5ee30f20695290e77193ce22bfe26a4918d9b24 Binary files /dev/null and b/evaluation/open_clip/__pycache__/loss.cpython-311.pyc differ diff --git a/evaluation/open_clip/__pycache__/model.cpython-311.pyc b/evaluation/open_clip/__pycache__/model.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f4672150333d121bbec9f401692319c8539ca512 Binary files /dev/null and b/evaluation/open_clip/__pycache__/model.cpython-311.pyc differ diff --git a/evaluation/open_clip/__pycache__/pretrained.cpython-311.pyc b/evaluation/open_clip/__pycache__/pretrained.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..9ee4295a4cfa2934e33158801bd6d409d5484242 Binary files /dev/null and b/evaluation/open_clip/__pycache__/pretrained.cpython-311.pyc differ diff --git a/evaluation/open_clip/__pycache__/push_to_hf_hub.cpython-311.pyc b/evaluation/open_clip/__pycache__/push_to_hf_hub.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..fdd9b559b75998d7504652ac4cc40750068f1287 Binary files /dev/null and b/evaluation/open_clip/__pycache__/push_to_hf_hub.cpython-311.pyc differ diff --git a/evaluation/open_clip/__pycache__/tokenizer.cpython-311.pyc b/evaluation/open_clip/__pycache__/tokenizer.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..9f8d3f3512cc5149fdf8b1f16a6783b80ce630f2 Binary files /dev/null and b/evaluation/open_clip/__pycache__/tokenizer.cpython-311.pyc differ diff --git a/evaluation/open_clip/__pycache__/transform.cpython-311.pyc b/evaluation/open_clip/__pycache__/transform.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..82ff729925013700a7cf35c0d08556719b72d470 Binary files /dev/null and b/evaluation/open_clip/__pycache__/transform.cpython-311.pyc differ diff --git a/evaluation/open_clip/__pycache__/transformer.cpython-311.pyc b/evaluation/open_clip/__pycache__/transformer.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..75fa853777dc673eb0933dc56651cb650c99bd61 Binary files /dev/null and b/evaluation/open_clip/__pycache__/transformer.cpython-311.pyc differ diff --git a/evaluation/open_clip/__pycache__/utils.cpython-311.pyc b/evaluation/open_clip/__pycache__/utils.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..092bb4722b6987f6f7dc198e77665c058a3e82f4 Binary files /dev/null and b/evaluation/open_clip/__pycache__/utils.cpython-311.pyc differ diff --git a/evaluation/open_clip/model_configs/RN50.json b/evaluation/open_clip/model_configs/RN50.json new file mode 100644 index 0000000000000000000000000000000000000000..33aa884d54fee0076c33676831e49d5e1ffcb8f2 --- /dev/null +++ b/evaluation/open_clip/model_configs/RN50.json @@ -0,0 +1,21 @@ +{ + "embed_dim": 1024, + "vision_cfg": { + "image_size": 224, + "layers": [ + 3, + 4, + 6, + 3 + ], + "width": 64, + "patch_size": null + }, + "text_cfg": { + "context_length": 77, + "vocab_size": 49408, + "width": 512, + "heads": 8, + "layers": 12 + } +} \ No newline at end of file diff --git a/evaluation/open_clip/model_configs/ViT-B-32-plus-256.json b/evaluation/open_clip/model_configs/ViT-B-32-plus-256.json new file mode 100644 index 0000000000000000000000000000000000000000..2f09c857de9a4c01ae51297a7e2451984879f9de --- /dev/null +++ b/evaluation/open_clip/model_configs/ViT-B-32-plus-256.json @@ -0,0 +1,16 @@ +{ + "embed_dim": 640, + "vision_cfg": { + "image_size": 256, + "layers": 12, + "width": 896, + "patch_size": 32 + }, + "text_cfg": { + "context_length": 77, + "vocab_size": 49408, + "width": 640, + "heads": 10, + "layers": 12 + } +} \ No newline at end of file diff --git a/evaluation/open_clip/model_configs/ViT-S-32.json b/evaluation/open_clip/model_configs/ViT-S-32.json new file mode 100644 index 0000000000000000000000000000000000000000..9b8b4191b268de267268cfcb90fc01c6b9df07d8 --- /dev/null +++ b/evaluation/open_clip/model_configs/ViT-S-32.json @@ -0,0 +1,16 @@ +{ + "embed_dim": 384, + "vision_cfg": { + "image_size": 224, + "layers": 12, + "width": 384, + "patch_size": 32 + }, + "text_cfg": { + "context_length": 77, + "vocab_size": 49408, + "width": 384, + "heads": 6, + "layers": 12 + } +} \ No newline at end of file diff --git a/evaluation/open_clip/model_configs/convnext_large_d_320.json b/evaluation/open_clip/model_configs/convnext_large_d_320.json new file mode 100644 index 0000000000000000000000000000000000000000..54c3df36a6f56ace0b12ada24c13058de96feed8 --- /dev/null +++ b/evaluation/open_clip/model_configs/convnext_large_d_320.json @@ -0,0 +1,19 @@ +{ + "embed_dim": 768, + "vision_cfg": { + "timm_model_name": "convnext_large", + "timm_model_pretrained": false, + "timm_pool": "", + "timm_proj": "mlp", + "timm_drop": 0.0, + "timm_drop_path": 0.1, + "image_size": 320 + }, + "text_cfg": { + "context_length": 77, + "vocab_size": 49408, + "width": 768, + "heads": 12, + "layers": 16 + } +} \ No newline at end of file diff --git a/lrm/flux/.hydra/config.yaml b/lrm/flux/.hydra/config.yaml new file mode 100644 index 0000000000000000000000000000000000000000..df0c4a4b12f0fcf5a5ef36653c042c5728c18845 --- /dev/null +++ b/lrm/flux/.hydra/config.yaml @@ -0,0 +1,124 @@ +accelerator: + _target_: trainer.accelerators.debug_accelerator.DebugAccelerator + output_dir: ${output_dir} + mixed_precision: BF16 + gradient_accumulation_steps: 1 + log_with: null + debug: + activate: false + port: 5900 + seed: 42 + resume_from_checkpoint: false + max_steps: 8000 + num_epochs: 10 + validate_steps: 100 + generalization_validate_steps: 500 + eval_on_start: true + project_name: reward_model + run_name: step_flux_schnell_variable-t_lr1e-5_step-8000_cfg0.0_filter2_time951 + max_grad_norm: 1.0 + save_steps: 100 + metric_name: accuracy + metric_mode: MAX + limit_num_checkpoints: 1 + save_only_if_best: true + dynamo_backend: 'NO' + keep_best_ckpts: true +task: + limit_examples_to_wandb: 50 + _target_: trainer.tasks.step_flux_task.StepFluxTask + pretrained_model_name_or_path: ${model.pretrained_model_name_or_path} + tokenizer_subfolder: tokenizer + label_0_column_name: ${dataset.label_0_column_name} + label_1_column_name: ${dataset.label_1_column_name} + input_ids_column_name: ${dataset.input_ids_column_name} + input_ids_2_column_name: ${dataset.input_ids_2_column_name} + pixels_0_column_name: ${dataset.pixels_0_column_name} + pixels_1_column_name: ${dataset.pixels_1_column_name} + timestep_column_name: ${dataset.timestep_column_name} + constant_timestep: ${dataset.constant_timestep} +model: + _target_: trainer.models.flux_preference_model.FluxPreferenceModel + pretrained_model_name_or_path: black-forest-labs/FLUX.1-schnell + pretrained_vae_name_or_path: black-forest-labs/FLUX.1-schnell + projection_dim: 1024 + text_embed_dim: 768 + logit_scale_init_value: 2.6592 + freeze_text_encoder: false + guidance_scale: 0.0 + noise_offset: false + noise_offset_coeff: 0.05 + max_sequence_length: 512 + image_size: 1024 +criterion: + _target_: trainer.criterions.step_clip_criterion_flux.StepFluxCLIPCriterion + is_distributed: false + label_0_column_name: ${dataset.label_0_column_name} + label_1_column_name: ${dataset.label_1_column_name} + input_ids_column_name: ${dataset.input_ids_column_name} + input_ids_2_column_name: ${dataset.input_ids_2_column_name} + pixels_0_column_name: ${dataset.pixels_0_column_name} + pixels_1_column_name: ${dataset.pixels_1_column_name} + num_examples_per_prompt_column_name: ${dataset.num_examples_per_prompt_column_name} + timestep_column_name: ${dataset.timestep_column_name} + loss_type: pair + batch_coeff: 1.0 + aux_loss_coeff: 1.0 +dataset: + train_split_name: train + valid_split_name: validation_unique + test_split_name: test_unique + batch_size: 4 + num_workers: 2 + drop_last: true + _target_: trainer.datasets.step_flux_hf_dataset.StepFluxHFDataset + dataset_name: pickapic-anonymous/pickapic_v1 + dataset_config_name: null + from_disk: false + cache_dir: null + caption_column_name: caption + input_ids_column_name: input_ids + input_ids_2_column_name: input_ids_2 + image_0_column_name: jpg_0 + image_1_column_name: jpg_1 + label_0_column_name: label_0 + label_1_column_name: label_1 + are_different_column_name: are_different + has_label_column_name: has_label + pixels_0_column_name: pixel_values_0 + pixels_1_column_name: pixel_values_1 + timestep_column_name: timestep + constant_timestep: 1 + variable_timestep: true + largest_timestep: 951 + compare_between_timestep: false + timestep_comparison_column_name: timestep_comparison + timestep_interval: 1 + num_examples_per_prompt_column_name: num_example_per_prompt + keep_only_different: false + keep_only_with_label: false + keep_only_with_label_in_non_train: true + keep_only_with_pesudo_preference: true + pseudo_preference_path: /g/data/rr81/LPO/lrm/flux/vqa_aes_clip_score_mp.csv + filter_strategy: 2 + processor: + pretrained_model_name_or_path: ${model.pretrained_model_name_or_path} + max_sequence_length: ${model.max_sequence_length} + image_size: ${model.image_size} + random_crop: false + no_hflip: true + limit_examples_per_prompt: -1 + only_on_best: false +optimizer: + _target_: trainer.optimizers.dummy_optimizer.BaseDummyOptim + lr: 1.0e-05 + weight_decay: 0.3 +lr_scheduler: + _target_: trainer.lr_schedulers.dummy_lr_scheduler.instantiate_dummy_lr_scheduler + lr: ${optimizer.lr} + lr_warmup_steps: 1000 + total_num_steps: ${accelerator.max_steps} +debug: + activate: false + port: 5900 +output_dir: logs/lrm/${accelerator.project_name}/${accelerator.run_name} diff --git a/lrm/flux/.hydra/hydra.yaml b/lrm/flux/.hydra/hydra.yaml new file mode 100644 index 0000000000000000000000000000000000000000..8a7ae2a978d48da66001ea919d5c8ac54270a166 --- /dev/null +++ b/lrm/flux/.hydra/hydra.yaml @@ -0,0 +1,166 @@ +hydra: + run: + dir: . + sweep: + dir: multirun/${now:%Y-%m-%d}/${now:%H-%M-%S} + subdir: ${hydra.job.num} + launcher: + _target_: hydra._internal.core_plugins.basic_launcher.BasicLauncher + sweeper: + _target_: hydra._internal.core_plugins.basic_sweeper.BasicSweeper + max_batch_size: null + params: null + help: + app_name: ${hydra.job.name} + header: '${hydra.help.app_name} is powered by Hydra. + + ' + footer: 'Powered by Hydra (https://hydra.cc) + + Use --hydra-help to view Hydra specific help + + ' + template: '${hydra.help.header} + + == Configuration groups == + + Compose your configuration from those groups (group=option) + + + $APP_CONFIG_GROUPS + + + == Config == + + Override anything in the config (foo.bar=value) + + + $CONFIG + + + ${hydra.help.footer} + + ' + hydra_help: + template: 'Hydra (${hydra.runtime.version}) + + See https://hydra.cc for more info. + + + == Flags == + + $FLAGS_HELP + + + == Configuration groups == + + Compose your configuration from those groups (For example, append hydra/job_logging=disabled + to command line) + + + $HYDRA_CONFIG_GROUPS + + + Use ''--cfg hydra'' to Show the Hydra config. + + ' + hydra_help: ??? + hydra_logging: + version: 1 + formatters: + simple: + format: '[%(asctime)s][HYDRA] %(message)s' + handlers: + console: + class: logging.StreamHandler + formatter: simple + stream: ext://sys.stdout + root: + level: INFO + handlers: + - console + loggers: + logging_example: + level: DEBUG + disable_existing_loggers: false + job_logging: + version: 1 + formatters: + simple: + format: '[%(asctime)s][%(name)s][%(levelname)s] - %(message)s' + handlers: + console: + class: logging.StreamHandler + formatter: simple + stream: ext://sys.stdout + file: + class: logging.FileHandler + formatter: simple + filename: ${hydra.runtime.output_dir}/${hydra.job.name}.log + root: + level: INFO + handlers: + - console + - file + disable_existing_loggers: false + env: {} + mode: RUN + searchpath: [] + callbacks: {} + output_subdir: .hydra + overrides: + hydra: + - hydra.mode=RUN + task: + - accelerator.mixed_precision=BF16 + - accelerator.log_with=null + - accelerator=debug + - criterion.is_distributed=false + - dataset.pseudo_preference_path=/g/data/rr81/LPO/lrm/flux/vqa_aes_clip_score_mp.csv + job: + name: train + chdir: null + override_dirname: accelerator.log_with=null,accelerator.mixed_precision=BF16,accelerator=debug,criterion.is_distributed=false,dataset.pseudo_preference_path=/g/data/rr81/LPO/lrm/flux/vqa_aes_clip_score_mp.csv + id: ??? + num: ??? + config_name: step_flux_base + env_set: {} + env_copy: [] + config: + override_dirname: + kv_sep: '=' + item_sep: ',' + exclude_keys: [] + runtime: + version: 1.3.2 + version_base: '1.3' + cwd: /g/data/rr81/LPO/lrm/flux + config_sources: + - path: hydra.conf + schema: pkg + provider: hydra + - path: /g/data/rr81/LPO/lrm/flux/trainer/conf + schema: file + provider: main + - path: '' + schema: structured + provider: schema + output_dir: /g/data/rr81/LPO/lrm/flux + choices: + lr_scheduler: dummy + optimizer: dummy + dataset: step_flux + criterion: step_clip_flux + model: step_flux_base + task: step_flux + accelerator: debug + hydra/env: default + hydra/callbacks: null + hydra/job_logging: default + hydra/hydra_logging: default + hydra/hydra_help: default + hydra/help: default + hydra/sweeper: basic + hydra/launcher: basic + hydra/output: default + verbose: false diff --git a/lrm/flux/.hydra/overrides.yaml b/lrm/flux/.hydra/overrides.yaml new file mode 100644 index 0000000000000000000000000000000000000000..cfbea765103653086b8c8fc5f269a800118b4e2e --- /dev/null +++ b/lrm/flux/.hydra/overrides.yaml @@ -0,0 +1,5 @@ +- accelerator.mixed_precision=BF16 +- accelerator.log_with=null +- accelerator=debug +- criterion.is_distributed=false +- dataset.pseudo_preference_path=/g/data/rr81/LPO/lrm/flux/vqa_aes_clip_score_mp.csv diff --git a/lrm/flux/README.md b/lrm/flux/README.md new file mode 100644 index 0000000000000000000000000000000000000000..b261b50a60f586a8c40280e64195e9f56c8bd035 --- /dev/null +++ b/lrm/flux/README.md @@ -0,0 +1,4 @@ +Please check the train_flux.sh file +In line 21 there is a variable named "RUN_PROFILE" which can be set to "main" or "quick for testing. If set to "main", it will run the full training loop. If set to "quick", it will run a minimal training loop for testing purposes. + +I have set distributed shared for quick testing mode but distributed is set for main mode. diff --git a/lrm/flux/setup.py b/lrm/flux/setup.py new file mode 100644 index 0000000000000000000000000000000000000000..9b1d8c0d798ed46b11d2981c65f229ee0f0a76b0 --- /dev/null +++ b/lrm/flux/setup.py @@ -0,0 +1,3 @@ +from setuptools import setup, find_packages + +setup(name='trainer', version='1.0', packages=find_packages()) \ No newline at end of file diff --git a/lrm/flux/trainer/conf/step_flux_base.yaml b/lrm/flux/trainer/conf/step_flux_base.yaml new file mode 100644 index 0000000000000000000000000000000000000000..c0e990cbc8f717cd3186c08b906d155059a18dd4 --- /dev/null +++ b/lrm/flux/trainer/conf/step_flux_base.yaml @@ -0,0 +1,57 @@ +defaults: + - step_flux_base_config + - _self_ + +dataset: + batch_size: 1 + dataset_name: 'pickapic-anonymous/pickapic_v1' + from_disk: False + constant_timestep: 1 + variable_timestep: True + keep_only_with_pesudo_preference: True + filter_strategy: 2 + compare_between_timestep: False + timestep_interval: 1 + largest_timestep: 951 + +optimizer: + lr: 1e-5 + +criterion: + loss_type: pair + batch_coeff: 1.0 + aux_loss_coeff: 1.0 + +lr_scheduler: + lr_warmup_steps: 1000 + +model: + pretrained_model_name_or_path: "black-forest-labs/FLUX.1-schnell" + pretrained_vae_name_or_path: "black-forest-labs/FLUX.1-schnell" + logit_scale_init_value: 2.6592 + freeze_text_encoder: False + guidance_scale: 0.0 + noise_offset: false + noise_offset_coeff: 0.05 + +accelerator: + mixed_precision: BF16 + project_name: reward_model + resume_from_checkpoint: False + eval_on_start: False + metric_name: "accuracy" # save best ckpt according to this metric + progress_log_interval: 50 + gradient_accumulation_steps: 1 + max_steps: 8000 + run_name: step_flux_schnell_variable-t_lr1e-5_step-8000_cfg0.0_filter2_time951 + + +output_dir: logs/lrm/${accelerator.project_name}/${accelerator.run_name} + +hydra: + run: + dir: ${output_dir} + +debug: + activate: false + port: 5900 \ No newline at end of file diff --git a/lrm/lrm_sana/docs/__init__.py b/lrm/lrm_sana/docs/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..014ddcebf52b8209c53f6511cd68798c0c8ec0f6 --- /dev/null +++ b/lrm/lrm_sana/docs/__init__.py @@ -0,0 +1 @@ +"""Local SANA reference modules for LRM integration.""" diff --git a/lrm/lrm_sana/docs/architecture.md b/lrm/lrm_sana/docs/architecture.md new file mode 100644 index 0000000000000000000000000000000000000000..79b2e445d87b9b5fe806bda3102f4a5390700853 --- /dev/null +++ b/lrm/lrm_sana/docs/architecture.md @@ -0,0 +1,59 @@ +# SANA LRM Architecture + +## System Overview +This implementation reuses the modular trainer architecture from `flux`: +- `scripts/train.py` orchestrates load/prepare/train/eval/save. +- `accelerators/*` manage distributed runtime, logging, and checkpoints. +- `datasets/*` build pairwise preference batches with timestep controls. +- `models/*` provide latent-space text-image feature extraction. +- `criterions/*` compute pairwise preference loss. +- `tasks/*` compute inference probabilities and accuracy metrics. + +## Data Flow +1. Dataset loads pairwise examples from `pickapic-anonymous/pickapic_v1`. +2. Each sample yields prompt tokens, image pair tensors, labels, and timestep pair. +3. Criterion concatenates image pairs and passes text/image/timestep to the model. +4. Model returns normalized text/image embeddings in shared projection space. +5. Criterion computes pairwise logits and weighted preference loss. +6. Task evaluation converts scores to probabilities and computes accuracy. + +## SANA Model Path +1. Text branch: +- Load SANA tokenizer/text encoder(s) by checkpoint profile. +- Build prompt conditioning embeddings for transformer cross-attention. +- Build pooled text representation for reward embedding projection. + +2. Image branch: +- Preprocess RGB image to configured resolution. +- Encode image with SANA VAE to latents. +- Apply scheduler-based noise at selected timesteps. +- Run SANA transformer on noisy latents with text conditioning. +- Pool transformer latent outputs to image representation. + +3. Reward projection: +- Project text and image representations to common dimension. +- L2-normalize features. +- Compute scaled similarity using learnable `logit_scale`. + +## Training Controls +- Mixed precision and gradient accumulation from accelerator config. +- Distributed feature gather for pairwise loss consistency. +- Validation/test evaluation at configured intervals. +- Periodic checkpointing and best-metric tracking. + +## Logging and Outputs +- Output root: `logs/lrm/{project_name}/{run_name}`. +- Saved artifacts: + - config snapshot + - train log + - periodic checkpoints + - final model state + +## Variant-Aware Profile Design +A model profile selects: +- pretrained checkpoint id +- default image size (512 or 1024) +- tokenizer/text path behavior +- optional special overrides for memory or precision + +This keeps one codebase while enabling all four requested SANA checkpoints. diff --git a/lrm/lrm_sana/docs/checklist.md b/lrm/lrm_sana/docs/checklist.md new file mode 100644 index 0000000000000000000000000000000000000000..3026baae5e41f44d891bf3df938da30cb8a2937f --- /dev/null +++ b/lrm/lrm_sana/docs/checklist.md @@ -0,0 +1,45 @@ +# SANA LRM Implementation Checklist + +## A. Documentation First +- [x] Create `docs/plan.md`. +- [x] Create `docs/architecture.md`. +- [x] Create `docs/checklist.md`. +- [x] Create `docs/migration_notes.md`. + +## B. Code Scaffold +- [x] Ensure `lrm_sana/setup.py` exists. +- [x] Ensure `lrm_sana/train_lrm_sana.sh` exists. +- [x] Ensure full `lrm_sana/trainer/*` structure exists. + +## C. Config Registration +- [x] Add SANA config registration in `trainer/models/__init__.py`. +- [x] Add SANA config registration in `trainer/datasets/__init__.py`. +- [x] Add SANA config registration in `trainer/tasks/__init__.py`. +- [x] Add SANA config registration in `trainer/criterions/__init__.py`. +- [x] Add SANA trainer config dataclass in `trainer/configs/step_sana_configs.py`. +- [x] Add `trainer/conf/step_sana_base.yaml`. + +## D. Model Integration +- [x] Implement `trainer/models/sana_preference_model.py`. +- [x] Implement variant-aware checkpoint selection support. +- [x] Confirm latent encode/noise/transformer/pooling path. +- [x] Confirm text/image projection + `logit_scale` logic. + +## E. Dataset/Task/Criterion +- [x] Implement `trainer/datasets/step_sana_hf_dataset.py`. +- [x] Implement `trainer/tasks/step_sana_task.py`. +- [x] Implement `trainer/criterions/step_clip_criterion_sana.py`. +- [x] Preserve pseudo-preference filtering and timestep behavior. + +## F. Runtime Launcher +- [x] Adapt `train_lrm_sana.sh` from flux launcher. +- [x] Keep `RUN_PROFILE=main|quick` flow. +- [x] Keep offline cache and DeepSpeed launch behavior. +- [x] Add model profile switch for 4 SANA checkpoints. + +## G. Validation +- [x] Run static import checks. +- [ ] Run hydra config composition check. +- [ ] Run quick smoke training (`max_steps=1`). +- [ ] Verify logs/checkpoints/config snapshot output. +- [ ] Verify each SANA profile initializes cleanly. diff --git a/lrm/lrm_sana/docs/checklistv2.md b/lrm/lrm_sana/docs/checklistv2.md new file mode 100644 index 0000000000000000000000000000000000000000..e6b103d012c2272a555dd324cc732ec84541fd03 --- /dev/null +++ b/lrm/lrm_sana/docs/checklistv2.md @@ -0,0 +1,31 @@ +# SANA LRM Checklist V2 + +## 1. Scope and Dependency Rules +- [x] Core parity scope is trainer architecture and runtime contracts across flux, lrm_15, lrm_xl, and lrm_sana. +- [x] `information_related_to_sana` is treated as model-specific external adapter code. +- [x] `information_related_to_flux` is treated as model-specific external adapter code. +- [x] External model adapter modules are excluded from core trainer parity checks. + +## 2. Codebase Parity Against Existing Variants +- [x] SANA has expected variant-specific replacements for config/task/model/dataset/criterion modules. +- [x] SANA keeps shared trainer scaffolding structure aligned with other variants. +- [x] Launcher flow preserves profile-based behavior and runtime overrides. +- [x] Optimizer/lr-scheduler defaults are set for runnable quick smoke behavior. +- [x] Quick profile precision default updated to BF16 for stable H200 smoke runs. + +## 3. Runtime Verification Evidence (centralized in log.log) +- [x] Comparison inventory and focused diffs recorded in log output. +- [x] Hydra composition succeeds (`Hydra compose bg exit code: 0`). +- [x] Deterministic quick smoke run reaches final evaluation end marker (`EVAL END (final@gstep=1)`). +- [x] Deterministic quick smoke run saves checkpoint (`checkpoint-gstep1`). +- [x] All verification command outputs are consolidated under `lrm_sana/log.log`. + +## 4. Remaining Validation Items +- [ ] Initialization smoke checks for all four SANA model profiles. +- [ ] Optional distributed_sharded path validation on nodes with CUDA toolchain available for DeepSpeed ops. +- [ ] Extended multi-step sanity run (beyond max_steps=1). + +## 5. Canonical Artifacts +- Main aggregated run/comparison log: `lrm_sana/log.log` +- Previous checklist: `lrm_sana/docs/checklist.md` +- This checklist revision: `lrm_sana/docs/checklistv2.md` diff --git a/lrm/lrm_sana/docs/information_related_to_sana/finetune.py b/lrm/lrm_sana/docs/information_related_to_sana/finetune.py new file mode 100644 index 0000000000000000000000000000000000000000..203d6605cf48af553effcc47819ffe2f4fecd1d4 --- /dev/null +++ b/lrm/lrm_sana/docs/information_related_to_sana/finetune.py @@ -0,0 +1,1537 @@ +#!/usr/bin/env python +# Copyright 2024 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 + +import argparse +import copy +import itertools +import logging +import math +import os +import random +import shutil +import warnings +from pathlib import Path + +import diffusers +import numpy as np +import torch +import torch.utils.checkpoint +import transformers +from accelerate import Accelerator +from accelerate.logging import get_logger +from accelerate.utils import DistributedDataParallelKwargs, ProjectConfiguration, set_seed +from diffusers import AutoencoderDC, FlowMatchEulerDiscreteScheduler, SanaPipeline, SanaTransformer2DModel +from diffusers.optimization import get_scheduler +from diffusers.training_utils import ( + cast_training_params, + compute_density_for_timestep_sampling, + compute_loss_weighting_for_sd3, + free_memory, +) +from diffusers.utils import check_min_version, convert_unet_state_dict_to_peft, is_wandb_available +from diffusers.utils.hub_utils import load_or_create_model_card, populate_model_card +from diffusers.utils.torch_utils import is_compiled_module +from huggingface_hub import create_repo, upload_folder +from huggingface_hub.utils import insecure_hashlib +from peft import LoraConfig, set_peft_model_state_dict +from peft.utils import get_peft_model_state_dict +from PIL import Image +from PIL.ImageOps import exif_transpose +from torch.utils.data import Dataset +from torchvision import transforms +from torchvision.transforms.functional import crop +from tqdm.auto import tqdm +from transformers import AutoTokenizer, Gemma2Model + +if is_wandb_available(): + import wandb + +# Will error if the minimal version of diffusers is not installed. Remove at your own risks. +check_min_version("0.32.0.dev0") + +logger = get_logger(__name__) + + +def save_model_card( + repo_id: str, + images=None, + base_model: str = None, + instance_prompt=None, + validation_prompt=None, + repo_folder=None, +): + widget_dict = [] + if images is not None: + for i, image in enumerate(images): + image.save(os.path.join(repo_folder, f"image_{i}.png")) + widget_dict.append( + {"text": validation_prompt if validation_prompt else " ", "output": {"url": f"image_{i}.png"}} + ) + + model_description = f""" +# Sana DreamBooth LoRA - {repo_id} + + + +## Model description + +These are {repo_id} DreamBooth LoRA weights for {base_model}. + +The weights were trained using [DreamBooth](https://dreambooth.github.io/) with the [Sana diffusers trainer](https://github.com/huggingface/diffusers/blob/main/examples/dreambooth/README_sana.md). + + +## Trigger words + +You should use `{instance_prompt}` to trigger the image generation. + +## Download model + +[Download the *.safetensors LoRA]({repo_id}/tree/main) in the Files & versions tab. + +## Use it with the [🧨 diffusers library](https://github.com/huggingface/diffusers) + +```py +TODO +``` + +For more details, including weighting, merging and fusing LoRAs, check the [documentation on loading LoRAs in diffusers](https://huggingface.co/docs/diffusers/main/en/using-diffusers/loading_adapters) + +## License + +TODO +""" + model_card = load_or_create_model_card( + repo_id_or_path=repo_id, + from_training=True, + license="other", + base_model=base_model, + prompt=instance_prompt, + model_description=model_description, + widget=widget_dict, + ) + tags = [ + "text-to-image", + "diffusers-training", + "diffusers", + "lora", + "sana", + "sana-diffusers", + "template:sd-lora", + ] + + model_card = populate_model_card(model_card, tags=tags) + model_card.save(os.path.join(repo_folder, "README.md")) + + +def log_validation( + pipeline, + args, + accelerator, + pipeline_args, + epoch, + is_final_validation=False, +): + logger.info( + f"Running validation... \n Generating {args.num_validation_images} images with prompt:" + f" {args.validation_prompt}." + ) + pipeline.text_encoder = pipeline.text_encoder.to(torch.bfloat16) + pipeline = pipeline.to(accelerator.device) + pipeline.set_progress_bar_config(disable=True) + + # run inference + generator = torch.Generator(device=accelerator.device).manual_seed(args.seed) if args.seed else None + + images = [pipeline(**pipeline_args, generator=generator).images[0] for _ in range(args.num_validation_images)] + + for tracker in accelerator.trackers: + phase_name = "test" if is_final_validation else "validation" + if tracker.name == "tensorboard": + np_images = np.stack([np.asarray(img) for img in images]) + tracker.writer.add_images(phase_name, np_images, epoch, dataformats="NHWC") + if tracker.name == "wandb": + tracker.log( + { + phase_name: [ + wandb.Image(image, caption=f"{i}: {args.validation_prompt}") for i, image in enumerate(images) + ] + } + ) + + del pipeline + if torch.cuda.is_available(): + torch.cuda.empty_cache() + + return images + + +def parse_args(input_args=None): + parser = argparse.ArgumentParser(description="Simple example of a training script.") + parser.add_argument( + "--pretrained_model_name_or_path", + type=str, + default=None, + required=True, + help="Path to pretrained model or model identifier from huggingface.co/models.", + ) + parser.add_argument( + "--revision", + type=str, + default=None, + required=False, + help="Revision of pretrained model identifier from huggingface.co/models.", + ) + parser.add_argument( + "--variant", + type=str, + default=None, + help="Variant of the model files of the pretrained model identifier from huggingface.co/models, 'e.g.' fp16", + ) + parser.add_argument( + "--dataset_name", + type=str, + default=None, + help=( + "The name of the Dataset (from the HuggingFace hub) containing the training data of instance images (could be your own, possibly private," + " dataset). It can also be a path pointing to a local copy of a dataset in your filesystem," + " or to a folder containing files that 🤗 Datasets can understand." + ), + ) + parser.add_argument( + "--dataset_config_name", + type=str, + default=None, + help="The config of the Dataset, leave as None if there's only one config.", + ) + parser.add_argument( + "--instance_data_dir", + type=str, + default=None, + help=("A folder containing the training data. "), + ) + + parser.add_argument( + "--cache_dir", + type=str, + default=None, + help="The directory where the downloaded models and datasets will be stored.", + ) + + parser.add_argument( + "--image_column", + type=str, + default="image", + help="The column of the dataset containing the target image. By " + "default, the standard Image Dataset maps out 'file_name' " + "to 'image'.", + ) + parser.add_argument( + "--caption_column", + type=str, + default=None, + help="The column of the dataset containing the instance prompt for each image", + ) + + parser.add_argument("--repeats", type=int, default=1, help="How many times to repeat the training data.") + + parser.add_argument( + "--class_data_dir", + type=str, + default=None, + required=False, + help="A folder containing the training data of class images.", + ) + parser.add_argument( + "--instance_prompt", + type=str, + default=None, + required=True, + help="The prompt with identifier specifying the instance, e.g. 'photo of a TOK dog', 'in the style of TOK'", + ) + parser.add_argument( + "--class_prompt", + type=str, + default=None, + help="The prompt to specify images in the same class as provided instance images.", + ) + parser.add_argument( + "--max_sequence_length", + type=int, + default=300, + help="Maximum sequence length to use with with the Gemma model", + ) + parser.add_argument( + "--complex_human_instruction", + type=str, + default=None, + help="Instructions for complex human attention: https://github.com/NVlabs/Sana/blob/main/configs/sana_app_config/Sana_1600M_app.yaml#L55.", + ) + parser.add_argument( + "--validation_prompt", + type=str, + default=None, + help="A prompt that is used during validation to verify that the model is learning.", + ) + parser.add_argument( + "--num_validation_images", + type=int, + default=4, + help="Number of images that should be generated during validation with `validation_prompt`.", + ) + parser.add_argument( + "--validation_epochs", + type=int, + default=50, + help=( + "Run dreambooth validation every X epochs. Dreambooth validation consists of running the prompt" + " `args.validation_prompt` multiple times: `args.num_validation_images`." + ), + ) + parser.add_argument( + "--rank", + type=int, + default=4, + help=("The dimension of the LoRA update matrices."), + ) + parser.add_argument( + "--with_prior_preservation", + default=False, + action="store_true", + help="Flag to add prior preservation loss.", + ) + parser.add_argument("--prior_loss_weight", type=float, default=1.0, help="The weight of prior preservation loss.") + parser.add_argument( + "--num_class_images", + type=int, + default=100, + help=( + "Minimal class images for prior preservation loss. If there are not enough images already present in" + " class_data_dir, additional images will be sampled with class_prompt." + ), + ) + parser.add_argument( + "--output_dir", + type=str, + default="sana-dreambooth-lora", + help="The output directory where the model predictions and checkpoints will be written.", + ) + parser.add_argument("--seed", type=int, default=None, help="A seed for reproducible training.") + parser.add_argument( + "--resolution", + type=int, + default=512, + help=( + "The resolution for input images, all the images in the train/validation dataset will be resized to this" + " resolution" + ), + ) + parser.add_argument( + "--center_crop", + default=False, + action="store_true", + help=( + "Whether to center crop the input images to the resolution. If not set, the images will be randomly" + " cropped. The images will be resized to the resolution first before cropping." + ), + ) + parser.add_argument( + "--random_flip", + action="store_true", + help="whether to randomly flip images horizontally", + ) + parser.add_argument( + "--train_batch_size", type=int, default=4, help="Batch size (per device) for the training dataloader." + ) + parser.add_argument("--sample_batch_size", type=int, default=4, help="Batch size (per device) for sampling images.") + parser.add_argument("--num_train_epochs", type=int, default=1) + parser.add_argument( + "--max_train_steps", + type=int, + default=None, + help="Total number of training steps to perform. If provided, overrides num_train_epochs.", + ) + parser.add_argument( + "--checkpointing_steps", + type=int, + default=500, + help=( + "Save a checkpoint of the training state every X updates. These checkpoints can be used both as final" + " checkpoints in case they are better than the last checkpoint, and are also suitable for resuming" + " training using `--resume_from_checkpoint`." + ), + ) + parser.add_argument( + "--checkpoints_total_limit", + type=int, + default=None, + help=("Max number of checkpoints to store."), + ) + parser.add_argument( + "--resume_from_checkpoint", + type=str, + default=None, + help=( + "Whether training should be resumed from a previous checkpoint. Use a path saved by" + ' `--checkpointing_steps`, or `"latest"` to automatically select the last available checkpoint.' + ), + ) + parser.add_argument( + "--gradient_accumulation_steps", + type=int, + default=1, + help="Number of updates steps to accumulate before performing a backward/update pass.", + ) + parser.add_argument( + "--gradient_checkpointing", + action="store_true", + help="Whether or not to use gradient checkpointing to save memory at the expense of slower backward pass.", + ) + parser.add_argument( + "--learning_rate", + type=float, + default=1e-4, + help="Initial learning rate (after the potential warmup period) to use.", + ) + parser.add_argument( + "--scale_lr", + action="store_true", + default=False, + help="Scale the learning rate by the number of GPUs, gradient accumulation steps, and batch size.", + ) + parser.add_argument( + "--lr_scheduler", + type=str, + default="constant", + help=( + 'The scheduler type to use. Choose between ["linear", "cosine", "cosine_with_restarts", "polynomial",' + ' "constant", "constant_with_warmup"]' + ), + ) + parser.add_argument( + "--lr_warmup_steps", type=int, default=500, help="Number of steps for the warmup in the lr scheduler." + ) + parser.add_argument( + "--lr_num_cycles", + type=int, + default=1, + help="Number of hard resets of the lr in cosine_with_restarts scheduler.", + ) + parser.add_argument("--lr_power", type=float, default=1.0, help="Power factor of the polynomial scheduler.") + parser.add_argument( + "--dataloader_num_workers", + type=int, + default=0, + help=( + "Number of subprocesses to use for data loading. 0 means that the data will be loaded in the main process." + ), + ) + parser.add_argument( + "--weighting_scheme", + type=str, + default="none", + choices=["sigma_sqrt", "logit_normal", "mode", "cosmap", "none"], + help=('We default to the "none" weighting scheme for uniform sampling and uniform loss'), + ) + parser.add_argument( + "--logit_mean", type=float, default=0.0, help="mean to use when using the `'logit_normal'` weighting scheme." + ) + parser.add_argument( + "--logit_std", type=float, default=1.0, help="std to use when using the `'logit_normal'` weighting scheme." + ) + parser.add_argument( + "--mode_scale", + type=float, + default=1.29, + help="Scale of mode weighting scheme. Only effective when using the `'mode'` as the `weighting_scheme`.", + ) + parser.add_argument( + "--optimizer", + type=str, + default="AdamW", + help=('The optimizer type to use. Choose between ["AdamW", "prodigy"]'), + ) + + parser.add_argument( + "--use_8bit_adam", + action="store_true", + help="Whether or not to use 8-bit Adam from bitsandbytes. Ignored if optimizer is not set to AdamW", + ) + + parser.add_argument( + "--adam_beta1", type=float, default=0.9, help="The beta1 parameter for the Adam and Prodigy optimizers." + ) + parser.add_argument( + "--adam_beta2", type=float, default=0.999, help="The beta2 parameter for the Adam and Prodigy optimizers." + ) + parser.add_argument( + "--prodigy_beta3", + type=float, + default=None, + help="coefficients for computing the Prodigy stepsize using running averages. If set to None, " + "uses the value of square root of beta2. Ignored if optimizer is adamW", + ) + parser.add_argument("--prodigy_decouple", type=bool, default=True, help="Use AdamW style decoupled weight decay") + parser.add_argument("--adam_weight_decay", type=float, default=1e-04, help="Weight decay to use for unet params") + parser.add_argument( + "--adam_weight_decay_text_encoder", type=float, default=1e-03, help="Weight decay to use for text_encoder" + ) + + parser.add_argument( + "--lora_layers", + type=str, + default=None, + help=( + 'The transformer modules to apply LoRA training on. Please specify the layers in a comma seperated. E.g. - "to_k,to_q,to_v" will result in lora training of attention layers only' + ), + ) + + parser.add_argument( + "--adam_epsilon", + type=float, + default=1e-08, + help="Epsilon value for the Adam optimizer and Prodigy optimizers.", + ) + + parser.add_argument( + "--prodigy_use_bias_correction", + type=bool, + default=True, + help="Turn on Adam's bias correction. True by default. Ignored if optimizer is adamW", + ) + parser.add_argument( + "--prodigy_safeguard_warmup", + type=bool, + default=True, + help="Remove lr from the denominator of D estimate to avoid issues during warm-up stage. True by default. " + "Ignored if optimizer is adamW", + ) + parser.add_argument("--max_grad_norm", default=1.0, type=float, help="Max gradient norm.") + parser.add_argument("--push_to_hub", action="store_true", help="Whether or not to push the model to the Hub.") + parser.add_argument("--hub_token", type=str, default=None, help="The token to use to push to the Model Hub.") + parser.add_argument( + "--hub_model_id", + type=str, + default=None, + help="The name of the repository to keep in sync with the local `output_dir`.", + ) + parser.add_argument( + "--logging_dir", + type=str, + default="logs", + help=( + "[TensorBoard](https://www.tensorflow.org/tensorboard) log directory. Will default to" + " *output_dir/runs/**CURRENT_DATETIME_HOSTNAME***." + ), + ) + parser.add_argument( + "--allow_tf32", + action="store_true", + help=( + "Whether or not to allow TF32 on Ampere GPUs. Can be used to speed up training. For more information, see" + " https://pytorch.org/docs/stable/notes/cuda.html#tensorfloat-32-tf32-on-ampere-devices" + ), + ) + parser.add_argument( + "--cache_latents", + action="store_true", + default=False, + help="Cache the VAE latents", + ) + parser.add_argument( + "--report_to", + type=str, + default="tensorboard", + help=( + 'The integration to report the results and logs to. Supported platforms are `"tensorboard"`' + ' (default), `"wandb"` and `"comet_ml"`. Use `"all"` to report to all integrations.' + ), + ) + parser.add_argument( + "--mixed_precision", + type=str, + default=None, + choices=["no", "fp16", "bf16"], + help=( + "Whether to use mixed precision. Choose between fp16 and bf16 (bfloat16). Bf16 requires PyTorch >=" + " 1.10.and an Nvidia Ampere GPU. Default to the value of accelerate config of the current system or the" + " flag passed with the `accelerate.launch` command. Use this argument to override the accelerate config." + ), + ) + parser.add_argument( + "--upcast_before_saving", + action="store_true", + default=False, + help=( + "Whether to upcast the trained transformer layers to float32 before saving (at the end of training). " + "Defaults to precision dtype used for training to save memory" + ), + ) + parser.add_argument( + "--offload", + action="store_true", + help="Whether to offload the VAE and the text encoder to CPU when they are not used.", + ) + parser.add_argument("--local_rank", type=int, default=-1, help="For distributed training: local_rank") + + if input_args is not None: + args = parser.parse_args(input_args) + else: + args = parser.parse_args() + + if args.dataset_name is None and args.instance_data_dir is None: + raise ValueError("Specify either `--dataset_name` or `--instance_data_dir`") + + if args.dataset_name is not None and args.instance_data_dir is not None: + raise ValueError("Specify only one of `--dataset_name` or `--instance_data_dir`") + + env_local_rank = int(os.environ.get("LOCAL_RANK", -1)) + if env_local_rank != -1 and env_local_rank != args.local_rank: + args.local_rank = env_local_rank + + if args.with_prior_preservation: + if args.class_data_dir is None: + raise ValueError("You must specify a data directory for class images.") + if args.class_prompt is None: + raise ValueError("You must specify prompt for class images.") + else: + # logger is not available yet + if args.class_data_dir is not None: + warnings.warn("You need not use --class_data_dir without --with_prior_preservation.") + if args.class_prompt is not None: + warnings.warn("You need not use --class_prompt without --with_prior_preservation.") + + return args + + +class DreamBoothDataset(Dataset): + """ + A dataset to prepare the instance and class images with the prompts for fine-tuning the model. + It pre-processes the images. + """ + + def __init__( + self, + instance_data_root, + instance_prompt, + class_prompt, + class_data_root=None, + class_num=None, + size=1024, + repeats=1, + center_crop=False, + ): + self.size = size + self.center_crop = center_crop + + self.instance_prompt = instance_prompt + self.custom_instance_prompts = None + self.class_prompt = class_prompt + + # if --dataset_name is provided or a metadata jsonl file is provided in the local --instance_data directory, + # we load the training data using load_dataset + if args.dataset_name is not None: + try: + from datasets import load_dataset + except ImportError: + raise ImportError( + "You are trying to load your data using the datasets library. If you wish to train using custom " + "captions please install the datasets library: `pip install datasets`. If you wish to load a " + "local folder containing images only, specify --instance_data_dir instead." + ) + # Downloading and loading a dataset from the hub. + # See more about loading custom images at + # https://huggingface.co/docs/datasets/v2.0.0/en/dataset_script + dataset = load_dataset( + args.dataset_name, + args.dataset_config_name, + cache_dir=args.cache_dir, + ) + # Preprocessing the datasets. + column_names = dataset["train"].column_names + + # 6. Get the column names for input/target. + if args.image_column is None: + image_column = column_names[0] + logger.info(f"image column defaulting to {image_column}") + else: + image_column = args.image_column + if image_column not in column_names: + raise ValueError( + f"`--image_column` value '{args.image_column}' not found in dataset columns. Dataset columns are: {', '.join(column_names)}" + ) + instance_images = dataset["train"][image_column] + + if args.caption_column is None: + logger.info( + "No caption column provided, defaulting to instance_prompt for all images. If your dataset " + "contains captions/prompts for the images, make sure to specify the " + "column as --caption_column" + ) + self.custom_instance_prompts = None + else: + if args.caption_column not in column_names: + raise ValueError( + f"`--caption_column` value '{args.caption_column}' not found in dataset columns. Dataset columns are: {', '.join(column_names)}" + ) + custom_instance_prompts = dataset["train"][args.caption_column] + # create final list of captions according to --repeats + self.custom_instance_prompts = [] + for caption in custom_instance_prompts: + self.custom_instance_prompts.extend(itertools.repeat(caption, repeats)) + else: + self.instance_data_root = Path(instance_data_root) + if not self.instance_data_root.exists(): + raise ValueError("Instance images root doesn't exists.") + + instance_images = [Image.open(path) for path in list(Path(instance_data_root).iterdir())] + self.custom_instance_prompts = None + + self.instance_images = [] + for img in instance_images: + self.instance_images.extend(itertools.repeat(img, repeats)) + + self.pixel_values = [] + train_resize = transforms.Resize(size, interpolation=transforms.InterpolationMode.BILINEAR) + train_crop = transforms.CenterCrop(size) if center_crop else transforms.RandomCrop(size) + train_flip = transforms.RandomHorizontalFlip(p=1.0) + train_transforms = transforms.Compose( + [ + transforms.ToTensor(), + transforms.Normalize([0.5], [0.5]), + ] + ) + for image in self.instance_images: + image = exif_transpose(image) + if not image.mode == "RGB": + image = image.convert("RGB") + image = train_resize(image) + if args.random_flip and random.random() < 0.5: + # flip + image = train_flip(image) + if args.center_crop: + y1 = max(0, int(round((image.height - args.resolution) / 2.0))) + x1 = max(0, int(round((image.width - args.resolution) / 2.0))) + image = train_crop(image) + else: + y1, x1, h, w = train_crop.get_params(image, (args.resolution, args.resolution)) + image = crop(image, y1, x1, h, w) + image = train_transforms(image) + self.pixel_values.append(image) + + self.num_instance_images = len(self.instance_images) + self._length = self.num_instance_images + + if class_data_root is not None: + self.class_data_root = Path(class_data_root) + self.class_data_root.mkdir(parents=True, exist_ok=True) + self.class_images_path = list(self.class_data_root.iterdir()) + if class_num is not None: + self.num_class_images = min(len(self.class_images_path), class_num) + else: + self.num_class_images = len(self.class_images_path) + self._length = max(self.num_class_images, self.num_instance_images) + else: + self.class_data_root = None + + self.image_transforms = transforms.Compose( + [ + transforms.Resize(size, interpolation=transforms.InterpolationMode.BILINEAR), + transforms.CenterCrop(size) if center_crop else transforms.RandomCrop(size), + transforms.ToTensor(), + transforms.Normalize([0.5], [0.5]), + ] + ) + + def __len__(self): + return self._length + + def __getitem__(self, index): + example = {} + instance_image = self.pixel_values[index % self.num_instance_images] + example["instance_images"] = instance_image + + if self.custom_instance_prompts: + caption = self.custom_instance_prompts[index % self.num_instance_images] + if caption: + example["instance_prompt"] = caption + else: + example["instance_prompt"] = self.instance_prompt + + else: # custom prompts were provided, but length does not match size of image dataset + example["instance_prompt"] = self.instance_prompt + + if self.class_data_root: + class_image = Image.open(self.class_images_path[index % self.num_class_images]) + class_image = exif_transpose(class_image) + + if not class_image.mode == "RGB": + class_image = class_image.convert("RGB") + example["class_images"] = self.image_transforms(class_image) + example["class_prompt"] = self.class_prompt + + return example + + +def collate_fn(examples, with_prior_preservation=False): + pixel_values = [example["instance_images"] for example in examples] + prompts = [example["instance_prompt"] for example in examples] + + # Concat class and instance examples for prior preservation. + # We do this to avoid doing two forward passes. + if with_prior_preservation: + pixel_values += [example["class_images"] for example in examples] + prompts += [example["class_prompt"] for example in examples] + + pixel_values = torch.stack(pixel_values) + pixel_values = pixel_values.to(memory_format=torch.contiguous_format).float() + + batch = {"pixel_values": pixel_values, "prompts": prompts} + return batch + + +class PromptDataset(Dataset): + "A simple dataset to prepare the prompts to generate class images on multiple GPUs." + + def __init__(self, prompt, num_samples): + self.prompt = prompt + self.num_samples = num_samples + + def __len__(self): + return self.num_samples + + def __getitem__(self, index): + example = {} + example["prompt"] = self.prompt + example["index"] = index + return example + + +def main(args): + if args.report_to == "wandb" and args.hub_token is not None: + raise ValueError( + "You cannot use both --report_to=wandb and --hub_token due to a security risk of exposing your token." + " Please use `huggingface-cli login` to authenticate with the Hub." + ) + + if torch.backends.mps.is_available() and args.mixed_precision == "bf16": + # due to pytorch#99272, MPS does not yet support bfloat16. + raise ValueError( + "Mixed precision training with bfloat16 is not supported on MPS. Please use fp16 (recommended) or fp32 instead." + ) + + logging_dir = Path(args.output_dir, args.logging_dir) + + accelerator_project_config = ProjectConfiguration(project_dir=args.output_dir, logging_dir=logging_dir) + kwargs = DistributedDataParallelKwargs(find_unused_parameters=True) + accelerator = Accelerator( + gradient_accumulation_steps=args.gradient_accumulation_steps, + mixed_precision=args.mixed_precision, + log_with=args.report_to, + project_config=accelerator_project_config, + kwargs_handlers=[kwargs], + ) + + # Disable AMP for MPS. + if torch.backends.mps.is_available(): + accelerator.native_amp = False + + if args.report_to == "wandb": + if not is_wandb_available(): + raise ImportError("Make sure to install wandb if you want to use it for logging during training.") + + # Make one log on every process with the configuration for debugging. + logging.basicConfig( + format="%(asctime)s - %(levelname)s - %(name)s - %(message)s", + datefmt="%m/%d/%Y %H:%M:%S", + level=logging.INFO, + ) + logger.info(accelerator.state, main_process_only=False) + if accelerator.is_local_main_process: + transformers.utils.logging.set_verbosity_warning() + diffusers.utils.logging.set_verbosity_info() + else: + transformers.utils.logging.set_verbosity_error() + diffusers.utils.logging.set_verbosity_error() + + # If passed along, set the training seed now. + if args.seed is not None: + set_seed(args.seed) + + # Generate class images if prior preservation is enabled. + if args.with_prior_preservation: + class_images_dir = Path(args.class_data_dir) + if not class_images_dir.exists(): + class_images_dir.mkdir(parents=True) + cur_class_images = len(list(class_images_dir.iterdir())) + + if cur_class_images < args.num_class_images: + pipeline = SanaPipeline.from_pretrained( + args.pretrained_model_name_or_path, + torch_dtype=torch.float32, + revision=args.revision, + variant=args.variant, + ) + pipeline.text_encoder = pipeline.text_encoder.to(torch.bfloat16) + pipeline.transformer = pipeline.transformer.to(torch.float16) + pipeline.set_progress_bar_config(disable=True) + + num_new_images = args.num_class_images - cur_class_images + logger.info(f"Number of class images to sample: {num_new_images}.") + + sample_dataset = PromptDataset(args.class_prompt, num_new_images) + sample_dataloader = torch.utils.data.DataLoader(sample_dataset, batch_size=args.sample_batch_size) + + sample_dataloader = accelerator.prepare(sample_dataloader) + pipeline.to(accelerator.device) + + for example in tqdm( + sample_dataloader, desc="Generating class images", disable=not accelerator.is_local_main_process + ): + images = pipeline(example["prompt"]).images + + for i, image in enumerate(images): + hash_image = insecure_hashlib.sha1(image.tobytes()).hexdigest() + image_filename = class_images_dir / f"{example['index'][i] + cur_class_images}-{hash_image}.jpg" + image.save(image_filename) + + del pipeline + if torch.cuda.is_available(): + torch.cuda.empty_cache() + + # Handle the repository creation + if accelerator.is_main_process: + if args.output_dir is not None: + os.makedirs(args.output_dir, exist_ok=True) + + if args.push_to_hub: + repo_id = create_repo( + repo_id=args.hub_model_id or Path(args.output_dir).name, + exist_ok=True, + private=True, + ).repo_id + + # Load the tokenizer + tokenizer = AutoTokenizer.from_pretrained( + args.pretrained_model_name_or_path, + subfolder="tokenizer", + revision=args.revision, + ) + + # Load scheduler and models + noise_scheduler = FlowMatchEulerDiscreteScheduler.from_pretrained( + args.pretrained_model_name_or_path, subfolder="scheduler" + ) + noise_scheduler_copy = copy.deepcopy(noise_scheduler) + text_encoder = Gemma2Model.from_pretrained( + args.pretrained_model_name_or_path, subfolder="text_encoder", revision=args.revision, variant=args.variant + ) + vae = AutoencoderDC.from_pretrained( + args.pretrained_model_name_or_path, + subfolder="vae", + revision=args.revision, + variant=args.variant, + ) + transformer = SanaTransformer2DModel.from_pretrained( + args.pretrained_model_name_or_path, subfolder="transformer", revision=args.revision, variant=args.variant + ) + + # We only train the additional adapter LoRA layers + transformer.requires_grad_(False) + vae.requires_grad_(False) + text_encoder.requires_grad_(False) + + # Initialize a text encoding pipeline and keep it to CPU for now. + text_encoding_pipeline = SanaPipeline.from_pretrained( + args.pretrained_model_name_or_path, + vae=None, + transformer=None, + text_encoder=text_encoder, + tokenizer=tokenizer, + ) + + # For mixed precision training we cast all non-trainable weights (vae, text_encoder and transformer) to half-precision + # as these weights are only used for inference, keeping weights in full precision is not required. + weight_dtype = torch.float32 + if accelerator.mixed_precision == "fp16": + weight_dtype = torch.float16 + elif accelerator.mixed_precision == "bf16": + weight_dtype = torch.bfloat16 + + if torch.backends.mps.is_available() and weight_dtype == torch.bfloat16: + # due to pytorch#99272, MPS does not yet support bfloat16. + raise ValueError( + "Mixed precision training with bfloat16 is not supported on MPS. Please use fp16 (recommended) or fp32 instead." + ) + + # VAE should always be kept in fp32 for SANA (?) + vae.to(dtype=torch.float32) + transformer.to(accelerator.device, dtype=weight_dtype) + # because Gemma2 is particularly suited for bfloat16. + text_encoder.to(dtype=torch.bfloat16) + + if args.gradient_checkpointing: + transformer.enable_gradient_checkpointing() + + if args.lora_layers is not None: + target_modules = [layer.strip() for layer in args.lora_layers.split(",")] + else: + target_modules = ["to_k", "to_q", "to_v"] + + # now we will add new LoRA weights the transformer layers + transformer_lora_config = LoraConfig( + r=args.rank, + lora_alpha=args.rank, + init_lora_weights="gaussian", + target_modules=target_modules, + ) + transformer.add_adapter(transformer_lora_config) + + def unwrap_model(model): + model = accelerator.unwrap_model(model) + model = model._orig_mod if is_compiled_module(model) else model + return model + + # create custom saving & loading hooks so that `accelerator.save_state(...)` serializes in a nice format + def save_model_hook(models, weights, output_dir): + if accelerator.is_main_process: + transformer_lora_layers_to_save = None + + for model in models: + if isinstance(model, type(unwrap_model(transformer))): + transformer_lora_layers_to_save = get_peft_model_state_dict(model) + else: + raise ValueError(f"unexpected save model: {model.__class__}") + + # make sure to pop weight so that corresponding model is not saved again + weights.pop() + + SanaPipeline.save_lora_weights( + output_dir, + transformer_lora_layers=transformer_lora_layers_to_save, + ) + + def load_model_hook(models, input_dir): + transformer_ = None + + while len(models) > 0: + model = models.pop() + + if isinstance(model, type(unwrap_model(transformer))): + transformer_ = model + else: + raise ValueError(f"unexpected save model: {model.__class__}") + + lora_state_dict = SanaPipeline.lora_state_dict(input_dir) + + transformer_state_dict = { + f'{k.replace("transformer.", "")}': v for k, v in lora_state_dict.items() if k.startswith("transformer.") + } + transformer_state_dict = convert_unet_state_dict_to_peft(transformer_state_dict) + incompatible_keys = set_peft_model_state_dict(transformer_, transformer_state_dict, adapter_name="default") + if incompatible_keys is not None: + # check only for unexpected keys + unexpected_keys = getattr(incompatible_keys, "unexpected_keys", None) + if unexpected_keys: + logger.warning( + f"Loading adapter weights from state_dict led to unexpected keys not found in the model: " + f" {unexpected_keys}. " + ) + + # Make sure the trainable params are in float32. This is again needed since the base models + # are in `weight_dtype`. More details: + # https://github.com/huggingface/diffusers/pull/6514#discussion_r1449796804 + if args.mixed_precision == "fp16": + models = [transformer_] + # only upcast trainable parameters (LoRA) into fp32 + cast_training_params(models) + + accelerator.register_save_state_pre_hook(save_model_hook) + accelerator.register_load_state_pre_hook(load_model_hook) + + # Enable TF32 for faster training on Ampere GPUs, + # cf https://pytorch.org/docs/stable/notes/cuda.html#tensorfloat-32-tf32-on-ampere-devices + if args.allow_tf32 and torch.cuda.is_available(): + torch.backends.cuda.matmul.allow_tf32 = True + + if args.scale_lr: + args.learning_rate = ( + args.learning_rate * args.gradient_accumulation_steps * args.train_batch_size * accelerator.num_processes + ) + + # Make sure the trainable params are in float32. + if args.mixed_precision == "fp16": + models = [transformer] + # only upcast trainable parameters (LoRA) into fp32 + cast_training_params(models, dtype=torch.float32) + + transformer_lora_parameters = list(filter(lambda p: p.requires_grad, transformer.parameters())) + + # Optimization parameters + transformer_parameters_with_lr = {"params": transformer_lora_parameters, "lr": args.learning_rate} + params_to_optimize = [transformer_parameters_with_lr] + + # Optimizer creation + if not (args.optimizer.lower() == "prodigy" or args.optimizer.lower() == "adamw"): + logger.warning( + f"Unsupported choice of optimizer: {args.optimizer}.Supported optimizers include [adamW, prodigy]." + "Defaulting to adamW" + ) + args.optimizer = "adamw" + + if args.use_8bit_adam and not args.optimizer.lower() == "adamw": + logger.warning( + f"use_8bit_adam is ignored when optimizer is not set to 'AdamW'. Optimizer was " + f"set to {args.optimizer.lower()}" + ) + + if args.optimizer.lower() == "adamw": + if args.use_8bit_adam: + try: + import bitsandbytes as bnb + except ImportError: + raise ImportError( + "To use 8-bit Adam, please install the bitsandbytes library: `pip install bitsandbytes`." + ) + + optimizer_class = bnb.optim.AdamW8bit + else: + optimizer_class = torch.optim.AdamW + + optimizer = optimizer_class( + params_to_optimize, + betas=(args.adam_beta1, args.adam_beta2), + weight_decay=args.adam_weight_decay, + eps=args.adam_epsilon, + ) + + if args.optimizer.lower() == "prodigy": + try: + import prodigyopt + except ImportError: + raise ImportError("To use Prodigy, please install the prodigyopt library: `pip install prodigyopt`") + + optimizer_class = prodigyopt.Prodigy + + if args.learning_rate <= 0.1: + logger.warning( + "Learning rate is too low. When using prodigy, it's generally better to set learning rate around 1.0" + ) + + optimizer = optimizer_class( + params_to_optimize, + betas=(args.adam_beta1, args.adam_beta2), + beta3=args.prodigy_beta3, + weight_decay=args.adam_weight_decay, + eps=args.adam_epsilon, + decouple=args.prodigy_decouple, + use_bias_correction=args.prodigy_use_bias_correction, + safeguard_warmup=args.prodigy_safeguard_warmup, + ) + + # Dataset and DataLoaders creation: + train_dataset = DreamBoothDataset( + instance_data_root=args.instance_data_dir, + instance_prompt=args.instance_prompt, + class_prompt=args.class_prompt, + class_data_root=args.class_data_dir if args.with_prior_preservation else None, + class_num=args.num_class_images, + size=args.resolution, + repeats=args.repeats, + center_crop=args.center_crop, + ) + + train_dataloader = torch.utils.data.DataLoader( + train_dataset, + batch_size=args.train_batch_size, + shuffle=True, + collate_fn=lambda examples: collate_fn(examples, args.with_prior_preservation), + num_workers=args.dataloader_num_workers, + ) + + def compute_text_embeddings(prompt, text_encoding_pipeline): + text_encoding_pipeline = text_encoding_pipeline.to(accelerator.device) + with torch.no_grad(): + prompt_embeds, prompt_attention_mask, _, _ = text_encoding_pipeline.encode_prompt( + prompt, + max_sequence_length=args.max_sequence_length, + complex_human_instruction=args.complex_human_instruction, + ) + if args.offload: + text_encoding_pipeline = text_encoding_pipeline.to("cpu") + return prompt_embeds, prompt_attention_mask + + # If no type of tuning is done on the text_encoder and custom instance prompts are NOT + # provided (i.e. the --instance_prompt is used for all images), we encode the instance prompt once to avoid + # the redundant encoding. + if not train_dataset.custom_instance_prompts: + instance_prompt_hidden_states, instance_prompt_attention_mask = compute_text_embeddings( + args.instance_prompt, text_encoding_pipeline + ) + + # Handle class prompt for prior-preservation. + if args.with_prior_preservation: + class_prompt_hidden_states, class_prompt_attention_mask = compute_text_embeddings( + args.class_prompt, text_encoding_pipeline + ) + + # Clear the memory here + if not train_dataset.custom_instance_prompts: + del text_encoder, tokenizer + free_memory() + + # If custom instance prompts are NOT provided (i.e. the instance prompt is used for all images), + # pack the statically computed variables appropriately here. This is so that we don't + # have to pass them to the dataloader. + if not train_dataset.custom_instance_prompts: + prompt_embeds = instance_prompt_hidden_states + prompt_attention_mask = instance_prompt_attention_mask + if args.with_prior_preservation: + prompt_embeds = torch.cat([prompt_embeds, class_prompt_hidden_states], dim=0) + prompt_attention_mask = torch.cat([prompt_attention_mask, class_prompt_attention_mask], dim=0) + + vae_config_scaling_factor = vae.config.scaling_factor + if args.cache_latents: + latents_cache = [] + vae = vae.to("cuda") + for batch in tqdm(train_dataloader, desc="Caching latents"): + with torch.no_grad(): + batch["pixel_values"] = batch["pixel_values"].to(accelerator.device, non_blocking=True, dtype=vae.dtype) + latents_cache.append(vae.encode(batch["pixel_values"]).latent) + + if args.validation_prompt is None: + del vae + free_memory() + + # Scheduler and math around the number of training steps. + overrode_max_train_steps = False + num_update_steps_per_epoch = math.ceil(len(train_dataloader) / args.gradient_accumulation_steps) + if args.max_train_steps is None: + args.max_train_steps = args.num_train_epochs * num_update_steps_per_epoch + overrode_max_train_steps = True + + lr_scheduler = get_scheduler( + args.lr_scheduler, + optimizer=optimizer, + num_warmup_steps=args.lr_warmup_steps * accelerator.num_processes, + num_training_steps=args.max_train_steps * accelerator.num_processes, + num_cycles=args.lr_num_cycles, + power=args.lr_power, + ) + + # Prepare everything with our `accelerator`. + transformer, optimizer, train_dataloader, lr_scheduler = accelerator.prepare( + transformer, optimizer, train_dataloader, lr_scheduler + ) + + # We need to recalculate our total training steps as the size of the training dataloader may have changed. + num_update_steps_per_epoch = math.ceil(len(train_dataloader) / args.gradient_accumulation_steps) + if overrode_max_train_steps: + args.max_train_steps = args.num_train_epochs * num_update_steps_per_epoch + # Afterwards we recalculate our number of training epochs + args.num_train_epochs = math.ceil(args.max_train_steps / num_update_steps_per_epoch) + + # We need to initialize the trackers we use, and also store our configuration. + # The trackers initializes automatically on the main process. + if accelerator.is_main_process: + tracker_name = "dreambooth-sana-lora" + accelerator.init_trackers(tracker_name, config=vars(args)) + + # Train! + total_batch_size = args.train_batch_size * accelerator.num_processes * args.gradient_accumulation_steps + + logger.info("***** Running training *****") + logger.info(f" Num examples = {len(train_dataset)}") + logger.info(f" Num batches each epoch = {len(train_dataloader)}") + logger.info(f" Num Epochs = {args.num_train_epochs}") + logger.info(f" Instantaneous batch size per device = {args.train_batch_size}") + logger.info(f" Total train batch size (w. parallel, distributed & accumulation) = {total_batch_size}") + logger.info(f" Gradient Accumulation steps = {args.gradient_accumulation_steps}") + logger.info(f" Total optimization steps = {args.max_train_steps}") + global_step = 0 + first_epoch = 0 + + # Potentially load in the weights and states from a previous save + if args.resume_from_checkpoint: + if args.resume_from_checkpoint != "latest": + path = os.path.basename(args.resume_from_checkpoint) + else: + # Get the mos recent checkpoint + dirs = os.listdir(args.output_dir) + dirs = [d for d in dirs if d.startswith("checkpoint")] + dirs = sorted(dirs, key=lambda x: int(x.split("-")[1])) + path = dirs[-1] if len(dirs) > 0 else None + + if path is None: + accelerator.print( + f"Checkpoint '{args.resume_from_checkpoint}' does not exist. Starting a new training run." + ) + args.resume_from_checkpoint = None + initial_global_step = 0 + else: + accelerator.print(f"Resuming from checkpoint {path}") + accelerator.load_state(os.path.join(args.output_dir, path)) + global_step = int(path.split("-")[1]) + + initial_global_step = global_step + first_epoch = global_step // num_update_steps_per_epoch + + else: + initial_global_step = 0 + + progress_bar = tqdm( + range(0, args.max_train_steps), + initial=initial_global_step, + desc="Steps", + # Only show the progress bar once on each machine. + disable=not accelerator.is_local_main_process, + ) + + def get_sigmas(timesteps, n_dim=4, dtype=torch.float32): + sigmas = noise_scheduler_copy.sigmas.to(device=accelerator.device, dtype=dtype) + schedule_timesteps = noise_scheduler_copy.timesteps.to(accelerator.device) + timesteps = timesteps.to(accelerator.device) + step_indices = [(schedule_timesteps == t).nonzero().item() for t in timesteps] + + sigma = sigmas[step_indices].flatten() + while len(sigma.shape) < n_dim: + sigma = sigma.unsqueeze(-1) + return sigma + + for epoch in range(first_epoch, args.num_train_epochs): + transformer.train() + + for step, batch in enumerate(train_dataloader): + models_to_accumulate = [transformer] + with accelerator.accumulate(models_to_accumulate): + prompts = batch["prompts"] + + # encode batch prompts when custom prompts are provided for each image - + if train_dataset.custom_instance_prompts: + prompt_embeds, prompt_attention_mask = compute_text_embeddings(prompts, text_encoding_pipeline) + + # Convert images to latent space + if args.cache_latents: + model_input = latents_cache[step] + else: + vae = vae.to(accelerator.device) + pixel_values = batch["pixel_values"].to(dtype=vae.dtype) + model_input = vae.encode(pixel_values).latent + if args.offload: + vae = vae.to("cpu") + model_input = model_input * vae_config_scaling_factor + model_input = model_input.to(dtype=weight_dtype) + + # Sample noise that we'll add to the latents + noise = torch.randn_like(model_input) + bsz = model_input.shape[0] + + # Sample a random timestep for each image + # for weighting schemes where we sample timesteps non-uniformly + u = compute_density_for_timestep_sampling( + weighting_scheme=args.weighting_scheme, + batch_size=bsz, + logit_mean=args.logit_mean, + logit_std=args.logit_std, + mode_scale=args.mode_scale, + ) + indices = (u * noise_scheduler_copy.config.num_train_timesteps).long() + timesteps = noise_scheduler_copy.timesteps[indices].to(device=model_input.device) + + # Add noise according to flow matching. + # zt = (1 - texp) * x + texp * z1 + sigmas = get_sigmas(timesteps, n_dim=model_input.ndim, dtype=model_input.dtype) + noisy_model_input = (1.0 - sigmas) * model_input + sigmas * noise + + # Predict the noise residual + model_pred = transformer( + hidden_states=noisy_model_input, + encoder_hidden_states=prompt_embeds, + encoder_attention_mask=prompt_attention_mask, + timestep=timesteps, + return_dict=False, + )[0] + + # these weighting schemes use a uniform timestep sampling + # and instead post-weight the loss + weighting = compute_loss_weighting_for_sd3(weighting_scheme=args.weighting_scheme, sigmas=sigmas) + + # flow matching loss + target = noise - model_input + + if args.with_prior_preservation: + # Chunk the noise and model_pred into two parts and compute the loss on each part separately. + model_pred, model_pred_prior = torch.chunk(model_pred, 2, dim=0) + target, target_prior = torch.chunk(target, 2, dim=0) + + # Compute prior loss + prior_loss = torch.mean( + (weighting.float() * (model_pred_prior.float() - target_prior.float()) ** 2).reshape( + target_prior.shape[0], -1 + ), + 1, + ) + prior_loss = prior_loss.mean() + + # Compute regular loss. + loss = torch.mean( + (weighting.float() * (model_pred.float() - target.float()) ** 2).reshape(target.shape[0], -1), + 1, + ) + loss = loss.mean() + + if args.with_prior_preservation: + # Add the prior loss to the instance loss. + loss = loss + args.prior_loss_weight * prior_loss + + accelerator.backward(loss) + if accelerator.sync_gradients: + params_to_clip = transformer.parameters() + accelerator.clip_grad_norm_(params_to_clip, args.max_grad_norm) + + optimizer.step() + lr_scheduler.step() + optimizer.zero_grad() + + # Checks if the accelerator has performed an optimization step behind the scenes + if accelerator.sync_gradients: + progress_bar.update(1) + global_step += 1 + + if accelerator.is_main_process: + if global_step % args.checkpointing_steps == 0: + # _before_ saving state, check if this save would set us over the `checkpoints_total_limit` + if args.checkpoints_total_limit is not None: + checkpoints = os.listdir(args.output_dir) + checkpoints = [d for d in checkpoints if d.startswith("checkpoint")] + checkpoints = sorted(checkpoints, key=lambda x: int(x.split("-")[1])) + + # before we save the new checkpoint, we need to have at _most_ `checkpoints_total_limit - 1` checkpoints + if len(checkpoints) >= args.checkpoints_total_limit: + num_to_remove = len(checkpoints) - args.checkpoints_total_limit + 1 + removing_checkpoints = checkpoints[0:num_to_remove] + + logger.info( + f"{len(checkpoints)} checkpoints already exist, removing {len(removing_checkpoints)} checkpoints" + ) + logger.info(f"removing checkpoints: {', '.join(removing_checkpoints)}") + + for removing_checkpoint in removing_checkpoints: + removing_checkpoint = os.path.join(args.output_dir, removing_checkpoint) + shutil.rmtree(removing_checkpoint) + + save_path = os.path.join(args.output_dir, f"checkpoint-{global_step}") + accelerator.save_state(save_path) + logger.info(f"Saved state to {save_path}") + + logs = {"loss": loss.detach().item(), "lr": lr_scheduler.get_last_lr()[0]} + progress_bar.set_postfix(**logs) + accelerator.log(logs, step=global_step) + + if global_step >= args.max_train_steps: + break + + if accelerator.is_main_process: + if args.validation_prompt is not None and epoch % args.validation_epochs == 0: + # create pipeline + pipeline = SanaPipeline.from_pretrained( + args.pretrained_model_name_or_path, + transformer=accelerator.unwrap_model(transformer), + revision=args.revision, + variant=args.variant, + torch_dtype=torch.float32, + ) + pipeline_args = { + "prompt": args.validation_prompt, + "complex_human_instruction": args.complex_human_instruction, + } + images = log_validation( + pipeline=pipeline, + args=args, + accelerator=accelerator, + pipeline_args=pipeline_args, + epoch=epoch, + ) + free_memory() + + images = None + del pipeline + + # Save the lora layers + accelerator.wait_for_everyone() + if accelerator.is_main_process: + transformer = unwrap_model(transformer) + if args.upcast_before_saving: + transformer.to(torch.float32) + else: + transformer = transformer.to(weight_dtype) + transformer_lora_layers = get_peft_model_state_dict(transformer) + + SanaPipeline.save_lora_weights( + save_directory=args.output_dir, + transformer_lora_layers=transformer_lora_layers, + ) + + # Final inference + # Load previous pipeline + pipeline = SanaPipeline.from_pretrained( + args.pretrained_model_name_or_path, + revision=args.revision, + variant=args.variant, + torch_dtype=torch.float32, + ) + pipeline.transformer = pipeline.transformer.to(torch.float16) + # load attention processors + pipeline.load_lora_weights(args.output_dir) + + # run inference + images = [] + if args.validation_prompt and args.num_validation_images > 0: + pipeline_args = { + "prompt": args.validation_prompt, + "complex_human_instruction": args.complex_human_instruction, + } + images = log_validation( + pipeline=pipeline, + args=args, + accelerator=accelerator, + pipeline_args=pipeline_args, + epoch=epoch, + is_final_validation=True, + ) + + if args.push_to_hub: + save_model_card( + repo_id, + images=images, + base_model=args.pretrained_model_name_or_path, + instance_prompt=args.instance_prompt, + validation_prompt=args.validation_prompt, + repo_folder=args.output_dir, + ) + upload_folder( + repo_id=repo_id, + folder_path=args.output_dir, + commit_message="End of training", + ignore_patterns=["step_*", "epoch_*"], + ) + + images = None + del pipeline + + accelerator.end_training() + + +if __name__ == "__main__": + args = parse_args() + main(args) \ No newline at end of file diff --git a/lrm/lrm_sana/docs/information_related_to_sana/pipeline.py b/lrm/lrm_sana/docs/information_related_to_sana/pipeline.py new file mode 100644 index 0000000000000000000000000000000000000000..17917db8aaba4e2bfc2b0d512b7035431d760dc7 --- /dev/null +++ b/lrm/lrm_sana/docs/information_related_to_sana/pipeline.py @@ -0,0 +1,1041 @@ +# Copyright 2025 SANA Authors and 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. + +import html +import inspect +import re +import urllib.parse as ul +import warnings +from typing import Any, Callable + +import torch +from transformers import Gemma2PreTrainedModel, GemmaTokenizer, GemmaTokenizerFast + +from diffusers.callbacks import MultiPipelineCallbacks, PipelineCallback +from diffusers.image_processor import PixArtImageProcessor +from diffusers.loaders import SanaLoraLoaderMixin +from diffusers.models import AutoencoderDC +from docs.information_related_to_sana.dit import SanaTransformer2DModel +from diffusers.schedulers import DPMSolverMultistepScheduler +from diffusers.utils import ( + BACKENDS_MAPPING, + USE_PEFT_BACKEND, + deprecate, + is_bs4_available, + is_ftfy_available, + is_torch_xla_available, + logging, + replace_example_docstring, + scale_lora_layers, + unscale_lora_layers, +) +from diffusers.utils.torch_utils import get_device, is_torch_version, randn_tensor +from diffusers.pipelines.pipeline_utils import DiffusionPipeline +from diffusers.pipelines.pixart_alpha.pipeline_pixart_alpha import ( + ASPECT_RATIO_512_BIN, + ASPECT_RATIO_1024_BIN, +) +from diffusers.pipelines.pixart_alpha.pipeline_pixart_sigma import ASPECT_RATIO_2048_BIN +from diffusers.pipelines.sana.pipeline_output import SanaPipelineOutput + + +if is_torch_xla_available(): + import torch_xla.core.xla_model as xm + + XLA_AVAILABLE = True +else: + XLA_AVAILABLE = False + +logger = logging.get_logger(__name__) # pylint: disable=invalid-name + +if is_bs4_available(): + from bs4 import BeautifulSoup + +if is_ftfy_available(): + import ftfy + + +ASPECT_RATIO_4096_BIN = { + "0.25": [2048.0, 8192.0], + "0.26": [2048.0, 7936.0], + "0.27": [2048.0, 7680.0], + "0.28": [2048.0, 7424.0], + "0.32": [2304.0, 7168.0], + "0.33": [2304.0, 6912.0], + "0.35": [2304.0, 6656.0], + "0.4": [2560.0, 6400.0], + "0.42": [2560.0, 6144.0], + "0.48": [2816.0, 5888.0], + "0.5": [2816.0, 5632.0], + "0.52": [2816.0, 5376.0], + "0.57": [3072.0, 5376.0], + "0.6": [3072.0, 5120.0], + "0.68": [3328.0, 4864.0], + "0.72": [3328.0, 4608.0], + "0.78": [3584.0, 4608.0], + "0.82": [3584.0, 4352.0], + "0.88": [3840.0, 4352.0], + "0.94": [3840.0, 4096.0], + "1.0": [4096.0, 4096.0], + "1.07": [4096.0, 3840.0], + "1.13": [4352.0, 3840.0], + "1.21": [4352.0, 3584.0], + "1.29": [4608.0, 3584.0], + "1.38": [4608.0, 3328.0], + "1.46": [4864.0, 3328.0], + "1.67": [5120.0, 3072.0], + "1.75": [5376.0, 3072.0], + "2.0": [5632.0, 2816.0], + "2.09": [5888.0, 2816.0], + "2.4": [6144.0, 2560.0], + "2.5": [6400.0, 2560.0], + "2.89": [6656.0, 2304.0], + "3.0": [6912.0, 2304.0], + "3.11": [7168.0, 2304.0], + "3.62": [7424.0, 2048.0], + "3.75": [7680.0, 2048.0], + "3.88": [7936.0, 2048.0], + "4.0": [8192.0, 2048.0], +} + +EXAMPLE_DOC_STRING = """ + Examples: + ```py + >>> import torch + >>> from diffusers import SanaPipeline + + >>> pipe = SanaPipeline.from_pretrained( + ... "Efficient-Large-Model/Sana_1600M_1024px_BF16_diffusers", torch_dtype=torch.float32 + ... ) + >>> pipe.to("cuda") + >>> pipe.text_encoder.to(torch.bfloat16) + >>> pipe.transformer = pipe.transformer.to(torch.bfloat16) + + >>> image = pipe(prompt='a cyberpunk cat with a neon sign that says "Sana"')[0] + >>> image[0].save("output.png") + ``` +""" + + +# Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.retrieve_timesteps +def retrieve_timesteps( + scheduler, + num_inference_steps: int | None = None, + device: str | torch.device | None = None, + timesteps: list[int] | None = None, + sigmas: list[float] | None = None, + **kwargs, +): + r""" + Calls the scheduler's `set_timesteps` method and retrieves timesteps from the scheduler after the call. Handles + custom timesteps. Any kwargs will be supplied to `scheduler.set_timesteps`. + + Args: + scheduler (`SchedulerMixin`): + The scheduler to get timesteps from. + num_inference_steps (`int`): + The number of diffusion steps used when generating samples with a pre-trained model. If used, `timesteps` + must be `None`. + device (`str` or `torch.device`, *optional*): + The device to which the timesteps should be moved to. If `None`, the timesteps are not moved. + timesteps (`list[int]`, *optional*): + Custom timesteps used to override the timestep spacing strategy of the scheduler. If `timesteps` is passed, + `num_inference_steps` and `sigmas` must be `None`. + sigmas (`list[float]`, *optional*): + Custom sigmas used to override the timestep spacing strategy of the scheduler. If `sigmas` is passed, + `num_inference_steps` and `timesteps` must be `None`. + + Returns: + `tuple[torch.Tensor, int]`: A tuple where the first element is the timestep schedule from the scheduler and the + second element is the number of inference steps. + """ + if timesteps is not None and sigmas is not None: + raise ValueError("Only one of `timesteps` or `sigmas` can be passed. Please choose one to set custom values") + if timesteps is not None: + accepts_timesteps = "timesteps" in set(inspect.signature(scheduler.set_timesteps).parameters.keys()) + if not accepts_timesteps: + raise ValueError( + f"The current scheduler class {scheduler.__class__}'s `set_timesteps` does not support custom" + f" timestep schedules. Please check whether you are using the correct scheduler." + ) + scheduler.set_timesteps(timesteps=timesteps, device=device, **kwargs) + timesteps = scheduler.timesteps + num_inference_steps = len(timesteps) + elif sigmas is not None: + accept_sigmas = "sigmas" in set(inspect.signature(scheduler.set_timesteps).parameters.keys()) + if not accept_sigmas: + raise ValueError( + f"The current scheduler class {scheduler.__class__}'s `set_timesteps` does not support custom" + f" sigmas schedules. Please check whether you are using the correct scheduler." + ) + scheduler.set_timesteps(sigmas=sigmas, device=device, **kwargs) + timesteps = scheduler.timesteps + num_inference_steps = len(timesteps) + else: + scheduler.set_timesteps(num_inference_steps, device=device, **kwargs) + timesteps = scheduler.timesteps + return timesteps, num_inference_steps + + +class SanaPipeline(DiffusionPipeline, SanaLoraLoaderMixin): + r""" + Pipeline for text-to-image generation using [Sana](https://huggingface.co/papers/2410.10629). + """ + + # fmt: off + bad_punct_regex = re.compile(r"[" + "#®•©™&@·º½¾¿¡§~" + r"\)" + r"\(" + r"\]" + r"\[" + r"\}" + r"\{" + r"\|" + "\\" + r"\/" + r"\*" + r"]{1,}") + # fmt: on + + model_cpu_offload_seq = "text_encoder->transformer->vae" + _callback_tensor_inputs = ["latents", "prompt_embeds", "negative_prompt_embeds"] + + def __init__( + self, + tokenizer: GemmaTokenizer | GemmaTokenizerFast, + text_encoder: Gemma2PreTrainedModel, + vae: AutoencoderDC, + transformer: SanaTransformer2DModel, + scheduler: DPMSolverMultistepScheduler, + ): + super().__init__() + + self.register_modules( + tokenizer=tokenizer, text_encoder=text_encoder, vae=vae, transformer=transformer, scheduler=scheduler + ) + + self.vae_scale_factor = ( + 2 ** (len(self.vae.config.encoder_block_out_channels) - 1) + if hasattr(self, "vae") and self.vae is not None + else 32 + ) + self.image_processor = PixArtImageProcessor(vae_scale_factor=self.vae_scale_factor) + + def enable_vae_slicing(self): + r""" + Enable sliced VAE decoding. When this option is enabled, the VAE will split the input tensor in slices to + compute decoding in several steps. This is useful to save some memory and allow larger batch sizes. + """ + depr_message = f"Calling `enable_vae_slicing()` on a `{self.__class__.__name__}` is deprecated and this method will be removed in a future version. Please use `pipe.vae.enable_slicing()`." + deprecate( + "enable_vae_slicing", + "0.40.0", + depr_message, + ) + self.vae.enable_slicing() + + def disable_vae_slicing(self): + r""" + Disable sliced VAE decoding. If `enable_vae_slicing` was previously enabled, this method will go back to + computing decoding in one step. + """ + depr_message = f"Calling `disable_vae_slicing()` on a `{self.__class__.__name__}` is deprecated and this method will be removed in a future version. Please use `pipe.vae.disable_slicing()`." + deprecate( + "disable_vae_slicing", + "0.40.0", + depr_message, + ) + self.vae.disable_slicing() + + def enable_vae_tiling(self): + r""" + Enable tiled VAE decoding. When this option is enabled, the VAE will split the input tensor into tiles to + compute decoding and encoding in several steps. This is useful for saving a large amount of memory and to allow + processing larger images. + """ + depr_message = f"Calling `enable_vae_tiling()` on a `{self.__class__.__name__}` is deprecated and this method will be removed in a future version. Please use `pipe.vae.enable_tiling()`." + deprecate( + "enable_vae_tiling", + "0.40.0", + depr_message, + ) + self.vae.enable_tiling() + + def disable_vae_tiling(self): + r""" + Disable tiled VAE decoding. If `enable_vae_tiling` was previously enabled, this method will go back to + computing decoding in one step. + """ + depr_message = f"Calling `disable_vae_tiling()` on a `{self.__class__.__name__}` is deprecated and this method will be removed in a future version. Please use `pipe.vae.disable_tiling()`." + deprecate( + "disable_vae_tiling", + "0.40.0", + depr_message, + ) + self.vae.disable_tiling() + + def _get_gemma_prompt_embeds( + self, + prompt: str | list[str], + device: torch.device, + dtype: torch.dtype, + clean_caption: bool = False, + max_sequence_length: int = 300, + complex_human_instruction: list[str] | None = None, + ): + r""" + Encodes the prompt into text encoder hidden states. + + Args: + prompt (`str` or `list[str]`, *optional*): + prompt to be encoded + device: (`torch.device`, *optional*): + torch device to place the resulting embeddings on + clean_caption (`bool`, defaults to `False`): + If `True`, the function will preprocess and clean the provided caption before encoding. + max_sequence_length (`int`, defaults to 300): Maximum sequence length to use for the prompt. + complex_human_instruction (`list[str]`, defaults to `complex_human_instruction`): + If `complex_human_instruction` is not empty, the function will use the complex Human instruction for + the prompt. + """ + prompt = [prompt] if isinstance(prompt, str) else prompt + + if getattr(self, "tokenizer", None) is not None: + self.tokenizer.padding_side = "right" + + prompt = self._text_preprocessing(prompt, clean_caption=clean_caption) + + # prepare complex human instruction + if not complex_human_instruction: + max_length_all = max_sequence_length + else: + chi_prompt = "\n".join(complex_human_instruction) + prompt = [chi_prompt + p for p in prompt] + num_chi_prompt_tokens = len(self.tokenizer.encode(chi_prompt)) + max_length_all = num_chi_prompt_tokens + max_sequence_length - 2 + + text_inputs = self.tokenizer( + prompt, + padding="max_length", + max_length=max_length_all, + truncation=True, + add_special_tokens=True, + return_tensors="pt", + ) + text_input_ids = text_inputs.input_ids + + prompt_attention_mask = text_inputs.attention_mask + prompt_attention_mask = prompt_attention_mask.to(device) + + prompt_embeds = self.text_encoder(text_input_ids.to(device), attention_mask=prompt_attention_mask) + prompt_embeds = prompt_embeds[0].to(dtype=dtype, device=device) + + return prompt_embeds, prompt_attention_mask + + def encode_prompt( + self, + prompt: str | list[str], + do_classifier_free_guidance: bool = True, + negative_prompt: str = "", + num_images_per_prompt: int = 1, + device: torch.device | None = None, + prompt_embeds: torch.Tensor | None = None, + negative_prompt_embeds: torch.Tensor | None = None, + prompt_attention_mask: torch.Tensor | None = None, + negative_prompt_attention_mask: torch.Tensor | None = None, + clean_caption: bool = False, + max_sequence_length: int = 300, + complex_human_instruction: list[str] | None = None, + lora_scale: float | None = None, + ): + r""" + Encodes the prompt into text encoder hidden states. + + Args: + prompt (`str` or `list[str]`, *optional*): + prompt to be encoded + negative_prompt (`str` or `list[str]`, *optional*): + The prompt not to guide the image generation. If not defined, one has to pass `negative_prompt_embeds` + instead. Ignored when not using guidance (i.e., ignored if `guidance_scale` is less than `1`). For + PixArt-Alpha, this should be "". + do_classifier_free_guidance (`bool`, *optional*, defaults to `True`): + whether to use classifier free guidance or not + num_images_per_prompt (`int`, *optional*, defaults to 1): + number of images that should be generated per prompt + device: (`torch.device`, *optional*): + torch device to place the resulting embeddings on + prompt_embeds (`torch.Tensor`, *optional*): + Pre-generated text embeddings. Can be used to easily tweak text inputs, *e.g.* prompt weighting. If not + provided, text embeddings will be generated from `prompt` input argument. + negative_prompt_embeds (`torch.Tensor`, *optional*): + Pre-generated negative text embeddings. For Sana, it's should be the embeddings of the "" string. + clean_caption (`bool`, defaults to `False`): + If `True`, the function will preprocess and clean the provided caption before encoding. + max_sequence_length (`int`, defaults to 300): Maximum sequence length to use for the prompt. + complex_human_instruction (`list[str]`, defaults to `complex_human_instruction`): + If `complex_human_instruction` is not empty, the function will use the complex Human instruction for + the prompt. + """ + + if device is None: + device = self._execution_device + + if self.text_encoder is not None: + dtype = self.text_encoder.dtype + else: + dtype = None + + # set lora scale so that monkey patched LoRA + # function of text encoder can correctly access it + if lora_scale is not None and isinstance(self, SanaLoraLoaderMixin): + self._lora_scale = lora_scale + + # dynamically adjust the LoRA scale + if self.text_encoder is not None and USE_PEFT_BACKEND: + scale_lora_layers(self.text_encoder, lora_scale) + + if prompt is not None and isinstance(prompt, str): + batch_size = 1 + elif prompt is not None and isinstance(prompt, list): + batch_size = len(prompt) + else: + batch_size = prompt_embeds.shape[0] + + if getattr(self, "tokenizer", None) is not None: + self.tokenizer.padding_side = "right" + + # See Section 3.1. of the paper. + max_length = max_sequence_length + select_index = [0] + list(range(-max_length + 1, 0)) + + if prompt_embeds is None: + prompt_embeds, prompt_attention_mask = self._get_gemma_prompt_embeds( + prompt=prompt, + device=device, + dtype=dtype, + clean_caption=clean_caption, + max_sequence_length=max_sequence_length, + complex_human_instruction=complex_human_instruction, + ) + + prompt_embeds = prompt_embeds[:, select_index] + prompt_attention_mask = prompt_attention_mask[:, select_index] + + bs_embed, seq_len, _ = prompt_embeds.shape + # duplicate text embeddings and attention mask for each generation per prompt, using mps friendly method + prompt_embeds = prompt_embeds.repeat(1, num_images_per_prompt, 1) + prompt_embeds = prompt_embeds.view(bs_embed * num_images_per_prompt, seq_len, -1) + prompt_attention_mask = prompt_attention_mask.view(bs_embed, -1) + prompt_attention_mask = prompt_attention_mask.repeat(num_images_per_prompt, 1) + + # get unconditional embeddings for classifier free guidance + if do_classifier_free_guidance and negative_prompt_embeds is None: + negative_prompt = [negative_prompt] * batch_size if isinstance(negative_prompt, str) else negative_prompt + negative_prompt_embeds, negative_prompt_attention_mask = self._get_gemma_prompt_embeds( + prompt=negative_prompt, + device=device, + dtype=dtype, + clean_caption=clean_caption, + max_sequence_length=max_sequence_length, + complex_human_instruction=False, + ) + + if do_classifier_free_guidance: + # duplicate unconditional embeddings for each generation per prompt, using mps friendly method + seq_len = negative_prompt_embeds.shape[1] + + negative_prompt_embeds = negative_prompt_embeds.to(dtype=dtype, device=device) + + negative_prompt_embeds = negative_prompt_embeds.repeat(1, num_images_per_prompt, 1) + negative_prompt_embeds = negative_prompt_embeds.view(batch_size * num_images_per_prompt, seq_len, -1) + + negative_prompt_attention_mask = negative_prompt_attention_mask.view(bs_embed, -1) + negative_prompt_attention_mask = negative_prompt_attention_mask.repeat(num_images_per_prompt, 1) + else: + negative_prompt_embeds = None + negative_prompt_attention_mask = None + + if self.text_encoder is not None: + if isinstance(self, SanaLoraLoaderMixin) and USE_PEFT_BACKEND: + # Retrieve the original scale by scaling back the LoRA layers + unscale_lora_layers(self.text_encoder, lora_scale) + + return prompt_embeds, prompt_attention_mask, negative_prompt_embeds, negative_prompt_attention_mask + + # Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.StableDiffusionPipeline.prepare_extra_step_kwargs + def prepare_extra_step_kwargs(self, generator, eta): + # prepare extra kwargs for the scheduler step, since not all schedulers have the same signature + # eta (η) is only used with the DDIMScheduler, it will be ignored for other schedulers. + # eta corresponds to η in DDIM paper: https://huggingface.co/papers/2010.02502 + # and should be between [0, 1] + + accepts_eta = "eta" in set(inspect.signature(self.scheduler.step).parameters.keys()) + extra_step_kwargs = {} + if accepts_eta: + extra_step_kwargs["eta"] = eta + + # check if the scheduler accepts generator + accepts_generator = "generator" in set(inspect.signature(self.scheduler.step).parameters.keys()) + if accepts_generator: + extra_step_kwargs["generator"] = generator + return extra_step_kwargs + + def check_inputs( + self, + prompt, + height, + width, + callback_on_step_end_tensor_inputs=None, + negative_prompt=None, + prompt_embeds=None, + negative_prompt_embeds=None, + prompt_attention_mask=None, + negative_prompt_attention_mask=None, + ): + if height % 32 != 0 or width % 32 != 0: + raise ValueError(f"`height` and `width` have to be divisible by 32 but are {height} and {width}.") + + if callback_on_step_end_tensor_inputs is not None and not all( + k in self._callback_tensor_inputs for k in callback_on_step_end_tensor_inputs + ): + raise ValueError( + f"`callback_on_step_end_tensor_inputs` has to be in {self._callback_tensor_inputs}, but found {[k for k in callback_on_step_end_tensor_inputs if k not in self._callback_tensor_inputs]}" + ) + + if prompt is not None and prompt_embeds is not None: + raise ValueError( + f"Cannot forward both `prompt`: {prompt} and `prompt_embeds`: {prompt_embeds}. Please make sure to" + " only forward one of the two." + ) + elif prompt is None and prompt_embeds is None: + raise ValueError( + "Provide either `prompt` or `prompt_embeds`. Cannot leave both `prompt` and `prompt_embeds` undefined." + ) + elif prompt is not None and (not isinstance(prompt, str) and not isinstance(prompt, list)): + raise ValueError(f"`prompt` has to be of type `str` or `list` but is {type(prompt)}") + + if prompt is not None and negative_prompt_embeds is not None: + raise ValueError( + f"Cannot forward both `prompt`: {prompt} and `negative_prompt_embeds`:" + f" {negative_prompt_embeds}. Please make sure to only forward one of the two." + ) + + if negative_prompt is not None and negative_prompt_embeds is not None: + raise ValueError( + f"Cannot forward both `negative_prompt`: {negative_prompt} and `negative_prompt_embeds`:" + f" {negative_prompt_embeds}. Please make sure to only forward one of the two." + ) + + if prompt_embeds is not None and prompt_attention_mask is None: + raise ValueError("Must provide `prompt_attention_mask` when specifying `prompt_embeds`.") + + if negative_prompt_embeds is not None and negative_prompt_attention_mask is None: + raise ValueError("Must provide `negative_prompt_attention_mask` when specifying `negative_prompt_embeds`.") + + if prompt_embeds is not None and negative_prompt_embeds is not None: + if prompt_embeds.shape != negative_prompt_embeds.shape: + raise ValueError( + "`prompt_embeds` and `negative_prompt_embeds` must have the same shape when passed directly, but" + f" got: `prompt_embeds` {prompt_embeds.shape} != `negative_prompt_embeds`" + f" {negative_prompt_embeds.shape}." + ) + if prompt_attention_mask.shape != negative_prompt_attention_mask.shape: + raise ValueError( + "`prompt_attention_mask` and `negative_prompt_attention_mask` must have the same shape when passed directly, but" + f" got: `prompt_attention_mask` {prompt_attention_mask.shape} != `negative_prompt_attention_mask`" + f" {negative_prompt_attention_mask.shape}." + ) + + # Copied from diffusers.pipelines.deepfloyd_if.pipeline_if.IFPipeline._text_preprocessing + def _text_preprocessing(self, text, clean_caption=False): + if clean_caption and not is_bs4_available(): + logger.warning(BACKENDS_MAPPING["bs4"][-1].format("Setting `clean_caption=True`")) + logger.warning("Setting `clean_caption` to False...") + clean_caption = False + + if clean_caption and not is_ftfy_available(): + logger.warning(BACKENDS_MAPPING["ftfy"][-1].format("Setting `clean_caption=True`")) + logger.warning("Setting `clean_caption` to False...") + clean_caption = False + + if not isinstance(text, (tuple, list)): + text = [text] + + def process(text: str): + if clean_caption: + text = self._clean_caption(text) + text = self._clean_caption(text) + else: + text = text.lower().strip() + return text + + return [process(t) for t in text] + + # Copied from diffusers.pipelines.deepfloyd_if.pipeline_if.IFPipeline._clean_caption + def _clean_caption(self, caption): + caption = str(caption) + caption = ul.unquote_plus(caption) + caption = caption.strip().lower() + caption = re.sub("", "person", caption) + # urls: + caption = re.sub( + r"\b((?:https?:(?:\/{1,3}|[a-zA-Z0-9%])|[a-zA-Z0-9.\-]+[.](?:com|co|ru|net|org|edu|gov|it)[\w/-]*\b\/?(?!@)))", # noqa + "", + caption, + ) # regex for urls + caption = re.sub( + r"\b((?:www:(?:\/{1,3}|[a-zA-Z0-9%])|[a-zA-Z0-9.\-]+[.](?:com|co|ru|net|org|edu|gov|it)[\w/-]*\b\/?(?!@)))", # noqa + "", + caption, + ) # regex for urls + # html: + caption = BeautifulSoup(caption, features="html.parser").text + + # @ + caption = re.sub(r"@[\w\d]+\b", "", caption) + + # 31C0—31EF CJK Strokes + # 31F0—31FF Katakana Phonetic Extensions + # 3200—32FF Enclosed CJK Letters and Months + # 3300—33FF CJK Compatibility + # 3400—4DBF CJK Unified Ideographs Extension A + # 4DC0—4DFF Yijing Hexagram Symbols + # 4E00—9FFF CJK Unified Ideographs + caption = re.sub(r"[\u31c0-\u31ef]+", "", caption) + caption = re.sub(r"[\u31f0-\u31ff]+", "", caption) + caption = re.sub(r"[\u3200-\u32ff]+", "", caption) + caption = re.sub(r"[\u3300-\u33ff]+", "", caption) + caption = re.sub(r"[\u3400-\u4dbf]+", "", caption) + caption = re.sub(r"[\u4dc0-\u4dff]+", "", caption) + caption = re.sub(r"[\u4e00-\u9fff]+", "", caption) + ####################################################### + + # все виды тире / all types of dash --> "-" + caption = re.sub( + r"[\u002D\u058A\u05BE\u1400\u1806\u2010-\u2015\u2E17\u2E1A\u2E3A\u2E3B\u2E40\u301C\u3030\u30A0\uFE31\uFE32\uFE58\uFE63\uFF0D]+", # noqa + "-", + caption, + ) + + # кавычки к одному стандарту + caption = re.sub(r"[`´«»“”¨]", '"', caption) + caption = re.sub(r"[‘’]", "'", caption) + + # " + caption = re.sub(r""?", "", caption) + # & + caption = re.sub(r"&", "", caption) + + # ip addresses: + caption = re.sub(r"\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}", " ", caption) + + # article ids: + caption = re.sub(r"\d:\d\d\s+$", "", caption) + + # \n + caption = re.sub(r"\\n", " ", caption) + + # "#123" + caption = re.sub(r"#\d{1,3}\b", "", caption) + # "#12345.." + caption = re.sub(r"#\d{5,}\b", "", caption) + # "123456.." + caption = re.sub(r"\b\d{6,}\b", "", caption) + # filenames: + caption = re.sub(r"[\S]+\.(?:png|jpg|jpeg|bmp|webp|eps|pdf|apk|mp4)", "", caption) + + # + caption = re.sub(r"[\"\']{2,}", r'"', caption) # """AUSVERKAUFT""" + caption = re.sub(r"[\.]{2,}", r" ", caption) # """AUSVERKAUFT""" + + caption = re.sub(self.bad_punct_regex, r" ", caption) # ***AUSVERKAUFT***, #AUSVERKAUFT + caption = re.sub(r"\s+\.\s+", r" ", caption) # " . " + + # this-is-my-cute-cat / this_is_my_cute_cat + regex2 = re.compile(r"(?:\-|\_)") + if len(re.findall(regex2, caption)) > 3: + caption = re.sub(regex2, " ", caption) + + caption = ftfy.fix_text(caption) + caption = html.unescape(html.unescape(caption)) + + caption = re.sub(r"\b[a-zA-Z]{1,3}\d{3,15}\b", "", caption) # jc6640 + caption = re.sub(r"\b[a-zA-Z]+\d+[a-zA-Z]+\b", "", caption) # jc6640vc + caption = re.sub(r"\b\d+[a-zA-Z]+\d+\b", "", caption) # 6640vc231 + + caption = re.sub(r"(worldwide\s+)?(free\s+)?shipping", "", caption) + caption = re.sub(r"(free\s)?download(\sfree)?", "", caption) + caption = re.sub(r"\bclick\b\s(?:for|on)\s\w+", "", caption) + caption = re.sub(r"\b(?:png|jpg|jpeg|bmp|webp|eps|pdf|apk|mp4)(\simage[s]?)?", "", caption) + caption = re.sub(r"\bpage\s+\d+\b", "", caption) + + caption = re.sub(r"\b\d*[a-zA-Z]+\d+[a-zA-Z]+\d+[a-zA-Z\d]*\b", r" ", caption) # j2d1a2a... + + caption = re.sub(r"\b\d+\.?\d*[xх×]\d+\.?\d*\b", "", caption) + + caption = re.sub(r"\b\s+\:\s+", r": ", caption) + caption = re.sub(r"(\D[,\./])\b", r"\1 ", caption) + caption = re.sub(r"\s+", " ", caption) + + caption.strip() + + caption = re.sub(r"^[\"\']([\w\W]+)[\"\']$", r"\1", caption) + caption = re.sub(r"^[\'\_,\-\:;]", r"", caption) + caption = re.sub(r"[\'\_,\-\:\-\+]$", r"", caption) + caption = re.sub(r"^\.\S+$", "", caption) + + return caption.strip() + + def prepare_latents(self, batch_size, num_channels_latents, height, width, dtype, device, generator, latents=None): + if latents is not None: + return latents.to(device=device, dtype=dtype) + + shape = ( + batch_size, + num_channels_latents, + int(height) // self.vae_scale_factor, + int(width) // self.vae_scale_factor, + ) + if isinstance(generator, list) and len(generator) != batch_size: + raise ValueError( + f"You have passed a list of generators of length {len(generator)}, but requested an effective batch" + f" size of {batch_size}. Make sure the batch size matches the length of the generators." + ) + + latents = randn_tensor(shape, generator=generator, device=device, dtype=dtype) + return latents + + @property + def guidance_scale(self): + return self._guidance_scale + + @property + def attention_kwargs(self): + return self._attention_kwargs + + @property + def do_classifier_free_guidance(self): + return self._guidance_scale > 1.0 + + @property + def num_timesteps(self): + return self._num_timesteps + + @property + def interrupt(self): + return self._interrupt + + @torch.no_grad() + @replace_example_docstring(EXAMPLE_DOC_STRING) + def __call__( + self, + prompt: str | list[str] = None, + negative_prompt: str = "", + num_inference_steps: int = 20, + timesteps: list[int] = None, + sigmas: list[float] = None, + guidance_scale: float = 4.5, + num_images_per_prompt: int | None = 1, + height: int = 1024, + width: int = 1024, + eta: float = 0.0, + generator: torch.Generator | list[torch.Generator] | None = None, + latents: torch.Tensor | None = None, + prompt_embeds: torch.Tensor | None = None, + prompt_attention_mask: torch.Tensor | None = None, + negative_prompt_embeds: torch.Tensor | None = None, + negative_prompt_attention_mask: torch.Tensor | None = None, + output_type: str | None = "pil", + return_dict: bool = True, + clean_caption: bool = False, + use_resolution_binning: bool = True, + attention_kwargs: dict[str, Any] | None = None, + callback_on_step_end: Callable[[int, int], None] | None = None, + callback_on_step_end_tensor_inputs: list[str] = ["latents"], + max_sequence_length: int = 300, + complex_human_instruction: list[str] = [ + "Given a user prompt, generate an 'Enhanced prompt' that provides detailed visual descriptions suitable for image generation. Evaluate the level of detail in the user prompt:", + "- If the prompt is simple, focus on adding specifics about colors, shapes, sizes, textures, and spatial relationships to create vivid and concrete scenes.", + "- If the prompt is already detailed, refine and enhance the existing details slightly without overcomplicating.", + "Here are examples of how to transform or refine prompts:", + "- User Prompt: A cat sleeping -> Enhanced: A small, fluffy white cat curled up in a round shape, sleeping peacefully on a warm sunny windowsill, surrounded by pots of blooming red flowers.", + "- User Prompt: A busy city street -> Enhanced: A bustling city street scene at dusk, featuring glowing street lamps, a diverse crowd of people in colorful clothing, and a double-decker bus passing by towering glass skyscrapers.", + "Please generate only the enhanced description for the prompt below and avoid including any additional commentary or evaluations:", + "User Prompt: ", + ], + ) -> SanaPipelineOutput | tuple: + """ + Function invoked when calling the pipeline for generation. + + Args: + prompt (`str` or `list[str]`, *optional*): + The prompt or prompts to guide the image generation. If not defined, one has to pass `prompt_embeds`. + instead. + negative_prompt (`str` or `list[str]`, *optional*): + The prompt or prompts not to guide the image generation. If not defined, one has to pass + `negative_prompt_embeds` instead. Ignored when not using guidance (i.e., ignored if `guidance_scale` is + less than `1`). + num_inference_steps (`int`, *optional*, defaults to 20): + The number of denoising steps. More denoising steps usually lead to a higher quality image at the + expense of slower inference. + timesteps (`list[int]`, *optional*): + Custom timesteps to use for the denoising process with schedulers which support a `timesteps` argument + in their `set_timesteps` method. If not defined, the default behavior when `num_inference_steps` is + passed will be used. Must be in descending order. + sigmas (`list[float]`, *optional*): + Custom sigmas to use for the denoising process with schedulers which support a `sigmas` argument in + their `set_timesteps` method. If not defined, the default behavior when `num_inference_steps` is passed + will be used. + guidance_scale (`float`, *optional*, defaults to 4.5): + Guidance scale as defined in [Classifier-Free Diffusion + Guidance](https://huggingface.co/papers/2207.12598). `guidance_scale` is defined as `w` of equation 2. + of [Imagen Paper](https://huggingface.co/papers/2205.11487). Guidance scale is enabled by setting + `guidance_scale > 1`. Higher guidance scale encourages to generate images that are closely linked to + the text `prompt`, usually at the expense of lower image quality. + num_images_per_prompt (`int`, *optional*, defaults to 1): + The number of images to generate per prompt. + height (`int`, *optional*, defaults to self.unet.config.sample_size): + The height in pixels of the generated image. + width (`int`, *optional*, defaults to self.unet.config.sample_size): + The width in pixels of the generated image. + eta (`float`, *optional*, defaults to 0.0): + Corresponds to parameter eta (η) in the DDIM paper: https://huggingface.co/papers/2010.02502. Only + applies to [`schedulers.DDIMScheduler`], will be ignored for others. + generator (`torch.Generator` or `list[torch.Generator]`, *optional*): + One or a list of [torch generator(s)](https://pytorch.org/docs/stable/generated/torch.Generator.html) + to make generation deterministic. + latents (`torch.Tensor`, *optional*): + Pre-generated noisy latents, sampled from a Gaussian distribution, to be used as inputs for image + generation. Can be used to tweak the same generation with different prompts. If not provided, a latents + tensor will be generated by sampling using the supplied random `generator`. + prompt_embeds (`torch.Tensor`, *optional*): + Pre-generated text embeddings. Can be used to easily tweak text inputs, *e.g.* prompt weighting. If not + provided, text embeddings will be generated from `prompt` input argument. + prompt_attention_mask (`torch.Tensor`, *optional*): Pre-generated attention mask for text embeddings. + negative_prompt_embeds (`torch.Tensor`, *optional*): + Pre-generated negative text embeddings. For PixArt-Sigma this negative prompt should be "". If not + provided, negative_prompt_embeds will be generated from `negative_prompt` input argument. + negative_prompt_attention_mask (`torch.Tensor`, *optional*): + Pre-generated attention mask for negative text embeddings. + output_type (`str`, *optional*, defaults to `"pil"`): + The output format of the generate image. Choose between + [PIL](https://pillow.readthedocs.io/en/stable/): `PIL.Image.Image` or `np.array`. + return_dict (`bool`, *optional*, defaults to `True`): + Whether or not to return a [`~pipelines.stable_diffusion.IFPipelineOutput`] instead of a plain tuple. + attention_kwargs: + A kwargs dictionary that if specified is passed along to the `AttentionProcessor` as defined under + `self.processor` in + [diffusers.models.attention_processor](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py). + clean_caption (`bool`, *optional*, defaults to `True`): + Whether or not to clean the caption before creating embeddings. Requires `beautifulsoup4` and `ftfy` to + be installed. If the dependencies are not installed, the embeddings will be created from the raw + prompt. + use_resolution_binning (`bool` defaults to `True`): + If set to `True`, the requested height and width are first mapped to the closest resolutions using + `ASPECT_RATIO_1024_BIN`. After the produced latents are decoded into images, they are resized back to + the requested resolution. Useful for generating non-square images. + callback_on_step_end (`Callable`, *optional*): + A function that calls at the end of each denoising steps during the inference. The function is called + with the following arguments: `callback_on_step_end(self: DiffusionPipeline, step: int, timestep: int, + callback_kwargs: Dict)`. `callback_kwargs` will include a list of all tensors as specified by + `callback_on_step_end_tensor_inputs`. + callback_on_step_end_tensor_inputs (`list`, *optional*): + The list of tensor inputs for the `callback_on_step_end` function. The tensors specified in the list + will be passed as `callback_kwargs` argument. You will only be able to include variables listed in the + `._callback_tensor_inputs` attribute of your pipeline class. + max_sequence_length (`int` defaults to `300`): + Maximum sequence length to use with the `prompt`. + complex_human_instruction (`list[str]`, *optional*): + Instructions for complex human attention: + https://github.com/NVlabs/Sana/blob/main/configs/sana_app_config/Sana_1600M_app.yaml#L55. + + Examples: + + Returns: + [`~pipelines.sana.pipeline_output.SanaPipelineOutput`] or `tuple`: + If `return_dict` is `True`, [`~pipelines.sana.pipeline_output.SanaPipelineOutput`] is returned, + otherwise a `tuple` is returned where the first element is a list with the generated images + """ + + if isinstance(callback_on_step_end, (PipelineCallback, MultiPipelineCallbacks)): + callback_on_step_end_tensor_inputs = callback_on_step_end.tensor_inputs + + # 1. Check inputs. Raise error if not correct + if use_resolution_binning: + if self.transformer.config.sample_size == 128: + aspect_ratio_bin = ASPECT_RATIO_4096_BIN + elif self.transformer.config.sample_size == 64: + aspect_ratio_bin = ASPECT_RATIO_2048_BIN + elif self.transformer.config.sample_size == 32: + aspect_ratio_bin = ASPECT_RATIO_1024_BIN + elif self.transformer.config.sample_size == 16: + aspect_ratio_bin = ASPECT_RATIO_512_BIN + else: + raise ValueError("Invalid sample size") + orig_height, orig_width = height, width + height, width = self.image_processor.classify_height_width_bin(height, width, ratios=aspect_ratio_bin) + + self.check_inputs( + prompt, + height, + width, + callback_on_step_end_tensor_inputs, + negative_prompt, + prompt_embeds, + negative_prompt_embeds, + prompt_attention_mask, + negative_prompt_attention_mask, + ) + + self._guidance_scale = guidance_scale + self._attention_kwargs = attention_kwargs + self._interrupt = False + + # 2. Default height and width to transformer + if prompt is not None and isinstance(prompt, str): + batch_size = 1 + elif prompt is not None and isinstance(prompt, list): + batch_size = len(prompt) + else: + batch_size = prompt_embeds.shape[0] + + device = self._execution_device + lora_scale = self.attention_kwargs.get("scale", None) if self.attention_kwargs is not None else None + + # 3. Encode input prompt + ( + prompt_embeds, + prompt_attention_mask, + negative_prompt_embeds, + negative_prompt_attention_mask, + ) = self.encode_prompt( + prompt, + self.do_classifier_free_guidance, + negative_prompt=negative_prompt, + num_images_per_prompt=num_images_per_prompt, + device=device, + prompt_embeds=prompt_embeds, + negative_prompt_embeds=negative_prompt_embeds, + prompt_attention_mask=prompt_attention_mask, + negative_prompt_attention_mask=negative_prompt_attention_mask, + clean_caption=clean_caption, + max_sequence_length=max_sequence_length, + complex_human_instruction=complex_human_instruction, + lora_scale=lora_scale, + ) + if self.do_classifier_free_guidance: + prompt_embeds = torch.cat([negative_prompt_embeds, prompt_embeds], dim=0) + prompt_attention_mask = torch.cat([negative_prompt_attention_mask, prompt_attention_mask], dim=0) + + # 4. Prepare timesteps + if XLA_AVAILABLE: + timestep_device = "cpu" + else: + timestep_device = device + timesteps, num_inference_steps = retrieve_timesteps( + self.scheduler, num_inference_steps, timestep_device, timesteps, sigmas + ) + + # 5. Prepare latents. + latent_channels = self.transformer.config.in_channels + latents = self.prepare_latents( + batch_size * num_images_per_prompt, + latent_channels, + height, + width, + torch.float32, + device, + generator, + latents, + ) + + # 6. Prepare extra step kwargs. TODO: Logic should ideally just be moved out of the pipeline + extra_step_kwargs = self.prepare_extra_step_kwargs(generator, eta) + + # 7. Denoising loop + num_warmup_steps = max(len(timesteps) - num_inference_steps * self.scheduler.order, 0) + self._num_timesteps = len(timesteps) + + transformer_dtype = self.transformer.dtype + with self.progress_bar(total=num_inference_steps) as progress_bar: + for i, t in enumerate(timesteps): + if self.interrupt: + continue + + latent_model_input = torch.cat([latents] * 2) if self.do_classifier_free_guidance else latents + + # broadcast to batch dimension in a way that's compatible with ONNX/Core ML + timestep = t.expand(latent_model_input.shape[0]) + timestep = timestep * self.transformer.config.timestep_scale + + # predict noise model_output + noise_pred = self.transformer( + latent_model_input.to(dtype=transformer_dtype), + encoder_hidden_states=prompt_embeds.to(dtype=transformer_dtype), + encoder_attention_mask=prompt_attention_mask, + timestep=timestep, + return_dict=False, + attention_kwargs=self.attention_kwargs, + )[0] + noise_pred = noise_pred.float() + + # perform guidance + if self.do_classifier_free_guidance: + noise_pred_uncond, noise_pred_text = noise_pred.chunk(2) + noise_pred = noise_pred_uncond + guidance_scale * (noise_pred_text - noise_pred_uncond) + + # learned sigma + if self.transformer.config.out_channels // 2 == latent_channels: + noise_pred = noise_pred.chunk(2, dim=1)[0] + + # compute previous image: x_t -> x_t-1 + latents = self.scheduler.step(noise_pred, t, latents, **extra_step_kwargs, return_dict=False)[0] + + if callback_on_step_end is not None: + callback_kwargs = {} + for k in callback_on_step_end_tensor_inputs: + callback_kwargs[k] = locals()[k] + callback_outputs = callback_on_step_end(self, i, t, callback_kwargs) + + latents = callback_outputs.pop("latents", latents) + prompt_embeds = callback_outputs.pop("prompt_embeds", prompt_embeds) + negative_prompt_embeds = callback_outputs.pop("negative_prompt_embeds", negative_prompt_embeds) + + # call the callback, if provided + if i == len(timesteps) - 1 or ((i + 1) > num_warmup_steps and (i + 1) % self.scheduler.order == 0): + progress_bar.update() + + if XLA_AVAILABLE: + xm.mark_step() + + if output_type == "latent": + image = latents + else: + latents = latents.to(self.vae.dtype) + torch_accelerator_module = getattr(torch, get_device(), torch.cuda) + oom_error = ( + torch.OutOfMemoryError + if is_torch_version(">=", "2.5.0") + else torch_accelerator_module.OutOfMemoryError + ) + try: + image = self.vae.decode(latents / self.vae.config.scaling_factor, return_dict=False)[0] + except oom_error as e: + warnings.warn( + f"{e}. \n" + f"Try to use VAE tiling for large images. For example: \n" + f"pipe.vae.enable_tiling(tile_sample_min_width=512, tile_sample_min_height=512)" + ) + if use_resolution_binning: + image = self.image_processor.resize_and_crop_tensor(image, orig_width, orig_height) + + if not output_type == "latent": + image = self.image_processor.postprocess(image, output_type=output_type) + + # Offload all models + self.maybe_free_model_hooks() + + if not return_dict: + return (image,) + + return SanaPipelineOutput(images=image) \ No newline at end of file diff --git a/lrm/lrm_sana/docs/migration_notes.md b/lrm/lrm_sana/docs/migration_notes.md new file mode 100644 index 0000000000000000000000000000000000000000..9969c2a7876a02650efce06e7de0ee52fbff3763 --- /dev/null +++ b/lrm/lrm_sana/docs/migration_notes.md @@ -0,0 +1,45 @@ +# Migration Notes: Flux -> SANA LRM + +## Reused Components +- Training loop orchestration from `flux/trainer/scripts/train.py`. +- Accelerator stack (`base`, `debug`, `deepspeed`). +- Optimizer and LR scheduler modules. +- Pairwise loss structure and evaluation flow. +- Dataset filtering logic including pseudo-preference support. + +## SANA-Specific Adaptations +- Replace Flux model wrapper with SANA latent-transformer wrapper. +- Replace Flux tokenizer/text path with variant-aware SANA path. +- Keep pairwise reward objective unchanged; adapt only feature extraction. +- Add model profile support for four requested checkpoints. + +## Naming Changes +- `step_flux` -> `step_sana` +- `step_flux_base` -> `step_sana_base` +- `step_clip_flux` -> `step_clip_sana` +- `FluxPreferenceModel` -> `SanaPreferenceModel` + +## Config Baseline Choice +- Dataset source follows flux working setting: + - `pickapic-anonymous/pickapic_v1` +- Pseudo preference CSV path follows flux launcher fallback behavior. +- Logging/output path remains flux-style to simplify operational parity. + +## Runtime Notes +- Quick profile should force minimal run: + - test split for train/valid/test + - image size downscaled + - `max_steps=1` +- Main profile should use production defaults with DeepSpeed sharded mode. + +## Known Risks During Migration +- Mismatch between tokenizer outputs and model forward signature. +- Caption embedding/channel shape mismatch in SANA transformer conditioning. +- Missing subfolders for some checkpoints (tokenizer_2 or text_encoder_2). +- Diffusers/transformers version compatibility for SANA classes. + +## Mitigation Strategy +- Use profile metadata for each checkpoint (explicit, not implicit only). +- Fail fast with clear validation errors at model init time. +- Keep quick-run smoke checks as gate before longer runs. +- Preserve fallback behavior from flux launcher for data and cache paths. diff --git a/lrm/lrm_sana/docs/plan.md b/lrm/lrm_sana/docs/plan.md new file mode 100644 index 0000000000000000000000000000000000000000..5eb6ab6afe0ba4d63ceee96d57ed8f3e1e4f181e --- /dev/null +++ b/lrm/lrm_sana/docs/plan.md @@ -0,0 +1,83 @@ +# SANA LRM Implementation Plan + +## Goal +Build a working latent-space reward model (LRM) under `lrm_sana` that follows the proven training path used in `flux` and aligns with the LRM objective from https://arxiv.org/abs/2502.01051. + +## Scope +- Keep code inside `lrm_sana`. +- Keep all markdown docs inside `lrm_sana/docs`. +- Reuse the available dataset path/protocol from `flux`. +- Preserve flux-like run facilities: launcher profiles, logs structure, checkpoint behavior. +- Support these SANA checkpoints via model profiles: + - `Efficient-Large-Model/Sana_600M_512px_diffusers` + - `Efficient-Large-Model/Sana_1600M_512px_diffusers` + - `Efficient-Large-Model/Sana_Sprint_0.6B_1024px_diffusers` + - `Efficient-Large-Model/Sana_Sprint_1.6B_1024px_diffusers` + +## Constraints +- Use `pickapic-anonymous/pickapic_v1` dataset flow from `flux`. +- Keep pseudo-preference CSV filtering support (`vqa_aes_clip_score_mp.csv`). +- Follow distributed DeepSpeed launch conventions from `flux/train_flux.sh`. +- Add variant-aware SANA text path so single/dual encoder variants can be handled safely. + +## Phases + +### Phase 1: Docs-First Baseline +- Create planning and architecture docs in `lrm_sana/docs`. +- Define implementation checkpoints and verification criteria before code rewrites. + +### Phase 2: Project Scaffolding +- Mirror `flux` trainer structure into `lrm_sana/trainer`. +- Add top-level files: `lrm_sana/setup.py`, `lrm_sana/train_lrm_sana.sh`. +- Keep import paths local to `lrm_sana` package. + +### Phase 3: Config and Registration Wiring +- Add SANA config groups and names: + - task: `step_sana` + - dataset: `step_sana` + - model: `step_sana_base` + - criterion: `step_clip_sana` +- Add `step_sana_base.yaml` with flux-like accelerator/dataset defaults. + +### Phase 4: SANA Preference Model +- Implement `trainer/models/sana_preference_model.py`: + - SANA tokenizer/text encoder loading. + - SANA VAE latent encode + scaling. + - Scheduler timestep/noise mixing. + - SANA transformer forward. + - Text/image projection heads and `logit_scale`. +- Keep save/load behavior compatible with current trainer checkpoint flow. + +### Phase 5: Dataset/Task/Criterion Integration +- Implement `step_sana_hf_dataset.py` from `step_flux_hf_dataset.py` baseline. +- Implement `step_sana_task.py` from `step_flux_task.py` baseline. +- Implement `step_clip_criterion_sana.py` from flux criterion baseline. +- Keep pairwise preference loss, distributed gather, and eval accuracy logic. + +### Phase 6: Runtime Script and Profiles +- Adapt `train_lrm_sana.sh` from `train_flux.sh`: + - `RUN_PROFILE=main|quick` + - offline cache env defaults + - pseudo-preference CSV fallback + - DeepSpeed sharded launch +- Add model profile selection variable for the four SANA checkpoints. + +### Phase 7: Verification +- Static checks: + - module imports + - hydra config composition + - dataclass/config registration validity +- Runtime checks: + - quick smoke run (`max_steps=1`) + - output/log/checkpoint tree validation + +## Deliverables +- Working SANA LRM code under `lrm_sana`. +- Documentation set in `lrm_sana/docs`. +- Flux-like launcher for H200 node testing. + +## Success Criteria +- Training script launches and completes a quick run end-to-end. +- Dataloader, model forward, criterion loss, and eval metric path work without interface mismatch. +- Logs/checkpoints/config snapshots are written to expected locations. +- Model profile switch works across the four requested SANA checkpoints. diff --git a/lrm/lrm_sana/logs/lrm/reward_model/step_sana_sana_sprint_0_6b_1024_variable-t_lr1e-5_step-8000_filter2_time951/.hydra/config.yaml b/lrm/lrm_sana/logs/lrm/reward_model/step_sana_sana_sprint_0_6b_1024_variable-t_lr1e-5_step-8000_filter2_time951/.hydra/config.yaml new file mode 100644 index 0000000000000000000000000000000000000000..96602d1464fa5e18378cffde8edb7d5586fb1c62 --- /dev/null +++ b/lrm/lrm_sana/logs/lrm/reward_model/step_sana_sana_sprint_0_6b_1024_variable-t_lr1e-5_step-8000_filter2_time951/.hydra/config.yaml @@ -0,0 +1,126 @@ +accelerator: + _target_: trainer.accelerators.debug_accelerator.DebugAccelerator + output_dir: ${output_dir} + mixed_precision: BF16 + gradient_accumulation_steps: 1 + log_with: null + debug: + activate: false + port: 5900 + seed: 42 + resume_from_checkpoint: false + max_steps: 8000 + num_epochs: 10 + validate_steps: 100 + generalization_validate_steps: 500 + eval_on_start: false + project_name: reward_model + run_name: step_sana_sana_sprint_0_6b_1024_variable-t_lr1e-5_step-8000_filter2_time951 + max_grad_norm: 1.0 + save_steps: 100 + metric_name: accuracy + metric_mode: MAX + limit_num_checkpoints: 1 + save_only_if_best: true + dynamo_backend: 'NO' + keep_best_ckpts: true + progress_log_interval: 50 +task: + limit_examples_to_wandb: 50 + _target_: trainer.tasks.step_sana_task.StepSanaTask + pretrained_model_name_or_path: ${model.pretrained_model_name_or_path} + tokenizer_subfolder: tokenizer + label_0_column_name: ${dataset.label_0_column_name} + label_1_column_name: ${dataset.label_1_column_name} + input_ids_column_name: ${dataset.input_ids_column_name} + input_ids_2_column_name: ${dataset.input_ids_2_column_name} + pixels_0_column_name: ${dataset.pixels_0_column_name} + pixels_1_column_name: ${dataset.pixels_1_column_name} + timestep_column_name: ${dataset.timestep_column_name} + constant_timestep: ${dataset.constant_timestep} +model: + _target_: trainer.models.sana_preference_model.SanaPreferenceModel + pretrained_model_name_or_path: Efficient-Large-Model/Sana_Sprint_0.6B_1024px_diffusers + pretrained_vae_name_or_path: '' + model_profile: sana_sprint_0_6b_1024 + projection_dim: 1024 + logit_scale_init_value: 2.6592 + freeze_text_encoder: false + guidance_scale: 0.0 + noise_offset: false + noise_offset_coeff: 0.05 + max_sequence_length: 300 + max_sequence_length_2: 300 + image_size: 1024 +criterion: + _target_: trainer.criterions.step_clip_criterion_sana.StepSanaCLIPCriterion + is_distributed: false + label_0_column_name: ${dataset.label_0_column_name} + label_1_column_name: ${dataset.label_1_column_name} + input_ids_column_name: ${dataset.input_ids_column_name} + input_ids_2_column_name: ${dataset.input_ids_2_column_name} + pixels_0_column_name: ${dataset.pixels_0_column_name} + pixels_1_column_name: ${dataset.pixels_1_column_name} + num_examples_per_prompt_column_name: ${dataset.num_examples_per_prompt_column_name} + timestep_column_name: ${dataset.timestep_column_name} + loss_type: pair + batch_coeff: 1.0 + aux_loss_coeff: 1.0 +dataset: + train_split_name: train + valid_split_name: validation_unique + test_split_name: test_unique + batch_size: 4 + num_workers: 2 + drop_last: true + _target_: trainer.datasets.step_sana_hf_dataset.StepSanaHFDataset + dataset_name: pickapic-anonymous/pickapic_v1 + dataset_config_name: null + from_disk: false + cache_dir: null + caption_column_name: caption + input_ids_column_name: input_ids + input_ids_2_column_name: input_ids_2 + image_0_column_name: jpg_0 + image_1_column_name: jpg_1 + label_0_column_name: label_0 + label_1_column_name: label_1 + are_different_column_name: are_different + has_label_column_name: has_label + pixels_0_column_name: pixel_values_0 + pixels_1_column_name: pixel_values_1 + timestep_column_name: timestep + constant_timestep: 1 + variable_timestep: true + largest_timestep: 951 + compare_between_timestep: false + timestep_comparison_column_name: timestep_comparison + timestep_interval: 1 + num_examples_per_prompt_column_name: num_example_per_prompt + keep_only_different: false + keep_only_with_label: false + keep_only_with_label_in_non_train: true + keep_only_with_pesudo_preference: true + pseudo_preference_path: /g/data/rr81/LPO/lrm/lrm_sana/vqa_aes_clip_score_mp.csv + filter_strategy: 2 + processor: + pretrained_model_name_or_path: ${model.pretrained_model_name_or_path} + max_sequence_length: ${model.max_sequence_length} + max_sequence_length_2: ${model.max_sequence_length_2} + image_size: ${model.image_size} + random_crop: false + no_hflip: true + limit_examples_per_prompt: -1 + only_on_best: false +optimizer: + _target_: trainer.optimizers.adamw.BaseAdamW + lr: 5.0e-05 +lr_scheduler: + _target_: trainer.lr_schedulers.constant_with_warmup.instantiate_dummy_lr_scheduler + lr: ${optimizer.lr} + lr_warmup_steps: 1000 + total_num_steps: ${accelerator.max_steps} +debug: + activate: false + port: 5900 +output_dir: logs/lrm/${accelerator.project_name}/${accelerator.run_name} diff --git a/lrm/lrm_sana/logs/lrm/reward_model/step_sana_sana_sprint_0_6b_1024_variable-t_lr1e-5_step-8000_filter2_time951/.hydra/hydra.yaml b/lrm/lrm_sana/logs/lrm/reward_model/step_sana_sana_sprint_0_6b_1024_variable-t_lr1e-5_step-8000_filter2_time951/.hydra/hydra.yaml new file mode 100644 index 0000000000000000000000000000000000000000..7f7a1e15f8866c0d170d9f60eeb53c1709912ce6 --- /dev/null +++ b/lrm/lrm_sana/logs/lrm/reward_model/step_sana_sana_sprint_0_6b_1024_variable-t_lr1e-5_step-8000_filter2_time951/.hydra/hydra.yaml @@ -0,0 +1,172 @@ +hydra: + run: + dir: ${output_dir} + sweep: + dir: multirun/${now:%Y-%m-%d}/${now:%H-%M-%S} + subdir: ${hydra.job.num} + launcher: + _target_: hydra._internal.core_plugins.basic_launcher.BasicLauncher + sweeper: + _target_: hydra._internal.core_plugins.basic_sweeper.BasicSweeper + max_batch_size: null + params: null + help: + app_name: ${hydra.job.name} + header: '${hydra.help.app_name} is powered by Hydra. + + ' + footer: 'Powered by Hydra (https://hydra.cc) + + Use --hydra-help to view Hydra specific help + + ' + template: '${hydra.help.header} + + == Configuration groups == + + Compose your configuration from those groups (group=option) + + + $APP_CONFIG_GROUPS + + + == Config == + + Override anything in the config (foo.bar=value) + + + $CONFIG + + + ${hydra.help.footer} + + ' + hydra_help: + template: 'Hydra (${hydra.runtime.version}) + + See https://hydra.cc for more info. + + + == Flags == + + $FLAGS_HELP + + + == Configuration groups == + + Compose your configuration from those groups (For example, append hydra/job_logging=disabled + to command line) + + + $HYDRA_CONFIG_GROUPS + + + Use ''--cfg hydra'' to Show the Hydra config. + + ' + hydra_help: ??? + hydra_logging: + version: 1 + formatters: + simple: + format: '[%(asctime)s][HYDRA] %(message)s' + handlers: + console: + class: logging.StreamHandler + formatter: simple + stream: ext://sys.stdout + root: + level: INFO + handlers: + - console + loggers: + logging_example: + level: DEBUG + disable_existing_loggers: false + job_logging: + version: 1 + formatters: + simple: + format: '[%(asctime)s][%(name)s][%(levelname)s] - %(message)s' + handlers: + console: + class: logging.StreamHandler + formatter: simple + stream: ext://sys.stdout + file: + class: logging.FileHandler + formatter: simple + filename: ${hydra.runtime.output_dir}/${hydra.job.name}.log + root: + level: INFO + handlers: + - console + - file + disable_existing_loggers: false + env: {} + mode: RUN + searchpath: [] + callbacks: {} + output_subdir: .hydra + overrides: + hydra: + - hydra.mode=RUN + task: + - accelerator.mixed_precision=BF16 + - model.model_profile=sana_sprint_0_6b_1024 + - model.pretrained_model_name_or_path=Efficient-Large-Model/Sana_Sprint_0.6B_1024px_diffusers + - model.image_size=1024 + - accelerator.run_name=step_sana_sana_sprint_0_6b_1024_variable-t_lr1e-5_step-8000_filter2_time951 + - accelerator.log_with=null + - accelerator=debug + - criterion.is_distributed=false + - dataset.pseudo_preference_path=/g/data/rr81/LPO/lrm/lrm_sana/vqa_aes_clip_score_mp.csv + - dataset.valid_split_name=validation_unique + - dataset.test_split_name=test_unique + job: + name: train + chdir: null + override_dirname: accelerator.log_with=null,accelerator.mixed_precision=BF16,accelerator.run_name=step_sana_sana_sprint_0_6b_1024_variable-t_lr1e-5_step-8000_filter2_time951,accelerator=debug,criterion.is_distributed=false,dataset.pseudo_preference_path=/g/data/rr81/LPO/lrm/lrm_sana/vqa_aes_clip_score_mp.csv,dataset.test_split_name=test_unique,dataset.valid_split_name=validation_unique,model.image_size=1024,model.model_profile=sana_sprint_0_6b_1024,model.pretrained_model_name_or_path=Efficient-Large-Model/Sana_Sprint_0.6B_1024px_diffusers + id: ??? + num: ??? + config_name: step_sana_base + env_set: {} + env_copy: [] + config: + override_dirname: + kv_sep: '=' + item_sep: ',' + exclude_keys: [] + runtime: + version: 1.3.2 + version_base: '1.3' + cwd: /g/data/rr81/LPO/lrm/lrm_sana + config_sources: + - path: hydra.conf + schema: pkg + provider: hydra + - path: /g/data/rr81/LPO/lrm/lrm_sana/trainer/conf + schema: file + provider: main + - path: '' + schema: structured + provider: schema + output_dir: /g/data/rr81/LPO/lrm/lrm_sana/logs/lrm/reward_model/step_sana_sana_sprint_0_6b_1024_variable-t_lr1e-5_step-8000_filter2_time951 + choices: + lr_scheduler: constant_with_warmup + optimizer: adamw + dataset: step_sana + criterion: step_clip_sana + model: step_sana_base + task: step_sana + accelerator: debug + hydra/env: default + hydra/callbacks: null + hydra/job_logging: default + hydra/hydra_logging: default + hydra/hydra_help: default + hydra/help: default + hydra/sweeper: basic + hydra/launcher: basic + hydra/output: default + verbose: false diff --git a/lrm/lrm_sana/logs/lrm/reward_model/step_sana_sana_sprint_0_6b_1024_variable-t_lr1e-5_step-8000_filter2_time951/.hydra/overrides.yaml b/lrm/lrm_sana/logs/lrm/reward_model/step_sana_sana_sprint_0_6b_1024_variable-t_lr1e-5_step-8000_filter2_time951/.hydra/overrides.yaml new file mode 100644 index 0000000000000000000000000000000000000000..1b4e25bcbe880f51ee6bf95c5122e3358ec83f7a --- /dev/null +++ b/lrm/lrm_sana/logs/lrm/reward_model/step_sana_sana_sprint_0_6b_1024_variable-t_lr1e-5_step-8000_filter2_time951/.hydra/overrides.yaml @@ -0,0 +1,11 @@ +- accelerator.mixed_precision=BF16 +- model.model_profile=sana_sprint_0_6b_1024 +- model.pretrained_model_name_or_path=Efficient-Large-Model/Sana_Sprint_0.6B_1024px_diffusers +- model.image_size=1024 +- accelerator.run_name=step_sana_sana_sprint_0_6b_1024_variable-t_lr1e-5_step-8000_filter2_time951 +- accelerator.log_with=null +- accelerator=debug +- criterion.is_distributed=false +- dataset.pseudo_preference_path=/g/data/rr81/LPO/lrm/lrm_sana/vqa_aes_clip_score_mp.csv +- dataset.valid_split_name=validation_unique +- dataset.test_split_name=test_unique diff --git a/lrm/lrm_sana/logs/lrm/reward_model/step_sana_sana_sprint_0_6b_1024_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep1600/training_stage.json b/lrm/lrm_sana/logs/lrm/reward_model/step_sana_sana_sprint_0_6b_1024_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep1600/training_stage.json new file mode 100644 index 0000000000000000000000000000000000000000..179ca0055b1b0191c00575ead150a4d08cb8d8fd --- /dev/null +++ b/lrm/lrm_sana/logs/lrm/reward_model/step_sana_sana_sprint_0_6b_1024_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep1600/training_stage.json @@ -0,0 +1,14 @@ +{ + "epoch": 0, + "step": 1600, + "global_step": 1600, + "step_loss": 0.0, + "lr": 5e-05, + "metrics": { + "logit_scale": 14.22330093383789, + "accuracy": 0.548235294117647, + "num_samples": 425, + "test_unique_accuracy": 0.4791666666666667, + "test_unique_num_samples": 432 + } +} \ No newline at end of file diff --git a/lrm/lrm_sana/logs/lrm/reward_model/step_sana_sana_sprint_0_6b_1024_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep4400/training_stage.json b/lrm/lrm_sana/logs/lrm/reward_model/step_sana_sana_sprint_0_6b_1024_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep4400/training_stage.json new file mode 100644 index 0000000000000000000000000000000000000000..8a53ed7b4f75209c10ae0a4d4ae6efdf70fdab83 --- /dev/null +++ b/lrm/lrm_sana/logs/lrm/reward_model/step_sana_sana_sprint_0_6b_1024_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep4400/training_stage.json @@ -0,0 +1,14 @@ +{ + "epoch": 0, + "step": 4400, + "global_step": 4400, + "step_loss": 0.0, + "lr": 5e-05, + "metrics": { + "logit_scale": 14.216266632080078, + "accuracy": 0.5694117647058824, + "num_samples": 425, + "test_unique_accuracy": 0.5393518518518519, + "test_unique_num_samples": 432 + } +} \ No newline at end of file diff --git a/lrm/lrm_sana/logs/lrm/reward_model/step_sana_sana_sprint_0_6b_1024_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep500/training_stage.json b/lrm/lrm_sana/logs/lrm/reward_model/step_sana_sana_sprint_0_6b_1024_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep500/training_stage.json new file mode 100644 index 0000000000000000000000000000000000000000..78a1525355d50fe131f8c6c951004a55d32deeb5 --- /dev/null +++ b/lrm/lrm_sana/logs/lrm/reward_model/step_sana_sana_sprint_0_6b_1024_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep500/training_stage.json @@ -0,0 +1,14 @@ +{ + "epoch": 0, + "step": 500, + "global_step": 500, + "step_loss": 0.0, + "lr": 2.5e-05, + "metrics": { + "logit_scale": 14.269028663635254, + "accuracy": 0.5270588235294118, + "num_samples": 425, + "test_unique_accuracy": 0.5277777777777778, + "test_unique_num_samples": 432 + } +} \ No newline at end of file diff --git a/lrm/lrm_sana/logs/lrm/reward_model/step_sana_sana_sprint_0_6b_1024_variable-t_lr1e-5_step-8000_filter2_time951/config.yaml b/lrm/lrm_sana/logs/lrm/reward_model/step_sana_sana_sprint_0_6b_1024_variable-t_lr1e-5_step-8000_filter2_time951/config.yaml new file mode 100644 index 0000000000000000000000000000000000000000..36028e9d92f0de4247e016ea62f0778fc5466bf6 --- /dev/null +++ b/lrm/lrm_sana/logs/lrm/reward_model/step_sana_sana_sprint_0_6b_1024_variable-t_lr1e-5_step-8000_filter2_time951/config.yaml @@ -0,0 +1,126 @@ +accelerator: + _target_: trainer.accelerators.debug_accelerator.DebugAccelerator + output_dir: logs/lrm/reward_model/step_sana_sana_sprint_0_6b_1024_variable-t_lr1e-5_step-8000_filter2_time951 + mixed_precision: BF16 + gradient_accumulation_steps: 1 + log_with: null + debug: + activate: false + port: 5900 + seed: 42 + resume_from_checkpoint: false + max_steps: 8000 + num_epochs: 10 + validate_steps: 100 + generalization_validate_steps: 500 + eval_on_start: false + project_name: reward_model + run_name: step_sana_sana_sprint_0_6b_1024_variable-t_lr1e-5_step-8000_filter2_time951 + max_grad_norm: 1.0 + save_steps: 100 + metric_name: accuracy + metric_mode: MAX + limit_num_checkpoints: 1 + save_only_if_best: true + dynamo_backend: 'NO' + keep_best_ckpts: true + progress_log_interval: 50 +task: + limit_examples_to_wandb: 50 + _target_: trainer.tasks.step_sana_task.StepSanaTask + pretrained_model_name_or_path: Efficient-Large-Model/Sana_Sprint_0.6B_1024px_diffusers + tokenizer_subfolder: tokenizer + label_0_column_name: label_0 + label_1_column_name: label_1 + input_ids_column_name: input_ids + input_ids_2_column_name: input_ids_2 + pixels_0_column_name: pixel_values_0 + pixels_1_column_name: pixel_values_1 + timestep_column_name: timestep + constant_timestep: 1 +model: + _target_: trainer.models.sana_preference_model.SanaPreferenceModel + pretrained_model_name_or_path: Efficient-Large-Model/Sana_Sprint_0.6B_1024px_diffusers + pretrained_vae_name_or_path: '' + model_profile: sana_sprint_0_6b_1024 + projection_dim: 1024 + logit_scale_init_value: 2.6592 + freeze_text_encoder: false + guidance_scale: 0.0 + noise_offset: false + noise_offset_coeff: 0.05 + max_sequence_length: 300 + max_sequence_length_2: 300 + image_size: 1024 +criterion: + _target_: trainer.criterions.step_clip_criterion_sana.StepSanaCLIPCriterion + is_distributed: false + label_0_column_name: label_0 + label_1_column_name: label_1 + input_ids_column_name: input_ids + input_ids_2_column_name: input_ids_2 + pixels_0_column_name: pixel_values_0 + pixels_1_column_name: pixel_values_1 + num_examples_per_prompt_column_name: num_example_per_prompt + timestep_column_name: timestep + loss_type: pair + batch_coeff: 1.0 + aux_loss_coeff: 1.0 +dataset: + train_split_name: train + valid_split_name: validation_unique + test_split_name: test_unique + batch_size: 4 + num_workers: 2 + drop_last: true + _target_: trainer.datasets.step_sana_hf_dataset.StepSanaHFDataset + dataset_name: pickapic-anonymous/pickapic_v1 + dataset_config_name: null + from_disk: false + cache_dir: null + caption_column_name: caption + input_ids_column_name: input_ids + input_ids_2_column_name: input_ids_2 + image_0_column_name: jpg_0 + image_1_column_name: jpg_1 + label_0_column_name: label_0 + label_1_column_name: label_1 + are_different_column_name: are_different + has_label_column_name: has_label + pixels_0_column_name: pixel_values_0 + pixels_1_column_name: pixel_values_1 + timestep_column_name: timestep + constant_timestep: 1 + variable_timestep: true + largest_timestep: 951 + compare_between_timestep: false + timestep_comparison_column_name: timestep_comparison + timestep_interval: 1 + num_examples_per_prompt_column_name: num_example_per_prompt + keep_only_different: false + keep_only_with_label: false + keep_only_with_label_in_non_train: true + keep_only_with_pesudo_preference: true + pseudo_preference_path: /g/data/rr81/LPO/lrm/lrm_sana/vqa_aes_clip_score_mp.csv + filter_strategy: 2 + processor: + pretrained_model_name_or_path: Efficient-Large-Model/Sana_Sprint_0.6B_1024px_diffusers + max_sequence_length: 300 + max_sequence_length_2: 300 + image_size: 1024 + random_crop: false + no_hflip: true + limit_examples_per_prompt: -1 + only_on_best: false +optimizer: + _target_: trainer.optimizers.adamw.BaseAdamW + lr: 5.0e-05 +lr_scheduler: + _target_: trainer.lr_schedulers.constant_with_warmup.instantiate_dummy_lr_scheduler + lr: 5.0e-05 + lr_warmup_steps: 1000 + total_num_steps: 8000 +debug: + activate: false + port: 5900 +output_dir: logs/lrm/reward_model/step_sana_sana_sprint_0_6b_1024_variable-t_lr1e-5_step-8000_filter2_time951 diff --git a/lrm/lrm_sana/logs/lrm/reward_model/step_sana_sana_sprint_0_6b_1024_variable-t_lr1e-5_step-8000_filter2_time951/train.log b/lrm/lrm_sana/logs/lrm/reward_model/step_sana_sana_sprint_0_6b_1024_variable-t_lr1e-5_step-8000_filter2_time951/train.log new file mode 100644 index 0000000000000000000000000000000000000000..cf3e6c7550f1555dc337b0f0756063a9ef4f2158 --- /dev/null +++ b/lrm/lrm_sana/logs/lrm/reward_model/step_sana_sana_sprint_0_6b_1024_variable-t_lr1e-5_step-8000_filter2_time951/train.log @@ -0,0 +1,818 @@ +[2026-04-06 16:57:55,599][accelerate.utils.other][WARNING] - Detected kernel version 4.18.0, which is below the recommended minimum of 5.5.0; this can cause the process to hang. It is recommended to upgrade the kernel to the minimum version or higher. +[2026-04-06 16:57:55,600][trainer.accelerators.base_accelerator][INFO] - Setting seed 42 +[2026-04-06 16:57:55,615][trainer.accelerators.base_accelerator][INFO] - Initialized accelerator: rank=0 +[2026-04-06 16:57:55,657][__main__][INFO] - Config can be found in logs/lrm/reward_model/step_sana_sana_sprint_0_6b_1024_variable-t_lr1e-5_step-8000_filter2_time951/config.yaml +[2026-04-06 16:57:55,657][__main__][INFO] - Loading task +[2026-04-06 16:57:56,663][__main__][INFO] - Loading model +[2026-04-06 16:58:20,366][accelerate.utils.other][WARNING] - Detected kernel version 4.18.0, which is below the recommended minimum of 5.5.0; this can cause the process to hang. It is recommended to upgrade the kernel to the minimum version or higher. +[2026-04-06 16:58:20,367][trainer.accelerators.base_accelerator][INFO] - Setting seed 42 +[2026-04-06 16:58:20,383][trainer.accelerators.base_accelerator][INFO] - Initialized accelerator: rank=0 +[2026-04-06 16:58:20,388][__main__][INFO] - Config can be found in logs/lrm/reward_model/step_sana_sana_sprint_0_6b_1024_variable-t_lr1e-5_step-8000_filter2_time951/config.yaml +[2026-04-06 16:58:20,388][__main__][INFO] - Loading task +[2026-04-06 16:58:21,466][__main__][INFO] - Loading model +[2026-04-06 16:58:23,131][__main__][INFO] - Loading criterion +[2026-04-06 16:58:23,131][__main__][INFO] - Loading optimizer +[2026-04-06 16:58:23,135][__main__][INFO] - Loading lr scheduler +[2026-04-06 16:58:23,136][__main__][INFO] - Loading dataloaders +[2026-04-06 16:58:23,136][trainer.datasets.step_sana_hf_dataset][INFO] - Using step-aware datasets +[2026-04-06 16:58:23,136][trainer.datasets.step_sana_hf_dataset][INFO] - Loading train dataset +[2026-04-06 16:58:23,136][trainer.datasets.step_sana_hf_dataset][INFO] - Batch size is 4 +[2026-04-06 16:58:23,137][trainer.datasets.step_sana_hf_dataset][INFO] - Loading cached offline split 'train' from 387 parquet shards +[2026-04-06 16:58:24,139][trainer.datasets.step_sana_hf_dataset][INFO] - Loaded 583747 examples from train dataset +[2026-04-06 16:58:24,630][trainer.datasets.step_sana_hf_dataset][INFO] - Keeping only examples with pesudo preference, filter_strategy: 2 +[2026-04-06 16:58:24,637][trainer.datasets.step_sana_hf_dataset][INFO] - Loaded 583747 examples from train dataset +[2026-04-06 16:58:24,814][trainer.datasets.step_sana_hf_dataset][INFO] - Kept 177076 examples from train dataset +[2026-04-06 16:58:24,815][trainer.datasets.step_sana_hf_dataset][INFO] - Loaded 177076 examples from train dataset +[2026-04-06 16:58:25,632][trainer.datasets.step_sana_hf_dataset][INFO] - Using step-aware datasets +[2026-04-06 16:58:25,632][trainer.datasets.step_sana_hf_dataset][INFO] - Loading validation_unique dataset +[2026-04-06 16:58:25,633][trainer.datasets.step_sana_hf_dataset][INFO] - Batch size is 4 +[2026-04-06 16:58:25,634][trainer.datasets.step_sana_hf_dataset][INFO] - Loading cached offline split 'validation_unique' from 1 parquet shards +[2026-04-06 16:58:25,647][trainer.datasets.step_sana_hf_dataset][INFO] - Loaded 500 examples from validation_unique dataset +[2026-04-06 16:58:25,647][trainer.datasets.step_sana_hf_dataset][INFO] - Keeping only examples with label in validation_unique split +[2026-04-06 16:58:25,924][trainer.datasets.step_sana_hf_dataset][INFO] - Kept 425 examples from validation_unique dataset +[2026-04-06 16:58:25,925][trainer.datasets.step_sana_hf_dataset][INFO] - Loaded 425 examples from validation_unique dataset +[2026-04-06 16:58:26,834][trainer.datasets.step_sana_hf_dataset][INFO] - Using step-aware datasets +[2026-04-06 16:58:26,834][trainer.datasets.step_sana_hf_dataset][INFO] - Loading test_unique dataset +[2026-04-06 16:58:26,834][trainer.datasets.step_sana_hf_dataset][INFO] - Batch size is 4 +[2026-04-06 16:58:26,835][trainer.datasets.step_sana_hf_dataset][INFO] - Loading cached offline split 'test_unique' from 1 parquet shards +[2026-04-06 16:58:26,843][trainer.datasets.step_sana_hf_dataset][INFO] - Loaded 500 examples from test_unique dataset +[2026-04-06 16:58:26,843][trainer.datasets.step_sana_hf_dataset][INFO] - Keeping only examples with label in test_unique split +[2026-04-06 16:58:26,986][trainer.datasets.step_sana_hf_dataset][INFO] - Kept 432 examples from test_unique dataset +[2026-04-06 16:58:26,987][trainer.datasets.step_sana_hf_dataset][INFO] - Loaded 432 examples from test_unique dataset +[2026-04-06 16:58:31,422][trainer.accelerators.base_accelerator][INFO] - num_update_steps_per_epoch = 44269 +[2026-04-06 16:58:31,423][trainer.accelerators.base_accelerator][INFO] - num_batches = 44269 +[2026-04-06 16:58:31,423][trainer.accelerators.base_accelerator][INFO] - num_epochs = 1 +[2026-04-06 16:58:31,439][trainer.accelerators.base_accelerator][INFO] - Initializing trackers +[2026-04-06 16:58:31,439][trainer.accelerators.base_accelerator][INFO] - Training config: +[2026-04-06 16:58:31,497][trainer.accelerators.base_accelerator][INFO] - nvidia-smi stats: {'gpu_0_mem_used_gb': 7.3818359375} +[2026-04-06 16:58:31,498][trainer.accelerators.base_accelerator][INFO] - ***** Running training ***** +[2026-04-06 16:58:31,498][trainer.accelerators.base_accelerator][INFO] - Instantaneous batch size per device = 4 +[2026-04-06 16:58:31,498][trainer.accelerators.base_accelerator][INFO] - Total train batch size (w. parallel, distributed & accumulation) = 4 +[2026-04-06 16:58:31,499][trainer.accelerators.base_accelerator][INFO] - Gradient Accumulation steps = 1 +[2026-04-06 16:58:31,499][trainer.accelerators.base_accelerator][INFO] - Total warmup steps = 1000 +[2026-04-06 16:58:31,499][trainer.accelerators.base_accelerator][INFO] - Total training steps = 8000 +[2026-04-06 16:58:31,499][trainer.accelerators.base_accelerator][INFO] - Total epochs = 1 +[2026-04-06 16:58:31,499][trainer.accelerators.base_accelerator][INFO] - Steps per epoch = 44269 +[2026-04-06 16:58:31,499][trainer.accelerators.base_accelerator][INFO] - Update steps per epoch = 44269 +[2026-04-06 16:58:31,500][trainer.accelerators.base_accelerator][INFO] - Total optimization steps = 8000 +[2026-04-06 16:58:31,500][trainer.accelerators.base_accelerator][INFO] - Mixed precision = bf16 +[2026-04-06 16:58:31,500][trainer.accelerators.base_accelerator][INFO] - World size = 1 +[2026-04-06 16:58:31,501][__main__][INFO] - task: StepSanaTask +[2026-04-06 16:58:31,501][__main__][INFO] - model: SanaPreferenceModel +[2026-04-06 16:58:31,510][__main__][INFO] - num. model params: 3522M +[2026-04-06 16:58:31,518][__main__][INFO] - num. model trainable params: 3210M +[2026-04-06 16:58:31,518][__main__][INFO] - criterion: StepSanaCLIPCriterion +[2026-04-06 16:58:31,518][__main__][INFO] - num. train examples: 177076 +[2026-04-06 16:58:31,518][__main__][INFO] - num. valid examples: 425 +[2026-04-06 16:58:31,519][__main__][INFO] - num. test examples: 432 +[2026-04-06 16:58:31,542][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.284856796264648} +[2026-04-06 16:58:31,543][__main__][INFO] - ========== TRAIN LOOP START (eval_on_start=False, validate_steps=100, progress_log_interval=50) ========== +[2026-04-06 16:58:36,318][trainer.accelerators.base_accelerator][INFO] - Training progress: step=1/8000 (0.01%), epoch=0, lr=0.0, speed=0.208 step/s, elapsed=00:04, eta=10:42:17 +[2026-04-06 16:59:12,855][trainer.accelerators.base_accelerator][INFO] - Training progress: step=50/8000 (0.62%), epoch=0, lr=2.5e-06, speed=1.209 step/s, elapsed=00:41, eta=01:49:35 +[2026-04-06 16:59:50,213][trainer.accelerators.base_accelerator][INFO] - Training progress: step=100/8000 (1.25%), epoch=0, lr=5e-06, speed=1.270 step/s, elapsed=01:18, eta=01:43:38 +[2026-04-06 16:59:50,278][__main__][INFO] - ========== EVAL START (periodic@gstep=100) ========== +[2026-04-06 16:59:50,278][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-06 16:59:50,279][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-06 17:00:37,000][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.284856796264648, 'accuracy': 0.508235294117647, 'num_samples': 425} +[2026-04-06 17:00:37,000][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-06 17:00:37,000][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-06 17:01:22,693][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.284856796264648, 'accuracy': 0.508235294117647, 'num_samples': 425, 'test_unique_accuracy': 0.49537037037037035, 'test_unique_num_samples': 432} +[2026-04-06 17:01:22,693][__main__][INFO] - ========== EVAL END (periodic@gstep=100) ========== +[2026-04-06 17:01:22,693][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.284689903259277, 'accuracy': 0.508235294117647, 'num_samples': 425, 'test_unique_accuracy': 0.49537037037037035, 'test_unique_num_samples': 432} +[2026-04-06 17:01:22,696][trainer.accelerators.base_accelerator][INFO] - Not cleaning up checkpoints as only 0 checkpoints found +[2026-04-06 17:01:22,696][trainer.accelerators.base_accelerator][INFO] - Saving checkpoint to logs/lrm/reward_model/step_sana_sana_sprint_0_6b_1024_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep100 +[2026-04-06 17:01:22,697][accelerate.accelerator][INFO] - Saving current state to logs/lrm/reward_model/step_sana_sana_sprint_0_6b_1024_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep100 +[2026-04-06 17:01:43,398][accelerate.checkpointing][INFO] - Model weights saved in logs/lrm/reward_model/step_sana_sana_sprint_0_6b_1024_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep100/model.safetensors +[2026-04-06 17:02:19,505][accelerate.checkpointing][INFO] - Optimizer state saved in logs/lrm/reward_model/step_sana_sana_sprint_0_6b_1024_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep100/optimizer.bin +[2026-04-06 17:02:19,566][accelerate.checkpointing][INFO] - Scheduler state saved in logs/lrm/reward_model/step_sana_sana_sprint_0_6b_1024_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep100/scheduler.bin +[2026-04-06 17:02:19,566][accelerate.checkpointing][INFO] - Sampler state for dataloader 0 saved in logs/lrm/reward_model/step_sana_sana_sprint_0_6b_1024_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep100/sampler.bin +[2026-04-06 17:02:19,566][accelerate.checkpointing][INFO] - Sampler state for dataloader 1 saved in logs/lrm/reward_model/step_sana_sana_sprint_0_6b_1024_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep100/sampler_1.bin +[2026-04-06 17:02:19,567][accelerate.checkpointing][INFO] - Sampler state for dataloader 2 saved in logs/lrm/reward_model/step_sana_sana_sprint_0_6b_1024_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep100/sampler_2.bin +[2026-04-06 17:02:19,575][accelerate.checkpointing][INFO] - Random states saved in logs/lrm/reward_model/step_sana_sana_sprint_0_6b_1024_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep100/random_states_0.pkl +[2026-04-06 17:02:19,596][trainer.accelerators.base_accelerator][INFO] - Saved checkpoint to logs/lrm/reward_model/step_sana_sana_sprint_0_6b_1024_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep100 +[2026-04-06 17:02:57,514][trainer.accelerators.base_accelerator][INFO] - Training progress: step=150/8000 (1.88%), epoch=0, lr=7.5e-06, speed=0.564 step/s, elapsed=04:26, eta=03:52:01 +[2026-04-06 17:03:35,054][trainer.accelerators.base_accelerator][INFO] - Training progress: step=200/8000 (2.50%), epoch=0, lr=1e-05, speed=0.659 step/s, elapsed=05:03, eta=03:17:18 +[2026-04-06 17:03:35,112][__main__][INFO] - ========== EVAL START (periodic@gstep=200) ========== +[2026-04-06 17:03:35,112][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-06 17:03:35,112][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-06 17:04:20,016][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.284689903259277, 'accuracy': 0.52, 'num_samples': 425, 'test_unique_accuracy': 0.49537037037037035, 'test_unique_num_samples': 432} +[2026-04-06 17:04:20,016][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-06 17:04:20,016][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-06 17:05:05,594][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.284689903259277, 'accuracy': 0.52, 'num_samples': 425, 'test_unique_accuracy': 0.4930555555555556, 'test_unique_num_samples': 432} +[2026-04-06 17:05:05,594][__main__][INFO] - ========== EVAL END (periodic@gstep=200) ========== +[2026-04-06 17:05:05,594][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.282672882080078, 'accuracy': 0.52, 'num_samples': 425, 'test_unique_accuracy': 0.4930555555555556, 'test_unique_num_samples': 432} +[2026-04-06 17:05:05,598][trainer.accelerators.base_accelerator][INFO] - Not cleaning up checkpoints as only 1 checkpoints found +[2026-04-06 17:05:05,598][trainer.accelerators.base_accelerator][INFO] - Saving checkpoint to logs/lrm/reward_model/step_sana_sana_sprint_0_6b_1024_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep200 +[2026-04-06 17:05:05,599][accelerate.accelerator][INFO] - Saving current state to logs/lrm/reward_model/step_sana_sana_sprint_0_6b_1024_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep200 +[2026-04-06 17:05:21,617][accelerate.checkpointing][INFO] - Model weights saved in logs/lrm/reward_model/step_sana_sana_sprint_0_6b_1024_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep200/model.safetensors +[2026-04-06 17:05:34,665][accelerate.checkpointing][INFO] - Optimizer state saved in logs/lrm/reward_model/step_sana_sana_sprint_0_6b_1024_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep200/optimizer.bin +[2026-04-06 17:05:34,667][accelerate.checkpointing][INFO] - Scheduler state saved in logs/lrm/reward_model/step_sana_sana_sprint_0_6b_1024_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep200/scheduler.bin +[2026-04-06 17:05:34,667][accelerate.checkpointing][INFO] - Sampler state for dataloader 0 saved in logs/lrm/reward_model/step_sana_sana_sprint_0_6b_1024_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep200/sampler.bin +[2026-04-06 17:05:34,667][accelerate.checkpointing][INFO] - Sampler state for dataloader 1 saved in logs/lrm/reward_model/step_sana_sana_sprint_0_6b_1024_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep200/sampler_1.bin +[2026-04-06 17:05:34,667][accelerate.checkpointing][INFO] - Sampler state for dataloader 2 saved in logs/lrm/reward_model/step_sana_sana_sprint_0_6b_1024_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep200/sampler_2.bin +[2026-04-06 17:05:34,679][accelerate.checkpointing][INFO] - Random states saved in logs/lrm/reward_model/step_sana_sana_sprint_0_6b_1024_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep200/random_states_0.pkl +[2026-04-06 17:05:34,713][trainer.accelerators.base_accelerator][INFO] - Saved checkpoint to logs/lrm/reward_model/step_sana_sana_sprint_0_6b_1024_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep200 +[2026-04-06 17:06:12,251][trainer.accelerators.base_accelerator][INFO] - Training progress: step=250/8000 (3.12%), epoch=0, lr=1.25e-05, speed=0.543 step/s, elapsed=07:40, eta=03:58:03 +[2026-04-06 17:06:49,741][trainer.accelerators.base_accelerator][INFO] - Training progress: step=300/8000 (3.75%), epoch=0, lr=1.5e-05, speed=0.602 step/s, elapsed=08:18, eta=03:33:08 +[2026-04-06 17:06:49,803][__main__][INFO] - ========== EVAL START (periodic@gstep=300) ========== +[2026-04-06 17:06:49,803][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-06 17:06:49,803][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-06 17:07:34,748][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.282672882080078, 'accuracy': 0.508235294117647, 'num_samples': 425, 'test_unique_accuracy': 0.4930555555555556, 'test_unique_num_samples': 432} +[2026-04-06 17:07:34,748][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-06 17:07:34,748][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-06 17:08:20,355][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.282672882080078, 'accuracy': 0.508235294117647, 'num_samples': 425, 'test_unique_accuracy': 0.49537037037037035, 'test_unique_num_samples': 432} +[2026-04-06 17:08:20,355][__main__][INFO] - ========== EVAL END (periodic@gstep=300) ========== +[2026-04-06 17:08:20,356][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.27853012084961, 'accuracy': 0.508235294117647, 'num_samples': 425, 'test_unique_accuracy': 0.49537037037037035, 'test_unique_num_samples': 432} +[2026-04-06 17:08:20,359][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.508235294117647 is not better than 0.52 of logs/lrm/reward_model/step_sana_sana_sprint_0_6b_1024_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep200, skipping checkpoint +[2026-04-06 17:08:58,122][trainer.accelerators.base_accelerator][INFO] - Training progress: step=350/8000 (4.38%), epoch=0, lr=1.75e-05, speed=0.559 step/s, elapsed=10:26, eta=03:48:16 +[2026-04-06 17:09:35,589][trainer.accelerators.base_accelerator][INFO] - Training progress: step=400/8000 (5.00%), epoch=0, lr=2e-05, speed=0.602 step/s, elapsed=11:04, eta=03:30:17 +[2026-04-06 17:09:35,648][__main__][INFO] - ========== EVAL START (periodic@gstep=400) ========== +[2026-04-06 17:09:35,648][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-06 17:09:35,648][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-06 17:10:20,583][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.27853012084961, 'accuracy': 0.46352941176470586, 'num_samples': 425, 'test_unique_accuracy': 0.49537037037037035, 'test_unique_num_samples': 432} +[2026-04-06 17:10:20,583][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-06 17:10:20,583][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-06 17:11:06,232][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.27853012084961, 'accuracy': 0.46352941176470586, 'num_samples': 425, 'test_unique_accuracy': 0.49537037037037035, 'test_unique_num_samples': 432} +[2026-04-06 17:11:06,232][__main__][INFO] - ========== EVAL END (periodic@gstep=400) ========== +[2026-04-06 17:11:06,232][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.275421142578125, 'accuracy': 0.46352941176470586, 'num_samples': 425, 'test_unique_accuracy': 0.49537037037037035, 'test_unique_num_samples': 432} +[2026-04-06 17:11:06,234][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.46352941176470586 is not better than 0.508235294117647 of logs/lrm/reward_model/step_sana_sana_sprint_0_6b_1024_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep100, skipping checkpoint +[2026-04-06 17:11:43,810][trainer.accelerators.base_accelerator][INFO] - Training progress: step=450/8000 (5.62%), epoch=0, lr=2.25e-05, speed=0.568 step/s, elapsed=13:12, eta=03:41:33 +[2026-04-06 17:12:21,280][trainer.accelerators.base_accelerator][INFO] - Training progress: step=500/8000 (6.25%), epoch=0, lr=2.5e-05, speed=0.603 step/s, elapsed=13:49, eta=03:27:26 +[2026-04-06 17:12:21,340][__main__][INFO] - ========== EVAL START (periodic@gstep=500) ========== +[2026-04-06 17:12:21,340][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-06 17:12:21,340][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-06 17:13:06,294][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.275421142578125, 'accuracy': 0.5270588235294118, 'num_samples': 425, 'test_unique_accuracy': 0.49537037037037035, 'test_unique_num_samples': 432} +[2026-04-06 17:13:06,294][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-06 17:13:06,294][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-06 17:13:51,957][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.275421142578125, 'accuracy': 0.5270588235294118, 'num_samples': 425, 'test_unique_accuracy': 0.5277777777777778, 'test_unique_num_samples': 432} +[2026-04-06 17:13:51,957][__main__][INFO] - ========== EVAL END (periodic@gstep=500) ========== +[2026-04-06 17:13:51,957][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.269028663635254, 'accuracy': 0.5270588235294118, 'num_samples': 425, 'test_unique_accuracy': 0.5277777777777778, 'test_unique_num_samples': 432} +[2026-04-06 17:13:51,960][trainer.accelerators.base_accelerator][INFO] - Found 2 checkpoints in logs/lrm/reward_model/step_sana_sana_sprint_0_6b_1024_variable-t_lr1e-5_step-8000_filter2_time951 +[2026-04-06 17:13:51,962][trainer.accelerators.base_accelerator][INFO] - Saving checkpoint to logs/lrm/reward_model/step_sana_sana_sprint_0_6b_1024_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep500 +[2026-04-06 17:13:51,963][accelerate.accelerator][INFO] - Saving current state to logs/lrm/reward_model/step_sana_sana_sprint_0_6b_1024_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep500 +[2026-04-06 17:14:04,921][accelerate.checkpointing][INFO] - Model weights saved in logs/lrm/reward_model/step_sana_sana_sprint_0_6b_1024_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep500/model.safetensors +[2026-04-06 17:14:25,037][accelerate.checkpointing][INFO] - Optimizer state saved in logs/lrm/reward_model/step_sana_sana_sprint_0_6b_1024_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep500/optimizer.bin +[2026-04-06 17:14:25,062][accelerate.checkpointing][INFO] - Scheduler state saved in logs/lrm/reward_model/step_sana_sana_sprint_0_6b_1024_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep500/scheduler.bin +[2026-04-06 17:14:25,063][accelerate.checkpointing][INFO] - Sampler state for dataloader 0 saved in logs/lrm/reward_model/step_sana_sana_sprint_0_6b_1024_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep500/sampler.bin +[2026-04-06 17:14:25,063][accelerate.checkpointing][INFO] - Sampler state for dataloader 1 saved in logs/lrm/reward_model/step_sana_sana_sprint_0_6b_1024_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep500/sampler_1.bin +[2026-04-06 17:14:25,064][accelerate.checkpointing][INFO] - Sampler state for dataloader 2 saved in logs/lrm/reward_model/step_sana_sana_sprint_0_6b_1024_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep500/sampler_2.bin +[2026-04-06 17:14:25,097][accelerate.checkpointing][INFO] - Random states saved in logs/lrm/reward_model/step_sana_sana_sprint_0_6b_1024_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep500/random_states_0.pkl +[2026-04-06 17:14:25,151][trainer.accelerators.base_accelerator][INFO] - Saved checkpoint to logs/lrm/reward_model/step_sana_sana_sprint_0_6b_1024_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep500 +[2026-04-06 17:15:04,680][trainer.accelerators.base_accelerator][INFO] - Training progress: step=550/8000 (6.88%), epoch=0, lr=2.7500000000000004e-05, speed=0.554 step/s, elapsed=16:33, eta=03:44:13 +[2026-04-06 17:15:42,014][trainer.accelerators.base_accelerator][INFO] - Training progress: step=600/8000 (7.50%), epoch=0, lr=3e-05, speed=0.582 step/s, elapsed=17:10, eta=03:31:49 +[2026-04-06 17:15:42,075][__main__][INFO] - ========== EVAL START (periodic@gstep=600) ========== +[2026-04-06 17:15:42,075][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-06 17:15:42,075][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-06 17:16:27,854][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.269028663635254, 'accuracy': 0.4470588235294118, 'num_samples': 425, 'test_unique_accuracy': 0.5277777777777778, 'test_unique_num_samples': 432} +[2026-04-06 17:16:27,855][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-06 17:16:27,855][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-06 17:17:13,523][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.269028663635254, 'accuracy': 0.4470588235294118, 'num_samples': 425, 'test_unique_accuracy': 0.5324074074074074, 'test_unique_num_samples': 432} +[2026-04-06 17:17:13,524][__main__][INFO] - ========== EVAL END (periodic@gstep=600) ========== +[2026-04-06 17:17:13,524][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.265201568603516, 'accuracy': 0.4470588235294118, 'num_samples': 425, 'test_unique_accuracy': 0.5324074074074074, 'test_unique_num_samples': 432} +[2026-04-06 17:17:13,526][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.4470588235294118 is not better than 0.508235294117647 of logs/lrm/reward_model/step_sana_sana_sprint_0_6b_1024_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep100, skipping checkpoint +[2026-04-06 17:17:51,053][trainer.accelerators.base_accelerator][INFO] - Training progress: step=650/8000 (8.12%), epoch=0, lr=3.2500000000000004e-05, speed=0.561 step/s, elapsed=19:19, eta=03:38:31 +[2026-04-06 17:18:28,459][trainer.accelerators.base_accelerator][INFO] - Training progress: step=700/8000 (8.75%), epoch=0, lr=3.5e-05, speed=0.585 step/s, elapsed=19:56, eta=03:28:02 +[2026-04-06 17:18:28,526][__main__][INFO] - ========== EVAL START (periodic@gstep=700) ========== +[2026-04-06 17:18:28,527][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-06 17:18:28,527][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-06 17:19:13,857][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.265201568603516, 'accuracy': 0.4752941176470588, 'num_samples': 425, 'test_unique_accuracy': 0.5324074074074074, 'test_unique_num_samples': 432} +[2026-04-06 17:19:13,857][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-06 17:19:13,857][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-06 17:19:59,561][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.265201568603516, 'accuracy': 0.4752941176470588, 'num_samples': 425, 'test_unique_accuracy': 0.4722222222222222, 'test_unique_num_samples': 432} +[2026-04-06 17:19:59,561][__main__][INFO] - ========== EVAL END (periodic@gstep=700) ========== +[2026-04-06 17:19:59,561][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.259349822998047, 'accuracy': 0.4752941176470588, 'num_samples': 425, 'test_unique_accuracy': 0.4722222222222222, 'test_unique_num_samples': 432} +[2026-04-06 17:19:59,563][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.4752941176470588 is not better than 0.508235294117647 of logs/lrm/reward_model/step_sana_sana_sprint_0_6b_1024_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep100, skipping checkpoint +[2026-04-06 17:20:36,883][trainer.accelerators.base_accelerator][INFO] - Training progress: step=750/8000 (9.38%), epoch=0, lr=3.7500000000000003e-05, speed=0.566 step/s, elapsed=22:05, eta=03:33:32 +[2026-04-06 17:21:14,958][trainer.accelerators.base_accelerator][INFO] - Training progress: step=800/8000 (10.00%), epoch=0, lr=4e-05, speed=0.587 step/s, elapsed=22:43, eta=03:24:31 +[2026-04-06 17:21:15,021][__main__][INFO] - ========== EVAL START (periodic@gstep=800) ========== +[2026-04-06 17:21:15,021][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-06 17:21:15,021][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-06 17:22:00,467][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.259349822998047, 'accuracy': 0.4988235294117647, 'num_samples': 425, 'test_unique_accuracy': 0.4722222222222222, 'test_unique_num_samples': 432} +[2026-04-06 17:22:00,467][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-06 17:22:00,467][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-06 17:22:46,174][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.259349822998047, 'accuracy': 0.4988235294117647, 'num_samples': 425, 'test_unique_accuracy': 0.4976851851851852, 'test_unique_num_samples': 432} +[2026-04-06 17:22:46,174][__main__][INFO] - ========== EVAL END (periodic@gstep=800) ========== +[2026-04-06 17:22:46,174][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.244266510009766, 'accuracy': 0.4988235294117647, 'num_samples': 425, 'test_unique_accuracy': 0.4976851851851852, 'test_unique_num_samples': 432} +[2026-04-06 17:22:46,176][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.4988235294117647 is not better than 0.508235294117647 of logs/lrm/reward_model/step_sana_sana_sprint_0_6b_1024_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep100, skipping checkpoint +[2026-04-06 17:23:23,657][trainer.accelerators.base_accelerator][INFO] - Training progress: step=850/8000 (10.62%), epoch=0, lr=4.25e-05, speed=0.570 step/s, elapsed=24:52, eta=03:29:11 +[2026-04-06 17:24:01,075][trainer.accelerators.base_accelerator][INFO] - Training progress: step=900/8000 (11.25%), epoch=0, lr=4.5e-05, speed=0.588 step/s, elapsed=25:29, eta=03:21:06 +[2026-04-06 17:24:01,136][__main__][INFO] - ========== EVAL START (periodic@gstep=900) ========== +[2026-04-06 17:24:01,137][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-06 17:24:01,137][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-06 17:24:46,418][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.244266510009766, 'accuracy': 0.5011764705882353, 'num_samples': 425, 'test_unique_accuracy': 0.4976851851851852, 'test_unique_num_samples': 432} +[2026-04-06 17:24:46,418][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-06 17:24:46,418][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-06 17:25:31,999][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.244266510009766, 'accuracy': 0.5011764705882353, 'num_samples': 425, 'test_unique_accuracy': 0.5023148148148148, 'test_unique_num_samples': 432} +[2026-04-06 17:25:32,001][__main__][INFO] - ========== EVAL END (periodic@gstep=900) ========== +[2026-04-06 17:25:32,001][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.233514785766602, 'accuracy': 0.5011764705882353, 'num_samples': 425, 'test_unique_accuracy': 0.5023148148148148, 'test_unique_num_samples': 432} +[2026-04-06 17:25:32,003][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.5011764705882353 is not better than 0.508235294117647 of logs/lrm/reward_model/step_sana_sana_sprint_0_6b_1024_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep100, skipping checkpoint +[2026-04-06 17:26:09,434][trainer.accelerators.base_accelerator][INFO] - Training progress: step=950/8000 (11.88%), epoch=0, lr=4.75e-05, speed=0.573 step/s, elapsed=27:37, eta=03:25:03 +[2026-04-06 17:26:47,051][trainer.accelerators.base_accelerator][INFO] - Training progress: step=1000/8000 (12.50%), epoch=0, lr=5e-05, speed=0.590 step/s, elapsed=28:15, eta=03:17:48 +[2026-04-06 17:26:47,113][__main__][INFO] - ========== EVAL START (periodic@gstep=1000) ========== +[2026-04-06 17:26:47,114][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-06 17:26:47,114][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-06 17:27:33,032][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.233514785766602, 'accuracy': 0.52, 'num_samples': 425, 'test_unique_accuracy': 0.5023148148148148, 'test_unique_num_samples': 432} +[2026-04-06 17:27:33,033][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-06 17:27:33,033][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-06 17:28:18,791][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.233514785766602, 'accuracy': 0.52, 'num_samples': 425, 'test_unique_accuracy': 0.5671296296296297, 'test_unique_num_samples': 432} +[2026-04-06 17:28:18,792][__main__][INFO] - ========== EVAL END (periodic@gstep=1000) ========== +[2026-04-06 17:28:18,792][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.229741096496582, 'accuracy': 0.52, 'num_samples': 425, 'test_unique_accuracy': 0.5671296296296297, 'test_unique_num_samples': 432} +[2026-04-06 17:28:18,794][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.52 is not better than 0.5270588235294118 of logs/lrm/reward_model/step_sana_sana_sprint_0_6b_1024_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep500, skipping checkpoint +[2026-04-06 17:28:56,263][trainer.accelerators.base_accelerator][INFO] - Training progress: step=1050/8000 (13.12%), epoch=0, lr=5e-05, speed=0.575 step/s, elapsed=30:24, eta=03:21:18 +[2026-04-06 17:29:33,770][trainer.accelerators.base_accelerator][INFO] - Training progress: step=1100/8000 (13.75%), epoch=0, lr=5e-05, speed=0.591 step/s, elapsed=31:02, eta=03:14:41 +[2026-04-06 17:29:33,831][__main__][INFO] - ========== EVAL START (periodic@gstep=1100) ========== +[2026-04-06 17:29:33,831][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-06 17:29:33,832][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-06 17:30:19,176][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.229741096496582, 'accuracy': 0.48, 'num_samples': 425, 'test_unique_accuracy': 0.5671296296296297, 'test_unique_num_samples': 432} +[2026-04-06 17:30:19,177][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-06 17:30:19,177][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-06 17:31:04,788][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.229741096496582, 'accuracy': 0.48, 'num_samples': 425, 'test_unique_accuracy': 0.5046296296296297, 'test_unique_num_samples': 432} +[2026-04-06 17:31:04,788][__main__][INFO] - ========== EVAL END (periodic@gstep=1100) ========== +[2026-04-06 17:31:04,788][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.23116683959961, 'accuracy': 0.48, 'num_samples': 425, 'test_unique_accuracy': 0.5046296296296297, 'test_unique_num_samples': 432} +[2026-04-06 17:31:04,790][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.48 is not better than 0.508235294117647 of logs/lrm/reward_model/step_sana_sana_sprint_0_6b_1024_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep100, skipping checkpoint +[2026-04-06 17:31:42,331][trainer.accelerators.base_accelerator][INFO] - Training progress: step=1150/8000 (14.38%), epoch=0, lr=5e-05, speed=0.578 step/s, elapsed=33:10, eta=03:17:38 +[2026-04-06 17:32:19,971][trainer.accelerators.base_accelerator][INFO] - Training progress: step=1200/8000 (15.00%), epoch=0, lr=5e-05, speed=0.592 step/s, elapsed=33:48, eta=03:11:34 +[2026-04-06 17:32:20,034][__main__][INFO] - ========== EVAL START (periodic@gstep=1200) ========== +[2026-04-06 17:32:20,034][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-06 17:32:20,034][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-06 17:33:05,306][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.23116683959961, 'accuracy': 0.5058823529411764, 'num_samples': 425, 'test_unique_accuracy': 0.5046296296296297, 'test_unique_num_samples': 432} +[2026-04-06 17:33:05,307][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-06 17:33:05,307][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-06 17:33:50,951][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.23116683959961, 'accuracy': 0.5058823529411764, 'num_samples': 425, 'test_unique_accuracy': 0.48148148148148145, 'test_unique_num_samples': 432} +[2026-04-06 17:33:50,951][__main__][INFO] - ========== EVAL END (periodic@gstep=1200) ========== +[2026-04-06 17:33:50,951][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.234842300415039, 'accuracy': 0.5058823529411764, 'num_samples': 425, 'test_unique_accuracy': 0.48148148148148145, 'test_unique_num_samples': 432} +[2026-04-06 17:33:50,953][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.5058823529411764 is not better than 0.508235294117647 of logs/lrm/reward_model/step_sana_sana_sprint_0_6b_1024_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep100, skipping checkpoint +[2026-04-06 17:34:28,618][trainer.accelerators.base_accelerator][INFO] - Training progress: step=1250/8000 (15.62%), epoch=0, lr=5e-05, speed=0.579 step/s, elapsed=35:57, eta=03:14:08 +[2026-04-06 17:35:05,948][trainer.accelerators.base_accelerator][INFO] - Training progress: step=1300/8000 (16.25%), epoch=0, lr=5e-05, speed=0.592 step/s, elapsed=36:34, eta=03:08:29 +[2026-04-06 17:35:06,012][__main__][INFO] - ========== EVAL START (periodic@gstep=1300) ========== +[2026-04-06 17:35:06,012][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-06 17:35:06,012][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-06 17:35:51,336][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.234842300415039, 'accuracy': 0.5105882352941177, 'num_samples': 425, 'test_unique_accuracy': 0.48148148148148145, 'test_unique_num_samples': 432} +[2026-04-06 17:35:51,498][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-06 17:35:51,498][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-06 17:36:37,215][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.234842300415039, 'accuracy': 0.5105882352941177, 'num_samples': 425, 'test_unique_accuracy': 0.5023148148148148, 'test_unique_num_samples': 432} +[2026-04-06 17:36:37,951][__main__][INFO] - ========== EVAL END (periodic@gstep=1300) ========== +[2026-04-06 17:36:37,951][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.22242259979248, 'accuracy': 0.5105882352941177, 'num_samples': 425, 'test_unique_accuracy': 0.5023148148148148, 'test_unique_num_samples': 432} +[2026-04-06 17:36:37,957][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.5105882352941177 is not better than 0.52 of logs/lrm/reward_model/step_sana_sana_sprint_0_6b_1024_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep200, skipping checkpoint +[2026-04-06 17:37:15,289][trainer.accelerators.base_accelerator][INFO] - Training progress: step=1350/8000 (16.88%), epoch=0, lr=5e-05, speed=0.581 step/s, elapsed=38:43, eta=03:10:46 +[2026-04-06 17:37:52,596][trainer.accelerators.base_accelerator][INFO] - Training progress: step=1400/8000 (17.50%), epoch=0, lr=5e-05, speed=0.593 step/s, elapsed=39:21, eta=03:05:30 +[2026-04-06 17:37:52,657][__main__][INFO] - ========== EVAL START (periodic@gstep=1400) ========== +[2026-04-06 17:37:52,658][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-06 17:37:52,658][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-06 17:38:37,956][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.22242259979248, 'accuracy': 0.5152941176470588, 'num_samples': 425, 'test_unique_accuracy': 0.5023148148148148, 'test_unique_num_samples': 432} +[2026-04-06 17:38:38,325][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-06 17:38:38,325][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-06 17:39:24,029][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.22242259979248, 'accuracy': 0.5152941176470588, 'num_samples': 425, 'test_unique_accuracy': 0.5069444444444444, 'test_unique_num_samples': 432} +[2026-04-06 17:39:24,030][__main__][INFO] - ========== EVAL END (periodic@gstep=1400) ========== +[2026-04-06 17:39:24,031][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.22171688079834, 'accuracy': 0.5152941176470588, 'num_samples': 425, 'test_unique_accuracy': 0.5069444444444444, 'test_unique_num_samples': 432} +[2026-04-06 17:39:24,033][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.5152941176470588 is not better than 0.52 of logs/lrm/reward_model/step_sana_sana_sprint_0_6b_1024_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep200, skipping checkpoint +[2026-04-06 17:40:01,796][trainer.accelerators.base_accelerator][INFO] - Training progress: step=1450/8000 (18.12%), epoch=0, lr=5e-05, speed=0.582 step/s, elapsed=41:30, eta=03:07:29 +[2026-04-06 17:40:39,315][trainer.accelerators.base_accelerator][INFO] - Training progress: step=1500/8000 (18.75%), epoch=0, lr=5e-05, speed=0.593 step/s, elapsed=42:07, eta=03:02:33 +[2026-04-06 17:40:39,397][__main__][INFO] - ========== EVAL START (periodic@gstep=1500) ========== +[2026-04-06 17:40:39,397][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-06 17:40:39,398][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-06 17:41:24,750][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.22171688079834, 'accuracy': 0.49411764705882355, 'num_samples': 425, 'test_unique_accuracy': 0.5069444444444444, 'test_unique_num_samples': 432} +[2026-04-06 17:41:24,752][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-06 17:41:24,752][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-06 17:42:10,356][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.22171688079834, 'accuracy': 0.49411764705882355, 'num_samples': 425, 'test_unique_accuracy': 0.4861111111111111, 'test_unique_num_samples': 432} +[2026-04-06 17:42:10,358][__main__][INFO] - ========== EVAL END (periodic@gstep=1500) ========== +[2026-04-06 17:42:10,358][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.223368644714355, 'accuracy': 0.49411764705882355, 'num_samples': 425, 'test_unique_accuracy': 0.4861111111111111, 'test_unique_num_samples': 432} +[2026-04-06 17:42:10,359][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.49411764705882355 is not better than 0.508235294117647 of logs/lrm/reward_model/step_sana_sana_sprint_0_6b_1024_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep100, skipping checkpoint +[2026-04-06 17:42:47,662][trainer.accelerators.base_accelerator][INFO] - Training progress: step=1550/8000 (19.38%), epoch=0, lr=5e-05, speed=0.584 step/s, elapsed=44:16, eta=03:04:13 +[2026-04-06 17:43:25,020][trainer.accelerators.base_accelerator][INFO] - Training progress: step=1600/8000 (20.00%), epoch=0, lr=5e-05, speed=0.594 step/s, elapsed=44:53, eta=02:59:34 +[2026-04-06 17:43:25,080][__main__][INFO] - ========== EVAL START (periodic@gstep=1600) ========== +[2026-04-06 17:43:25,080][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-06 17:43:25,080][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-06 17:44:10,324][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.223368644714355, 'accuracy': 0.548235294117647, 'num_samples': 425, 'test_unique_accuracy': 0.4861111111111111, 'test_unique_num_samples': 432} +[2026-04-06 17:44:10,325][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-06 17:44:10,325][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-06 17:44:55,962][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.223368644714355, 'accuracy': 0.548235294117647, 'num_samples': 425, 'test_unique_accuracy': 0.4791666666666667, 'test_unique_num_samples': 432} +[2026-04-06 17:44:55,964][__main__][INFO] - ========== EVAL END (periodic@gstep=1600) ========== +[2026-04-06 17:44:55,964][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.22330093383789, 'accuracy': 0.548235294117647, 'num_samples': 425, 'test_unique_accuracy': 0.4791666666666667, 'test_unique_num_samples': 432} +[2026-04-06 17:44:55,967][trainer.accelerators.base_accelerator][INFO] - Found 3 checkpoints in logs/lrm/reward_model/step_sana_sana_sprint_0_6b_1024_variable-t_lr1e-5_step-8000_filter2_time951 +[2026-04-06 17:44:55,969][trainer.accelerators.base_accelerator][INFO] - Deleting checkpoint logs/lrm/reward_model/step_sana_sana_sprint_0_6b_1024_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep100 +[2026-04-06 17:44:55,975][trainer.accelerators.base_accelerator][INFO] - Saving checkpoint to logs/lrm/reward_model/step_sana_sana_sprint_0_6b_1024_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep1600 +[2026-04-06 17:44:55,976][accelerate.accelerator][INFO] - Saving current state to logs/lrm/reward_model/step_sana_sana_sprint_0_6b_1024_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep1600 +[2026-04-06 17:45:22,653][accelerate.checkpointing][INFO] - Model weights saved in logs/lrm/reward_model/step_sana_sana_sprint_0_6b_1024_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep1600/model.safetensors +[2026-04-06 17:45:57,398][accelerate.checkpointing][INFO] - Optimizer state saved in logs/lrm/reward_model/step_sana_sana_sprint_0_6b_1024_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep1600/optimizer.bin +[2026-04-06 17:45:57,402][accelerate.checkpointing][INFO] - Scheduler state saved in logs/lrm/reward_model/step_sana_sana_sprint_0_6b_1024_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep1600/scheduler.bin +[2026-04-06 17:45:57,402][accelerate.checkpointing][INFO] - Sampler state for dataloader 0 saved in logs/lrm/reward_model/step_sana_sana_sprint_0_6b_1024_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep1600/sampler.bin +[2026-04-06 17:45:57,402][accelerate.checkpointing][INFO] - Sampler state for dataloader 1 saved in logs/lrm/reward_model/step_sana_sana_sprint_0_6b_1024_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep1600/sampler_1.bin +[2026-04-06 17:45:57,402][accelerate.checkpointing][INFO] - Sampler state for dataloader 2 saved in logs/lrm/reward_model/step_sana_sana_sprint_0_6b_1024_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep1600/sampler_2.bin +[2026-04-06 17:45:57,405][accelerate.checkpointing][INFO] - Random states saved in logs/lrm/reward_model/step_sana_sana_sprint_0_6b_1024_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep1600/random_states_0.pkl +[2026-04-06 17:45:57,428][trainer.accelerators.base_accelerator][INFO] - Saved checkpoint to logs/lrm/reward_model/step_sana_sana_sprint_0_6b_1024_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep1600 +[2026-04-06 17:46:34,844][trainer.accelerators.base_accelerator][INFO] - Training progress: step=1650/8000 (20.62%), epoch=0, lr=5e-05, speed=0.572 step/s, elapsed=48:03, eta=03:04:56 +[2026-04-06 17:47:12,691][trainer.accelerators.base_accelerator][INFO] - Training progress: step=1700/8000 (21.25%), epoch=0, lr=5e-05, speed=0.582 step/s, elapsed=48:41, eta=03:00:25 +[2026-04-06 17:47:12,752][__main__][INFO] - ========== EVAL START (periodic@gstep=1700) ========== +[2026-04-06 17:47:12,752][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-06 17:47:12,752][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-06 17:47:57,782][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.22330093383789, 'accuracy': 0.48, 'num_samples': 425, 'test_unique_accuracy': 0.4791666666666667, 'test_unique_num_samples': 432} +[2026-04-06 17:47:57,783][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-06 17:47:57,783][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-06 17:48:43,513][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.22330093383789, 'accuracy': 0.48, 'num_samples': 425, 'test_unique_accuracy': 0.5046296296296297, 'test_unique_num_samples': 432} +[2026-04-06 17:48:43,513][__main__][INFO] - ========== EVAL END (periodic@gstep=1700) ========== +[2026-04-06 17:48:43,513][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.225396156311035, 'accuracy': 0.48, 'num_samples': 425, 'test_unique_accuracy': 0.5046296296296297, 'test_unique_num_samples': 432} +[2026-04-06 17:48:43,516][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.48 is not better than 0.548235294117647 of logs/lrm/reward_model/step_sana_sana_sprint_0_6b_1024_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep1600, skipping checkpoint +[2026-04-06 17:49:31,434][trainer.accelerators.base_accelerator][INFO] - Training progress: step=1750/8000 (21.88%), epoch=0, lr=5e-05, speed=0.572 step/s, elapsed=50:59, eta=03:02:08 +[2026-04-06 17:50:38,168][trainer.accelerators.base_accelerator][INFO] - Training progress: step=1800/8000 (22.50%), epoch=0, lr=5e-05, speed=0.576 step/s, elapsed=52:06, eta=02:59:29 +[2026-04-06 17:50:38,272][__main__][INFO] - ========== EVAL START (periodic@gstep=1800) ========== +[2026-04-06 17:50:38,272][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-06 17:50:38,272][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-06 17:52:08,652][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.225396156311035, 'accuracy': 0.5035294117647059, 'num_samples': 425, 'test_unique_accuracy': 0.5046296296296297, 'test_unique_num_samples': 432} +[2026-04-06 17:52:08,652][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-06 17:52:08,652][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-06 17:53:39,317][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.225396156311035, 'accuracy': 0.5035294117647059, 'num_samples': 425, 'test_unique_accuracy': 0.5300925925925926, 'test_unique_num_samples': 432} +[2026-04-06 17:53:39,317][__main__][INFO] - ========== EVAL END (periodic@gstep=1800) ========== +[2026-04-06 17:53:39,317][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.22375202178955, 'accuracy': 0.5035294117647059, 'num_samples': 425, 'test_unique_accuracy': 0.5300925925925926, 'test_unique_num_samples': 432} +[2026-04-06 17:53:39,319][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.5035294117647059 is not better than 0.548235294117647 of logs/lrm/reward_model/step_sana_sana_sprint_0_6b_1024_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep1600, skipping checkpoint +[2026-04-06 17:54:37,453][trainer.accelerators.base_accelerator][INFO] - Training progress: step=1850/8000 (23.12%), epoch=0, lr=5e-05, speed=0.550 step/s, elapsed=56:05, eta=03:06:29 +[2026-04-06 17:55:15,297][trainer.accelerators.base_accelerator][INFO] - Training progress: step=1900/8000 (23.75%), epoch=0, lr=5e-05, speed=0.558 step/s, elapsed=56:43, eta=03:02:07 +[2026-04-06 17:55:15,365][__main__][INFO] - ========== EVAL START (periodic@gstep=1900) ========== +[2026-04-06 17:55:15,365][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-06 17:55:15,365][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-06 17:56:39,453][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.22375202178955, 'accuracy': 0.48, 'num_samples': 425, 'test_unique_accuracy': 0.5300925925925926, 'test_unique_num_samples': 432} +[2026-04-06 17:56:39,454][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-06 17:56:39,454][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-06 17:58:11,269][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.22375202178955, 'accuracy': 0.48, 'num_samples': 425, 'test_unique_accuracy': 0.5370370370370371, 'test_unique_num_samples': 432} +[2026-04-06 17:58:11,269][__main__][INFO] - ========== EVAL END (periodic@gstep=1900) ========== +[2026-04-06 17:58:11,271][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.222124099731445, 'accuracy': 0.48, 'num_samples': 425, 'test_unique_accuracy': 0.5370370370370371, 'test_unique_num_samples': 432} +[2026-04-06 17:58:11,272][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.48 is not better than 0.548235294117647 of logs/lrm/reward_model/step_sana_sana_sprint_0_6b_1024_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep1600, skipping checkpoint +[2026-04-06 17:59:18,543][trainer.accelerators.base_accelerator][INFO] - Training progress: step=1950/8000 (24.38%), epoch=0, lr=5e-05, speed=0.535 step/s, elapsed=01:00:47, eta=03:08:35 +[2026-04-06 18:00:26,645][trainer.accelerators.base_accelerator][INFO] - Training progress: step=2000/8000 (25.00%), epoch=0, lr=5e-05, speed=0.538 step/s, elapsed=01:01:55, eta=03:05:45 +[2026-04-06 18:00:26,751][__main__][INFO] - ========== EVAL START (periodic@gstep=2000) ========== +[2026-04-06 18:00:26,752][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-06 18:00:26,752][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-06 18:01:19,543][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.222124099731445, 'accuracy': 0.47058823529411764, 'num_samples': 425, 'test_unique_accuracy': 0.5370370370370371, 'test_unique_num_samples': 432} +[2026-04-06 18:01:19,543][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-06 18:01:19,543][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-06 18:02:37,867][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.222124099731445, 'accuracy': 0.47058823529411764, 'num_samples': 425, 'test_unique_accuracy': 0.5046296296296297, 'test_unique_num_samples': 432} +[2026-04-06 18:02:37,867][__main__][INFO] - ========== EVAL END (periodic@gstep=2000) ========== +[2026-04-06 18:02:37,869][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.225687980651855, 'accuracy': 0.47058823529411764, 'num_samples': 425, 'test_unique_accuracy': 0.5046296296296297, 'test_unique_num_samples': 432} +[2026-04-06 18:02:37,871][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.47058823529411764 is not better than 0.548235294117647 of logs/lrm/reward_model/step_sana_sana_sprint_0_6b_1024_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep1600, skipping checkpoint +[2026-04-06 18:03:44,868][trainer.accelerators.base_accelerator][INFO] - Training progress: step=2050/8000 (25.62%), epoch=0, lr=5e-05, speed=0.524 step/s, elapsed=01:05:13, eta=03:09:18 +[2026-04-06 18:04:51,976][trainer.accelerators.base_accelerator][INFO] - Training progress: step=2100/8000 (26.25%), epoch=0, lr=5e-05, speed=0.528 step/s, elapsed=01:06:20, eta=03:06:23 +[2026-04-06 18:04:52,080][__main__][INFO] - ========== EVAL START (periodic@gstep=2100) ========== +[2026-04-06 18:04:52,081][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-06 18:04:52,081][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-06 18:06:23,068][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.225687980651855, 'accuracy': 0.4823529411764706, 'num_samples': 425, 'test_unique_accuracy': 0.5046296296296297, 'test_unique_num_samples': 432} +[2026-04-06 18:06:23,068][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-06 18:06:23,068][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-06 18:07:25,623][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.225687980651855, 'accuracy': 0.4823529411764706, 'num_samples': 425, 'test_unique_accuracy': 0.5185185185185185, 'test_unique_num_samples': 432} +[2026-04-06 18:07:25,623][__main__][INFO] - ========== EVAL END (periodic@gstep=2100) ========== +[2026-04-06 18:07:25,623][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.227452278137207, 'accuracy': 0.4823529411764706, 'num_samples': 425, 'test_unique_accuracy': 0.5185185185185185, 'test_unique_num_samples': 432} +[2026-04-06 18:07:25,625][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.4823529411764706 is not better than 0.548235294117647 of logs/lrm/reward_model/step_sana_sana_sprint_0_6b_1024_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep1600, skipping checkpoint +[2026-04-06 18:08:24,326][trainer.accelerators.base_accelerator][INFO] - Training progress: step=2150/8000 (26.88%), epoch=0, lr=5e-05, speed=0.513 step/s, elapsed=01:09:52, eta=03:10:08 +[2026-04-06 18:09:32,522][trainer.accelerators.base_accelerator][INFO] - Training progress: step=2200/8000 (27.50%), epoch=0, lr=5e-05, speed=0.516 step/s, elapsed=01:11:01, eta=03:07:13 +[2026-04-06 18:09:32,621][__main__][INFO] - ========== EVAL START (periodic@gstep=2200) ========== +[2026-04-06 18:09:32,621][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-06 18:09:32,621][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-06 18:11:06,353][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.227452278137207, 'accuracy': 0.46352941176470586, 'num_samples': 425, 'test_unique_accuracy': 0.5185185185185185, 'test_unique_num_samples': 432} +[2026-04-06 18:11:06,353][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-06 18:11:06,353][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-06 18:12:41,037][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.227452278137207, 'accuracy': 0.46352941176470586, 'num_samples': 425, 'test_unique_accuracy': 0.4675925925925926, 'test_unique_num_samples': 432} +[2026-04-06 18:12:41,037][__main__][INFO] - ========== EVAL END (periodic@gstep=2200) ========== +[2026-04-06 18:12:41,038][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.232205390930176, 'accuracy': 0.46352941176470586, 'num_samples': 425, 'test_unique_accuracy': 0.4675925925925926, 'test_unique_num_samples': 432} +[2026-04-06 18:12:41,040][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.46352941176470586 is not better than 0.548235294117647 of logs/lrm/reward_model/step_sana_sana_sprint_0_6b_1024_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep1600, skipping checkpoint +[2026-04-06 18:13:48,344][trainer.accelerators.base_accelerator][INFO] - Training progress: step=2250/8000 (28.12%), epoch=0, lr=5e-05, speed=0.498 step/s, elapsed=01:15:16, eta=03:12:23 +[2026-04-06 18:14:58,629][trainer.accelerators.base_accelerator][INFO] - Training progress: step=2300/8000 (28.75%), epoch=0, lr=5e-05, speed=0.501 step/s, elapsed=01:16:27, eta=03:09:28 +[2026-04-06 18:14:58,726][__main__][INFO] - ========== EVAL START (periodic@gstep=2300) ========== +[2026-04-06 18:14:58,726][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-06 18:14:58,726][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-06 18:16:29,143][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.232205390930176, 'accuracy': 0.4894117647058824, 'num_samples': 425, 'test_unique_accuracy': 0.4675925925925926, 'test_unique_num_samples': 432} +[2026-04-06 18:16:29,144][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-06 18:16:29,144][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-06 18:18:00,698][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.232205390930176, 'accuracy': 0.4894117647058824, 'num_samples': 425, 'test_unique_accuracy': 0.48148148148148145, 'test_unique_num_samples': 432} +[2026-04-06 18:18:00,698][__main__][INFO] - ========== EVAL END (periodic@gstep=2300) ========== +[2026-04-06 18:18:00,698][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.219425201416016, 'accuracy': 0.4894117647058824, 'num_samples': 425, 'test_unique_accuracy': 0.48148148148148145, 'test_unique_num_samples': 432} +[2026-04-06 18:18:00,700][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.4894117647058824 is not better than 0.548235294117647 of logs/lrm/reward_model/step_sana_sana_sprint_0_6b_1024_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep1600, skipping checkpoint +[2026-04-06 18:19:07,767][trainer.accelerators.base_accelerator][INFO] - Training progress: step=2350/8000 (29.38%), epoch=0, lr=5e-05, speed=0.486 step/s, elapsed=01:20:36, eta=03:13:47 +[2026-04-06 18:20:14,555][trainer.accelerators.base_accelerator][INFO] - Training progress: step=2400/8000 (30.00%), epoch=0, lr=5e-05, speed=0.489 step/s, elapsed=01:21:43, eta=03:10:40 +[2026-04-06 18:20:14,657][__main__][INFO] - ========== EVAL START (periodic@gstep=2400) ========== +[2026-04-06 18:20:14,657][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-06 18:20:14,657][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-06 18:21:47,949][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.219425201416016, 'accuracy': 0.47058823529411764, 'num_samples': 425, 'test_unique_accuracy': 0.48148148148148145, 'test_unique_num_samples': 432} +[2026-04-06 18:21:47,950][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-06 18:21:47,950][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-06 18:23:19,637][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.219425201416016, 'accuracy': 0.47058823529411764, 'num_samples': 425, 'test_unique_accuracy': 0.5069444444444444, 'test_unique_num_samples': 432} +[2026-04-06 18:23:19,638][__main__][INFO] - ========== EVAL END (periodic@gstep=2400) ========== +[2026-04-06 18:23:19,640][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.21829605102539, 'accuracy': 0.47058823529411764, 'num_samples': 425, 'test_unique_accuracy': 0.5069444444444444, 'test_unique_num_samples': 432} +[2026-04-06 18:23:19,642][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.47058823529411764 is not better than 0.548235294117647 of logs/lrm/reward_model/step_sana_sana_sprint_0_6b_1024_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep1600, skipping checkpoint +[2026-04-06 18:24:26,726][trainer.accelerators.base_accelerator][INFO] - Training progress: step=2450/8000 (30.62%), epoch=0, lr=5e-05, speed=0.475 step/s, elapsed=01:25:55, eta=03:14:38 +[2026-04-06 18:25:33,765][trainer.accelerators.base_accelerator][INFO] - Training progress: step=2500/8000 (31.25%), epoch=0, lr=5e-05, speed=0.479 step/s, elapsed=01:27:02, eta=03:11:28 +[2026-04-06 18:25:33,871][__main__][INFO] - ========== EVAL START (periodic@gstep=2500) ========== +[2026-04-06 18:25:33,871][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-06 18:25:33,871][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-06 18:27:04,180][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.21829605102539, 'accuracy': 0.4964705882352941, 'num_samples': 425, 'test_unique_accuracy': 0.5069444444444444, 'test_unique_num_samples': 432} +[2026-04-06 18:27:04,181][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-06 18:27:04,181][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-06 18:28:36,281][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.21829605102539, 'accuracy': 0.4964705882352941, 'num_samples': 425, 'test_unique_accuracy': 0.5092592592592593, 'test_unique_num_samples': 432} +[2026-04-06 18:28:36,282][__main__][INFO] - ========== EVAL END (periodic@gstep=2500) ========== +[2026-04-06 18:28:36,282][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.22069263458252, 'accuracy': 0.4964705882352941, 'num_samples': 425, 'test_unique_accuracy': 0.5092592592592593, 'test_unique_num_samples': 432} +[2026-04-06 18:28:36,284][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.4964705882352941 is not better than 0.548235294117647 of logs/lrm/reward_model/step_sana_sana_sprint_0_6b_1024_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep1600, skipping checkpoint +[2026-04-06 18:29:43,345][trainer.accelerators.base_accelerator][INFO] - Training progress: step=2550/8000 (31.88%), epoch=0, lr=5e-05, speed=0.466 step/s, elapsed=01:31:11, eta=03:14:54 +[2026-04-06 18:30:51,942][trainer.accelerators.base_accelerator][INFO] - Training progress: step=2600/8000 (32.50%), epoch=0, lr=5e-05, speed=0.469 step/s, elapsed=01:32:20, eta=03:11:47 +[2026-04-06 18:30:52,047][__main__][INFO] - ========== EVAL START (periodic@gstep=2600) ========== +[2026-04-06 18:30:52,048][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-06 18:30:52,048][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-06 18:32:26,088][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.22069263458252, 'accuracy': 0.5129411764705882, 'num_samples': 425, 'test_unique_accuracy': 0.5092592592592593, 'test_unique_num_samples': 432} +[2026-04-06 18:32:26,089][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-06 18:32:26,089][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-06 18:34:01,085][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.22069263458252, 'accuracy': 0.5129411764705882, 'num_samples': 425, 'test_unique_accuracy': 0.4513888888888889, 'test_unique_num_samples': 432} +[2026-04-06 18:34:01,085][__main__][INFO] - ========== EVAL END (periodic@gstep=2600) ========== +[2026-04-06 18:34:01,088][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.2271089553833, 'accuracy': 0.5129411764705882, 'num_samples': 425, 'test_unique_accuracy': 0.4513888888888889, 'test_unique_num_samples': 432} +[2026-04-06 18:34:01,089][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.5129411764705882 is not better than 0.548235294117647 of logs/lrm/reward_model/step_sana_sana_sprint_0_6b_1024_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep1600, skipping checkpoint +[2026-04-06 18:35:07,917][trainer.accelerators.base_accelerator][INFO] - Training progress: step=2650/8000 (33.12%), epoch=0, lr=5e-05, speed=0.457 step/s, elapsed=01:36:36, eta=03:15:02 +[2026-04-06 18:36:14,709][trainer.accelerators.base_accelerator][INFO] - Training progress: step=2700/8000 (33.75%), epoch=0, lr=5e-05, speed=0.460 step/s, elapsed=01:37:43, eta=03:11:49 +[2026-04-06 18:36:14,813][__main__][INFO] - ========== EVAL START (periodic@gstep=2700) ========== +[2026-04-06 18:36:14,813][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-06 18:36:14,813][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-06 18:37:45,315][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.2271089553833, 'accuracy': 0.5035294117647059, 'num_samples': 425, 'test_unique_accuracy': 0.4513888888888889, 'test_unique_num_samples': 432} +[2026-04-06 18:37:45,315][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-06 18:37:45,315][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-06 18:39:20,191][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.2271089553833, 'accuracy': 0.5035294117647059, 'num_samples': 425, 'test_unique_accuracy': 0.5277777777777778, 'test_unique_num_samples': 432} +[2026-04-06 18:39:20,191][__main__][INFO] - ========== EVAL END (periodic@gstep=2700) ========== +[2026-04-06 18:39:20,193][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.22199535369873, 'accuracy': 0.5035294117647059, 'num_samples': 425, 'test_unique_accuracy': 0.5277777777777778, 'test_unique_num_samples': 432} +[2026-04-06 18:39:20,195][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.5035294117647059 is not better than 0.548235294117647 of logs/lrm/reward_model/step_sana_sana_sprint_0_6b_1024_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep1600, skipping checkpoint +[2026-04-06 18:40:26,897][trainer.accelerators.base_accelerator][INFO] - Training progress: step=2750/8000 (34.38%), epoch=0, lr=5e-05, speed=0.450 step/s, elapsed=01:41:55, eta=03:14:34 +[2026-04-06 18:41:33,957][trainer.accelerators.base_accelerator][INFO] - Training progress: step=2800/8000 (35.00%), epoch=0, lr=5e-05, speed=0.453 step/s, elapsed=01:43:02, eta=03:11:21 +[2026-04-06 18:41:34,062][__main__][INFO] - ========== EVAL START (periodic@gstep=2800) ========== +[2026-04-06 18:41:34,062][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-06 18:41:34,062][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-06 18:43:04,190][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.22199535369873, 'accuracy': 0.48, 'num_samples': 425, 'test_unique_accuracy': 0.5277777777777778, 'test_unique_num_samples': 432} +[2026-04-06 18:43:04,190][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-06 18:43:04,190][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-06 18:44:35,591][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.22199535369873, 'accuracy': 0.48, 'num_samples': 425, 'test_unique_accuracy': 0.5, 'test_unique_num_samples': 432} +[2026-04-06 18:44:35,591][__main__][INFO] - ========== EVAL END (periodic@gstep=2800) ========== +[2026-04-06 18:44:35,592][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.234033584594727, 'accuracy': 0.48, 'num_samples': 425, 'test_unique_accuracy': 0.5, 'test_unique_num_samples': 432} +[2026-04-06 18:44:35,593][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.48 is not better than 0.548235294117647 of logs/lrm/reward_model/step_sana_sana_sprint_0_6b_1024_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep1600, skipping checkpoint +[2026-04-06 18:45:44,656][trainer.accelerators.base_accelerator][INFO] - Training progress: step=2850/8000 (35.62%), epoch=0, lr=5e-05, speed=0.443 step/s, elapsed=01:47:13, eta=03:13:44 +[2026-04-06 18:46:54,842][trainer.accelerators.base_accelerator][INFO] - Training progress: step=2900/8000 (36.25%), epoch=0, lr=5e-05, speed=0.446 step/s, elapsed=01:48:23, eta=03:10:36 +[2026-04-06 18:46:54,942][__main__][INFO] - ========== EVAL START (periodic@gstep=2900) ========== +[2026-04-06 18:46:54,942][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-06 18:46:54,942][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-06 18:48:25,397][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.234033584594727, 'accuracy': 0.4964705882352941, 'num_samples': 425, 'test_unique_accuracy': 0.5, 'test_unique_num_samples': 432} +[2026-04-06 18:48:25,397][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-06 18:48:25,397][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-06 18:50:00,436][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.234033584594727, 'accuracy': 0.4964705882352941, 'num_samples': 425, 'test_unique_accuracy': 0.5393518518518519, 'test_unique_num_samples': 432} +[2026-04-06 18:50:00,437][__main__][INFO] - ========== EVAL END (periodic@gstep=2900) ========== +[2026-04-06 18:50:00,437][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.227668762207031, 'accuracy': 0.4964705882352941, 'num_samples': 425, 'test_unique_accuracy': 0.5393518518518519, 'test_unique_num_samples': 432} +[2026-04-06 18:50:00,439][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.4964705882352941 is not better than 0.548235294117647 of logs/lrm/reward_model/step_sana_sana_sprint_0_6b_1024_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep1600, skipping checkpoint +[2026-04-06 18:51:07,403][trainer.accelerators.base_accelerator][INFO] - Training progress: step=2950/8000 (36.88%), epoch=0, lr=5e-05, speed=0.437 step/s, elapsed=01:52:35, eta=03:12:45 +[2026-04-06 18:52:14,405][trainer.accelerators.base_accelerator][INFO] - Training progress: step=3000/8000 (37.50%), epoch=0, lr=5e-05, speed=0.440 step/s, elapsed=01:53:42, eta=03:09:31 +[2026-04-06 18:52:14,506][__main__][INFO] - ========== EVAL START (periodic@gstep=3000) ========== +[2026-04-06 18:52:14,506][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-06 18:52:14,506][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-06 18:53:45,693][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.227668762207031, 'accuracy': 0.49411764705882355, 'num_samples': 425, 'test_unique_accuracy': 0.5393518518518519, 'test_unique_num_samples': 432} +[2026-04-06 18:53:45,694][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-06 18:53:45,694][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-06 18:55:17,486][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.227668762207031, 'accuracy': 0.49411764705882355, 'num_samples': 425, 'test_unique_accuracy': 0.49074074074074076, 'test_unique_num_samples': 432} +[2026-04-06 18:55:17,486][__main__][INFO] - ========== EVAL END (periodic@gstep=3000) ========== +[2026-04-06 18:55:17,487][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.229436874389648, 'accuracy': 0.49411764705882355, 'num_samples': 425, 'test_unique_accuracy': 0.49074074074074076, 'test_unique_num_samples': 432} +[2026-04-06 18:55:17,489][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.49411764705882355 is not better than 0.548235294117647 of logs/lrm/reward_model/step_sana_sana_sprint_0_6b_1024_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep1600, skipping checkpoint +[2026-04-06 18:56:24,097][trainer.accelerators.base_accelerator][INFO] - Training progress: step=3050/8000 (38.12%), epoch=0, lr=5e-05, speed=0.431 step/s, elapsed=01:57:52, eta=03:11:18 +[2026-04-06 18:57:30,888][trainer.accelerators.base_accelerator][INFO] - Training progress: step=3100/8000 (38.75%), epoch=0, lr=5e-05, speed=0.434 step/s, elapsed=01:58:59, eta=03:08:04 +[2026-04-06 18:57:30,992][__main__][INFO] - ========== EVAL START (periodic@gstep=3100) ========== +[2026-04-06 18:57:30,992][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-06 18:57:30,992][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-06 18:59:01,396][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.229436874389648, 'accuracy': 0.5105882352941177, 'num_samples': 425, 'test_unique_accuracy': 0.49074074074074076, 'test_unique_num_samples': 432} +[2026-04-06 18:59:01,396][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-06 18:59:01,396][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-06 19:00:33,419][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.229436874389648, 'accuracy': 0.5105882352941177, 'num_samples': 425, 'test_unique_accuracy': 0.4791666666666667, 'test_unique_num_samples': 432} +[2026-04-06 19:00:33,463][__main__][INFO] - ========== EVAL END (periodic@gstep=3100) ========== +[2026-04-06 19:00:33,466][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.23278522491455, 'accuracy': 0.5105882352941177, 'num_samples': 425, 'test_unique_accuracy': 0.4791666666666667, 'test_unique_num_samples': 432} +[2026-04-06 19:00:33,471][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.5105882352941177 is not better than 0.548235294117647 of logs/lrm/reward_model/step_sana_sana_sprint_0_6b_1024_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep1600, skipping checkpoint +[2026-04-06 19:01:40,393][trainer.accelerators.base_accelerator][INFO] - Training progress: step=3150/8000 (39.38%), epoch=0, lr=5e-05, speed=0.426 step/s, elapsed=02:03:08, eta=03:09:36 +[2026-04-06 19:02:47,081][trainer.accelerators.base_accelerator][INFO] - Training progress: step=3200/8000 (40.00%), epoch=0, lr=5e-05, speed=0.429 step/s, elapsed=02:04:15, eta=03:06:23 +[2026-04-06 19:02:47,184][__main__][INFO] - ========== EVAL START (periodic@gstep=3200) ========== +[2026-04-06 19:02:47,184][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-06 19:02:47,184][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-06 19:04:20,932][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.23278522491455, 'accuracy': 0.49176470588235294, 'num_samples': 425, 'test_unique_accuracy': 0.4791666666666667, 'test_unique_num_samples': 432} +[2026-04-06 19:04:20,932][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-06 19:04:20,933][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-06 19:05:52,489][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.23278522491455, 'accuracy': 0.49176470588235294, 'num_samples': 425, 'test_unique_accuracy': 0.4861111111111111, 'test_unique_num_samples': 432} +[2026-04-06 19:05:52,489][__main__][INFO] - ========== EVAL END (periodic@gstep=3200) ========== +[2026-04-06 19:05:52,490][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.229162216186523, 'accuracy': 0.49176470588235294, 'num_samples': 425, 'test_unique_accuracy': 0.4861111111111111, 'test_unique_num_samples': 432} +[2026-04-06 19:05:52,493][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.49176470588235294 is not better than 0.548235294117647 of logs/lrm/reward_model/step_sana_sana_sprint_0_6b_1024_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep1600, skipping checkpoint +[2026-04-06 19:06:59,582][trainer.accelerators.base_accelerator][INFO] - Training progress: step=3250/8000 (40.62%), epoch=0, lr=5e-05, speed=0.422 step/s, elapsed=02:08:28, eta=03:07:45 +[2026-04-06 19:08:06,312][trainer.accelerators.base_accelerator][INFO] - Training progress: step=3300/8000 (41.25%), epoch=0, lr=5e-05, speed=0.424 step/s, elapsed=02:09:34, eta=03:04:33 +[2026-04-06 19:08:06,414][__main__][INFO] - ========== EVAL START (periodic@gstep=3300) ========== +[2026-04-06 19:08:06,414][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-06 19:08:06,414][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-06 19:09:37,207][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.229162216186523, 'accuracy': 0.4682352941176471, 'num_samples': 425, 'test_unique_accuracy': 0.4861111111111111, 'test_unique_num_samples': 432} +[2026-04-06 19:09:37,207][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-06 19:09:37,207][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-06 19:11:08,673][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.229162216186523, 'accuracy': 0.4682352941176471, 'num_samples': 425, 'test_unique_accuracy': 0.5138888888888888, 'test_unique_num_samples': 432} +[2026-04-06 19:11:08,674][__main__][INFO] - ========== EVAL END (periodic@gstep=3300) ========== +[2026-04-06 19:11:08,674][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.227542877197266, 'accuracy': 0.4682352941176471, 'num_samples': 425, 'test_unique_accuracy': 0.5138888888888888, 'test_unique_num_samples': 432} +[2026-04-06 19:11:08,676][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.4682352941176471 is not better than 0.548235294117647 of logs/lrm/reward_model/step_sana_sana_sprint_0_6b_1024_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep1600, skipping checkpoint +[2026-04-06 19:12:18,185][trainer.accelerators.base_accelerator][INFO] - Training progress: step=3350/8000 (41.88%), epoch=0, lr=5e-05, speed=0.417 step/s, elapsed=02:13:46, eta=03:05:41 +[2026-04-06 19:13:28,274][trainer.accelerators.base_accelerator][INFO] - Training progress: step=3400/8000 (42.50%), epoch=0, lr=5e-05, speed=0.420 step/s, elapsed=02:14:56, eta=03:02:34 +[2026-04-06 19:13:28,369][__main__][INFO] - ========== EVAL START (periodic@gstep=3400) ========== +[2026-04-06 19:13:28,369][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-06 19:13:28,369][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-06 19:14:58,717][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.227542877197266, 'accuracy': 0.49411764705882355, 'num_samples': 425, 'test_unique_accuracy': 0.5138888888888888, 'test_unique_num_samples': 432} +[2026-04-06 19:14:58,719][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-06 19:14:58,719][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-06 19:16:30,330][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.227542877197266, 'accuracy': 0.49411764705882355, 'num_samples': 425, 'test_unique_accuracy': 0.4837962962962963, 'test_unique_num_samples': 432} +[2026-04-06 19:16:30,331][__main__][INFO] - ========== EVAL END (periodic@gstep=3400) ========== +[2026-04-06 19:16:30,333][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.209997177124023, 'accuracy': 0.49411764705882355, 'num_samples': 425, 'test_unique_accuracy': 0.4837962962962963, 'test_unique_num_samples': 432} +[2026-04-06 19:16:30,335][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.49411764705882355 is not better than 0.548235294117647 of logs/lrm/reward_model/step_sana_sana_sprint_0_6b_1024_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep1600, skipping checkpoint +[2026-04-06 19:17:37,298][trainer.accelerators.base_accelerator][INFO] - Training progress: step=3450/8000 (43.12%), epoch=0, lr=5e-05, speed=0.413 step/s, elapsed=02:19:05, eta=03:03:26 +[2026-04-06 19:18:43,878][trainer.accelerators.base_accelerator][INFO] - Training progress: step=3500/8000 (43.75%), epoch=0, lr=5e-05, speed=0.416 step/s, elapsed=02:20:12, eta=03:00:15 +[2026-04-06 19:18:43,982][__main__][INFO] - ========== EVAL START (periodic@gstep=3500) ========== +[2026-04-06 19:18:43,983][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-06 19:18:43,983][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-06 19:20:14,144][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.209997177124023, 'accuracy': 0.5105882352941177, 'num_samples': 425, 'test_unique_accuracy': 0.4837962962962963, 'test_unique_num_samples': 432} +[2026-04-06 19:20:14,144][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-06 19:20:14,144][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-06 19:21:46,136][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.209997177124023, 'accuracy': 0.5105882352941177, 'num_samples': 425, 'test_unique_accuracy': 0.49537037037037035, 'test_unique_num_samples': 432} +[2026-04-06 19:21:46,136][__main__][INFO] - ========== EVAL END (periodic@gstep=3500) ========== +[2026-04-06 19:21:46,137][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.208271980285645, 'accuracy': 0.5105882352941177, 'num_samples': 425, 'test_unique_accuracy': 0.49537037037037035, 'test_unique_num_samples': 432} +[2026-04-06 19:21:46,139][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.5105882352941177 is not better than 0.548235294117647 of logs/lrm/reward_model/step_sana_sana_sprint_0_6b_1024_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep1600, skipping checkpoint +[2026-04-06 19:22:52,970][trainer.accelerators.base_accelerator][INFO] - Training progress: step=3550/8000 (44.38%), epoch=0, lr=5e-05, speed=0.410 step/s, elapsed=02:24:21, eta=03:00:57 +[2026-04-06 19:23:59,664][trainer.accelerators.base_accelerator][INFO] - Training progress: step=3600/8000 (45.00%), epoch=0, lr=5e-05, speed=0.412 step/s, elapsed=02:25:28, eta=02:57:47 +[2026-04-06 19:23:59,767][__main__][INFO] - ========== EVAL START (periodic@gstep=3600) ========== +[2026-04-06 19:23:59,767][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-06 19:23:59,767][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-06 19:25:30,133][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.208271980285645, 'accuracy': 0.5105882352941177, 'num_samples': 425, 'test_unique_accuracy': 0.49537037037037035, 'test_unique_num_samples': 432} +[2026-04-06 19:25:30,135][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-06 19:25:30,135][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-06 19:27:01,816][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.208271980285645, 'accuracy': 0.5105882352941177, 'num_samples': 425, 'test_unique_accuracy': 0.5046296296296297, 'test_unique_num_samples': 432} +[2026-04-06 19:27:01,817][__main__][INFO] - ========== EVAL END (periodic@gstep=3600) ========== +[2026-04-06 19:27:01,819][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.218086242675781, 'accuracy': 0.5105882352941177, 'num_samples': 425, 'test_unique_accuracy': 0.5046296296296297, 'test_unique_num_samples': 432} +[2026-04-06 19:27:01,820][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.5105882352941177 is not better than 0.548235294117647 of logs/lrm/reward_model/step_sana_sana_sprint_0_6b_1024_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep1600, skipping checkpoint +[2026-04-06 19:28:08,429][trainer.accelerators.base_accelerator][INFO] - Training progress: step=3650/8000 (45.62%), epoch=0, lr=5e-05, speed=0.407 step/s, elapsed=02:29:36, eta=02:58:18 +[2026-04-06 19:29:15,376][trainer.accelerators.base_accelerator][INFO] - Training progress: step=3700/8000 (46.25%), epoch=0, lr=5e-05, speed=0.409 step/s, elapsed=02:30:43, eta=02:55:10 +[2026-04-06 19:29:15,436][__main__][INFO] - ========== EVAL START (periodic@gstep=3700) ========== +[2026-04-06 19:29:15,437][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-06 19:29:15,437][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-06 19:30:49,383][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.218086242675781, 'accuracy': 0.5105882352941177, 'num_samples': 425, 'test_unique_accuracy': 0.5046296296296297, 'test_unique_num_samples': 432} +[2026-04-06 19:30:49,383][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-06 19:30:49,383][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-06 19:32:24,370][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.218086242675781, 'accuracy': 0.5105882352941177, 'num_samples': 425, 'test_unique_accuracy': 0.4791666666666667, 'test_unique_num_samples': 432} +[2026-04-06 19:32:24,371][__main__][INFO] - ========== EVAL END (periodic@gstep=3700) ========== +[2026-04-06 19:32:24,373][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.21255111694336, 'accuracy': 0.5105882352941177, 'num_samples': 425, 'test_unique_accuracy': 0.4791666666666667, 'test_unique_num_samples': 432} +[2026-04-06 19:32:24,375][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.5105882352941177 is not better than 0.548235294117647 of logs/lrm/reward_model/step_sana_sana_sprint_0_6b_1024_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep1600, skipping checkpoint +[2026-04-06 19:33:33,694][trainer.accelerators.base_accelerator][INFO] - Training progress: step=3750/8000 (46.88%), epoch=0, lr=5e-05, speed=0.403 step/s, elapsed=02:35:02, eta=02:55:42 +[2026-04-06 19:34:43,904][trainer.accelerators.base_accelerator][INFO] - Training progress: step=3800/8000 (47.50%), epoch=0, lr=5e-05, speed=0.405 step/s, elapsed=02:36:12, eta=02:52:38 +[2026-04-06 19:34:44,001][__main__][INFO] - ========== EVAL START (periodic@gstep=3800) ========== +[2026-04-06 19:34:44,001][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-06 19:34:44,001][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-06 19:36:14,471][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.21255111694336, 'accuracy': 0.4964705882352941, 'num_samples': 425, 'test_unique_accuracy': 0.4791666666666667, 'test_unique_num_samples': 432} +[2026-04-06 19:36:14,471][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-06 19:36:14,471][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-06 19:37:49,686][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.21255111694336, 'accuracy': 0.4964705882352941, 'num_samples': 425, 'test_unique_accuracy': 0.5208333333333334, 'test_unique_num_samples': 432} +[2026-04-06 19:37:49,686][__main__][INFO] - ========== EVAL END (periodic@gstep=3800) ========== +[2026-04-06 19:37:49,688][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.220444679260254, 'accuracy': 0.4964705882352941, 'num_samples': 425, 'test_unique_accuracy': 0.5208333333333334, 'test_unique_num_samples': 432} +[2026-04-06 19:37:49,689][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.4964705882352941 is not better than 0.548235294117647 of logs/lrm/reward_model/step_sana_sana_sprint_0_6b_1024_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep1600, skipping checkpoint +[2026-04-06 19:38:59,050][trainer.accelerators.base_accelerator][INFO] - Training progress: step=3850/8000 (48.12%), epoch=0, lr=5e-05, speed=0.400 step/s, elapsed=02:40:27, eta=02:52:57 +[2026-04-06 19:40:08,987][trainer.accelerators.base_accelerator][INFO] - Training progress: step=3900/8000 (48.75%), epoch=0, lr=5e-05, speed=0.402 step/s, elapsed=02:41:37, eta=02:49:54 +[2026-04-06 19:40:09,096][__main__][INFO] - ========== EVAL START (periodic@gstep=3900) ========== +[2026-04-06 19:40:09,096][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-06 19:40:09,096][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-06 19:41:43,130][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.220444679260254, 'accuracy': 0.47058823529411764, 'num_samples': 425, 'test_unique_accuracy': 0.5208333333333334, 'test_unique_num_samples': 432} +[2026-04-06 19:41:43,131][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-06 19:41:43,132][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-06 19:43:14,390][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.220444679260254, 'accuracy': 0.47058823529411764, 'num_samples': 425, 'test_unique_accuracy': 0.46296296296296297, 'test_unique_num_samples': 432} +[2026-04-06 19:43:14,391][__main__][INFO] - ========== EVAL END (periodic@gstep=3900) ========== +[2026-04-06 19:43:14,392][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.208895683288574, 'accuracy': 0.47058823529411764, 'num_samples': 425, 'test_unique_accuracy': 0.46296296296296297, 'test_unique_num_samples': 432} +[2026-04-06 19:43:14,394][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.47058823529411764 is not better than 0.548235294117647 of logs/lrm/reward_model/step_sana_sana_sprint_0_6b_1024_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep1600, skipping checkpoint +[2026-04-06 19:44:21,005][trainer.accelerators.base_accelerator][INFO] - Training progress: step=3950/8000 (49.38%), epoch=0, lr=5e-05, speed=0.397 step/s, elapsed=02:45:49, eta=02:50:01 +[2026-04-06 19:45:27,748][trainer.accelerators.base_accelerator][INFO] - Training progress: step=4000/8000 (50.00%), epoch=0, lr=5e-05, speed=0.399 step/s, elapsed=02:46:56, eta=02:46:56 +[2026-04-06 19:45:27,852][__main__][INFO] - ========== EVAL START (periodic@gstep=4000) ========== +[2026-04-06 19:45:27,852][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-06 19:45:27,853][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-06 19:46:58,331][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.208895683288574, 'accuracy': 0.5105882352941177, 'num_samples': 425, 'test_unique_accuracy': 0.46296296296296297, 'test_unique_num_samples': 432} +[2026-04-06 19:46:58,331][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-06 19:46:58,331][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-06 19:48:29,885][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.208895683288574, 'accuracy': 0.5105882352941177, 'num_samples': 425, 'test_unique_accuracy': 0.49537037037037035, 'test_unique_num_samples': 432} +[2026-04-06 19:48:29,885][__main__][INFO] - ========== EVAL END (periodic@gstep=4000) ========== +[2026-04-06 19:48:29,886][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.206538200378418, 'accuracy': 0.5105882352941177, 'num_samples': 425, 'test_unique_accuracy': 0.49537037037037035, 'test_unique_num_samples': 432} +[2026-04-06 19:48:29,888][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.5105882352941177 is not better than 0.548235294117647 of logs/lrm/reward_model/step_sana_sana_sprint_0_6b_1024_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep1600, skipping checkpoint +[2026-04-06 19:49:36,958][trainer.accelerators.base_accelerator][INFO] - Training progress: step=4050/8000 (50.62%), epoch=0, lr=5e-05, speed=0.395 step/s, elapsed=02:51:05, eta=02:46:51 +[2026-04-06 19:50:44,179][trainer.accelerators.base_accelerator][INFO] - Training progress: step=4100/8000 (51.25%), epoch=0, lr=5e-05, speed=0.397 step/s, elapsed=02:52:12, eta=02:43:48 +[2026-04-06 19:50:44,283][__main__][INFO] - ========== EVAL START (periodic@gstep=4100) ========== +[2026-04-06 19:50:44,283][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-06 19:50:44,284][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-06 19:52:18,288][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.206538200378418, 'accuracy': 0.4823529411764706, 'num_samples': 425, 'test_unique_accuracy': 0.49537037037037035, 'test_unique_num_samples': 432} +[2026-04-06 19:52:18,289][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-06 19:52:18,289][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-06 19:53:53,461][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.206538200378418, 'accuracy': 0.4823529411764706, 'num_samples': 425, 'test_unique_accuracy': 0.4976851851851852, 'test_unique_num_samples': 432} +[2026-04-06 19:53:53,461][__main__][INFO] - ========== EVAL END (periodic@gstep=4100) ========== +[2026-04-06 19:53:53,463][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.204029083251953, 'accuracy': 0.4823529411764706, 'num_samples': 425, 'test_unique_accuracy': 0.4976851851851852, 'test_unique_num_samples': 432} +[2026-04-06 19:53:53,465][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.4823529411764706 is not better than 0.548235294117647 of logs/lrm/reward_model/step_sana_sana_sprint_0_6b_1024_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep1600, skipping checkpoint +[2026-04-06 19:55:01,685][trainer.accelerators.base_accelerator][INFO] - Training progress: step=4150/8000 (51.88%), epoch=0, lr=5e-05, speed=0.392 step/s, elapsed=02:56:30, eta=02:43:44 +[2026-04-06 19:56:08,677][trainer.accelerators.base_accelerator][INFO] - Training progress: step=4200/8000 (52.50%), epoch=0, lr=5e-05, speed=0.394 step/s, elapsed=02:57:37, eta=02:40:42 +[2026-04-06 19:56:08,780][__main__][INFO] - ========== EVAL START (periodic@gstep=4200) ========== +[2026-04-06 19:56:08,781][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-06 19:56:08,781][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-06 19:57:39,118][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.204029083251953, 'accuracy': 0.5176470588235295, 'num_samples': 425, 'test_unique_accuracy': 0.4976851851851852, 'test_unique_num_samples': 432} +[2026-04-06 19:57:39,118][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-06 19:57:39,118][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-06 19:59:10,898][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.204029083251953, 'accuracy': 0.5176470588235295, 'num_samples': 425, 'test_unique_accuracy': 0.5162037037037037, 'test_unique_num_samples': 432} +[2026-04-06 19:59:10,899][__main__][INFO] - ========== EVAL END (periodic@gstep=4200) ========== +[2026-04-06 19:59:10,900][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.212906837463379, 'accuracy': 0.5176470588235295, 'num_samples': 425, 'test_unique_accuracy': 0.5162037037037037, 'test_unique_num_samples': 432} +[2026-04-06 19:59:10,902][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.5176470588235295 is not better than 0.548235294117647 of logs/lrm/reward_model/step_sana_sana_sprint_0_6b_1024_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep1600, skipping checkpoint +[2026-04-06 20:00:17,794][trainer.accelerators.base_accelerator][INFO] - Training progress: step=4250/8000 (53.12%), epoch=0, lr=5e-05, speed=0.390 step/s, elapsed=03:01:46, eta=02:40:23 +[2026-04-06 20:01:24,834][trainer.accelerators.base_accelerator][INFO] - Training progress: step=4300/8000 (53.75%), epoch=0, lr=5e-05, speed=0.392 step/s, elapsed=03:02:53, eta=02:37:22 +[2026-04-06 20:01:24,937][__main__][INFO] - ========== EVAL START (periodic@gstep=4300) ========== +[2026-04-06 20:01:24,938][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-06 20:01:24,938][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-06 20:02:58,453][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.212906837463379, 'accuracy': 0.5152941176470588, 'num_samples': 425, 'test_unique_accuracy': 0.5162037037037037, 'test_unique_num_samples': 432} +[2026-04-06 20:02:58,454][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-06 20:02:58,454][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-06 20:04:30,157][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.212906837463379, 'accuracy': 0.5152941176470588, 'num_samples': 425, 'test_unique_accuracy': 0.48148148148148145, 'test_unique_num_samples': 432} +[2026-04-06 20:04:30,157][__main__][INFO] - ========== EVAL END (periodic@gstep=4300) ========== +[2026-04-06 20:04:30,158][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.213947296142578, 'accuracy': 0.5152941176470588, 'num_samples': 425, 'test_unique_accuracy': 0.48148148148148145, 'test_unique_num_samples': 432} +[2026-04-06 20:04:30,160][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.5152941176470588 is not better than 0.548235294117647 of logs/lrm/reward_model/step_sana_sana_sprint_0_6b_1024_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep1600, skipping checkpoint +[2026-04-06 20:05:37,060][trainer.accelerators.base_accelerator][INFO] - Training progress: step=4350/8000 (54.38%), epoch=0, lr=5e-05, speed=0.388 step/s, elapsed=03:07:05, eta=02:36:59 +[2026-04-06 20:06:43,591][trainer.accelerators.base_accelerator][INFO] - Training progress: step=4400/8000 (55.00%), epoch=0, lr=5e-05, speed=0.390 step/s, elapsed=03:08:12, eta=02:33:58 +[2026-04-06 20:06:43,698][__main__][INFO] - ========== EVAL START (periodic@gstep=4400) ========== +[2026-04-06 20:06:43,698][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-06 20:06:43,698][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-06 20:08:14,115][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.213947296142578, 'accuracy': 0.5694117647058824, 'num_samples': 425, 'test_unique_accuracy': 0.48148148148148145, 'test_unique_num_samples': 432} +[2026-04-06 20:08:14,116][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-06 20:08:14,116][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-06 20:09:45,610][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.213947296142578, 'accuracy': 0.5694117647058824, 'num_samples': 425, 'test_unique_accuracy': 0.5393518518518519, 'test_unique_num_samples': 432} +[2026-04-06 20:09:45,610][__main__][INFO] - ========== EVAL END (periodic@gstep=4400) ========== +[2026-04-06 20:09:45,610][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.216266632080078, 'accuracy': 0.5694117647058824, 'num_samples': 425, 'test_unique_accuracy': 0.5393518518518519, 'test_unique_num_samples': 432} +[2026-04-06 20:09:45,666][trainer.accelerators.base_accelerator][INFO] - Found 3 checkpoints in logs/lrm/reward_model/step_sana_sana_sprint_0_6b_1024_variable-t_lr1e-5_step-8000_filter2_time951 +[2026-04-06 20:09:45,671][trainer.accelerators.base_accelerator][INFO] - Deleting checkpoint logs/lrm/reward_model/step_sana_sana_sprint_0_6b_1024_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep200 +[2026-04-06 20:09:45,678][trainer.accelerators.base_accelerator][INFO] - Saving checkpoint to logs/lrm/reward_model/step_sana_sana_sprint_0_6b_1024_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep4400 +[2026-04-06 20:09:45,679][accelerate.accelerator][INFO] - Saving current state to logs/lrm/reward_model/step_sana_sana_sprint_0_6b_1024_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep4400 +[2026-04-06 20:10:07,231][accelerate.checkpointing][INFO] - Model weights saved in logs/lrm/reward_model/step_sana_sana_sprint_0_6b_1024_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep4400/model.safetensors +[2026-04-06 20:10:37,644][accelerate.checkpointing][INFO] - Optimizer state saved in logs/lrm/reward_model/step_sana_sana_sprint_0_6b_1024_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep4400/optimizer.bin +[2026-04-06 20:10:38,193][accelerate.checkpointing][INFO] - Scheduler state saved in logs/lrm/reward_model/step_sana_sana_sprint_0_6b_1024_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep4400/scheduler.bin +[2026-04-06 20:10:38,194][accelerate.checkpointing][INFO] - Sampler state for dataloader 0 saved in logs/lrm/reward_model/step_sana_sana_sprint_0_6b_1024_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep4400/sampler.bin +[2026-04-06 20:10:38,194][accelerate.checkpointing][INFO] - Sampler state for dataloader 1 saved in logs/lrm/reward_model/step_sana_sana_sprint_0_6b_1024_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep4400/sampler_1.bin +[2026-04-06 20:10:38,194][accelerate.checkpointing][INFO] - Sampler state for dataloader 2 saved in logs/lrm/reward_model/step_sana_sana_sprint_0_6b_1024_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep4400/sampler_2.bin +[2026-04-06 20:10:38,853][accelerate.checkpointing][INFO] - Random states saved in logs/lrm/reward_model/step_sana_sana_sprint_0_6b_1024_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep4400/random_states_0.pkl +[2026-04-06 20:10:39,438][trainer.accelerators.base_accelerator][INFO] - Saved checkpoint to logs/lrm/reward_model/step_sana_sana_sprint_0_6b_1024_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep4400 +[2026-04-06 20:11:18,992][trainer.accelerators.base_accelerator][INFO] - Training progress: step=4450/8000 (55.62%), epoch=0, lr=5e-05, speed=0.385 step/s, elapsed=03:12:47, eta=02:33:47 +[2026-04-06 20:11:56,583][trainer.accelerators.base_accelerator][INFO] - Training progress: step=4500/8000 (56.25%), epoch=0, lr=5e-05, speed=0.388 step/s, elapsed=03:13:25, eta=02:30:26 +[2026-04-06 20:11:56,654][__main__][INFO] - ========== EVAL START (periodic@gstep=4500) ========== +[2026-04-06 20:11:56,655][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-06 20:11:56,655][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-06 20:12:42,416][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.216266632080078, 'accuracy': 0.47294117647058825, 'num_samples': 425, 'test_unique_accuracy': 0.5393518518518519, 'test_unique_num_samples': 432} +[2026-04-06 20:12:42,417][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-06 20:12:42,417][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-06 20:13:28,234][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.216266632080078, 'accuracy': 0.47294117647058825, 'num_samples': 425, 'test_unique_accuracy': 0.5254629629629629, 'test_unique_num_samples': 432} +[2026-04-06 20:13:28,234][__main__][INFO] - ========== EVAL END (periodic@gstep=4500) ========== +[2026-04-06 20:13:28,234][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.21926212310791, 'accuracy': 0.47294117647058825, 'num_samples': 425, 'test_unique_accuracy': 0.5254629629629629, 'test_unique_num_samples': 432} +[2026-04-06 20:13:28,236][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.47294117647058825 is not better than 0.548235294117647 of logs/lrm/reward_model/step_sana_sana_sprint_0_6b_1024_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep1600, skipping checkpoint +[2026-04-06 20:14:06,011][trainer.accelerators.base_accelerator][INFO] - Training progress: step=4550/8000 (56.88%), epoch=0, lr=5e-05, speed=0.388 step/s, elapsed=03:15:34, eta=02:28:17 +[2026-04-06 20:14:43,626][trainer.accelerators.base_accelerator][INFO] - Training progress: step=4600/8000 (57.50%), epoch=0, lr=5e-05, speed=0.391 step/s, elapsed=03:16:12, eta=02:25:01 +[2026-04-06 20:14:43,687][__main__][INFO] - ========== EVAL START (periodic@gstep=4600) ========== +[2026-04-06 20:14:43,687][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-06 20:14:43,687][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-06 20:15:29,360][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.21926212310791, 'accuracy': 0.5035294117647059, 'num_samples': 425, 'test_unique_accuracy': 0.5254629629629629, 'test_unique_num_samples': 432} +[2026-04-06 20:15:29,361][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-06 20:15:29,361][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-06 20:16:15,321][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.21926212310791, 'accuracy': 0.5035294117647059, 'num_samples': 425, 'test_unique_accuracy': 0.5162037037037037, 'test_unique_num_samples': 432} +[2026-04-06 20:16:15,321][__main__][INFO] - ========== EVAL END (periodic@gstep=4600) ========== +[2026-04-06 20:16:15,322][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.217994689941406, 'accuracy': 0.5035294117647059, 'num_samples': 425, 'test_unique_accuracy': 0.5162037037037037, 'test_unique_num_samples': 432} +[2026-04-06 20:16:15,324][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.5035294117647059 is not better than 0.548235294117647 of logs/lrm/reward_model/step_sana_sana_sprint_0_6b_1024_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep1600, skipping checkpoint +[2026-04-06 20:16:52,931][trainer.accelerators.base_accelerator][INFO] - Training progress: step=4650/8000 (58.12%), epoch=0, lr=5e-05, speed=0.391 step/s, elapsed=03:18:21, eta=02:22:54 +[2026-04-06 20:17:31,261][trainer.accelerators.base_accelerator][INFO] - Training progress: step=4700/8000 (58.75%), epoch=0, lr=5e-05, speed=0.394 step/s, elapsed=03:18:59, eta=02:19:43 +[2026-04-06 20:17:31,328][__main__][INFO] - ========== EVAL START (periodic@gstep=4700) ========== +[2026-04-06 20:17:31,328][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-06 20:17:31,328][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-06 20:19:02,043][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.217994689941406, 'accuracy': 0.49411764705882355, 'num_samples': 425, 'test_unique_accuracy': 0.5162037037037037, 'test_unique_num_samples': 432} +[2026-04-06 20:19:02,043][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-06 20:19:02,043][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-06 20:20:33,697][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.217994689941406, 'accuracy': 0.49411764705882355, 'num_samples': 425, 'test_unique_accuracy': 0.4976851851851852, 'test_unique_num_samples': 432} +[2026-04-06 20:20:33,697][__main__][INFO] - ========== EVAL END (periodic@gstep=4700) ========== +[2026-04-06 20:20:33,699][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.21309757232666, 'accuracy': 0.49411764705882355, 'num_samples': 425, 'test_unique_accuracy': 0.4976851851851852, 'test_unique_num_samples': 432} +[2026-04-06 20:20:33,702][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.49411764705882355 is not better than 0.548235294117647 of logs/lrm/reward_model/step_sana_sana_sprint_0_6b_1024_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep1600, skipping checkpoint +[2026-04-06 20:21:39,699][trainer.accelerators.base_accelerator][INFO] - Training progress: step=4750/8000 (59.38%), epoch=0, lr=5e-05, speed=0.390 step/s, elapsed=03:23:08, eta=02:18:59 +[2026-04-06 20:22:47,694][trainer.accelerators.base_accelerator][INFO] - Training progress: step=4800/8000 (60.00%), epoch=0, lr=5e-05, speed=0.392 step/s, elapsed=03:24:16, eta=02:16:10 +[2026-04-06 20:22:47,802][__main__][INFO] - ========== EVAL START (periodic@gstep=4800) ========== +[2026-04-06 20:22:47,802][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-06 20:22:47,803][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-06 20:23:37,486][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.21309757232666, 'accuracy': 0.5647058823529412, 'num_samples': 425, 'test_unique_accuracy': 0.4976851851851852, 'test_unique_num_samples': 432} +[2026-04-06 20:23:37,486][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-06 20:23:37,486][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-06 20:25:09,759][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.21309757232666, 'accuracy': 0.5647058823529412, 'num_samples': 425, 'test_unique_accuracy': 0.5162037037037037, 'test_unique_num_samples': 432} +[2026-04-06 20:25:09,759][__main__][INFO] - ========== EVAL END (periodic@gstep=4800) ========== +[2026-04-06 20:25:09,759][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.216730117797852, 'accuracy': 0.5647058823529412, 'num_samples': 425, 'test_unique_accuracy': 0.5162037037037037, 'test_unique_num_samples': 432} +[2026-04-06 20:25:09,762][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.5647058823529412 is not better than 0.5694117647058824 of logs/lrm/reward_model/step_sana_sana_sprint_0_6b_1024_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep4400, skipping checkpoint +[2026-04-06 20:26:16,369][trainer.accelerators.base_accelerator][INFO] - Training progress: step=4850/8000 (60.62%), epoch=0, lr=5e-05, speed=0.389 step/s, elapsed=03:27:44, eta=02:14:55 +[2026-04-06 20:27:23,416][trainer.accelerators.base_accelerator][INFO] - Training progress: step=4900/8000 (61.25%), epoch=0, lr=5e-05, speed=0.391 step/s, elapsed=03:28:51, eta=02:12:08 +[2026-04-06 20:27:23,524][__main__][INFO] - ========== EVAL START (periodic@gstep=4900) ========== +[2026-04-06 20:27:23,524][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-06 20:27:23,524][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-06 20:28:56,207][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.216730117797852, 'accuracy': 0.5105882352941177, 'num_samples': 425, 'test_unique_accuracy': 0.5162037037037037, 'test_unique_num_samples': 432} +[2026-04-06 20:28:56,207][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-06 20:28:56,207][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-06 20:29:48,145][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.216730117797852, 'accuracy': 0.5105882352941177, 'num_samples': 425, 'test_unique_accuracy': 0.5254629629629629, 'test_unique_num_samples': 432} +[2026-04-06 20:29:48,145][__main__][INFO] - ========== EVAL END (periodic@gstep=4900) ========== +[2026-04-06 20:29:48,147][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.208184242248535, 'accuracy': 0.5105882352941177, 'num_samples': 425, 'test_unique_accuracy': 0.5254629629629629, 'test_unique_num_samples': 432} +[2026-04-06 20:29:48,149][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.5105882352941177 is not better than 0.548235294117647 of logs/lrm/reward_model/step_sana_sana_sprint_0_6b_1024_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep1600, skipping checkpoint +[2026-04-06 20:30:55,862][trainer.accelerators.base_accelerator][INFO] - Training progress: step=4950/8000 (61.88%), epoch=0, lr=5e-05, speed=0.388 step/s, elapsed=03:32:24, eta=02:10:52 +[2026-04-06 20:32:02,527][trainer.accelerators.base_accelerator][INFO] - Training progress: step=5000/8000 (62.50%), epoch=0, lr=5e-05, speed=0.390 step/s, elapsed=03:33:31, eta=02:08:06 +[2026-04-06 20:32:02,630][__main__][INFO] - ========== EVAL START (periodic@gstep=5000) ========== +[2026-04-06 20:32:02,630][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-06 20:32:02,630][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-06 20:33:32,631][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.208184242248535, 'accuracy': 0.48, 'num_samples': 425, 'test_unique_accuracy': 0.5254629629629629, 'test_unique_num_samples': 432} +[2026-04-06 20:33:32,632][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-06 20:33:32,632][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-06 20:35:04,754][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.208184242248535, 'accuracy': 0.48, 'num_samples': 425, 'test_unique_accuracy': 0.5046296296296297, 'test_unique_num_samples': 432} +[2026-04-06 20:35:04,754][__main__][INFO] - ========== EVAL END (periodic@gstep=5000) ========== +[2026-04-06 20:35:04,756][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.205854415893555, 'accuracy': 0.48, 'num_samples': 425, 'test_unique_accuracy': 0.5046296296296297, 'test_unique_num_samples': 432} +[2026-04-06 20:35:04,758][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.48 is not better than 0.548235294117647 of logs/lrm/reward_model/step_sana_sana_sprint_0_6b_1024_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep1600, skipping checkpoint +[2026-04-06 20:36:11,349][trainer.accelerators.base_accelerator][INFO] - Training progress: step=5050/8000 (63.12%), epoch=0, lr=5e-05, speed=0.387 step/s, elapsed=03:37:39, eta=02:07:09 +[2026-04-06 20:37:17,720][trainer.accelerators.base_accelerator][INFO] - Training progress: step=5100/8000 (63.75%), epoch=0, lr=5e-05, speed=0.389 step/s, elapsed=03:38:46, eta=02:04:23 +[2026-04-06 20:37:17,822][__main__][INFO] - ========== EVAL START (periodic@gstep=5100) ========== +[2026-04-06 20:37:17,823][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-06 20:37:17,823][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-06 20:38:48,136][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.205854415893555, 'accuracy': 0.5176470588235295, 'num_samples': 425, 'test_unique_accuracy': 0.5046296296296297, 'test_unique_num_samples': 432} +[2026-04-06 20:38:48,136][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-06 20:38:48,136][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-06 20:40:23,745][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.205854415893555, 'accuracy': 0.5176470588235295, 'num_samples': 425, 'test_unique_accuracy': 0.5092592592592593, 'test_unique_num_samples': 432} +[2026-04-06 20:40:23,745][__main__][INFO] - ========== EVAL END (periodic@gstep=5100) ========== +[2026-04-06 20:40:23,747][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.209424018859863, 'accuracy': 0.5176470588235295, 'num_samples': 425, 'test_unique_accuracy': 0.5092592592592593, 'test_unique_num_samples': 432} +[2026-04-06 20:40:23,749][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.5176470588235295 is not better than 0.548235294117647 of logs/lrm/reward_model/step_sana_sana_sprint_0_6b_1024_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep1600, skipping checkpoint +[2026-04-06 20:41:30,823][trainer.accelerators.base_accelerator][INFO] - Training progress: step=5150/8000 (64.38%), epoch=0, lr=5e-05, speed=0.385 step/s, elapsed=03:42:59, eta=02:03:24 +[2026-04-06 20:42:36,858][trainer.accelerators.base_accelerator][INFO] - Training progress: step=5200/8000 (65.00%), epoch=0, lr=5e-05, speed=0.387 step/s, elapsed=03:44:05, eta=02:00:39 +[2026-04-06 20:42:36,962][__main__][INFO] - ========== EVAL START (periodic@gstep=5200) ========== +[2026-04-06 20:42:36,962][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-06 20:42:36,962][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-06 20:44:07,073][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.209424018859863, 'accuracy': 0.5223529411764706, 'num_samples': 425, 'test_unique_accuracy': 0.5092592592592593, 'test_unique_num_samples': 432} +[2026-04-06 20:44:07,073][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-06 20:44:07,073][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-06 20:45:43,464][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.209424018859863, 'accuracy': 0.5223529411764706, 'num_samples': 425, 'test_unique_accuracy': 0.49537037037037035, 'test_unique_num_samples': 432} +[2026-04-06 20:45:43,464][__main__][INFO] - ========== EVAL END (periodic@gstep=5200) ========== +[2026-04-06 20:45:43,465][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.205193519592285, 'accuracy': 0.5223529411764706, 'num_samples': 425, 'test_unique_accuracy': 0.49537037037037035, 'test_unique_num_samples': 432} +[2026-04-06 20:45:43,467][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.5223529411764706 is not better than 0.548235294117647 of logs/lrm/reward_model/step_sana_sana_sprint_0_6b_1024_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep1600, skipping checkpoint +[2026-04-06 20:46:50,661][trainer.accelerators.base_accelerator][INFO] - Training progress: step=5250/8000 (65.62%), epoch=0, lr=5e-05, speed=0.383 step/s, elapsed=03:48:19, eta=01:59:35 +[2026-04-06 20:47:56,823][trainer.accelerators.base_accelerator][INFO] - Training progress: step=5300/8000 (66.25%), epoch=0, lr=5e-05, speed=0.385 step/s, elapsed=03:49:25, eta=01:56:52 +[2026-04-06 20:47:56,926][__main__][INFO] - ========== EVAL START (periodic@gstep=5300) ========== +[2026-04-06 20:47:56,926][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-06 20:47:56,927][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-06 20:49:31,426][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.205193519592285, 'accuracy': 0.48, 'num_samples': 425, 'test_unique_accuracy': 0.49537037037037035, 'test_unique_num_samples': 432} +[2026-04-06 20:49:31,426][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-06 20:49:31,427][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-06 20:51:08,008][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.205193519592285, 'accuracy': 0.48, 'num_samples': 425, 'test_unique_accuracy': 0.4976851851851852, 'test_unique_num_samples': 432} +[2026-04-06 20:51:08,008][__main__][INFO] - ========== EVAL END (periodic@gstep=5300) ========== +[2026-04-06 20:51:08,009][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.205216407775879, 'accuracy': 0.48, 'num_samples': 425, 'test_unique_accuracy': 0.4976851851851852, 'test_unique_num_samples': 432} +[2026-04-06 20:51:08,012][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.48 is not better than 0.548235294117647 of logs/lrm/reward_model/step_sana_sana_sprint_0_6b_1024_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep1600, skipping checkpoint +[2026-04-06 20:52:14,806][trainer.accelerators.base_accelerator][INFO] - Training progress: step=5350/8000 (66.88%), epoch=0, lr=5e-05, speed=0.382 step/s, elapsed=03:53:43, eta=01:55:46 +[2026-04-06 20:53:21,283][trainer.accelerators.base_accelerator][INFO] - Training progress: step=5400/8000 (67.50%), epoch=0, lr=5e-05, speed=0.383 step/s, elapsed=03:54:49, eta=01:53:03 +[2026-04-06 20:53:21,390][__main__][INFO] - ========== EVAL START (periodic@gstep=5400) ========== +[2026-04-06 20:53:21,390][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-06 20:53:21,390][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-06 20:54:51,808][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.205216407775879, 'accuracy': 0.5341176470588235, 'num_samples': 425, 'test_unique_accuracy': 0.4976851851851852, 'test_unique_num_samples': 432} +[2026-04-06 20:54:51,808][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-06 20:54:51,808][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-06 20:56:28,224][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.205216407775879, 'accuracy': 0.5341176470588235, 'num_samples': 425, 'test_unique_accuracy': 0.4976851851851852, 'test_unique_num_samples': 432} +[2026-04-06 20:56:28,224][__main__][INFO] - ========== EVAL END (periodic@gstep=5400) ========== +[2026-04-06 20:56:28,227][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.203723907470703, 'accuracy': 0.5341176470588235, 'num_samples': 425, 'test_unique_accuracy': 0.4976851851851852, 'test_unique_num_samples': 432} +[2026-04-06 20:56:28,228][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.5341176470588235 is not better than 0.548235294117647 of logs/lrm/reward_model/step_sana_sana_sprint_0_6b_1024_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep1600, skipping checkpoint +[2026-04-06 20:57:35,313][trainer.accelerators.base_accelerator][INFO] - Training progress: step=5450/8000 (68.12%), epoch=0, lr=5e-05, speed=0.380 step/s, elapsed=03:59:03, eta=01:51:51 +[2026-04-06 20:58:41,626][trainer.accelerators.base_accelerator][INFO] - Training progress: step=5500/8000 (68.75%), epoch=0, lr=5e-05, speed=0.382 step/s, elapsed=04:00:10, eta=01:49:10 +[2026-04-06 20:58:41,731][__main__][INFO] - ========== EVAL START (periodic@gstep=5500) ========== +[2026-04-06 20:58:41,731][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-06 20:58:41,732][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-06 21:00:16,113][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.203723907470703, 'accuracy': 0.48705882352941177, 'num_samples': 425, 'test_unique_accuracy': 0.4976851851851852, 'test_unique_num_samples': 432} +[2026-04-06 21:00:16,113][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-06 21:00:16,113][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-06 21:01:52,704][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.203723907470703, 'accuracy': 0.48705882352941177, 'num_samples': 425, 'test_unique_accuracy': 0.5324074074074074, 'test_unique_num_samples': 432} +[2026-04-06 21:01:52,704][__main__][INFO] - ========== EVAL END (periodic@gstep=5500) ========== +[2026-04-06 21:01:52,705][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.220096588134766, 'accuracy': 0.48705882352941177, 'num_samples': 425, 'test_unique_accuracy': 0.5324074074074074, 'test_unique_num_samples': 432} +[2026-04-06 21:01:52,707][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.48705882352941177 is not better than 0.548235294117647 of logs/lrm/reward_model/step_sana_sana_sprint_0_6b_1024_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep1600, skipping checkpoint +[2026-04-06 21:02:59,549][trainer.accelerators.base_accelerator][INFO] - Training progress: step=5550/8000 (69.38%), epoch=0, lr=5e-05, speed=0.378 step/s, elapsed=04:04:28, eta=01:47:55 +[2026-04-06 21:04:05,882][trainer.accelerators.base_accelerator][INFO] - Training progress: step=5600/8000 (70.00%), epoch=0, lr=5e-05, speed=0.380 step/s, elapsed=04:05:34, eta=01:45:14 +[2026-04-06 21:04:05,987][__main__][INFO] - ========== EVAL START (periodic@gstep=5600) ========== +[2026-04-06 21:04:05,987][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-06 21:04:05,987][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-06 21:05:40,200][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.220096588134766, 'accuracy': 0.5129411764705882, 'num_samples': 425, 'test_unique_accuracy': 0.5324074074074074, 'test_unique_num_samples': 432} +[2026-04-06 21:05:40,201][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-06 21:05:40,201][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-06 21:07:12,424][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.220096588134766, 'accuracy': 0.5129411764705882, 'num_samples': 425, 'test_unique_accuracy': 0.5185185185185185, 'test_unique_num_samples': 432} +[2026-04-06 21:07:12,424][__main__][INFO] - ========== EVAL END (periodic@gstep=5600) ========== +[2026-04-06 21:07:12,426][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.206604957580566, 'accuracy': 0.5129411764705882, 'num_samples': 425, 'test_unique_accuracy': 0.5185185185185185, 'test_unique_num_samples': 432} +[2026-04-06 21:07:12,427][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.5129411764705882 is not better than 0.548235294117647 of logs/lrm/reward_model/step_sana_sana_sprint_0_6b_1024_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep1600, skipping checkpoint +[2026-04-06 21:08:19,288][trainer.accelerators.base_accelerator][INFO] - Training progress: step=5650/8000 (70.62%), epoch=0, lr=5e-05, speed=0.377 step/s, elapsed=04:09:47, eta=01:43:53 +[2026-04-06 21:09:25,988][trainer.accelerators.base_accelerator][INFO] - Training progress: step=5700/8000 (71.25%), epoch=0, lr=5e-05, speed=0.379 step/s, elapsed=04:10:54, eta=01:41:14 +[2026-04-06 21:09:26,092][__main__][INFO] - ========== EVAL START (periodic@gstep=5700) ========== +[2026-04-06 21:09:26,092][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-06 21:09:26,092][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-06 21:11:00,659][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.206604957580566, 'accuracy': 0.5529411764705883, 'num_samples': 425, 'test_unique_accuracy': 0.5185185185185185, 'test_unique_num_samples': 432} +[2026-04-06 21:11:00,660][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-06 21:11:00,660][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-06 21:12:32,638][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.206604957580566, 'accuracy': 0.5529411764705883, 'num_samples': 425, 'test_unique_accuracy': 0.5370370370370371, 'test_unique_num_samples': 432} +[2026-04-06 21:12:32,638][__main__][INFO] - ========== EVAL END (periodic@gstep=5700) ========== +[2026-04-06 21:12:32,640][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.206852912902832, 'accuracy': 0.5529411764705883, 'num_samples': 425, 'test_unique_accuracy': 0.5370370370370371, 'test_unique_num_samples': 432} +[2026-04-06 21:12:32,643][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.5529411764705883 is not better than 0.5694117647058824 of logs/lrm/reward_model/step_sana_sana_sprint_0_6b_1024_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep4400, skipping checkpoint +[2026-04-06 21:13:39,429][trainer.accelerators.base_accelerator][INFO] - Training progress: step=5750/8000 (71.88%), epoch=0, lr=5e-05, speed=0.376 step/s, elapsed=04:15:07, eta=01:39:50 +[2026-04-06 21:14:45,836][trainer.accelerators.base_accelerator][INFO] - Training progress: step=5800/8000 (72.50%), epoch=0, lr=5e-05, speed=0.377 step/s, elapsed=04:16:14, eta=01:37:11 +[2026-04-06 21:14:45,945][__main__][INFO] - ========== EVAL START (periodic@gstep=5800) ========== +[2026-04-06 21:14:45,945][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-06 21:14:45,945][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-06 21:16:16,450][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.206852912902832, 'accuracy': 0.52, 'num_samples': 425, 'test_unique_accuracy': 0.5370370370370371, 'test_unique_num_samples': 432} +[2026-04-06 21:16:16,451][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-06 21:16:16,451][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-06 21:17:50,331][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.206852912902832, 'accuracy': 0.52, 'num_samples': 425, 'test_unique_accuracy': 0.5092592592592593, 'test_unique_num_samples': 432} +[2026-04-06 21:17:50,331][__main__][INFO] - ========== EVAL END (periodic@gstep=5800) ========== +[2026-04-06 21:17:50,331][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.210890769958496, 'accuracy': 0.52, 'num_samples': 425, 'test_unique_accuracy': 0.5092592592592593, 'test_unique_num_samples': 432} +[2026-04-06 21:17:50,333][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.52 is not better than 0.548235294117647 of logs/lrm/reward_model/step_sana_sana_sprint_0_6b_1024_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep1600, skipping checkpoint diff --git a/lrm/lrm_sana/logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/.hydra/config.yaml b/lrm/lrm_sana/logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/.hydra/config.yaml new file mode 100644 index 0000000000000000000000000000000000000000..378b47fdbb441e67817f6aa517f1f6fe3e5d2a97 --- /dev/null +++ b/lrm/lrm_sana/logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/.hydra/config.yaml @@ -0,0 +1,126 @@ +accelerator: + _target_: trainer.accelerators.debug_accelerator.DebugAccelerator + output_dir: ${output_dir} + mixed_precision: BF16 + gradient_accumulation_steps: 1 + log_with: null + debug: + activate: false + port: 5900 + seed: 42 + resume_from_checkpoint: true + max_steps: 100000 + num_epochs: 10 + validate_steps: 1000 + generalization_validate_steps: 500 + eval_on_start: false + project_name: reward_model + run_name: step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951 + max_grad_norm: 1.0 + save_steps: ${accelerator.validate_steps} + metric_name: accuracy + metric_mode: MAX + limit_num_checkpoints: 1 + save_only_if_best: true + dynamo_backend: 'NO' + keep_best_ckpts: true + progress_log_interval: 50 +task: + limit_examples_to_wandb: 50 + _target_: trainer.tasks.step_sana_task.StepSanaTask + pretrained_model_name_or_path: ${model.pretrained_model_name_or_path} + tokenizer_subfolder: tokenizer + label_0_column_name: ${dataset.label_0_column_name} + label_1_column_name: ${dataset.label_1_column_name} + input_ids_column_name: ${dataset.input_ids_column_name} + input_ids_2_column_name: ${dataset.input_ids_2_column_name} + pixels_0_column_name: ${dataset.pixels_0_column_name} + pixels_1_column_name: ${dataset.pixels_1_column_name} + timestep_column_name: ${dataset.timestep_column_name} + constant_timestep: ${dataset.constant_timestep} +model: + _target_: trainer.models.sana_preference_model.SanaPreferenceModel + pretrained_model_name_or_path: Efficient-Large-Model/Sana_600M_512px_diffusers + pretrained_vae_name_or_path: '' + model_profile: sana_600m_512 + projection_dim: 1024 + logit_scale_init_value: 2.6592 + freeze_text_encoder: true + guidance_scale: 2.5 + noise_offset: false + noise_offset_coeff: 0.05 + max_sequence_length: 300 + max_sequence_length_2: 300 + image_size: 512 +criterion: + _target_: trainer.criterions.step_clip_criterion_sana.StepSanaCLIPCriterion + is_distributed: false + label_0_column_name: ${dataset.label_0_column_name} + label_1_column_name: ${dataset.label_1_column_name} + input_ids_column_name: ${dataset.input_ids_column_name} + input_ids_2_column_name: ${dataset.input_ids_2_column_name} + pixels_0_column_name: ${dataset.pixels_0_column_name} + pixels_1_column_name: ${dataset.pixels_1_column_name} + num_examples_per_prompt_column_name: ${dataset.num_examples_per_prompt_column_name} + timestep_column_name: ${dataset.timestep_column_name} + loss_type: pair + batch_coeff: 1.0 + aux_loss_coeff: 1.0 +dataset: + train_split_name: train + valid_split_name: validation_unique + test_split_name: test_unique + batch_size: 4 + num_workers: 2 + drop_last: true + _target_: trainer.datasets.step_sana_hf_dataset.StepSanaHFDataset + dataset_name: pickapic-anonymous/pickapic_v1 + dataset_config_name: null + from_disk: false + cache_dir: null + caption_column_name: caption + input_ids_column_name: input_ids + input_ids_2_column_name: input_ids_2 + image_0_column_name: jpg_0 + image_1_column_name: jpg_1 + label_0_column_name: label_0 + label_1_column_name: label_1 + are_different_column_name: are_different + has_label_column_name: has_label + pixels_0_column_name: pixel_values_0 + pixels_1_column_name: pixel_values_1 + timestep_column_name: timestep + constant_timestep: 1 + variable_timestep: true + largest_timestep: 951 + compare_between_timestep: false + timestep_comparison_column_name: timestep_comparison + timestep_interval: 1 + num_examples_per_prompt_column_name: num_example_per_prompt + keep_only_different: false + keep_only_with_label: false + keep_only_with_label_in_non_train: true + keep_only_with_pesudo_preference: true + pseudo_preference_path: /g/data/rr81/LPO/lrm/lrm_sana/vqa_aes_clip_score_mp.csv + filter_strategy: 2 + processor: + pretrained_model_name_or_path: ${model.pretrained_model_name_or_path} + max_sequence_length: ${model.max_sequence_length} + max_sequence_length_2: ${model.max_sequence_length_2} + image_size: ${model.image_size} + random_crop: false + no_hflip: true + limit_examples_per_prompt: -1 + only_on_best: false +optimizer: + _target_: trainer.optimizers.adamw.BaseAdamW + lr: 1.0e-05 +lr_scheduler: + _target_: trainer.lr_schedulers.constant_with_warmup.instantiate_dummy_lr_scheduler + lr: ${optimizer.lr} + lr_warmup_steps: 1000 + total_num_steps: ${accelerator.max_steps} +debug: + activate: false + port: 5900 +output_dir: logs/v7/${accelerator.project_name}/${accelerator.run_name} diff --git a/lrm/lrm_sana/logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/.hydra/hydra.yaml b/lrm/lrm_sana/logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/.hydra/hydra.yaml new file mode 100644 index 0000000000000000000000000000000000000000..90082046c5fe39d3b0129965d42e94a9d14de2eb --- /dev/null +++ b/lrm/lrm_sana/logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/.hydra/hydra.yaml @@ -0,0 +1,172 @@ +hydra: + run: + dir: ${output_dir} + sweep: + dir: multirun/${now:%Y-%m-%d}/${now:%H-%M-%S} + subdir: ${hydra.job.num} + launcher: + _target_: hydra._internal.core_plugins.basic_launcher.BasicLauncher + sweeper: + _target_: hydra._internal.core_plugins.basic_sweeper.BasicSweeper + max_batch_size: null + params: null + help: + app_name: ${hydra.job.name} + header: '${hydra.help.app_name} is powered by Hydra. + + ' + footer: 'Powered by Hydra (https://hydra.cc) + + Use --hydra-help to view Hydra specific help + + ' + template: '${hydra.help.header} + + == Configuration groups == + + Compose your configuration from those groups (group=option) + + + $APP_CONFIG_GROUPS + + + == Config == + + Override anything in the config (foo.bar=value) + + + $CONFIG + + + ${hydra.help.footer} + + ' + hydra_help: + template: 'Hydra (${hydra.runtime.version}) + + See https://hydra.cc for more info. + + + == Flags == + + $FLAGS_HELP + + + == Configuration groups == + + Compose your configuration from those groups (For example, append hydra/job_logging=disabled + to command line) + + + $HYDRA_CONFIG_GROUPS + + + Use ''--cfg hydra'' to Show the Hydra config. + + ' + hydra_help: ??? + hydra_logging: + version: 1 + formatters: + simple: + format: '[%(asctime)s][HYDRA] %(message)s' + handlers: + console: + class: logging.StreamHandler + formatter: simple + stream: ext://sys.stdout + root: + level: INFO + handlers: + - console + loggers: + logging_example: + level: DEBUG + disable_existing_loggers: false + job_logging: + version: 1 + formatters: + simple: + format: '[%(asctime)s][%(name)s][%(levelname)s] - %(message)s' + handlers: + console: + class: logging.StreamHandler + formatter: simple + stream: ext://sys.stdout + file: + class: logging.FileHandler + formatter: simple + filename: ${hydra.runtime.output_dir}/${hydra.job.name}.log + root: + level: INFO + handlers: + - console + - file + disable_existing_loggers: false + env: {} + mode: RUN + searchpath: [] + callbacks: {} + output_subdir: .hydra + overrides: + hydra: + - hydra.mode=RUN + task: + - accelerator.mixed_precision=BF16 + - model.model_profile=sana_600m_512 + - model.pretrained_model_name_or_path=Efficient-Large-Model/Sana_600M_512px_diffusers + - model.image_size=512 + - accelerator.run_name=step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951 + - accelerator.log_with=null + - accelerator=debug + - criterion.is_distributed=false + - dataset.pseudo_preference_path=/g/data/rr81/LPO/lrm/lrm_sana/vqa_aes_clip_score_mp.csv + - dataset.valid_split_name=validation_unique + - dataset.test_split_name=test_unique + job: + name: train + chdir: null + override_dirname: accelerator.log_with=null,accelerator.mixed_precision=BF16,accelerator.run_name=step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951,accelerator=debug,criterion.is_distributed=false,dataset.pseudo_preference_path=/g/data/rr81/LPO/lrm/lrm_sana/vqa_aes_clip_score_mp.csv,dataset.test_split_name=test_unique,dataset.valid_split_name=validation_unique,model.image_size=512,model.model_profile=sana_600m_512,model.pretrained_model_name_or_path=Efficient-Large-Model/Sana_600M_512px_diffusers + id: ??? + num: ??? + config_name: step_sana_base + env_set: {} + env_copy: [] + config: + override_dirname: + kv_sep: '=' + item_sep: ',' + exclude_keys: [] + runtime: + version: 1.3.2 + version_base: '1.3' + cwd: /g/data/rr81/LPO/lrm/lrm_sana + config_sources: + - path: hydra.conf + schema: pkg + provider: hydra + - path: /g/data/rr81/LPO/lrm/lrm_sana/trainer/conf + schema: file + provider: main + - path: '' + schema: structured + provider: schema + output_dir: /g/data/rr81/LPO/lrm/lrm_sana/logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951 + choices: + lr_scheduler: constant_with_warmup + optimizer: adamw + dataset: step_sana + criterion: step_clip_sana + model: step_sana_base + task: step_sana + accelerator: debug + hydra/env: default + hydra/callbacks: null + hydra/job_logging: default + hydra/hydra_logging: default + hydra/hydra_help: default + hydra/help: default + hydra/sweeper: basic + hydra/launcher: basic + hydra/output: default + verbose: false diff --git a/lrm/lrm_sana/logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/.hydra/overrides.yaml b/lrm/lrm_sana/logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/.hydra/overrides.yaml new file mode 100644 index 0000000000000000000000000000000000000000..70b5f1288287baf490e700a136bba21d4f0c18d7 --- /dev/null +++ b/lrm/lrm_sana/logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/.hydra/overrides.yaml @@ -0,0 +1,11 @@ +- accelerator.mixed_precision=BF16 +- model.model_profile=sana_600m_512 +- model.pretrained_model_name_or_path=Efficient-Large-Model/Sana_600M_512px_diffusers +- model.image_size=512 +- accelerator.run_name=step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951 +- accelerator.log_with=null +- accelerator=debug +- criterion.is_distributed=false +- dataset.pseudo_preference_path=/g/data/rr81/LPO/lrm/lrm_sana/vqa_aes_clip_score_mp.csv +- dataset.valid_split_name=validation_unique +- dataset.test_split_name=test_unique diff --git a/lrm/lrm_sana/logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-final/training_stage.json b/lrm/lrm_sana/logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-final/training_stage.json new file mode 100644 index 0000000000000000000000000000000000000000..ff7b0333cabbf14feb04b75850658df627790177 --- /dev/null +++ b/lrm/lrm_sana/logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-final/training_stage.json @@ -0,0 +1,14 @@ +{ + "epoch": 2, + "step": 11462, + "global_step": 100000, + "step_loss": 0.0, + "lr": 1e-05, + "metrics": { + "logit_scale": 14.118317604064941, + "accuracy": 0.5270588235294118, + "num_samples": 425, + "test_unique_accuracy": 0.49074074074074076, + "test_unique_num_samples": 432 + } +} \ No newline at end of file diff --git a/lrm/lrm_sana/logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-final/transformer/config.json b/lrm/lrm_sana/logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-final/transformer/config.json new file mode 100644 index 0000000000000000000000000000000000000000..d3a24a14e0aff9a6e41a16a821f56257ff8ab814 --- /dev/null +++ b/lrm/lrm_sana/logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-final/transformer/config.json @@ -0,0 +1,26 @@ +{ + "_class_name": "SanaTransformer2DModel", + "_diffusers_version": "0.36.0", + "_name_or_path": "Efficient-Large-Model/Sana_600M_512px_diffusers", + "attention_bias": false, + "attention_head_dim": 32, + "caption_channels": 2304, + "cross_attention_dim": 1152, + "cross_attention_head_dim": 72, + "dropout": 0.0, + "guidance_embeds": false, + "guidance_embeds_scale": 0.1, + "in_channels": 32, + "interpolation_scale": null, + "mlp_ratio": 2.5, + "norm_elementwise_affine": false, + "norm_eps": 1e-06, + "num_attention_heads": 36, + "num_cross_attention_heads": 16, + "num_layers": 28, + "out_channels": 32, + "patch_size": 1, + "qk_norm": null, + "sample_size": 16, + "timestep_scale": 1.0 +} diff --git a/lrm/lrm_sana/logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep1000/training_stage.json b/lrm/lrm_sana/logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep1000/training_stage.json new file mode 100644 index 0000000000000000000000000000000000000000..2111e0e471a8ba4dc21052cb35897431d2071942 --- /dev/null +++ b/lrm/lrm_sana/logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep1000/training_stage.json @@ -0,0 +1,14 @@ +{ + "epoch": 0, + "step": 1000, + "global_step": 1000, + "step_loss": 0.0, + "lr": 1e-05, + "metrics": { + "logit_scale": 14.279633522033691, + "accuracy": 0.48705882352941177, + "num_samples": 425, + "test_unique_accuracy": 0.5231481481481481, + "test_unique_num_samples": 432 + } +} \ No newline at end of file diff --git a/lrm/lrm_sana/logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep2000/training_stage.json b/lrm/lrm_sana/logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep2000/training_stage.json new file mode 100644 index 0000000000000000000000000000000000000000..8ec4aa3e28ab36f490f92b6993de95c6f387e6fb --- /dev/null +++ b/lrm/lrm_sana/logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep2000/training_stage.json @@ -0,0 +1,14 @@ +{ + "epoch": 0, + "step": 2000, + "global_step": 2000, + "step_loss": 0.0, + "lr": 1e-05, + "metrics": { + "logit_scale": 14.268759727478027, + "accuracy": 0.52, + "num_samples": 425, + "test_unique_accuracy": 0.46296296296296297, + "test_unique_num_samples": 432 + } +} \ No newline at end of file diff --git a/lrm/lrm_sana/logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep32000/training_stage.json b/lrm/lrm_sana/logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep32000/training_stage.json new file mode 100644 index 0000000000000000000000000000000000000000..2632da164dd7257b8f7d14411ab7bbd32096a53f --- /dev/null +++ b/lrm/lrm_sana/logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep32000/training_stage.json @@ -0,0 +1,14 @@ +{ + "epoch": 0, + "step": 32000, + "global_step": 32000, + "step_loss": 0.0, + "lr": 1e-05, + "metrics": { + "logit_scale": 14.1469144821167, + "accuracy": 0.5788235294117647, + "num_samples": 425, + "test_unique_accuracy": 0.5115740740740741, + "test_unique_num_samples": 432 + } +} \ No newline at end of file diff --git a/lrm/lrm_sana/logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/config.yaml b/lrm/lrm_sana/logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/config.yaml new file mode 100644 index 0000000000000000000000000000000000000000..2050a32d169b0affbf0b47970ee5fd46f4499049 --- /dev/null +++ b/lrm/lrm_sana/logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/config.yaml @@ -0,0 +1,126 @@ +accelerator: + _target_: trainer.accelerators.debug_accelerator.DebugAccelerator + output_dir: logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951 + mixed_precision: BF16 + gradient_accumulation_steps: 1 + log_with: null + debug: + activate: false + port: 5900 + seed: 42 + resume_from_checkpoint: true + max_steps: 100000 + num_epochs: 10 + validate_steps: 1000 + generalization_validate_steps: 500 + eval_on_start: false + project_name: reward_model + run_name: step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951 + max_grad_norm: 1.0 + save_steps: 1000 + metric_name: accuracy + metric_mode: MAX + limit_num_checkpoints: 1 + save_only_if_best: true + dynamo_backend: 'NO' + keep_best_ckpts: true + progress_log_interval: 50 +task: + limit_examples_to_wandb: 50 + _target_: trainer.tasks.step_sana_task.StepSanaTask + pretrained_model_name_or_path: Efficient-Large-Model/Sana_600M_512px_diffusers + tokenizer_subfolder: tokenizer + label_0_column_name: label_0 + label_1_column_name: label_1 + input_ids_column_name: input_ids + input_ids_2_column_name: input_ids_2 + pixels_0_column_name: pixel_values_0 + pixels_1_column_name: pixel_values_1 + timestep_column_name: timestep + constant_timestep: 1 +model: + _target_: trainer.models.sana_preference_model.SanaPreferenceModel + pretrained_model_name_or_path: Efficient-Large-Model/Sana_600M_512px_diffusers + pretrained_vae_name_or_path: '' + model_profile: sana_600m_512 + projection_dim: 1024 + logit_scale_init_value: 2.6592 + freeze_text_encoder: true + guidance_scale: 2.5 + noise_offset: false + noise_offset_coeff: 0.05 + max_sequence_length: 300 + max_sequence_length_2: 300 + image_size: 512 +criterion: + _target_: trainer.criterions.step_clip_criterion_sana.StepSanaCLIPCriterion + is_distributed: false + label_0_column_name: label_0 + label_1_column_name: label_1 + input_ids_column_name: input_ids + input_ids_2_column_name: input_ids_2 + pixels_0_column_name: pixel_values_0 + pixels_1_column_name: pixel_values_1 + num_examples_per_prompt_column_name: num_example_per_prompt + timestep_column_name: timestep + loss_type: pair + batch_coeff: 1.0 + aux_loss_coeff: 1.0 +dataset: + train_split_name: train + valid_split_name: validation_unique + test_split_name: test_unique + batch_size: 4 + num_workers: 2 + drop_last: true + _target_: trainer.datasets.step_sana_hf_dataset.StepSanaHFDataset + dataset_name: pickapic-anonymous/pickapic_v1 + dataset_config_name: null + from_disk: false + cache_dir: null + caption_column_name: caption + input_ids_column_name: input_ids + input_ids_2_column_name: input_ids_2 + image_0_column_name: jpg_0 + image_1_column_name: jpg_1 + label_0_column_name: label_0 + label_1_column_name: label_1 + are_different_column_name: are_different + has_label_column_name: has_label + pixels_0_column_name: pixel_values_0 + pixels_1_column_name: pixel_values_1 + timestep_column_name: timestep + constant_timestep: 1 + variable_timestep: true + largest_timestep: 951 + compare_between_timestep: false + timestep_comparison_column_name: timestep_comparison + timestep_interval: 1 + num_examples_per_prompt_column_name: num_example_per_prompt + keep_only_different: false + keep_only_with_label: false + keep_only_with_label_in_non_train: true + keep_only_with_pesudo_preference: true + pseudo_preference_path: /g/data/rr81/LPO/lrm/lrm_sana/vqa_aes_clip_score_mp.csv + filter_strategy: 2 + processor: + pretrained_model_name_or_path: Efficient-Large-Model/Sana_600M_512px_diffusers + max_sequence_length: 300 + max_sequence_length_2: 300 + image_size: 512 + random_crop: false + no_hflip: true + limit_examples_per_prompt: -1 + only_on_best: false +optimizer: + _target_: trainer.optimizers.adamw.BaseAdamW + lr: 1.0e-05 +lr_scheduler: + _target_: trainer.lr_schedulers.constant_with_warmup.instantiate_dummy_lr_scheduler + lr: 1.0e-05 + lr_warmup_steps: 1000 + total_num_steps: 100000 +debug: + activate: false + port: 5900 +output_dir: logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951 diff --git a/lrm/lrm_sana/logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/train.log b/lrm/lrm_sana/logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/train.log new file mode 100644 index 0000000000000000000000000000000000000000..1991d523456c8b2cb57ad35af3a042e0c4cbc887 --- /dev/null +++ b/lrm/lrm_sana/logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/train.log @@ -0,0 +1,3102 @@ +[2026-04-15 05:34:28,916][accelerate.utils.other][WARNING] - Detected kernel version 4.18.0, which is below the recommended minimum of 5.5.0; this can cause the process to hang. It is recommended to upgrade the kernel to the minimum version or higher. +[2026-04-15 05:34:28,918][trainer.accelerators.base_accelerator][INFO] - Setting seed 42 +[2026-04-15 05:34:29,296][trainer.accelerators.base_accelerator][INFO] - Initialized accelerator: rank=0 +[2026-04-15 05:34:29,341][__main__][INFO] - Config can be found in logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/config.yaml +[2026-04-15 05:34:29,341][__main__][INFO] - Loading task +[2026-04-15 05:34:30,923][__main__][INFO] - Loading model +[2026-04-15 05:34:44,996][__main__][INFO] - Loading criterion +[2026-04-15 05:34:44,996][__main__][INFO] - Loading optimizer +[2026-04-15 05:34:45,005][__main__][INFO] - Loading lr scheduler +[2026-04-15 05:34:45,006][__main__][INFO] - Loading dataloaders +[2026-04-15 05:34:45,006][trainer.datasets.step_sana_hf_dataset][INFO] - Using step-aware datasets +[2026-04-15 05:34:45,006][trainer.datasets.step_sana_hf_dataset][INFO] - Loading train dataset +[2026-04-15 05:34:45,006][trainer.datasets.step_sana_hf_dataset][INFO] - Batch size is 4 +[2026-04-15 05:34:45,030][trainer.datasets.step_sana_hf_dataset][INFO] - Loading cached offline split 'train' from 387 parquet shards +[2026-04-15 05:34:51,679][trainer.datasets.step_sana_hf_dataset][INFO] - Loaded 583747 examples from train dataset +[2026-04-15 05:34:52,704][trainer.datasets.step_sana_hf_dataset][INFO] - Keeping only examples with pesudo preference, filter_strategy: 2 +[2026-04-15 05:34:52,733][trainer.datasets.step_sana_hf_dataset][INFO] - Loaded 583747 examples from train dataset +[2026-04-15 05:34:53,178][trainer.datasets.step_sana_hf_dataset][INFO] - Kept 177076 examples from train dataset +[2026-04-15 05:34:53,179][trainer.datasets.step_sana_hf_dataset][INFO] - Loaded 177076 examples from train dataset +[2026-04-15 05:34:54,199][trainer.datasets.step_sana_hf_dataset][INFO] - Using step-aware datasets +[2026-04-15 05:34:54,199][trainer.datasets.step_sana_hf_dataset][INFO] - Loading validation_unique dataset +[2026-04-15 05:34:54,199][trainer.datasets.step_sana_hf_dataset][INFO] - Batch size is 4 +[2026-04-15 05:34:54,200][trainer.datasets.step_sana_hf_dataset][INFO] - Loading cached offline split 'validation_unique' from 1 parquet shards +[2026-04-15 05:34:54,317][trainer.datasets.step_sana_hf_dataset][INFO] - Loaded 500 examples from validation_unique dataset +[2026-04-15 05:34:54,318][trainer.datasets.step_sana_hf_dataset][INFO] - Keeping only examples with label in validation_unique split +[2026-04-15 05:34:54,939][trainer.datasets.step_sana_hf_dataset][INFO] - Kept 425 examples from validation_unique dataset +[2026-04-15 05:34:54,940][trainer.datasets.step_sana_hf_dataset][INFO] - Loaded 425 examples from validation_unique dataset +[2026-04-15 05:34:55,982][trainer.datasets.step_sana_hf_dataset][INFO] - Using step-aware datasets +[2026-04-15 05:34:55,982][trainer.datasets.step_sana_hf_dataset][INFO] - Loading test_unique dataset +[2026-04-15 05:34:55,982][trainer.datasets.step_sana_hf_dataset][INFO] - Batch size is 4 +[2026-04-15 05:34:55,983][trainer.datasets.step_sana_hf_dataset][INFO] - Loading cached offline split 'test_unique' from 1 parquet shards +[2026-04-15 05:34:56,121][trainer.datasets.step_sana_hf_dataset][INFO] - Loaded 500 examples from test_unique dataset +[2026-04-15 05:34:56,122][trainer.datasets.step_sana_hf_dataset][INFO] - Keeping only examples with label in test_unique split +[2026-04-15 05:34:56,829][trainer.datasets.step_sana_hf_dataset][INFO] - Kept 432 examples from test_unique dataset +[2026-04-15 05:34:56,830][trainer.datasets.step_sana_hf_dataset][INFO] - Loaded 432 examples from test_unique dataset +[2026-04-15 05:35:09,209][trainer.accelerators.base_accelerator][INFO] - No checkpoint found, training from scratch +[2026-04-15 05:35:09,209][trainer.accelerators.base_accelerator][INFO] - num_update_steps_per_epoch = 44269 +[2026-04-15 05:35:09,209][trainer.accelerators.base_accelerator][INFO] - num_batches = 44269 +[2026-04-15 05:35:09,209][trainer.accelerators.base_accelerator][INFO] - num_epochs = 3 +[2026-04-15 05:35:09,238][trainer.accelerators.base_accelerator][INFO] - Initializing trackers +[2026-04-15 05:35:09,238][trainer.accelerators.base_accelerator][INFO] - Training config: +[2026-04-15 05:35:09,314][trainer.accelerators.base_accelerator][INFO] - nvidia-smi stats: {'gpu_0_mem_used_gb': 7.3779296875} +[2026-04-15 05:35:09,314][trainer.accelerators.base_accelerator][INFO] - ***** Running training ***** +[2026-04-15 05:35:09,314][trainer.accelerators.base_accelerator][INFO] - Instantaneous batch size per device = 4 +[2026-04-15 05:35:09,315][trainer.accelerators.base_accelerator][INFO] - Total train batch size (w. parallel, distributed & accumulation) = 4 +[2026-04-15 05:35:09,315][trainer.accelerators.base_accelerator][INFO] - Gradient Accumulation steps = 1 +[2026-04-15 05:35:09,315][trainer.accelerators.base_accelerator][INFO] - Total warmup steps = 1000 +[2026-04-15 05:35:09,315][trainer.accelerators.base_accelerator][INFO] - Total training steps = 100000 +[2026-04-15 05:35:09,315][trainer.accelerators.base_accelerator][INFO] - Total epochs = 3 +[2026-04-15 05:35:09,315][trainer.accelerators.base_accelerator][INFO] - Steps per epoch = 44269 +[2026-04-15 05:35:09,316][trainer.accelerators.base_accelerator][INFO] - Update steps per epoch = 44269 +[2026-04-15 05:35:09,316][trainer.accelerators.base_accelerator][INFO] - Total optimization steps = 100000 +[2026-04-15 05:35:09,316][trainer.accelerators.base_accelerator][INFO] - Mixed precision = bf16 +[2026-04-15 05:35:09,316][trainer.accelerators.base_accelerator][INFO] - World size = 1 +[2026-04-15 05:35:09,317][__main__][INFO] - task: StepSanaTask +[2026-04-15 05:35:09,318][__main__][INFO] - model: SanaPreferenceModel +[2026-04-15 05:35:09,325][__main__][INFO] - num. model params: 3520M +[2026-04-15 05:35:09,332][__main__][INFO] - num. model trainable params: 594M +[2026-04-15 05:35:09,332][__main__][INFO] - criterion: StepSanaCLIPCriterion +[2026-04-15 05:35:09,333][__main__][INFO] - num. train examples: 177076 +[2026-04-15 05:35:09,333][__main__][INFO] - num. valid examples: 425 +[2026-04-15 05:35:09,333][__main__][INFO] - num. test examples: 432 +[2026-04-15 05:35:09,666][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.284856796264648} +[2026-04-15 05:35:09,667][__main__][INFO] - ========== TRAIN LOOP START (eval_on_start=False, validate_steps=1000, progress_log_interval=50) ========== +[2026-04-15 05:35:26,437][trainer.accelerators.base_accelerator][INFO] - Training progress: step=1/100000 (0.00%), epoch=0, lr=0.0, speed=0.058 step/s, elapsed=00:17, eta=475:34:07 +[2026-04-15 05:35:48,060][trainer.accelerators.base_accelerator][INFO] - Training progress: step=50/100000 (0.05%), epoch=0, lr=5.000000000000001e-07, speed=1.291 step/s, elapsed=00:38, eta=21:30:47 +[2026-04-15 05:36:07,835][trainer.accelerators.base_accelerator][INFO] - Training progress: step=100/100000 (0.10%), epoch=0, lr=1.0000000000000002e-06, speed=1.709 step/s, elapsed=00:58, eta=16:14:20 +[2026-04-15 05:36:27,528][trainer.accelerators.base_accelerator][INFO] - Training progress: step=150/100000 (0.15%), epoch=0, lr=1.5e-06, speed=1.918 step/s, elapsed=01:18, eta=14:27:43 +[2026-04-15 05:36:47,320][trainer.accelerators.base_accelerator][INFO] - Training progress: step=200/100000 (0.20%), epoch=0, lr=2.0000000000000003e-06, speed=2.041 step/s, elapsed=01:38, eta=13:35:04 +[2026-04-15 05:37:07,127][trainer.accelerators.base_accelerator][INFO] - Training progress: step=250/100000 (0.25%), epoch=0, lr=2.5e-06, speed=2.122 step/s, elapsed=01:57, eta=13:03:26 +[2026-04-15 05:37:26,501][trainer.accelerators.base_accelerator][INFO] - Training progress: step=300/100000 (0.30%), epoch=0, lr=3e-06, speed=2.187 step/s, elapsed=02:17, eta=12:39:51 +[2026-04-15 05:37:45,676][trainer.accelerators.base_accelerator][INFO] - Training progress: step=350/100000 (0.35%), epoch=0, lr=3.5e-06, speed=2.238 step/s, elapsed=02:36, eta=12:21:57 +[2026-04-15 05:38:05,101][trainer.accelerators.base_accelerator][INFO] - Training progress: step=400/100000 (0.40%), epoch=0, lr=4.000000000000001e-06, speed=2.276 step/s, elapsed=02:55, eta=12:09:30 +[2026-04-15 05:38:24,181][trainer.accelerators.base_accelerator][INFO] - Training progress: step=450/100000 (0.45%), epoch=0, lr=4.5e-06, speed=2.309 step/s, elapsed=03:14, eta=11:58:28 +[2026-04-15 05:38:42,370][trainer.accelerators.base_accelerator][INFO] - Training progress: step=500/100000 (0.50%), epoch=0, lr=5e-06, speed=2.347 step/s, elapsed=03:33, eta=11:46:37 +[2026-04-15 05:39:00,748][trainer.accelerators.base_accelerator][INFO] - Training progress: step=550/100000 (0.55%), epoch=0, lr=5.500000000000001e-06, speed=2.377 step/s, elapsed=03:51, eta=11:37:27 +[2026-04-15 05:39:19,569][trainer.accelerators.base_accelerator][INFO] - Training progress: step=600/100000 (0.60%), epoch=0, lr=6e-06, speed=2.398 step/s, elapsed=04:10, eta=11:30:58 +[2026-04-15 05:39:37,894][trainer.accelerators.base_accelerator][INFO] - Training progress: step=650/100000 (0.65%), epoch=0, lr=6.5000000000000004e-06, speed=2.420 step/s, elapsed=04:28, eta=11:24:11 +[2026-04-15 05:39:56,232][trainer.accelerators.base_accelerator][INFO] - Training progress: step=700/100000 (0.70%), epoch=0, lr=7e-06, speed=2.440 step/s, elapsed=04:46, eta=11:18:21 +[2026-04-15 05:40:14,210][trainer.accelerators.base_accelerator][INFO] - Training progress: step=750/100000 (0.75%), epoch=0, lr=7.500000000000001e-06, speed=2.460 step/s, elapsed=05:04, eta=11:12:27 +[2026-04-15 05:40:32,189][trainer.accelerators.base_accelerator][INFO] - Training progress: step=800/100000 (0.80%), epoch=0, lr=8.000000000000001e-06, speed=2.478 step/s, elapsed=05:22, eta=11:07:16 +[2026-04-15 05:40:50,093][trainer.accelerators.base_accelerator][INFO] - Training progress: step=850/100000 (0.85%), epoch=0, lr=8.5e-06, speed=2.494 step/s, elapsed=05:40, eta=11:02:30 +[2026-04-15 05:41:08,151][trainer.accelerators.base_accelerator][INFO] - Training progress: step=900/100000 (0.90%), epoch=0, lr=9e-06, speed=2.508 step/s, elapsed=05:58, eta=10:58:31 +[2026-04-15 05:41:26,072][trainer.accelerators.base_accelerator][INFO] - Training progress: step=950/100000 (0.95%), epoch=0, lr=9.5e-06, speed=2.522 step/s, elapsed=06:16, eta=10:54:41 +[2026-04-15 05:41:44,572][trainer.accelerators.base_accelerator][INFO] - Training progress: step=1000/100000 (1.00%), epoch=0, lr=1e-05, speed=2.530 step/s, elapsed=06:35, eta=10:52:10 +[2026-04-15 05:41:44,597][__main__][INFO] - ========== EVAL START (periodic@gstep=1000) ========== +[2026-04-15 05:41:44,597][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-15 05:41:44,598][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 05:42:01,470][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.284856796264648, 'accuracy': 0.48705882352941177, 'num_samples': 425} +[2026-04-15 05:42:01,470][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-15 05:42:01,471][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 05:42:16,541][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.284856796264648, 'accuracy': 0.48705882352941177, 'num_samples': 425, 'test_unique_accuracy': 0.5231481481481481, 'test_unique_num_samples': 432} +[2026-04-15 05:42:16,541][__main__][INFO] - ========== EVAL END (periodic@gstep=1000) ========== +[2026-04-15 05:42:16,542][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.279633522033691, 'accuracy': 0.48705882352941177, 'num_samples': 425, 'test_unique_accuracy': 0.5231481481481481, 'test_unique_num_samples': 432} +[2026-04-15 05:42:16,545][trainer.accelerators.base_accelerator][INFO] - Not cleaning up checkpoints as only 0 checkpoints found +[2026-04-15 05:42:16,546][trainer.accelerators.base_accelerator][INFO] - Saving checkpoint to logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep1000 +[2026-04-15 05:42:16,547][accelerate.accelerator][INFO] - Saving current state to logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep1000 +[2026-04-15 08:23:51,315][accelerate.checkpointing][INFO] - Model weights saved in logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep1000/model.safetensors +[2026-04-15 08:23:54,759][accelerate.checkpointing][INFO] - Optimizer state saved in logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep1000/optimizer.bin +[2026-04-15 08:23:54,818][accelerate.checkpointing][INFO] - Scheduler state saved in logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep1000/scheduler.bin +[2026-04-15 08:23:54,819][accelerate.checkpointing][INFO] - Sampler state for dataloader 0 saved in logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep1000/sampler.bin +[2026-04-15 08:23:54,819][accelerate.checkpointing][INFO] - Sampler state for dataloader 1 saved in logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep1000/sampler_1.bin +[2026-04-15 08:23:54,819][accelerate.checkpointing][INFO] - Sampler state for dataloader 2 saved in logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep1000/sampler_2.bin +[2026-04-15 08:23:54,828][accelerate.checkpointing][INFO] - Random states saved in logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep1000/random_states_0.pkl +[2026-04-15 08:23:54,866][trainer.accelerators.base_accelerator][INFO] - Saved checkpoint to logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep1000 +[2026-04-15 08:24:13,025][trainer.accelerators.base_accelerator][INFO] - Training progress: step=1050/100000 (1.05%), epoch=0, lr=1e-05, speed=0.104 step/s, elapsed=02:49:03, eta=265:32:03 +[2026-04-15 08:24:31,464][trainer.accelerators.base_accelerator][INFO] - Training progress: step=1100/100000 (1.10%), epoch=0, lr=1e-05, speed=0.108 step/s, elapsed=02:49:22, eta=253:47:49 +[2026-04-15 08:24:49,622][trainer.accelerators.base_accelerator][INFO] - Training progress: step=1150/100000 (1.15%), epoch=0, lr=1e-05, speed=0.113 step/s, elapsed=02:49:40, eta=243:04:23 +[2026-04-15 08:25:07,614][trainer.accelerators.base_accelerator][INFO] - Training progress: step=1200/100000 (1.20%), epoch=0, lr=1e-05, speed=0.118 step/s, elapsed=02:49:58, eta=233:14:19 +[2026-04-15 08:25:25,500][trainer.accelerators.base_accelerator][INFO] - Training progress: step=1250/100000 (1.25%), epoch=0, lr=1e-05, speed=0.122 step/s, elapsed=02:50:16, eta=224:11:18 +[2026-04-15 08:25:43,366][trainer.accelerators.base_accelerator][INFO] - Training progress: step=1300/100000 (1.30%), epoch=0, lr=1e-05, speed=0.127 step/s, elapsed=02:50:34, eta=215:50:00 +[2026-04-15 08:26:01,501][trainer.accelerators.base_accelerator][INFO] - Training progress: step=1350/100000 (1.35%), epoch=0, lr=1e-05, speed=0.132 step/s, elapsed=02:50:52, eta=208:06:08 +[2026-04-15 08:26:19,398][trainer.accelerators.base_accelerator][INFO] - Training progress: step=1400/100000 (1.40%), epoch=0, lr=1e-05, speed=0.136 step/s, elapsed=02:51:10, eta=200:55:07 +[2026-04-15 08:26:37,280][trainer.accelerators.base_accelerator][INFO] - Training progress: step=1450/100000 (1.45%), epoch=0, lr=1e-05, speed=0.141 step/s, elapsed=02:51:27, eta=194:13:46 +[2026-04-15 08:26:55,255][trainer.accelerators.base_accelerator][INFO] - Training progress: step=1500/100000 (1.50%), epoch=0, lr=1e-05, speed=0.146 step/s, elapsed=02:51:45, eta=187:59:16 +[2026-04-15 08:27:13,386][trainer.accelerators.base_accelerator][INFO] - Training progress: step=1550/100000 (1.55%), epoch=0, lr=1e-05, speed=0.150 step/s, elapsed=02:52:04, eta=182:09:04 +[2026-04-15 08:27:31,561][trainer.accelerators.base_accelerator][INFO] - Training progress: step=1600/100000 (1.60%), epoch=0, lr=1e-05, speed=0.155 step/s, elapsed=02:52:22, eta=176:40:48 +[2026-04-15 08:27:49,503][trainer.accelerators.base_accelerator][INFO] - Training progress: step=1650/100000 (1.65%), epoch=0, lr=1e-05, speed=0.159 step/s, elapsed=02:52:40, eta=171:32:09 +[2026-04-15 08:28:07,685][trainer.accelerators.base_accelerator][INFO] - Training progress: step=1700/100000 (1.70%), epoch=0, lr=1e-05, speed=0.164 step/s, elapsed=02:52:58, eta=166:41:53 +[2026-04-15 08:28:25,621][trainer.accelerators.base_accelerator][INFO] - Training progress: step=1750/100000 (1.75%), epoch=0, lr=1e-05, speed=0.168 step/s, elapsed=02:53:16, eta=162:07:58 +[2026-04-15 08:28:43,476][trainer.accelerators.base_accelerator][INFO] - Training progress: step=1800/100000 (1.80%), epoch=0, lr=1e-05, speed=0.173 step/s, elapsed=02:53:34, eta=157:49:10 +[2026-04-15 08:29:01,308][trainer.accelerators.base_accelerator][INFO] - Training progress: step=1850/100000 (1.85%), epoch=0, lr=1e-05, speed=0.177 step/s, elapsed=02:53:51, eta=153:44:19 +[2026-04-15 08:29:19,559][trainer.accelerators.base_accelerator][INFO] - Training progress: step=1900/100000 (1.90%), epoch=0, lr=1e-05, speed=0.182 step/s, elapsed=02:54:10, eta=149:52:42 +[2026-04-15 08:29:37,497][trainer.accelerators.base_accelerator][INFO] - Training progress: step=1950/100000 (1.95%), epoch=0, lr=1e-05, speed=0.186 step/s, elapsed=02:54:28, eta=146:12:41 +[2026-04-15 08:29:55,376][trainer.accelerators.base_accelerator][INFO] - Training progress: step=2000/100000 (2.00%), epoch=0, lr=1e-05, speed=0.191 step/s, elapsed=02:54:46, eta=142:43:36 +[2026-04-15 08:29:55,401][__main__][INFO] - ========== EVAL START (periodic@gstep=2000) ========== +[2026-04-15 08:29:55,401][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-15 08:29:55,401][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 08:30:10,511][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.279633522033691, 'accuracy': 0.52, 'num_samples': 425, 'test_unique_accuracy': 0.5231481481481481, 'test_unique_num_samples': 432} +[2026-04-15 08:30:10,512][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-15 08:30:10,512][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 08:30:25,512][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.279633522033691, 'accuracy': 0.52, 'num_samples': 425, 'test_unique_accuracy': 0.46296296296296297, 'test_unique_num_samples': 432} +[2026-04-15 08:30:25,513][__main__][INFO] - ========== EVAL END (periodic@gstep=2000) ========== +[2026-04-15 08:30:25,513][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.268759727478027, 'accuracy': 0.52, 'num_samples': 425, 'test_unique_accuracy': 0.46296296296296297, 'test_unique_num_samples': 432} +[2026-04-15 08:30:25,518][trainer.accelerators.base_accelerator][INFO] - Not cleaning up checkpoints as only 1 checkpoints found +[2026-04-15 08:30:25,518][trainer.accelerators.base_accelerator][INFO] - Saving checkpoint to logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep2000 +[2026-04-15 08:30:25,520][accelerate.accelerator][INFO] - Saving current state to logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep2000 +[2026-04-15 08:30:46,479][accelerate.checkpointing][INFO] - Model weights saved in logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep2000/model.safetensors +[2026-04-15 08:30:49,688][accelerate.checkpointing][INFO] - Optimizer state saved in logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep2000/optimizer.bin +[2026-04-15 08:30:49,690][accelerate.checkpointing][INFO] - Scheduler state saved in logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep2000/scheduler.bin +[2026-04-15 08:30:49,691][accelerate.checkpointing][INFO] - Sampler state for dataloader 0 saved in logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep2000/sampler.bin +[2026-04-15 08:30:49,691][accelerate.checkpointing][INFO] - Sampler state for dataloader 1 saved in logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep2000/sampler_1.bin +[2026-04-15 08:30:49,691][accelerate.checkpointing][INFO] - Sampler state for dataloader 2 saved in logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep2000/sampler_2.bin +[2026-04-15 08:30:49,695][accelerate.checkpointing][INFO] - Random states saved in logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep2000/random_states_0.pkl +[2026-04-15 08:30:49,701][trainer.accelerators.base_accelerator][INFO] - Saved checkpoint to logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep2000 +[2026-04-15 08:31:07,579][trainer.accelerators.base_accelerator][INFO] - Training progress: step=2050/100000 (2.05%), epoch=0, lr=1e-05, speed=0.194 step/s, elapsed=02:55:58, eta=140:07:58 +[2026-04-15 08:31:25,413][trainer.accelerators.base_accelerator][INFO] - Training progress: step=2100/100000 (2.10%), epoch=0, lr=1e-05, speed=0.199 step/s, elapsed=02:56:16, eta=136:57:27 +[2026-04-15 08:31:43,237][trainer.accelerators.base_accelerator][INFO] - Training progress: step=2150/100000 (2.15%), epoch=0, lr=1e-05, speed=0.203 step/s, elapsed=02:56:33, eta=133:55:46 +[2026-04-15 08:32:01,061][trainer.accelerators.base_accelerator][INFO] - Training progress: step=2200/100000 (2.20%), epoch=0, lr=1e-05, speed=0.207 step/s, elapsed=02:56:51, eta=131:02:20 +[2026-04-15 08:32:18,975][trainer.accelerators.base_accelerator][INFO] - Training progress: step=2250/100000 (2.25%), epoch=0, lr=1e-05, speed=0.212 step/s, elapsed=02:57:09, eta=128:16:39 +[2026-04-15 08:32:36,878][trainer.accelerators.base_accelerator][INFO] - Training progress: step=2300/100000 (2.30%), epoch=0, lr=1e-05, speed=0.216 step/s, elapsed=02:57:27, eta=125:38:09 +[2026-04-15 08:32:54,675][trainer.accelerators.base_accelerator][INFO] - Training progress: step=2350/100000 (2.35%), epoch=0, lr=1e-05, speed=0.220 step/s, elapsed=02:57:45, eta=123:06:19 +[2026-04-15 08:33:12,505][trainer.accelerators.base_accelerator][INFO] - Training progress: step=2400/100000 (2.40%), epoch=0, lr=1e-05, speed=0.225 step/s, elapsed=02:58:03, eta=120:40:49 +[2026-04-15 08:33:30,356][trainer.accelerators.base_accelerator][INFO] - Training progress: step=2450/100000 (2.45%), epoch=0, lr=1e-05, speed=0.229 step/s, elapsed=02:58:21, eta=118:21:16 +[2026-04-15 08:33:48,571][trainer.accelerators.base_accelerator][INFO] - Training progress: step=2500/100000 (2.50%), epoch=0, lr=1e-05, speed=0.233 step/s, elapsed=02:58:39, eta=116:07:30 +[2026-04-15 08:34:06,346][trainer.accelerators.base_accelerator][INFO] - Training progress: step=2550/100000 (2.55%), epoch=0, lr=1e-05, speed=0.237 step/s, elapsed=02:58:57, eta=113:58:42 +[2026-04-15 08:34:24,213][trainer.accelerators.base_accelerator][INFO] - Training progress: step=2600/100000 (2.60%), epoch=0, lr=1e-05, speed=0.242 step/s, elapsed=02:59:14, eta=111:54:54 +[2026-04-15 08:34:42,161][trainer.accelerators.base_accelerator][INFO] - Training progress: step=2650/100000 (2.65%), epoch=0, lr=1e-05, speed=0.246 step/s, elapsed=02:59:32, eta=109:55:49 +[2026-04-15 08:35:00,043][trainer.accelerators.base_accelerator][INFO] - Training progress: step=2700/100000 (2.70%), epoch=0, lr=1e-05, speed=0.250 step/s, elapsed=02:59:50, eta=108:01:05 +[2026-04-15 08:35:17,868][trainer.accelerators.base_accelerator][INFO] - Training progress: step=2750/100000 (2.75%), epoch=0, lr=1e-05, speed=0.254 step/s, elapsed=03:00:08, eta=106:10:29 +[2026-04-15 08:35:35,680][trainer.accelerators.base_accelerator][INFO] - Training progress: step=2800/100000 (2.80%), epoch=0, lr=1e-05, speed=0.259 step/s, elapsed=03:00:26, eta=104:23:49 +[2026-04-15 08:35:53,520][trainer.accelerators.base_accelerator][INFO] - Training progress: step=2850/100000 (2.85%), epoch=0, lr=1e-05, speed=0.263 step/s, elapsed=03:00:44, eta=102:40:54 +[2026-04-15 08:36:11,429][trainer.accelerators.base_accelerator][INFO] - Training progress: step=2900/100000 (2.90%), epoch=0, lr=1e-05, speed=0.267 step/s, elapsed=03:01:02, eta=101:01:33 +[2026-04-15 08:36:29,167][trainer.accelerators.base_accelerator][INFO] - Training progress: step=2950/100000 (2.95%), epoch=0, lr=1e-05, speed=0.271 step/s, elapsed=03:01:19, eta=99:25:28 +[2026-04-15 08:36:47,040][trainer.accelerators.base_accelerator][INFO] - Training progress: step=3000/100000 (3.00%), epoch=0, lr=1e-05, speed=0.275 step/s, elapsed=03:01:37, eta=97:52:39 +[2026-04-15 08:36:47,064][__main__][INFO] - ========== EVAL START (periodic@gstep=3000) ========== +[2026-04-15 08:36:47,064][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-15 08:36:47,065][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 08:37:02,084][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.268759727478027, 'accuracy': 0.4988235294117647, 'num_samples': 425, 'test_unique_accuracy': 0.46296296296296297, 'test_unique_num_samples': 432} +[2026-04-15 08:37:02,085][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-15 08:37:02,085][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 08:37:17,114][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.268759727478027, 'accuracy': 0.4988235294117647, 'num_samples': 425, 'test_unique_accuracy': 0.47685185185185186, 'test_unique_num_samples': 432} +[2026-04-15 08:37:17,114][__main__][INFO] - ========== EVAL END (periodic@gstep=3000) ========== +[2026-04-15 08:37:17,114][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.264531135559082, 'accuracy': 0.4988235294117647, 'num_samples': 425, 'test_unique_accuracy': 0.47685185185185186, 'test_unique_num_samples': 432} +[2026-04-15 08:37:17,119][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.4988235294117647 is not better than 0.52 of logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep2000, skipping checkpoint +[2026-04-15 08:37:34,995][trainer.accelerators.base_accelerator][INFO] - Training progress: step=3050/100000 (3.05%), epoch=0, lr=1e-05, speed=0.279 step/s, elapsed=03:02:25, eta=96:38:49 +[2026-04-15 08:37:52,897][trainer.accelerators.base_accelerator][INFO] - Training progress: step=3100/100000 (3.10%), epoch=0, lr=1e-05, speed=0.283 step/s, elapsed=03:02:43, eta=95:11:40 +[2026-04-15 08:38:10,812][trainer.accelerators.base_accelerator][INFO] - Training progress: step=3150/100000 (3.15%), epoch=0, lr=1e-05, speed=0.287 step/s, elapsed=03:03:01, eta=93:47:17 +[2026-04-15 08:38:28,723][trainer.accelerators.base_accelerator][INFO] - Training progress: step=3200/100000 (3.20%), epoch=0, lr=1e-05, speed=0.291 step/s, elapsed=03:03:19, eta=92:25:32 +[2026-04-15 08:38:46,613][trainer.accelerators.base_accelerator][INFO] - Training progress: step=3250/100000 (3.25%), epoch=0, lr=1e-05, speed=0.295 step/s, elapsed=03:03:37, eta=91:06:16 +[2026-04-15 08:39:04,562][trainer.accelerators.base_accelerator][INFO] - Training progress: step=3300/100000 (3.30%), epoch=0, lr=1e-05, speed=0.299 step/s, elapsed=03:03:55, eta=89:49:26 +[2026-04-15 08:39:22,334][trainer.accelerators.base_accelerator][INFO] - Training progress: step=3350/100000 (3.35%), epoch=0, lr=1e-05, speed=0.303 step/s, elapsed=03:04:13, eta=88:34:47 +[2026-04-15 08:39:40,169][trainer.accelerators.base_accelerator][INFO] - Training progress: step=3400/100000 (3.40%), epoch=0, lr=1e-05, speed=0.307 step/s, elapsed=03:04:30, eta=87:22:22 +[2026-04-15 08:39:58,066][trainer.accelerators.base_accelerator][INFO] - Training progress: step=3450/100000 (3.45%), epoch=0, lr=1e-05, speed=0.311 step/s, elapsed=03:04:48, eta=86:12:04 +[2026-04-15 08:40:15,886][trainer.accelerators.base_accelerator][INFO] - Training progress: step=3500/100000 (3.50%), epoch=0, lr=1e-05, speed=0.315 step/s, elapsed=03:05:06, eta=85:03:44 +[2026-04-15 08:40:34,030][trainer.accelerators.base_accelerator][INFO] - Training progress: step=3550/100000 (3.55%), epoch=0, lr=1e-05, speed=0.319 step/s, elapsed=03:05:24, eta=83:57:27 +[2026-04-15 08:40:51,904][trainer.accelerators.base_accelerator][INFO] - Training progress: step=3600/100000 (3.60%), epoch=0, lr=1e-05, speed=0.323 step/s, elapsed=03:05:42, eta=82:52:53 +[2026-04-15 08:41:09,674][trainer.accelerators.base_accelerator][INFO] - Training progress: step=3650/100000 (3.65%), epoch=0, lr=1e-05, speed=0.327 step/s, elapsed=03:06:00, eta=81:50:02 +[2026-04-15 08:41:27,443][trainer.accelerators.base_accelerator][INFO] - Training progress: step=3700/100000 (3.70%), epoch=0, lr=1e-05, speed=0.331 step/s, elapsed=03:06:18, eta=80:48:53 +[2026-04-15 08:41:45,178][trainer.accelerators.base_accelerator][INFO] - Training progress: step=3750/100000 (3.75%), epoch=0, lr=1e-05, speed=0.335 step/s, elapsed=03:06:35, eta=79:49:20 +[2026-04-15 08:42:03,018][trainer.accelerators.base_accelerator][INFO] - Training progress: step=3800/100000 (3.80%), epoch=0, lr=1e-05, speed=0.339 step/s, elapsed=03:06:53, eta=78:51:23 +[2026-04-15 08:42:20,886][trainer.accelerators.base_accelerator][INFO] - Training progress: step=3850/100000 (3.85%), epoch=0, lr=1e-05, speed=0.343 step/s, elapsed=03:07:11, eta=77:54:57 +[2026-04-15 08:42:38,676][trainer.accelerators.base_accelerator][INFO] - Training progress: step=3900/100000 (3.90%), epoch=0, lr=1e-05, speed=0.347 step/s, elapsed=03:07:29, eta=76:59:55 +[2026-04-15 08:42:56,497][trainer.accelerators.base_accelerator][INFO] - Training progress: step=3950/100000 (3.95%), epoch=0, lr=1e-05, speed=0.351 step/s, elapsed=03:07:47, eta=76:06:17 +[2026-04-15 08:43:14,277][trainer.accelerators.base_accelerator][INFO] - Training progress: step=4000/100000 (4.00%), epoch=0, lr=1e-05, speed=0.354 step/s, elapsed=03:08:04, eta=75:13:59 +[2026-04-15 08:43:14,300][__main__][INFO] - ========== EVAL START (periodic@gstep=4000) ========== +[2026-04-15 08:43:14,301][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-15 08:43:14,301][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 08:43:29,401][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.264531135559082, 'accuracy': 0.508235294117647, 'num_samples': 425, 'test_unique_accuracy': 0.47685185185185186, 'test_unique_num_samples': 432} +[2026-04-15 08:43:29,401][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-15 08:43:29,402][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 08:43:44,552][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.264531135559082, 'accuracy': 0.508235294117647, 'num_samples': 425, 'test_unique_accuracy': 0.5393518518518519, 'test_unique_num_samples': 432} +[2026-04-15 08:43:44,553][__main__][INFO] - ========== EVAL END (periodic@gstep=4000) ========== +[2026-04-15 08:43:44,553][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.252857208251953, 'accuracy': 0.508235294117647, 'num_samples': 425, 'test_unique_accuracy': 0.5393518518518519, 'test_unique_num_samples': 432} +[2026-04-15 08:43:44,557][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.508235294117647 is not better than 0.52 of logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep2000, skipping checkpoint +[2026-04-15 08:44:02,336][trainer.accelerators.base_accelerator][INFO] - Training progress: step=4050/100000 (4.05%), epoch=0, lr=1e-05, speed=0.357 step/s, elapsed=03:08:53, eta=74:34:54 +[2026-04-15 08:44:20,140][trainer.accelerators.base_accelerator][INFO] - Training progress: step=4100/100000 (4.10%), epoch=0, lr=1e-05, speed=0.361 step/s, elapsed=03:09:10, eta=73:44:58 +[2026-04-15 08:44:38,038][trainer.accelerators.base_accelerator][INFO] - Training progress: step=4150/100000 (4.15%), epoch=0, lr=1e-05, speed=0.365 step/s, elapsed=03:09:28, eta=72:56:16 +[2026-04-15 08:44:55,967][trainer.accelerators.base_accelerator][INFO] - Training progress: step=4200/100000 (4.20%), epoch=0, lr=1e-05, speed=0.369 step/s, elapsed=03:09:46, eta=72:08:44 +[2026-04-15 08:45:13,800][trainer.accelerators.base_accelerator][INFO] - Training progress: step=4250/100000 (4.25%), epoch=0, lr=1e-05, speed=0.373 step/s, elapsed=03:10:04, eta=71:22:16 +[2026-04-15 08:45:31,664][trainer.accelerators.base_accelerator][INFO] - Training progress: step=4300/100000 (4.30%), epoch=0, lr=1e-05, speed=0.376 step/s, elapsed=03:10:22, eta=70:36:53 +[2026-04-15 08:45:49,521][trainer.accelerators.base_accelerator][INFO] - Training progress: step=4350/100000 (4.35%), epoch=0, lr=1e-05, speed=0.380 step/s, elapsed=03:10:40, eta=69:52:32 +[2026-04-15 08:46:07,421][trainer.accelerators.base_accelerator][INFO] - Training progress: step=4400/100000 (4.40%), epoch=0, lr=1e-05, speed=0.384 step/s, elapsed=03:10:58, eta=69:09:13 +[2026-04-15 08:46:25,240][trainer.accelerators.base_accelerator][INFO] - Training progress: step=4450/100000 (4.45%), epoch=0, lr=1e-05, speed=0.388 step/s, elapsed=03:11:15, eta=68:26:49 +[2026-04-15 08:46:43,043][trainer.accelerators.base_accelerator][INFO] - Training progress: step=4500/100000 (4.50%), epoch=0, lr=1e-05, speed=0.392 step/s, elapsed=03:11:33, eta=67:45:22 +[2026-04-15 08:47:00,897][trainer.accelerators.base_accelerator][INFO] - Training progress: step=4550/100000 (4.55%), epoch=0, lr=1e-05, speed=0.395 step/s, elapsed=03:11:51, eta=67:04:50 +[2026-04-15 08:47:18,762][trainer.accelerators.base_accelerator][INFO] - Training progress: step=4600/100000 (4.60%), epoch=0, lr=1e-05, speed=0.399 step/s, elapsed=03:12:09, eta=66:25:10 +[2026-04-15 08:47:36,905][trainer.accelerators.base_accelerator][INFO] - Training progress: step=4650/100000 (4.65%), epoch=0, lr=1e-05, speed=0.403 step/s, elapsed=03:12:27, eta=65:46:27 +[2026-04-15 08:47:54,757][trainer.accelerators.base_accelerator][INFO] - Training progress: step=4700/100000 (4.70%), epoch=0, lr=1e-05, speed=0.406 step/s, elapsed=03:12:45, eta=65:08:27 +[2026-04-15 08:48:12,536][trainer.accelerators.base_accelerator][INFO] - Training progress: step=4750/100000 (4.75%), epoch=0, lr=1e-05, speed=0.410 step/s, elapsed=03:13:03, eta=64:31:14 +[2026-04-15 08:48:30,278][trainer.accelerators.base_accelerator][INFO] - Training progress: step=4800/100000 (4.80%), epoch=0, lr=1e-05, speed=0.414 step/s, elapsed=03:13:20, eta=63:54:45 +[2026-04-15 08:48:48,047][trainer.accelerators.base_accelerator][INFO] - Training progress: step=4850/100000 (4.85%), epoch=0, lr=1e-05, speed=0.417 step/s, elapsed=03:13:38, eta=63:19:02 +[2026-04-15 08:49:05,884][trainer.accelerators.base_accelerator][INFO] - Training progress: step=4900/100000 (4.90%), epoch=0, lr=1e-05, speed=0.421 step/s, elapsed=03:13:56, eta=62:44:04 +[2026-04-15 08:49:23,713][trainer.accelerators.base_accelerator][INFO] - Training progress: step=4950/100000 (4.95%), epoch=0, lr=1e-05, speed=0.425 step/s, elapsed=03:14:14, eta=62:09:47 +[2026-04-15 08:49:41,519][trainer.accelerators.base_accelerator][INFO] - Training progress: step=5000/100000 (5.00%), epoch=0, lr=1e-05, speed=0.428 step/s, elapsed=03:14:32, eta=61:36:11 +[2026-04-15 08:49:41,542][__main__][INFO] - ========== EVAL START (periodic@gstep=5000) ========== +[2026-04-15 08:49:41,543][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-15 08:49:41,543][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 08:49:56,523][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.252857208251953, 'accuracy': 0.4776470588235294, 'num_samples': 425, 'test_unique_accuracy': 0.5393518518518519, 'test_unique_num_samples': 432} +[2026-04-15 08:49:56,524][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-15 08:49:56,524][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 08:50:11,534][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.252857208251953, 'accuracy': 0.4776470588235294, 'num_samples': 425, 'test_unique_accuracy': 0.46064814814814814, 'test_unique_num_samples': 432} +[2026-04-15 08:50:11,534][__main__][INFO] - ========== EVAL END (periodic@gstep=5000) ========== +[2026-04-15 08:50:11,535][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.24815845489502, 'accuracy': 0.4776470588235294, 'num_samples': 425, 'test_unique_accuracy': 0.46064814814814814, 'test_unique_num_samples': 432} +[2026-04-15 08:50:11,538][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.4776470588235294 is not better than 0.48705882352941177 of logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep1000, skipping checkpoint +[2026-04-15 08:50:29,382][trainer.accelerators.base_accelerator][INFO] - Training progress: step=5050/100000 (5.05%), epoch=0, lr=1e-05, speed=0.431 step/s, elapsed=03:15:20, eta=61:12:40 +[2026-04-15 08:50:47,273][trainer.accelerators.base_accelerator][INFO] - Training progress: step=5100/100000 (5.10%), epoch=0, lr=1e-05, speed=0.434 step/s, elapsed=03:15:37, eta=60:40:18 +[2026-04-15 08:51:05,072][trainer.accelerators.base_accelerator][INFO] - Training progress: step=5150/100000 (5.15%), epoch=0, lr=1e-05, speed=0.438 step/s, elapsed=03:15:55, eta=60:08:31 +[2026-04-15 08:51:22,915][trainer.accelerators.base_accelerator][INFO] - Training progress: step=5200/100000 (5.20%), epoch=0, lr=1e-05, speed=0.442 step/s, elapsed=03:16:13, eta=59:37:21 +[2026-04-15 08:51:40,790][trainer.accelerators.base_accelerator][INFO] - Training progress: step=5250/100000 (5.25%), epoch=0, lr=1e-05, speed=0.445 step/s, elapsed=03:16:31, eta=59:06:48 +[2026-04-15 08:51:58,689][trainer.accelerators.base_accelerator][INFO] - Training progress: step=5300/100000 (5.30%), epoch=0, lr=1e-05, speed=0.449 step/s, elapsed=03:16:49, eta=58:36:48 +[2026-04-15 08:52:16,476][trainer.accelerators.base_accelerator][INFO] - Training progress: step=5350/100000 (5.35%), epoch=0, lr=1e-05, speed=0.452 step/s, elapsed=03:17:07, eta=58:07:21 +[2026-04-15 08:52:34,294][trainer.accelerators.base_accelerator][INFO] - Training progress: step=5400/100000 (5.40%), epoch=0, lr=1e-05, speed=0.456 step/s, elapsed=03:17:24, eta=57:38:26 +[2026-04-15 08:52:52,127][trainer.accelerators.base_accelerator][INFO] - Training progress: step=5450/100000 (5.45%), epoch=0, lr=1e-05, speed=0.459 step/s, elapsed=03:17:42, eta=57:10:03 +[2026-04-15 08:53:09,851][trainer.accelerators.base_accelerator][INFO] - Training progress: step=5500/100000 (5.50%), epoch=0, lr=1e-05, speed=0.463 step/s, elapsed=03:18:00, eta=56:42:09 +[2026-04-15 08:53:27,677][trainer.accelerators.base_accelerator][INFO] - Training progress: step=5550/100000 (5.55%), epoch=0, lr=1e-05, speed=0.466 step/s, elapsed=03:18:18, eta=56:14:46 +[2026-04-15 08:53:45,452][trainer.accelerators.base_accelerator][INFO] - Training progress: step=5600/100000 (5.60%), epoch=0, lr=1e-05, speed=0.470 step/s, elapsed=03:18:36, eta=55:47:52 +[2026-04-15 09:17:36,531][trainer.accelerators.base_accelerator][INFO] - Training progress: step=5650/100000 (5.65%), epoch=0, lr=1e-05, speed=0.423 step/s, elapsed=03:42:27, eta=61:54:46 +[2026-04-15 09:17:54,379][trainer.accelerators.base_accelerator][INFO] - Training progress: step=5700/100000 (5.70%), epoch=0, lr=1e-05, speed=0.426 step/s, elapsed=03:42:45, eta=61:25:09 +[2026-04-15 09:18:12,473][trainer.accelerators.base_accelerator][INFO] - Training progress: step=5750/100000 (5.75%), epoch=0, lr=1e-05, speed=0.430 step/s, elapsed=03:43:03, eta=60:56:07 +[2026-04-15 09:18:30,227][trainer.accelerators.base_accelerator][INFO] - Training progress: step=5800/100000 (5.80%), epoch=0, lr=1e-05, speed=0.433 step/s, elapsed=03:43:20, eta=60:27:29 +[2026-04-15 09:18:48,061][trainer.accelerators.base_accelerator][INFO] - Training progress: step=5850/100000 (5.85%), epoch=0, lr=1e-05, speed=0.436 step/s, elapsed=03:43:38, eta=59:59:21 +[2026-04-15 09:19:05,826][trainer.accelerators.base_accelerator][INFO] - Training progress: step=5900/100000 (5.90%), epoch=0, lr=1e-05, speed=0.439 step/s, elapsed=03:43:56, eta=59:31:40 +[2026-04-15 09:19:23,617][trainer.accelerators.base_accelerator][INFO] - Training progress: step=5950/100000 (5.95%), epoch=0, lr=1e-05, speed=0.442 step/s, elapsed=03:44:14, eta=59:04:28 +[2026-04-15 09:19:41,421][trainer.accelerators.base_accelerator][INFO] - Training progress: step=6000/100000 (6.00%), epoch=0, lr=1e-05, speed=0.445 step/s, elapsed=03:44:32, eta=58:37:42 +[2026-04-15 09:19:41,443][__main__][INFO] - ========== EVAL START (periodic@gstep=6000) ========== +[2026-04-15 09:19:41,444][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-15 09:19:41,444][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 09:19:56,444][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.24815845489502, 'accuracy': 0.48470588235294115, 'num_samples': 425, 'test_unique_accuracy': 0.46064814814814814, 'test_unique_num_samples': 432} +[2026-04-15 09:19:56,444][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-15 09:19:56,445][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 09:20:11,473][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.24815845489502, 'accuracy': 0.48470588235294115, 'num_samples': 425, 'test_unique_accuracy': 0.46296296296296297, 'test_unique_num_samples': 432} +[2026-04-15 09:20:11,473][__main__][INFO] - ========== EVAL END (periodic@gstep=6000) ========== +[2026-04-15 09:20:11,473][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.24202823638916, 'accuracy': 0.48470588235294115, 'num_samples': 425, 'test_unique_accuracy': 0.46296296296296297, 'test_unique_num_samples': 432} +[2026-04-15 09:20:11,476][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.48470588235294115 is not better than 0.48705882352941177 of logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep1000, skipping checkpoint +[2026-04-15 09:20:29,304][trainer.accelerators.base_accelerator][INFO] - Training progress: step=6050/100000 (6.05%), epoch=0, lr=1e-05, speed=0.447 step/s, elapsed=03:45:19, eta=58:19:10 +[2026-04-15 09:20:47,143][trainer.accelerators.base_accelerator][INFO] - Training progress: step=6100/100000 (6.10%), epoch=0, lr=1e-05, speed=0.451 step/s, elapsed=03:45:37, eta=57:53:13 +[2026-04-15 09:21:04,885][trainer.accelerators.base_accelerator][INFO] - Training progress: step=6150/100000 (6.15%), epoch=0, lr=1e-05, speed=0.454 step/s, elapsed=03:45:55, eta=57:27:40 +[2026-04-15 09:21:22,750][trainer.accelerators.base_accelerator][INFO] - Training progress: step=6200/100000 (6.20%), epoch=0, lr=1e-05, speed=0.457 step/s, elapsed=03:46:13, eta=57:02:32 +[2026-04-15 09:21:40,660][trainer.accelerators.base_accelerator][INFO] - Training progress: step=6250/100000 (6.25%), epoch=0, lr=1e-05, speed=0.460 step/s, elapsed=03:46:31, eta=56:37:50 +[2026-04-15 09:21:58,494][trainer.accelerators.base_accelerator][INFO] - Training progress: step=6300/100000 (6.30%), epoch=0, lr=1e-05, speed=0.463 step/s, elapsed=03:46:49, eta=56:13:29 +[2026-04-15 09:22:16,266][trainer.accelerators.base_accelerator][INFO] - Training progress: step=6350/100000 (6.35%), epoch=0, lr=1e-05, speed=0.466 step/s, elapsed=03:47:06, eta=55:49:30 +[2026-04-15 09:22:34,037][trainer.accelerators.base_accelerator][INFO] - Training progress: step=6400/100000 (6.40%), epoch=0, lr=1e-05, speed=0.469 step/s, elapsed=03:47:24, eta=55:25:54 +[2026-04-15 09:22:51,853][trainer.accelerators.base_accelerator][INFO] - Training progress: step=6450/100000 (6.45%), epoch=0, lr=1e-05, speed=0.472 step/s, elapsed=03:47:42, eta=55:02:39 +[2026-04-15 09:23:09,727][trainer.accelerators.base_accelerator][INFO] - Training progress: step=6500/100000 (6.50%), epoch=0, lr=1e-05, speed=0.475 step/s, elapsed=03:48:00, eta=54:39:47 +[2026-04-15 09:23:27,510][trainer.accelerators.base_accelerator][INFO] - Training progress: step=6550/100000 (6.55%), epoch=0, lr=1e-05, speed=0.478 step/s, elapsed=03:48:18, eta=54:17:14 +[2026-04-15 09:23:45,347][trainer.accelerators.base_accelerator][INFO] - Training progress: step=6600/100000 (6.60%), epoch=0, lr=1e-05, speed=0.481 step/s, elapsed=03:48:36, eta=53:55:02 +[2026-04-15 09:24:03,145][trainer.accelerators.base_accelerator][INFO] - Training progress: step=6650/100000 (6.65%), epoch=0, lr=1e-05, speed=0.484 step/s, elapsed=03:48:53, eta=53:33:09 +[2026-04-15 09:24:21,004][trainer.accelerators.base_accelerator][INFO] - Training progress: step=6700/100000 (6.70%), epoch=0, lr=1e-05, speed=0.487 step/s, elapsed=03:49:11, eta=53:11:37 +[2026-04-15 09:24:38,876][trainer.accelerators.base_accelerator][INFO] - Training progress: step=6750/100000 (6.75%), epoch=0, lr=1e-05, speed=0.490 step/s, elapsed=03:49:29, eta=52:50:23 +[2026-04-15 09:24:56,948][trainer.accelerators.base_accelerator][INFO] - Training progress: step=6800/100000 (6.80%), epoch=0, lr=1e-05, speed=0.493 step/s, elapsed=03:49:47, eta=52:29:31 +[2026-04-15 09:25:14,814][trainer.accelerators.base_accelerator][INFO] - Training progress: step=6850/100000 (6.85%), epoch=0, lr=1e-05, speed=0.496 step/s, elapsed=03:50:05, eta=52:08:54 +[2026-04-15 09:25:32,672][trainer.accelerators.base_accelerator][INFO] - Training progress: step=6900/100000 (6.90%), epoch=0, lr=1e-05, speed=0.499 step/s, elapsed=03:50:23, eta=51:48:35 +[2026-04-15 09:25:50,540][trainer.accelerators.base_accelerator][INFO] - Training progress: step=6950/100000 (6.95%), epoch=0, lr=1e-05, speed=0.502 step/s, elapsed=03:50:41, eta=51:28:33 +[2026-04-15 09:26:08,373][trainer.accelerators.base_accelerator][INFO] - Training progress: step=7000/100000 (7.00%), epoch=0, lr=1e-05, speed=0.505 step/s, elapsed=03:50:59, eta=51:08:47 +[2026-04-15 09:26:08,397][__main__][INFO] - ========== EVAL START (periodic@gstep=7000) ========== +[2026-04-15 09:26:08,397][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-15 09:26:08,397][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 09:26:23,408][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.24202823638916, 'accuracy': 0.5058823529411764, 'num_samples': 425, 'test_unique_accuracy': 0.46296296296296297, 'test_unique_num_samples': 432} +[2026-04-15 09:26:23,408][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-15 09:26:23,408][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 09:26:38,453][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.24202823638916, 'accuracy': 0.5058823529411764, 'num_samples': 425, 'test_unique_accuracy': 0.5115740740740741, 'test_unique_num_samples': 432} +[2026-04-15 09:26:38,453][__main__][INFO] - ========== EVAL END (periodic@gstep=7000) ========== +[2026-04-15 09:26:38,453][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.235391616821289, 'accuracy': 0.5058823529411764, 'num_samples': 425, 'test_unique_accuracy': 0.5115740740740741, 'test_unique_num_samples': 432} +[2026-04-15 09:26:38,458][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.5058823529411764 is not better than 0.52 of logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep2000, skipping checkpoint +[2026-04-15 09:26:56,311][trainer.accelerators.base_accelerator][INFO] - Training progress: step=7050/100000 (7.05%), epoch=0, lr=1e-05, speed=0.507 step/s, elapsed=03:51:46, eta=50:55:55 +[2026-04-15 09:27:14,190][trainer.accelerators.base_accelerator][INFO] - Training progress: step=7100/100000 (7.10%), epoch=0, lr=1e-05, speed=0.510 step/s, elapsed=03:52:04, eta=50:36:40 +[2026-04-15 09:27:32,010][trainer.accelerators.base_accelerator][INFO] - Training progress: step=7150/100000 (7.15%), epoch=0, lr=1e-05, speed=0.513 step/s, elapsed=03:52:22, eta=50:17:40 +[2026-04-15 09:27:49,820][trainer.accelerators.base_accelerator][INFO] - Training progress: step=7200/100000 (7.20%), epoch=0, lr=1e-05, speed=0.516 step/s, elapsed=03:52:40, eta=49:58:55 +[2026-04-15 09:28:07,640][trainer.accelerators.base_accelerator][INFO] - Training progress: step=7250/100000 (7.25%), epoch=0, lr=1e-05, speed=0.519 step/s, elapsed=03:52:58, eta=49:40:26 +[2026-04-15 09:28:25,495][trainer.accelerators.base_accelerator][INFO] - Training progress: step=7300/100000 (7.30%), epoch=0, lr=1e-05, speed=0.522 step/s, elapsed=03:53:16, eta=49:22:12 +[2026-04-15 09:28:43,268][trainer.accelerators.base_accelerator][INFO] - Training progress: step=7350/100000 (7.35%), epoch=0, lr=1e-05, speed=0.524 step/s, elapsed=03:53:33, eta=49:04:12 +[2026-04-15 09:29:01,167][trainer.accelerators.base_accelerator][INFO] - Training progress: step=7400/100000 (7.40%), epoch=0, lr=1e-05, speed=0.527 step/s, elapsed=03:53:51, eta=48:46:27 +[2026-04-15 09:29:19,055][trainer.accelerators.base_accelerator][INFO] - Training progress: step=7450/100000 (7.45%), epoch=0, lr=1e-05, speed=0.530 step/s, elapsed=03:54:09, eta=48:28:57 +[2026-04-15 09:29:36,883][trainer.accelerators.base_accelerator][INFO] - Training progress: step=7500/100000 (7.50%), epoch=0, lr=1e-05, speed=0.533 step/s, elapsed=03:54:27, eta=48:11:39 +[2026-04-15 09:29:54,788][trainer.accelerators.base_accelerator][INFO] - Training progress: step=7550/100000 (7.55%), epoch=0, lr=1e-05, speed=0.536 step/s, elapsed=03:54:45, eta=47:54:37 +[2026-04-15 09:30:12,633][trainer.accelerators.base_accelerator][INFO] - Training progress: step=7600/100000 (7.60%), epoch=0, lr=1e-05, speed=0.539 step/s, elapsed=03:55:03, eta=47:37:46 +[2026-04-15 09:30:30,509][trainer.accelerators.base_accelerator][INFO] - Training progress: step=7650/100000 (7.65%), epoch=0, lr=1e-05, speed=0.542 step/s, elapsed=03:55:21, eta=47:21:09 +[2026-04-15 09:30:48,332][trainer.accelerators.base_accelerator][INFO] - Training progress: step=7700/100000 (7.70%), epoch=0, lr=1e-05, speed=0.545 step/s, elapsed=03:55:39, eta=47:04:44 +[2026-04-15 09:31:06,171][trainer.accelerators.base_accelerator][INFO] - Training progress: step=7750/100000 (7.75%), epoch=0, lr=1e-05, speed=0.547 step/s, elapsed=03:55:56, eta=46:48:32 +[2026-04-15 09:31:23,889][trainer.accelerators.base_accelerator][INFO] - Training progress: step=7800/100000 (7.80%), epoch=0, lr=1e-05, speed=0.550 step/s, elapsed=03:56:14, eta=46:32:30 +[2026-04-15 09:31:41,777][trainer.accelerators.base_accelerator][INFO] - Training progress: step=7850/100000 (7.85%), epoch=0, lr=1e-05, speed=0.553 step/s, elapsed=03:56:32, eta=46:16:43 +[2026-04-15 09:31:59,939][trainer.accelerators.base_accelerator][INFO] - Training progress: step=7900/100000 (7.90%), epoch=0, lr=1e-05, speed=0.556 step/s, elapsed=03:56:50, eta=46:01:10 +[2026-04-15 09:32:17,761][trainer.accelerators.base_accelerator][INFO] - Training progress: step=7950/100000 (7.95%), epoch=0, lr=1e-05, speed=0.559 step/s, elapsed=03:57:08, eta=45:45:45 +[2026-04-15 09:32:35,646][trainer.accelerators.base_accelerator][INFO] - Training progress: step=8000/100000 (8.00%), epoch=0, lr=1e-05, speed=0.562 step/s, elapsed=03:57:26, eta=45:30:32 +[2026-04-15 09:32:35,670][__main__][INFO] - ========== EVAL START (periodic@gstep=8000) ========== +[2026-04-15 09:32:35,671][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-15 09:32:35,671][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 09:32:50,660][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.235391616821289, 'accuracy': 0.5011764705882353, 'num_samples': 425, 'test_unique_accuracy': 0.5115740740740741, 'test_unique_num_samples': 432} +[2026-04-15 09:32:50,660][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-15 09:32:50,661][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 09:33:05,702][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.235391616821289, 'accuracy': 0.5011764705882353, 'num_samples': 425, 'test_unique_accuracy': 0.4236111111111111, 'test_unique_num_samples': 432} +[2026-04-15 09:33:05,702][__main__][INFO] - ========== EVAL END (periodic@gstep=8000) ========== +[2026-04-15 09:33:05,702][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.234237670898438, 'accuracy': 0.5011764705882353, 'num_samples': 425, 'test_unique_accuracy': 0.4236111111111111, 'test_unique_num_samples': 432} +[2026-04-15 09:33:05,706][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.5011764705882353 is not better than 0.52 of logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep2000, skipping checkpoint +[2026-04-15 09:33:23,537][trainer.accelerators.base_accelerator][INFO] - Training progress: step=8050/100000 (8.05%), epoch=0, lr=1e-05, speed=0.563 step/s, elapsed=03:58:14, eta=45:21:13 +[2026-04-15 09:33:41,381][trainer.accelerators.base_accelerator][INFO] - Training progress: step=8100/100000 (8.10%), epoch=0, lr=1e-05, speed=0.566 step/s, elapsed=03:58:32, eta=45:06:20 +[2026-04-15 09:33:59,243][trainer.accelerators.base_accelerator][INFO] - Training progress: step=8150/100000 (8.15%), epoch=0, lr=1e-05, speed=0.569 step/s, elapsed=03:58:49, eta=44:51:37 +[2026-04-15 09:34:17,067][trainer.accelerators.base_accelerator][INFO] - Training progress: step=8200/100000 (8.20%), epoch=0, lr=1e-05, speed=0.572 step/s, elapsed=03:59:07, eta=44:37:04 +[2026-04-15 09:34:34,862][trainer.accelerators.base_accelerator][INFO] - Training progress: step=8250/100000 (8.25%), epoch=0, lr=1e-05, speed=0.574 step/s, elapsed=03:59:25, eta=44:22:42 +[2026-04-15 09:34:52,689][trainer.accelerators.base_accelerator][INFO] - Training progress: step=8300/100000 (8.30%), epoch=0, lr=1e-05, speed=0.577 step/s, elapsed=03:59:43, eta=44:08:30 +[2026-04-15 09:35:10,495][trainer.accelerators.base_accelerator][INFO] - Training progress: step=8350/100000 (8.35%), epoch=0, lr=1e-05, speed=0.580 step/s, elapsed=04:00:01, eta=43:54:28 +[2026-04-15 09:35:28,217][trainer.accelerators.base_accelerator][INFO] - Training progress: step=8400/100000 (8.40%), epoch=0, lr=1e-05, speed=0.583 step/s, elapsed=04:00:18, eta=43:40:34 +[2026-04-15 09:35:46,063][trainer.accelerators.base_accelerator][INFO] - Training progress: step=8450/100000 (8.45%), epoch=0, lr=1e-05, speed=0.585 step/s, elapsed=04:00:36, eta=43:26:52 +[2026-04-15 09:36:03,844][trainer.accelerators.base_accelerator][INFO] - Training progress: step=8500/100000 (8.50%), epoch=0, lr=1e-05, speed=0.588 step/s, elapsed=04:00:54, eta=43:13:18 +[2026-04-15 09:36:21,614][trainer.accelerators.base_accelerator][INFO] - Training progress: step=8550/100000 (8.55%), epoch=0, lr=1e-05, speed=0.591 step/s, elapsed=04:01:12, eta=42:59:54 +[2026-04-15 09:36:39,367][trainer.accelerators.base_accelerator][INFO] - Training progress: step=8600/100000 (8.60%), epoch=0, lr=1e-05, speed=0.594 step/s, elapsed=04:01:30, eta=42:46:38 +[2026-04-15 09:36:57,153][trainer.accelerators.base_accelerator][INFO] - Training progress: step=8650/100000 (8.65%), epoch=0, lr=1e-05, speed=0.596 step/s, elapsed=04:01:47, eta=42:33:32 +[2026-04-15 09:37:14,970][trainer.accelerators.base_accelerator][INFO] - Training progress: step=8700/100000 (8.70%), epoch=0, lr=1e-05, speed=0.599 step/s, elapsed=04:02:05, eta=42:20:35 +[2026-04-15 09:37:32,818][trainer.accelerators.base_accelerator][INFO] - Training progress: step=8750/100000 (8.75%), epoch=0, lr=1e-05, speed=0.602 step/s, elapsed=04:02:23, eta=42:07:47 +[2026-04-15 09:37:50,611][trainer.accelerators.base_accelerator][INFO] - Training progress: step=8800/100000 (8.80%), epoch=0, lr=1e-05, speed=0.604 step/s, elapsed=04:02:41, eta=41:55:07 +[2026-04-15 09:38:08,453][trainer.accelerators.base_accelerator][INFO] - Training progress: step=8850/100000 (8.85%), epoch=0, lr=1e-05, speed=0.607 step/s, elapsed=04:02:59, eta=41:42:36 +[2026-04-15 09:38:26,246][trainer.accelerators.base_accelerator][INFO] - Training progress: step=8900/100000 (8.90%), epoch=0, lr=1e-05, speed=0.610 step/s, elapsed=04:03:16, eta=41:30:13 +[2026-04-15 09:38:44,132][trainer.accelerators.base_accelerator][INFO] - Training progress: step=8950/100000 (8.95%), epoch=0, lr=1e-05, speed=0.612 step/s, elapsed=04:03:34, eta=41:17:59 +[2026-04-15 09:39:02,250][trainer.accelerators.base_accelerator][INFO] - Training progress: step=9000/100000 (9.00%), epoch=0, lr=1e-05, speed=0.615 step/s, elapsed=04:03:52, eta=41:05:55 +[2026-04-15 09:39:02,275][__main__][INFO] - ========== EVAL START (periodic@gstep=9000) ========== +[2026-04-15 09:39:02,275][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-15 09:39:02,275][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 09:39:17,340][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.234237670898438, 'accuracy': 0.46588235294117647, 'num_samples': 425, 'test_unique_accuracy': 0.4236111111111111, 'test_unique_num_samples': 432} +[2026-04-15 09:39:17,340][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-15 09:39:17,340][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 09:39:32,355][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.234237670898438, 'accuracy': 0.46588235294117647, 'num_samples': 425, 'test_unique_accuracy': 0.5046296296296297, 'test_unique_num_samples': 432} +[2026-04-15 09:39:32,355][__main__][INFO] - ========== EVAL END (periodic@gstep=9000) ========== +[2026-04-15 09:39:32,355][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.229820251464844, 'accuracy': 0.46588235294117647, 'num_samples': 425, 'test_unique_accuracy': 0.5046296296296297, 'test_unique_num_samples': 432} +[2026-04-15 09:39:32,358][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.46588235294117647 is not better than 0.48705882352941177 of logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep1000, skipping checkpoint +[2026-04-15 09:39:50,251][trainer.accelerators.base_accelerator][INFO] - Training progress: step=9050/100000 (9.05%), epoch=0, lr=1e-05, speed=0.616 step/s, elapsed=04:04:40, eta=40:58:59 +[2026-04-15 09:40:08,073][trainer.accelerators.base_accelerator][INFO] - Training progress: step=9100/100000 (9.10%), epoch=0, lr=1e-05, speed=0.619 step/s, elapsed=04:04:58, eta=40:47:06 +[2026-04-15 09:40:25,931][trainer.accelerators.base_accelerator][INFO] - Training progress: step=9150/100000 (9.15%), epoch=0, lr=1e-05, speed=0.622 step/s, elapsed=04:05:16, eta=40:35:20 +[2026-04-15 09:40:43,774][trainer.accelerators.base_accelerator][INFO] - Training progress: step=9200/100000 (9.20%), epoch=0, lr=1e-05, speed=0.624 step/s, elapsed=04:05:34, eta=40:23:42 +[2026-04-15 09:41:01,518][trainer.accelerators.base_accelerator][INFO] - Training progress: step=9250/100000 (9.25%), epoch=0, lr=1e-05, speed=0.627 step/s, elapsed=04:05:52, eta=40:12:11 +[2026-04-15 09:41:19,321][trainer.accelerators.base_accelerator][INFO] - Training progress: step=9300/100000 (9.30%), epoch=0, lr=1e-05, speed=0.630 step/s, elapsed=04:06:10, eta=40:00:47 +[2026-04-15 09:41:37,078][trainer.accelerators.base_accelerator][INFO] - Training progress: step=9350/100000 (9.35%), epoch=0, lr=1e-05, speed=0.632 step/s, elapsed=04:06:27, eta=39:49:30 +[2026-04-15 09:41:54,906][trainer.accelerators.base_accelerator][INFO] - Training progress: step=9400/100000 (9.40%), epoch=0, lr=1e-05, speed=0.635 step/s, elapsed=04:06:45, eta=39:38:20 +[2026-04-15 09:42:12,637][trainer.accelerators.base_accelerator][INFO] - Training progress: step=9450/100000 (9.45%), epoch=0, lr=1e-05, speed=0.638 step/s, elapsed=04:07:03, eta=39:27:17 +[2026-04-15 09:42:30,362][trainer.accelerators.base_accelerator][INFO] - Training progress: step=9500/100000 (9.50%), epoch=0, lr=1e-05, speed=0.640 step/s, elapsed=04:07:21, eta=39:16:20 +[2026-04-15 09:42:48,176][trainer.accelerators.base_accelerator][INFO] - Training progress: step=9550/100000 (9.55%), epoch=0, lr=1e-05, speed=0.643 step/s, elapsed=04:07:38, eta=39:05:31 +[2026-04-15 09:43:05,929][trainer.accelerators.base_accelerator][INFO] - Training progress: step=9600/100000 (9.60%), epoch=0, lr=1e-05, speed=0.645 step/s, elapsed=04:07:56, eta=38:54:48 +[2026-04-15 09:43:23,688][trainer.accelerators.base_accelerator][INFO] - Training progress: step=9650/100000 (9.65%), epoch=0, lr=1e-05, speed=0.648 step/s, elapsed=04:08:14, eta=38:44:11 +[2026-04-15 09:43:41,545][trainer.accelerators.base_accelerator][INFO] - Training progress: step=9700/100000 (9.70%), epoch=0, lr=1e-05, speed=0.650 step/s, elapsed=04:08:32, eta=38:33:42 +[2026-04-15 09:43:59,340][trainer.accelerators.base_accelerator][INFO] - Training progress: step=9750/100000 (9.75%), epoch=0, lr=1e-05, speed=0.653 step/s, elapsed=04:08:50, eta=38:23:18 +[2026-04-15 09:44:17,238][trainer.accelerators.base_accelerator][INFO] - Training progress: step=9800/100000 (9.80%), epoch=0, lr=1e-05, speed=0.656 step/s, elapsed=04:09:07, eta=38:13:01 +[2026-04-15 09:44:34,951][trainer.accelerators.base_accelerator][INFO] - Training progress: step=9850/100000 (9.85%), epoch=0, lr=1e-05, speed=0.658 step/s, elapsed=04:09:25, eta=38:02:49 +[2026-04-15 09:44:52,803][trainer.accelerators.base_accelerator][INFO] - Training progress: step=9900/100000 (9.90%), epoch=0, lr=1e-05, speed=0.661 step/s, elapsed=04:09:43, eta=37:52:44 +[2026-04-15 09:45:10,669][trainer.accelerators.base_accelerator][INFO] - Training progress: step=9950/100000 (9.95%), epoch=0, lr=1e-05, speed=0.663 step/s, elapsed=04:10:01, eta=37:42:46 +[2026-04-15 09:45:28,486][trainer.accelerators.base_accelerator][INFO] - Training progress: step=10000/100000 (10.00%), epoch=0, lr=1e-05, speed=0.666 step/s, elapsed=04:10:19, eta=37:32:52 +[2026-04-15 09:45:28,510][__main__][INFO] - ========== EVAL START (periodic@gstep=10000) ========== +[2026-04-15 09:45:28,511][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-15 09:45:28,511][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 09:45:43,567][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.229820251464844, 'accuracy': 0.4776470588235294, 'num_samples': 425, 'test_unique_accuracy': 0.5046296296296297, 'test_unique_num_samples': 432} +[2026-04-15 09:45:43,567][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-15 09:45:43,567][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 09:45:59,079][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.229820251464844, 'accuracy': 0.4776470588235294, 'num_samples': 425, 'test_unique_accuracy': 0.5, 'test_unique_num_samples': 432} +[2026-04-15 09:45:59,079][__main__][INFO] - ========== EVAL END (periodic@gstep=10000) ========== +[2026-04-15 09:45:59,079][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.22332763671875, 'accuracy': 0.4776470588235294, 'num_samples': 425, 'test_unique_accuracy': 0.5, 'test_unique_num_samples': 432} +[2026-04-15 09:45:59,082][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.4776470588235294 is not better than 0.48705882352941177 of logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep1000, skipping checkpoint +[2026-04-15 09:46:16,918][trainer.accelerators.base_accelerator][INFO] - Training progress: step=10050/100000 (10.05%), epoch=0, lr=1e-05, speed=0.667 step/s, elapsed=04:11:07, eta=37:27:38 +[2026-04-15 09:46:34,593][trainer.accelerators.base_accelerator][INFO] - Training progress: step=10100/100000 (10.10%), epoch=0, lr=1e-05, speed=0.670 step/s, elapsed=04:11:25, eta=37:17:53 +[2026-04-15 09:46:52,454][trainer.accelerators.base_accelerator][INFO] - Training progress: step=10150/100000 (10.15%), epoch=0, lr=1e-05, speed=0.672 step/s, elapsed=04:11:43, eta=37:08:16 +[2026-04-15 09:47:10,224][trainer.accelerators.base_accelerator][INFO] - Training progress: step=10200/100000 (10.20%), epoch=0, lr=1e-05, speed=0.675 step/s, elapsed=04:12:00, eta=36:58:43 +[2026-04-15 09:47:28,058][trainer.accelerators.base_accelerator][INFO] - Training progress: step=10250/100000 (10.25%), epoch=0, lr=1e-05, speed=0.677 step/s, elapsed=04:12:18, eta=36:49:16 +[2026-04-15 09:47:45,875][trainer.accelerators.base_accelerator][INFO] - Training progress: step=10300/100000 (10.30%), epoch=0, lr=1e-05, speed=0.680 step/s, elapsed=04:12:36, eta=36:39:54 +[2026-04-15 09:48:03,828][trainer.accelerators.base_accelerator][INFO] - Training progress: step=10350/100000 (10.35%), epoch=0, lr=1e-05, speed=0.682 step/s, elapsed=04:12:54, eta=36:30:39 +[2026-04-15 09:48:21,782][trainer.accelerators.base_accelerator][INFO] - Training progress: step=10400/100000 (10.40%), epoch=0, lr=1e-05, speed=0.685 step/s, elapsed=04:13:12, eta=36:21:28 +[2026-04-15 09:48:39,679][trainer.accelerators.base_accelerator][INFO] - Training progress: step=10450/100000 (10.45%), epoch=0, lr=1e-05, speed=0.687 step/s, elapsed=04:13:30, eta=36:12:23 +[2026-04-15 09:48:57,554][trainer.accelerators.base_accelerator][INFO] - Training progress: step=10500/100000 (10.50%), epoch=0, lr=1e-05, speed=0.690 step/s, elapsed=04:13:48, eta=36:03:22 +[2026-04-15 09:49:15,515][trainer.accelerators.base_accelerator][INFO] - Training progress: step=10550/100000 (10.55%), epoch=0, lr=1e-05, speed=0.692 step/s, elapsed=04:14:06, eta=35:54:27 +[2026-04-15 09:49:33,482][trainer.accelerators.base_accelerator][INFO] - Training progress: step=10600/100000 (10.60%), epoch=0, lr=1e-05, speed=0.694 step/s, elapsed=04:14:24, eta=35:45:37 +[2026-04-15 09:49:51,296][trainer.accelerators.base_accelerator][INFO] - Training progress: step=10650/100000 (10.65%), epoch=0, lr=1e-05, speed=0.697 step/s, elapsed=04:14:41, eta=35:36:50 +[2026-04-15 09:50:09,191][trainer.accelerators.base_accelerator][INFO] - Training progress: step=10700/100000 (10.70%), epoch=0, lr=1e-05, speed=0.699 step/s, elapsed=04:14:59, eta=35:28:09 +[2026-04-15 09:50:27,099][trainer.accelerators.base_accelerator][INFO] - Training progress: step=10750/100000 (10.75%), epoch=0, lr=1e-05, speed=0.702 step/s, elapsed=04:15:17, eta=35:19:33 +[2026-04-15 09:50:44,864][trainer.accelerators.base_accelerator][INFO] - Training progress: step=10800/100000 (10.80%), epoch=0, lr=1e-05, speed=0.704 step/s, elapsed=04:15:35, eta=35:11:00 +[2026-04-15 09:51:02,817][trainer.accelerators.base_accelerator][INFO] - Training progress: step=10850/100000 (10.85%), epoch=0, lr=1e-05, speed=0.707 step/s, elapsed=04:15:53, eta=35:02:33 +[2026-04-15 09:51:20,649][trainer.accelerators.base_accelerator][INFO] - Training progress: step=10900/100000 (10.90%), epoch=0, lr=1e-05, speed=0.709 step/s, elapsed=04:16:11, eta=34:54:10 +[2026-04-15 09:51:38,530][trainer.accelerators.base_accelerator][INFO] - Training progress: step=10950/100000 (10.95%), epoch=0, lr=1e-05, speed=0.712 step/s, elapsed=04:16:29, eta=34:45:51 +[2026-04-15 09:51:56,416][trainer.accelerators.base_accelerator][INFO] - Training progress: step=11000/100000 (11.00%), epoch=0, lr=1e-05, speed=0.714 step/s, elapsed=04:16:47, eta=34:37:37 +[2026-04-15 09:51:56,439][__main__][INFO] - ========== EVAL START (periodic@gstep=11000) ========== +[2026-04-15 09:51:56,440][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-15 09:51:56,440][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 09:52:11,423][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.22332763671875, 'accuracy': 0.4894117647058824, 'num_samples': 425, 'test_unique_accuracy': 0.5, 'test_unique_num_samples': 432} +[2026-04-15 09:52:11,424][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-15 09:52:11,424][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 09:52:26,428][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.22332763671875, 'accuracy': 0.4894117647058824, 'num_samples': 425, 'test_unique_accuracy': 0.5115740740740741, 'test_unique_num_samples': 432} +[2026-04-15 09:52:26,428][__main__][INFO] - ========== EVAL END (periodic@gstep=11000) ========== +[2026-04-15 09:52:26,428][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.224198341369629, 'accuracy': 0.4894117647058824, 'num_samples': 425, 'test_unique_accuracy': 0.5115740740740741, 'test_unique_num_samples': 432} +[2026-04-15 09:52:26,432][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.4894117647058824 is not better than 0.52 of logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep2000, skipping checkpoint +[2026-04-15 09:52:44,620][trainer.accelerators.base_accelerator][INFO] - Training progress: step=11050/100000 (11.05%), epoch=0, lr=1e-05, speed=0.715 step/s, elapsed=04:17:35, eta=34:33:31 +[2026-04-15 09:53:02,482][trainer.accelerators.base_accelerator][INFO] - Training progress: step=11100/100000 (11.10%), epoch=0, lr=1e-05, speed=0.717 step/s, elapsed=04:17:53, eta=34:25:24 +[2026-04-15 09:53:20,655][trainer.accelerators.base_accelerator][INFO] - Training progress: step=11150/100000 (11.15%), epoch=0, lr=1e-05, speed=0.720 step/s, elapsed=04:18:11, eta=34:17:24 +[2026-04-15 09:53:38,615][trainer.accelerators.base_accelerator][INFO] - Training progress: step=11200/100000 (11.20%), epoch=0, lr=1e-05, speed=0.722 step/s, elapsed=04:18:29, eta=34:09:26 +[2026-04-15 09:53:56,441][trainer.accelerators.base_accelerator][INFO] - Training progress: step=11250/100000 (11.25%), epoch=0, lr=1e-05, speed=0.725 step/s, elapsed=04:18:47, eta=34:01:31 +[2026-04-15 09:54:14,415][trainer.accelerators.base_accelerator][INFO] - Training progress: step=11300/100000 (11.30%), epoch=0, lr=1e-05, speed=0.727 step/s, elapsed=04:19:05, eta=33:53:42 +[2026-04-15 09:54:32,337][trainer.accelerators.base_accelerator][INFO] - Training progress: step=11350/100000 (11.35%), epoch=0, lr=1e-05, speed=0.729 step/s, elapsed=04:19:23, eta=33:45:56 +[2026-04-15 09:54:50,288][trainer.accelerators.base_accelerator][INFO] - Training progress: step=11400/100000 (11.40%), epoch=0, lr=1e-05, speed=0.732 step/s, elapsed=04:19:40, eta=33:38:14 +[2026-04-15 09:55:08,156][trainer.accelerators.base_accelerator][INFO] - Training progress: step=11450/100000 (11.45%), epoch=0, lr=1e-05, speed=0.734 step/s, elapsed=04:19:58, eta=33:30:35 +[2026-04-15 09:55:26,283][trainer.accelerators.base_accelerator][INFO] - Training progress: step=11500/100000 (11.50%), epoch=0, lr=1e-05, speed=0.736 step/s, elapsed=04:20:16, eta=33:23:02 +[2026-04-15 09:55:44,199][trainer.accelerators.base_accelerator][INFO] - Training progress: step=11550/100000 (11.55%), epoch=0, lr=1e-05, speed=0.739 step/s, elapsed=04:20:34, eta=33:15:32 +[2026-04-15 09:56:02,178][trainer.accelerators.base_accelerator][INFO] - Training progress: step=11600/100000 (11.60%), epoch=0, lr=1e-05, speed=0.741 step/s, elapsed=04:20:52, eta=33:08:05 +[2026-04-15 09:56:20,016][trainer.accelerators.base_accelerator][INFO] - Training progress: step=11650/100000 (11.65%), epoch=0, lr=1e-05, speed=0.743 step/s, elapsed=04:21:10, eta=33:00:41 +[2026-04-15 09:56:37,926][trainer.accelerators.base_accelerator][INFO] - Training progress: step=11700/100000 (11.70%), epoch=0, lr=1e-05, speed=0.746 step/s, elapsed=04:21:28, eta=32:53:22 +[2026-04-15 09:56:55,792][trainer.accelerators.base_accelerator][INFO] - Training progress: step=11750/100000 (11.75%), epoch=0, lr=1e-05, speed=0.748 step/s, elapsed=04:21:46, eta=32:46:05 +[2026-04-15 09:57:13,587][trainer.accelerators.base_accelerator][INFO] - Training progress: step=11800/100000 (11.80%), epoch=0, lr=1e-05, speed=0.750 step/s, elapsed=04:22:04, eta=32:38:52 +[2026-04-15 09:57:31,447][trainer.accelerators.base_accelerator][INFO] - Training progress: step=11850/100000 (11.85%), epoch=0, lr=1e-05, speed=0.753 step/s, elapsed=04:22:22, eta=32:31:42 +[2026-04-15 09:57:49,382][trainer.accelerators.base_accelerator][INFO] - Training progress: step=11900/100000 (11.90%), epoch=0, lr=1e-05, speed=0.755 step/s, elapsed=04:22:40, eta=32:24:37 +[2026-04-15 09:58:07,298][trainer.accelerators.base_accelerator][INFO] - Training progress: step=11950/100000 (11.95%), epoch=0, lr=1e-05, speed=0.757 step/s, elapsed=04:22:57, eta=32:17:35 +[2026-04-15 09:58:25,175][trainer.accelerators.base_accelerator][INFO] - Training progress: step=12000/100000 (12.00%), epoch=0, lr=1e-05, speed=0.760 step/s, elapsed=04:23:15, eta=32:10:36 +[2026-04-15 09:58:25,198][__main__][INFO] - ========== EVAL START (periodic@gstep=12000) ========== +[2026-04-15 09:58:25,198][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-15 09:58:25,199][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 09:58:45,305][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.224198341369629, 'accuracy': 0.48470588235294115, 'num_samples': 425, 'test_unique_accuracy': 0.5115740740740741, 'test_unique_num_samples': 432} +[2026-04-15 09:58:45,306][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-15 09:58:45,306][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 09:59:00,356][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.224198341369629, 'accuracy': 0.48470588235294115, 'num_samples': 425, 'test_unique_accuracy': 0.5023148148148148, 'test_unique_num_samples': 432} +[2026-04-15 09:59:00,356][__main__][INFO] - ========== EVAL END (periodic@gstep=12000) ========== +[2026-04-15 09:59:00,356][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.222635269165039, 'accuracy': 0.48470588235294115, 'num_samples': 425, 'test_unique_accuracy': 0.5023148148148148, 'test_unique_num_samples': 432} +[2026-04-15 09:59:00,420][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.48470588235294115 is not better than 0.48705882352941177 of logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep1000, skipping checkpoint +[2026-04-15 09:59:18,297][trainer.accelerators.base_accelerator][INFO] - Training progress: step=12050/100000 (12.05%), epoch=0, lr=1e-05, speed=0.760 step/s, elapsed=04:24:08, eta=32:07:57 +[2026-04-15 09:59:36,178][trainer.accelerators.base_accelerator][INFO] - Training progress: step=12100/100000 (12.10%), epoch=0, lr=1e-05, speed=0.763 step/s, elapsed=04:24:26, eta=32:01:04 +[2026-04-15 09:59:54,349][trainer.accelerators.base_accelerator][INFO] - Training progress: step=12150/100000 (12.15%), epoch=0, lr=1e-05, speed=0.765 step/s, elapsed=04:24:45, eta=31:54:15 +[2026-04-15 10:00:12,267][trainer.accelerators.base_accelerator][INFO] - Training progress: step=12200/100000 (12.20%), epoch=0, lr=1e-05, speed=0.767 step/s, elapsed=04:25:02, eta=31:47:29 +[2026-04-15 10:00:30,160][trainer.accelerators.base_accelerator][INFO] - Training progress: step=12250/100000 (12.25%), epoch=0, lr=1e-05, speed=0.769 step/s, elapsed=04:25:20, eta=31:40:45 +[2026-04-15 10:00:47,998][trainer.accelerators.base_accelerator][INFO] - Training progress: step=12300/100000 (12.30%), epoch=0, lr=1e-05, speed=0.772 step/s, elapsed=04:25:38, eta=31:34:04 +[2026-04-15 10:01:05,835][trainer.accelerators.base_accelerator][INFO] - Training progress: step=12350/100000 (12.35%), epoch=0, lr=1e-05, speed=0.774 step/s, elapsed=04:25:56, eta=31:27:26 +[2026-04-15 10:01:23,640][trainer.accelerators.base_accelerator][INFO] - Training progress: step=12400/100000 (12.40%), epoch=0, lr=1e-05, speed=0.776 step/s, elapsed=04:26:14, eta=31:20:50 +[2026-04-15 10:01:41,423][trainer.accelerators.base_accelerator][INFO] - Training progress: step=12450/100000 (12.45%), epoch=0, lr=1e-05, speed=0.779 step/s, elapsed=04:26:32, eta=31:14:18 +[2026-04-15 10:01:59,322][trainer.accelerators.base_accelerator][INFO] - Training progress: step=12500/100000 (12.50%), epoch=0, lr=1e-05, speed=0.781 step/s, elapsed=04:26:50, eta=31:07:50 +[2026-04-15 10:02:17,241][trainer.accelerators.base_accelerator][INFO] - Training progress: step=12550/100000 (12.55%), epoch=0, lr=1e-05, speed=0.783 step/s, elapsed=04:27:07, eta=31:01:24 +[2026-04-15 10:02:35,133][trainer.accelerators.base_accelerator][INFO] - Training progress: step=12600/100000 (12.60%), epoch=0, lr=1e-05, speed=0.785 step/s, elapsed=04:27:25, eta=30:55:01 +[2026-04-15 10:02:53,042][trainer.accelerators.base_accelerator][INFO] - Training progress: step=12650/100000 (12.65%), epoch=0, lr=1e-05, speed=0.787 step/s, elapsed=04:27:43, eta=30:48:42 +[2026-04-15 10:03:10,952][trainer.accelerators.base_accelerator][INFO] - Training progress: step=12700/100000 (12.70%), epoch=0, lr=1e-05, speed=0.790 step/s, elapsed=04:28:01, eta=30:42:25 +[2026-04-15 10:03:28,822][trainer.accelerators.base_accelerator][INFO] - Training progress: step=12750/100000 (12.75%), epoch=0, lr=1e-05, speed=0.792 step/s, elapsed=04:28:19, eta=30:36:11 +[2026-04-15 10:03:46,647][trainer.accelerators.base_accelerator][INFO] - Training progress: step=12800/100000 (12.80%), epoch=0, lr=1e-05, speed=0.794 step/s, elapsed=04:28:37, eta=30:29:59 +[2026-04-15 10:04:04,361][trainer.accelerators.base_accelerator][INFO] - Training progress: step=12850/100000 (12.85%), epoch=0, lr=1e-05, speed=0.796 step/s, elapsed=04:28:55, eta=30:23:49 +[2026-04-15 10:04:22,220][trainer.accelerators.base_accelerator][INFO] - Training progress: step=12900/100000 (12.90%), epoch=0, lr=1e-05, speed=0.799 step/s, elapsed=04:29:12, eta=30:17:43 +[2026-04-15 10:04:40,056][trainer.accelerators.base_accelerator][INFO] - Training progress: step=12950/100000 (12.95%), epoch=0, lr=1e-05, speed=0.801 step/s, elapsed=04:29:30, eta=30:11:39 +[2026-04-15 10:04:57,911][trainer.accelerators.base_accelerator][INFO] - Training progress: step=13000/100000 (13.00%), epoch=0, lr=1e-05, speed=0.803 step/s, elapsed=04:29:48, eta=30:05:39 +[2026-04-15 10:04:57,936][__main__][INFO] - ========== EVAL START (periodic@gstep=13000) ========== +[2026-04-15 10:04:57,936][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-15 10:04:57,936][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 10:05:13,622][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.222635269165039, 'accuracy': 0.47058823529411764, 'num_samples': 425, 'test_unique_accuracy': 0.5023148148148148, 'test_unique_num_samples': 432} +[2026-04-15 10:05:13,623][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-15 10:05:13,623][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 10:05:28,684][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.222635269165039, 'accuracy': 0.47058823529411764, 'num_samples': 425, 'test_unique_accuracy': 0.4699074074074074, 'test_unique_num_samples': 432} +[2026-04-15 10:05:28,685][__main__][INFO] - ========== EVAL END (periodic@gstep=13000) ========== +[2026-04-15 10:05:28,685][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.215462684631348, 'accuracy': 0.47058823529411764, 'num_samples': 425, 'test_unique_accuracy': 0.4699074074074074, 'test_unique_num_samples': 432} +[2026-04-15 10:05:28,690][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.47058823529411764 is not better than 0.48705882352941177 of logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep1000, skipping checkpoint +[2026-04-15 10:05:46,661][trainer.accelerators.base_accelerator][INFO] - Training progress: step=13050/100000 (13.05%), epoch=0, lr=1e-05, speed=0.804 step/s, elapsed=04:30:37, eta=30:03:06 +[2026-04-15 10:06:04,601][trainer.accelerators.base_accelerator][INFO] - Training progress: step=13100/100000 (13.10%), epoch=0, lr=1e-05, speed=0.806 step/s, elapsed=04:30:55, eta=29:57:10 +[2026-04-15 10:06:22,383][trainer.accelerators.base_accelerator][INFO] - Training progress: step=13150/100000 (13.15%), epoch=0, lr=1e-05, speed=0.808 step/s, elapsed=04:31:13, eta=29:51:16 +[2026-04-15 10:06:40,263][trainer.accelerators.base_accelerator][INFO] - Training progress: step=13200/100000 (13.20%), epoch=0, lr=1e-05, speed=0.810 step/s, elapsed=04:31:30, eta=29:45:25 +[2026-04-15 10:06:58,522][trainer.accelerators.base_accelerator][INFO] - Training progress: step=13250/100000 (13.25%), epoch=0, lr=1e-05, speed=0.812 step/s, elapsed=04:31:49, eta=29:39:39 +[2026-04-15 10:07:16,357][trainer.accelerators.base_accelerator][INFO] - Training progress: step=13300/100000 (13.30%), epoch=0, lr=1e-05, speed=0.815 step/s, elapsed=04:32:07, eta=29:33:52 +[2026-04-15 10:07:34,230][trainer.accelerators.base_accelerator][INFO] - Training progress: step=13350/100000 (13.35%), epoch=0, lr=1e-05, speed=0.817 step/s, elapsed=04:32:24, eta=29:28:08 +[2026-04-15 10:07:52,118][trainer.accelerators.base_accelerator][INFO] - Training progress: step=13400/100000 (13.40%), epoch=0, lr=1e-05, speed=0.819 step/s, elapsed=04:32:42, eta=29:22:27 +[2026-04-15 10:08:10,038][trainer.accelerators.base_accelerator][INFO] - Training progress: step=13450/100000 (13.45%), epoch=0, lr=1e-05, speed=0.821 step/s, elapsed=04:33:00, eta=29:16:49 +[2026-04-15 10:08:28,027][trainer.accelerators.base_accelerator][INFO] - Training progress: step=13500/100000 (13.50%), epoch=0, lr=1e-05, speed=0.823 step/s, elapsed=04:33:18, eta=29:11:13 +[2026-04-15 10:08:46,139][trainer.accelerators.base_accelerator][INFO] - Training progress: step=13550/100000 (13.55%), epoch=0, lr=1e-05, speed=0.825 step/s, elapsed=04:33:36, eta=29:05:40 +[2026-04-15 10:09:04,013][trainer.accelerators.base_accelerator][INFO] - Training progress: step=13600/100000 (13.60%), epoch=0, lr=1e-05, speed=0.828 step/s, elapsed=04:33:54, eta=29:00:08 +[2026-04-15 10:09:21,907][trainer.accelerators.base_accelerator][INFO] - Training progress: step=13650/100000 (13.65%), epoch=0, lr=1e-05, speed=0.830 step/s, elapsed=04:34:12, eta=28:54:39 +[2026-04-15 10:09:39,856][trainer.accelerators.base_accelerator][INFO] - Training progress: step=13700/100000 (13.70%), epoch=0, lr=1e-05, speed=0.832 step/s, elapsed=04:34:30, eta=28:49:12 +[2026-04-15 10:09:57,723][trainer.accelerators.base_accelerator][INFO] - Training progress: step=13750/100000 (13.75%), epoch=0, lr=1e-05, speed=0.834 step/s, elapsed=04:34:48, eta=28:43:47 +[2026-04-15 10:10:15,624][trainer.accelerators.base_accelerator][INFO] - Training progress: step=13800/100000 (13.80%), epoch=0, lr=1e-05, speed=0.836 step/s, elapsed=04:35:06, eta=28:38:24 +[2026-04-15 10:10:33,449][trainer.accelerators.base_accelerator][INFO] - Training progress: step=13850/100000 (13.85%), epoch=0, lr=1e-05, speed=0.838 step/s, elapsed=04:35:24, eta=28:33:03 +[2026-04-15 10:10:51,331][trainer.accelerators.base_accelerator][INFO] - Training progress: step=13900/100000 (13.90%), epoch=0, lr=1e-05, speed=0.840 step/s, elapsed=04:35:42, eta=28:27:45 +[2026-04-15 10:11:09,265][trainer.accelerators.base_accelerator][INFO] - Training progress: step=13950/100000 (13.95%), epoch=0, lr=1e-05, speed=0.842 step/s, elapsed=04:35:59, eta=28:22:29 +[2026-04-15 10:11:27,163][trainer.accelerators.base_accelerator][INFO] - Training progress: step=14000/100000 (14.00%), epoch=0, lr=1e-05, speed=0.845 step/s, elapsed=04:36:17, eta=28:17:15 +[2026-04-15 10:11:27,187][__main__][INFO] - ========== EVAL START (periodic@gstep=14000) ========== +[2026-04-15 10:11:27,187][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-15 10:11:27,188][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 10:11:44,280][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.215462684631348, 'accuracy': 0.48, 'num_samples': 425, 'test_unique_accuracy': 0.4699074074074074, 'test_unique_num_samples': 432} +[2026-04-15 10:11:44,280][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-15 10:11:44,280][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 10:11:59,357][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.215462684631348, 'accuracy': 0.48, 'num_samples': 425, 'test_unique_accuracy': 0.5555555555555556, 'test_unique_num_samples': 432} +[2026-04-15 10:11:59,357][__main__][INFO] - ========== EVAL END (periodic@gstep=14000) ========== +[2026-04-15 10:11:59,357][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.213327407836914, 'accuracy': 0.48, 'num_samples': 425, 'test_unique_accuracy': 0.5555555555555556, 'test_unique_num_samples': 432} +[2026-04-15 10:11:59,360][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.48 is not better than 0.48705882352941177 of logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep1000, skipping checkpoint +[2026-04-15 10:12:17,189][trainer.accelerators.base_accelerator][INFO] - Training progress: step=14050/100000 (14.05%), epoch=0, lr=1e-05, speed=0.845 step/s, elapsed=04:37:07, eta=28:15:19 +[2026-04-15 10:12:35,000][trainer.accelerators.base_accelerator][INFO] - Training progress: step=14100/100000 (14.10%), epoch=0, lr=1e-05, speed=0.847 step/s, elapsed=04:37:25, eta=28:10:08 +[2026-04-15 10:12:52,988][trainer.accelerators.base_accelerator][INFO] - Training progress: step=14150/100000 (14.15%), epoch=0, lr=1e-05, speed=0.849 step/s, elapsed=04:37:43, eta=28:05:00 +[2026-04-15 10:13:10,696][trainer.accelerators.base_accelerator][INFO] - Training progress: step=14200/100000 (14.20%), epoch=0, lr=1e-05, speed=0.851 step/s, elapsed=04:38:01, eta=27:59:53 +[2026-04-15 10:13:28,553][trainer.accelerators.base_accelerator][INFO] - Training progress: step=14250/100000 (14.25%), epoch=0, lr=1e-05, speed=0.853 step/s, elapsed=04:38:19, eta=27:54:48 +[2026-04-15 10:13:46,434][trainer.accelerators.base_accelerator][INFO] - Training progress: step=14300/100000 (14.30%), epoch=0, lr=1e-05, speed=0.855 step/s, elapsed=04:38:37, eta=27:49:45 +[2026-04-15 10:14:04,596][trainer.accelerators.base_accelerator][INFO] - Training progress: step=14350/100000 (14.35%), epoch=0, lr=1e-05, speed=0.857 step/s, elapsed=04:38:55, eta=27:44:46 +[2026-04-15 10:14:22,421][trainer.accelerators.base_accelerator][INFO] - Training progress: step=14400/100000 (14.40%), epoch=0, lr=1e-05, speed=0.860 step/s, elapsed=04:39:13, eta=27:39:47 +[2026-04-15 10:14:40,176][trainer.accelerators.base_accelerator][INFO] - Training progress: step=14450/100000 (14.45%), epoch=0, lr=1e-05, speed=0.862 step/s, elapsed=04:39:30, eta=27:34:50 +[2026-04-15 10:14:58,034][trainer.accelerators.base_accelerator][INFO] - Training progress: step=14500/100000 (14.50%), epoch=0, lr=1e-05, speed=0.864 step/s, elapsed=04:39:48, eta=27:29:55 +[2026-04-15 10:15:15,859][trainer.accelerators.base_accelerator][INFO] - Training progress: step=14550/100000 (14.55%), epoch=0, lr=1e-05, speed=0.866 step/s, elapsed=04:40:06, eta=27:25:02 +[2026-04-15 10:15:33,736][trainer.accelerators.base_accelerator][INFO] - Training progress: step=14600/100000 (14.60%), epoch=0, lr=1e-05, speed=0.868 step/s, elapsed=04:40:24, eta=27:20:11 +[2026-04-15 10:15:51,583][trainer.accelerators.base_accelerator][INFO] - Training progress: step=14650/100000 (14.65%), epoch=0, lr=1e-05, speed=0.870 step/s, elapsed=04:40:42, eta=27:15:22 +[2026-04-15 10:16:09,453][trainer.accelerators.base_accelerator][INFO] - Training progress: step=14700/100000 (14.70%), epoch=0, lr=1e-05, speed=0.872 step/s, elapsed=04:41:00, eta=27:10:34 +[2026-04-15 10:16:27,364][trainer.accelerators.base_accelerator][INFO] - Training progress: step=14750/100000 (14.75%), epoch=0, lr=1e-05, speed=0.874 step/s, elapsed=04:41:18, eta=27:05:49 +[2026-04-15 10:16:45,219][trainer.accelerators.base_accelerator][INFO] - Training progress: step=14800/100000 (14.80%), epoch=0, lr=1e-05, speed=0.876 step/s, elapsed=04:41:35, eta=27:01:05 +[2026-04-15 10:17:03,079][trainer.accelerators.base_accelerator][INFO] - Training progress: step=14850/100000 (14.85%), epoch=0, lr=1e-05, speed=0.878 step/s, elapsed=04:41:53, eta=26:56:23 +[2026-04-15 10:17:20,839][trainer.accelerators.base_accelerator][INFO] - Training progress: step=14900/100000 (14.90%), epoch=0, lr=1e-05, speed=0.880 step/s, elapsed=04:42:11, eta=26:51:42 +[2026-04-15 10:17:38,724][trainer.accelerators.base_accelerator][INFO] - Training progress: step=14950/100000 (14.95%), epoch=0, lr=1e-05, speed=0.882 step/s, elapsed=04:42:29, eta=26:47:04 +[2026-04-15 10:17:56,495][trainer.accelerators.base_accelerator][INFO] - Training progress: step=15000/100000 (15.00%), epoch=0, lr=1e-05, speed=0.884 step/s, elapsed=04:42:47, eta=26:42:27 +[2026-04-15 10:17:56,520][__main__][INFO] - ========== EVAL START (periodic@gstep=15000) ========== +[2026-04-15 10:17:56,520][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-15 10:17:56,520][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 10:18:11,589][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.213327407836914, 'accuracy': 0.45647058823529413, 'num_samples': 425, 'test_unique_accuracy': 0.5555555555555556, 'test_unique_num_samples': 432} +[2026-04-15 10:18:11,590][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-15 10:18:11,590][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 10:18:26,654][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.213327407836914, 'accuracy': 0.45647058823529413, 'num_samples': 425, 'test_unique_accuracy': 0.5300925925925926, 'test_unique_num_samples': 432} +[2026-04-15 10:18:26,654][__main__][INFO] - ========== EVAL END (periodic@gstep=15000) ========== +[2026-04-15 10:18:26,654][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.214885711669922, 'accuracy': 0.45647058823529413, 'num_samples': 425, 'test_unique_accuracy': 0.5300925925925926, 'test_unique_num_samples': 432} +[2026-04-15 10:18:26,657][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.45647058823529413 is not better than 0.48705882352941177 of logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep1000, skipping checkpoint +[2026-04-15 10:18:44,518][trainer.accelerators.base_accelerator][INFO] - Training progress: step=15050/100000 (15.05%), epoch=0, lr=1e-05, speed=0.885 step/s, elapsed=04:43:35, eta=26:40:42 +[2026-04-15 10:19:02,452][trainer.accelerators.base_accelerator][INFO] - Training progress: step=15100/100000 (15.10%), epoch=0, lr=1e-05, speed=0.887 step/s, elapsed=04:43:53, eta=26:36:09 +[2026-04-15 10:19:20,366][trainer.accelerators.base_accelerator][INFO] - Training progress: step=15150/100000 (15.15%), epoch=0, lr=1e-05, speed=0.889 step/s, elapsed=04:44:11, eta=26:31:37 +[2026-04-15 10:19:38,282][trainer.accelerators.base_accelerator][INFO] - Training progress: step=15200/100000 (15.20%), epoch=0, lr=1e-05, speed=0.891 step/s, elapsed=04:44:28, eta=26:27:06 +[2026-04-15 10:19:56,165][trainer.accelerators.base_accelerator][INFO] - Training progress: step=15250/100000 (15.25%), epoch=0, lr=1e-05, speed=0.892 step/s, elapsed=04:44:46, eta=26:22:38 +[2026-04-15 10:20:13,983][trainer.accelerators.base_accelerator][INFO] - Training progress: step=15300/100000 (15.30%), epoch=0, lr=1e-05, speed=0.894 step/s, elapsed=04:45:04, eta=26:18:10 +[2026-04-15 10:20:31,877][trainer.accelerators.base_accelerator][INFO] - Training progress: step=15350/100000 (15.35%), epoch=0, lr=1e-05, speed=0.896 step/s, elapsed=04:45:22, eta=26:13:45 +[2026-04-15 10:20:50,073][trainer.accelerators.base_accelerator][INFO] - Training progress: step=15400/100000 (15.40%), epoch=0, lr=1e-05, speed=0.898 step/s, elapsed=04:45:40, eta=26:09:22 +[2026-04-15 10:21:07,960][trainer.accelerators.base_accelerator][INFO] - Training progress: step=15450/100000 (15.45%), epoch=0, lr=1e-05, speed=0.900 step/s, elapsed=04:45:58, eta=26:05:00 +[2026-04-15 10:21:25,873][trainer.accelerators.base_accelerator][INFO] - Training progress: step=15500/100000 (15.50%), epoch=0, lr=1e-05, speed=0.902 step/s, elapsed=04:46:16, eta=26:00:39 +[2026-04-15 10:21:43,737][trainer.accelerators.base_accelerator][INFO] - Training progress: step=15550/100000 (15.55%), epoch=0, lr=1e-05, speed=0.904 step/s, elapsed=04:46:34, eta=25:56:20 +[2026-04-15 10:22:01,616][trainer.accelerators.base_accelerator][INFO] - Training progress: step=15600/100000 (15.60%), epoch=0, lr=1e-05, speed=0.906 step/s, elapsed=04:46:52, eta=25:52:02 +[2026-04-15 10:22:19,463][trainer.accelerators.base_accelerator][INFO] - Training progress: step=15650/100000 (15.65%), epoch=0, lr=1e-05, speed=0.908 step/s, elapsed=04:47:10, eta=25:47:46 +[2026-04-15 10:22:37,338][trainer.accelerators.base_accelerator][INFO] - Training progress: step=15700/100000 (15.70%), epoch=0, lr=1e-05, speed=0.910 step/s, elapsed=04:47:28, eta=25:43:31 +[2026-04-15 10:22:55,268][trainer.accelerators.base_accelerator][INFO] - Training progress: step=15750/100000 (15.75%), epoch=0, lr=1e-05, speed=0.912 step/s, elapsed=04:47:45, eta=25:39:19 +[2026-04-15 10:23:13,109][trainer.accelerators.base_accelerator][INFO] - Training progress: step=15800/100000 (15.80%), epoch=0, lr=1e-05, speed=0.914 step/s, elapsed=04:48:03, eta=25:35:07 +[2026-04-15 10:23:31,003][trainer.accelerators.base_accelerator][INFO] - Training progress: step=15850/100000 (15.85%), epoch=0, lr=1e-05, speed=0.916 step/s, elapsed=04:48:21, eta=25:30:57 +[2026-04-15 10:23:48,908][trainer.accelerators.base_accelerator][INFO] - Training progress: step=15900/100000 (15.90%), epoch=0, lr=1e-05, speed=0.918 step/s, elapsed=04:48:39, eta=25:26:48 +[2026-04-15 10:24:06,675][trainer.accelerators.base_accelerator][INFO] - Training progress: step=15950/100000 (15.95%), epoch=0, lr=1e-05, speed=0.920 step/s, elapsed=04:48:57, eta=25:22:40 +[2026-04-15 10:24:24,561][trainer.accelerators.base_accelerator][INFO] - Training progress: step=16000/100000 (16.00%), epoch=0, lr=1e-05, speed=0.922 step/s, elapsed=04:49:15, eta=25:18:35 +[2026-04-15 10:24:24,584][__main__][INFO] - ========== EVAL START (periodic@gstep=16000) ========== +[2026-04-15 10:24:24,585][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-15 10:24:24,585][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 10:24:41,205][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.214885711669922, 'accuracy': 0.47058823529411764, 'num_samples': 425, 'test_unique_accuracy': 0.5300925925925926, 'test_unique_num_samples': 432} +[2026-04-15 10:24:41,205][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-15 10:24:41,205][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 10:24:56,268][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.214885711669922, 'accuracy': 0.47058823529411764, 'num_samples': 425, 'test_unique_accuracy': 0.5, 'test_unique_num_samples': 432} +[2026-04-15 10:24:56,268][__main__][INFO] - ========== EVAL END (periodic@gstep=16000) ========== +[2026-04-15 10:24:56,268][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.204282760620117, 'accuracy': 0.47058823529411764, 'num_samples': 425, 'test_unique_accuracy': 0.5, 'test_unique_num_samples': 432} +[2026-04-15 10:24:56,273][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.47058823529411764 is not better than 0.48705882352941177 of logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep1000, skipping checkpoint +[2026-04-15 10:25:14,103][trainer.accelerators.base_accelerator][INFO] - Training progress: step=16050/100000 (16.05%), epoch=0, lr=1e-05, speed=0.922 step/s, elapsed=04:50:04, eta=25:17:16 +[2026-04-15 10:25:31,956][trainer.accelerators.base_accelerator][INFO] - Training progress: step=16100/100000 (16.10%), epoch=0, lr=1e-05, speed=0.924 step/s, elapsed=04:50:22, eta=25:13:12 +[2026-04-15 10:25:49,868][trainer.accelerators.base_accelerator][INFO] - Training progress: step=16150/100000 (16.15%), epoch=0, lr=1e-05, speed=0.926 step/s, elapsed=04:50:40, eta=25:09:10 +[2026-04-15 10:26:07,725][trainer.accelerators.base_accelerator][INFO] - Training progress: step=16200/100000 (16.20%), epoch=0, lr=1e-05, speed=0.928 step/s, elapsed=04:50:58, eta=25:05:09 +[2026-04-15 10:26:25,613][trainer.accelerators.base_accelerator][INFO] - Training progress: step=16250/100000 (16.25%), epoch=0, lr=1e-05, speed=0.930 step/s, elapsed=04:51:16, eta=25:01:10 +[2026-04-15 10:26:43,489][trainer.accelerators.base_accelerator][INFO] - Training progress: step=16300/100000 (16.30%), epoch=0, lr=1e-05, speed=0.932 step/s, elapsed=04:51:34, eta=24:57:12 +[2026-04-15 10:27:01,672][trainer.accelerators.base_accelerator][INFO] - Training progress: step=16350/100000 (16.35%), epoch=0, lr=1e-05, speed=0.934 step/s, elapsed=04:51:52, eta=24:53:16 +[2026-04-15 10:27:19,549][trainer.accelerators.base_accelerator][INFO] - Training progress: step=16400/100000 (16.40%), epoch=0, lr=1e-05, speed=0.936 step/s, elapsed=04:52:10, eta=24:49:21 +[2026-04-15 10:27:37,438][trainer.accelerators.base_accelerator][INFO] - Training progress: step=16450/100000 (16.45%), epoch=0, lr=1e-05, speed=0.937 step/s, elapsed=04:52:28, eta=24:45:27 +[2026-04-15 10:27:55,569][trainer.accelerators.base_accelerator][INFO] - Training progress: step=16500/100000 (16.50%), epoch=0, lr=1e-05, speed=0.939 step/s, elapsed=04:52:46, eta=24:41:35 +[2026-04-15 10:28:13,393][trainer.accelerators.base_accelerator][INFO] - Training progress: step=16550/100000 (16.55%), epoch=0, lr=1e-05, speed=0.941 step/s, elapsed=04:53:04, eta=24:37:44 +[2026-04-15 10:28:31,248][trainer.accelerators.base_accelerator][INFO] - Training progress: step=16600/100000 (16.60%), epoch=0, lr=1e-05, speed=0.943 step/s, elapsed=04:53:21, eta=24:33:53 +[2026-04-15 10:28:49,104][trainer.accelerators.base_accelerator][INFO] - Training progress: step=16650/100000 (16.65%), epoch=0, lr=1e-05, speed=0.945 step/s, elapsed=04:53:39, eta=24:30:04 +[2026-04-15 10:29:06,999][trainer.accelerators.base_accelerator][INFO] - Training progress: step=16700/100000 (16.70%), epoch=0, lr=1e-05, speed=0.947 step/s, elapsed=04:53:57, eta=24:26:17 +[2026-04-15 10:29:24,757][trainer.accelerators.base_accelerator][INFO] - Training progress: step=16750/100000 (16.75%), epoch=0, lr=1e-05, speed=0.949 step/s, elapsed=04:54:15, eta=24:22:30 +[2026-04-15 10:29:42,643][trainer.accelerators.base_accelerator][INFO] - Training progress: step=16800/100000 (16.80%), epoch=0, lr=1e-05, speed=0.951 step/s, elapsed=04:54:33, eta=24:18:45 +[2026-04-15 10:30:00,541][trainer.accelerators.base_accelerator][INFO] - Training progress: step=16850/100000 (16.85%), epoch=0, lr=1e-05, speed=0.952 step/s, elapsed=04:54:51, eta=24:15:01 +[2026-04-15 10:30:18,354][trainer.accelerators.base_accelerator][INFO] - Training progress: step=16900/100000 (16.90%), epoch=0, lr=1e-05, speed=0.954 step/s, elapsed=04:55:09, eta=24:11:18 +[2026-04-15 10:30:36,272][trainer.accelerators.base_accelerator][INFO] - Training progress: step=16950/100000 (16.95%), epoch=0, lr=1e-05, speed=0.956 step/s, elapsed=04:55:26, eta=24:07:36 +[2026-04-15 10:30:54,105][trainer.accelerators.base_accelerator][INFO] - Training progress: step=17000/100000 (17.00%), epoch=0, lr=1e-05, speed=0.958 step/s, elapsed=04:55:44, eta=24:03:56 +[2026-04-15 10:30:54,128][__main__][INFO] - ========== EVAL START (periodic@gstep=17000) ========== +[2026-04-15 10:30:54,129][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-15 10:30:54,129][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 10:31:09,360][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.204282760620117, 'accuracy': 0.5105882352941177, 'num_samples': 425, 'test_unique_accuracy': 0.5, 'test_unique_num_samples': 432} +[2026-04-15 10:31:09,361][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-15 10:31:09,361][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 10:31:24,411][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.204282760620117, 'accuracy': 0.5105882352941177, 'num_samples': 425, 'test_unique_accuracy': 0.5185185185185185, 'test_unique_num_samples': 432} +[2026-04-15 10:31:24,412][__main__][INFO] - ========== EVAL END (periodic@gstep=17000) ========== +[2026-04-15 10:31:24,412][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.196352005004883, 'accuracy': 0.5105882352941177, 'num_samples': 425, 'test_unique_accuracy': 0.5185185185185185, 'test_unique_num_samples': 432} +[2026-04-15 10:31:24,435][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.5105882352941177 is not better than 0.52 of logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep2000, skipping checkpoint +[2026-04-15 10:31:42,412][trainer.accelerators.base_accelerator][INFO] - Training progress: step=17050/100000 (17.05%), epoch=0, lr=1e-05, speed=0.958 step/s, elapsed=04:56:33, eta=24:02:45 +[2026-04-15 10:32:00,272][trainer.accelerators.base_accelerator][INFO] - Training progress: step=17100/100000 (17.10%), epoch=0, lr=1e-05, speed=0.960 step/s, elapsed=04:56:50, eta=23:59:06 +[2026-04-15 10:32:18,172][trainer.accelerators.base_accelerator][INFO] - Training progress: step=17150/100000 (17.15%), epoch=0, lr=1e-05, speed=0.962 step/s, elapsed=04:57:08, eta=23:55:29 +[2026-04-15 10:32:36,030][trainer.accelerators.base_accelerator][INFO] - Training progress: step=17200/100000 (17.20%), epoch=0, lr=1e-05, speed=0.964 step/s, elapsed=04:57:26, eta=23:51:53 +[2026-04-15 10:32:53,914][trainer.accelerators.base_accelerator][INFO] - Training progress: step=17250/100000 (17.25%), epoch=0, lr=1e-05, speed=0.966 step/s, elapsed=04:57:44, eta=23:48:18 +[2026-04-15 10:33:11,863][trainer.accelerators.base_accelerator][INFO] - Training progress: step=17300/100000 (17.30%), epoch=0, lr=1e-05, speed=0.967 step/s, elapsed=04:58:02, eta=23:44:44 +[2026-04-15 10:33:29,807][trainer.accelerators.base_accelerator][INFO] - Training progress: step=17350/100000 (17.35%), epoch=0, lr=1e-05, speed=0.969 step/s, elapsed=04:58:20, eta=23:41:12 +[2026-04-15 10:33:47,683][trainer.accelerators.base_accelerator][INFO] - Training progress: step=17400/100000 (17.40%), epoch=0, lr=1e-05, speed=0.971 step/s, elapsed=04:58:38, eta=23:37:40 +[2026-04-15 10:34:05,572][trainer.accelerators.base_accelerator][INFO] - Training progress: step=17450/100000 (17.45%), epoch=0, lr=1e-05, speed=0.973 step/s, elapsed=04:58:56, eta=23:34:10 +[2026-04-15 10:34:23,430][trainer.accelerators.base_accelerator][INFO] - Training progress: step=17500/100000 (17.50%), epoch=0, lr=1e-05, speed=0.975 step/s, elapsed=04:59:14, eta=23:30:40 +[2026-04-15 10:34:41,263][trainer.accelerators.base_accelerator][INFO] - Training progress: step=17550/100000 (17.55%), epoch=0, lr=1e-05, speed=0.977 step/s, elapsed=04:59:31, eta=23:27:12 +[2026-04-15 10:34:59,598][trainer.accelerators.base_accelerator][INFO] - Training progress: step=17600/100000 (17.60%), epoch=0, lr=1e-05, speed=0.978 step/s, elapsed=04:59:50, eta=23:23:47 +[2026-04-15 10:35:17,614][trainer.accelerators.base_accelerator][INFO] - Training progress: step=17650/100000 (17.65%), epoch=0, lr=1e-05, speed=0.980 step/s, elapsed=05:00:08, eta=23:20:21 +[2026-04-15 10:35:35,474][trainer.accelerators.base_accelerator][INFO] - Training progress: step=17700/100000 (17.70%), epoch=0, lr=1e-05, speed=0.982 step/s, elapsed=05:00:26, eta=23:16:56 +[2026-04-15 10:35:53,410][trainer.accelerators.base_accelerator][INFO] - Training progress: step=17750/100000 (17.75%), epoch=0, lr=1e-05, speed=0.984 step/s, elapsed=05:00:44, eta=23:13:32 +[2026-04-15 10:36:11,609][trainer.accelerators.base_accelerator][INFO] - Training progress: step=17800/100000 (17.80%), epoch=0, lr=1e-05, speed=0.985 step/s, elapsed=05:01:02, eta=23:10:11 +[2026-04-15 10:36:29,489][trainer.accelerators.base_accelerator][INFO] - Training progress: step=17850/100000 (17.85%), epoch=0, lr=1e-05, speed=0.987 step/s, elapsed=05:01:20, eta=23:06:49 +[2026-04-15 10:36:47,421][trainer.accelerators.base_accelerator][INFO] - Training progress: step=17900/100000 (17.90%), epoch=0, lr=1e-05, speed=0.989 step/s, elapsed=05:01:38, eta=23:03:28 +[2026-04-15 10:37:05,405][trainer.accelerators.base_accelerator][INFO] - Training progress: step=17950/100000 (17.95%), epoch=0, lr=1e-05, speed=0.991 step/s, elapsed=05:01:56, eta=23:00:09 +[2026-04-15 10:37:23,395][trainer.accelerators.base_accelerator][INFO] - Training progress: step=18000/100000 (18.00%), epoch=0, lr=1e-05, speed=0.993 step/s, elapsed=05:02:14, eta=22:56:50 +[2026-04-15 10:37:23,419][__main__][INFO] - ========== EVAL START (periodic@gstep=18000) ========== +[2026-04-15 10:37:23,420][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-15 10:37:23,420][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 10:37:38,779][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.196352005004883, 'accuracy': 0.5058823529411764, 'num_samples': 425, 'test_unique_accuracy': 0.5185185185185185, 'test_unique_num_samples': 432} +[2026-04-15 10:37:38,779][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-15 10:37:38,779][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 10:37:53,836][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.196352005004883, 'accuracy': 0.5058823529411764, 'num_samples': 425, 'test_unique_accuracy': 0.5, 'test_unique_num_samples': 432} +[2026-04-15 10:37:53,836][__main__][INFO] - ========== EVAL END (periodic@gstep=18000) ========== +[2026-04-15 10:37:53,836][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.191462516784668, 'accuracy': 0.5058823529411764, 'num_samples': 425, 'test_unique_accuracy': 0.5, 'test_unique_num_samples': 432} +[2026-04-15 10:37:53,840][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.5058823529411764 is not better than 0.52 of logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep2000, skipping checkpoint +[2026-04-15 10:38:11,886][trainer.accelerators.base_accelerator][INFO] - Training progress: step=18050/100000 (18.05%), epoch=0, lr=1e-05, speed=0.993 step/s, elapsed=05:03:02, eta=22:55:51 +[2026-04-15 10:38:29,822][trainer.accelerators.base_accelerator][INFO] - Training progress: step=18100/100000 (18.10%), epoch=0, lr=1e-05, speed=0.994 step/s, elapsed=05:03:20, eta=22:52:34 +[2026-04-15 10:38:47,721][trainer.accelerators.base_accelerator][INFO] - Training progress: step=18150/100000 (18.15%), epoch=0, lr=1e-05, speed=0.996 step/s, elapsed=05:03:38, eta=22:49:18 +[2026-04-15 10:39:05,559][trainer.accelerators.base_accelerator][INFO] - Training progress: step=18200/100000 (18.20%), epoch=0, lr=1e-05, speed=0.998 step/s, elapsed=05:03:56, eta=22:46:02 +[2026-04-15 10:39:23,323][trainer.accelerators.base_accelerator][INFO] - Training progress: step=18250/100000 (18.25%), epoch=0, lr=1e-05, speed=1.000 step/s, elapsed=05:04:14, eta=22:42:47 +[2026-04-15 10:39:41,185][trainer.accelerators.base_accelerator][INFO] - Training progress: step=18300/100000 (18.30%), epoch=0, lr=1e-05, speed=1.002 step/s, elapsed=05:04:31, eta=22:39:34 +[2026-04-15 10:39:58,937][trainer.accelerators.base_accelerator][INFO] - Training progress: step=18350/100000 (18.35%), epoch=0, lr=1e-05, speed=1.003 step/s, elapsed=05:04:49, eta=22:36:21 +[2026-04-15 10:40:16,785][trainer.accelerators.base_accelerator][INFO] - Training progress: step=18400/100000 (18.40%), epoch=0, lr=1e-05, speed=1.005 step/s, elapsed=05:05:07, eta=22:33:09 +[2026-04-15 10:40:34,645][trainer.accelerators.base_accelerator][INFO] - Training progress: step=18450/100000 (18.45%), epoch=0, lr=1e-05, speed=1.007 step/s, elapsed=05:05:25, eta=22:29:58 +[2026-04-15 10:40:52,399][trainer.accelerators.base_accelerator][INFO] - Training progress: step=18500/100000 (18.50%), epoch=0, lr=1e-05, speed=1.009 step/s, elapsed=05:05:43, eta=22:26:48 +[2026-04-15 10:41:10,244][trainer.accelerators.base_accelerator][INFO] - Training progress: step=18550/100000 (18.55%), epoch=0, lr=1e-05, speed=1.010 step/s, elapsed=05:06:00, eta=22:23:39 +[2026-04-15 10:41:28,051][trainer.accelerators.base_accelerator][INFO] - Training progress: step=18600/100000 (18.60%), epoch=0, lr=1e-05, speed=1.012 step/s, elapsed=05:06:18, eta=22:20:31 +[2026-04-15 10:41:46,129][trainer.accelerators.base_accelerator][INFO] - Training progress: step=18650/100000 (18.65%), epoch=0, lr=1e-05, speed=1.014 step/s, elapsed=05:06:36, eta=22:17:25 +[2026-04-15 10:42:03,879][trainer.accelerators.base_accelerator][INFO] - Training progress: step=18700/100000 (18.70%), epoch=0, lr=1e-05, speed=1.016 step/s, elapsed=05:06:54, eta=22:14:19 +[2026-04-15 10:42:21,716][trainer.accelerators.base_accelerator][INFO] - Training progress: step=18750/100000 (18.75%), epoch=0, lr=1e-05, speed=1.017 step/s, elapsed=05:07:12, eta=22:11:13 +[2026-04-15 10:42:39,578][trainer.accelerators.base_accelerator][INFO] - Training progress: step=18800/100000 (18.80%), epoch=0, lr=1e-05, speed=1.019 step/s, elapsed=05:07:30, eta=22:08:09 +[2026-04-15 10:42:57,456][trainer.accelerators.base_accelerator][INFO] - Training progress: step=18850/100000 (18.85%), epoch=0, lr=1e-05, speed=1.021 step/s, elapsed=05:07:48, eta=22:05:06 +[2026-04-15 10:43:15,334][trainer.accelerators.base_accelerator][INFO] - Training progress: step=18900/100000 (18.90%), epoch=0, lr=1e-05, speed=1.022 step/s, elapsed=05:08:06, eta=22:02:03 +[2026-04-15 10:43:33,096][trainer.accelerators.base_accelerator][INFO] - Training progress: step=18950/100000 (18.95%), epoch=0, lr=1e-05, speed=1.024 step/s, elapsed=05:08:23, eta=21:59:01 +[2026-04-15 10:43:50,934][trainer.accelerators.base_accelerator][INFO] - Training progress: step=19000/100000 (19.00%), epoch=0, lr=1e-05, speed=1.026 step/s, elapsed=05:08:41, eta=21:56:00 +[2026-04-15 10:43:50,957][__main__][INFO] - ========== EVAL START (periodic@gstep=19000) ========== +[2026-04-15 10:43:50,958][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-15 10:43:50,958][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 10:44:05,958][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.191462516784668, 'accuracy': 0.4964705882352941, 'num_samples': 425, 'test_unique_accuracy': 0.5, 'test_unique_num_samples': 432} +[2026-04-15 10:44:05,959][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-15 10:44:05,959][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 10:44:21,034][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.191462516784668, 'accuracy': 0.4964705882352941, 'num_samples': 425, 'test_unique_accuracy': 0.4930555555555556, 'test_unique_num_samples': 432} +[2026-04-15 10:44:21,034][__main__][INFO] - ========== EVAL END (periodic@gstep=19000) ========== +[2026-04-15 10:44:21,034][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.186422348022461, 'accuracy': 0.4964705882352941, 'num_samples': 425, 'test_unique_accuracy': 0.4930555555555556, 'test_unique_num_samples': 432} +[2026-04-15 10:44:21,038][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.4964705882352941 is not better than 0.52 of logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep2000, skipping checkpoint +[2026-04-15 10:44:38,927][trainer.accelerators.base_accelerator][INFO] - Training progress: step=19050/100000 (19.05%), epoch=0, lr=1e-05, speed=1.026 step/s, elapsed=05:09:29, eta=21:55:08 +[2026-04-15 10:44:56,757][trainer.accelerators.base_accelerator][INFO] - Training progress: step=19100/100000 (19.10%), epoch=0, lr=1e-05, speed=1.028 step/s, elapsed=05:09:47, eta=21:52:09 +[2026-04-15 10:45:14,620][trainer.accelerators.base_accelerator][INFO] - Training progress: step=19150/100000 (19.15%), epoch=0, lr=1e-05, speed=1.029 step/s, elapsed=05:10:05, eta=21:49:10 +[2026-04-15 10:45:32,395][trainer.accelerators.base_accelerator][INFO] - Training progress: step=19200/100000 (19.20%), epoch=0, lr=1e-05, speed=1.031 step/s, elapsed=05:10:23, eta=21:46:12 +[2026-04-15 10:45:50,305][trainer.accelerators.base_accelerator][INFO] - Training progress: step=19250/100000 (19.25%), epoch=0, lr=1e-05, speed=1.033 step/s, elapsed=05:10:40, eta=21:43:15 +[2026-04-15 10:46:08,135][trainer.accelerators.base_accelerator][INFO] - Training progress: step=19300/100000 (19.30%), epoch=0, lr=1e-05, speed=1.034 step/s, elapsed=05:10:58, eta=21:40:18 +[2026-04-15 10:46:26,034][trainer.accelerators.base_accelerator][INFO] - Training progress: step=19350/100000 (19.35%), epoch=0, lr=1e-05, speed=1.036 step/s, elapsed=05:11:16, eta=21:37:23 +[2026-04-15 10:46:43,931][trainer.accelerators.base_accelerator][INFO] - Training progress: step=19400/100000 (19.40%), epoch=0, lr=1e-05, speed=1.038 step/s, elapsed=05:11:34, eta=21:34:29 +[2026-04-15 10:47:01,824][trainer.accelerators.base_accelerator][INFO] - Training progress: step=19450/100000 (19.45%), epoch=0, lr=1e-05, speed=1.039 step/s, elapsed=05:11:52, eta=21:31:35 +[2026-04-15 10:47:19,753][trainer.accelerators.base_accelerator][INFO] - Training progress: step=19500/100000 (19.50%), epoch=0, lr=1e-05, speed=1.041 step/s, elapsed=05:12:10, eta=21:28:43 +[2026-04-15 10:47:37,653][trainer.accelerators.base_accelerator][INFO] - Training progress: step=19550/100000 (19.55%), epoch=0, lr=1e-05, speed=1.043 step/s, elapsed=05:12:28, eta=21:25:51 +[2026-04-15 10:47:55,498][trainer.accelerators.base_accelerator][INFO] - Training progress: step=19600/100000 (19.60%), epoch=0, lr=1e-05, speed=1.044 step/s, elapsed=05:12:46, eta=21:22:59 +[2026-04-15 10:48:13,368][trainer.accelerators.base_accelerator][INFO] - Training progress: step=19650/100000 (19.65%), epoch=0, lr=1e-05, speed=1.046 step/s, elapsed=05:13:04, eta=21:20:09 +[2026-04-15 10:48:31,199][trainer.accelerators.base_accelerator][INFO] - Training progress: step=19700/100000 (19.70%), epoch=0, lr=1e-05, speed=1.048 step/s, elapsed=05:13:21, eta=21:17:19 +[2026-04-15 10:48:49,384][trainer.accelerators.base_accelerator][INFO] - Training progress: step=19750/100000 (19.75%), epoch=0, lr=1e-05, speed=1.049 step/s, elapsed=05:13:40, eta=21:14:31 +[2026-04-15 10:49:07,189][trainer.accelerators.base_accelerator][INFO] - Training progress: step=19800/100000 (19.80%), epoch=0, lr=1e-05, speed=1.051 step/s, elapsed=05:13:57, eta=21:11:42 +[2026-04-15 10:49:25,005][trainer.accelerators.base_accelerator][INFO] - Training progress: step=19850/100000 (19.85%), epoch=0, lr=1e-05, speed=1.053 step/s, elapsed=05:14:15, eta=21:08:55 +[2026-04-15 10:49:42,897][trainer.accelerators.base_accelerator][INFO] - Training progress: step=19900/100000 (19.90%), epoch=0, lr=1e-05, speed=1.054 step/s, elapsed=05:14:33, eta=21:06:08 +[2026-04-15 10:50:00,781][trainer.accelerators.base_accelerator][INFO] - Training progress: step=19950/100000 (19.95%), epoch=0, lr=1e-05, speed=1.056 step/s, elapsed=05:14:51, eta=21:03:22 +[2026-04-15 10:50:18,673][trainer.accelerators.base_accelerator][INFO] - Training progress: step=20000/100000 (20.00%), epoch=0, lr=1e-05, speed=1.058 step/s, elapsed=05:15:09, eta=21:00:37 +[2026-04-15 10:50:18,696][__main__][INFO] - ========== EVAL START (periodic@gstep=20000) ========== +[2026-04-15 10:50:18,696][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-15 10:50:18,697][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 10:50:35,969][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.186422348022461, 'accuracy': 0.48470588235294115, 'num_samples': 425, 'test_unique_accuracy': 0.4930555555555556, 'test_unique_num_samples': 432} +[2026-04-15 10:50:35,970][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-15 10:50:35,970][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 10:50:51,002][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.186422348022461, 'accuracy': 0.48470588235294115, 'num_samples': 425, 'test_unique_accuracy': 0.5069444444444444, 'test_unique_num_samples': 432} +[2026-04-15 10:50:51,002][__main__][INFO] - ========== EVAL END (periodic@gstep=20000) ========== +[2026-04-15 10:50:51,002][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.176681518554688, 'accuracy': 0.48470588235294115, 'num_samples': 425, 'test_unique_accuracy': 0.5069444444444444, 'test_unique_num_samples': 432} +[2026-04-15 10:50:51,007][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.48470588235294115 is not better than 0.48705882352941177 of logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep1000, skipping checkpoint +[2026-04-15 10:51:08,885][trainer.accelerators.base_accelerator][INFO] - Training progress: step=20050/100000 (20.05%), epoch=0, lr=1e-05, speed=1.058 step/s, elapsed=05:15:59, eta=21:00:01 +[2026-04-15 10:51:26,726][trainer.accelerators.base_accelerator][INFO] - Training progress: step=20100/100000 (20.10%), epoch=0, lr=1e-05, speed=1.059 step/s, elapsed=05:16:17, eta=20:57:17 +[2026-04-15 10:51:44,682][trainer.accelerators.base_accelerator][INFO] - Training progress: step=20150/100000 (20.15%), epoch=0, lr=1e-05, speed=1.061 step/s, elapsed=05:16:35, eta=20:54:34 +[2026-04-15 10:52:02,506][trainer.accelerators.base_accelerator][INFO] - Training progress: step=20200/100000 (20.20%), epoch=0, lr=1e-05, speed=1.062 step/s, elapsed=05:16:53, eta=20:51:51 +[2026-04-15 10:52:20,415][trainer.accelerators.base_accelerator][INFO] - Training progress: step=20250/100000 (20.25%), epoch=0, lr=1e-05, speed=1.064 step/s, elapsed=05:17:11, eta=20:49:09 +[2026-04-15 10:52:38,279][trainer.accelerators.base_accelerator][INFO] - Training progress: step=20300/100000 (20.30%), epoch=0, lr=1e-05, speed=1.066 step/s, elapsed=05:17:28, eta=20:46:28 +[2026-04-15 10:52:56,039][trainer.accelerators.base_accelerator][INFO] - Training progress: step=20350/100000 (20.35%), epoch=0, lr=1e-05, speed=1.067 step/s, elapsed=05:17:46, eta=20:43:47 +[2026-04-15 10:53:13,993][trainer.accelerators.base_accelerator][INFO] - Training progress: step=20400/100000 (20.40%), epoch=0, lr=1e-05, speed=1.069 step/s, elapsed=05:18:04, eta=20:41:07 +[2026-04-15 10:53:31,896][trainer.accelerators.base_accelerator][INFO] - Training progress: step=20450/100000 (20.45%), epoch=0, lr=1e-05, speed=1.071 step/s, elapsed=05:18:22, eta=20:38:28 +[2026-04-15 10:53:49,759][trainer.accelerators.base_accelerator][INFO] - Training progress: step=20500/100000 (20.50%), epoch=0, lr=1e-05, speed=1.072 step/s, elapsed=05:18:40, eta=20:35:50 +[2026-04-15 10:54:07,586][trainer.accelerators.base_accelerator][INFO] - Training progress: step=20550/100000 (20.55%), epoch=0, lr=1e-05, speed=1.074 step/s, elapsed=05:18:58, eta=20:33:11 +[2026-04-15 10:54:25,392][trainer.accelerators.base_accelerator][INFO] - Training progress: step=20600/100000 (20.60%), epoch=0, lr=1e-05, speed=1.075 step/s, elapsed=05:19:16, eta=20:30:34 +[2026-04-15 10:54:43,319][trainer.accelerators.base_accelerator][INFO] - Training progress: step=20650/100000 (20.65%), epoch=0, lr=1e-05, speed=1.077 step/s, elapsed=05:19:34, eta=20:27:58 +[2026-04-15 10:55:01,206][trainer.accelerators.base_accelerator][INFO] - Training progress: step=20700/100000 (20.70%), epoch=0, lr=1e-05, speed=1.079 step/s, elapsed=05:19:51, eta=20:25:22 +[2026-04-15 10:55:19,052][trainer.accelerators.base_accelerator][INFO] - Training progress: step=20750/100000 (20.75%), epoch=0, lr=1e-05, speed=1.080 step/s, elapsed=05:20:09, eta=20:22:47 +[2026-04-15 10:55:36,939][trainer.accelerators.base_accelerator][INFO] - Training progress: step=20800/100000 (20.80%), epoch=0, lr=1e-05, speed=1.082 step/s, elapsed=05:20:27, eta=20:20:12 +[2026-04-15 10:55:55,056][trainer.accelerators.base_accelerator][INFO] - Training progress: step=20850/100000 (20.85%), epoch=0, lr=1e-05, speed=1.083 step/s, elapsed=05:20:45, eta=20:17:39 +[2026-04-15 10:56:12,906][trainer.accelerators.base_accelerator][INFO] - Training progress: step=20900/100000 (20.90%), epoch=0, lr=1e-05, speed=1.085 step/s, elapsed=05:21:03, eta=20:15:06 +[2026-04-15 10:56:30,705][trainer.accelerators.base_accelerator][INFO] - Training progress: step=20950/100000 (20.95%), epoch=0, lr=1e-05, speed=1.087 step/s, elapsed=05:21:21, eta=20:12:33 +[2026-04-15 10:56:48,596][trainer.accelerators.base_accelerator][INFO] - Training progress: step=21000/100000 (21.00%), epoch=0, lr=1e-05, speed=1.088 step/s, elapsed=05:21:39, eta=20:10:02 +[2026-04-15 10:56:48,621][__main__][INFO] - ========== EVAL START (periodic@gstep=21000) ========== +[2026-04-15 10:56:48,621][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-15 10:56:48,621][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 10:57:03,933][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.176681518554688, 'accuracy': 0.508235294117647, 'num_samples': 425, 'test_unique_accuracy': 0.5069444444444444, 'test_unique_num_samples': 432} +[2026-04-15 10:57:03,933][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-15 10:57:03,933][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 10:57:19,025][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.176681518554688, 'accuracy': 0.508235294117647, 'num_samples': 425, 'test_unique_accuracy': 0.4861111111111111, 'test_unique_num_samples': 432} +[2026-04-15 10:57:19,025][__main__][INFO] - ========== EVAL END (periodic@gstep=21000) ========== +[2026-04-15 10:57:19,025][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.17941951751709, 'accuracy': 0.508235294117647, 'num_samples': 425, 'test_unique_accuracy': 0.4861111111111111, 'test_unique_num_samples': 432} +[2026-04-15 10:57:19,029][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.508235294117647 is not better than 0.52 of logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep2000, skipping checkpoint +[2026-04-15 10:57:36,932][trainer.accelerators.base_accelerator][INFO] - Training progress: step=21050/100000 (21.05%), epoch=0, lr=1e-05, speed=1.088 step/s, elapsed=05:22:27, eta=20:09:25 +[2026-04-15 10:57:54,845][trainer.accelerators.base_accelerator][INFO] - Training progress: step=21100/100000 (21.10%), epoch=0, lr=1e-05, speed=1.090 step/s, elapsed=05:22:45, eta=20:06:54 +[2026-04-15 10:58:12,647][trainer.accelerators.base_accelerator][INFO] - Training progress: step=21150/100000 (21.15%), epoch=0, lr=1e-05, speed=1.091 step/s, elapsed=05:23:03, eta=20:04:23 +[2026-04-15 10:58:30,528][trainer.accelerators.base_accelerator][INFO] - Training progress: step=21200/100000 (21.20%), epoch=0, lr=1e-05, speed=1.093 step/s, elapsed=05:23:21, eta=20:01:53 +[2026-04-15 10:58:48,410][trainer.accelerators.base_accelerator][INFO] - Training progress: step=21250/100000 (21.25%), epoch=0, lr=1e-05, speed=1.094 step/s, elapsed=05:23:39, eta=19:59:24 +[2026-04-15 10:59:06,224][trainer.accelerators.base_accelerator][INFO] - Training progress: step=21300/100000 (21.30%), epoch=0, lr=1e-05, speed=1.096 step/s, elapsed=05:23:56, eta=19:56:56 +[2026-04-15 10:59:24,051][trainer.accelerators.base_accelerator][INFO] - Training progress: step=21350/100000 (21.35%), epoch=0, lr=1e-05, speed=1.097 step/s, elapsed=05:24:14, eta=19:54:28 +[2026-04-15 10:59:41,851][trainer.accelerators.base_accelerator][INFO] - Training progress: step=21400/100000 (21.40%), epoch=0, lr=1e-05, speed=1.099 step/s, elapsed=05:24:32, eta=19:52:00 +[2026-04-15 10:59:59,769][trainer.accelerators.base_accelerator][INFO] - Training progress: step=21450/100000 (21.45%), epoch=0, lr=1e-05, speed=1.101 step/s, elapsed=05:24:50, eta=19:49:34 +[2026-04-15 11:00:17,641][trainer.accelerators.base_accelerator][INFO] - Training progress: step=21500/100000 (21.50%), epoch=0, lr=1e-05, speed=1.102 step/s, elapsed=05:25:08, eta=19:47:08 +[2026-04-15 11:00:35,457][trainer.accelerators.base_accelerator][INFO] - Training progress: step=21550/100000 (21.55%), epoch=0, lr=1e-05, speed=1.104 step/s, elapsed=05:25:26, eta=19:44:42 +[2026-04-15 11:00:53,224][trainer.accelerators.base_accelerator][INFO] - Training progress: step=21600/100000 (21.60%), epoch=0, lr=1e-05, speed=1.105 step/s, elapsed=05:25:43, eta=19:42:17 +[2026-04-15 11:01:11,143][trainer.accelerators.base_accelerator][INFO] - Training progress: step=21650/100000 (21.65%), epoch=0, lr=1e-05, speed=1.107 step/s, elapsed=05:26:01, eta=19:39:53 +[2026-04-15 11:01:29,103][trainer.accelerators.base_accelerator][INFO] - Training progress: step=21700/100000 (21.70%), epoch=0, lr=1e-05, speed=1.108 step/s, elapsed=05:26:19, eta=19:37:29 +[2026-04-15 11:01:47,024][trainer.accelerators.base_accelerator][INFO] - Training progress: step=21750/100000 (21.75%), epoch=0, lr=1e-05, speed=1.110 step/s, elapsed=05:26:37, eta=19:35:06 +[2026-04-15 11:02:04,920][trainer.accelerators.base_accelerator][INFO] - Training progress: step=21800/100000 (21.80%), epoch=0, lr=1e-05, speed=1.111 step/s, elapsed=05:26:55, eta=19:32:44 +[2026-04-15 11:02:22,742][trainer.accelerators.base_accelerator][INFO] - Training progress: step=21850/100000 (21.85%), epoch=0, lr=1e-05, speed=1.113 step/s, elapsed=05:27:13, eta=19:30:22 +[2026-04-15 11:02:40,534][trainer.accelerators.base_accelerator][INFO] - Training progress: step=21900/100000 (21.90%), epoch=0, lr=1e-05, speed=1.114 step/s, elapsed=05:27:31, eta=19:28:00 +[2026-04-15 11:02:58,715][trainer.accelerators.base_accelerator][INFO] - Training progress: step=21950/100000 (21.95%), epoch=0, lr=1e-05, speed=1.116 step/s, elapsed=05:27:49, eta=19:25:40 +[2026-04-15 11:03:16,515][trainer.accelerators.base_accelerator][INFO] - Training progress: step=22000/100000 (22.00%), epoch=0, lr=1e-05, speed=1.117 step/s, elapsed=05:28:07, eta=19:23:20 +[2026-04-15 11:03:16,540][__main__][INFO] - ========== EVAL START (periodic@gstep=22000) ========== +[2026-04-15 11:03:16,540][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-15 11:03:16,540][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 11:03:32,091][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.17941951751709, 'accuracy': 0.4470588235294118, 'num_samples': 425, 'test_unique_accuracy': 0.4861111111111111, 'test_unique_num_samples': 432} +[2026-04-15 11:03:32,092][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-15 11:03:32,092][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 11:03:47,202][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.17941951751709, 'accuracy': 0.4470588235294118, 'num_samples': 425, 'test_unique_accuracy': 0.5115740740740741, 'test_unique_num_samples': 432} +[2026-04-15 11:03:47,203][__main__][INFO] - ========== EVAL END (periodic@gstep=22000) ========== +[2026-04-15 11:03:47,203][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.17612361907959, 'accuracy': 0.4470588235294118, 'num_samples': 425, 'test_unique_accuracy': 0.5115740740740741, 'test_unique_num_samples': 432} +[2026-04-15 11:03:47,206][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.4470588235294118 is not better than 0.48705882352941177 of logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep1000, skipping checkpoint +[2026-04-15 11:04:05,041][trainer.accelerators.base_accelerator][INFO] - Training progress: step=22050/100000 (22.05%), epoch=0, lr=1e-05, speed=1.117 step/s, elapsed=05:28:55, eta=19:22:48 +[2026-04-15 11:04:22,937][trainer.accelerators.base_accelerator][INFO] - Training progress: step=22100/100000 (22.10%), epoch=0, lr=1e-05, speed=1.119 step/s, elapsed=05:29:13, eta=19:20:29 +[2026-04-15 11:04:40,735][trainer.accelerators.base_accelerator][INFO] - Training progress: step=22150/100000 (22.15%), epoch=0, lr=1e-05, speed=1.120 step/s, elapsed=05:29:31, eta=19:18:10 +[2026-04-15 11:04:58,649][trainer.accelerators.base_accelerator][INFO] - Training progress: step=22200/100000 (22.20%), epoch=0, lr=1e-05, speed=1.122 step/s, elapsed=05:29:49, eta=19:15:51 +[2026-04-15 11:05:16,554][trainer.accelerators.base_accelerator][INFO] - Training progress: step=22250/100000 (22.25%), epoch=0, lr=1e-05, speed=1.123 step/s, elapsed=05:30:07, eta=19:13:34 +[2026-04-15 11:05:34,442][trainer.accelerators.base_accelerator][INFO] - Training progress: step=22300/100000 (22.30%), epoch=0, lr=1e-05, speed=1.125 step/s, elapsed=05:30:25, eta=19:11:16 +[2026-04-15 11:05:52,305][trainer.accelerators.base_accelerator][INFO] - Training progress: step=22350/100000 (22.35%), epoch=0, lr=1e-05, speed=1.126 step/s, elapsed=05:30:42, eta=19:08:59 +[2026-04-15 11:06:10,141][trainer.accelerators.base_accelerator][INFO] - Training progress: step=22400/100000 (22.40%), epoch=0, lr=1e-05, speed=1.128 step/s, elapsed=05:31:00, eta=19:06:43 +[2026-04-15 11:06:27,861][trainer.accelerators.base_accelerator][INFO] - Training progress: step=22450/100000 (22.45%), epoch=0, lr=1e-05, speed=1.129 step/s, elapsed=05:31:18, eta=19:04:27 +[2026-04-15 11:06:45,663][trainer.accelerators.base_accelerator][INFO] - Training progress: step=22500/100000 (22.50%), epoch=0, lr=1e-05, speed=1.131 step/s, elapsed=05:31:36, eta=19:02:11 +[2026-04-15 11:07:03,535][trainer.accelerators.base_accelerator][INFO] - Training progress: step=22550/100000 (22.55%), epoch=0, lr=1e-05, speed=1.132 step/s, elapsed=05:31:54, eta=18:59:57 +[2026-04-15 11:07:21,190][trainer.accelerators.base_accelerator][INFO] - Training progress: step=22600/100000 (22.60%), epoch=0, lr=1e-05, speed=1.134 step/s, elapsed=05:32:11, eta=18:57:42 +[2026-04-15 11:07:39,010][trainer.accelerators.base_accelerator][INFO] - Training progress: step=22650/100000 (22.65%), epoch=0, lr=1e-05, speed=1.135 step/s, elapsed=05:32:29, eta=18:55:28 +[2026-04-15 11:07:56,927][trainer.accelerators.base_accelerator][INFO] - Training progress: step=22700/100000 (22.70%), epoch=0, lr=1e-05, speed=1.137 step/s, elapsed=05:32:47, eta=18:53:15 +[2026-04-15 11:08:14,745][trainer.accelerators.base_accelerator][INFO] - Training progress: step=22750/100000 (22.75%), epoch=0, lr=1e-05, speed=1.138 step/s, elapsed=05:33:05, eta=18:51:02 +[2026-04-15 11:08:32,630][trainer.accelerators.base_accelerator][INFO] - Training progress: step=22800/100000 (22.80%), epoch=0, lr=1e-05, speed=1.140 step/s, elapsed=05:33:23, eta=18:48:50 +[2026-04-15 11:08:50,417][trainer.accelerators.base_accelerator][INFO] - Training progress: step=22850/100000 (22.85%), epoch=0, lr=1e-05, speed=1.141 step/s, elapsed=05:33:41, eta=18:46:38 +[2026-04-15 11:09:08,262][trainer.accelerators.base_accelerator][INFO] - Training progress: step=22900/100000 (22.90%), epoch=0, lr=1e-05, speed=1.143 step/s, elapsed=05:33:58, eta=18:44:27 +[2026-04-15 11:09:26,111][trainer.accelerators.base_accelerator][INFO] - Training progress: step=22950/100000 (22.95%), epoch=0, lr=1e-05, speed=1.144 step/s, elapsed=05:34:16, eta=18:42:16 +[2026-04-15 11:09:44,264][trainer.accelerators.base_accelerator][INFO] - Training progress: step=23000/100000 (23.00%), epoch=0, lr=1e-05, speed=1.146 step/s, elapsed=05:34:34, eta=18:40:07 +[2026-04-15 11:09:44,288][__main__][INFO] - ========== EVAL START (periodic@gstep=23000) ========== +[2026-04-15 11:09:44,289][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-15 11:09:44,289][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 11:09:59,317][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.17612361907959, 'accuracy': 0.5105882352941177, 'num_samples': 425, 'test_unique_accuracy': 0.5115740740740741, 'test_unique_num_samples': 432} +[2026-04-15 11:09:59,318][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-15 11:09:59,318][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 11:10:14,342][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.17612361907959, 'accuracy': 0.5105882352941177, 'num_samples': 425, 'test_unique_accuracy': 0.45601851851851855, 'test_unique_num_samples': 432} +[2026-04-15 11:10:14,342][__main__][INFO] - ========== EVAL END (periodic@gstep=23000) ========== +[2026-04-15 11:10:14,343][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.173463821411133, 'accuracy': 0.5105882352941177, 'num_samples': 425, 'test_unique_accuracy': 0.45601851851851855, 'test_unique_num_samples': 432} +[2026-04-15 11:10:14,347][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.5105882352941177 is not better than 0.52 of logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep2000, skipping checkpoint +[2026-04-15 11:10:32,203][trainer.accelerators.base_accelerator][INFO] - Training progress: step=23050/100000 (23.05%), epoch=0, lr=1e-05, speed=1.145 step/s, elapsed=05:35:22, eta=18:39:38 +[2026-04-15 11:10:50,100][trainer.accelerators.base_accelerator][INFO] - Training progress: step=23100/100000 (23.10%), epoch=0, lr=1e-05, speed=1.147 step/s, elapsed=05:35:40, eta=18:37:28 +[2026-04-15 11:11:07,994][trainer.accelerators.base_accelerator][INFO] - Training progress: step=23150/100000 (23.15%), epoch=0, lr=1e-05, speed=1.148 step/s, elapsed=05:35:58, eta=18:35:19 +[2026-04-15 11:11:25,903][trainer.accelerators.base_accelerator][INFO] - Training progress: step=23200/100000 (23.20%), epoch=0, lr=1e-05, speed=1.150 step/s, elapsed=05:36:16, eta=18:33:11 +[2026-04-15 11:11:43,781][trainer.accelerators.base_accelerator][INFO] - Training progress: step=23250/100000 (23.25%), epoch=0, lr=1e-05, speed=1.151 step/s, elapsed=05:36:34, eta=18:31:03 +[2026-04-15 11:12:01,555][trainer.accelerators.base_accelerator][INFO] - Training progress: step=23300/100000 (23.30%), epoch=0, lr=1e-05, speed=1.153 step/s, elapsed=05:36:52, eta=18:28:55 +[2026-04-15 11:12:19,465][trainer.accelerators.base_accelerator][INFO] - Training progress: step=23350/100000 (23.35%), epoch=0, lr=1e-05, speed=1.154 step/s, elapsed=05:37:10, eta=18:26:48 +[2026-04-15 11:12:37,316][trainer.accelerators.base_accelerator][INFO] - Training progress: step=23400/100000 (23.40%), epoch=0, lr=1e-05, speed=1.156 step/s, elapsed=05:37:28, eta=18:24:41 +[2026-04-15 11:12:55,183][trainer.accelerators.base_accelerator][INFO] - Training progress: step=23450/100000 (23.45%), epoch=0, lr=1e-05, speed=1.157 step/s, elapsed=05:37:45, eta=18:22:35 +[2026-04-15 11:13:13,032][trainer.accelerators.base_accelerator][INFO] - Training progress: step=23500/100000 (23.50%), epoch=0, lr=1e-05, speed=1.159 step/s, elapsed=05:38:03, eta=18:20:29 +[2026-04-15 11:13:30,894][trainer.accelerators.base_accelerator][INFO] - Training progress: step=23550/100000 (23.55%), epoch=0, lr=1e-05, speed=1.160 step/s, elapsed=05:38:21, eta=18:18:24 +[2026-04-15 11:13:48,775][trainer.accelerators.base_accelerator][INFO] - Training progress: step=23600/100000 (23.60%), epoch=0, lr=1e-05, speed=1.161 step/s, elapsed=05:38:39, eta=18:16:19 +[2026-04-15 11:14:06,747][trainer.accelerators.base_accelerator][INFO] - Training progress: step=23650/100000 (23.65%), epoch=0, lr=1e-05, speed=1.163 step/s, elapsed=05:38:57, eta=18:14:15 +[2026-04-15 11:14:24,665][trainer.accelerators.base_accelerator][INFO] - Training progress: step=23700/100000 (23.70%), epoch=0, lr=1e-05, speed=1.164 step/s, elapsed=05:39:15, eta=18:12:12 +[2026-04-15 11:14:42,615][trainer.accelerators.base_accelerator][INFO] - Training progress: step=23750/100000 (23.75%), epoch=0, lr=1e-05, speed=1.166 step/s, elapsed=05:39:33, eta=18:10:09 +[2026-04-15 11:15:00,527][trainer.accelerators.base_accelerator][INFO] - Training progress: step=23800/100000 (23.80%), epoch=0, lr=1e-05, speed=1.167 step/s, elapsed=05:39:51, eta=18:08:06 +[2026-04-15 11:15:18,465][trainer.accelerators.base_accelerator][INFO] - Training progress: step=23850/100000 (23.85%), epoch=0, lr=1e-05, speed=1.169 step/s, elapsed=05:40:09, eta=18:06:03 +[2026-04-15 11:15:36,410][trainer.accelerators.base_accelerator][INFO] - Training progress: step=23900/100000 (23.90%), epoch=0, lr=1e-05, speed=1.170 step/s, elapsed=05:40:27, eta=18:04:01 +[2026-04-15 11:15:54,234][trainer.accelerators.base_accelerator][INFO] - Training progress: step=23950/100000 (23.95%), epoch=0, lr=1e-05, speed=1.171 step/s, elapsed=05:40:44, eta=18:02:00 +[2026-04-15 11:16:12,126][trainer.accelerators.base_accelerator][INFO] - Training progress: step=24000/100000 (24.00%), epoch=0, lr=1e-05, speed=1.173 step/s, elapsed=05:41:02, eta=17:59:58 +[2026-04-15 11:16:12,150][__main__][INFO] - ========== EVAL START (periodic@gstep=24000) ========== +[2026-04-15 11:16:12,151][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-15 11:16:12,151][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 11:16:29,992][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.173463821411133, 'accuracy': 0.46352941176470586, 'num_samples': 425, 'test_unique_accuracy': 0.45601851851851855, 'test_unique_num_samples': 432} +[2026-04-15 11:16:29,992][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-15 11:16:29,992][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 11:16:45,398][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.173463821411133, 'accuracy': 0.46352941176470586, 'num_samples': 425, 'test_unique_accuracy': 0.5046296296296297, 'test_unique_num_samples': 432} +[2026-04-15 11:16:45,398][__main__][INFO] - ========== EVAL END (periodic@gstep=24000) ========== +[2026-04-15 11:16:45,398][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.167197227478027, 'accuracy': 0.46352941176470586, 'num_samples': 425, 'test_unique_accuracy': 0.5046296296296297, 'test_unique_num_samples': 432} +[2026-04-15 11:16:45,432][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.46352941176470586 is not better than 0.48705882352941177 of logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep1000, skipping checkpoint +[2026-04-15 11:17:03,384][trainer.accelerators.base_accelerator][INFO] - Training progress: step=24050/100000 (24.05%), epoch=0, lr=1e-05, speed=1.172 step/s, elapsed=05:41:54, eta=17:59:43 +[2026-04-15 11:17:21,285][trainer.accelerators.base_accelerator][INFO] - Training progress: step=24100/100000 (24.10%), epoch=0, lr=1e-05, speed=1.174 step/s, elapsed=05:42:11, eta=17:57:42 +[2026-04-15 11:17:39,125][trainer.accelerators.base_accelerator][INFO] - Training progress: step=24150/100000 (24.15%), epoch=0, lr=1e-05, speed=1.175 step/s, elapsed=05:42:29, eta=17:55:42 +[2026-04-15 11:17:56,981][trainer.accelerators.base_accelerator][INFO] - Training progress: step=24200/100000 (24.20%), epoch=0, lr=1e-05, speed=1.177 step/s, elapsed=05:42:47, eta=17:53:42 +[2026-04-15 11:18:15,031][trainer.accelerators.base_accelerator][INFO] - Training progress: step=24250/100000 (24.25%), epoch=0, lr=1e-05, speed=1.178 step/s, elapsed=05:43:05, eta=17:51:43 +[2026-04-15 11:18:32,922][trainer.accelerators.base_accelerator][INFO] - Training progress: step=24300/100000 (24.30%), epoch=0, lr=1e-05, speed=1.179 step/s, elapsed=05:43:23, eta=17:49:44 +[2026-04-15 11:18:50,762][trainer.accelerators.base_accelerator][INFO] - Training progress: step=24350/100000 (24.35%), epoch=0, lr=1e-05, speed=1.181 step/s, elapsed=05:43:41, eta=17:47:46 +[2026-04-15 11:19:08,666][trainer.accelerators.base_accelerator][INFO] - Training progress: step=24400/100000 (24.40%), epoch=0, lr=1e-05, speed=1.182 step/s, elapsed=05:43:59, eta=17:45:48 +[2026-04-15 11:19:26,849][trainer.accelerators.base_accelerator][INFO] - Training progress: step=24450/100000 (24.45%), epoch=0, lr=1e-05, speed=1.184 step/s, elapsed=05:44:17, eta=17:43:51 +[2026-04-15 11:19:44,833][trainer.accelerators.base_accelerator][INFO] - Training progress: step=24500/100000 (24.50%), epoch=0, lr=1e-05, speed=1.185 step/s, elapsed=05:44:35, eta=17:41:54 +[2026-04-15 11:20:02,717][trainer.accelerators.base_accelerator][INFO] - Training progress: step=24550/100000 (24.55%), epoch=0, lr=1e-05, speed=1.186 step/s, elapsed=05:44:53, eta=17:39:57 +[2026-04-15 11:20:20,850][trainer.accelerators.base_accelerator][INFO] - Training progress: step=24600/100000 (24.60%), epoch=0, lr=1e-05, speed=1.188 step/s, elapsed=05:45:11, eta=17:38:01 +[2026-04-15 11:20:38,850][trainer.accelerators.base_accelerator][INFO] - Training progress: step=24650/100000 (24.65%), epoch=0, lr=1e-05, speed=1.189 step/s, elapsed=05:45:29, eta=17:36:05 +[2026-04-15 11:20:56,745][trainer.accelerators.base_accelerator][INFO] - Training progress: step=24700/100000 (24.70%), epoch=0, lr=1e-05, speed=1.191 step/s, elapsed=05:45:47, eta=17:34:10 +[2026-04-15 11:21:14,687][trainer.accelerators.base_accelerator][INFO] - Training progress: step=24750/100000 (24.75%), epoch=0, lr=1e-05, speed=1.192 step/s, elapsed=05:46:05, eta=17:32:15 +[2026-04-15 11:21:32,742][trainer.accelerators.base_accelerator][INFO] - Training progress: step=24800/100000 (24.80%), epoch=0, lr=1e-05, speed=1.193 step/s, elapsed=05:46:23, eta=17:30:20 +[2026-04-15 11:21:50,692][trainer.accelerators.base_accelerator][INFO] - Training progress: step=24850/100000 (24.85%), epoch=0, lr=1e-05, speed=1.195 step/s, elapsed=05:46:41, eta=17:28:26 +[2026-04-15 11:22:08,707][trainer.accelerators.base_accelerator][INFO] - Training progress: step=24900/100000 (24.90%), epoch=0, lr=1e-05, speed=1.196 step/s, elapsed=05:46:59, eta=17:26:32 +[2026-04-15 11:22:26,630][trainer.accelerators.base_accelerator][INFO] - Training progress: step=24950/100000 (24.95%), epoch=0, lr=1e-05, speed=1.197 step/s, elapsed=05:47:17, eta=17:24:38 +[2026-04-15 11:22:44,510][trainer.accelerators.base_accelerator][INFO] - Training progress: step=25000/100000 (25.00%), epoch=0, lr=1e-05, speed=1.199 step/s, elapsed=05:47:35, eta=17:22:45 +[2026-04-15 11:22:44,535][__main__][INFO] - ========== EVAL START (periodic@gstep=25000) ========== +[2026-04-15 11:22:44,535][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-15 11:22:44,535][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 11:23:00,242][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.167197227478027, 'accuracy': 0.5129411764705882, 'num_samples': 425, 'test_unique_accuracy': 0.5046296296296297, 'test_unique_num_samples': 432} +[2026-04-15 11:23:00,243][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-15 11:23:00,243][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 11:23:15,340][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.167197227478027, 'accuracy': 0.5129411764705882, 'num_samples': 425, 'test_unique_accuracy': 0.5393518518518519, 'test_unique_num_samples': 432} +[2026-04-15 11:23:15,340][__main__][INFO] - ========== EVAL END (periodic@gstep=25000) ========== +[2026-04-15 11:23:15,340][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.162357330322266, 'accuracy': 0.5129411764705882, 'num_samples': 425, 'test_unique_accuracy': 0.5393518518518519, 'test_unique_num_samples': 432} +[2026-04-15 11:23:15,344][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.5129411764705882 is not better than 0.52 of logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep2000, skipping checkpoint +[2026-04-15 11:23:33,211][trainer.accelerators.base_accelerator][INFO] - Training progress: step=25050/100000 (25.05%), epoch=0, lr=1e-05, speed=1.198 step/s, elapsed=05:48:23, eta=17:22:24 +[2026-04-15 11:23:51,398][trainer.accelerators.base_accelerator][INFO] - Training progress: step=25100/100000 (25.10%), epoch=0, lr=1e-05, speed=1.200 step/s, elapsed=05:48:42, eta=17:20:32 +[2026-04-15 11:24:09,231][trainer.accelerators.base_accelerator][INFO] - Training progress: step=25150/100000 (25.15%), epoch=0, lr=1e-05, speed=1.201 step/s, elapsed=05:48:59, eta=17:18:40 +[2026-04-15 11:24:27,051][trainer.accelerators.base_accelerator][INFO] - Training progress: step=25200/100000 (25.20%), epoch=0, lr=1e-05, speed=1.202 step/s, elapsed=05:49:17, eta=17:16:47 +[2026-04-15 11:24:44,846][trainer.accelerators.base_accelerator][INFO] - Training progress: step=25250/100000 (25.25%), epoch=0, lr=1e-05, speed=1.204 step/s, elapsed=05:49:35, eta=17:14:55 +[2026-04-15 11:25:02,729][trainer.accelerators.base_accelerator][INFO] - Training progress: step=25300/100000 (25.30%), epoch=0, lr=1e-05, speed=1.205 step/s, elapsed=05:49:53, eta=17:13:04 +[2026-04-15 11:25:20,651][trainer.accelerators.base_accelerator][INFO] - Training progress: step=25350/100000 (25.35%), epoch=0, lr=1e-05, speed=1.206 step/s, elapsed=05:50:11, eta=17:11:13 +[2026-04-15 11:25:38,494][trainer.accelerators.base_accelerator][INFO] - Training progress: step=25400/100000 (25.40%), epoch=0, lr=1e-05, speed=1.208 step/s, elapsed=05:50:29, eta=17:09:22 +[2026-04-15 11:25:56,363][trainer.accelerators.base_accelerator][INFO] - Training progress: step=25450/100000 (25.45%), epoch=0, lr=1e-05, speed=1.209 step/s, elapsed=05:50:47, eta=17:07:32 +[2026-04-15 11:26:14,238][trainer.accelerators.base_accelerator][INFO] - Training progress: step=25500/100000 (25.50%), epoch=0, lr=1e-05, speed=1.211 step/s, elapsed=05:51:04, eta=17:05:42 +[2026-04-15 11:26:32,075][trainer.accelerators.base_accelerator][INFO] - Training progress: step=25550/100000 (25.55%), epoch=0, lr=1e-05, speed=1.212 step/s, elapsed=05:51:22, eta=17:03:52 +[2026-04-15 11:26:49,933][trainer.accelerators.base_accelerator][INFO] - Training progress: step=25600/100000 (25.60%), epoch=0, lr=1e-05, speed=1.213 step/s, elapsed=05:51:40, eta=17:02:03 +[2026-04-15 11:27:07,785][trainer.accelerators.base_accelerator][INFO] - Training progress: step=25650/100000 (25.65%), epoch=0, lr=1e-05, speed=1.215 step/s, elapsed=05:51:58, eta=17:00:14 +[2026-04-15 11:27:25,634][trainer.accelerators.base_accelerator][INFO] - Training progress: step=25700/100000 (25.70%), epoch=0, lr=1e-05, speed=1.216 step/s, elapsed=05:52:16, eta=16:58:26 +[2026-04-15 11:27:43,518][trainer.accelerators.base_accelerator][INFO] - Training progress: step=25750/100000 (25.75%), epoch=0, lr=1e-05, speed=1.217 step/s, elapsed=05:52:34, eta=16:56:38 +[2026-04-15 11:28:01,313][trainer.accelerators.base_accelerator][INFO] - Training progress: step=25800/100000 (25.80%), epoch=0, lr=1e-05, speed=1.219 step/s, elapsed=05:52:51, eta=16:54:50 +[2026-04-15 11:28:19,154][trainer.accelerators.base_accelerator][INFO] - Training progress: step=25850/100000 (25.85%), epoch=0, lr=1e-05, speed=1.220 step/s, elapsed=05:53:09, eta=16:53:02 +[2026-04-15 11:28:37,023][trainer.accelerators.base_accelerator][INFO] - Training progress: step=25900/100000 (25.90%), epoch=0, lr=1e-05, speed=1.221 step/s, elapsed=05:53:27, eta=16:51:15 +[2026-04-15 11:28:54,815][trainer.accelerators.base_accelerator][INFO] - Training progress: step=25950/100000 (25.95%), epoch=0, lr=1e-05, speed=1.223 step/s, elapsed=05:53:45, eta=16:49:28 +[2026-04-15 11:29:12,695][trainer.accelerators.base_accelerator][INFO] - Training progress: step=26000/100000 (26.00%), epoch=0, lr=1e-05, speed=1.224 step/s, elapsed=05:54:03, eta=16:47:41 +[2026-04-15 11:29:12,718][__main__][INFO] - ========== EVAL START (periodic@gstep=26000) ========== +[2026-04-15 11:29:12,719][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-15 11:29:12,719][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 11:29:28,527][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.162357330322266, 'accuracy': 0.4588235294117647, 'num_samples': 425, 'test_unique_accuracy': 0.5393518518518519, 'test_unique_num_samples': 432} +[2026-04-15 11:29:28,528][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-15 11:29:28,528][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 11:29:43,595][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.162357330322266, 'accuracy': 0.4588235294117647, 'num_samples': 425, 'test_unique_accuracy': 0.5023148148148148, 'test_unique_num_samples': 432} +[2026-04-15 11:29:43,595][__main__][INFO] - ========== EVAL END (periodic@gstep=26000) ========== +[2026-04-15 11:29:43,595][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.158060073852539, 'accuracy': 0.4588235294117647, 'num_samples': 425, 'test_unique_accuracy': 0.5023148148148148, 'test_unique_num_samples': 432} +[2026-04-15 11:29:43,598][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.4588235294117647 is not better than 0.48705882352941177 of logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep1000, skipping checkpoint +[2026-04-15 11:30:01,502][trainer.accelerators.base_accelerator][INFO] - Training progress: step=26050/100000 (26.05%), epoch=0, lr=1e-05, speed=1.223 step/s, elapsed=05:54:52, eta=16:47:23 +[2026-04-15 11:30:19,297][trainer.accelerators.base_accelerator][INFO] - Training progress: step=26100/100000 (26.10%), epoch=0, lr=1e-05, speed=1.225 step/s, elapsed=05:55:09, eta=16:45:37 +[2026-04-15 11:30:37,215][trainer.accelerators.base_accelerator][INFO] - Training progress: step=26150/100000 (26.15%), epoch=0, lr=1e-05, speed=1.226 step/s, elapsed=05:55:27, eta=16:43:51 +[2026-04-15 11:30:55,330][trainer.accelerators.base_accelerator][INFO] - Training progress: step=26200/100000 (26.20%), epoch=0, lr=1e-05, speed=1.227 step/s, elapsed=05:55:46, eta=16:42:07 +[2026-04-15 11:31:13,033][trainer.accelerators.base_accelerator][INFO] - Training progress: step=26250/100000 (26.25%), epoch=0, lr=1e-05, speed=1.229 step/s, elapsed=05:56:03, eta=16:40:21 +[2026-04-15 11:31:30,890][trainer.accelerators.base_accelerator][INFO] - Training progress: step=26300/100000 (26.30%), epoch=0, lr=1e-05, speed=1.230 step/s, elapsed=05:56:21, eta=16:38:37 +[2026-04-15 11:31:48,792][trainer.accelerators.base_accelerator][INFO] - Training progress: step=26350/100000 (26.35%), epoch=0, lr=1e-05, speed=1.231 step/s, elapsed=05:56:39, eta=16:36:52 +[2026-04-15 11:32:06,720][trainer.accelerators.base_accelerator][INFO] - Training progress: step=26400/100000 (26.40%), epoch=0, lr=1e-05, speed=1.233 step/s, elapsed=05:56:57, eta=16:35:09 +[2026-04-15 11:32:24,549][trainer.accelerators.base_accelerator][INFO] - Training progress: step=26450/100000 (26.45%), epoch=0, lr=1e-05, speed=1.234 step/s, elapsed=05:57:15, eta=16:33:25 +[2026-04-15 11:32:42,380][trainer.accelerators.base_accelerator][INFO] - Training progress: step=26500/100000 (26.50%), epoch=0, lr=1e-05, speed=1.235 step/s, elapsed=05:57:33, eta=16:31:41 +[2026-04-15 11:33:00,174][trainer.accelerators.base_accelerator][INFO] - Training progress: step=26550/100000 (26.55%), epoch=0, lr=1e-05, speed=1.237 step/s, elapsed=05:57:50, eta=16:29:58 +[2026-04-15 11:33:18,011][trainer.accelerators.base_accelerator][INFO] - Training progress: step=26600/100000 (26.60%), epoch=0, lr=1e-05, speed=1.238 step/s, elapsed=05:58:08, eta=16:28:15 +[2026-04-15 11:33:35,890][trainer.accelerators.base_accelerator][INFO] - Training progress: step=26650/100000 (26.65%), epoch=0, lr=1e-05, speed=1.239 step/s, elapsed=05:58:26, eta=16:26:33 +[2026-04-15 11:33:53,720][trainer.accelerators.base_accelerator][INFO] - Training progress: step=26700/100000 (26.70%), epoch=0, lr=1e-05, speed=1.240 step/s, elapsed=05:58:44, eta=16:24:51 +[2026-04-15 11:34:11,478][trainer.accelerators.base_accelerator][INFO] - Training progress: step=26750/100000 (26.75%), epoch=0, lr=1e-05, speed=1.242 step/s, elapsed=05:59:02, eta=16:23:09 +[2026-04-15 11:34:29,233][trainer.accelerators.base_accelerator][INFO] - Training progress: step=26800/100000 (26.80%), epoch=0, lr=1e-05, speed=1.243 step/s, elapsed=05:59:19, eta=16:21:27 +[2026-04-15 11:34:47,016][trainer.accelerators.base_accelerator][INFO] - Training progress: step=26850/100000 (26.85%), epoch=0, lr=1e-05, speed=1.244 step/s, elapsed=05:59:37, eta=16:19:46 +[2026-04-15 11:35:04,855][trainer.accelerators.base_accelerator][INFO] - Training progress: step=26900/100000 (26.90%), epoch=0, lr=1e-05, speed=1.246 step/s, elapsed=05:59:55, eta=16:18:05 +[2026-04-15 11:35:22,676][trainer.accelerators.base_accelerator][INFO] - Training progress: step=26950/100000 (26.95%), epoch=0, lr=1e-05, speed=1.247 step/s, elapsed=06:00:13, eta=16:16:24 +[2026-04-15 11:35:40,531][trainer.accelerators.base_accelerator][INFO] - Training progress: step=27000/100000 (27.00%), epoch=0, lr=1e-05, speed=1.248 step/s, elapsed=06:00:31, eta=16:14:44 +[2026-04-15 11:35:40,556][__main__][INFO] - ========== EVAL START (periodic@gstep=27000) ========== +[2026-04-15 11:35:40,556][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-15 11:35:40,557][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 11:35:55,711][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.158060073852539, 'accuracy': 0.5035294117647059, 'num_samples': 425, 'test_unique_accuracy': 0.5023148148148148, 'test_unique_num_samples': 432} +[2026-04-15 11:35:55,711][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-15 11:35:55,712][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 11:36:10,735][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.158060073852539, 'accuracy': 0.5035294117647059, 'num_samples': 425, 'test_unique_accuracy': 0.4837962962962963, 'test_unique_num_samples': 432} +[2026-04-15 11:36:10,735][__main__][INFO] - ========== EVAL END (periodic@gstep=27000) ========== +[2026-04-15 11:36:10,735][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.156301498413086, 'accuracy': 0.5035294117647059, 'num_samples': 425, 'test_unique_accuracy': 0.4837962962962963, 'test_unique_num_samples': 432} +[2026-04-15 11:36:10,739][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.5035294117647059 is not better than 0.52 of logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep2000, skipping checkpoint +[2026-04-15 11:36:28,551][trainer.accelerators.base_accelerator][INFO] - Training progress: step=27050/100000 (27.05%), epoch=0, lr=1e-05, speed=1.248 step/s, elapsed=06:01:19, eta=16:14:25 +[2026-04-15 11:36:46,373][trainer.accelerators.base_accelerator][INFO] - Training progress: step=27100/100000 (27.10%), epoch=0, lr=1e-05, speed=1.249 step/s, elapsed=06:01:37, eta=16:12:45 +[2026-04-15 11:37:04,210][trainer.accelerators.base_accelerator][INFO] - Training progress: step=27150/100000 (27.15%), epoch=0, lr=1e-05, speed=1.250 step/s, elapsed=06:01:54, eta=16:11:06 +[2026-04-15 11:37:22,071][trainer.accelerators.base_accelerator][INFO] - Training progress: step=27200/100000 (27.20%), epoch=0, lr=1e-05, speed=1.252 step/s, elapsed=06:02:12, eta=16:09:27 +[2026-04-15 11:37:40,191][trainer.accelerators.base_accelerator][INFO] - Training progress: step=27250/100000 (27.25%), epoch=0, lr=1e-05, speed=1.253 step/s, elapsed=06:02:30, eta=16:07:48 +[2026-04-15 11:37:58,022][trainer.accelerators.base_accelerator][INFO] - Training progress: step=27300/100000 (27.30%), epoch=0, lr=1e-05, speed=1.254 step/s, elapsed=06:02:48, eta=16:06:10 +[2026-04-15 11:38:15,898][trainer.accelerators.base_accelerator][INFO] - Training progress: step=27350/100000 (27.35%), epoch=0, lr=1e-05, speed=1.255 step/s, elapsed=06:03:06, eta=16:04:31 +[2026-04-15 11:38:33,703][trainer.accelerators.base_accelerator][INFO] - Training progress: step=27400/100000 (27.40%), epoch=0, lr=1e-05, speed=1.257 step/s, elapsed=06:03:24, eta=16:02:53 +[2026-04-15 11:38:51,615][trainer.accelerators.base_accelerator][INFO] - Training progress: step=27450/100000 (27.45%), epoch=0, lr=1e-05, speed=1.258 step/s, elapsed=06:03:42, eta=16:01:16 +[2026-04-15 11:39:09,439][trainer.accelerators.base_accelerator][INFO] - Training progress: step=27500/100000 (27.50%), epoch=0, lr=1e-05, speed=1.259 step/s, elapsed=06:04:00, eta=15:59:38 +[2026-04-15 11:39:27,306][trainer.accelerators.base_accelerator][INFO] - Training progress: step=27550/100000 (27.55%), epoch=0, lr=1e-05, speed=1.260 step/s, elapsed=06:04:17, eta=15:58:01 +[2026-04-15 11:39:45,193][trainer.accelerators.base_accelerator][INFO] - Training progress: step=27600/100000 (27.60%), epoch=0, lr=1e-05, speed=1.262 step/s, elapsed=06:04:35, eta=15:56:24 +[2026-04-15 11:40:03,130][trainer.accelerators.base_accelerator][INFO] - Training progress: step=27650/100000 (27.65%), epoch=0, lr=1e-05, speed=1.263 step/s, elapsed=06:04:53, eta=15:54:48 +[2026-04-15 11:40:21,014][trainer.accelerators.base_accelerator][INFO] - Training progress: step=27700/100000 (27.70%), epoch=0, lr=1e-05, speed=1.264 step/s, elapsed=06:05:11, eta=15:53:11 +[2026-04-15 11:40:38,881][trainer.accelerators.base_accelerator][INFO] - Training progress: step=27750/100000 (27.75%), epoch=0, lr=1e-05, speed=1.265 step/s, elapsed=06:05:29, eta=15:51:35 +[2026-04-15 11:40:56,945][trainer.accelerators.base_accelerator][INFO] - Training progress: step=27800/100000 (27.80%), epoch=0, lr=1e-05, speed=1.267 step/s, elapsed=06:05:47, eta=15:50:00 +[2026-04-15 11:41:14,824][trainer.accelerators.base_accelerator][INFO] - Training progress: step=27850/100000 (27.85%), epoch=0, lr=1e-05, speed=1.268 step/s, elapsed=06:06:05, eta=15:48:25 +[2026-04-15 11:41:32,691][trainer.accelerators.base_accelerator][INFO] - Training progress: step=27900/100000 (27.90%), epoch=0, lr=1e-05, speed=1.269 step/s, elapsed=06:06:23, eta=15:46:50 +[2026-04-15 11:41:50,552][trainer.accelerators.base_accelerator][INFO] - Training progress: step=27950/100000 (27.95%), epoch=0, lr=1e-05, speed=1.270 step/s, elapsed=06:06:41, eta=15:45:15 +[2026-04-15 11:42:08,467][trainer.accelerators.base_accelerator][INFO] - Training progress: step=28000/100000 (28.00%), epoch=0, lr=1e-05, speed=1.272 step/s, elapsed=06:06:59, eta=15:43:40 +[2026-04-15 11:42:08,490][__main__][INFO] - ========== EVAL START (periodic@gstep=28000) ========== +[2026-04-15 11:42:08,490][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-15 11:42:08,490][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 11:42:24,803][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.156301498413086, 'accuracy': 0.49176470588235294, 'num_samples': 425, 'test_unique_accuracy': 0.4837962962962963, 'test_unique_num_samples': 432} +[2026-04-15 11:42:24,804][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-15 11:42:24,804][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 11:42:39,895][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.156301498413086, 'accuracy': 0.49176470588235294, 'num_samples': 425, 'test_unique_accuracy': 0.4861111111111111, 'test_unique_num_samples': 432} +[2026-04-15 11:42:39,895][__main__][INFO] - ========== EVAL END (periodic@gstep=28000) ========== +[2026-04-15 11:42:39,896][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.151320457458496, 'accuracy': 0.49176470588235294, 'num_samples': 425, 'test_unique_accuracy': 0.4861111111111111, 'test_unique_num_samples': 432} +[2026-04-15 11:42:39,902][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.49176470588235294 is not better than 0.52 of logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep2000, skipping checkpoint +[2026-04-15 11:42:57,813][trainer.accelerators.base_accelerator][INFO] - Training progress: step=28050/100000 (28.05%), epoch=0, lr=1e-05, speed=1.271 step/s, elapsed=06:07:48, eta=15:43:27 +[2026-04-15 11:43:15,601][trainer.accelerators.base_accelerator][INFO] - Training progress: step=28100/100000 (28.10%), epoch=0, lr=1e-05, speed=1.272 step/s, elapsed=06:08:06, eta=15:41:52 +[2026-04-15 11:43:33,445][trainer.accelerators.base_accelerator][INFO] - Training progress: step=28150/100000 (28.15%), epoch=0, lr=1e-05, speed=1.274 step/s, elapsed=06:08:24, eta=15:40:18 +[2026-04-15 11:43:51,323][trainer.accelerators.base_accelerator][INFO] - Training progress: step=28200/100000 (28.20%), epoch=0, lr=1e-05, speed=1.275 step/s, elapsed=06:08:42, eta=15:38:44 +[2026-04-15 11:44:09,269][trainer.accelerators.base_accelerator][INFO] - Training progress: step=28250/100000 (28.25%), epoch=0, lr=1e-05, speed=1.276 step/s, elapsed=06:08:59, eta=15:37:11 +[2026-04-15 11:44:27,203][trainer.accelerators.base_accelerator][INFO] - Training progress: step=28300/100000 (28.30%), epoch=0, lr=1e-05, speed=1.277 step/s, elapsed=06:09:17, eta=15:35:38 +[2026-04-15 11:44:45,270][trainer.accelerators.base_accelerator][INFO] - Training progress: step=28350/100000 (28.35%), epoch=0, lr=1e-05, speed=1.278 step/s, elapsed=06:09:35, eta=15:34:06 +[2026-04-15 11:45:03,117][trainer.accelerators.base_accelerator][INFO] - Training progress: step=28400/100000 (28.40%), epoch=0, lr=1e-05, speed=1.280 step/s, elapsed=06:09:53, eta=15:32:33 +[2026-04-15 11:45:21,008][trainer.accelerators.base_accelerator][INFO] - Training progress: step=28450/100000 (28.45%), epoch=0, lr=1e-05, speed=1.281 step/s, elapsed=06:10:11, eta=15:31:01 +[2026-04-15 11:45:38,878][trainer.accelerators.base_accelerator][INFO] - Training progress: step=28500/100000 (28.50%), epoch=0, lr=1e-05, speed=1.282 step/s, elapsed=06:10:29, eta=15:29:28 +[2026-04-15 11:45:56,825][trainer.accelerators.base_accelerator][INFO] - Training progress: step=28550/100000 (28.55%), epoch=0, lr=1e-05, speed=1.283 step/s, elapsed=06:10:47, eta=15:27:57 +[2026-04-15 11:46:14,718][trainer.accelerators.base_accelerator][INFO] - Training progress: step=28600/100000 (28.60%), epoch=0, lr=1e-05, speed=1.285 step/s, elapsed=06:11:05, eta=15:26:25 +[2026-04-15 11:46:32,621][trainer.accelerators.base_accelerator][INFO] - Training progress: step=28650/100000 (28.65%), epoch=0, lr=1e-05, speed=1.286 step/s, elapsed=06:11:23, eta=15:24:54 +[2026-04-15 11:46:50,508][trainer.accelerators.base_accelerator][INFO] - Training progress: step=28700/100000 (28.70%), epoch=0, lr=1e-05, speed=1.287 step/s, elapsed=06:11:41, eta=15:23:23 +[2026-04-15 11:47:08,354][trainer.accelerators.base_accelerator][INFO] - Training progress: step=28750/100000 (28.75%), epoch=0, lr=1e-05, speed=1.288 step/s, elapsed=06:11:59, eta=15:21:52 +[2026-04-15 11:47:26,263][trainer.accelerators.base_accelerator][INFO] - Training progress: step=28800/100000 (28.80%), epoch=0, lr=1e-05, speed=1.289 step/s, elapsed=06:12:16, eta=15:20:21 +[2026-04-15 11:47:44,137][trainer.accelerators.base_accelerator][INFO] - Training progress: step=28850/100000 (28.85%), epoch=0, lr=1e-05, speed=1.291 step/s, elapsed=06:12:34, eta=15:18:51 +[2026-04-15 11:48:01,902][trainer.accelerators.base_accelerator][INFO] - Training progress: step=28900/100000 (28.90%), epoch=0, lr=1e-05, speed=1.292 step/s, elapsed=06:12:52, eta=15:17:21 +[2026-04-15 11:48:19,744][trainer.accelerators.base_accelerator][INFO] - Training progress: step=28950/100000 (28.95%), epoch=0, lr=1e-05, speed=1.293 step/s, elapsed=06:13:10, eta=15:15:51 +[2026-04-15 11:48:37,525][trainer.accelerators.base_accelerator][INFO] - Training progress: step=29000/100000 (29.00%), epoch=0, lr=1e-05, speed=1.294 step/s, elapsed=06:13:28, eta=15:14:21 +[2026-04-15 11:48:37,549][__main__][INFO] - ========== EVAL START (periodic@gstep=29000) ========== +[2026-04-15 11:48:37,549][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-15 11:48:37,549][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 11:48:52,772][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.151320457458496, 'accuracy': 0.48470588235294115, 'num_samples': 425, 'test_unique_accuracy': 0.4861111111111111, 'test_unique_num_samples': 432} +[2026-04-15 11:48:52,772][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-15 11:48:52,772][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 11:49:07,851][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.151320457458496, 'accuracy': 0.48470588235294115, 'num_samples': 425, 'test_unique_accuracy': 0.5277777777777778, 'test_unique_num_samples': 432} +[2026-04-15 11:49:07,851][__main__][INFO] - ========== EVAL END (periodic@gstep=29000) ========== +[2026-04-15 11:49:07,851][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.154900550842285, 'accuracy': 0.48470588235294115, 'num_samples': 425, 'test_unique_accuracy': 0.5277777777777778, 'test_unique_num_samples': 432} +[2026-04-15 11:49:07,855][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.48470588235294115 is not better than 0.48705882352941177 of logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep1000, skipping checkpoint +[2026-04-15 11:49:25,629][trainer.accelerators.base_accelerator][INFO] - Training progress: step=29050/100000 (29.05%), epoch=0, lr=1e-05, speed=1.294 step/s, elapsed=06:14:16, eta=15:14:05 +[2026-04-15 11:49:43,520][trainer.accelerators.base_accelerator][INFO] - Training progress: step=29100/100000 (29.10%), epoch=0, lr=1e-05, speed=1.295 step/s, elapsed=06:14:34, eta=15:12:36 +[2026-04-15 11:50:01,344][trainer.accelerators.base_accelerator][INFO] - Training progress: step=29150/100000 (29.15%), epoch=0, lr=1e-05, speed=1.296 step/s, elapsed=06:14:52, eta=15:11:07 +[2026-04-15 11:50:19,350][trainer.accelerators.base_accelerator][INFO] - Training progress: step=29200/100000 (29.20%), epoch=0, lr=1e-05, speed=1.297 step/s, elapsed=06:15:10, eta=15:09:39 +[2026-04-15 11:50:37,224][trainer.accelerators.base_accelerator][INFO] - Training progress: step=29250/100000 (29.25%), epoch=0, lr=1e-05, speed=1.298 step/s, elapsed=06:15:27, eta=15:08:10 +[2026-04-15 11:50:55,200][trainer.accelerators.base_accelerator][INFO] - Training progress: step=29300/100000 (29.30%), epoch=0, lr=1e-05, speed=1.300 step/s, elapsed=06:15:45, eta=15:06:42 +[2026-04-15 11:51:13,082][trainer.accelerators.base_accelerator][INFO] - Training progress: step=29350/100000 (29.35%), epoch=0, lr=1e-05, speed=1.301 step/s, elapsed=06:16:03, eta=15:05:14 +[2026-04-15 11:51:30,940][trainer.accelerators.base_accelerator][INFO] - Training progress: step=29400/100000 (29.40%), epoch=0, lr=1e-05, speed=1.302 step/s, elapsed=06:16:21, eta=15:03:46 +[2026-04-15 11:51:50,035][trainer.accelerators.base_accelerator][INFO] - Training progress: step=29450/100000 (29.45%), epoch=0, lr=1e-05, speed=1.303 step/s, elapsed=06:16:40, eta=15:02:21 +[2026-04-15 11:52:07,921][trainer.accelerators.base_accelerator][INFO] - Training progress: step=29500/100000 (29.50%), epoch=0, lr=1e-05, speed=1.304 step/s, elapsed=06:16:58, eta=15:00:54 +[2026-04-15 11:52:25,798][trainer.accelerators.base_accelerator][INFO] - Training progress: step=29550/100000 (29.55%), epoch=0, lr=1e-05, speed=1.305 step/s, elapsed=06:17:16, eta=14:59:27 +[2026-04-15 11:52:43,705][trainer.accelerators.base_accelerator][INFO] - Training progress: step=29600/100000 (29.60%), epoch=0, lr=1e-05, speed=1.307 step/s, elapsed=06:17:34, eta=14:58:00 +[2026-04-15 11:53:01,602][trainer.accelerators.base_accelerator][INFO] - Training progress: step=29650/100000 (29.65%), epoch=0, lr=1e-05, speed=1.308 step/s, elapsed=06:17:52, eta=14:56:34 +[2026-04-15 11:53:19,454][trainer.accelerators.base_accelerator][INFO] - Training progress: step=29700/100000 (29.70%), epoch=0, lr=1e-05, speed=1.309 step/s, elapsed=06:18:10, eta=14:55:07 +[2026-04-15 11:53:37,340][trainer.accelerators.base_accelerator][INFO] - Training progress: step=29750/100000 (29.75%), epoch=0, lr=1e-05, speed=1.310 step/s, elapsed=06:18:28, eta=14:53:41 +[2026-04-15 11:53:55,203][trainer.accelerators.base_accelerator][INFO] - Training progress: step=29800/100000 (29.80%), epoch=0, lr=1e-05, speed=1.311 step/s, elapsed=06:18:45, eta=14:52:15 +[2026-04-15 11:54:13,040][trainer.accelerators.base_accelerator][INFO] - Training progress: step=29850/100000 (29.85%), epoch=0, lr=1e-05, speed=1.312 step/s, elapsed=06:19:03, eta=14:50:49 +[2026-04-15 11:54:30,903][trainer.accelerators.base_accelerator][INFO] - Training progress: step=29900/100000 (29.90%), epoch=0, lr=1e-05, speed=1.314 step/s, elapsed=06:19:21, eta=14:49:24 +[2026-04-15 11:54:48,711][trainer.accelerators.base_accelerator][INFO] - Training progress: step=29950/100000 (29.95%), epoch=0, lr=1e-05, speed=1.315 step/s, elapsed=06:19:39, eta=14:47:58 +[2026-04-15 11:55:06,575][trainer.accelerators.base_accelerator][INFO] - Training progress: step=30000/100000 (30.00%), epoch=0, lr=1e-05, speed=1.316 step/s, elapsed=06:19:57, eta=14:46:33 +[2026-04-15 11:55:06,599][__main__][INFO] - ========== EVAL START (periodic@gstep=30000) ========== +[2026-04-15 11:55:06,599][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-15 11:55:06,600][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 11:55:21,921][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.154900550842285, 'accuracy': 0.4988235294117647, 'num_samples': 425, 'test_unique_accuracy': 0.5277777777777778, 'test_unique_num_samples': 432} +[2026-04-15 11:55:21,922][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-15 11:55:21,922][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 11:55:37,010][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.154900550842285, 'accuracy': 0.4988235294117647, 'num_samples': 425, 'test_unique_accuracy': 0.5185185185185185, 'test_unique_num_samples': 432} +[2026-04-15 11:55:37,010][__main__][INFO] - ========== EVAL END (periodic@gstep=30000) ========== +[2026-04-15 11:55:37,010][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.14932918548584, 'accuracy': 0.4988235294117647, 'num_samples': 425, 'test_unique_accuracy': 0.5185185185185185, 'test_unique_num_samples': 432} +[2026-04-15 11:55:37,014][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.4988235294117647 is not better than 0.52 of logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep2000, skipping checkpoint +[2026-04-15 11:55:54,799][trainer.accelerators.base_accelerator][INFO] - Training progress: step=30050/100000 (30.05%), epoch=0, lr=1e-05, speed=1.315 step/s, elapsed=06:20:45, eta=14:46:19 +[2026-04-15 11:56:12,649][trainer.accelerators.base_accelerator][INFO] - Training progress: step=30100/100000 (30.10%), epoch=0, lr=1e-05, speed=1.317 step/s, elapsed=06:21:03, eta=14:44:54 +[2026-04-15 11:56:30,493][trainer.accelerators.base_accelerator][INFO] - Training progress: step=30150/100000 (30.15%), epoch=0, lr=1e-05, speed=1.318 step/s, elapsed=06:21:21, eta=14:43:29 +[2026-04-15 11:56:48,385][trainer.accelerators.base_accelerator][INFO] - Training progress: step=30200/100000 (30.20%), epoch=0, lr=1e-05, speed=1.319 step/s, elapsed=06:21:39, eta=14:42:05 +[2026-04-15 11:57:06,360][trainer.accelerators.base_accelerator][INFO] - Training progress: step=30250/100000 (30.25%), epoch=0, lr=1e-05, speed=1.320 step/s, elapsed=06:21:57, eta=14:40:41 +[2026-04-15 11:57:24,369][trainer.accelerators.base_accelerator][INFO] - Training progress: step=30300/100000 (30.30%), epoch=0, lr=1e-05, speed=1.321 step/s, elapsed=06:22:15, eta=14:39:18 +[2026-04-15 11:57:42,354][trainer.accelerators.base_accelerator][INFO] - Training progress: step=30350/100000 (30.35%), epoch=0, lr=1e-05, speed=1.322 step/s, elapsed=06:22:33, eta=14:37:54 +[2026-04-15 11:58:00,288][trainer.accelerators.base_accelerator][INFO] - Training progress: step=30400/100000 (30.40%), epoch=0, lr=1e-05, speed=1.323 step/s, elapsed=06:22:50, eta=14:36:31 +[2026-04-15 11:58:18,254][trainer.accelerators.base_accelerator][INFO] - Training progress: step=30450/100000 (30.45%), epoch=0, lr=1e-05, speed=1.325 step/s, elapsed=06:23:08, eta=14:35:08 +[2026-04-15 11:58:37,137][trainer.accelerators.base_accelerator][INFO] - Training progress: step=30500/100000 (30.50%), epoch=0, lr=1e-05, speed=1.326 step/s, elapsed=06:23:27, eta=14:33:47 +[2026-04-15 11:58:54,983][trainer.accelerators.base_accelerator][INFO] - Training progress: step=30550/100000 (30.55%), epoch=0, lr=1e-05, speed=1.327 step/s, elapsed=06:23:45, eta=14:32:24 +[2026-04-15 11:59:12,850][trainer.accelerators.base_accelerator][INFO] - Training progress: step=30600/100000 (30.60%), epoch=0, lr=1e-05, speed=1.328 step/s, elapsed=06:24:03, eta=14:31:02 +[2026-04-15 11:59:30,794][trainer.accelerators.base_accelerator][INFO] - Training progress: step=30650/100000 (30.65%), epoch=0, lr=1e-05, speed=1.329 step/s, elapsed=06:24:21, eta=14:29:39 +[2026-04-15 11:59:48,762][trainer.accelerators.base_accelerator][INFO] - Training progress: step=30700/100000 (30.70%), epoch=0, lr=1e-05, speed=1.330 step/s, elapsed=06:24:39, eta=14:28:17 +[2026-04-15 12:00:06,699][trainer.accelerators.base_accelerator][INFO] - Training progress: step=30750/100000 (30.75%), epoch=0, lr=1e-05, speed=1.331 step/s, elapsed=06:24:57, eta=14:26:56 +[2026-04-15 12:00:24,633][trainer.accelerators.base_accelerator][INFO] - Training progress: step=30800/100000 (30.80%), epoch=0, lr=1e-05, speed=1.332 step/s, elapsed=06:25:15, eta=14:25:34 +[2026-04-15 12:00:42,515][trainer.accelerators.base_accelerator][INFO] - Training progress: step=30850/100000 (30.85%), epoch=0, lr=1e-05, speed=1.334 step/s, elapsed=06:25:33, eta=14:24:12 +[2026-04-15 12:01:00,437][trainer.accelerators.base_accelerator][INFO] - Training progress: step=30900/100000 (30.90%), epoch=0, lr=1e-05, speed=1.335 step/s, elapsed=06:25:51, eta=14:22:51 +[2026-04-15 12:01:18,444][trainer.accelerators.base_accelerator][INFO] - Training progress: step=30950/100000 (30.95%), epoch=0, lr=1e-05, speed=1.336 step/s, elapsed=06:26:09, eta=14:21:30 +[2026-04-15 12:01:36,514][trainer.accelerators.base_accelerator][INFO] - Training progress: step=31000/100000 (31.00%), epoch=0, lr=1e-05, speed=1.337 step/s, elapsed=06:26:27, eta=14:20:10 +[2026-04-15 12:01:36,539][__main__][INFO] - ========== EVAL START (periodic@gstep=31000) ========== +[2026-04-15 12:01:36,539][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-15 12:01:36,539][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 12:01:51,592][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.14932918548584, 'accuracy': 0.5058823529411764, 'num_samples': 425, 'test_unique_accuracy': 0.5185185185185185, 'test_unique_num_samples': 432} +[2026-04-15 12:01:51,592][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-15 12:01:51,592][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 12:02:06,679][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.14932918548584, 'accuracy': 0.5058823529411764, 'num_samples': 425, 'test_unique_accuracy': 0.5023148148148148, 'test_unique_num_samples': 432} +[2026-04-15 12:02:06,679][__main__][INFO] - ========== EVAL END (periodic@gstep=31000) ========== +[2026-04-15 12:02:06,680][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.146273612976074, 'accuracy': 0.5058823529411764, 'num_samples': 425, 'test_unique_accuracy': 0.5023148148148148, 'test_unique_num_samples': 432} +[2026-04-15 12:02:06,683][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.5058823529411764 is not better than 0.52 of logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep2000, skipping checkpoint +[2026-04-15 12:02:24,600][trainer.accelerators.base_accelerator][INFO] - Training progress: step=31050/100000 (31.05%), epoch=0, lr=1e-05, speed=1.336 step/s, elapsed=06:27:15, eta=14:19:56 +[2026-04-15 12:02:42,568][trainer.accelerators.base_accelerator][INFO] - Training progress: step=31100/100000 (31.10%), epoch=0, lr=1e-05, speed=1.337 step/s, elapsed=06:27:33, eta=14:18:36 +[2026-04-15 12:03:00,511][trainer.accelerators.base_accelerator][INFO] - Training progress: step=31150/100000 (31.15%), epoch=0, lr=1e-05, speed=1.339 step/s, elapsed=06:27:51, eta=14:17:15 +[2026-04-15 12:03:18,426][trainer.accelerators.base_accelerator][INFO] - Training progress: step=31200/100000 (31.20%), epoch=0, lr=1e-05, speed=1.340 step/s, elapsed=06:28:09, eta=14:15:55 +[2026-04-15 12:03:36,655][trainer.accelerators.base_accelerator][INFO] - Training progress: step=31250/100000 (31.25%), epoch=0, lr=1e-05, speed=1.341 step/s, elapsed=06:28:27, eta=14:14:36 +[2026-04-15 12:03:54,637][trainer.accelerators.base_accelerator][INFO] - Training progress: step=31300/100000 (31.30%), epoch=0, lr=1e-05, speed=1.342 step/s, elapsed=06:28:45, eta=14:13:16 +[2026-04-15 12:04:12,509][trainer.accelerators.base_accelerator][INFO] - Training progress: step=31350/100000 (31.35%), epoch=0, lr=1e-05, speed=1.343 step/s, elapsed=06:29:03, eta=14:11:56 +[2026-04-15 12:04:30,369][trainer.accelerators.base_accelerator][INFO] - Training progress: step=31400/100000 (31.40%), epoch=0, lr=1e-05, speed=1.344 step/s, elapsed=06:29:21, eta=14:10:37 +[2026-04-15 12:04:48,538][trainer.accelerators.base_accelerator][INFO] - Training progress: step=31450/100000 (31.45%), epoch=0, lr=1e-05, speed=1.345 step/s, elapsed=06:29:39, eta=14:09:18 +[2026-04-15 12:05:06,449][trainer.accelerators.base_accelerator][INFO] - Training progress: step=31500/100000 (31.50%), epoch=0, lr=1e-05, speed=1.346 step/s, elapsed=06:29:57, eta=14:07:59 +[2026-04-15 12:05:24,410][trainer.accelerators.base_accelerator][INFO] - Training progress: step=31550/100000 (31.55%), epoch=0, lr=1e-05, speed=1.347 step/s, elapsed=06:30:15, eta=14:06:40 +[2026-04-15 12:05:42,575][trainer.accelerators.base_accelerator][INFO] - Training progress: step=31600/100000 (31.60%), epoch=0, lr=1e-05, speed=1.349 step/s, elapsed=06:30:33, eta=14:05:22 +[2026-04-15 12:06:00,390][trainer.accelerators.base_accelerator][INFO] - Training progress: step=31650/100000 (31.65%), epoch=0, lr=1e-05, speed=1.350 step/s, elapsed=06:30:51, eta=14:04:03 +[2026-04-15 12:06:18,290][trainer.accelerators.base_accelerator][INFO] - Training progress: step=31700/100000 (31.70%), epoch=0, lr=1e-05, speed=1.351 step/s, elapsed=06:31:08, eta=14:02:45 +[2026-04-15 12:06:36,204][trainer.accelerators.base_accelerator][INFO] - Training progress: step=31750/100000 (31.75%), epoch=0, lr=1e-05, speed=1.352 step/s, elapsed=06:31:26, eta=14:01:27 +[2026-04-15 12:06:54,096][trainer.accelerators.base_accelerator][INFO] - Training progress: step=31800/100000 (31.80%), epoch=0, lr=1e-05, speed=1.353 step/s, elapsed=06:31:44, eta=14:00:09 +[2026-04-15 12:07:11,839][trainer.accelerators.base_accelerator][INFO] - Training progress: step=31850/100000 (31.85%), epoch=0, lr=1e-05, speed=1.354 step/s, elapsed=06:32:02, eta=13:58:51 +[2026-04-15 12:07:29,741][trainer.accelerators.base_accelerator][INFO] - Training progress: step=31900/100000 (31.90%), epoch=0, lr=1e-05, speed=1.355 step/s, elapsed=06:32:20, eta=13:57:34 +[2026-04-15 12:07:47,605][trainer.accelerators.base_accelerator][INFO] - Training progress: step=31950/100000 (31.95%), epoch=0, lr=1e-05, speed=1.356 step/s, elapsed=06:32:38, eta=13:56:16 +[2026-04-15 12:08:05,545][trainer.accelerators.base_accelerator][INFO] - Training progress: step=32000/100000 (32.00%), epoch=0, lr=1e-05, speed=1.357 step/s, elapsed=06:32:56, eta=13:54:59 +[2026-04-15 12:08:05,570][__main__][INFO] - ========== EVAL START (periodic@gstep=32000) ========== +[2026-04-15 12:08:05,570][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-15 12:08:05,570][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 12:08:21,763][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.146273612976074, 'accuracy': 0.5788235294117647, 'num_samples': 425, 'test_unique_accuracy': 0.5023148148148148, 'test_unique_num_samples': 432} +[2026-04-15 12:08:21,763][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-15 12:08:21,763][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 12:08:36,816][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.146273612976074, 'accuracy': 0.5788235294117647, 'num_samples': 425, 'test_unique_accuracy': 0.5115740740740741, 'test_unique_num_samples': 432} +[2026-04-15 12:08:36,817][__main__][INFO] - ========== EVAL END (periodic@gstep=32000) ========== +[2026-04-15 12:08:36,817][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.1469144821167, 'accuracy': 0.5788235294117647, 'num_samples': 425, 'test_unique_accuracy': 0.5115740740740741, 'test_unique_num_samples': 432} +[2026-04-15 12:08:36,847][trainer.accelerators.base_accelerator][INFO] - Found 2 checkpoints in logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951 +[2026-04-15 12:08:36,854][trainer.accelerators.base_accelerator][INFO] - Saving checkpoint to logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep32000 +[2026-04-15 12:08:36,856][accelerate.accelerator][INFO] - Saving current state to logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep32000 +[2026-04-15 12:08:52,757][accelerate.checkpointing][INFO] - Model weights saved in logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep32000/model.safetensors +[2026-04-15 12:08:56,142][accelerate.checkpointing][INFO] - Optimizer state saved in logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep32000/optimizer.bin +[2026-04-15 12:08:56,143][accelerate.checkpointing][INFO] - Scheduler state saved in logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep32000/scheduler.bin +[2026-04-15 12:08:56,143][accelerate.checkpointing][INFO] - Sampler state for dataloader 0 saved in logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep32000/sampler.bin +[2026-04-15 12:08:56,144][accelerate.checkpointing][INFO] - Sampler state for dataloader 1 saved in logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep32000/sampler_1.bin +[2026-04-15 12:08:56,144][accelerate.checkpointing][INFO] - Sampler state for dataloader 2 saved in logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep32000/sampler_2.bin +[2026-04-15 12:08:56,233][accelerate.checkpointing][INFO] - Random states saved in logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep32000/random_states_0.pkl +[2026-04-15 12:08:56,267][trainer.accelerators.base_accelerator][INFO] - Saved checkpoint to logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep32000 +[2026-04-15 12:09:14,351][trainer.accelerators.base_accelerator][INFO] - Training progress: step=32050/100000 (32.05%), epoch=0, lr=1e-05, speed=1.355 step/s, elapsed=06:34:05, eta=13:55:30 +[2026-04-15 12:09:32,271][trainer.accelerators.base_accelerator][INFO] - Training progress: step=32100/100000 (32.10%), epoch=0, lr=1e-05, speed=1.357 step/s, elapsed=06:34:22, eta=13:54:13 +[2026-04-15 12:09:50,108][trainer.accelerators.base_accelerator][INFO] - Training progress: step=32150/100000 (32.15%), epoch=0, lr=1e-05, speed=1.358 step/s, elapsed=06:34:40, eta=13:52:56 +[2026-04-15 12:10:07,966][trainer.accelerators.base_accelerator][INFO] - Training progress: step=32200/100000 (32.20%), epoch=0, lr=1e-05, speed=1.359 step/s, elapsed=06:34:58, eta=13:51:39 +[2026-04-15 12:10:25,742][trainer.accelerators.base_accelerator][INFO] - Training progress: step=32250/100000 (32.25%), epoch=0, lr=1e-05, speed=1.360 step/s, elapsed=06:35:16, eta=13:50:22 +[2026-04-15 12:10:43,664][trainer.accelerators.base_accelerator][INFO] - Training progress: step=32300/100000 (32.30%), epoch=0, lr=1e-05, speed=1.361 step/s, elapsed=06:35:34, eta=13:49:06 +[2026-04-15 12:11:01,550][trainer.accelerators.base_accelerator][INFO] - Training progress: step=32350/100000 (32.35%), epoch=0, lr=1e-05, speed=1.362 step/s, elapsed=06:35:52, eta=13:47:50 +[2026-04-15 12:11:19,376][trainer.accelerators.base_accelerator][INFO] - Training progress: step=32400/100000 (32.40%), epoch=0, lr=1e-05, speed=1.363 step/s, elapsed=06:36:10, eta=13:46:34 +[2026-04-15 12:11:37,278][trainer.accelerators.base_accelerator][INFO] - Training progress: step=32450/100000 (32.45%), epoch=0, lr=1e-05, speed=1.364 step/s, elapsed=06:36:27, eta=13:45:18 +[2026-04-15 12:11:55,458][trainer.accelerators.base_accelerator][INFO] - Training progress: step=32500/100000 (32.50%), epoch=0, lr=1e-05, speed=1.365 step/s, elapsed=06:36:46, eta=13:44:03 +[2026-04-15 12:12:13,363][trainer.accelerators.base_accelerator][INFO] - Training progress: step=32550/100000 (32.55%), epoch=0, lr=1e-05, speed=1.366 step/s, elapsed=06:37:04, eta=13:42:48 +[2026-04-15 12:12:31,240][trainer.accelerators.base_accelerator][INFO] - Training progress: step=32600/100000 (32.60%), epoch=0, lr=1e-05, speed=1.367 step/s, elapsed=06:37:21, eta=13:41:32 +[2026-04-15 12:12:49,075][trainer.accelerators.base_accelerator][INFO] - Training progress: step=32650/100000 (32.65%), epoch=0, lr=1e-05, speed=1.368 step/s, elapsed=06:37:39, eta=13:40:17 +[2026-04-15 12:13:06,994][trainer.accelerators.base_accelerator][INFO] - Training progress: step=32700/100000 (32.70%), epoch=0, lr=1e-05, speed=1.369 step/s, elapsed=06:37:57, eta=13:39:02 +[2026-04-15 12:13:24,890][trainer.accelerators.base_accelerator][INFO] - Training progress: step=32750/100000 (32.75%), epoch=0, lr=1e-05, speed=1.371 step/s, elapsed=06:38:15, eta=13:37:48 +[2026-04-15 12:13:42,824][trainer.accelerators.base_accelerator][INFO] - Training progress: step=32800/100000 (32.80%), epoch=0, lr=1e-05, speed=1.372 step/s, elapsed=06:38:33, eta=13:36:33 +[2026-04-15 12:14:00,667][trainer.accelerators.base_accelerator][INFO] - Training progress: step=32850/100000 (32.85%), epoch=0, lr=1e-05, speed=1.373 step/s, elapsed=06:38:51, eta=13:35:19 +[2026-04-15 12:14:18,491][trainer.accelerators.base_accelerator][INFO] - Training progress: step=32900/100000 (32.90%), epoch=0, lr=1e-05, speed=1.374 step/s, elapsed=06:39:09, eta=13:34:04 +[2026-04-15 12:14:36,404][trainer.accelerators.base_accelerator][INFO] - Training progress: step=32950/100000 (32.95%), epoch=0, lr=1e-05, speed=1.375 step/s, elapsed=06:39:27, eta=13:32:50 +[2026-04-15 12:14:54,287][trainer.accelerators.base_accelerator][INFO] - Training progress: step=33000/100000 (33.00%), epoch=0, lr=1e-05, speed=1.376 step/s, elapsed=06:39:44, eta=13:31:36 +[2026-04-15 12:14:54,311][__main__][INFO] - ========== EVAL START (periodic@gstep=33000) ========== +[2026-04-15 12:14:54,311][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-15 12:14:54,311][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 12:15:09,506][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.1469144821167, 'accuracy': 0.5294117647058824, 'num_samples': 425, 'test_unique_accuracy': 0.5115740740740741, 'test_unique_num_samples': 432} +[2026-04-15 12:15:09,506][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-15 12:15:09,506][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 12:15:24,636][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.1469144821167, 'accuracy': 0.5294117647058824, 'num_samples': 425, 'test_unique_accuracy': 0.5092592592592593, 'test_unique_num_samples': 432} +[2026-04-15 12:15:24,637][__main__][INFO] - ========== EVAL END (periodic@gstep=33000) ========== +[2026-04-15 12:15:24,637][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.143119812011719, 'accuracy': 0.5294117647058824, 'num_samples': 425, 'test_unique_accuracy': 0.5092592592592593, 'test_unique_num_samples': 432} +[2026-04-15 12:15:24,641][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.5294117647058824 is not better than 0.5788235294117647 of logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep32000, skipping checkpoint +[2026-04-15 12:15:42,567][trainer.accelerators.base_accelerator][INFO] - Training progress: step=33050/100000 (33.05%), epoch=0, lr=1e-05, speed=1.375 step/s, elapsed=06:40:33, eta=13:31:24 +[2026-04-15 12:16:00,541][trainer.accelerators.base_accelerator][INFO] - Training progress: step=33100/100000 (33.10%), epoch=0, lr=1e-05, speed=1.376 step/s, elapsed=06:40:51, eta=13:30:11 +[2026-04-15 12:16:18,443][trainer.accelerators.base_accelerator][INFO] - Training progress: step=33150/100000 (33.15%), epoch=0, lr=1e-05, speed=1.377 step/s, elapsed=06:41:09, eta=13:28:57 +[2026-04-15 12:16:36,343][trainer.accelerators.base_accelerator][INFO] - Training progress: step=33200/100000 (33.20%), epoch=0, lr=1e-05, speed=1.378 step/s, elapsed=06:41:27, eta=13:27:44 +[2026-04-15 12:16:54,205][trainer.accelerators.base_accelerator][INFO] - Training progress: step=33250/100000 (33.25%), epoch=0, lr=1e-05, speed=1.379 step/s, elapsed=06:41:44, eta=13:26:31 +[2026-04-15 12:17:12,095][trainer.accelerators.base_accelerator][INFO] - Training progress: step=33300/100000 (33.30%), epoch=0, lr=1e-05, speed=1.380 step/s, elapsed=06:42:02, eta=13:25:17 +[2026-04-15 12:17:30,006][trainer.accelerators.base_accelerator][INFO] - Training progress: step=33350/100000 (33.35%), epoch=0, lr=1e-05, speed=1.381 step/s, elapsed=06:42:20, eta=13:24:05 +[2026-04-15 12:17:47,855][trainer.accelerators.base_accelerator][INFO] - Training progress: step=33400/100000 (33.40%), epoch=0, lr=1e-05, speed=1.383 step/s, elapsed=06:42:38, eta=13:22:52 +[2026-04-15 12:18:05,633][trainer.accelerators.base_accelerator][INFO] - Training progress: step=33450/100000 (33.45%), epoch=0, lr=1e-05, speed=1.384 step/s, elapsed=06:42:56, eta=13:21:39 +[2026-04-15 12:18:23,539][trainer.accelerators.base_accelerator][INFO] - Training progress: step=33500/100000 (33.50%), epoch=0, lr=1e-05, speed=1.385 step/s, elapsed=06:43:14, eta=13:20:27 +[2026-04-15 12:18:41,684][trainer.accelerators.base_accelerator][INFO] - Training progress: step=33550/100000 (33.55%), epoch=0, lr=1e-05, speed=1.386 step/s, elapsed=06:43:32, eta=13:19:15 +[2026-04-15 12:18:59,573][trainer.accelerators.base_accelerator][INFO] - Training progress: step=33600/100000 (33.60%), epoch=0, lr=1e-05, speed=1.387 step/s, elapsed=06:43:50, eta=13:18:03 +[2026-04-15 12:19:17,477][trainer.accelerators.base_accelerator][INFO] - Training progress: step=33650/100000 (33.65%), epoch=0, lr=1e-05, speed=1.388 step/s, elapsed=06:44:08, eta=13:16:51 +[2026-04-15 12:19:35,316][trainer.accelerators.base_accelerator][INFO] - Training progress: step=33700/100000 (33.70%), epoch=0, lr=1e-05, speed=1.389 step/s, elapsed=06:44:25, eta=13:15:39 +[2026-04-15 12:19:53,240][trainer.accelerators.base_accelerator][INFO] - Training progress: step=33750/100000 (33.75%), epoch=0, lr=1e-05, speed=1.390 step/s, elapsed=06:44:43, eta=13:14:28 +[2026-04-15 12:20:11,149][trainer.accelerators.base_accelerator][INFO] - Training progress: step=33800/100000 (33.80%), epoch=0, lr=1e-05, speed=1.391 step/s, elapsed=06:45:01, eta=13:13:17 +[2026-04-15 12:20:29,012][trainer.accelerators.base_accelerator][INFO] - Training progress: step=33850/100000 (33.85%), epoch=0, lr=1e-05, speed=1.392 step/s, elapsed=06:45:19, eta=13:12:05 +[2026-04-15 12:20:46,832][trainer.accelerators.base_accelerator][INFO] - Training progress: step=33900/100000 (33.90%), epoch=0, lr=1e-05, speed=1.393 step/s, elapsed=06:45:37, eta=13:10:54 +[2026-04-15 12:21:04,707][trainer.accelerators.base_accelerator][INFO] - Training progress: step=33950/100000 (33.95%), epoch=0, lr=1e-05, speed=1.394 step/s, elapsed=06:45:55, eta=13:09:43 +[2026-04-15 12:21:22,558][trainer.accelerators.base_accelerator][INFO] - Training progress: step=34000/100000 (34.00%), epoch=0, lr=1e-05, speed=1.395 step/s, elapsed=06:46:13, eta=13:08:32 +[2026-04-15 12:21:22,583][__main__][INFO] - ========== EVAL START (periodic@gstep=34000) ========== +[2026-04-15 12:21:22,583][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-15 12:21:22,583][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 12:21:38,351][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.143119812011719, 'accuracy': 0.48705882352941177, 'num_samples': 425, 'test_unique_accuracy': 0.5092592592592593, 'test_unique_num_samples': 432} +[2026-04-15 12:21:38,352][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-15 12:21:38,352][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 12:21:53,408][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.143119812011719, 'accuracy': 0.48705882352941177, 'num_samples': 425, 'test_unique_accuracy': 0.5046296296296297, 'test_unique_num_samples': 432} +[2026-04-15 12:21:53,408][__main__][INFO] - ========== EVAL END (periodic@gstep=34000) ========== +[2026-04-15 12:21:53,408][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.143980026245117, 'accuracy': 0.48705882352941177, 'num_samples': 425, 'test_unique_accuracy': 0.5046296296296297, 'test_unique_num_samples': 432} +[2026-04-15 12:21:53,412][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.48705882352941177 is not better than 0.5788235294117647 of logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep32000, skipping checkpoint +[2026-04-15 12:22:11,333][trainer.accelerators.base_accelerator][INFO] - Training progress: step=34050/100000 (34.05%), epoch=0, lr=1e-05, speed=1.394 step/s, elapsed=06:47:02, eta=13:08:21 +[2026-04-15 12:22:29,255][trainer.accelerators.base_accelerator][INFO] - Training progress: step=34100/100000 (34.10%), epoch=0, lr=1e-05, speed=1.395 step/s, elapsed=06:47:19, eta=13:07:11 +[2026-04-15 12:22:47,156][trainer.accelerators.base_accelerator][INFO] - Training progress: step=34150/100000 (34.15%), epoch=0, lr=1e-05, speed=1.396 step/s, elapsed=06:47:37, eta=13:06:01 +[2026-04-15 12:23:05,052][trainer.accelerators.base_accelerator][INFO] - Training progress: step=34200/100000 (34.20%), epoch=0, lr=1e-05, speed=1.397 step/s, elapsed=06:47:55, eta=13:04:50 +[2026-04-15 12:23:22,923][trainer.accelerators.base_accelerator][INFO] - Training progress: step=34250/100000 (34.25%), epoch=0, lr=1e-05, speed=1.398 step/s, elapsed=06:48:13, eta=13:03:40 +[2026-04-15 12:23:40,853][trainer.accelerators.base_accelerator][INFO] - Training progress: step=34300/100000 (34.30%), epoch=0, lr=1e-05, speed=1.399 step/s, elapsed=06:48:31, eta=13:02:30 +[2026-04-15 12:23:58,791][trainer.accelerators.base_accelerator][INFO] - Training progress: step=34350/100000 (34.35%), epoch=0, lr=1e-05, speed=1.400 step/s, elapsed=06:48:49, eta=13:01:20 +[2026-04-15 12:24:16,663][trainer.accelerators.base_accelerator][INFO] - Training progress: step=34400/100000 (34.40%), epoch=0, lr=1e-05, speed=1.401 step/s, elapsed=06:49:07, eta=13:00:11 +[2026-04-15 12:24:34,615][trainer.accelerators.base_accelerator][INFO] - Training progress: step=34450/100000 (34.45%), epoch=0, lr=1e-05, speed=1.402 step/s, elapsed=06:49:25, eta=12:59:01 +[2026-04-15 12:24:52,501][trainer.accelerators.base_accelerator][INFO] - Training progress: step=34500/100000 (34.50%), epoch=0, lr=1e-05, speed=1.403 step/s, elapsed=06:49:43, eta=12:57:52 +[2026-04-15 12:25:10,358][trainer.accelerators.base_accelerator][INFO] - Training progress: step=34550/100000 (34.55%), epoch=0, lr=1e-05, speed=1.404 step/s, elapsed=06:50:01, eta=12:56:43 +[2026-04-15 12:25:28,420][trainer.accelerators.base_accelerator][INFO] - Training progress: step=34600/100000 (34.60%), epoch=0, lr=1e-05, speed=1.405 step/s, elapsed=06:50:19, eta=12:55:34 +[2026-04-15 12:25:46,290][trainer.accelerators.base_accelerator][INFO] - Training progress: step=34650/100000 (34.65%), epoch=0, lr=1e-05, speed=1.406 step/s, elapsed=06:50:36, eta=12:54:25 +[2026-04-15 12:26:04,118][trainer.accelerators.base_accelerator][INFO] - Training progress: step=34700/100000 (34.70%), epoch=0, lr=1e-05, speed=1.407 step/s, elapsed=06:50:54, eta=12:53:16 +[2026-04-15 12:26:21,951][trainer.accelerators.base_accelerator][INFO] - Training progress: step=34750/100000 (34.75%), epoch=0, lr=1e-05, speed=1.408 step/s, elapsed=06:51:12, eta=12:52:07 +[2026-04-15 12:26:39,771][trainer.accelerators.base_accelerator][INFO] - Training progress: step=34800/100000 (34.80%), epoch=0, lr=1e-05, speed=1.409 step/s, elapsed=06:51:30, eta=12:50:59 +[2026-04-15 12:26:57,973][trainer.accelerators.base_accelerator][INFO] - Training progress: step=34850/100000 (34.85%), epoch=0, lr=1e-05, speed=1.410 step/s, elapsed=06:51:48, eta=12:49:51 +[2026-04-15 12:27:15,895][trainer.accelerators.base_accelerator][INFO] - Training progress: step=34900/100000 (34.90%), epoch=0, lr=1e-05, speed=1.411 step/s, elapsed=06:52:06, eta=12:48:43 +[2026-04-15 12:27:33,665][trainer.accelerators.base_accelerator][INFO] - Training progress: step=34950/100000 (34.95%), epoch=0, lr=1e-05, speed=1.412 step/s, elapsed=06:52:24, eta=12:47:34 +[2026-04-15 12:27:51,545][trainer.accelerators.base_accelerator][INFO] - Training progress: step=35000/100000 (35.00%), epoch=0, lr=1e-05, speed=1.413 step/s, elapsed=06:52:42, eta=12:46:26 +[2026-04-15 12:27:51,570][__main__][INFO] - ========== EVAL START (periodic@gstep=35000) ========== +[2026-04-15 12:27:51,570][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-15 12:27:51,570][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 12:28:06,682][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.143980026245117, 'accuracy': 0.4988235294117647, 'num_samples': 425, 'test_unique_accuracy': 0.5046296296296297, 'test_unique_num_samples': 432} +[2026-04-15 12:28:06,682][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-15 12:28:06,682][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 12:28:21,810][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.143980026245117, 'accuracy': 0.4988235294117647, 'num_samples': 425, 'test_unique_accuracy': 0.4791666666666667, 'test_unique_num_samples': 432} +[2026-04-15 12:28:21,810][__main__][INFO] - ========== EVAL END (periodic@gstep=35000) ========== +[2026-04-15 12:28:21,810][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.140952110290527, 'accuracy': 0.4988235294117647, 'num_samples': 425, 'test_unique_accuracy': 0.4791666666666667, 'test_unique_num_samples': 432} +[2026-04-15 12:28:21,813][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.4988235294117647 is not better than 0.5788235294117647 of logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep32000, skipping checkpoint +[2026-04-15 12:28:39,662][trainer.accelerators.base_accelerator][INFO] - Training progress: step=35050/100000 (35.05%), epoch=0, lr=1e-05, speed=1.413 step/s, elapsed=06:53:30, eta=12:46:15 +[2026-04-15 12:28:57,576][trainer.accelerators.base_accelerator][INFO] - Training progress: step=35100/100000 (35.10%), epoch=0, lr=1e-05, speed=1.414 step/s, elapsed=06:53:48, eta=12:45:07 +[2026-04-15 12:29:15,428][trainer.accelerators.base_accelerator][INFO] - Training progress: step=35150/100000 (35.15%), epoch=0, lr=1e-05, speed=1.415 step/s, elapsed=06:54:06, eta=12:43:59 +[2026-04-15 12:29:33,316][trainer.accelerators.base_accelerator][INFO] - Training progress: step=35200/100000 (35.20%), epoch=0, lr=1e-05, speed=1.416 step/s, elapsed=06:54:23, eta=12:42:52 +[2026-04-15 12:29:51,175][trainer.accelerators.base_accelerator][INFO] - Training progress: step=35250/100000 (35.25%), epoch=0, lr=1e-05, speed=1.417 step/s, elapsed=06:54:41, eta=12:41:44 +[2026-04-15 12:30:09,126][trainer.accelerators.base_accelerator][INFO] - Training progress: step=35300/100000 (35.30%), epoch=0, lr=1e-05, speed=1.418 step/s, elapsed=06:54:59, eta=12:40:37 +[2026-04-15 12:30:27,011][trainer.accelerators.base_accelerator][INFO] - Training progress: step=35350/100000 (35.35%), epoch=0, lr=1e-05, speed=1.419 step/s, elapsed=06:55:17, eta=12:39:30 +[2026-04-15 12:30:44,922][trainer.accelerators.base_accelerator][INFO] - Training progress: step=35400/100000 (35.40%), epoch=0, lr=1e-05, speed=1.420 step/s, elapsed=06:55:35, eta=12:38:23 +[2026-04-15 12:31:02,775][trainer.accelerators.base_accelerator][INFO] - Training progress: step=35450/100000 (35.45%), epoch=0, lr=1e-05, speed=1.421 step/s, elapsed=06:55:53, eta=12:37:17 +[2026-04-15 12:31:20,657][trainer.accelerators.base_accelerator][INFO] - Training progress: step=35500/100000 (35.50%), epoch=0, lr=1e-05, speed=1.422 step/s, elapsed=06:56:11, eta=12:36:10 +[2026-04-15 12:31:38,411][trainer.accelerators.base_accelerator][INFO] - Training progress: step=35550/100000 (35.55%), epoch=0, lr=1e-05, speed=1.423 step/s, elapsed=06:56:29, eta=12:35:03 +[2026-04-15 12:31:56,236][trainer.accelerators.base_accelerator][INFO] - Training progress: step=35600/100000 (35.60%), epoch=0, lr=1e-05, speed=1.424 step/s, elapsed=06:56:46, eta=12:33:57 +[2026-04-15 12:32:14,293][trainer.accelerators.base_accelerator][INFO] - Training progress: step=35650/100000 (35.65%), epoch=0, lr=1e-05, speed=1.425 step/s, elapsed=06:57:04, eta=12:32:51 +[2026-04-15 12:32:32,048][trainer.accelerators.base_accelerator][INFO] - Training progress: step=35700/100000 (35.70%), epoch=0, lr=1e-05, speed=1.426 step/s, elapsed=06:57:22, eta=12:31:44 +[2026-04-15 12:32:49,936][trainer.accelerators.base_accelerator][INFO] - Training progress: step=35750/100000 (35.75%), epoch=0, lr=1e-05, speed=1.427 step/s, elapsed=06:57:40, eta=12:30:39 +[2026-04-15 12:33:07,764][trainer.accelerators.base_accelerator][INFO] - Training progress: step=35800/100000 (35.80%), epoch=0, lr=1e-05, speed=1.428 step/s, elapsed=06:57:58, eta=12:29:33 +[2026-04-15 12:33:25,675][trainer.accelerators.base_accelerator][INFO] - Training progress: step=35850/100000 (35.85%), epoch=0, lr=1e-05, speed=1.428 step/s, elapsed=06:58:16, eta=12:28:27 +[2026-04-15 12:33:43,552][trainer.accelerators.base_accelerator][INFO] - Training progress: step=35900/100000 (35.90%), epoch=0, lr=1e-05, speed=1.429 step/s, elapsed=06:58:34, eta=12:27:21 +[2026-04-15 12:34:01,400][trainer.accelerators.base_accelerator][INFO] - Training progress: step=35950/100000 (35.95%), epoch=0, lr=1e-05, speed=1.430 step/s, elapsed=06:58:52, eta=12:26:16 +[2026-04-15 12:34:19,325][trainer.accelerators.base_accelerator][INFO] - Training progress: step=36000/100000 (36.00%), epoch=0, lr=1e-05, speed=1.431 step/s, elapsed=06:59:10, eta=12:25:11 +[2026-04-15 12:34:19,350][__main__][INFO] - ========== EVAL START (periodic@gstep=36000) ========== +[2026-04-15 12:34:19,350][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-15 12:34:19,350][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 12:34:35,636][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.140952110290527, 'accuracy': 0.5011764705882353, 'num_samples': 425, 'test_unique_accuracy': 0.4791666666666667, 'test_unique_num_samples': 432} +[2026-04-15 12:34:35,636][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-15 12:34:35,636][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 12:34:50,711][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.140952110290527, 'accuracy': 0.5011764705882353, 'num_samples': 425, 'test_unique_accuracy': 0.49537037037037035, 'test_unique_num_samples': 432} +[2026-04-15 12:34:50,711][__main__][INFO] - ========== EVAL END (periodic@gstep=36000) ========== +[2026-04-15 12:34:50,712][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.140972137451172, 'accuracy': 0.5011764705882353, 'num_samples': 425, 'test_unique_accuracy': 0.49537037037037035, 'test_unique_num_samples': 432} +[2026-04-15 12:34:50,743][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.5011764705882353 is not better than 0.5788235294117647 of logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep32000, skipping checkpoint +[2026-04-15 12:35:08,695][trainer.accelerators.base_accelerator][INFO] - Training progress: step=36050/100000 (36.05%), epoch=0, lr=1e-05, speed=1.431 step/s, elapsed=06:59:59, eta=12:25:01 +[2026-04-15 12:35:26,596][trainer.accelerators.base_accelerator][INFO] - Training progress: step=36100/100000 (36.10%), epoch=0, lr=1e-05, speed=1.432 step/s, elapsed=07:00:17, eta=12:23:56 +[2026-04-15 12:35:44,471][trainer.accelerators.base_accelerator][INFO] - Training progress: step=36150/100000 (36.15%), epoch=0, lr=1e-05, speed=1.433 step/s, elapsed=07:00:35, eta=12:22:51 +[2026-04-15 12:36:02,251][trainer.accelerators.base_accelerator][INFO] - Training progress: step=36200/100000 (36.20%), epoch=0, lr=1e-05, speed=1.433 step/s, elapsed=07:00:52, eta=12:21:46 +[2026-04-15 12:36:20,083][trainer.accelerators.base_accelerator][INFO] - Training progress: step=36250/100000 (36.25%), epoch=0, lr=1e-05, speed=1.434 step/s, elapsed=07:01:10, eta=12:20:41 +[2026-04-15 12:36:37,999][trainer.accelerators.base_accelerator][INFO] - Training progress: step=36300/100000 (36.30%), epoch=0, lr=1e-05, speed=1.435 step/s, elapsed=07:01:28, eta=12:19:37 +[2026-04-15 12:36:55,877][trainer.accelerators.base_accelerator][INFO] - Training progress: step=36350/100000 (36.35%), epoch=0, lr=1e-05, speed=1.436 step/s, elapsed=07:01:46, eta=12:18:32 +[2026-04-15 12:37:13,830][trainer.accelerators.base_accelerator][INFO] - Training progress: step=36400/100000 (36.40%), epoch=0, lr=1e-05, speed=1.437 step/s, elapsed=07:02:04, eta=12:17:28 +[2026-04-15 12:37:31,709][trainer.accelerators.base_accelerator][INFO] - Training progress: step=36450/100000 (36.45%), epoch=0, lr=1e-05, speed=1.438 step/s, elapsed=07:02:22, eta=12:16:24 +[2026-04-15 12:37:49,617][trainer.accelerators.base_accelerator][INFO] - Training progress: step=36500/100000 (36.50%), epoch=0, lr=1e-05, speed=1.439 step/s, elapsed=07:02:40, eta=12:15:19 +[2026-04-15 12:38:07,532][trainer.accelerators.base_accelerator][INFO] - Training progress: step=36550/100000 (36.55%), epoch=0, lr=1e-05, speed=1.440 step/s, elapsed=07:02:58, eta=12:14:16 +[2026-04-15 12:38:25,420][trainer.accelerators.base_accelerator][INFO] - Training progress: step=36600/100000 (36.60%), epoch=0, lr=1e-05, speed=1.441 step/s, elapsed=07:03:16, eta=12:13:12 +[2026-04-15 12:38:43,292][trainer.accelerators.base_accelerator][INFO] - Training progress: step=36650/100000 (36.65%), epoch=0, lr=1e-05, speed=1.442 step/s, elapsed=07:03:33, eta=12:12:08 +[2026-04-15 12:39:01,495][trainer.accelerators.base_accelerator][INFO] - Training progress: step=36700/100000 (36.70%), epoch=0, lr=1e-05, speed=1.443 step/s, elapsed=07:03:52, eta=12:11:05 +[2026-04-15 12:39:19,365][trainer.accelerators.base_accelerator][INFO] - Training progress: step=36750/100000 (36.75%), epoch=0, lr=1e-05, speed=1.444 step/s, elapsed=07:04:10, eta=12:10:01 +[2026-04-15 12:39:37,148][trainer.accelerators.base_accelerator][INFO] - Training progress: step=36800/100000 (36.80%), epoch=0, lr=1e-05, speed=1.445 step/s, elapsed=07:04:27, eta=12:08:58 +[2026-04-15 12:39:55,041][trainer.accelerators.base_accelerator][INFO] - Training progress: step=36850/100000 (36.85%), epoch=0, lr=1e-05, speed=1.446 step/s, elapsed=07:04:45, eta=12:07:54 +[2026-04-15 12:40:13,027][trainer.accelerators.base_accelerator][INFO] - Training progress: step=36900/100000 (36.90%), epoch=0, lr=1e-05, speed=1.447 step/s, elapsed=07:05:03, eta=12:06:52 +[2026-04-15 12:40:31,030][trainer.accelerators.base_accelerator][INFO] - Training progress: step=36950/100000 (36.95%), epoch=0, lr=1e-05, speed=1.448 step/s, elapsed=07:05:21, eta=12:05:49 +[2026-04-15 12:40:48,933][trainer.accelerators.base_accelerator][INFO] - Training progress: step=37000/100000 (37.00%), epoch=0, lr=1e-05, speed=1.449 step/s, elapsed=07:05:39, eta=12:04:46 +[2026-04-15 12:40:48,958][__main__][INFO] - ========== EVAL START (periodic@gstep=37000) ========== +[2026-04-15 12:40:48,958][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-15 12:40:48,958][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 12:41:04,210][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.140972137451172, 'accuracy': 0.4988235294117647, 'num_samples': 425, 'test_unique_accuracy': 0.49537037037037035, 'test_unique_num_samples': 432} +[2026-04-15 12:41:04,210][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-15 12:41:04,210][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 12:41:19,297][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.140972137451172, 'accuracy': 0.4988235294117647, 'num_samples': 425, 'test_unique_accuracy': 0.4930555555555556, 'test_unique_num_samples': 432} +[2026-04-15 12:41:19,297][__main__][INFO] - ========== EVAL END (periodic@gstep=37000) ========== +[2026-04-15 12:41:19,298][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.137258529663086, 'accuracy': 0.4988235294117647, 'num_samples': 425, 'test_unique_accuracy': 0.4930555555555556, 'test_unique_num_samples': 432} +[2026-04-15 12:41:19,321][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.4988235294117647 is not better than 0.5788235294117647 of logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep32000, skipping checkpoint +[2026-04-15 12:41:37,245][trainer.accelerators.base_accelerator][INFO] - Training progress: step=37050/100000 (37.05%), epoch=0, lr=1e-05, speed=1.448 step/s, elapsed=07:06:27, eta=12:04:35 +[2026-04-15 12:41:55,120][trainer.accelerators.base_accelerator][INFO] - Training progress: step=37100/100000 (37.10%), epoch=0, lr=1e-05, speed=1.449 step/s, elapsed=07:06:45, eta=12:03:32 +[2026-04-15 12:42:12,838][trainer.accelerators.base_accelerator][INFO] - Training progress: step=37150/100000 (37.15%), epoch=0, lr=1e-05, speed=1.450 step/s, elapsed=07:07:03, eta=12:02:29 +[2026-04-15 12:42:30,769][trainer.accelerators.base_accelerator][INFO] - Training progress: step=37200/100000 (37.20%), epoch=0, lr=1e-05, speed=1.451 step/s, elapsed=07:07:21, eta=12:01:27 +[2026-04-15 12:42:48,617][trainer.accelerators.base_accelerator][INFO] - Training progress: step=37250/100000 (37.25%), epoch=0, lr=1e-05, speed=1.452 step/s, elapsed=07:07:39, eta=12:00:24 +[2026-04-15 12:43:06,530][trainer.accelerators.base_accelerator][INFO] - Training progress: step=37300/100000 (37.30%), epoch=0, lr=1e-05, speed=1.453 step/s, elapsed=07:07:57, eta=11:59:22 +[2026-04-15 12:43:24,420][trainer.accelerators.base_accelerator][INFO] - Training progress: step=37350/100000 (37.35%), epoch=0, lr=1e-05, speed=1.454 step/s, elapsed=07:08:15, eta=11:58:20 +[2026-04-15 12:43:42,321][trainer.accelerators.base_accelerator][INFO] - Training progress: step=37400/100000 (37.40%), epoch=0, lr=1e-05, speed=1.455 step/s, elapsed=07:08:33, eta=11:57:18 +[2026-04-15 12:44:00,240][trainer.accelerators.base_accelerator][INFO] - Training progress: step=37450/100000 (37.45%), epoch=0, lr=1e-05, speed=1.455 step/s, elapsed=07:08:50, eta=11:56:16 +[2026-04-15 12:44:18,405][trainer.accelerators.base_accelerator][INFO] - Training progress: step=37500/100000 (37.50%), epoch=0, lr=1e-05, speed=1.456 step/s, elapsed=07:09:09, eta=11:55:15 +[2026-04-15 12:44:36,171][trainer.accelerators.base_accelerator][INFO] - Training progress: step=37550/100000 (37.55%), epoch=0, lr=1e-05, speed=1.457 step/s, elapsed=07:09:26, eta=11:54:13 +[2026-04-15 12:44:54,011][trainer.accelerators.base_accelerator][INFO] - Training progress: step=37600/100000 (37.60%), epoch=0, lr=1e-05, speed=1.458 step/s, elapsed=07:09:44, eta=11:53:11 +[2026-04-15 12:45:11,907][trainer.accelerators.base_accelerator][INFO] - Training progress: step=37650/100000 (37.65%), epoch=0, lr=1e-05, speed=1.459 step/s, elapsed=07:10:02, eta=11:52:10 +[2026-04-15 12:45:29,722][trainer.accelerators.base_accelerator][INFO] - Training progress: step=37700/100000 (37.70%), epoch=0, lr=1e-05, speed=1.460 step/s, elapsed=07:10:20, eta=11:51:08 +[2026-04-15 12:45:47,600][trainer.accelerators.base_accelerator][INFO] - Training progress: step=37750/100000 (37.75%), epoch=0, lr=1e-05, speed=1.461 step/s, elapsed=07:10:38, eta=11:50:07 +[2026-04-15 12:46:05,723][trainer.accelerators.base_accelerator][INFO] - Training progress: step=37800/100000 (37.80%), epoch=0, lr=1e-05, speed=1.462 step/s, elapsed=07:10:56, eta=11:49:06 +[2026-04-15 12:46:23,550][trainer.accelerators.base_accelerator][INFO] - Training progress: step=37850/100000 (37.85%), epoch=0, lr=1e-05, speed=1.463 step/s, elapsed=07:11:14, eta=11:48:05 +[2026-04-15 12:46:41,450][trainer.accelerators.base_accelerator][INFO] - Training progress: step=37900/100000 (37.90%), epoch=0, lr=1e-05, speed=1.464 step/s, elapsed=07:11:32, eta=11:47:04 +[2026-04-15 12:46:59,327][trainer.accelerators.base_accelerator][INFO] - Training progress: step=37950/100000 (37.95%), epoch=0, lr=1e-05, speed=1.465 step/s, elapsed=07:11:50, eta=11:46:04 +[2026-04-15 12:47:17,201][trainer.accelerators.base_accelerator][INFO] - Training progress: step=38000/100000 (38.00%), epoch=0, lr=1e-05, speed=1.466 step/s, elapsed=07:12:07, eta=11:45:03 +[2026-04-15 12:47:17,226][__main__][INFO] - ========== EVAL START (periodic@gstep=38000) ========== +[2026-04-15 12:47:17,226][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-15 12:47:17,227][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 12:47:32,825][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.137258529663086, 'accuracy': 0.49176470588235294, 'num_samples': 425, 'test_unique_accuracy': 0.4930555555555556, 'test_unique_num_samples': 432} +[2026-04-15 12:47:32,825][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-15 12:47:32,825][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 12:47:47,923][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.137258529663086, 'accuracy': 0.49176470588235294, 'num_samples': 425, 'test_unique_accuracy': 0.5324074074074074, 'test_unique_num_samples': 432} +[2026-04-15 12:47:47,923][__main__][INFO] - ========== EVAL END (periodic@gstep=38000) ========== +[2026-04-15 12:47:47,923][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.129030227661133, 'accuracy': 0.49176470588235294, 'num_samples': 425, 'test_unique_accuracy': 0.5324074074074074, 'test_unique_num_samples': 432} +[2026-04-15 12:47:47,927][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.49176470588235294 is not better than 0.5788235294117647 of logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep32000, skipping checkpoint +[2026-04-15 12:48:05,717][trainer.accelerators.base_accelerator][INFO] - Training progress: step=38050/100000 (38.05%), epoch=0, lr=1e-05, speed=1.465 step/s, elapsed=07:12:56, eta=11:44:52 +[2026-04-15 12:48:23,365][trainer.accelerators.base_accelerator][INFO] - Training progress: step=38100/100000 (38.10%), epoch=0, lr=1e-05, speed=1.466 step/s, elapsed=07:13:14, eta=11:43:51 +[2026-04-15 12:48:41,001][trainer.accelerators.base_accelerator][INFO] - Training progress: step=38150/100000 (38.15%), epoch=0, lr=1e-05, speed=1.467 step/s, elapsed=07:13:31, eta=11:42:50 +[2026-04-15 12:48:58,861][trainer.accelerators.base_accelerator][INFO] - Training progress: step=38200/100000 (38.20%), epoch=0, lr=1e-05, speed=1.468 step/s, elapsed=07:13:49, eta=11:41:50 +[2026-04-15 12:49:16,759][trainer.accelerators.base_accelerator][INFO] - Training progress: step=38250/100000 (38.25%), epoch=0, lr=1e-05, speed=1.468 step/s, elapsed=07:14:07, eta=11:40:50 +[2026-04-15 12:49:34,634][trainer.accelerators.base_accelerator][INFO] - Training progress: step=38300/100000 (38.30%), epoch=0, lr=1e-05, speed=1.469 step/s, elapsed=07:14:25, eta=11:39:50 +[2026-04-15 12:49:52,527][trainer.accelerators.base_accelerator][INFO] - Training progress: step=38350/100000 (38.35%), epoch=0, lr=1e-05, speed=1.470 step/s, elapsed=07:14:43, eta=11:38:50 +[2026-04-15 12:50:10,398][trainer.accelerators.base_accelerator][INFO] - Training progress: step=38400/100000 (38.40%), epoch=0, lr=1e-05, speed=1.471 step/s, elapsed=07:15:01, eta=11:37:50 +[2026-04-15 12:50:28,249][trainer.accelerators.base_accelerator][INFO] - Training progress: step=38450/100000 (38.45%), epoch=0, lr=1e-05, speed=1.472 step/s, elapsed=07:15:18, eta=11:36:50 +[2026-04-15 12:50:46,090][trainer.accelerators.base_accelerator][INFO] - Training progress: step=38500/100000 (38.50%), epoch=0, lr=1e-05, speed=1.473 step/s, elapsed=07:15:36, eta=11:35:50 +[2026-04-15 12:51:03,969][trainer.accelerators.base_accelerator][INFO] - Training progress: step=38550/100000 (38.55%), epoch=0, lr=1e-05, speed=1.474 step/s, elapsed=07:15:54, eta=11:34:51 +[2026-04-15 12:51:21,842][trainer.accelerators.base_accelerator][INFO] - Training progress: step=38600/100000 (38.60%), epoch=0, lr=1e-05, speed=1.475 step/s, elapsed=07:16:12, eta=11:33:51 +[2026-04-15 12:51:39,704][trainer.accelerators.base_accelerator][INFO] - Training progress: step=38650/100000 (38.65%), epoch=0, lr=1e-05, speed=1.476 step/s, elapsed=07:16:30, eta=11:32:52 +[2026-04-15 12:51:57,579][trainer.accelerators.base_accelerator][INFO] - Training progress: step=38700/100000 (38.70%), epoch=0, lr=1e-05, speed=1.477 step/s, elapsed=07:16:48, eta=11:31:53 +[2026-04-15 12:52:15,496][trainer.accelerators.base_accelerator][INFO] - Training progress: step=38750/100000 (38.75%), epoch=0, lr=1e-05, speed=1.478 step/s, elapsed=07:17:06, eta=11:30:54 +[2026-04-15 12:52:33,372][trainer.accelerators.base_accelerator][INFO] - Training progress: step=38800/100000 (38.80%), epoch=0, lr=1e-05, speed=1.478 step/s, elapsed=07:17:24, eta=11:29:55 +[2026-04-15 12:52:51,252][trainer.accelerators.base_accelerator][INFO] - Training progress: step=38850/100000 (38.85%), epoch=0, lr=1e-05, speed=1.479 step/s, elapsed=07:17:41, eta=11:28:56 +[2026-04-15 12:53:09,523][trainer.accelerators.base_accelerator][INFO] - Training progress: step=38900/100000 (38.90%), epoch=0, lr=1e-05, speed=1.480 step/s, elapsed=07:18:00, eta=11:27:58 +[2026-04-15 12:53:27,304][trainer.accelerators.base_accelerator][INFO] - Training progress: step=38950/100000 (38.95%), epoch=0, lr=1e-05, speed=1.481 step/s, elapsed=07:18:17, eta=11:26:59 +[2026-04-15 12:53:45,183][trainer.accelerators.base_accelerator][INFO] - Training progress: step=39000/100000 (39.00%), epoch=0, lr=1e-05, speed=1.482 step/s, elapsed=07:18:35, eta=11:26:00 +[2026-04-15 12:53:45,207][__main__][INFO] - ========== EVAL START (periodic@gstep=39000) ========== +[2026-04-15 12:53:45,207][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-15 12:53:45,207][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 12:54:00,245][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.129030227661133, 'accuracy': 0.49176470588235294, 'num_samples': 425, 'test_unique_accuracy': 0.5324074074074074, 'test_unique_num_samples': 432} +[2026-04-15 12:54:00,245][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-15 12:54:00,245][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 12:54:15,282][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.129030227661133, 'accuracy': 0.49176470588235294, 'num_samples': 425, 'test_unique_accuracy': 0.5138888888888888, 'test_unique_num_samples': 432} +[2026-04-15 12:54:15,282][__main__][INFO] - ========== EVAL END (periodic@gstep=39000) ========== +[2026-04-15 12:54:15,282][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.120970726013184, 'accuracy': 0.49176470588235294, 'num_samples': 425, 'test_unique_accuracy': 0.5138888888888888, 'test_unique_num_samples': 432} +[2026-04-15 12:54:15,285][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.49176470588235294 is not better than 0.5788235294117647 of logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep32000, skipping checkpoint +[2026-04-15 12:54:33,157][trainer.accelerators.base_accelerator][INFO] - Training progress: step=39050/100000 (39.05%), epoch=0, lr=1e-05, speed=1.481 step/s, elapsed=07:19:23, eta=11:25:49 +[2026-04-15 12:54:51,042][trainer.accelerators.base_accelerator][INFO] - Training progress: step=39100/100000 (39.10%), epoch=0, lr=1e-05, speed=1.482 step/s, elapsed=07:19:41, eta=11:24:50 +[2026-04-15 12:55:08,890][trainer.accelerators.base_accelerator][INFO] - Training progress: step=39150/100000 (39.15%), epoch=0, lr=1e-05, speed=1.483 step/s, elapsed=07:19:59, eta=11:23:52 +[2026-04-15 12:55:26,662][trainer.accelerators.base_accelerator][INFO] - Training progress: step=39200/100000 (39.20%), epoch=0, lr=1e-05, speed=1.484 step/s, elapsed=07:20:17, eta=11:22:53 +[2026-04-15 12:55:44,469][trainer.accelerators.base_accelerator][INFO] - Training progress: step=39250/100000 (39.25%), epoch=0, lr=1e-05, speed=1.485 step/s, elapsed=07:20:35, eta=11:21:55 +[2026-04-15 12:56:02,327][trainer.accelerators.base_accelerator][INFO] - Training progress: step=39300/100000 (39.30%), epoch=0, lr=1e-05, speed=1.486 step/s, elapsed=07:20:53, eta=11:20:57 +[2026-04-15 12:56:20,144][trainer.accelerators.base_accelerator][INFO] - Training progress: step=39350/100000 (39.35%), epoch=0, lr=1e-05, speed=1.487 step/s, elapsed=07:21:10, eta=11:19:59 +[2026-04-15 12:56:38,005][trainer.accelerators.base_accelerator][INFO] - Training progress: step=39400/100000 (39.40%), epoch=0, lr=1e-05, speed=1.487 step/s, elapsed=07:21:28, eta=11:19:01 +[2026-04-15 12:56:55,799][trainer.accelerators.base_accelerator][INFO] - Training progress: step=39450/100000 (39.45%), epoch=0, lr=1e-05, speed=1.488 step/s, elapsed=07:21:46, eta=11:18:03 +[2026-04-15 12:57:13,634][trainer.accelerators.base_accelerator][INFO] - Training progress: step=39500/100000 (39.50%), epoch=0, lr=1e-05, speed=1.489 step/s, elapsed=07:22:04, eta=11:17:05 +[2026-04-15 12:57:31,474][trainer.accelerators.base_accelerator][INFO] - Training progress: step=39550/100000 (39.55%), epoch=0, lr=1e-05, speed=1.490 step/s, elapsed=07:22:22, eta=11:16:08 +[2026-04-15 12:57:49,362][trainer.accelerators.base_accelerator][INFO] - Training progress: step=39600/100000 (39.60%), epoch=0, lr=1e-05, speed=1.491 step/s, elapsed=07:22:40, eta=11:15:10 +[2026-04-15 12:58:07,173][trainer.accelerators.base_accelerator][INFO] - Training progress: step=39650/100000 (39.65%), epoch=0, lr=1e-05, speed=1.492 step/s, elapsed=07:22:57, eta=11:14:13 +[2026-04-15 12:58:25,005][trainer.accelerators.base_accelerator][INFO] - Training progress: step=39700/100000 (39.70%), epoch=0, lr=1e-05, speed=1.493 step/s, elapsed=07:23:15, eta=11:13:15 +[2026-04-15 12:58:42,843][trainer.accelerators.base_accelerator][INFO] - Training progress: step=39750/100000 (39.75%), epoch=0, lr=1e-05, speed=1.494 step/s, elapsed=07:23:33, eta=11:12:18 +[2026-04-15 12:59:00,738][trainer.accelerators.base_accelerator][INFO] - Training progress: step=39800/100000 (39.80%), epoch=0, lr=1e-05, speed=1.494 step/s, elapsed=07:23:51, eta=11:11:21 +[2026-04-15 12:59:18,584][trainer.accelerators.base_accelerator][INFO] - Training progress: step=39850/100000 (39.85%), epoch=0, lr=1e-05, speed=1.495 step/s, elapsed=07:24:09, eta=11:10:24 +[2026-04-15 12:59:36,445][trainer.accelerators.base_accelerator][INFO] - Training progress: step=39900/100000 (39.90%), epoch=0, lr=1e-05, speed=1.496 step/s, elapsed=07:24:27, eta=11:09:27 +[2026-04-15 12:59:54,595][trainer.accelerators.base_accelerator][INFO] - Training progress: step=39950/100000 (39.95%), epoch=0, lr=1e-05, speed=1.497 step/s, elapsed=07:24:45, eta=11:08:31 +[2026-04-15 13:00:12,447][trainer.accelerators.base_accelerator][INFO] - Training progress: step=40000/100000 (40.00%), epoch=0, lr=1e-05, speed=1.498 step/s, elapsed=07:25:03, eta=11:07:34 +[2026-04-15 13:00:12,472][__main__][INFO] - ========== EVAL START (periodic@gstep=40000) ========== +[2026-04-15 13:00:12,472][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-15 13:00:12,473][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 13:00:31,531][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.120970726013184, 'accuracy': 0.5223529411764706, 'num_samples': 425, 'test_unique_accuracy': 0.5138888888888888, 'test_unique_num_samples': 432} +[2026-04-15 13:00:31,532][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-15 13:00:31,532][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 13:00:46,583][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.120970726013184, 'accuracy': 0.5223529411764706, 'num_samples': 425, 'test_unique_accuracy': 0.4583333333333333, 'test_unique_num_samples': 432} +[2026-04-15 13:00:46,583][__main__][INFO] - ========== EVAL END (periodic@gstep=40000) ========== +[2026-04-15 13:00:46,583][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.123967170715332, 'accuracy': 0.5223529411764706, 'num_samples': 425, 'test_unique_accuracy': 0.4583333333333333, 'test_unique_num_samples': 432} +[2026-04-15 13:00:46,627][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.5223529411764706 is not better than 0.5788235294117647 of logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep32000, skipping checkpoint +[2026-04-15 13:01:04,597][trainer.accelerators.base_accelerator][INFO] - Training progress: step=40050/100000 (40.05%), epoch=0, lr=1e-05, speed=1.497 step/s, elapsed=07:25:55, eta=11:07:29 +[2026-04-15 13:01:22,435][trainer.accelerators.base_accelerator][INFO] - Training progress: step=40100/100000 (40.10%), epoch=0, lr=1e-05, speed=1.498 step/s, elapsed=07:26:13, eta=11:06:32 +[2026-04-15 13:01:40,249][trainer.accelerators.base_accelerator][INFO] - Training progress: step=40150/100000 (40.15%), epoch=0, lr=1e-05, speed=1.499 step/s, elapsed=07:26:30, eta=11:05:36 +[2026-04-15 13:01:58,158][trainer.accelerators.base_accelerator][INFO] - Training progress: step=40200/100000 (40.20%), epoch=0, lr=1e-05, speed=1.500 step/s, elapsed=07:26:48, eta=11:04:39 +[2026-04-15 13:02:15,962][trainer.accelerators.base_accelerator][INFO] - Training progress: step=40250/100000 (40.25%), epoch=0, lr=1e-05, speed=1.500 step/s, elapsed=07:27:06, eta=11:03:43 +[2026-04-15 13:02:33,776][trainer.accelerators.base_accelerator][INFO] - Training progress: step=40300/100000 (40.30%), epoch=0, lr=1e-05, speed=1.501 step/s, elapsed=07:27:24, eta=11:02:47 +[2026-04-15 13:02:51,592][trainer.accelerators.base_accelerator][INFO] - Training progress: step=40350/100000 (40.35%), epoch=0, lr=1e-05, speed=1.502 step/s, elapsed=07:27:42, eta=11:01:50 +[2026-04-15 13:03:09,486][trainer.accelerators.base_accelerator][INFO] - Training progress: step=40400/100000 (40.40%), epoch=0, lr=1e-05, speed=1.503 step/s, elapsed=07:28:00, eta=11:00:54 +[2026-04-15 13:03:27,358][trainer.accelerators.base_accelerator][INFO] - Training progress: step=40450/100000 (40.45%), epoch=0, lr=1e-05, speed=1.504 step/s, elapsed=07:28:18, eta=10:59:58 +[2026-04-15 13:03:45,070][trainer.accelerators.base_accelerator][INFO] - Training progress: step=40500/100000 (40.50%), epoch=0, lr=1e-05, speed=1.505 step/s, elapsed=07:28:35, eta=10:59:02 +[2026-04-15 13:04:02,846][trainer.accelerators.base_accelerator][INFO] - Training progress: step=40550/100000 (40.55%), epoch=0, lr=1e-05, speed=1.506 step/s, elapsed=07:28:53, eta=10:58:07 +[2026-04-15 13:04:20,662][trainer.accelerators.base_accelerator][INFO] - Training progress: step=40600/100000 (40.60%), epoch=0, lr=1e-05, speed=1.506 step/s, elapsed=07:29:11, eta=10:57:11 +[2026-04-15 13:04:38,448][trainer.accelerators.base_accelerator][INFO] - Training progress: step=40650/100000 (40.65%), epoch=0, lr=1e-05, speed=1.507 step/s, elapsed=07:29:29, eta=10:56:15 +[2026-04-15 13:04:56,290][trainer.accelerators.base_accelerator][INFO] - Training progress: step=40700/100000 (40.70%), epoch=0, lr=1e-05, speed=1.508 step/s, elapsed=07:29:46, eta=10:55:20 +[2026-04-15 13:05:14,102][trainer.accelerators.base_accelerator][INFO] - Training progress: step=40750/100000 (40.75%), epoch=0, lr=1e-05, speed=1.509 step/s, elapsed=07:30:04, eta=10:54:24 +[2026-04-15 13:05:31,985][trainer.accelerators.base_accelerator][INFO] - Training progress: step=40800/100000 (40.80%), epoch=0, lr=1e-05, speed=1.510 step/s, elapsed=07:30:22, eta=10:53:29 +[2026-04-15 13:05:49,867][trainer.accelerators.base_accelerator][INFO] - Training progress: step=40850/100000 (40.85%), epoch=0, lr=1e-05, speed=1.511 step/s, elapsed=07:30:40, eta=10:52:34 +[2026-04-15 13:06:07,721][trainer.accelerators.base_accelerator][INFO] - Training progress: step=40900/100000 (40.90%), epoch=0, lr=1e-05, speed=1.512 step/s, elapsed=07:30:58, eta=10:51:39 +[2026-04-15 13:06:25,576][trainer.accelerators.base_accelerator][INFO] - Training progress: step=40950/100000 (40.95%), epoch=0, lr=1e-05, speed=1.512 step/s, elapsed=07:31:16, eta=10:50:44 +[2026-04-15 13:06:43,399][trainer.accelerators.base_accelerator][INFO] - Training progress: step=41000/100000 (41.00%), epoch=0, lr=1e-05, speed=1.513 step/s, elapsed=07:31:34, eta=10:49:49 +[2026-04-15 13:06:43,423][__main__][INFO] - ========== EVAL START (periodic@gstep=41000) ========== +[2026-04-15 13:06:43,423][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-15 13:06:43,424][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 13:06:59,765][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.123967170715332, 'accuracy': 0.4964705882352941, 'num_samples': 425, 'test_unique_accuracy': 0.4583333333333333, 'test_unique_num_samples': 432} +[2026-04-15 13:06:59,766][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-15 13:06:59,766][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 13:07:14,852][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.123967170715332, 'accuracy': 0.4964705882352941, 'num_samples': 425, 'test_unique_accuracy': 0.5, 'test_unique_num_samples': 432} +[2026-04-15 13:07:14,852][__main__][INFO] - ========== EVAL END (periodic@gstep=41000) ========== +[2026-04-15 13:07:14,852][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.121549606323242, 'accuracy': 0.4964705882352941, 'num_samples': 425, 'test_unique_accuracy': 0.5, 'test_unique_num_samples': 432} +[2026-04-15 13:07:14,870][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.4964705882352941 is not better than 0.5788235294117647 of logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep32000, skipping checkpoint +[2026-04-15 13:07:32,724][trainer.accelerators.base_accelerator][INFO] - Training progress: step=41050/100000 (41.05%), epoch=0, lr=1e-05, speed=1.512 step/s, elapsed=07:32:23, eta=10:49:39 +[2026-04-15 13:07:50,481][trainer.accelerators.base_accelerator][INFO] - Training progress: step=41100/100000 (41.10%), epoch=0, lr=1e-05, speed=1.513 step/s, elapsed=07:32:41, eta=10:48:44 +[2026-04-15 13:08:08,360][trainer.accelerators.base_accelerator][INFO] - Training progress: step=41150/100000 (41.15%), epoch=0, lr=1e-05, speed=1.514 step/s, elapsed=07:32:59, eta=10:47:49 +[2026-04-15 13:08:26,139][trainer.accelerators.base_accelerator][INFO] - Training progress: step=41200/100000 (41.20%), epoch=0, lr=1e-05, speed=1.515 step/s, elapsed=07:33:16, eta=10:46:54 +[2026-04-15 13:08:44,001][trainer.accelerators.base_accelerator][INFO] - Training progress: step=41250/100000 (41.25%), epoch=0, lr=1e-05, speed=1.516 step/s, elapsed=07:33:34, eta=10:46:00 +[2026-04-15 13:09:01,873][trainer.accelerators.base_accelerator][INFO] - Training progress: step=41300/100000 (41.30%), epoch=0, lr=1e-05, speed=1.517 step/s, elapsed=07:33:52, eta=10:45:05 +[2026-04-15 13:09:19,711][trainer.accelerators.base_accelerator][INFO] - Training progress: step=41350/100000 (41.35%), epoch=0, lr=1e-05, speed=1.517 step/s, elapsed=07:34:10, eta=10:44:11 +[2026-04-15 13:09:37,563][trainer.accelerators.base_accelerator][INFO] - Training progress: step=41400/100000 (41.40%), epoch=0, lr=1e-05, speed=1.518 step/s, elapsed=07:34:28, eta=10:43:17 +[2026-04-15 13:09:55,391][trainer.accelerators.base_accelerator][INFO] - Training progress: step=41450/100000 (41.45%), epoch=0, lr=1e-05, speed=1.519 step/s, elapsed=07:34:46, eta=10:42:22 +[2026-04-15 13:10:13,283][trainer.accelerators.base_accelerator][INFO] - Training progress: step=41500/100000 (41.50%), epoch=0, lr=1e-05, speed=1.520 step/s, elapsed=07:35:03, eta=10:41:28 +[2026-04-15 13:10:31,097][trainer.accelerators.base_accelerator][INFO] - Training progress: step=41550/100000 (41.55%), epoch=0, lr=1e-05, speed=1.521 step/s, elapsed=07:35:21, eta=10:40:34 +[2026-04-15 13:10:48,965][trainer.accelerators.base_accelerator][INFO] - Training progress: step=41600/100000 (41.60%), epoch=0, lr=1e-05, speed=1.522 step/s, elapsed=07:35:39, eta=10:39:40 +[2026-04-15 13:11:06,807][trainer.accelerators.base_accelerator][INFO] - Training progress: step=41650/100000 (41.65%), epoch=0, lr=1e-05, speed=1.522 step/s, elapsed=07:35:57, eta=10:38:46 +[2026-04-15 13:11:24,686][trainer.accelerators.base_accelerator][INFO] - Training progress: step=41700/100000 (41.70%), epoch=0, lr=1e-05, speed=1.523 step/s, elapsed=07:36:15, eta=10:37:52 +[2026-04-15 13:11:42,557][trainer.accelerators.base_accelerator][INFO] - Training progress: step=41750/100000 (41.75%), epoch=0, lr=1e-05, speed=1.524 step/s, elapsed=07:36:33, eta=10:36:59 +[2026-04-15 13:12:00,427][trainer.accelerators.base_accelerator][INFO] - Training progress: step=41800/100000 (41.80%), epoch=0, lr=1e-05, speed=1.525 step/s, elapsed=07:36:51, eta=10:36:05 +[2026-04-15 13:12:18,333][trainer.accelerators.base_accelerator][INFO] - Training progress: step=41850/100000 (41.85%), epoch=0, lr=1e-05, speed=1.526 step/s, elapsed=07:37:09, eta=10:35:12 +[2026-04-15 13:12:36,218][trainer.accelerators.base_accelerator][INFO] - Training progress: step=41900/100000 (41.90%), epoch=0, lr=1e-05, speed=1.527 step/s, elapsed=07:37:26, eta=10:34:18 +[2026-04-15 13:12:54,071][trainer.accelerators.base_accelerator][INFO] - Training progress: step=41950/100000 (41.95%), epoch=0, lr=1e-05, speed=1.527 step/s, elapsed=07:37:44, eta=10:33:25 +[2026-04-15 13:13:11,868][trainer.accelerators.base_accelerator][INFO] - Training progress: step=42000/100000 (42.00%), epoch=0, lr=1e-05, speed=1.528 step/s, elapsed=07:38:02, eta=10:32:32 +[2026-04-15 13:13:11,892][__main__][INFO] - ========== EVAL START (periodic@gstep=42000) ========== +[2026-04-15 13:13:11,892][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-15 13:13:11,893][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 13:13:28,724][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.121549606323242, 'accuracy': 0.49411764705882355, 'num_samples': 425, 'test_unique_accuracy': 0.5, 'test_unique_num_samples': 432} +[2026-04-15 13:13:28,724][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-15 13:13:28,724][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 13:13:44,205][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.121549606323242, 'accuracy': 0.49411764705882355, 'num_samples': 425, 'test_unique_accuracy': 0.5254629629629629, 'test_unique_num_samples': 432} +[2026-04-15 13:13:44,206][__main__][INFO] - ========== EVAL END (periodic@gstep=42000) ========== +[2026-04-15 13:13:44,206][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.12188720703125, 'accuracy': 0.49411764705882355, 'num_samples': 425, 'test_unique_accuracy': 0.5254629629629629, 'test_unique_num_samples': 432} +[2026-04-15 13:13:44,209][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.49411764705882355 is not better than 0.5788235294117647 of logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep32000, skipping checkpoint +[2026-04-15 13:14:02,066][trainer.accelerators.base_accelerator][INFO] - Training progress: step=42050/100000 (42.05%), epoch=0, lr=1e-05, speed=1.527 step/s, elapsed=07:38:52, eta=10:32:23 +[2026-04-15 13:14:19,905][trainer.accelerators.base_accelerator][INFO] - Training progress: step=42100/100000 (42.10%), epoch=0, lr=1e-05, speed=1.528 step/s, elapsed=07:39:10, eta=10:31:30 +[2026-04-15 13:14:37,757][trainer.accelerators.base_accelerator][INFO] - Training progress: step=42150/100000 (42.15%), epoch=0, lr=1e-05, speed=1.529 step/s, elapsed=07:39:28, eta=10:30:37 +[2026-04-15 13:14:55,611][trainer.accelerators.base_accelerator][INFO] - Training progress: step=42200/100000 (42.20%), epoch=0, lr=1e-05, speed=1.530 step/s, elapsed=07:39:46, eta=10:29:44 +[2026-04-15 13:15:13,493][trainer.accelerators.base_accelerator][INFO] - Training progress: step=42250/100000 (42.25%), epoch=0, lr=1e-05, speed=1.531 step/s, elapsed=07:40:04, eta=10:28:51 +[2026-04-15 13:15:31,348][trainer.accelerators.base_accelerator][INFO] - Training progress: step=42300/100000 (42.30%), epoch=0, lr=1e-05, speed=1.531 step/s, elapsed=07:40:22, eta=10:27:58 +[2026-04-15 13:15:49,234][trainer.accelerators.base_accelerator][INFO] - Training progress: step=42350/100000 (42.35%), epoch=0, lr=1e-05, speed=1.532 step/s, elapsed=07:40:39, eta=10:27:05 +[2026-04-15 13:16:07,120][trainer.accelerators.base_accelerator][INFO] - Training progress: step=42400/100000 (42.40%), epoch=0, lr=1e-05, speed=1.533 step/s, elapsed=07:40:57, eta=10:26:12 +[2026-04-15 13:16:24,903][trainer.accelerators.base_accelerator][INFO] - Training progress: step=42450/100000 (42.45%), epoch=0, lr=1e-05, speed=1.534 step/s, elapsed=07:41:15, eta=10:25:20 +[2026-04-15 13:16:42,835][trainer.accelerators.base_accelerator][INFO] - Training progress: step=42500/100000 (42.50%), epoch=0, lr=1e-05, speed=1.535 step/s, elapsed=07:41:33, eta=10:24:27 +[2026-04-15 13:17:00,721][trainer.accelerators.base_accelerator][INFO] - Training progress: step=42550/100000 (42.55%), epoch=0, lr=1e-05, speed=1.535 step/s, elapsed=07:41:51, eta=10:23:35 +[2026-04-15 13:17:18,637][trainer.accelerators.base_accelerator][INFO] - Training progress: step=42600/100000 (42.60%), epoch=0, lr=1e-05, speed=1.536 step/s, elapsed=07:42:09, eta=10:22:42 +[2026-04-15 13:17:36,532][trainer.accelerators.base_accelerator][INFO] - Training progress: step=42650/100000 (42.65%), epoch=0, lr=1e-05, speed=1.537 step/s, elapsed=07:42:27, eta=10:21:50 +[2026-04-15 13:17:54,431][trainer.accelerators.base_accelerator][INFO] - Training progress: step=42700/100000 (42.70%), epoch=0, lr=1e-05, speed=1.538 step/s, elapsed=07:42:45, eta=10:20:58 +[2026-04-15 13:18:12,386][trainer.accelerators.base_accelerator][INFO] - Training progress: step=42750/100000 (42.75%), epoch=0, lr=1e-05, speed=1.539 step/s, elapsed=07:43:03, eta=10:20:06 +[2026-04-15 13:18:30,290][trainer.accelerators.base_accelerator][INFO] - Training progress: step=42800/100000 (42.80%), epoch=0, lr=1e-05, speed=1.540 step/s, elapsed=07:43:20, eta=10:19:14 +[2026-04-15 13:18:48,130][trainer.accelerators.base_accelerator][INFO] - Training progress: step=42850/100000 (42.85%), epoch=0, lr=1e-05, speed=1.540 step/s, elapsed=07:43:38, eta=10:18:22 +[2026-04-15 13:19:06,020][trainer.accelerators.base_accelerator][INFO] - Training progress: step=42900/100000 (42.90%), epoch=0, lr=1e-05, speed=1.541 step/s, elapsed=07:43:56, eta=10:17:30 +[2026-04-15 13:19:23,830][trainer.accelerators.base_accelerator][INFO] - Training progress: step=42950/100000 (42.95%), epoch=0, lr=1e-05, speed=1.542 step/s, elapsed=07:44:14, eta=10:16:38 +[2026-04-15 13:19:41,687][trainer.accelerators.base_accelerator][INFO] - Training progress: step=43000/100000 (43.00%), epoch=0, lr=1e-05, speed=1.543 step/s, elapsed=07:44:32, eta=10:15:47 +[2026-04-15 13:19:41,711][__main__][INFO] - ========== EVAL START (periodic@gstep=43000) ========== +[2026-04-15 13:19:41,712][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-15 13:19:41,712][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 13:19:56,782][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.12188720703125, 'accuracy': 0.4964705882352941, 'num_samples': 425, 'test_unique_accuracy': 0.5254629629629629, 'test_unique_num_samples': 432} +[2026-04-15 13:19:56,782][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-15 13:19:56,783][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 13:20:11,938][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.12188720703125, 'accuracy': 0.4964705882352941, 'num_samples': 425, 'test_unique_accuracy': 0.5254629629629629, 'test_unique_num_samples': 432} +[2026-04-15 13:20:11,938][__main__][INFO] - ========== EVAL END (periodic@gstep=43000) ========== +[2026-04-15 13:20:11,939][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.124879837036133, 'accuracy': 0.4964705882352941, 'num_samples': 425, 'test_unique_accuracy': 0.5254629629629629, 'test_unique_num_samples': 432} +[2026-04-15 13:20:11,942][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.4964705882352941 is not better than 0.5788235294117647 of logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep32000, skipping checkpoint +[2026-04-15 13:20:30,179][trainer.accelerators.base_accelerator][INFO] - Training progress: step=43050/100000 (43.05%), epoch=0, lr=1e-05, speed=1.542 step/s, elapsed=07:45:20, eta=10:15:35 +[2026-04-15 13:20:48,020][trainer.accelerators.base_accelerator][INFO] - Training progress: step=43100/100000 (43.10%), epoch=0, lr=1e-05, speed=1.543 step/s, elapsed=07:45:38, eta=10:14:44 +[2026-04-15 13:21:05,824][trainer.accelerators.base_accelerator][INFO] - Training progress: step=43150/100000 (43.15%), epoch=0, lr=1e-05, speed=1.543 step/s, elapsed=07:45:56, eta=10:13:52 +[2026-04-15 13:21:23,611][trainer.accelerators.base_accelerator][INFO] - Training progress: step=43200/100000 (43.20%), epoch=0, lr=1e-05, speed=1.544 step/s, elapsed=07:46:14, eta=10:13:01 +[2026-04-15 13:21:41,437][trainer.accelerators.base_accelerator][INFO] - Training progress: step=43250/100000 (43.25%), epoch=0, lr=1e-05, speed=1.545 step/s, elapsed=07:46:32, eta=10:12:09 +[2026-04-15 13:21:59,318][trainer.accelerators.base_accelerator][INFO] - Training progress: step=43300/100000 (43.30%), epoch=0, lr=1e-05, speed=1.546 step/s, elapsed=07:46:50, eta=10:11:18 +[2026-04-15 13:22:17,240][trainer.accelerators.base_accelerator][INFO] - Training progress: step=43350/100000 (43.35%), epoch=0, lr=1e-05, speed=1.547 step/s, elapsed=07:47:07, eta=10:10:27 +[2026-04-15 13:22:35,166][trainer.accelerators.base_accelerator][INFO] - Training progress: step=43400/100000 (43.40%), epoch=0, lr=1e-05, speed=1.547 step/s, elapsed=07:47:25, eta=10:09:35 +[2026-04-15 13:22:53,168][trainer.accelerators.base_accelerator][INFO] - Training progress: step=43450/100000 (43.45%), epoch=0, lr=1e-05, speed=1.548 step/s, elapsed=07:47:43, eta=10:08:44 +[2026-04-15 13:23:11,156][trainer.accelerators.base_accelerator][INFO] - Training progress: step=43500/100000 (43.50%), epoch=0, lr=1e-05, speed=1.549 step/s, elapsed=07:48:01, eta=10:07:54 +[2026-04-15 13:23:29,156][trainer.accelerators.base_accelerator][INFO] - Training progress: step=43550/100000 (43.55%), epoch=0, lr=1e-05, speed=1.550 step/s, elapsed=07:48:19, eta=10:07:03 +[2026-04-15 13:23:47,102][trainer.accelerators.base_accelerator][INFO] - Training progress: step=43600/100000 (43.60%), epoch=0, lr=1e-05, speed=1.551 step/s, elapsed=07:48:37, eta=10:06:12 +[2026-04-15 13:24:05,028][trainer.accelerators.base_accelerator][INFO] - Training progress: step=43650/100000 (43.65%), epoch=0, lr=1e-05, speed=1.551 step/s, elapsed=07:48:55, eta=10:05:21 +[2026-04-15 13:24:22,921][trainer.accelerators.base_accelerator][INFO] - Training progress: step=43700/100000 (43.70%), epoch=0, lr=1e-05, speed=1.552 step/s, elapsed=07:49:13, eta=10:04:31 +[2026-04-15 13:24:40,802][trainer.accelerators.base_accelerator][INFO] - Training progress: step=43750/100000 (43.75%), epoch=0, lr=1e-05, speed=1.553 step/s, elapsed=07:49:31, eta=10:03:40 +[2026-04-15 13:24:58,755][trainer.accelerators.base_accelerator][INFO] - Training progress: step=43800/100000 (43.80%), epoch=0, lr=1e-05, speed=1.554 step/s, elapsed=07:49:49, eta=10:02:50 +[2026-04-15 13:25:16,658][trainer.accelerators.base_accelerator][INFO] - Training progress: step=43850/100000 (43.85%), epoch=0, lr=1e-05, speed=1.555 step/s, elapsed=07:50:07, eta=10:01:59 +[2026-04-15 13:25:34,540][trainer.accelerators.base_accelerator][INFO] - Training progress: step=43900/100000 (43.90%), epoch=0, lr=1e-05, speed=1.555 step/s, elapsed=07:50:25, eta=10:01:09 +[2026-04-15 13:25:52,402][trainer.accelerators.base_accelerator][INFO] - Training progress: step=43950/100000 (43.95%), epoch=0, lr=1e-05, speed=1.556 step/s, elapsed=07:50:43, eta=10:00:18 +[2026-04-15 13:26:10,324][trainer.accelerators.base_accelerator][INFO] - Training progress: step=44000/100000 (44.00%), epoch=0, lr=1e-05, speed=1.557 step/s, elapsed=07:51:01, eta=09:59:28 +[2026-04-15 13:26:10,348][__main__][INFO] - ========== EVAL START (periodic@gstep=44000) ========== +[2026-04-15 13:26:10,348][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-15 13:26:10,348][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 13:26:27,638][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.124879837036133, 'accuracy': 0.5505882352941176, 'num_samples': 425, 'test_unique_accuracy': 0.5254629629629629, 'test_unique_num_samples': 432} +[2026-04-15 13:26:27,638][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-15 13:26:27,639][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 13:26:42,747][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.124879837036133, 'accuracy': 0.5505882352941176, 'num_samples': 425, 'test_unique_accuracy': 0.5208333333333334, 'test_unique_num_samples': 432} +[2026-04-15 13:26:42,748][__main__][INFO] - ========== EVAL END (periodic@gstep=44000) ========== +[2026-04-15 13:26:42,748][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.118358612060547, 'accuracy': 0.5505882352941176, 'num_samples': 425, 'test_unique_accuracy': 0.5208333333333334, 'test_unique_num_samples': 432} +[2026-04-15 13:26:42,765][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.5505882352941176 is not better than 0.5788235294117647 of logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep32000, skipping checkpoint +[2026-04-15 13:27:00,961][trainer.accelerators.base_accelerator][INFO] - Training progress: step=44050/100000 (44.05%), epoch=0, lr=1e-05, speed=1.556 step/s, elapsed=07:51:51, eta=09:59:19 +[2026-04-15 13:27:19,438][trainer.accelerators.base_accelerator][INFO] - Training progress: step=44100/100000 (44.10%), epoch=0, lr=1e-05, speed=1.557 step/s, elapsed=07:52:10, eta=09:58:30 +[2026-04-15 13:27:37,393][trainer.accelerators.base_accelerator][INFO] - Training progress: step=44150/100000 (44.15%), epoch=0, lr=1e-05, speed=1.557 step/s, elapsed=07:52:28, eta=09:57:40 +[2026-04-15 13:27:55,277][trainer.accelerators.base_accelerator][INFO] - Training progress: step=44200/100000 (44.20%), epoch=0, lr=1e-05, speed=1.558 step/s, elapsed=07:52:45, eta=09:56:50 +[2026-04-15 13:28:13,411][trainer.accelerators.base_accelerator][INFO] - Training progress: step=44250/100000 (44.25%), epoch=0, lr=1e-05, speed=1.559 step/s, elapsed=07:53:04, eta=09:56:00 +[2026-04-15 13:28:20,725][trainer.accelerators.base_accelerator][INFO] - Epoch 0 finished +[2026-04-15 13:28:32,731][trainer.accelerators.base_accelerator][INFO] - Training progress: step=44300/100000 (44.30%), epoch=1, lr=1e-05, speed=1.560 step/s, elapsed=07:53:23, eta=09:55:12 +[2026-04-15 13:28:50,671][trainer.accelerators.base_accelerator][INFO] - Training progress: step=44350/100000 (44.35%), epoch=1, lr=1e-05, speed=1.560 step/s, elapsed=07:53:41, eta=09:54:22 +[2026-04-15 13:29:08,827][trainer.accelerators.base_accelerator][INFO] - Training progress: step=44400/100000 (44.40%), epoch=1, lr=1e-05, speed=1.561 step/s, elapsed=07:53:59, eta=09:53:33 +[2026-04-15 13:29:26,740][trainer.accelerators.base_accelerator][INFO] - Training progress: step=44450/100000 (44.45%), epoch=1, lr=1e-05, speed=1.562 step/s, elapsed=07:54:17, eta=09:52:43 +[2026-04-15 13:29:44,652][trainer.accelerators.base_accelerator][INFO] - Training progress: step=44500/100000 (44.50%), epoch=1, lr=1e-05, speed=1.563 step/s, elapsed=07:54:35, eta=09:51:54 +[2026-04-15 13:30:02,524][trainer.accelerators.base_accelerator][INFO] - Training progress: step=44550/100000 (44.55%), epoch=1, lr=1e-05, speed=1.564 step/s, elapsed=07:54:53, eta=09:51:04 +[2026-04-15 13:30:20,635][trainer.accelerators.base_accelerator][INFO] - Training progress: step=44600/100000 (44.60%), epoch=1, lr=1e-05, speed=1.564 step/s, elapsed=07:55:11, eta=09:50:15 +[2026-04-15 13:30:38,625][trainer.accelerators.base_accelerator][INFO] - Training progress: step=44650/100000 (44.65%), epoch=1, lr=1e-05, speed=1.565 step/s, elapsed=07:55:29, eta=09:49:26 +[2026-04-15 13:30:56,619][trainer.accelerators.base_accelerator][INFO] - Training progress: step=44700/100000 (44.70%), epoch=1, lr=1e-05, speed=1.566 step/s, elapsed=07:55:47, eta=09:48:36 +[2026-04-15 13:31:14,393][trainer.accelerators.base_accelerator][INFO] - Training progress: step=44750/100000 (44.75%), epoch=1, lr=1e-05, speed=1.567 step/s, elapsed=07:56:05, eta=09:47:47 +[2026-04-15 13:31:32,350][trainer.accelerators.base_accelerator][INFO] - Training progress: step=44800/100000 (44.80%), epoch=1, lr=1e-05, speed=1.567 step/s, elapsed=07:56:23, eta=09:46:58 +[2026-04-15 13:31:50,316][trainer.accelerators.base_accelerator][INFO] - Training progress: step=44850/100000 (44.85%), epoch=1, lr=1e-05, speed=1.568 step/s, elapsed=07:56:40, eta=09:46:09 +[2026-04-15 13:32:08,136][trainer.accelerators.base_accelerator][INFO] - Training progress: step=44900/100000 (44.90%), epoch=1, lr=1e-05, speed=1.569 step/s, elapsed=07:56:58, eta=09:45:20 +[2026-04-15 13:32:26,031][trainer.accelerators.base_accelerator][INFO] - Training progress: step=44950/100000 (44.95%), epoch=1, lr=1e-05, speed=1.570 step/s, elapsed=07:57:16, eta=09:44:31 +[2026-04-15 13:32:44,351][trainer.accelerators.base_accelerator][INFO] - Training progress: step=45000/100000 (45.00%), epoch=1, lr=1e-05, speed=1.570 step/s, elapsed=07:57:35, eta=09:43:42 +[2026-04-15 13:32:44,376][__main__][INFO] - ========== EVAL START (periodic@gstep=45000) ========== +[2026-04-15 13:32:44,376][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-15 13:32:44,376][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 13:32:59,530][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.118358612060547, 'accuracy': 0.4894117647058824, 'num_samples': 425, 'test_unique_accuracy': 0.5208333333333334, 'test_unique_num_samples': 432} +[2026-04-15 13:32:59,530][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-15 13:32:59,530][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 13:33:14,651][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.118358612060547, 'accuracy': 0.4894117647058824, 'num_samples': 425, 'test_unique_accuracy': 0.4930555555555556, 'test_unique_num_samples': 432} +[2026-04-15 13:33:14,651][__main__][INFO] - ========== EVAL END (periodic@gstep=45000) ========== +[2026-04-15 13:33:14,652][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.11446762084961, 'accuracy': 0.4894117647058824, 'num_samples': 425, 'test_unique_accuracy': 0.4930555555555556, 'test_unique_num_samples': 432} +[2026-04-15 13:33:14,655][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.4894117647058824 is not better than 0.5788235294117647 of logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep32000, skipping checkpoint +[2026-04-15 13:33:32,435][trainer.accelerators.base_accelerator][INFO] - Training progress: step=45050/100000 (45.05%), epoch=1, lr=1e-05, speed=1.570 step/s, elapsed=07:58:23, eta=09:43:30 +[2026-04-15 13:33:50,311][trainer.accelerators.base_accelerator][INFO] - Training progress: step=45100/100000 (45.10%), epoch=1, lr=1e-05, speed=1.570 step/s, elapsed=07:58:40, eta=09:42:41 +[2026-04-15 13:34:08,174][trainer.accelerators.base_accelerator][INFO] - Training progress: step=45150/100000 (45.15%), epoch=1, lr=1e-05, speed=1.571 step/s, elapsed=07:58:58, eta=09:41:53 +[2026-04-15 13:34:25,989][trainer.accelerators.base_accelerator][INFO] - Training progress: step=45200/100000 (45.20%), epoch=1, lr=1e-05, speed=1.572 step/s, elapsed=07:59:16, eta=09:41:04 +[2026-04-15 13:34:43,831][trainer.accelerators.base_accelerator][INFO] - Training progress: step=45250/100000 (45.25%), epoch=1, lr=1e-05, speed=1.573 step/s, elapsed=07:59:34, eta=09:40:15 +[2026-04-15 13:35:01,685][trainer.accelerators.base_accelerator][INFO] - Training progress: step=45300/100000 (45.30%), epoch=1, lr=1e-05, speed=1.573 step/s, elapsed=07:59:52, eta=09:39:26 +[2026-04-15 13:35:19,435][trainer.accelerators.base_accelerator][INFO] - Training progress: step=45350/100000 (45.35%), epoch=1, lr=1e-05, speed=1.574 step/s, elapsed=08:00:10, eta=09:38:38 +[2026-04-15 13:35:37,267][trainer.accelerators.base_accelerator][INFO] - Training progress: step=45400/100000 (45.40%), epoch=1, lr=1e-05, speed=1.575 step/s, elapsed=08:00:27, eta=09:37:49 +[2026-04-15 13:35:55,118][trainer.accelerators.base_accelerator][INFO] - Training progress: step=45450/100000 (45.45%), epoch=1, lr=1e-05, speed=1.576 step/s, elapsed=08:00:45, eta=09:37:01 +[2026-04-15 13:36:12,932][trainer.accelerators.base_accelerator][INFO] - Training progress: step=45500/100000 (45.50%), epoch=1, lr=1e-05, speed=1.576 step/s, elapsed=08:01:03, eta=09:36:12 +[2026-04-15 13:36:30,807][trainer.accelerators.base_accelerator][INFO] - Training progress: step=45550/100000 (45.55%), epoch=1, lr=1e-05, speed=1.577 step/s, elapsed=08:01:21, eta=09:35:24 +[2026-04-15 13:36:48,718][trainer.accelerators.base_accelerator][INFO] - Training progress: step=45600/100000 (45.60%), epoch=1, lr=1e-05, speed=1.578 step/s, elapsed=08:01:39, eta=09:34:36 +[2026-04-15 13:37:06,606][trainer.accelerators.base_accelerator][INFO] - Training progress: step=45650/100000 (45.65%), epoch=1, lr=1e-05, speed=1.579 step/s, elapsed=08:01:57, eta=09:33:48 +[2026-04-15 13:37:24,409][trainer.accelerators.base_accelerator][INFO] - Training progress: step=45700/100000 (45.70%), epoch=1, lr=1e-05, speed=1.579 step/s, elapsed=08:02:15, eta=09:33:00 +[2026-04-15 13:37:42,238][trainer.accelerators.base_accelerator][INFO] - Training progress: step=45750/100000 (45.75%), epoch=1, lr=1e-05, speed=1.580 step/s, elapsed=08:02:32, eta=09:32:12 +[2026-04-15 13:38:00,458][trainer.accelerators.base_accelerator][INFO] - Training progress: step=45800/100000 (45.80%), epoch=1, lr=1e-05, speed=1.581 step/s, elapsed=08:02:51, eta=09:31:24 +[2026-04-15 13:38:18,342][trainer.accelerators.base_accelerator][INFO] - Training progress: step=45850/100000 (45.85%), epoch=1, lr=1e-05, speed=1.582 step/s, elapsed=08:03:09, eta=09:30:36 +[2026-04-15 13:38:36,146][trainer.accelerators.base_accelerator][INFO] - Training progress: step=45900/100000 (45.90%), epoch=1, lr=1e-05, speed=1.582 step/s, elapsed=08:03:26, eta=09:29:48 +[2026-04-15 13:38:54,055][trainer.accelerators.base_accelerator][INFO] - Training progress: step=45950/100000 (45.95%), epoch=1, lr=1e-05, speed=1.583 step/s, elapsed=08:03:44, eta=09:29:01 +[2026-04-15 13:39:11,873][trainer.accelerators.base_accelerator][INFO] - Training progress: step=46000/100000 (46.00%), epoch=1, lr=1e-05, speed=1.584 step/s, elapsed=08:04:02, eta=09:28:13 +[2026-04-15 13:39:11,898][__main__][INFO] - ========== EVAL START (periodic@gstep=46000) ========== +[2026-04-15 13:39:11,898][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-15 13:39:11,898][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 13:39:27,222][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.11446762084961, 'accuracy': 0.5176470588235295, 'num_samples': 425, 'test_unique_accuracy': 0.4930555555555556, 'test_unique_num_samples': 432} +[2026-04-15 13:39:27,223][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-15 13:39:27,223][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 13:39:42,365][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.11446762084961, 'accuracy': 0.5176470588235295, 'num_samples': 425, 'test_unique_accuracy': 0.47685185185185186, 'test_unique_num_samples': 432} +[2026-04-15 13:39:42,366][__main__][INFO] - ========== EVAL END (periodic@gstep=46000) ========== +[2026-04-15 13:39:42,366][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.111109733581543, 'accuracy': 0.5176470588235295, 'num_samples': 425, 'test_unique_accuracy': 0.47685185185185186, 'test_unique_num_samples': 432} +[2026-04-15 13:39:42,369][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.5176470588235295 is not better than 0.5788235294117647 of logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep32000, skipping checkpoint +[2026-04-15 13:40:00,181][trainer.accelerators.base_accelerator][INFO] - Training progress: step=46050/100000 (46.05%), epoch=1, lr=1e-05, speed=1.583 step/s, elapsed=08:04:50, eta=09:28:01 +[2026-04-15 13:40:18,032][trainer.accelerators.base_accelerator][INFO] - Training progress: step=46100/100000 (46.10%), epoch=1, lr=1e-05, speed=1.584 step/s, elapsed=08:05:08, eta=09:27:13 +[2026-04-15 13:40:35,921][trainer.accelerators.base_accelerator][INFO] - Training progress: step=46150/100000 (46.15%), epoch=1, lr=1e-05, speed=1.584 step/s, elapsed=08:05:26, eta=09:26:26 +[2026-04-15 13:40:53,834][trainer.accelerators.base_accelerator][INFO] - Training progress: step=46200/100000 (46.20%), epoch=1, lr=1e-05, speed=1.585 step/s, elapsed=08:05:44, eta=09:25:38 +[2026-04-15 13:41:11,678][trainer.accelerators.base_accelerator][INFO] - Training progress: step=46250/100000 (46.25%), epoch=1, lr=1e-05, speed=1.586 step/s, elapsed=08:06:02, eta=09:24:51 +[2026-04-15 13:41:29,523][trainer.accelerators.base_accelerator][INFO] - Training progress: step=46300/100000 (46.30%), epoch=1, lr=1e-05, speed=1.587 step/s, elapsed=08:06:20, eta=09:24:03 +[2026-04-15 13:41:47,425][trainer.accelerators.base_accelerator][INFO] - Training progress: step=46350/100000 (46.35%), epoch=1, lr=1e-05, speed=1.587 step/s, elapsed=08:06:38, eta=09:23:16 +[2026-04-15 13:42:05,300][trainer.accelerators.base_accelerator][INFO] - Training progress: step=46400/100000 (46.40%), epoch=1, lr=1e-05, speed=1.588 step/s, elapsed=08:06:55, eta=09:22:29 +[2026-04-15 13:42:23,263][trainer.accelerators.base_accelerator][INFO] - Training progress: step=46450/100000 (46.45%), epoch=1, lr=1e-05, speed=1.589 step/s, elapsed=08:07:13, eta=09:21:42 +[2026-04-15 13:42:41,026][trainer.accelerators.base_accelerator][INFO] - Training progress: step=46500/100000 (46.50%), epoch=1, lr=1e-05, speed=1.590 step/s, elapsed=08:07:31, eta=09:20:55 +[2026-04-15 13:42:58,868][trainer.accelerators.base_accelerator][INFO] - Training progress: step=46550/100000 (46.55%), epoch=1, lr=1e-05, speed=1.590 step/s, elapsed=08:07:49, eta=09:20:08 +[2026-04-15 13:43:16,773][trainer.accelerators.base_accelerator][INFO] - Training progress: step=46600/100000 (46.60%), epoch=1, lr=1e-05, speed=1.591 step/s, elapsed=08:08:07, eta=09:19:21 +[2026-04-15 13:43:34,609][trainer.accelerators.base_accelerator][INFO] - Training progress: step=46650/100000 (46.65%), epoch=1, lr=1e-05, speed=1.592 step/s, elapsed=08:08:25, eta=09:18:34 +[2026-04-15 13:43:52,499][trainer.accelerators.base_accelerator][INFO] - Training progress: step=46700/100000 (46.70%), epoch=1, lr=1e-05, speed=1.593 step/s, elapsed=08:08:43, eta=09:17:47 +[2026-04-15 13:44:10,383][trainer.accelerators.base_accelerator][INFO] - Training progress: step=46750/100000 (46.75%), epoch=1, lr=1e-05, speed=1.593 step/s, elapsed=08:09:01, eta=09:17:00 +[2026-04-15 13:44:28,331][trainer.accelerators.base_accelerator][INFO] - Training progress: step=46800/100000 (46.80%), epoch=1, lr=1e-05, speed=1.594 step/s, elapsed=08:09:19, eta=09:16:13 +[2026-04-15 13:44:46,727][trainer.accelerators.base_accelerator][INFO] - Training progress: step=46850/100000 (46.85%), epoch=1, lr=1e-05, speed=1.595 step/s, elapsed=08:09:37, eta=09:15:27 +[2026-04-15 13:45:04,617][trainer.accelerators.base_accelerator][INFO] - Training progress: step=46900/100000 (46.90%), epoch=1, lr=1e-05, speed=1.595 step/s, elapsed=08:09:55, eta=09:14:41 +[2026-04-15 13:45:22,483][trainer.accelerators.base_accelerator][INFO] - Training progress: step=46950/100000 (46.95%), epoch=1, lr=1e-05, speed=1.596 step/s, elapsed=08:10:13, eta=09:13:54 +[2026-04-15 13:45:40,328][trainer.accelerators.base_accelerator][INFO] - Training progress: step=47000/100000 (47.00%), epoch=1, lr=1e-05, speed=1.597 step/s, elapsed=08:10:31, eta=09:13:08 +[2026-04-15 13:45:40,353][__main__][INFO] - ========== EVAL START (periodic@gstep=47000) ========== +[2026-04-15 13:45:40,353][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-15 13:45:40,353][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 13:45:55,472][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.111109733581543, 'accuracy': 0.4776470588235294, 'num_samples': 425, 'test_unique_accuracy': 0.47685185185185186, 'test_unique_num_samples': 432} +[2026-04-15 13:45:55,472][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-15 13:45:55,472][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 13:46:10,552][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.111109733581543, 'accuracy': 0.4776470588235294, 'num_samples': 425, 'test_unique_accuracy': 0.5069444444444444, 'test_unique_num_samples': 432} +[2026-04-15 13:46:10,552][__main__][INFO] - ========== EVAL END (periodic@gstep=47000) ========== +[2026-04-15 13:46:10,552][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.11485481262207, 'accuracy': 0.4776470588235294, 'num_samples': 425, 'test_unique_accuracy': 0.5069444444444444, 'test_unique_num_samples': 432} +[2026-04-15 13:46:10,558][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.4776470588235294 is not better than 0.5788235294117647 of logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep32000, skipping checkpoint +[2026-04-15 13:46:28,399][trainer.accelerators.base_accelerator][INFO] - Training progress: step=47050/100000 (47.05%), epoch=1, lr=1e-05, speed=1.596 step/s, elapsed=08:11:19, eta=09:12:55 +[2026-04-15 13:46:46,230][trainer.accelerators.base_accelerator][INFO] - Training progress: step=47100/100000 (47.10%), epoch=1, lr=1e-05, speed=1.597 step/s, elapsed=08:11:36, eta=09:12:09 +[2026-04-15 13:47:04,104][trainer.accelerators.base_accelerator][INFO] - Training progress: step=47150/100000 (47.15%), epoch=1, lr=1e-05, speed=1.598 step/s, elapsed=08:11:54, eta=09:11:22 +[2026-04-15 13:47:21,975][trainer.accelerators.base_accelerator][INFO] - Training progress: step=47200/100000 (47.20%), epoch=1, lr=1e-05, speed=1.598 step/s, elapsed=08:12:12, eta=09:10:36 +[2026-04-15 13:47:39,845][trainer.accelerators.base_accelerator][INFO] - Training progress: step=47250/100000 (47.25%), epoch=1, lr=1e-05, speed=1.599 step/s, elapsed=08:12:30, eta=09:09:50 +[2026-04-15 13:47:57,630][trainer.accelerators.base_accelerator][INFO] - Training progress: step=47300/100000 (47.30%), epoch=1, lr=1e-05, speed=1.600 step/s, elapsed=08:12:48, eta=09:09:03 +[2026-04-15 13:48:15,480][trainer.accelerators.base_accelerator][INFO] - Training progress: step=47350/100000 (47.35%), epoch=1, lr=1e-05, speed=1.600 step/s, elapsed=08:13:06, eta=09:08:17 +[2026-04-15 13:48:33,293][trainer.accelerators.base_accelerator][INFO] - Training progress: step=47400/100000 (47.40%), epoch=1, lr=1e-05, speed=1.601 step/s, elapsed=08:13:23, eta=09:07:31 +[2026-04-15 13:48:51,210][trainer.accelerators.base_accelerator][INFO] - Training progress: step=47450/100000 (47.45%), epoch=1, lr=1e-05, speed=1.602 step/s, elapsed=08:13:41, eta=09:06:45 +[2026-04-15 13:49:09,051][trainer.accelerators.base_accelerator][INFO] - Training progress: step=47500/100000 (47.50%), epoch=1, lr=1e-05, speed=1.603 step/s, elapsed=08:13:59, eta=09:05:59 +[2026-04-15 13:49:26,947][trainer.accelerators.base_accelerator][INFO] - Training progress: step=47550/100000 (47.55%), epoch=1, lr=1e-05, speed=1.603 step/s, elapsed=08:14:17, eta=09:05:13 +[2026-04-15 13:49:44,857][trainer.accelerators.base_accelerator][INFO] - Training progress: step=47600/100000 (47.60%), epoch=1, lr=1e-05, speed=1.604 step/s, elapsed=08:14:35, eta=09:04:28 +[2026-04-15 13:50:02,777][trainer.accelerators.base_accelerator][INFO] - Training progress: step=47650/100000 (47.65%), epoch=1, lr=1e-05, speed=1.605 step/s, elapsed=08:14:53, eta=09:03:42 +[2026-04-15 13:50:20,601][trainer.accelerators.base_accelerator][INFO] - Training progress: step=47700/100000 (47.70%), epoch=1, lr=1e-05, speed=1.605 step/s, elapsed=08:15:11, eta=09:02:56 +[2026-04-15 13:50:38,489][trainer.accelerators.base_accelerator][INFO] - Training progress: step=47750/100000 (47.75%), epoch=1, lr=1e-05, speed=1.606 step/s, elapsed=08:15:29, eta=09:02:10 +[2026-04-15 13:50:56,389][trainer.accelerators.base_accelerator][INFO] - Training progress: step=47800/100000 (47.80%), epoch=1, lr=1e-05, speed=1.607 step/s, elapsed=08:15:47, eta=09:01:25 +[2026-04-15 13:51:14,272][trainer.accelerators.base_accelerator][INFO] - Training progress: step=47850/100000 (47.85%), epoch=1, lr=1e-05, speed=1.608 step/s, elapsed=08:16:04, eta=09:00:39 +[2026-04-15 13:51:32,052][trainer.accelerators.base_accelerator][INFO] - Training progress: step=47900/100000 (47.90%), epoch=1, lr=1e-05, speed=1.608 step/s, elapsed=08:16:22, eta=08:59:54 +[2026-04-15 13:51:50,261][trainer.accelerators.base_accelerator][INFO] - Training progress: step=47950/100000 (47.95%), epoch=1, lr=1e-05, speed=1.609 step/s, elapsed=08:16:40, eta=08:59:09 +[2026-04-15 13:52:08,103][trainer.accelerators.base_accelerator][INFO] - Training progress: step=48000/100000 (48.00%), epoch=1, lr=1e-05, speed=1.610 step/s, elapsed=08:16:58, eta=08:58:23 +[2026-04-15 13:52:08,128][__main__][INFO] - ========== EVAL START (periodic@gstep=48000) ========== +[2026-04-15 13:52:08,128][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-15 13:52:08,128][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 13:52:25,037][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.11485481262207, 'accuracy': 0.4964705882352941, 'num_samples': 425, 'test_unique_accuracy': 0.5069444444444444, 'test_unique_num_samples': 432} +[2026-04-15 13:52:25,038][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-15 13:52:25,038][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 13:52:40,113][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.11485481262207, 'accuracy': 0.4964705882352941, 'num_samples': 425, 'test_unique_accuracy': 0.47685185185185186, 'test_unique_num_samples': 432} +[2026-04-15 13:52:40,114][__main__][INFO] - ========== EVAL END (periodic@gstep=48000) ========== +[2026-04-15 13:52:40,114][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.110554695129395, 'accuracy': 0.4964705882352941, 'num_samples': 425, 'test_unique_accuracy': 0.47685185185185186, 'test_unique_num_samples': 432} +[2026-04-15 13:52:40,171][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.4964705882352941 is not better than 0.5788235294117647 of logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep32000, skipping checkpoint +[2026-04-15 13:52:58,006][trainer.accelerators.base_accelerator][INFO] - Training progress: step=48050/100000 (48.05%), epoch=1, lr=1e-05, speed=1.609 step/s, elapsed=08:17:48, eta=08:58:12 +[2026-04-15 13:53:15,930][trainer.accelerators.base_accelerator][INFO] - Training progress: step=48100/100000 (48.10%), epoch=1, lr=1e-05, speed=1.609 step/s, elapsed=08:18:06, eta=08:57:27 +[2026-04-15 13:53:33,790][trainer.accelerators.base_accelerator][INFO] - Training progress: step=48150/100000 (48.15%), epoch=1, lr=1e-05, speed=1.610 step/s, elapsed=08:18:24, eta=08:56:42 +[2026-04-15 13:53:51,594][trainer.accelerators.base_accelerator][INFO] - Training progress: step=48200/100000 (48.20%), epoch=1, lr=1e-05, speed=1.611 step/s, elapsed=08:18:42, eta=08:55:57 +[2026-04-15 13:54:09,438][trainer.accelerators.base_accelerator][INFO] - Training progress: step=48250/100000 (48.25%), epoch=1, lr=1e-05, speed=1.612 step/s, elapsed=08:19:00, eta=08:55:11 +[2026-04-15 13:54:27,333][trainer.accelerators.base_accelerator][INFO] - Training progress: step=48300/100000 (48.30%), epoch=1, lr=1e-05, speed=1.612 step/s, elapsed=08:19:18, eta=08:54:26 +[2026-04-15 13:54:45,234][trainer.accelerators.base_accelerator][INFO] - Training progress: step=48350/100000 (48.35%), epoch=1, lr=1e-05, speed=1.613 step/s, elapsed=08:19:35, eta=08:53:41 +[2026-04-15 13:55:03,144][trainer.accelerators.base_accelerator][INFO] - Training progress: step=48400/100000 (48.40%), epoch=1, lr=1e-05, speed=1.614 step/s, elapsed=08:19:53, eta=08:52:56 +[2026-04-15 13:55:20,930][trainer.accelerators.base_accelerator][INFO] - Training progress: step=48450/100000 (48.45%), epoch=1, lr=1e-05, speed=1.614 step/s, elapsed=08:20:11, eta=08:52:11 +[2026-04-15 13:55:38,744][trainer.accelerators.base_accelerator][INFO] - Training progress: step=48500/100000 (48.50%), epoch=1, lr=1e-05, speed=1.615 step/s, elapsed=08:20:29, eta=08:51:26 +[2026-04-15 13:55:56,599][trainer.accelerators.base_accelerator][INFO] - Training progress: step=48550/100000 (48.55%), epoch=1, lr=1e-05, speed=1.616 step/s, elapsed=08:20:47, eta=08:50:42 +[2026-04-15 13:56:14,447][trainer.accelerators.base_accelerator][INFO] - Training progress: step=48600/100000 (48.60%), epoch=1, lr=1e-05, speed=1.616 step/s, elapsed=08:21:05, eta=08:49:57 +[2026-04-15 13:56:32,278][trainer.accelerators.base_accelerator][INFO] - Training progress: step=48650/100000 (48.65%), epoch=1, lr=1e-05, speed=1.617 step/s, elapsed=08:21:22, eta=08:49:12 +[2026-04-15 13:56:50,062][trainer.accelerators.base_accelerator][INFO] - Training progress: step=48700/100000 (48.70%), epoch=1, lr=1e-05, speed=1.618 step/s, elapsed=08:21:40, eta=08:48:27 +[2026-04-15 13:57:07,924][trainer.accelerators.base_accelerator][INFO] - Training progress: step=48750/100000 (48.75%), epoch=1, lr=1e-05, speed=1.619 step/s, elapsed=08:21:58, eta=08:47:43 +[2026-04-15 13:57:25,787][trainer.accelerators.base_accelerator][INFO] - Training progress: step=48800/100000 (48.80%), epoch=1, lr=1e-05, speed=1.619 step/s, elapsed=08:22:16, eta=08:46:58 +[2026-04-15 13:57:43,648][trainer.accelerators.base_accelerator][INFO] - Training progress: step=48850/100000 (48.85%), epoch=1, lr=1e-05, speed=1.620 step/s, elapsed=08:22:34, eta=08:46:14 +[2026-04-15 13:58:01,520][trainer.accelerators.base_accelerator][INFO] - Training progress: step=48900/100000 (48.90%), epoch=1, lr=1e-05, speed=1.621 step/s, elapsed=08:22:52, eta=08:45:29 +[2026-04-15 13:58:19,343][trainer.accelerators.base_accelerator][INFO] - Training progress: step=48950/100000 (48.95%), epoch=1, lr=1e-05, speed=1.621 step/s, elapsed=08:23:10, eta=08:44:45 +[2026-04-15 13:58:37,604][trainer.accelerators.base_accelerator][INFO] - Training progress: step=49000/100000 (49.00%), epoch=1, lr=1e-05, speed=1.622 step/s, elapsed=08:23:28, eta=08:44:01 +[2026-04-15 13:58:37,629][__main__][INFO] - ========== EVAL START (periodic@gstep=49000) ========== +[2026-04-15 13:58:37,629][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-15 13:58:37,630][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 13:58:52,921][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.110554695129395, 'accuracy': 0.5223529411764706, 'num_samples': 425, 'test_unique_accuracy': 0.47685185185185186, 'test_unique_num_samples': 432} +[2026-04-15 13:58:52,921][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-15 13:58:52,921][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 13:59:07,990][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.110554695129395, 'accuracy': 0.5223529411764706, 'num_samples': 425, 'test_unique_accuracy': 0.48842592592592593, 'test_unique_num_samples': 432} +[2026-04-15 13:59:07,991][__main__][INFO] - ========== EVAL END (periodic@gstep=49000) ========== +[2026-04-15 13:59:07,991][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.108744621276855, 'accuracy': 0.5223529411764706, 'num_samples': 425, 'test_unique_accuracy': 0.48842592592592593, 'test_unique_num_samples': 432} +[2026-04-15 13:59:07,994][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.5223529411764706 is not better than 0.5788235294117647 of logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep32000, skipping checkpoint +[2026-04-15 13:59:25,776][trainer.accelerators.base_accelerator][INFO] - Training progress: step=49050/100000 (49.05%), epoch=1, lr=1e-05, speed=1.621 step/s, elapsed=08:24:16, eta=08:43:48 +[2026-04-15 13:59:43,555][trainer.accelerators.base_accelerator][INFO] - Training progress: step=49100/100000 (49.10%), epoch=1, lr=1e-05, speed=1.622 step/s, elapsed=08:24:34, eta=08:43:04 +[2026-04-15 14:00:01,472][trainer.accelerators.base_accelerator][INFO] - Training progress: step=49150/100000 (49.15%), epoch=1, lr=1e-05, speed=1.623 step/s, elapsed=08:24:52, eta=08:42:19 +[2026-04-15 14:00:19,415][trainer.accelerators.base_accelerator][INFO] - Training progress: step=49200/100000 (49.20%), epoch=1, lr=1e-05, speed=1.623 step/s, elapsed=08:25:10, eta=08:41:35 +[2026-04-15 14:00:37,291][trainer.accelerators.base_accelerator][INFO] - Training progress: step=49250/100000 (49.25%), epoch=1, lr=1e-05, speed=1.624 step/s, elapsed=08:25:27, eta=08:40:51 +[2026-04-15 14:00:55,112][trainer.accelerators.base_accelerator][INFO] - Training progress: step=49300/100000 (49.30%), epoch=1, lr=1e-05, speed=1.625 step/s, elapsed=08:25:45, eta=08:40:07 +[2026-04-15 14:01:12,894][trainer.accelerators.base_accelerator][INFO] - Training progress: step=49350/100000 (49.35%), epoch=1, lr=1e-05, speed=1.625 step/s, elapsed=08:26:03, eta=08:39:23 +[2026-04-15 14:01:30,715][trainer.accelerators.base_accelerator][INFO] - Training progress: step=49400/100000 (49.40%), epoch=1, lr=1e-05, speed=1.626 step/s, elapsed=08:26:21, eta=08:38:39 +[2026-04-15 14:01:48,494][trainer.accelerators.base_accelerator][INFO] - Training progress: step=49450/100000 (49.45%), epoch=1, lr=1e-05, speed=1.627 step/s, elapsed=08:26:39, eta=08:37:55 +[2026-04-15 14:02:06,354][trainer.accelerators.base_accelerator][INFO] - Training progress: step=49500/100000 (49.50%), epoch=1, lr=1e-05, speed=1.627 step/s, elapsed=08:26:57, eta=08:37:11 +[2026-04-15 14:02:24,237][trainer.accelerators.base_accelerator][INFO] - Training progress: step=49550/100000 (49.55%), epoch=1, lr=1e-05, speed=1.628 step/s, elapsed=08:27:14, eta=08:36:27 +[2026-04-15 14:02:42,114][trainer.accelerators.base_accelerator][INFO] - Training progress: step=49600/100000 (49.60%), epoch=1, lr=1e-05, speed=1.629 step/s, elapsed=08:27:32, eta=08:35:43 +[2026-04-15 14:02:59,968][trainer.accelerators.base_accelerator][INFO] - Training progress: step=49650/100000 (49.65%), epoch=1, lr=1e-05, speed=1.629 step/s, elapsed=08:27:50, eta=08:35:00 +[2026-04-15 14:03:17,847][trainer.accelerators.base_accelerator][INFO] - Training progress: step=49700/100000 (49.70%), epoch=1, lr=1e-05, speed=1.630 step/s, elapsed=08:28:08, eta=08:34:16 +[2026-04-15 14:03:35,640][trainer.accelerators.base_accelerator][INFO] - Training progress: step=49750/100000 (49.75%), epoch=1, lr=1e-05, speed=1.631 step/s, elapsed=08:28:26, eta=08:33:32 +[2026-04-15 14:03:53,482][trainer.accelerators.base_accelerator][INFO] - Training progress: step=49800/100000 (49.80%), epoch=1, lr=1e-05, speed=1.631 step/s, elapsed=08:28:44, eta=08:32:49 +[2026-04-15 14:04:11,358][trainer.accelerators.base_accelerator][INFO] - Training progress: step=49850/100000 (49.85%), epoch=1, lr=1e-05, speed=1.632 step/s, elapsed=08:29:02, eta=08:32:05 +[2026-04-15 14:04:29,263][trainer.accelerators.base_accelerator][INFO] - Training progress: step=49900/100000 (49.90%), epoch=1, lr=1e-05, speed=1.633 step/s, elapsed=08:29:19, eta=08:31:22 +[2026-04-15 14:04:47,153][trainer.accelerators.base_accelerator][INFO] - Training progress: step=49950/100000 (49.95%), epoch=1, lr=1e-05, speed=1.634 step/s, elapsed=08:29:37, eta=08:30:39 +[2026-04-15 14:05:04,916][trainer.accelerators.base_accelerator][INFO] - Training progress: step=50000/100000 (50.00%), epoch=1, lr=1e-05, speed=1.634 step/s, elapsed=08:29:55, eta=08:29:55 +[2026-04-15 14:05:04,940][__main__][INFO] - ========== EVAL START (periodic@gstep=50000) ========== +[2026-04-15 14:05:04,940][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-15 14:05:04,941][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 14:05:20,473][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.108744621276855, 'accuracy': 0.5223529411764706, 'num_samples': 425, 'test_unique_accuracy': 0.48842592592592593, 'test_unique_num_samples': 432} +[2026-04-15 14:05:20,473][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-15 14:05:20,474][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 14:05:35,913][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.108744621276855, 'accuracy': 0.5223529411764706, 'num_samples': 425, 'test_unique_accuracy': 0.46296296296296297, 'test_unique_num_samples': 432} +[2026-04-15 14:05:35,914][__main__][INFO] - ========== EVAL END (periodic@gstep=50000) ========== +[2026-04-15 14:05:35,914][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.110107421875, 'accuracy': 0.5223529411764706, 'num_samples': 425, 'test_unique_accuracy': 0.46296296296296297, 'test_unique_num_samples': 432} +[2026-04-15 14:05:35,917][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.5223529411764706 is not better than 0.5788235294117647 of logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep32000, skipping checkpoint +[2026-04-15 14:05:53,697][trainer.accelerators.base_accelerator][INFO] - Training progress: step=50050/100000 (50.05%), epoch=1, lr=1e-05, speed=1.633 step/s, elapsed=08:30:44, eta=08:29:43 +[2026-04-15 14:06:11,539][trainer.accelerators.base_accelerator][INFO] - Training progress: step=50100/100000 (50.10%), epoch=1, lr=1e-05, speed=1.634 step/s, elapsed=08:31:02, eta=08:28:59 +[2026-04-15 14:06:29,306][trainer.accelerators.base_accelerator][INFO] - Training progress: step=50150/100000 (50.15%), epoch=1, lr=1e-05, speed=1.635 step/s, elapsed=08:31:19, eta=08:28:16 +[2026-04-15 14:06:47,127][trainer.accelerators.base_accelerator][INFO] - Training progress: step=50200/100000 (50.20%), epoch=1, lr=1e-05, speed=1.635 step/s, elapsed=08:31:37, eta=08:27:33 +[2026-04-15 14:07:04,928][trainer.accelerators.base_accelerator][INFO] - Training progress: step=50250/100000 (50.25%), epoch=1, lr=1e-05, speed=1.636 step/s, elapsed=08:31:55, eta=08:26:49 +[2026-04-15 14:07:22,748][trainer.accelerators.base_accelerator][INFO] - Training progress: step=50300/100000 (50.30%), epoch=1, lr=1e-05, speed=1.637 step/s, elapsed=08:32:13, eta=08:26:06 +[2026-04-15 14:07:40,547][trainer.accelerators.base_accelerator][INFO] - Training progress: step=50350/100000 (50.35%), epoch=1, lr=1e-05, speed=1.637 step/s, elapsed=08:32:31, eta=08:25:23 +[2026-04-15 14:07:58,372][trainer.accelerators.base_accelerator][INFO] - Training progress: step=50400/100000 (50.40%), epoch=1, lr=1e-05, speed=1.638 step/s, elapsed=08:32:49, eta=08:24:40 +[2026-04-15 14:08:16,183][trainer.accelerators.base_accelerator][INFO] - Training progress: step=50450/100000 (50.45%), epoch=1, lr=1e-05, speed=1.639 step/s, elapsed=08:33:06, eta=08:23:57 +[2026-04-15 14:08:34,052][trainer.accelerators.base_accelerator][INFO] - Training progress: step=50500/100000 (50.50%), epoch=1, lr=1e-05, speed=1.639 step/s, elapsed=08:33:24, eta=08:23:14 +[2026-04-15 14:08:51,963][trainer.accelerators.base_accelerator][INFO] - Training progress: step=50550/100000 (50.55%), epoch=1, lr=1e-05, speed=1.640 step/s, elapsed=08:33:42, eta=08:22:31 +[2026-04-15 14:09:09,806][trainer.accelerators.base_accelerator][INFO] - Training progress: step=50600/100000 (50.60%), epoch=1, lr=1e-05, speed=1.641 step/s, elapsed=08:34:00, eta=08:21:49 +[2026-04-15 14:09:27,670][trainer.accelerators.base_accelerator][INFO] - Training progress: step=50650/100000 (50.65%), epoch=1, lr=1e-05, speed=1.641 step/s, elapsed=08:34:18, eta=08:21:06 +[2026-04-15 14:09:45,501][trainer.accelerators.base_accelerator][INFO] - Training progress: step=50700/100000 (50.70%), epoch=1, lr=1e-05, speed=1.642 step/s, elapsed=08:34:36, eta=08:20:23 +[2026-04-15 14:10:03,262][trainer.accelerators.base_accelerator][INFO] - Training progress: step=50750/100000 (50.75%), epoch=1, lr=1e-05, speed=1.643 step/s, elapsed=08:34:53, eta=08:19:40 +[2026-04-15 14:10:21,147][trainer.accelerators.base_accelerator][INFO] - Training progress: step=50800/100000 (50.80%), epoch=1, lr=1e-05, speed=1.643 step/s, elapsed=08:35:11, eta=08:18:58 +[2026-04-15 14:10:39,044][trainer.accelerators.base_accelerator][INFO] - Training progress: step=50850/100000 (50.85%), epoch=1, lr=1e-05, speed=1.644 step/s, elapsed=08:35:29, eta=08:18:15 +[2026-04-15 14:10:56,847][trainer.accelerators.base_accelerator][INFO] - Training progress: step=50900/100000 (50.90%), epoch=1, lr=1e-05, speed=1.645 step/s, elapsed=08:35:47, eta=08:17:33 +[2026-04-15 14:11:14,714][trainer.accelerators.base_accelerator][INFO] - Training progress: step=50950/100000 (50.95%), epoch=1, lr=1e-05, speed=1.645 step/s, elapsed=08:36:05, eta=08:16:50 +[2026-04-15 14:11:32,644][trainer.accelerators.base_accelerator][INFO] - Training progress: step=51000/100000 (51.00%), epoch=1, lr=1e-05, speed=1.646 step/s, elapsed=08:36:23, eta=08:16:08 +[2026-04-15 14:11:32,669][__main__][INFO] - ========== EVAL START (periodic@gstep=51000) ========== +[2026-04-15 14:11:32,669][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-15 14:11:32,670][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 14:11:47,966][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.110107421875, 'accuracy': 0.4752941176470588, 'num_samples': 425, 'test_unique_accuracy': 0.46296296296296297, 'test_unique_num_samples': 432} +[2026-04-15 14:11:47,967][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-15 14:11:47,967][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 14:12:03,084][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.110107421875, 'accuracy': 0.4752941176470588, 'num_samples': 425, 'test_unique_accuracy': 0.48148148148148145, 'test_unique_num_samples': 432} +[2026-04-15 14:12:03,084][__main__][INFO] - ========== EVAL END (periodic@gstep=51000) ========== +[2026-04-15 14:12:03,085][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.111156463623047, 'accuracy': 0.4752941176470588, 'num_samples': 425, 'test_unique_accuracy': 0.48148148148148145, 'test_unique_num_samples': 432} +[2026-04-15 14:12:03,088][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.4752941176470588 is not better than 0.5788235294117647 of logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep32000, skipping checkpoint +[2026-04-15 14:12:20,995][trainer.accelerators.base_accelerator][INFO] - Training progress: step=51050/100000 (51.05%), epoch=1, lr=1e-05, speed=1.645 step/s, elapsed=08:37:11, eta=08:15:55 +[2026-04-15 14:12:39,182][trainer.accelerators.base_accelerator][INFO] - Training progress: step=51100/100000 (51.10%), epoch=1, lr=1e-05, speed=1.646 step/s, elapsed=08:37:29, eta=08:15:13 +[2026-04-15 14:12:57,013][trainer.accelerators.base_accelerator][INFO] - Training progress: step=51150/100000 (51.15%), epoch=1, lr=1e-05, speed=1.646 step/s, elapsed=08:37:47, eta=08:14:30 +[2026-04-15 14:13:14,843][trainer.accelerators.base_accelerator][INFO] - Training progress: step=51200/100000 (51.20%), epoch=1, lr=1e-05, speed=1.647 step/s, elapsed=08:38:05, eta=08:13:48 +[2026-04-15 14:13:32,658][trainer.accelerators.base_accelerator][INFO] - Training progress: step=51250/100000 (51.25%), epoch=1, lr=1e-05, speed=1.648 step/s, elapsed=08:38:23, eta=08:13:06 +[2026-04-15 14:13:50,526][trainer.accelerators.base_accelerator][INFO] - Training progress: step=51300/100000 (51.30%), epoch=1, lr=1e-05, speed=1.648 step/s, elapsed=08:38:41, eta=08:12:23 +[2026-04-15 14:14:08,413][trainer.accelerators.base_accelerator][INFO] - Training progress: step=51350/100000 (51.35%), epoch=1, lr=1e-05, speed=1.649 step/s, elapsed=08:38:59, eta=08:11:41 +[2026-04-15 14:14:26,340][trainer.accelerators.base_accelerator][INFO] - Training progress: step=51400/100000 (51.40%), epoch=1, lr=1e-05, speed=1.650 step/s, elapsed=08:39:17, eta=08:10:59 +[2026-04-15 14:14:44,241][trainer.accelerators.base_accelerator][INFO] - Training progress: step=51450/100000 (51.45%), epoch=1, lr=1e-05, speed=1.650 step/s, elapsed=08:39:34, eta=08:10:17 +[2026-04-15 14:15:02,102][trainer.accelerators.base_accelerator][INFO] - Training progress: step=51500/100000 (51.50%), epoch=1, lr=1e-05, speed=1.651 step/s, elapsed=08:39:52, eta=08:09:35 +[2026-04-15 14:15:19,875][trainer.accelerators.base_accelerator][INFO] - Training progress: step=51550/100000 (51.55%), epoch=1, lr=1e-05, speed=1.652 step/s, elapsed=08:40:10, eta=08:08:53 +[2026-04-15 14:15:37,722][trainer.accelerators.base_accelerator][INFO] - Training progress: step=51600/100000 (51.60%), epoch=1, lr=1e-05, speed=1.652 step/s, elapsed=08:40:28, eta=08:08:11 +[2026-04-15 14:15:55,583][trainer.accelerators.base_accelerator][INFO] - Training progress: step=51650/100000 (51.65%), epoch=1, lr=1e-05, speed=1.653 step/s, elapsed=08:40:46, eta=08:07:29 +[2026-04-15 14:16:13,339][trainer.accelerators.base_accelerator][INFO] - Training progress: step=51700/100000 (51.70%), epoch=1, lr=1e-05, speed=1.654 step/s, elapsed=08:41:04, eta=08:06:47 +[2026-04-15 14:16:31,158][trainer.accelerators.base_accelerator][INFO] - Training progress: step=51750/100000 (51.75%), epoch=1, lr=1e-05, speed=1.654 step/s, elapsed=08:41:21, eta=08:06:06 +[2026-04-15 14:16:49,036][trainer.accelerators.base_accelerator][INFO] - Training progress: step=51800/100000 (51.80%), epoch=1, lr=1e-05, speed=1.655 step/s, elapsed=08:41:39, eta=08:05:24 +[2026-04-15 14:17:06,961][trainer.accelerators.base_accelerator][INFO] - Training progress: step=51850/100000 (51.85%), epoch=1, lr=1e-05, speed=1.656 step/s, elapsed=08:41:57, eta=08:04:42 +[2026-04-15 14:17:24,743][trainer.accelerators.base_accelerator][INFO] - Training progress: step=51900/100000 (51.90%), epoch=1, lr=1e-05, speed=1.656 step/s, elapsed=08:42:15, eta=08:04:01 +[2026-04-15 14:17:42,628][trainer.accelerators.base_accelerator][INFO] - Training progress: step=51950/100000 (51.95%), epoch=1, lr=1e-05, speed=1.657 step/s, elapsed=08:42:33, eta=08:03:19 +[2026-04-15 14:18:00,638][trainer.accelerators.base_accelerator][INFO] - Training progress: step=52000/100000 (52.00%), epoch=1, lr=1e-05, speed=1.658 step/s, elapsed=08:42:51, eta=08:02:38 +[2026-04-15 14:18:00,662][__main__][INFO] - ========== EVAL START (periodic@gstep=52000) ========== +[2026-04-15 14:18:00,663][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-15 14:18:00,663][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 14:18:17,422][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.111156463623047, 'accuracy': 0.5011764705882353, 'num_samples': 425, 'test_unique_accuracy': 0.48148148148148145, 'test_unique_num_samples': 432} +[2026-04-15 14:18:17,423][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-15 14:18:17,423][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 14:18:32,521][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.111156463623047, 'accuracy': 0.5011764705882353, 'num_samples': 425, 'test_unique_accuracy': 0.5115740740740741, 'test_unique_num_samples': 432} +[2026-04-15 14:18:32,521][__main__][INFO] - ========== EVAL END (periodic@gstep=52000) ========== +[2026-04-15 14:18:32,522][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.116059303283691, 'accuracy': 0.5011764705882353, 'num_samples': 425, 'test_unique_accuracy': 0.5115740740740741, 'test_unique_num_samples': 432} +[2026-04-15 14:18:32,560][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.5011764705882353 is not better than 0.5788235294117647 of logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep32000, skipping checkpoint +[2026-04-15 14:18:50,465][trainer.accelerators.base_accelerator][INFO] - Training progress: step=52050/100000 (52.05%), epoch=1, lr=1e-05, speed=1.657 step/s, elapsed=08:43:41, eta=08:02:26 +[2026-04-15 14:19:08,352][trainer.accelerators.base_accelerator][INFO] - Training progress: step=52100/100000 (52.10%), epoch=1, lr=1e-05, speed=1.657 step/s, elapsed=08:43:59, eta=08:01:44 +[2026-04-15 14:19:26,209][trainer.accelerators.base_accelerator][INFO] - Training progress: step=52150/100000 (52.15%), epoch=1, lr=1e-05, speed=1.658 step/s, elapsed=08:44:16, eta=08:01:03 +[2026-04-15 14:19:44,115][trainer.accelerators.base_accelerator][INFO] - Training progress: step=52200/100000 (52.20%), epoch=1, lr=1e-05, speed=1.658 step/s, elapsed=08:44:34, eta=08:00:21 +[2026-04-15 14:20:01,989][trainer.accelerators.base_accelerator][INFO] - Training progress: step=52250/100000 (52.25%), epoch=1, lr=1e-05, speed=1.659 step/s, elapsed=08:44:52, eta=07:59:40 +[2026-04-15 14:20:19,839][trainer.accelerators.base_accelerator][INFO] - Training progress: step=52300/100000 (52.30%), epoch=1, lr=1e-05, speed=1.660 step/s, elapsed=08:45:10, eta=07:58:59 +[2026-04-15 14:20:37,713][trainer.accelerators.base_accelerator][INFO] - Training progress: step=52350/100000 (52.35%), epoch=1, lr=1e-05, speed=1.660 step/s, elapsed=08:45:28, eta=07:58:17 +[2026-04-15 14:20:55,426][trainer.accelerators.base_accelerator][INFO] - Training progress: step=52400/100000 (52.40%), epoch=1, lr=1e-05, speed=1.661 step/s, elapsed=08:45:46, eta=07:57:36 +[2026-04-15 14:21:13,306][trainer.accelerators.base_accelerator][INFO] - Training progress: step=52450/100000 (52.45%), epoch=1, lr=1e-05, speed=1.662 step/s, elapsed=08:46:03, eta=07:56:55 +[2026-04-15 14:21:31,210][trainer.accelerators.base_accelerator][INFO] - Training progress: step=52500/100000 (52.50%), epoch=1, lr=1e-05, speed=1.662 step/s, elapsed=08:46:21, eta=07:56:14 +[2026-04-15 14:21:49,046][trainer.accelerators.base_accelerator][INFO] - Training progress: step=52550/100000 (52.55%), epoch=1, lr=1e-05, speed=1.663 step/s, elapsed=08:46:39, eta=07:55:32 +[2026-04-15 14:22:06,871][trainer.accelerators.base_accelerator][INFO] - Training progress: step=52600/100000 (52.60%), epoch=1, lr=1e-05, speed=1.664 step/s, elapsed=08:46:57, eta=07:54:51 +[2026-04-15 14:22:24,762][trainer.accelerators.base_accelerator][INFO] - Training progress: step=52650/100000 (52.65%), epoch=1, lr=1e-05, speed=1.664 step/s, elapsed=08:47:15, eta=07:54:10 +[2026-04-15 14:22:42,677][trainer.accelerators.base_accelerator][INFO] - Training progress: step=52700/100000 (52.70%), epoch=1, lr=1e-05, speed=1.665 step/s, elapsed=08:47:33, eta=07:53:29 +[2026-04-15 14:23:00,566][trainer.accelerators.base_accelerator][INFO] - Training progress: step=52750/100000 (52.75%), epoch=1, lr=1e-05, speed=1.666 step/s, elapsed=08:47:51, eta=07:52:49 +[2026-04-15 14:23:18,398][trainer.accelerators.base_accelerator][INFO] - Training progress: step=52800/100000 (52.80%), epoch=1, lr=1e-05, speed=1.666 step/s, elapsed=08:48:09, eta=07:52:08 +[2026-04-15 14:23:36,277][trainer.accelerators.base_accelerator][INFO] - Training progress: step=52850/100000 (52.85%), epoch=1, lr=1e-05, speed=1.667 step/s, elapsed=08:48:26, eta=07:51:27 +[2026-04-15 14:23:54,129][trainer.accelerators.base_accelerator][INFO] - Training progress: step=52900/100000 (52.90%), epoch=1, lr=1e-05, speed=1.667 step/s, elapsed=08:48:44, eta=07:50:46 +[2026-04-15 14:24:11,985][trainer.accelerators.base_accelerator][INFO] - Training progress: step=52950/100000 (52.95%), epoch=1, lr=1e-05, speed=1.668 step/s, elapsed=08:49:02, eta=07:50:05 +[2026-04-15 14:24:29,826][trainer.accelerators.base_accelerator][INFO] - Training progress: step=53000/100000 (53.00%), epoch=1, lr=1e-05, speed=1.669 step/s, elapsed=08:49:20, eta=07:49:24 +[2026-04-15 14:24:29,851][__main__][INFO] - ========== EVAL START (periodic@gstep=53000) ========== +[2026-04-15 14:24:29,851][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-15 14:24:29,852][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 14:24:45,636][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.116059303283691, 'accuracy': 0.49176470588235294, 'num_samples': 425, 'test_unique_accuracy': 0.5115740740740741, 'test_unique_num_samples': 432} +[2026-04-15 14:24:45,637][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-15 14:24:45,637][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 14:25:00,721][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.116059303283691, 'accuracy': 0.49176470588235294, 'num_samples': 425, 'test_unique_accuracy': 0.4930555555555556, 'test_unique_num_samples': 432} +[2026-04-15 14:25:00,722][__main__][INFO] - ========== EVAL END (periodic@gstep=53000) ========== +[2026-04-15 14:25:00,722][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.115803718566895, 'accuracy': 0.49176470588235294, 'num_samples': 425, 'test_unique_accuracy': 0.4930555555555556, 'test_unique_num_samples': 432} +[2026-04-15 14:25:00,761][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.49176470588235294 is not better than 0.5788235294117647 of logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep32000, skipping checkpoint +[2026-04-15 14:25:18,638][trainer.accelerators.base_accelerator][INFO] - Training progress: step=53050/100000 (53.05%), epoch=1, lr=1e-05, speed=1.668 step/s, elapsed=08:50:09, eta=07:49:11 +[2026-04-15 14:25:36,494][trainer.accelerators.base_accelerator][INFO] - Training progress: step=53100/100000 (53.10%), epoch=1, lr=1e-05, speed=1.668 step/s, elapsed=08:50:27, eta=07:48:31 +[2026-04-15 14:25:54,388][trainer.accelerators.base_accelerator][INFO] - Training progress: step=53150/100000 (53.15%), epoch=1, lr=1e-05, speed=1.669 step/s, elapsed=08:50:45, eta=07:47:50 +[2026-04-15 14:26:12,326][trainer.accelerators.base_accelerator][INFO] - Training progress: step=53200/100000 (53.20%), epoch=1, lr=1e-05, speed=1.670 step/s, elapsed=08:51:03, eta=07:47:09 +[2026-04-15 14:26:30,244][trainer.accelerators.base_accelerator][INFO] - Training progress: step=53250/100000 (53.25%), epoch=1, lr=1e-05, speed=1.670 step/s, elapsed=08:51:20, eta=07:46:29 +[2026-04-15 14:26:48,113][trainer.accelerators.base_accelerator][INFO] - Training progress: step=53300/100000 (53.30%), epoch=1, lr=1e-05, speed=1.671 step/s, elapsed=08:51:38, eta=07:45:48 +[2026-04-15 14:27:05,988][trainer.accelerators.base_accelerator][INFO] - Training progress: step=53350/100000 (53.35%), epoch=1, lr=1e-05, speed=1.672 step/s, elapsed=08:51:56, eta=07:45:08 +[2026-04-15 14:27:23,831][trainer.accelerators.base_accelerator][INFO] - Training progress: step=53400/100000 (53.40%), epoch=1, lr=1e-05, speed=1.672 step/s, elapsed=08:52:14, eta=07:44:27 +[2026-04-15 14:27:41,709][trainer.accelerators.base_accelerator][INFO] - Training progress: step=53450/100000 (53.45%), epoch=1, lr=1e-05, speed=1.673 step/s, elapsed=08:52:32, eta=07:43:47 +[2026-04-15 14:27:59,543][trainer.accelerators.base_accelerator][INFO] - Training progress: step=53500/100000 (53.50%), epoch=1, lr=1e-05, speed=1.673 step/s, elapsed=08:52:50, eta=07:43:07 +[2026-04-15 14:28:17,454][trainer.accelerators.base_accelerator][INFO] - Training progress: step=53550/100000 (53.55%), epoch=1, lr=1e-05, speed=1.674 step/s, elapsed=08:53:08, eta=07:42:26 +[2026-04-15 14:28:35,289][trainer.accelerators.base_accelerator][INFO] - Training progress: step=53600/100000 (53.60%), epoch=1, lr=1e-05, speed=1.675 step/s, elapsed=08:53:25, eta=07:41:46 +[2026-04-15 14:28:53,220][trainer.accelerators.base_accelerator][INFO] - Training progress: step=53650/100000 (53.65%), epoch=1, lr=1e-05, speed=1.675 step/s, elapsed=08:53:43, eta=07:41:06 +[2026-04-15 14:29:11,000][trainer.accelerators.base_accelerator][INFO] - Training progress: step=53700/100000 (53.70%), epoch=1, lr=1e-05, speed=1.676 step/s, elapsed=08:54:01, eta=07:40:26 +[2026-04-15 14:29:28,891][trainer.accelerators.base_accelerator][INFO] - Training progress: step=53750/100000 (53.75%), epoch=1, lr=1e-05, speed=1.677 step/s, elapsed=08:54:19, eta=07:39:46 +[2026-04-15 14:29:46,717][trainer.accelerators.base_accelerator][INFO] - Training progress: step=53800/100000 (53.80%), epoch=1, lr=1e-05, speed=1.677 step/s, elapsed=08:54:37, eta=07:39:06 +[2026-04-15 14:30:04,627][trainer.accelerators.base_accelerator][INFO] - Training progress: step=53850/100000 (53.85%), epoch=1, lr=1e-05, speed=1.678 step/s, elapsed=08:54:55, eta=07:38:26 +[2026-04-15 14:30:22,421][trainer.accelerators.base_accelerator][INFO] - Training progress: step=53900/100000 (53.90%), epoch=1, lr=1e-05, speed=1.678 step/s, elapsed=08:55:13, eta=07:37:45 +[2026-04-15 14:30:40,300][trainer.accelerators.base_accelerator][INFO] - Training progress: step=53950/100000 (53.95%), epoch=1, lr=1e-05, speed=1.679 step/s, elapsed=08:55:30, eta=07:37:05 +[2026-04-15 14:30:58,129][trainer.accelerators.base_accelerator][INFO] - Training progress: step=54000/100000 (54.00%), epoch=1, lr=1e-05, speed=1.680 step/s, elapsed=08:55:48, eta=07:36:26 +[2026-04-15 14:30:58,153][__main__][INFO] - ========== EVAL START (periodic@gstep=54000) ========== +[2026-04-15 14:30:58,153][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-15 14:30:58,153][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 14:31:14,132][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.115803718566895, 'accuracy': 0.48705882352941177, 'num_samples': 425, 'test_unique_accuracy': 0.4930555555555556, 'test_unique_num_samples': 432} +[2026-04-15 14:31:14,133][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-15 14:31:14,133][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 14:31:29,620][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.115803718566895, 'accuracy': 0.48705882352941177, 'num_samples': 425, 'test_unique_accuracy': 0.4930555555555556, 'test_unique_num_samples': 432} +[2026-04-15 14:31:29,621][__main__][INFO] - ========== EVAL END (periodic@gstep=54000) ========== +[2026-04-15 14:31:29,621][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.118112564086914, 'accuracy': 0.48705882352941177, 'num_samples': 425, 'test_unique_accuracy': 0.4930555555555556, 'test_unique_num_samples': 432} +[2026-04-15 14:31:29,624][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.48705882352941177 is not better than 0.5788235294117647 of logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep32000, skipping checkpoint +[2026-04-15 14:31:47,448][trainer.accelerators.base_accelerator][INFO] - Training progress: step=54050/100000 (54.05%), epoch=1, lr=1e-05, speed=1.679 step/s, elapsed=08:56:38, eta=07:36:12 +[2026-04-15 14:32:05,286][trainer.accelerators.base_accelerator][INFO] - Training progress: step=54100/100000 (54.10%), epoch=1, lr=1e-05, speed=1.679 step/s, elapsed=08:56:55, eta=07:35:32 +[2026-04-15 14:32:23,139][trainer.accelerators.base_accelerator][INFO] - Training progress: step=54150/100000 (54.15%), epoch=1, lr=1e-05, speed=1.680 step/s, elapsed=08:57:13, eta=07:34:53 +[2026-04-15 14:32:40,987][trainer.accelerators.base_accelerator][INFO] - Training progress: step=54200/100000 (54.20%), epoch=1, lr=1e-05, speed=1.681 step/s, elapsed=08:57:31, eta=07:34:13 +[2026-04-15 14:32:58,849][trainer.accelerators.base_accelerator][INFO] - Training progress: step=54250/100000 (54.25%), epoch=1, lr=1e-05, speed=1.681 step/s, elapsed=08:57:49, eta=07:33:33 +[2026-04-15 14:33:16,717][trainer.accelerators.base_accelerator][INFO] - Training progress: step=54300/100000 (54.30%), epoch=1, lr=1e-05, speed=1.682 step/s, elapsed=08:58:07, eta=07:32:53 +[2026-04-15 14:33:34,585][trainer.accelerators.base_accelerator][INFO] - Training progress: step=54350/100000 (54.35%), epoch=1, lr=1e-05, speed=1.682 step/s, elapsed=08:58:25, eta=07:32:14 +[2026-04-15 14:33:52,484][trainer.accelerators.base_accelerator][INFO] - Training progress: step=54400/100000 (54.40%), epoch=1, lr=1e-05, speed=1.683 step/s, elapsed=08:58:43, eta=07:31:34 +[2026-04-15 14:34:10,245][trainer.accelerators.base_accelerator][INFO] - Training progress: step=54450/100000 (54.45%), epoch=1, lr=1e-05, speed=1.684 step/s, elapsed=08:59:00, eta=07:30:54 +[2026-04-15 14:34:28,099][trainer.accelerators.base_accelerator][INFO] - Training progress: step=54500/100000 (54.50%), epoch=1, lr=1e-05, speed=1.684 step/s, elapsed=08:59:18, eta=07:30:15 +[2026-04-15 14:34:45,865][trainer.accelerators.base_accelerator][INFO] - Training progress: step=54550/100000 (54.55%), epoch=1, lr=1e-05, speed=1.685 step/s, elapsed=08:59:36, eta=07:29:35 +[2026-04-15 14:35:03,745][trainer.accelerators.base_accelerator][INFO] - Training progress: step=54600/100000 (54.60%), epoch=1, lr=1e-05, speed=1.685 step/s, elapsed=08:59:54, eta=07:28:56 +[2026-04-15 14:35:21,594][trainer.accelerators.base_accelerator][INFO] - Training progress: step=54650/100000 (54.65%), epoch=1, lr=1e-05, speed=1.686 step/s, elapsed=09:00:12, eta=07:28:16 +[2026-04-15 14:35:39,536][trainer.accelerators.base_accelerator][INFO] - Training progress: step=54700/100000 (54.70%), epoch=1, lr=1e-05, speed=1.687 step/s, elapsed=09:00:30, eta=07:27:37 +[2026-04-15 14:35:57,418][trainer.accelerators.base_accelerator][INFO] - Training progress: step=54750/100000 (54.75%), epoch=1, lr=1e-05, speed=1.687 step/s, elapsed=09:00:48, eta=07:26:57 +[2026-04-15 14:36:15,241][trainer.accelerators.base_accelerator][INFO] - Training progress: step=54800/100000 (54.80%), epoch=1, lr=1e-05, speed=1.688 step/s, elapsed=09:01:05, eta=07:26:18 +[2026-04-15 14:36:33,034][trainer.accelerators.base_accelerator][INFO] - Training progress: step=54850/100000 (54.85%), epoch=1, lr=1e-05, speed=1.689 step/s, elapsed=09:01:23, eta=07:25:39 +[2026-04-15 14:36:50,951][trainer.accelerators.base_accelerator][INFO] - Training progress: step=54900/100000 (54.90%), epoch=1, lr=1e-05, speed=1.689 step/s, elapsed=09:01:41, eta=07:24:59 +[2026-04-15 14:37:08,858][trainer.accelerators.base_accelerator][INFO] - Training progress: step=54950/100000 (54.95%), epoch=1, lr=1e-05, speed=1.690 step/s, elapsed=09:01:59, eta=07:24:20 +[2026-04-15 14:37:26,789][trainer.accelerators.base_accelerator][INFO] - Training progress: step=55000/100000 (55.00%), epoch=1, lr=1e-05, speed=1.690 step/s, elapsed=09:02:17, eta=07:23:41 +[2026-04-15 14:37:26,814][__main__][INFO] - ========== EVAL START (periodic@gstep=55000) ========== +[2026-04-15 14:37:26,814][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-15 14:37:26,815][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 14:37:42,090][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.118112564086914, 'accuracy': 0.4611764705882353, 'num_samples': 425, 'test_unique_accuracy': 0.4930555555555556, 'test_unique_num_samples': 432} +[2026-04-15 14:37:42,091][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-15 14:37:42,091][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 14:37:57,138][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.118112564086914, 'accuracy': 0.4611764705882353, 'num_samples': 425, 'test_unique_accuracy': 0.49074074074074076, 'test_unique_num_samples': 432} +[2026-04-15 14:37:57,138][__main__][INFO] - ========== EVAL END (periodic@gstep=55000) ========== +[2026-04-15 14:37:57,139][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.118658065795898, 'accuracy': 0.4611764705882353, 'num_samples': 425, 'test_unique_accuracy': 0.49074074074074076, 'test_unique_num_samples': 432} +[2026-04-15 14:37:57,142][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.4611764705882353 is not better than 0.5788235294117647 of logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep32000, skipping checkpoint +[2026-04-15 14:38:15,018][trainer.accelerators.base_accelerator][INFO] - Training progress: step=55050/100000 (55.05%), epoch=1, lr=1e-05, speed=1.689 step/s, elapsed=09:03:05, eta=07:23:27 +[2026-04-15 14:38:33,165][trainer.accelerators.base_accelerator][INFO] - Training progress: step=55100/100000 (55.10%), epoch=1, lr=1e-05, speed=1.690 step/s, elapsed=09:03:23, eta=07:22:48 +[2026-04-15 14:38:51,005][trainer.accelerators.base_accelerator][INFO] - Training progress: step=55150/100000 (55.15%), epoch=1, lr=1e-05, speed=1.691 step/s, elapsed=09:03:41, eta=07:22:09 +[2026-04-15 14:39:08,923][trainer.accelerators.base_accelerator][INFO] - Training progress: step=55200/100000 (55.20%), epoch=1, lr=1e-05, speed=1.691 step/s, elapsed=09:03:59, eta=07:21:30 +[2026-04-15 14:39:26,822][trainer.accelerators.base_accelerator][INFO] - Training progress: step=55250/100000 (55.25%), epoch=1, lr=1e-05, speed=1.692 step/s, elapsed=09:04:17, eta=07:20:51 +[2026-04-15 14:39:44,665][trainer.accelerators.base_accelerator][INFO] - Training progress: step=55300/100000 (55.30%), epoch=1, lr=1e-05, speed=1.692 step/s, elapsed=09:04:35, eta=07:20:12 +[2026-04-15 14:40:02,416][trainer.accelerators.base_accelerator][INFO] - Training progress: step=55350/100000 (55.35%), epoch=1, lr=1e-05, speed=1.693 step/s, elapsed=09:04:53, eta=07:19:33 +[2026-04-15 14:40:20,279][trainer.accelerators.base_accelerator][INFO] - Training progress: step=55400/100000 (55.40%), epoch=1, lr=1e-05, speed=1.694 step/s, elapsed=09:05:10, eta=07:18:54 +[2026-04-15 14:40:38,077][trainer.accelerators.base_accelerator][INFO] - Training progress: step=55450/100000 (55.45%), epoch=1, lr=1e-05, speed=1.694 step/s, elapsed=09:05:28, eta=07:18:15 +[2026-04-15 14:40:55,921][trainer.accelerators.base_accelerator][INFO] - Training progress: step=55500/100000 (55.50%), epoch=1, lr=1e-05, speed=1.695 step/s, elapsed=09:05:46, eta=07:17:36 +[2026-04-15 14:41:13,760][trainer.accelerators.base_accelerator][INFO] - Training progress: step=55550/100000 (55.55%), epoch=1, lr=1e-05, speed=1.695 step/s, elapsed=09:06:04, eta=07:16:57 +[2026-04-15 14:41:31,604][trainer.accelerators.base_accelerator][INFO] - Training progress: step=55600/100000 (55.60%), epoch=1, lr=1e-05, speed=1.696 step/s, elapsed=09:06:22, eta=07:16:18 +[2026-04-15 14:41:49,423][trainer.accelerators.base_accelerator][INFO] - Training progress: step=55650/100000 (55.65%), epoch=1, lr=1e-05, speed=1.697 step/s, elapsed=09:06:40, eta=07:15:39 +[2026-04-15 14:42:07,202][trainer.accelerators.base_accelerator][INFO] - Training progress: step=55700/100000 (55.70%), epoch=1, lr=1e-05, speed=1.697 step/s, elapsed=09:06:57, eta=07:15:01 +[2026-04-15 14:42:25,056][trainer.accelerators.base_accelerator][INFO] - Training progress: step=55750/100000 (55.75%), epoch=1, lr=1e-05, speed=1.698 step/s, elapsed=09:07:15, eta=07:14:22 +[2026-04-15 14:42:43,131][trainer.accelerators.base_accelerator][INFO] - Training progress: step=55800/100000 (55.80%), epoch=1, lr=1e-05, speed=1.698 step/s, elapsed=09:07:33, eta=07:13:43 +[2026-04-15 14:43:01,017][trainer.accelerators.base_accelerator][INFO] - Training progress: step=55850/100000 (55.85%), epoch=1, lr=1e-05, speed=1.699 step/s, elapsed=09:07:51, eta=07:13:05 +[2026-04-15 14:43:18,879][trainer.accelerators.base_accelerator][INFO] - Training progress: step=55900/100000 (55.90%), epoch=1, lr=1e-05, speed=1.700 step/s, elapsed=09:08:09, eta=07:12:26 +[2026-04-15 14:43:36,792][trainer.accelerators.base_accelerator][INFO] - Training progress: step=55950/100000 (55.95%), epoch=1, lr=1e-05, speed=1.700 step/s, elapsed=09:08:27, eta=07:11:48 +[2026-04-15 14:43:54,641][trainer.accelerators.base_accelerator][INFO] - Training progress: step=56000/100000 (56.00%), epoch=1, lr=1e-05, speed=1.701 step/s, elapsed=09:08:45, eta=07:11:09 +[2026-04-15 14:43:54,666][__main__][INFO] - ========== EVAL START (periodic@gstep=56000) ========== +[2026-04-15 14:43:54,666][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-15 14:43:54,666][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 14:44:13,245][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.118658065795898, 'accuracy': 0.5152941176470588, 'num_samples': 425, 'test_unique_accuracy': 0.49074074074074076, 'test_unique_num_samples': 432} +[2026-04-15 14:44:13,245][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-15 14:44:13,245][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 14:44:28,358][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.118658065795898, 'accuracy': 0.5152941176470588, 'num_samples': 425, 'test_unique_accuracy': 0.47453703703703703, 'test_unique_num_samples': 432} +[2026-04-15 14:44:28,358][__main__][INFO] - ========== EVAL END (periodic@gstep=56000) ========== +[2026-04-15 14:44:28,358][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.120512008666992, 'accuracy': 0.5152941176470588, 'num_samples': 425, 'test_unique_accuracy': 0.47453703703703703, 'test_unique_num_samples': 432} +[2026-04-15 14:44:28,371][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.5152941176470588 is not better than 0.5788235294117647 of logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep32000, skipping checkpoint +[2026-04-15 14:44:46,269][trainer.accelerators.base_accelerator][INFO] - Training progress: step=56050/100000 (56.05%), epoch=1, lr=1e-05, speed=1.700 step/s, elapsed=09:09:36, eta=07:10:57 +[2026-04-15 14:45:04,133][trainer.accelerators.base_accelerator][INFO] - Training progress: step=56100/100000 (56.10%), epoch=1, lr=1e-05, speed=1.700 step/s, elapsed=09:09:54, eta=07:10:19 +[2026-04-15 14:45:22,257][trainer.accelerators.base_accelerator][INFO] - Training progress: step=56150/100000 (56.15%), epoch=1, lr=1e-05, speed=1.701 step/s, elapsed=09:10:12, eta=07:09:41 +[2026-04-15 14:45:40,164][trainer.accelerators.base_accelerator][INFO] - Training progress: step=56200/100000 (56.20%), epoch=1, lr=1e-05, speed=1.701 step/s, elapsed=09:10:30, eta=07:09:02 +[2026-04-15 14:45:58,053][trainer.accelerators.base_accelerator][INFO] - Training progress: step=56250/100000 (56.25%), epoch=1, lr=1e-05, speed=1.702 step/s, elapsed=09:10:48, eta=07:08:24 +[2026-04-15 14:46:15,851][trainer.accelerators.base_accelerator][INFO] - Training progress: step=56300/100000 (56.30%), epoch=1, lr=1e-05, speed=1.703 step/s, elapsed=09:11:06, eta=07:07:46 +[2026-04-15 14:46:33,706][trainer.accelerators.base_accelerator][INFO] - Training progress: step=56350/100000 (56.35%), epoch=1, lr=1e-05, speed=1.703 step/s, elapsed=09:11:24, eta=07:07:07 +[2026-04-15 14:46:51,556][trainer.accelerators.base_accelerator][INFO] - Training progress: step=56400/100000 (56.40%), epoch=1, lr=1e-05, speed=1.704 step/s, elapsed=09:11:42, eta=07:06:29 +[2026-04-15 14:47:09,403][trainer.accelerators.base_accelerator][INFO] - Training progress: step=56450/100000 (56.45%), epoch=1, lr=1e-05, speed=1.704 step/s, elapsed=09:12:00, eta=07:05:51 +[2026-04-15 14:47:27,275][trainer.accelerators.base_accelerator][INFO] - Training progress: step=56500/100000 (56.50%), epoch=1, lr=1e-05, speed=1.705 step/s, elapsed=09:12:17, eta=07:05:13 +[2026-04-15 14:47:45,039][trainer.accelerators.base_accelerator][INFO] - Training progress: step=56550/100000 (56.55%), epoch=1, lr=1e-05, speed=1.706 step/s, elapsed=09:12:35, eta=07:04:35 +[2026-04-15 14:48:02,900][trainer.accelerators.base_accelerator][INFO] - Training progress: step=56600/100000 (56.60%), epoch=1, lr=1e-05, speed=1.706 step/s, elapsed=09:12:53, eta=07:03:56 +[2026-04-15 14:48:20,779][trainer.accelerators.base_accelerator][INFO] - Training progress: step=56650/100000 (56.65%), epoch=1, lr=1e-05, speed=1.707 step/s, elapsed=09:13:11, eta=07:03:18 +[2026-04-15 14:48:38,620][trainer.accelerators.base_accelerator][INFO] - Training progress: step=56700/100000 (56.70%), epoch=1, lr=1e-05, speed=1.707 step/s, elapsed=09:13:29, eta=07:02:40 +[2026-04-15 14:48:56,493][trainer.accelerators.base_accelerator][INFO] - Training progress: step=56750/100000 (56.75%), epoch=1, lr=1e-05, speed=1.708 step/s, elapsed=09:13:47, eta=07:02:02 +[2026-04-15 14:49:14,363][trainer.accelerators.base_accelerator][INFO] - Training progress: step=56800/100000 (56.80%), epoch=1, lr=1e-05, speed=1.709 step/s, elapsed=09:14:05, eta=07:01:24 +[2026-04-15 14:49:32,166][trainer.accelerators.base_accelerator][INFO] - Training progress: step=56850/100000 (56.85%), epoch=1, lr=1e-05, speed=1.709 step/s, elapsed=09:14:22, eta=07:00:47 +[2026-04-15 14:49:50,030][trainer.accelerators.base_accelerator][INFO] - Training progress: step=56900/100000 (56.90%), epoch=1, lr=1e-05, speed=1.710 step/s, elapsed=09:14:40, eta=07:00:09 +[2026-04-15 14:50:07,861][trainer.accelerators.base_accelerator][INFO] - Training progress: step=56950/100000 (56.95%), epoch=1, lr=1e-05, speed=1.710 step/s, elapsed=09:14:58, eta=06:59:31 +[2026-04-15 14:50:25,679][trainer.accelerators.base_accelerator][INFO] - Training progress: step=57000/100000 (57.00%), epoch=1, lr=1e-05, speed=1.711 step/s, elapsed=09:15:16, eta=06:58:53 +[2026-04-15 14:50:25,703][__main__][INFO] - ========== EVAL START (periodic@gstep=57000) ========== +[2026-04-15 14:50:25,703][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-15 14:50:25,704][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 14:50:41,003][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.120512008666992, 'accuracy': 0.49176470588235294, 'num_samples': 425, 'test_unique_accuracy': 0.47453703703703703, 'test_unique_num_samples': 432} +[2026-04-15 14:50:41,003][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-15 14:50:41,003][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 14:50:56,118][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.120512008666992, 'accuracy': 0.49176470588235294, 'num_samples': 425, 'test_unique_accuracy': 0.47453703703703703, 'test_unique_num_samples': 432} +[2026-04-15 14:50:56,118][__main__][INFO] - ========== EVAL END (periodic@gstep=57000) ========== +[2026-04-15 14:50:56,118][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.12329387664795, 'accuracy': 0.49176470588235294, 'num_samples': 425, 'test_unique_accuracy': 0.47453703703703703, 'test_unique_num_samples': 432} +[2026-04-15 14:50:56,122][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.49176470588235294 is not better than 0.5788235294117647 of logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep32000, skipping checkpoint +[2026-04-15 14:51:14,023][trainer.accelerators.base_accelerator][INFO] - Training progress: step=57050/100000 (57.05%), epoch=1, lr=1e-05, speed=1.710 step/s, elapsed=09:16:04, eta=06:58:38 +[2026-04-15 14:51:31,879][trainer.accelerators.base_accelerator][INFO] - Training progress: step=57100/100000 (57.10%), epoch=1, lr=1e-05, speed=1.710 step/s, elapsed=09:16:22, eta=06:58:00 +[2026-04-15 14:51:49,722][trainer.accelerators.base_accelerator][INFO] - Training progress: step=57150/100000 (57.15%), epoch=1, lr=1e-05, speed=1.711 step/s, elapsed=09:16:40, eta=06:57:22 +[2026-04-15 14:52:07,473][trainer.accelerators.base_accelerator][INFO] - Training progress: step=57200/100000 (57.20%), epoch=1, lr=1e-05, speed=1.712 step/s, elapsed=09:16:58, eta=06:56:45 +[2026-04-15 14:52:25,708][trainer.accelerators.base_accelerator][INFO] - Training progress: step=57250/100000 (57.25%), epoch=1, lr=1e-05, speed=1.712 step/s, elapsed=09:17:16, eta=06:56:07 +[2026-04-15 14:52:43,637][trainer.accelerators.base_accelerator][INFO] - Training progress: step=57300/100000 (57.30%), epoch=1, lr=1e-05, speed=1.713 step/s, elapsed=09:17:34, eta=06:55:30 +[2026-04-15 14:53:01,512][trainer.accelerators.base_accelerator][INFO] - Training progress: step=57350/100000 (57.35%), epoch=1, lr=1e-05, speed=1.713 step/s, elapsed=09:17:52, eta=06:54:52 +[2026-04-15 14:53:19,376][trainer.accelerators.base_accelerator][INFO] - Training progress: step=57400/100000 (57.40%), epoch=1, lr=1e-05, speed=1.714 step/s, elapsed=09:18:10, eta=06:54:14 +[2026-04-15 14:53:37,264][trainer.accelerators.base_accelerator][INFO] - Training progress: step=57450/100000 (57.45%), epoch=1, lr=1e-05, speed=1.715 step/s, elapsed=09:18:27, eta=06:53:37 +[2026-04-15 14:53:55,088][trainer.accelerators.base_accelerator][INFO] - Training progress: step=57500/100000 (57.50%), epoch=1, lr=1e-05, speed=1.715 step/s, elapsed=09:18:45, eta=06:52:59 +[2026-04-15 14:54:12,947][trainer.accelerators.base_accelerator][INFO] - Training progress: step=57550/100000 (57.55%), epoch=1, lr=1e-05, speed=1.716 step/s, elapsed=09:19:03, eta=06:52:22 +[2026-04-15 14:54:30,835][trainer.accelerators.base_accelerator][INFO] - Training progress: step=57600/100000 (57.60%), epoch=1, lr=1e-05, speed=1.716 step/s, elapsed=09:19:21, eta=06:51:45 +[2026-04-15 14:54:48,758][trainer.accelerators.base_accelerator][INFO] - Training progress: step=57650/100000 (57.65%), epoch=1, lr=1e-05, speed=1.717 step/s, elapsed=09:19:39, eta=06:51:07 +[2026-04-15 14:55:06,706][trainer.accelerators.base_accelerator][INFO] - Training progress: step=57700/100000 (57.70%), epoch=1, lr=1e-05, speed=1.717 step/s, elapsed=09:19:57, eta=06:50:30 +[2026-04-15 14:55:24,521][trainer.accelerators.base_accelerator][INFO] - Training progress: step=57750/100000 (57.75%), epoch=1, lr=1e-05, speed=1.718 step/s, elapsed=09:20:15, eta=06:49:52 +[2026-04-15 14:55:42,376][trainer.accelerators.base_accelerator][INFO] - Training progress: step=57800/100000 (57.80%), epoch=1, lr=1e-05, speed=1.719 step/s, elapsed=09:20:33, eta=06:49:15 +[2026-04-15 14:56:00,216][trainer.accelerators.base_accelerator][INFO] - Training progress: step=57850/100000 (57.85%), epoch=1, lr=1e-05, speed=1.719 step/s, elapsed=09:20:50, eta=06:48:38 +[2026-04-15 14:56:18,064][trainer.accelerators.base_accelerator][INFO] - Training progress: step=57900/100000 (57.90%), epoch=1, lr=1e-05, speed=1.720 step/s, elapsed=09:21:08, eta=06:48:01 +[2026-04-15 14:56:35,979][trainer.accelerators.base_accelerator][INFO] - Training progress: step=57950/100000 (57.95%), epoch=1, lr=1e-05, speed=1.720 step/s, elapsed=09:21:26, eta=06:47:23 +[2026-04-15 14:56:53,713][trainer.accelerators.base_accelerator][INFO] - Training progress: step=58000/100000 (58.00%), epoch=1, lr=1e-05, speed=1.721 step/s, elapsed=09:21:44, eta=06:46:46 +[2026-04-15 14:56:53,738][__main__][INFO] - ========== EVAL START (periodic@gstep=58000) ========== +[2026-04-15 14:56:53,739][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-15 14:56:53,739][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 14:57:09,822][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.12329387664795, 'accuracy': 0.4823529411764706, 'num_samples': 425, 'test_unique_accuracy': 0.47453703703703703, 'test_unique_num_samples': 432} +[2026-04-15 14:57:09,822][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-15 14:57:09,823][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 14:57:25,055][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.12329387664795, 'accuracy': 0.4823529411764706, 'num_samples': 425, 'test_unique_accuracy': 0.5277777777777778, 'test_unique_num_samples': 432} +[2026-04-15 14:57:25,055][__main__][INFO] - ========== EVAL END (periodic@gstep=58000) ========== +[2026-04-15 14:57:25,055][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.118573188781738, 'accuracy': 0.4823529411764706, 'num_samples': 425, 'test_unique_accuracy': 0.5277777777777778, 'test_unique_num_samples': 432} +[2026-04-15 14:57:25,059][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.4823529411764706 is not better than 0.5788235294117647 of logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep32000, skipping checkpoint +[2026-04-15 14:57:42,776][trainer.accelerators.base_accelerator][INFO] - Training progress: step=58050/100000 (58.05%), epoch=1, lr=1e-05, speed=1.720 step/s, elapsed=09:22:33, eta=06:46:32 +[2026-04-15 14:58:00,641][trainer.accelerators.base_accelerator][INFO] - Training progress: step=58100/100000 (58.10%), epoch=1, lr=1e-05, speed=1.720 step/s, elapsed=09:22:51, eta=06:45:54 +[2026-04-15 14:58:18,497][trainer.accelerators.base_accelerator][INFO] - Training progress: step=58150/100000 (58.15%), epoch=1, lr=1e-05, speed=1.721 step/s, elapsed=09:23:09, eta=06:45:17 +[2026-04-15 14:58:36,358][trainer.accelerators.base_accelerator][INFO] - Training progress: step=58200/100000 (58.20%), epoch=1, lr=1e-05, speed=1.722 step/s, elapsed=09:23:27, eta=06:44:40 +[2026-04-15 14:58:54,236][trainer.accelerators.base_accelerator][INFO] - Training progress: step=58250/100000 (58.25%), epoch=1, lr=1e-05, speed=1.722 step/s, elapsed=09:23:44, eta=06:44:03 +[2026-04-15 14:59:12,171][trainer.accelerators.base_accelerator][INFO] - Training progress: step=58300/100000 (58.30%), epoch=1, lr=1e-05, speed=1.723 step/s, elapsed=09:24:02, eta=06:43:26 +[2026-04-15 14:59:30,440][trainer.accelerators.base_accelerator][INFO] - Training progress: step=58350/100000 (58.35%), epoch=1, lr=1e-05, speed=1.723 step/s, elapsed=09:24:21, eta=06:42:49 +[2026-04-15 14:59:48,237][trainer.accelerators.base_accelerator][INFO] - Training progress: step=58400/100000 (58.40%), epoch=1, lr=1e-05, speed=1.724 step/s, elapsed=09:24:38, eta=06:42:12 +[2026-04-15 15:00:06,101][trainer.accelerators.base_accelerator][INFO] - Training progress: step=58450/100000 (58.45%), epoch=1, lr=1e-05, speed=1.724 step/s, elapsed=09:24:56, eta=06:41:36 +[2026-04-15 15:00:23,932][trainer.accelerators.base_accelerator][INFO] - Training progress: step=58500/100000 (58.50%), epoch=1, lr=1e-05, speed=1.725 step/s, elapsed=09:25:14, eta=06:40:59 +[2026-04-15 15:00:41,787][trainer.accelerators.base_accelerator][INFO] - Training progress: step=58550/100000 (58.55%), epoch=1, lr=1e-05, speed=1.725 step/s, elapsed=09:25:32, eta=06:40:22 +[2026-04-15 15:00:59,648][trainer.accelerators.base_accelerator][INFO] - Training progress: step=58600/100000 (58.60%), epoch=1, lr=1e-05, speed=1.726 step/s, elapsed=09:25:50, eta=06:39:45 +[2026-04-15 15:01:17,469][trainer.accelerators.base_accelerator][INFO] - Training progress: step=58650/100000 (58.65%), epoch=1, lr=1e-05, speed=1.727 step/s, elapsed=09:26:08, eta=06:39:08 +[2026-04-15 15:01:35,295][trainer.accelerators.base_accelerator][INFO] - Training progress: step=58700/100000 (58.70%), epoch=1, lr=1e-05, speed=1.727 step/s, elapsed=09:26:25, eta=06:38:31 +[2026-04-15 15:01:53,225][trainer.accelerators.base_accelerator][INFO] - Training progress: step=58750/100000 (58.75%), epoch=1, lr=1e-05, speed=1.728 step/s, elapsed=09:26:43, eta=06:37:55 +[2026-04-15 15:02:11,109][trainer.accelerators.base_accelerator][INFO] - Training progress: step=58800/100000 (58.80%), epoch=1, lr=1e-05, speed=1.728 step/s, elapsed=09:27:01, eta=06:37:18 +[2026-04-15 15:02:28,972][trainer.accelerators.base_accelerator][INFO] - Training progress: step=58850/100000 (58.85%), epoch=1, lr=1e-05, speed=1.729 step/s, elapsed=09:27:19, eta=06:36:41 +[2026-04-15 15:02:46,839][trainer.accelerators.base_accelerator][INFO] - Training progress: step=58900/100000 (58.90%), epoch=1, lr=1e-05, speed=1.729 step/s, elapsed=09:27:37, eta=06:36:05 +[2026-04-15 15:03:04,733][trainer.accelerators.base_accelerator][INFO] - Training progress: step=58950/100000 (58.95%), epoch=1, lr=1e-05, speed=1.730 step/s, elapsed=09:27:55, eta=06:35:28 +[2026-04-15 15:03:22,612][trainer.accelerators.base_accelerator][INFO] - Training progress: step=59000/100000 (59.00%), epoch=1, lr=1e-05, speed=1.731 step/s, elapsed=09:28:13, eta=06:34:51 +[2026-04-15 15:03:22,636][__main__][INFO] - ========== EVAL START (periodic@gstep=59000) ========== +[2026-04-15 15:03:22,636][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-15 15:03:22,636][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 15:03:37,777][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.118573188781738, 'accuracy': 0.4823529411764706, 'num_samples': 425, 'test_unique_accuracy': 0.5277777777777778, 'test_unique_num_samples': 432} +[2026-04-15 15:03:37,778][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-15 15:03:37,778][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 15:03:52,901][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.118573188781738, 'accuracy': 0.4823529411764706, 'num_samples': 425, 'test_unique_accuracy': 0.4699074074074074, 'test_unique_num_samples': 432} +[2026-04-15 15:03:52,902][__main__][INFO] - ========== EVAL END (periodic@gstep=59000) ========== +[2026-04-15 15:03:52,902][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.115938186645508, 'accuracy': 0.4823529411764706, 'num_samples': 425, 'test_unique_accuracy': 0.4699074074074074, 'test_unique_num_samples': 432} +[2026-04-15 15:03:52,905][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.4823529411764706 is not better than 0.5788235294117647 of logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep32000, skipping checkpoint +[2026-04-15 15:04:10,791][trainer.accelerators.base_accelerator][INFO] - Training progress: step=59050/100000 (59.05%), epoch=1, lr=1e-05, speed=1.730 step/s, elapsed=09:29:01, eta=06:34:36 +[2026-04-15 15:04:28,688][trainer.accelerators.base_accelerator][INFO] - Training progress: step=59100/100000 (59.10%), epoch=1, lr=1e-05, speed=1.730 step/s, elapsed=09:29:19, eta=06:33:59 +[2026-04-15 15:04:46,594][trainer.accelerators.base_accelerator][INFO] - Training progress: step=59150/100000 (59.15%), epoch=1, lr=1e-05, speed=1.731 step/s, elapsed=09:29:37, eta=06:33:23 +[2026-04-15 15:05:04,416][trainer.accelerators.base_accelerator][INFO] - Training progress: step=59200/100000 (59.20%), epoch=1, lr=1e-05, speed=1.731 step/s, elapsed=09:29:55, eta=06:32:46 +[2026-04-15 15:05:22,326][trainer.accelerators.base_accelerator][INFO] - Training progress: step=59250/100000 (59.25%), epoch=1, lr=1e-05, speed=1.732 step/s, elapsed=09:30:13, eta=06:32:10 +[2026-04-15 15:05:40,226][trainer.accelerators.base_accelerator][INFO] - Training progress: step=59300/100000 (59.30%), epoch=1, lr=1e-05, speed=1.732 step/s, elapsed=09:30:30, eta=06:31:34 +[2026-04-15 15:05:58,028][trainer.accelerators.base_accelerator][INFO] - Training progress: step=59350/100000 (59.35%), epoch=1, lr=1e-05, speed=1.733 step/s, elapsed=09:30:48, eta=06:30:57 +[2026-04-15 15:06:15,929][trainer.accelerators.base_accelerator][INFO] - Training progress: step=59400/100000 (59.40%), epoch=1, lr=1e-05, speed=1.733 step/s, elapsed=09:31:06, eta=06:30:21 +[2026-04-15 15:06:34,058][trainer.accelerators.base_accelerator][INFO] - Training progress: step=59450/100000 (59.45%), epoch=1, lr=1e-05, speed=1.734 step/s, elapsed=09:31:24, eta=06:29:45 +[2026-04-15 15:06:51,934][trainer.accelerators.base_accelerator][INFO] - Training progress: step=59500/100000 (59.50%), epoch=1, lr=1e-05, speed=1.735 step/s, elapsed=09:31:42, eta=06:29:08 +[2026-04-15 15:07:09,658][trainer.accelerators.base_accelerator][INFO] - Training progress: step=59550/100000 (59.55%), epoch=1, lr=1e-05, speed=1.735 step/s, elapsed=09:32:00, eta=06:28:32 +[2026-04-15 15:07:27,504][trainer.accelerators.base_accelerator][INFO] - Training progress: step=59600/100000 (59.60%), epoch=1, lr=1e-05, speed=1.736 step/s, elapsed=09:32:18, eta=06:27:56 +[2026-04-15 15:07:45,328][trainer.accelerators.base_accelerator][INFO] - Training progress: step=59650/100000 (59.65%), epoch=1, lr=1e-05, speed=1.736 step/s, elapsed=09:32:36, eta=06:27:19 +[2026-04-15 15:08:03,048][trainer.accelerators.base_accelerator][INFO] - Training progress: step=59700/100000 (59.70%), epoch=1, lr=1e-05, speed=1.737 step/s, elapsed=09:32:53, eta=06:26:43 +[2026-04-15 15:08:20,877][trainer.accelerators.base_accelerator][INFO] - Training progress: step=59750/100000 (59.75%), epoch=1, lr=1e-05, speed=1.737 step/s, elapsed=09:33:11, eta=06:26:07 +[2026-04-15 15:08:38,775][trainer.accelerators.base_accelerator][INFO] - Training progress: step=59800/100000 (59.80%), epoch=1, lr=1e-05, speed=1.738 step/s, elapsed=09:33:29, eta=06:25:31 +[2026-04-15 15:08:56,696][trainer.accelerators.base_accelerator][INFO] - Training progress: step=59850/100000 (59.85%), epoch=1, lr=1e-05, speed=1.738 step/s, elapsed=09:33:47, eta=06:24:55 +[2026-04-15 15:09:14,467][trainer.accelerators.base_accelerator][INFO] - Training progress: step=59900/100000 (59.90%), epoch=1, lr=1e-05, speed=1.739 step/s, elapsed=09:34:05, eta=06:24:19 +[2026-04-15 15:09:32,321][trainer.accelerators.base_accelerator][INFO] - Training progress: step=59950/100000 (59.95%), epoch=1, lr=1e-05, speed=1.740 step/s, elapsed=09:34:23, eta=06:23:43 +[2026-04-15 15:09:50,114][trainer.accelerators.base_accelerator][INFO] - Training progress: step=60000/100000 (60.00%), epoch=1, lr=1e-05, speed=1.740 step/s, elapsed=09:34:40, eta=06:23:07 +[2026-04-15 15:09:50,137][__main__][INFO] - ========== EVAL START (periodic@gstep=60000) ========== +[2026-04-15 15:09:50,138][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-15 15:09:50,138][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 15:10:06,002][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.115938186645508, 'accuracy': 0.4988235294117647, 'num_samples': 425, 'test_unique_accuracy': 0.4699074074074074, 'test_unique_num_samples': 432} +[2026-04-15 15:10:06,003][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-15 15:10:06,003][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 15:10:21,157][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.115938186645508, 'accuracy': 0.4988235294117647, 'num_samples': 425, 'test_unique_accuracy': 0.5138888888888888, 'test_unique_num_samples': 432} +[2026-04-15 15:10:21,158][__main__][INFO] - ========== EVAL END (periodic@gstep=60000) ========== +[2026-04-15 15:10:21,158][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.116833686828613, 'accuracy': 0.4988235294117647, 'num_samples': 425, 'test_unique_accuracy': 0.5138888888888888, 'test_unique_num_samples': 432} +[2026-04-15 15:10:21,177][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.4988235294117647 is not better than 0.5788235294117647 of logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep32000, skipping checkpoint +[2026-04-15 15:10:39,102][trainer.accelerators.base_accelerator][INFO] - Training progress: step=60050/100000 (60.05%), epoch=1, lr=1e-05, speed=1.739 step/s, elapsed=09:35:29, eta=06:22:51 +[2026-04-15 15:10:56,994][trainer.accelerators.base_accelerator][INFO] - Training progress: step=60100/100000 (60.10%), epoch=1, lr=1e-05, speed=1.740 step/s, elapsed=09:35:47, eta=06:22:15 +[2026-04-15 15:11:14,788][trainer.accelerators.base_accelerator][INFO] - Training progress: step=60150/100000 (60.15%), epoch=1, lr=1e-05, speed=1.740 step/s, elapsed=09:36:05, eta=06:21:39 +[2026-04-15 15:11:32,633][trainer.accelerators.base_accelerator][INFO] - Training progress: step=60200/100000 (60.20%), epoch=1, lr=1e-05, speed=1.741 step/s, elapsed=09:36:23, eta=06:21:04 +[2026-04-15 15:11:50,498][trainer.accelerators.base_accelerator][INFO] - Training progress: step=60250/100000 (60.25%), epoch=1, lr=1e-05, speed=1.741 step/s, elapsed=09:36:41, eta=06:20:28 +[2026-04-15 15:12:08,342][trainer.accelerators.base_accelerator][INFO] - Training progress: step=60300/100000 (60.30%), epoch=1, lr=1e-05, speed=1.742 step/s, elapsed=09:36:59, eta=06:19:52 +[2026-04-15 15:12:26,186][trainer.accelerators.base_accelerator][INFO] - Training progress: step=60350/100000 (60.35%), epoch=1, lr=1e-05, speed=1.742 step/s, elapsed=09:37:16, eta=06:19:16 +[2026-04-15 15:12:44,066][trainer.accelerators.base_accelerator][INFO] - Training progress: step=60400/100000 (60.40%), epoch=1, lr=1e-05, speed=1.743 step/s, elapsed=09:37:34, eta=06:18:40 +[2026-04-15 15:13:01,939][trainer.accelerators.base_accelerator][INFO] - Training progress: step=60450/100000 (60.45%), epoch=1, lr=1e-05, speed=1.743 step/s, elapsed=09:37:52, eta=06:18:04 +[2026-04-15 15:13:20,036][trainer.accelerators.base_accelerator][INFO] - Training progress: step=60500/100000 (60.50%), epoch=1, lr=1e-05, speed=1.744 step/s, elapsed=09:38:10, eta=06:17:29 +[2026-04-15 15:13:37,913][trainer.accelerators.base_accelerator][INFO] - Training progress: step=60550/100000 (60.55%), epoch=1, lr=1e-05, speed=1.745 step/s, elapsed=09:38:28, eta=06:16:53 +[2026-04-15 15:13:55,757][trainer.accelerators.base_accelerator][INFO] - Training progress: step=60600/100000 (60.60%), epoch=1, lr=1e-05, speed=1.745 step/s, elapsed=09:38:46, eta=06:16:17 +[2026-04-15 15:14:13,667][trainer.accelerators.base_accelerator][INFO] - Training progress: step=60650/100000 (60.65%), epoch=1, lr=1e-05, speed=1.746 step/s, elapsed=09:39:04, eta=06:15:42 +[2026-04-15 15:14:31,489][trainer.accelerators.base_accelerator][INFO] - Training progress: step=60700/100000 (60.70%), epoch=1, lr=1e-05, speed=1.746 step/s, elapsed=09:39:22, eta=06:15:06 +[2026-04-15 15:14:49,315][trainer.accelerators.base_accelerator][INFO] - Training progress: step=60750/100000 (60.75%), epoch=1, lr=1e-05, speed=1.747 step/s, elapsed=09:39:39, eta=06:14:31 +[2026-04-15 15:15:07,153][trainer.accelerators.base_accelerator][INFO] - Training progress: step=60800/100000 (60.80%), epoch=1, lr=1e-05, speed=1.747 step/s, elapsed=09:39:57, eta=06:13:55 +[2026-04-15 15:15:24,962][trainer.accelerators.base_accelerator][INFO] - Training progress: step=60850/100000 (60.85%), epoch=1, lr=1e-05, speed=1.748 step/s, elapsed=09:40:15, eta=06:13:19 +[2026-04-15 15:15:42,794][trainer.accelerators.base_accelerator][INFO] - Training progress: step=60900/100000 (60.90%), epoch=1, lr=1e-05, speed=1.748 step/s, elapsed=09:40:33, eta=06:12:44 +[2026-04-15 15:16:00,624][trainer.accelerators.base_accelerator][INFO] - Training progress: step=60950/100000 (60.95%), epoch=1, lr=1e-05, speed=1.749 step/s, elapsed=09:40:51, eta=06:12:08 +[2026-04-15 15:16:18,475][trainer.accelerators.base_accelerator][INFO] - Training progress: step=61000/100000 (61.00%), epoch=1, lr=1e-05, speed=1.749 step/s, elapsed=09:41:09, eta=06:11:33 +[2026-04-15 15:16:18,499][__main__][INFO] - ========== EVAL START (periodic@gstep=61000) ========== +[2026-04-15 15:16:18,499][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-15 15:16:18,499][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 15:16:33,552][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.116833686828613, 'accuracy': 0.5270588235294118, 'num_samples': 425, 'test_unique_accuracy': 0.5138888888888888, 'test_unique_num_samples': 432} +[2026-04-15 15:16:33,552][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-15 15:16:33,552][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 15:16:48,649][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.116833686828613, 'accuracy': 0.5270588235294118, 'num_samples': 425, 'test_unique_accuracy': 0.5185185185185185, 'test_unique_num_samples': 432} +[2026-04-15 15:16:48,649][__main__][INFO] - ========== EVAL END (periodic@gstep=61000) ========== +[2026-04-15 15:16:48,649][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.115056037902832, 'accuracy': 0.5270588235294118, 'num_samples': 425, 'test_unique_accuracy': 0.5185185185185185, 'test_unique_num_samples': 432} +[2026-04-15 15:16:48,653][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.5270588235294118 is not better than 0.5788235294117647 of logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep32000, skipping checkpoint +[2026-04-15 15:17:06,424][trainer.accelerators.base_accelerator][INFO] - Training progress: step=61050/100000 (61.05%), epoch=1, lr=1e-05, speed=1.748 step/s, elapsed=09:41:57, eta=06:11:17 +[2026-04-15 15:17:24,113][trainer.accelerators.base_accelerator][INFO] - Training progress: step=61100/100000 (61.10%), epoch=1, lr=1e-05, speed=1.749 step/s, elapsed=09:42:14, eta=06:10:41 +[2026-04-15 15:17:41,922][trainer.accelerators.base_accelerator][INFO] - Training progress: step=61150/100000 (61.15%), epoch=1, lr=1e-05, speed=1.750 step/s, elapsed=09:42:32, eta=06:10:06 +[2026-04-15 15:17:59,675][trainer.accelerators.base_accelerator][INFO] - Training progress: step=61200/100000 (61.20%), epoch=1, lr=1e-05, speed=1.750 step/s, elapsed=09:42:50, eta=06:09:30 +[2026-04-15 15:18:17,512][trainer.accelerators.base_accelerator][INFO] - Training progress: step=61250/100000 (61.25%), epoch=1, lr=1e-05, speed=1.751 step/s, elapsed=09:43:08, eta=06:08:55 +[2026-04-15 15:18:35,255][trainer.accelerators.base_accelerator][INFO] - Training progress: step=61300/100000 (61.30%), epoch=1, lr=1e-05, speed=1.751 step/s, elapsed=09:43:25, eta=06:08:19 +[2026-04-15 15:18:53,059][trainer.accelerators.base_accelerator][INFO] - Training progress: step=61350/100000 (61.35%), epoch=1, lr=1e-05, speed=1.752 step/s, elapsed=09:43:43, eta=06:07:44 +[2026-04-15 15:19:10,854][trainer.accelerators.base_accelerator][INFO] - Training progress: step=61400/100000 (61.40%), epoch=1, lr=1e-05, speed=1.752 step/s, elapsed=09:44:01, eta=06:07:09 +[2026-04-15 15:19:28,682][trainer.accelerators.base_accelerator][INFO] - Training progress: step=61450/100000 (61.45%), epoch=1, lr=1e-05, speed=1.753 step/s, elapsed=09:44:19, eta=06:06:34 +[2026-04-15 15:19:46,463][trainer.accelerators.base_accelerator][INFO] - Training progress: step=61500/100000 (61.50%), epoch=1, lr=1e-05, speed=1.753 step/s, elapsed=09:44:37, eta=06:05:58 +[2026-04-15 15:20:04,240][trainer.accelerators.base_accelerator][INFO] - Training progress: step=61550/100000 (61.55%), epoch=1, lr=1e-05, speed=1.754 step/s, elapsed=09:44:54, eta=06:05:23 +[2026-04-15 15:20:22,423][trainer.accelerators.base_accelerator][INFO] - Training progress: step=61600/100000 (61.60%), epoch=1, lr=1e-05, speed=1.754 step/s, elapsed=09:45:13, eta=06:04:48 +[2026-04-15 15:20:40,242][trainer.accelerators.base_accelerator][INFO] - Training progress: step=61650/100000 (61.65%), epoch=1, lr=1e-05, speed=1.755 step/s, elapsed=09:45:30, eta=06:04:13 +[2026-04-15 15:20:58,152][trainer.accelerators.base_accelerator][INFO] - Training progress: step=61700/100000 (61.70%), epoch=1, lr=1e-05, speed=1.755 step/s, elapsed=09:45:48, eta=06:03:38 +[2026-04-15 15:21:15,933][trainer.accelerators.base_accelerator][INFO] - Training progress: step=61750/100000 (61.75%), epoch=1, lr=1e-05, speed=1.756 step/s, elapsed=09:46:06, eta=06:03:03 +[2026-04-15 15:21:33,784][trainer.accelerators.base_accelerator][INFO] - Training progress: step=61800/100000 (61.80%), epoch=1, lr=1e-05, speed=1.756 step/s, elapsed=09:46:24, eta=06:02:28 +[2026-04-15 15:21:51,650][trainer.accelerators.base_accelerator][INFO] - Training progress: step=61850/100000 (61.85%), epoch=1, lr=1e-05, speed=1.757 step/s, elapsed=09:46:42, eta=06:01:53 +[2026-04-15 15:22:09,535][trainer.accelerators.base_accelerator][INFO] - Training progress: step=61900/100000 (61.90%), epoch=1, lr=1e-05, speed=1.758 step/s, elapsed=09:47:00, eta=06:01:18 +[2026-04-15 15:22:27,334][trainer.accelerators.base_accelerator][INFO] - Training progress: step=61950/100000 (61.95%), epoch=1, lr=1e-05, speed=1.758 step/s, elapsed=09:47:18, eta=06:00:43 +[2026-04-15 15:22:45,185][trainer.accelerators.base_accelerator][INFO] - Training progress: step=62000/100000 (62.00%), epoch=1, lr=1e-05, speed=1.759 step/s, elapsed=09:47:35, eta=06:00:08 +[2026-04-15 15:22:45,210][__main__][INFO] - ========== EVAL START (periodic@gstep=62000) ========== +[2026-04-15 15:22:45,210][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-15 15:22:45,210][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 15:23:01,303][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.115056037902832, 'accuracy': 0.5011764705882353, 'num_samples': 425, 'test_unique_accuracy': 0.5185185185185185, 'test_unique_num_samples': 432} +[2026-04-15 15:23:01,304][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-15 15:23:01,304][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 15:23:16,464][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.115056037902832, 'accuracy': 0.5011764705882353, 'num_samples': 425, 'test_unique_accuracy': 0.4930555555555556, 'test_unique_num_samples': 432} +[2026-04-15 15:23:16,464][__main__][INFO] - ========== EVAL END (periodic@gstep=62000) ========== +[2026-04-15 15:23:16,464][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.11483097076416, 'accuracy': 0.5011764705882353, 'num_samples': 425, 'test_unique_accuracy': 0.4930555555555556, 'test_unique_num_samples': 432} +[2026-04-15 15:23:16,468][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.5011764705882353 is not better than 0.5788235294117647 of logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep32000, skipping checkpoint +[2026-04-15 15:23:34,317][trainer.accelerators.base_accelerator][INFO] - Training progress: step=62050/100000 (62.05%), epoch=1, lr=1e-05, speed=1.758 step/s, elapsed=09:48:25, eta=05:59:52 +[2026-04-15 15:23:52,241][trainer.accelerators.base_accelerator][INFO] - Training progress: step=62100/100000 (62.10%), epoch=1, lr=1e-05, speed=1.758 step/s, elapsed=09:48:42, eta=05:59:17 +[2026-04-15 15:24:10,141][trainer.accelerators.base_accelerator][INFO] - Training progress: step=62150/100000 (62.15%), epoch=1, lr=1e-05, speed=1.759 step/s, elapsed=09:49:00, eta=05:58:42 +[2026-04-15 15:24:28,014][trainer.accelerators.base_accelerator][INFO] - Training progress: step=62200/100000 (62.20%), epoch=1, lr=1e-05, speed=1.759 step/s, elapsed=09:49:18, eta=05:58:08 +[2026-04-15 15:24:45,864][trainer.accelerators.base_accelerator][INFO] - Training progress: step=62250/100000 (62.25%), epoch=1, lr=1e-05, speed=1.760 step/s, elapsed=09:49:36, eta=05:57:33 +[2026-04-15 15:25:03,680][trainer.accelerators.base_accelerator][INFO] - Training progress: step=62300/100000 (62.30%), epoch=1, lr=1e-05, speed=1.760 step/s, elapsed=09:49:54, eta=05:56:58 +[2026-04-15 15:25:21,464][trainer.accelerators.base_accelerator][INFO] - Training progress: step=62350/100000 (62.35%), epoch=1, lr=1e-05, speed=1.761 step/s, elapsed=09:50:12, eta=05:56:23 +[2026-04-15 15:25:39,260][trainer.accelerators.base_accelerator][INFO] - Training progress: step=62400/100000 (62.40%), epoch=1, lr=1e-05, speed=1.761 step/s, elapsed=09:50:29, eta=05:55:48 +[2026-04-15 15:25:57,116][trainer.accelerators.base_accelerator][INFO] - Training progress: step=62450/100000 (62.45%), epoch=1, lr=1e-05, speed=1.762 step/s, elapsed=09:50:47, eta=05:55:14 +[2026-04-15 15:26:15,045][trainer.accelerators.base_accelerator][INFO] - Training progress: step=62500/100000 (62.50%), epoch=1, lr=1e-05, speed=1.762 step/s, elapsed=09:51:05, eta=05:54:39 +[2026-04-15 15:26:32,879][trainer.accelerators.base_accelerator][INFO] - Training progress: step=62550/100000 (62.55%), epoch=1, lr=1e-05, speed=1.763 step/s, elapsed=09:51:23, eta=05:54:04 +[2026-04-15 15:26:50,687][trainer.accelerators.base_accelerator][INFO] - Training progress: step=62600/100000 (62.60%), epoch=1, lr=1e-05, speed=1.763 step/s, elapsed=09:51:41, eta=05:53:30 +[2026-04-15 15:27:08,497][trainer.accelerators.base_accelerator][INFO] - Training progress: step=62650/100000 (62.65%), epoch=1, lr=1e-05, speed=1.764 step/s, elapsed=09:51:59, eta=05:52:55 +[2026-04-15 15:27:26,752][trainer.accelerators.base_accelerator][INFO] - Training progress: step=62700/100000 (62.70%), epoch=1, lr=1e-05, speed=1.764 step/s, elapsed=09:52:17, eta=05:52:21 +[2026-04-15 15:27:44,560][trainer.accelerators.base_accelerator][INFO] - Training progress: step=62750/100000 (62.75%), epoch=1, lr=1e-05, speed=1.765 step/s, elapsed=09:52:35, eta=05:51:46 +[2026-04-15 15:28:02,372][trainer.accelerators.base_accelerator][INFO] - Training progress: step=62800/100000 (62.80%), epoch=1, lr=1e-05, speed=1.765 step/s, elapsed=09:52:53, eta=05:51:11 +[2026-04-15 15:28:20,145][trainer.accelerators.base_accelerator][INFO] - Training progress: step=62850/100000 (62.85%), epoch=1, lr=1e-05, speed=1.766 step/s, elapsed=09:53:10, eta=05:50:37 +[2026-04-15 15:28:38,002][trainer.accelerators.base_accelerator][INFO] - Training progress: step=62900/100000 (62.90%), epoch=1, lr=1e-05, speed=1.766 step/s, elapsed=09:53:28, eta=05:50:02 +[2026-04-15 15:28:55,888][trainer.accelerators.base_accelerator][INFO] - Training progress: step=62950/100000 (62.95%), epoch=1, lr=1e-05, speed=1.767 step/s, elapsed=09:53:46, eta=05:49:28 +[2026-04-15 15:29:13,663][trainer.accelerators.base_accelerator][INFO] - Training progress: step=63000/100000 (63.00%), epoch=1, lr=1e-05, speed=1.767 step/s, elapsed=09:54:04, eta=05:48:53 +[2026-04-15 15:29:13,686][__main__][INFO] - ========== EVAL START (periodic@gstep=63000) ========== +[2026-04-15 15:29:13,687][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-15 15:29:13,687][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 15:29:28,870][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.11483097076416, 'accuracy': 0.5364705882352941, 'num_samples': 425, 'test_unique_accuracy': 0.4930555555555556, 'test_unique_num_samples': 432} +[2026-04-15 15:29:28,870][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-15 15:29:28,870][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 15:29:43,954][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.11483097076416, 'accuracy': 0.5364705882352941, 'num_samples': 425, 'test_unique_accuracy': 0.4675925925925926, 'test_unique_num_samples': 432} +[2026-04-15 15:29:43,955][__main__][INFO] - ========== EVAL END (periodic@gstep=63000) ========== +[2026-04-15 15:29:43,955][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.108933448791504, 'accuracy': 0.5364705882352941, 'num_samples': 425, 'test_unique_accuracy': 0.4675925925925926, 'test_unique_num_samples': 432} +[2026-04-15 15:29:43,958][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.5364705882352941 is not better than 0.5788235294117647 of logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep32000, skipping checkpoint +[2026-04-15 15:30:01,742][trainer.accelerators.base_accelerator][INFO] - Training progress: step=63050/100000 (63.05%), epoch=1, lr=1e-05, speed=1.766 step/s, elapsed=09:54:52, eta=05:48:37 +[2026-04-15 15:30:19,533][trainer.accelerators.base_accelerator][INFO] - Training progress: step=63100/100000 (63.10%), epoch=1, lr=1e-05, speed=1.767 step/s, elapsed=09:55:10, eta=05:48:02 +[2026-04-15 15:30:37,307][trainer.accelerators.base_accelerator][INFO] - Training progress: step=63150/100000 (63.15%), epoch=1, lr=1e-05, speed=1.768 step/s, elapsed=09:55:27, eta=05:47:28 +[2026-04-15 15:30:55,107][trainer.accelerators.base_accelerator][INFO] - Training progress: step=63200/100000 (63.20%), epoch=1, lr=1e-05, speed=1.768 step/s, elapsed=09:55:45, eta=05:46:54 +[2026-04-15 15:31:12,966][trainer.accelerators.base_accelerator][INFO] - Training progress: step=63250/100000 (63.25%), epoch=1, lr=1e-05, speed=1.769 step/s, elapsed=09:56:03, eta=05:46:19 +[2026-04-15 15:31:30,807][trainer.accelerators.base_accelerator][INFO] - Training progress: step=63300/100000 (63.30%), epoch=1, lr=1e-05, speed=1.769 step/s, elapsed=09:56:21, eta=05:45:45 +[2026-04-15 15:31:48,585][trainer.accelerators.base_accelerator][INFO] - Training progress: step=63350/100000 (63.35%), epoch=1, lr=1e-05, speed=1.770 step/s, elapsed=09:56:39, eta=05:45:11 +[2026-04-15 15:32:06,382][trainer.accelerators.base_accelerator][INFO] - Training progress: step=63400/100000 (63.40%), epoch=1, lr=1e-05, speed=1.770 step/s, elapsed=09:56:57, eta=05:44:36 +[2026-04-15 15:32:24,214][trainer.accelerators.base_accelerator][INFO] - Training progress: step=63450/100000 (63.45%), epoch=1, lr=1e-05, speed=1.771 step/s, elapsed=09:57:14, eta=05:44:02 +[2026-04-15 15:32:42,066][trainer.accelerators.base_accelerator][INFO] - Training progress: step=63500/100000 (63.50%), epoch=1, lr=1e-05, speed=1.771 step/s, elapsed=09:57:32, eta=05:43:28 +[2026-04-15 15:32:59,936][trainer.accelerators.base_accelerator][INFO] - Training progress: step=63550/100000 (63.55%), epoch=1, lr=1e-05, speed=1.772 step/s, elapsed=09:57:50, eta=05:42:54 +[2026-04-15 15:33:17,757][trainer.accelerators.base_accelerator][INFO] - Training progress: step=63600/100000 (63.60%), epoch=1, lr=1e-05, speed=1.772 step/s, elapsed=09:58:08, eta=05:42:19 +[2026-04-15 15:33:35,633][trainer.accelerators.base_accelerator][INFO] - Training progress: step=63650/100000 (63.65%), epoch=1, lr=1e-05, speed=1.773 step/s, elapsed=09:58:26, eta=05:41:45 +[2026-04-15 15:33:53,548][trainer.accelerators.base_accelerator][INFO] - Training progress: step=63700/100000 (63.70%), epoch=1, lr=1e-05, speed=1.773 step/s, elapsed=09:58:44, eta=05:41:11 +[2026-04-15 15:34:11,730][trainer.accelerators.base_accelerator][INFO] - Training progress: step=63750/100000 (63.75%), epoch=1, lr=1e-05, speed=1.774 step/s, elapsed=09:59:02, eta=05:40:37 +[2026-04-15 15:34:29,555][trainer.accelerators.base_accelerator][INFO] - Training progress: step=63800/100000 (63.80%), epoch=1, lr=1e-05, speed=1.774 step/s, elapsed=09:59:20, eta=05:40:03 +[2026-04-15 15:34:47,402][trainer.accelerators.base_accelerator][INFO] - Training progress: step=63850/100000 (63.85%), epoch=1, lr=1e-05, speed=1.775 step/s, elapsed=09:59:38, eta=05:39:29 +[2026-04-15 15:35:05,288][trainer.accelerators.base_accelerator][INFO] - Training progress: step=63900/100000 (63.90%), epoch=1, lr=1e-05, speed=1.775 step/s, elapsed=09:59:55, eta=05:38:55 +[2026-04-15 15:35:23,096][trainer.accelerators.base_accelerator][INFO] - Training progress: step=63950/100000 (63.95%), epoch=1, lr=1e-05, speed=1.776 step/s, elapsed=10:00:13, eta=05:38:21 +[2026-04-15 15:35:40,950][trainer.accelerators.base_accelerator][INFO] - Training progress: step=64000/100000 (64.00%), epoch=1, lr=1e-05, speed=1.776 step/s, elapsed=10:00:31, eta=05:37:47 +[2026-04-15 15:35:40,974][__main__][INFO] - ========== EVAL START (periodic@gstep=64000) ========== +[2026-04-15 15:35:40,974][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-15 15:35:40,974][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 15:35:59,819][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.108933448791504, 'accuracy': 0.5223529411764706, 'num_samples': 425, 'test_unique_accuracy': 0.4675925925925926, 'test_unique_num_samples': 432} +[2026-04-15 15:35:59,820][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-15 15:35:59,820][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 15:36:14,939][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.108933448791504, 'accuracy': 0.5223529411764706, 'num_samples': 425, 'test_unique_accuracy': 0.5023148148148148, 'test_unique_num_samples': 432} +[2026-04-15 15:36:14,940][__main__][INFO] - ========== EVAL END (periodic@gstep=64000) ========== +[2026-04-15 15:36:14,940][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.113110542297363, 'accuracy': 0.5223529411764706, 'num_samples': 425, 'test_unique_accuracy': 0.5023148148148148, 'test_unique_num_samples': 432} +[2026-04-15 15:36:15,024][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.5223529411764706 is not better than 0.5788235294117647 of logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep32000, skipping checkpoint +[2026-04-15 15:36:32,950][trainer.accelerators.base_accelerator][INFO] - Training progress: step=64050/100000 (64.05%), epoch=1, lr=1e-05, speed=1.775 step/s, elapsed=10:01:23, eta=05:37:33 +[2026-04-15 15:36:50,841][trainer.accelerators.base_accelerator][INFO] - Training progress: step=64100/100000 (64.10%), epoch=1, lr=1e-05, speed=1.776 step/s, elapsed=10:01:41, eta=05:36:59 +[2026-04-15 15:37:08,628][trainer.accelerators.base_accelerator][INFO] - Training progress: step=64150/100000 (64.15%), epoch=1, lr=1e-05, speed=1.776 step/s, elapsed=10:01:59, eta=05:36:25 +[2026-04-15 15:37:26,425][trainer.accelerators.base_accelerator][INFO] - Training progress: step=64200/100000 (64.20%), epoch=1, lr=1e-05, speed=1.777 step/s, elapsed=10:02:17, eta=05:35:51 +[2026-04-15 15:37:44,321][trainer.accelerators.base_accelerator][INFO] - Training progress: step=64250/100000 (64.25%), epoch=1, lr=1e-05, speed=1.777 step/s, elapsed=10:02:35, eta=05:35:17 +[2026-04-15 15:38:02,172][trainer.accelerators.base_accelerator][INFO] - Training progress: step=64300/100000 (64.30%), epoch=1, lr=1e-05, speed=1.778 step/s, elapsed=10:02:52, eta=05:34:43 +[2026-04-15 15:38:20,048][trainer.accelerators.base_accelerator][INFO] - Training progress: step=64350/100000 (64.35%), epoch=1, lr=1e-05, speed=1.778 step/s, elapsed=10:03:10, eta=05:34:09 +[2026-04-15 15:38:37,919][trainer.accelerators.base_accelerator][INFO] - Training progress: step=64400/100000 (64.40%), epoch=1, lr=1e-05, speed=1.779 step/s, elapsed=10:03:28, eta=05:33:35 +[2026-04-15 15:38:55,783][trainer.accelerators.base_accelerator][INFO] - Training progress: step=64450/100000 (64.45%), epoch=1, lr=1e-05, speed=1.779 step/s, elapsed=10:03:46, eta=05:33:02 +[2026-04-15 15:39:13,624][trainer.accelerators.base_accelerator][INFO] - Training progress: step=64500/100000 (64.50%), epoch=1, lr=1e-05, speed=1.780 step/s, elapsed=10:04:04, eta=05:32:28 +[2026-04-15 15:39:31,538][trainer.accelerators.base_accelerator][INFO] - Training progress: step=64550/100000 (64.55%), epoch=1, lr=1e-05, speed=1.780 step/s, elapsed=10:04:22, eta=05:31:54 +[2026-04-15 15:39:49,383][trainer.accelerators.base_accelerator][INFO] - Training progress: step=64600/100000 (64.60%), epoch=1, lr=1e-05, speed=1.781 step/s, elapsed=10:04:40, eta=05:31:21 +[2026-04-15 15:40:07,242][trainer.accelerators.base_accelerator][INFO] - Training progress: step=64650/100000 (64.65%), epoch=1, lr=1e-05, speed=1.781 step/s, elapsed=10:04:57, eta=05:30:47 +[2026-04-15 15:40:25,024][trainer.accelerators.base_accelerator][INFO] - Training progress: step=64700/100000 (64.70%), epoch=1, lr=1e-05, speed=1.782 step/s, elapsed=10:05:15, eta=05:30:13 +[2026-04-15 15:40:42,975][trainer.accelerators.base_accelerator][INFO] - Training progress: step=64750/100000 (64.75%), epoch=1, lr=1e-05, speed=1.782 step/s, elapsed=10:05:33, eta=05:29:40 +[2026-04-15 15:41:00,894][trainer.accelerators.base_accelerator][INFO] - Training progress: step=64800/100000 (64.80%), epoch=1, lr=1e-05, speed=1.783 step/s, elapsed=10:05:51, eta=05:29:06 +[2026-04-15 15:41:19,021][trainer.accelerators.base_accelerator][INFO] - Training progress: step=64850/100000 (64.85%), epoch=1, lr=1e-05, speed=1.783 step/s, elapsed=10:06:09, eta=05:28:33 +[2026-04-15 15:41:36,855][trainer.accelerators.base_accelerator][INFO] - Training progress: step=64900/100000 (64.90%), epoch=1, lr=1e-05, speed=1.784 step/s, elapsed=10:06:27, eta=05:27:59 +[2026-04-15 15:41:54,694][trainer.accelerators.base_accelerator][INFO] - Training progress: step=64950/100000 (64.95%), epoch=1, lr=1e-05, speed=1.784 step/s, elapsed=10:06:45, eta=05:27:26 +[2026-04-15 15:42:12,504][trainer.accelerators.base_accelerator][INFO] - Training progress: step=65000/100000 (65.00%), epoch=1, lr=1e-05, speed=1.785 step/s, elapsed=10:07:03, eta=05:26:52 +[2026-04-15 15:42:12,528][__main__][INFO] - ========== EVAL START (periodic@gstep=65000) ========== +[2026-04-15 15:42:12,528][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-15 15:42:12,528][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 15:42:28,208][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.113110542297363, 'accuracy': 0.49176470588235294, 'num_samples': 425, 'test_unique_accuracy': 0.5023148148148148, 'test_unique_num_samples': 432} +[2026-04-15 15:42:28,209][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-15 15:42:28,209][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 15:42:43,295][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.113110542297363, 'accuracy': 0.49176470588235294, 'num_samples': 425, 'test_unique_accuracy': 0.5115740740740741, 'test_unique_num_samples': 432} +[2026-04-15 15:42:43,295][__main__][INFO] - ========== EVAL END (periodic@gstep=65000) ========== +[2026-04-15 15:42:43,295][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.102381706237793, 'accuracy': 0.49176470588235294, 'num_samples': 425, 'test_unique_accuracy': 0.5115740740740741, 'test_unique_num_samples': 432} +[2026-04-15 15:42:43,345][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.49176470588235294 is not better than 0.5788235294117647 of logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep32000, skipping checkpoint +[2026-04-15 15:43:01,181][trainer.accelerators.base_accelerator][INFO] - Training progress: step=65050/100000 (65.05%), epoch=1, lr=1e-05, speed=1.784 step/s, elapsed=10:07:51, eta=05:26:35 +[2026-04-15 15:43:19,061][trainer.accelerators.base_accelerator][INFO] - Training progress: step=65100/100000 (65.10%), epoch=1, lr=1e-05, speed=1.784 step/s, elapsed=10:08:09, eta=05:26:02 +[2026-04-15 15:43:36,908][trainer.accelerators.base_accelerator][INFO] - Training progress: step=65150/100000 (65.15%), epoch=1, lr=1e-05, speed=1.785 step/s, elapsed=10:08:27, eta=05:25:28 +[2026-04-15 15:43:54,755][trainer.accelerators.base_accelerator][INFO] - Training progress: step=65200/100000 (65.20%), epoch=1, lr=1e-05, speed=1.785 step/s, elapsed=10:08:45, eta=05:24:55 +[2026-04-15 15:44:12,605][trainer.accelerators.base_accelerator][INFO] - Training progress: step=65250/100000 (65.25%), epoch=1, lr=1e-05, speed=1.786 step/s, elapsed=10:09:03, eta=05:24:21 +[2026-04-15 15:44:30,487][trainer.accelerators.base_accelerator][INFO] - Training progress: step=65300/100000 (65.30%), epoch=1, lr=1e-05, speed=1.786 step/s, elapsed=10:09:21, eta=05:23:48 +[2026-04-15 15:44:48,295][trainer.accelerators.base_accelerator][INFO] - Training progress: step=65350/100000 (65.35%), epoch=1, lr=1e-05, speed=1.787 step/s, elapsed=10:09:38, eta=05:23:14 +[2026-04-15 15:45:06,062][trainer.accelerators.base_accelerator][INFO] - Training progress: step=65400/100000 (65.40%), epoch=1, lr=1e-05, speed=1.787 step/s, elapsed=10:09:56, eta=05:22:41 +[2026-04-15 15:45:23,842][trainer.accelerators.base_accelerator][INFO] - Training progress: step=65450/100000 (65.45%), epoch=1, lr=1e-05, speed=1.788 step/s, elapsed=10:10:14, eta=05:22:08 +[2026-04-15 15:45:41,731][trainer.accelerators.base_accelerator][INFO] - Training progress: step=65500/100000 (65.50%), epoch=1, lr=1e-05, speed=1.788 step/s, elapsed=10:10:32, eta=05:21:34 +[2026-04-15 15:45:59,609][trainer.accelerators.base_accelerator][INFO] - Training progress: step=65550/100000 (65.55%), epoch=1, lr=1e-05, speed=1.789 step/s, elapsed=10:10:50, eta=05:21:01 +[2026-04-15 15:46:17,444][trainer.accelerators.base_accelerator][INFO] - Training progress: step=65600/100000 (65.60%), epoch=1, lr=1e-05, speed=1.789 step/s, elapsed=10:11:08, eta=05:20:28 +[2026-04-15 15:46:35,322][trainer.accelerators.base_accelerator][INFO] - Training progress: step=65650/100000 (65.65%), epoch=1, lr=1e-05, speed=1.790 step/s, elapsed=10:11:26, eta=05:19:55 +[2026-04-15 15:46:53,177][trainer.accelerators.base_accelerator][INFO] - Training progress: step=65700/100000 (65.70%), epoch=1, lr=1e-05, speed=1.790 step/s, elapsed=10:11:43, eta=05:19:21 +[2026-04-15 15:47:11,042][trainer.accelerators.base_accelerator][INFO] - Training progress: step=65750/100000 (65.75%), epoch=1, lr=1e-05, speed=1.790 step/s, elapsed=10:12:01, eta=05:18:48 +[2026-04-15 15:47:28,851][trainer.accelerators.base_accelerator][INFO] - Training progress: step=65800/100000 (65.80%), epoch=1, lr=1e-05, speed=1.791 step/s, elapsed=10:12:19, eta=05:18:15 +[2026-04-15 15:47:46,720][trainer.accelerators.base_accelerator][INFO] - Training progress: step=65850/100000 (65.85%), epoch=1, lr=1e-05, speed=1.791 step/s, elapsed=10:12:37, eta=05:17:42 +[2026-04-15 15:48:04,560][trainer.accelerators.base_accelerator][INFO] - Training progress: step=65900/100000 (65.90%), epoch=1, lr=1e-05, speed=1.792 step/s, elapsed=10:12:55, eta=05:17:09 +[2026-04-15 15:48:22,709][trainer.accelerators.base_accelerator][INFO] - Training progress: step=65950/100000 (65.95%), epoch=1, lr=1e-05, speed=1.792 step/s, elapsed=10:13:13, eta=05:16:36 +[2026-04-15 15:48:40,527][trainer.accelerators.base_accelerator][INFO] - Training progress: step=66000/100000 (66.00%), epoch=1, lr=1e-05, speed=1.793 step/s, elapsed=10:13:31, eta=05:16:03 +[2026-04-15 15:48:40,551][__main__][INFO] - ========== EVAL START (periodic@gstep=66000) ========== +[2026-04-15 15:48:40,552][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-15 15:48:40,552][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 15:48:57,184][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.102381706237793, 'accuracy': 0.4682352941176471, 'num_samples': 425, 'test_unique_accuracy': 0.5115740740740741, 'test_unique_num_samples': 432} +[2026-04-15 15:48:57,184][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-15 15:48:57,184][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 15:49:12,274][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.102381706237793, 'accuracy': 0.4682352941176471, 'num_samples': 425, 'test_unique_accuracy': 0.5300925925925926, 'test_unique_num_samples': 432} +[2026-04-15 15:49:12,274][__main__][INFO] - ========== EVAL END (periodic@gstep=66000) ========== +[2026-04-15 15:49:12,274][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.102815628051758, 'accuracy': 0.4682352941176471, 'num_samples': 425, 'test_unique_accuracy': 0.5300925925925926, 'test_unique_num_samples': 432} +[2026-04-15 15:49:12,278][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.4682352941176471 is not better than 0.5788235294117647 of logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep32000, skipping checkpoint +[2026-04-15 15:49:30,125][trainer.accelerators.base_accelerator][INFO] - Training progress: step=66050/100000 (66.05%), epoch=1, lr=1e-05, speed=1.792 step/s, elapsed=10:14:20, eta=05:15:46 +[2026-04-15 15:49:47,925][trainer.accelerators.base_accelerator][INFO] - Training progress: step=66100/100000 (66.10%), epoch=1, lr=1e-05, speed=1.792 step/s, elapsed=10:14:38, eta=05:15:13 +[2026-04-15 15:50:05,773][trainer.accelerators.base_accelerator][INFO] - Training progress: step=66150/100000 (66.15%), epoch=1, lr=1e-05, speed=1.793 step/s, elapsed=10:14:56, eta=05:14:40 +[2026-04-15 15:50:23,587][trainer.accelerators.base_accelerator][INFO] - Training progress: step=66200/100000 (66.20%), epoch=1, lr=1e-05, speed=1.793 step/s, elapsed=10:15:14, eta=05:14:07 +[2026-04-15 15:50:41,483][trainer.accelerators.base_accelerator][INFO] - Training progress: step=66250/100000 (66.25%), epoch=1, lr=1e-05, speed=1.794 step/s, elapsed=10:15:32, eta=05:13:34 +[2026-04-15 15:50:59,346][trainer.accelerators.base_accelerator][INFO] - Training progress: step=66300/100000 (66.30%), epoch=1, lr=1e-05, speed=1.794 step/s, elapsed=10:15:50, eta=05:13:01 +[2026-04-15 15:51:17,194][trainer.accelerators.base_accelerator][INFO] - Training progress: step=66350/100000 (66.35%), epoch=1, lr=1e-05, speed=1.795 step/s, elapsed=10:16:07, eta=05:12:28 +[2026-04-15 15:51:35,068][trainer.accelerators.base_accelerator][INFO] - Training progress: step=66400/100000 (66.40%), epoch=1, lr=1e-05, speed=1.795 step/s, elapsed=10:16:25, eta=05:11:55 +[2026-04-15 15:51:52,903][trainer.accelerators.base_accelerator][INFO] - Training progress: step=66450/100000 (66.45%), epoch=1, lr=1e-05, speed=1.796 step/s, elapsed=10:16:43, eta=05:11:22 +[2026-04-15 15:52:10,795][trainer.accelerators.base_accelerator][INFO] - Training progress: step=66500/100000 (66.50%), epoch=1, lr=1e-05, speed=1.796 step/s, elapsed=10:17:01, eta=05:10:49 +[2026-04-15 15:52:28,622][trainer.accelerators.base_accelerator][INFO] - Training progress: step=66550/100000 (66.55%), epoch=1, lr=1e-05, speed=1.797 step/s, elapsed=10:17:19, eta=05:10:17 +[2026-04-15 15:52:46,442][trainer.accelerators.base_accelerator][INFO] - Training progress: step=66600/100000 (66.60%), epoch=1, lr=1e-05, speed=1.797 step/s, elapsed=10:17:37, eta=05:09:44 +[2026-04-15 15:53:04,134][trainer.accelerators.base_accelerator][INFO] - Training progress: step=66650/100000 (66.65%), epoch=1, lr=1e-05, speed=1.798 step/s, elapsed=10:17:54, eta=05:09:11 +[2026-04-15 15:53:22,045][trainer.accelerators.base_accelerator][INFO] - Training progress: step=66700/100000 (66.70%), epoch=1, lr=1e-05, speed=1.798 step/s, elapsed=10:18:12, eta=05:08:38 +[2026-04-15 15:53:39,973][trainer.accelerators.base_accelerator][INFO] - Training progress: step=66750/100000 (66.75%), epoch=1, lr=1e-05, speed=1.799 step/s, elapsed=10:18:30, eta=05:08:05 +[2026-04-15 15:53:57,843][trainer.accelerators.base_accelerator][INFO] - Training progress: step=66800/100000 (66.80%), epoch=1, lr=1e-05, speed=1.799 step/s, elapsed=10:18:48, eta=05:07:33 +[2026-04-15 15:54:15,729][trainer.accelerators.base_accelerator][INFO] - Training progress: step=66850/100000 (66.85%), epoch=1, lr=1e-05, speed=1.800 step/s, elapsed=10:19:06, eta=05:07:00 +[2026-04-15 15:54:33,462][trainer.accelerators.base_accelerator][INFO] - Training progress: step=66900/100000 (66.90%), epoch=1, lr=1e-05, speed=1.800 step/s, elapsed=10:19:24, eta=05:06:27 +[2026-04-15 15:54:51,372][trainer.accelerators.base_accelerator][INFO] - Training progress: step=66950/100000 (66.95%), epoch=1, lr=1e-05, speed=1.801 step/s, elapsed=10:19:42, eta=05:05:54 +[2026-04-15 15:55:09,302][trainer.accelerators.base_accelerator][INFO] - Training progress: step=67000/100000 (67.00%), epoch=1, lr=1e-05, speed=1.801 step/s, elapsed=10:19:59, eta=05:05:22 +[2026-04-15 15:55:09,327][__main__][INFO] - ========== EVAL START (periodic@gstep=67000) ========== +[2026-04-15 15:55:09,327][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-15 15:55:09,327][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 15:55:25,298][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.102815628051758, 'accuracy': 0.52, 'num_samples': 425, 'test_unique_accuracy': 0.5300925925925926, 'test_unique_num_samples': 432} +[2026-04-15 15:55:25,298][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-15 15:55:25,299][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 15:55:40,391][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.102815628051758, 'accuracy': 0.52, 'num_samples': 425, 'test_unique_accuracy': 0.4930555555555556, 'test_unique_num_samples': 432} +[2026-04-15 15:55:40,392][__main__][INFO] - ========== EVAL END (periodic@gstep=67000) ========== +[2026-04-15 15:55:40,392][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.110682487487793, 'accuracy': 0.52, 'num_samples': 425, 'test_unique_accuracy': 0.4930555555555556, 'test_unique_num_samples': 432} +[2026-04-15 15:55:40,395][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.52 is not better than 0.5788235294117647 of logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep32000, skipping checkpoint +[2026-04-15 15:55:58,233][trainer.accelerators.base_accelerator][INFO] - Training progress: step=67050/100000 (67.05%), epoch=1, lr=1e-05, speed=1.800 step/s, elapsed=10:20:48, eta=05:05:05 +[2026-04-15 15:56:16,064][trainer.accelerators.base_accelerator][INFO] - Training progress: step=67100/100000 (67.10%), epoch=1, lr=1e-05, speed=1.801 step/s, elapsed=10:21:06, eta=05:04:32 +[2026-04-15 15:56:33,961][trainer.accelerators.base_accelerator][INFO] - Training progress: step=67150/100000 (67.15%), epoch=1, lr=1e-05, speed=1.801 step/s, elapsed=10:21:24, eta=05:03:59 +[2026-04-15 15:56:51,782][trainer.accelerators.base_accelerator][INFO] - Training progress: step=67200/100000 (67.20%), epoch=1, lr=1e-05, speed=1.801 step/s, elapsed=10:21:42, eta=05:03:27 +[2026-04-15 15:57:09,653][trainer.accelerators.base_accelerator][INFO] - Training progress: step=67250/100000 (67.25%), epoch=1, lr=1e-05, speed=1.802 step/s, elapsed=10:22:00, eta=05:02:54 +[2026-04-15 15:57:27,454][trainer.accelerators.base_accelerator][INFO] - Training progress: step=67300/100000 (67.30%), epoch=1, lr=1e-05, speed=1.802 step/s, elapsed=10:22:18, eta=05:02:22 +[2026-04-15 15:57:45,379][trainer.accelerators.base_accelerator][INFO] - Training progress: step=67350/100000 (67.35%), epoch=1, lr=1e-05, speed=1.803 step/s, elapsed=10:22:36, eta=05:01:49 +[2026-04-15 15:58:03,152][trainer.accelerators.base_accelerator][INFO] - Training progress: step=67400/100000 (67.40%), epoch=1, lr=1e-05, speed=1.803 step/s, elapsed=10:22:53, eta=05:01:16 +[2026-04-15 15:58:21,013][trainer.accelerators.base_accelerator][INFO] - Training progress: step=67450/100000 (67.45%), epoch=1, lr=1e-05, speed=1.804 step/s, elapsed=10:23:11, eta=05:00:44 +[2026-04-15 15:58:38,827][trainer.accelerators.base_accelerator][INFO] - Training progress: step=67500/100000 (67.50%), epoch=1, lr=1e-05, speed=1.804 step/s, elapsed=10:23:29, eta=05:00:11 +[2026-04-15 15:58:56,703][trainer.accelerators.base_accelerator][INFO] - Training progress: step=67550/100000 (67.55%), epoch=1, lr=1e-05, speed=1.805 step/s, elapsed=10:23:47, eta=04:59:39 +[2026-04-15 15:59:14,566][trainer.accelerators.base_accelerator][INFO] - Training progress: step=67600/100000 (67.60%), epoch=1, lr=1e-05, speed=1.805 step/s, elapsed=10:24:05, eta=04:59:07 +[2026-04-15 15:59:32,466][trainer.accelerators.base_accelerator][INFO] - Training progress: step=67650/100000 (67.65%), epoch=1, lr=1e-05, speed=1.806 step/s, elapsed=10:24:23, eta=04:58:34 +[2026-04-15 15:59:50,268][trainer.accelerators.base_accelerator][INFO] - Training progress: step=67700/100000 (67.70%), epoch=1, lr=1e-05, speed=1.806 step/s, elapsed=10:24:40, eta=04:58:02 +[2026-04-15 16:00:08,157][trainer.accelerators.base_accelerator][INFO] - Training progress: step=67750/100000 (67.75%), epoch=1, lr=1e-05, speed=1.807 step/s, elapsed=10:24:58, eta=04:57:30 +[2026-04-15 16:00:25,975][trainer.accelerators.base_accelerator][INFO] - Training progress: step=67800/100000 (67.80%), epoch=1, lr=1e-05, speed=1.807 step/s, elapsed=10:25:16, eta=04:56:57 +[2026-04-15 16:00:43,800][trainer.accelerators.base_accelerator][INFO] - Training progress: step=67850/100000 (67.85%), epoch=1, lr=1e-05, speed=1.808 step/s, elapsed=10:25:34, eta=04:56:25 +[2026-04-15 16:01:01,648][trainer.accelerators.base_accelerator][INFO] - Training progress: step=67900/100000 (67.90%), epoch=1, lr=1e-05, speed=1.808 step/s, elapsed=10:25:52, eta=04:55:53 +[2026-04-15 16:01:19,506][trainer.accelerators.base_accelerator][INFO] - Training progress: step=67950/100000 (67.95%), epoch=1, lr=1e-05, speed=1.809 step/s, elapsed=10:26:10, eta=04:55:20 +[2026-04-15 16:01:37,346][trainer.accelerators.base_accelerator][INFO] - Training progress: step=68000/100000 (68.00%), epoch=1, lr=1e-05, speed=1.809 step/s, elapsed=10:26:28, eta=04:54:48 +[2026-04-15 16:01:37,369][__main__][INFO] - ========== EVAL START (periodic@gstep=68000) ========== +[2026-04-15 16:01:37,370][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-15 16:01:37,370][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 16:01:57,609][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.110682487487793, 'accuracy': 0.5223529411764706, 'num_samples': 425, 'test_unique_accuracy': 0.4930555555555556, 'test_unique_num_samples': 432} +[2026-04-15 16:01:57,609][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-15 16:01:57,609][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 16:02:13,010][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.110682487487793, 'accuracy': 0.5223529411764706, 'num_samples': 425, 'test_unique_accuracy': 0.5069444444444444, 'test_unique_num_samples': 432} +[2026-04-15 16:02:13,010][__main__][INFO] - ========== EVAL END (periodic@gstep=68000) ========== +[2026-04-15 16:02:13,010][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.101978302001953, 'accuracy': 0.5223529411764706, 'num_samples': 425, 'test_unique_accuracy': 0.5069444444444444, 'test_unique_num_samples': 432} +[2026-04-15 16:02:13,042][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.5223529411764706 is not better than 0.5788235294117647 of logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep32000, skipping checkpoint +[2026-04-15 16:02:30,929][trainer.accelerators.base_accelerator][INFO] - Training progress: step=68050/100000 (68.05%), epoch=1, lr=1e-05, speed=1.808 step/s, elapsed=10:27:21, eta=04:54:33 +[2026-04-15 16:02:48,792][trainer.accelerators.base_accelerator][INFO] - Training progress: step=68100/100000 (68.10%), epoch=1, lr=1e-05, speed=1.808 step/s, elapsed=10:27:39, eta=04:54:00 +[2026-04-15 16:03:06,613][trainer.accelerators.base_accelerator][INFO] - Training progress: step=68150/100000 (68.15%), epoch=1, lr=1e-05, speed=1.809 step/s, elapsed=10:27:57, eta=04:53:28 +[2026-04-15 16:03:24,331][trainer.accelerators.base_accelerator][INFO] - Training progress: step=68200/100000 (68.20%), epoch=1, lr=1e-05, speed=1.809 step/s, elapsed=10:28:15, eta=04:52:56 +[2026-04-15 16:03:42,192][trainer.accelerators.base_accelerator][INFO] - Training progress: step=68250/100000 (68.25%), epoch=1, lr=1e-05, speed=1.810 step/s, elapsed=10:28:32, eta=04:52:24 +[2026-04-15 16:04:00,074][trainer.accelerators.base_accelerator][INFO] - Training progress: step=68300/100000 (68.30%), epoch=1, lr=1e-05, speed=1.810 step/s, elapsed=10:28:50, eta=04:51:51 +[2026-04-15 16:04:17,897][trainer.accelerators.base_accelerator][INFO] - Training progress: step=68350/100000 (68.35%), epoch=1, lr=1e-05, speed=1.811 step/s, elapsed=10:29:08, eta=04:51:19 +[2026-04-15 16:04:35,743][trainer.accelerators.base_accelerator][INFO] - Training progress: step=68400/100000 (68.40%), epoch=1, lr=1e-05, speed=1.811 step/s, elapsed=10:29:26, eta=04:50:47 +[2026-04-15 16:04:53,576][trainer.accelerators.base_accelerator][INFO] - Training progress: step=68450/100000 (68.45%), epoch=1, lr=1e-05, speed=1.812 step/s, elapsed=10:29:44, eta=04:50:15 +[2026-04-15 16:05:11,424][trainer.accelerators.base_accelerator][INFO] - Training progress: step=68500/100000 (68.50%), epoch=1, lr=1e-05, speed=1.812 step/s, elapsed=10:30:02, eta=04:49:43 +[2026-04-15 16:05:29,317][trainer.accelerators.base_accelerator][INFO] - Training progress: step=68550/100000 (68.55%), epoch=1, lr=1e-05, speed=1.813 step/s, elapsed=10:30:20, eta=04:49:11 +[2026-04-15 16:05:47,169][trainer.accelerators.base_accelerator][INFO] - Training progress: step=68600/100000 (68.60%), epoch=1, lr=1e-05, speed=1.813 step/s, elapsed=10:30:37, eta=04:48:39 +[2026-04-15 16:06:05,036][trainer.accelerators.base_accelerator][INFO] - Training progress: step=68650/100000 (68.65%), epoch=1, lr=1e-05, speed=1.813 step/s, elapsed=10:30:55, eta=04:48:07 +[2026-04-15 16:06:22,846][trainer.accelerators.base_accelerator][INFO] - Training progress: step=68700/100000 (68.70%), epoch=1, lr=1e-05, speed=1.814 step/s, elapsed=10:31:13, eta=04:47:35 +[2026-04-15 16:06:40,679][trainer.accelerators.base_accelerator][INFO] - Training progress: step=68750/100000 (68.75%), epoch=1, lr=1e-05, speed=1.814 step/s, elapsed=10:31:31, eta=04:47:03 +[2026-04-15 16:06:58,442][trainer.accelerators.base_accelerator][INFO] - Training progress: step=68800/100000 (68.80%), epoch=1, lr=1e-05, speed=1.815 step/s, elapsed=10:31:49, eta=04:46:31 +[2026-04-15 16:07:16,386][trainer.accelerators.base_accelerator][INFO] - Training progress: step=68850/100000 (68.85%), epoch=1, lr=1e-05, speed=1.815 step/s, elapsed=10:32:07, eta=04:45:59 +[2026-04-15 16:07:34,535][trainer.accelerators.base_accelerator][INFO] - Training progress: step=68900/100000 (68.90%), epoch=1, lr=1e-05, speed=1.816 step/s, elapsed=10:32:25, eta=04:45:27 +[2026-04-15 16:07:52,373][trainer.accelerators.base_accelerator][INFO] - Training progress: step=68950/100000 (68.95%), epoch=1, lr=1e-05, speed=1.816 step/s, elapsed=10:32:43, eta=04:44:55 +[2026-04-15 16:08:10,197][trainer.accelerators.base_accelerator][INFO] - Training progress: step=69000/100000 (69.00%), epoch=1, lr=1e-05, speed=1.817 step/s, elapsed=10:33:00, eta=04:44:23 +[2026-04-15 16:08:10,221][__main__][INFO] - ========== EVAL START (periodic@gstep=69000) ========== +[2026-04-15 16:08:10,221][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-15 16:08:10,222][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 16:08:25,568][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.101978302001953, 'accuracy': 0.52, 'num_samples': 425, 'test_unique_accuracy': 0.5069444444444444, 'test_unique_num_samples': 432} +[2026-04-15 16:08:25,569][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-15 16:08:25,569][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 16:08:40,667][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.101978302001953, 'accuracy': 0.52, 'num_samples': 425, 'test_unique_accuracy': 0.48148148148148145, 'test_unique_num_samples': 432} +[2026-04-15 16:08:40,667][__main__][INFO] - ========== EVAL END (periodic@gstep=69000) ========== +[2026-04-15 16:08:40,667][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.10833740234375, 'accuracy': 0.52, 'num_samples': 425, 'test_unique_accuracy': 0.48148148148148145, 'test_unique_num_samples': 432} +[2026-04-15 16:08:40,694][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.52 is not better than 0.5788235294117647 of logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep32000, skipping checkpoint +[2026-04-15 16:08:58,623][trainer.accelerators.base_accelerator][INFO] - Training progress: step=69050/100000 (69.05%), epoch=1, lr=1e-05, speed=1.816 step/s, elapsed=10:33:49, eta=04:44:05 +[2026-04-15 16:09:16,446][trainer.accelerators.base_accelerator][INFO] - Training progress: step=69100/100000 (69.10%), epoch=1, lr=1e-05, speed=1.816 step/s, elapsed=10:34:07, eta=04:43:33 +[2026-04-15 16:09:34,301][trainer.accelerators.base_accelerator][INFO] - Training progress: step=69150/100000 (69.15%), epoch=1, lr=1e-05, speed=1.817 step/s, elapsed=10:34:24, eta=04:43:01 +[2026-04-15 16:09:52,203][trainer.accelerators.base_accelerator][INFO] - Training progress: step=69200/100000 (69.20%), epoch=1, lr=1e-05, speed=1.817 step/s, elapsed=10:34:42, eta=04:42:30 +[2026-04-15 16:10:10,015][trainer.accelerators.base_accelerator][INFO] - Training progress: step=69250/100000 (69.25%), epoch=1, lr=1e-05, speed=1.818 step/s, elapsed=10:35:00, eta=04:41:58 +[2026-04-15 16:10:27,834][trainer.accelerators.base_accelerator][INFO] - Training progress: step=69300/100000 (69.30%), epoch=1, lr=1e-05, speed=1.818 step/s, elapsed=10:35:18, eta=04:41:26 +[2026-04-15 16:10:45,684][trainer.accelerators.base_accelerator][INFO] - Training progress: step=69350/100000 (69.35%), epoch=1, lr=1e-05, speed=1.818 step/s, elapsed=10:35:36, eta=04:40:54 +[2026-04-15 16:11:03,469][trainer.accelerators.base_accelerator][INFO] - Training progress: step=69400/100000 (69.40%), epoch=1, lr=1e-05, speed=1.819 step/s, elapsed=10:35:54, eta=04:40:23 +[2026-04-15 16:11:21,327][trainer.accelerators.base_accelerator][INFO] - Training progress: step=69450/100000 (69.45%), epoch=1, lr=1e-05, speed=1.819 step/s, elapsed=10:36:12, eta=04:39:51 +[2026-04-15 16:11:39,213][trainer.accelerators.base_accelerator][INFO] - Training progress: step=69500/100000 (69.50%), epoch=1, lr=1e-05, speed=1.820 step/s, elapsed=10:36:29, eta=04:39:19 +[2026-04-15 16:11:57,024][trainer.accelerators.base_accelerator][INFO] - Training progress: step=69550/100000 (69.55%), epoch=1, lr=1e-05, speed=1.820 step/s, elapsed=10:36:47, eta=04:38:47 +[2026-04-15 16:12:14,825][trainer.accelerators.base_accelerator][INFO] - Training progress: step=69600/100000 (69.60%), epoch=1, lr=1e-05, speed=1.821 step/s, elapsed=10:37:05, eta=04:38:16 +[2026-04-15 16:12:32,735][trainer.accelerators.base_accelerator][INFO] - Training progress: step=69650/100000 (69.65%), epoch=1, lr=1e-05, speed=1.821 step/s, elapsed=10:37:23, eta=04:37:44 +[2026-04-15 16:12:50,450][trainer.accelerators.base_accelerator][INFO] - Training progress: step=69700/100000 (69.70%), epoch=1, lr=1e-05, speed=1.822 step/s, elapsed=10:37:41, eta=04:37:12 +[2026-04-15 16:13:08,665][trainer.accelerators.base_accelerator][INFO] - Training progress: step=69750/100000 (69.75%), epoch=1, lr=1e-05, speed=1.822 step/s, elapsed=10:37:59, eta=04:36:41 +[2026-04-15 16:13:26,475][trainer.accelerators.base_accelerator][INFO] - Training progress: step=69800/100000 (69.80%), epoch=1, lr=1e-05, speed=1.823 step/s, elapsed=10:38:17, eta=04:36:09 +[2026-04-15 16:13:44,274][trainer.accelerators.base_accelerator][INFO] - Training progress: step=69850/100000 (69.85%), epoch=1, lr=1e-05, speed=1.823 step/s, elapsed=10:38:34, eta=04:35:38 +[2026-04-15 16:14:02,128][trainer.accelerators.base_accelerator][INFO] - Training progress: step=69900/100000 (69.90%), epoch=1, lr=1e-05, speed=1.824 step/s, elapsed=10:38:52, eta=04:35:06 +[2026-04-15 16:14:19,953][trainer.accelerators.base_accelerator][INFO] - Training progress: step=69950/100000 (69.95%), epoch=1, lr=1e-05, speed=1.824 step/s, elapsed=10:39:10, eta=04:34:35 +[2026-04-15 16:14:37,732][trainer.accelerators.base_accelerator][INFO] - Training progress: step=70000/100000 (70.00%), epoch=1, lr=1e-05, speed=1.824 step/s, elapsed=10:39:28, eta=04:34:03 +[2026-04-15 16:14:37,757][__main__][INFO] - ========== EVAL START (periodic@gstep=70000) ========== +[2026-04-15 16:14:37,757][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-15 16:14:37,758][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 16:14:54,183][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.10833740234375, 'accuracy': 0.48705882352941177, 'num_samples': 425, 'test_unique_accuracy': 0.48148148148148145, 'test_unique_num_samples': 432} +[2026-04-15 16:14:54,184][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-15 16:14:54,184][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 16:15:09,396][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.10833740234375, 'accuracy': 0.48705882352941177, 'num_samples': 425, 'test_unique_accuracy': 0.4675925925925926, 'test_unique_num_samples': 432} +[2026-04-15 16:15:09,397][__main__][INFO] - ========== EVAL END (periodic@gstep=70000) ========== +[2026-04-15 16:15:09,397][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.10663890838623, 'accuracy': 0.48705882352941177, 'num_samples': 425, 'test_unique_accuracy': 0.4675925925925926, 'test_unique_num_samples': 432} +[2026-04-15 16:15:09,403][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.48705882352941177 is not better than 0.5788235294117647 of logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep32000, skipping checkpoint +[2026-04-15 16:15:27,215][trainer.accelerators.base_accelerator][INFO] - Training progress: step=70050/100000 (70.05%), epoch=1, lr=1e-05, speed=1.823 step/s, elapsed=10:40:17, eta=04:33:45 +[2026-04-15 16:15:45,092][trainer.accelerators.base_accelerator][INFO] - Training progress: step=70100/100000 (70.10%), epoch=1, lr=1e-05, speed=1.824 step/s, elapsed=10:40:35, eta=04:33:14 +[2026-04-15 16:16:02,968][trainer.accelerators.base_accelerator][INFO] - Training progress: step=70150/100000 (70.15%), epoch=1, lr=1e-05, speed=1.824 step/s, elapsed=10:40:53, eta=04:32:42 +[2026-04-15 16:16:20,861][trainer.accelerators.base_accelerator][INFO] - Training progress: step=70200/100000 (70.20%), epoch=1, lr=1e-05, speed=1.825 step/s, elapsed=10:41:11, eta=04:32:11 +[2026-04-15 16:16:38,716][trainer.accelerators.base_accelerator][INFO] - Training progress: step=70250/100000 (70.25%), epoch=1, lr=1e-05, speed=1.825 step/s, elapsed=10:41:29, eta=04:31:39 +[2026-04-15 16:16:56,619][trainer.accelerators.base_accelerator][INFO] - Training progress: step=70300/100000 (70.30%), epoch=1, lr=1e-05, speed=1.826 step/s, elapsed=10:41:47, eta=04:31:08 +[2026-04-15 16:17:14,423][trainer.accelerators.base_accelerator][INFO] - Training progress: step=70350/100000 (70.35%), epoch=1, lr=1e-05, speed=1.826 step/s, elapsed=10:42:05, eta=04:30:36 +[2026-04-15 16:17:32,315][trainer.accelerators.base_accelerator][INFO] - Training progress: step=70400/100000 (70.40%), epoch=1, lr=1e-05, speed=1.827 step/s, elapsed=10:42:22, eta=04:30:05 +[2026-04-15 16:17:50,203][trainer.accelerators.base_accelerator][INFO] - Training progress: step=70450/100000 (70.45%), epoch=1, lr=1e-05, speed=1.827 step/s, elapsed=10:42:40, eta=04:29:34 +[2026-04-15 16:18:08,067][trainer.accelerators.base_accelerator][INFO] - Training progress: step=70500/100000 (70.50%), epoch=1, lr=1e-05, speed=1.827 step/s, elapsed=10:42:58, eta=04:29:02 +[2026-04-15 16:18:25,897][trainer.accelerators.base_accelerator][INFO] - Training progress: step=70550/100000 (70.55%), epoch=1, lr=1e-05, speed=1.828 step/s, elapsed=10:43:16, eta=04:28:31 +[2026-04-15 16:18:43,751][trainer.accelerators.base_accelerator][INFO] - Training progress: step=70600/100000 (70.60%), epoch=1, lr=1e-05, speed=1.828 step/s, elapsed=10:43:34, eta=04:28:00 +[2026-04-15 16:19:01,516][trainer.accelerators.base_accelerator][INFO] - Training progress: step=70650/100000 (70.65%), epoch=1, lr=1e-05, speed=1.829 step/s, elapsed=10:43:52, eta=04:27:28 +[2026-04-15 16:19:19,275][trainer.accelerators.base_accelerator][INFO] - Training progress: step=70700/100000 (70.70%), epoch=1, lr=1e-05, speed=1.829 step/s, elapsed=10:44:09, eta=04:26:57 +[2026-04-15 16:19:37,060][trainer.accelerators.base_accelerator][INFO] - Training progress: step=70750/100000 (70.75%), epoch=1, lr=1e-05, speed=1.830 step/s, elapsed=10:44:27, eta=04:26:26 +[2026-04-15 16:19:55,260][trainer.accelerators.base_accelerator][INFO] - Training progress: step=70800/100000 (70.80%), epoch=1, lr=1e-05, speed=1.830 step/s, elapsed=10:44:45, eta=04:25:55 +[2026-04-15 16:20:13,080][trainer.accelerators.base_accelerator][INFO] - Training progress: step=70850/100000 (70.85%), epoch=1, lr=1e-05, speed=1.831 step/s, elapsed=10:45:03, eta=04:25:23 +[2026-04-15 16:20:30,921][trainer.accelerators.base_accelerator][INFO] - Training progress: step=70900/100000 (70.90%), epoch=1, lr=1e-05, speed=1.831 step/s, elapsed=10:45:21, eta=04:24:52 +[2026-04-15 16:20:48,788][trainer.accelerators.base_accelerator][INFO] - Training progress: step=70950/100000 (70.95%), epoch=1, lr=1e-05, speed=1.831 step/s, elapsed=10:45:39, eta=04:24:21 +[2026-04-15 16:21:06,643][trainer.accelerators.base_accelerator][INFO] - Training progress: step=71000/100000 (71.00%), epoch=1, lr=1e-05, speed=1.832 step/s, elapsed=10:45:57, eta=04:23:50 +[2026-04-15 16:21:06,667][__main__][INFO] - ========== EVAL START (periodic@gstep=71000) ========== +[2026-04-15 16:21:06,667][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-15 16:21:06,668][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 16:21:22,586][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.10663890838623, 'accuracy': 0.508235294117647, 'num_samples': 425, 'test_unique_accuracy': 0.4675925925925926, 'test_unique_num_samples': 432} +[2026-04-15 16:21:22,587][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-15 16:21:22,587][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 16:21:37,743][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.10663890838623, 'accuracy': 0.508235294117647, 'num_samples': 425, 'test_unique_accuracy': 0.5069444444444444, 'test_unique_num_samples': 432} +[2026-04-15 16:21:37,744][__main__][INFO] - ========== EVAL END (periodic@gstep=71000) ========== +[2026-04-15 16:21:37,744][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.102485656738281, 'accuracy': 0.508235294117647, 'num_samples': 425, 'test_unique_accuracy': 0.5069444444444444, 'test_unique_num_samples': 432} +[2026-04-15 16:21:37,747][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.508235294117647 is not better than 0.5788235294117647 of logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep32000, skipping checkpoint +[2026-04-15 16:21:55,606][trainer.accelerators.base_accelerator][INFO] - Training progress: step=71050/100000 (71.05%), epoch=1, lr=1e-05, speed=1.831 step/s, elapsed=10:46:46, eta=04:23:31 +[2026-04-15 16:22:13,432][trainer.accelerators.base_accelerator][INFO] - Training progress: step=71100/100000 (71.10%), epoch=1, lr=1e-05, speed=1.831 step/s, elapsed=10:47:04, eta=04:23:00 +[2026-04-15 16:22:31,308][trainer.accelerators.base_accelerator][INFO] - Training progress: step=71150/100000 (71.15%), epoch=1, lr=1e-05, speed=1.832 step/s, elapsed=10:47:21, eta=04:22:29 +[2026-04-15 16:22:49,146][trainer.accelerators.base_accelerator][INFO] - Training progress: step=71200/100000 (71.20%), epoch=1, lr=1e-05, speed=1.832 step/s, elapsed=10:47:39, eta=04:21:58 +[2026-04-15 16:23:07,039][trainer.accelerators.base_accelerator][INFO] - Training progress: step=71250/100000 (71.25%), epoch=1, lr=1e-05, speed=1.833 step/s, elapsed=10:47:57, eta=04:21:27 +[2026-04-15 16:23:24,940][trainer.accelerators.base_accelerator][INFO] - Training progress: step=71300/100000 (71.30%), epoch=1, lr=1e-05, speed=1.833 step/s, elapsed=10:48:15, eta=04:20:56 +[2026-04-15 16:23:42,784][trainer.accelerators.base_accelerator][INFO] - Training progress: step=71350/100000 (71.35%), epoch=1, lr=1e-05, speed=1.834 step/s, elapsed=10:48:33, eta=04:20:25 +[2026-04-15 16:24:00,634][trainer.accelerators.base_accelerator][INFO] - Training progress: step=71400/100000 (71.40%), epoch=1, lr=1e-05, speed=1.834 step/s, elapsed=10:48:51, eta=04:19:54 +[2026-04-15 16:24:18,444][trainer.accelerators.base_accelerator][INFO] - Training progress: step=71450/100000 (71.45%), epoch=1, lr=1e-05, speed=1.834 step/s, elapsed=10:49:09, eta=04:19:23 +[2026-04-15 16:24:36,312][trainer.accelerators.base_accelerator][INFO] - Training progress: step=71500/100000 (71.50%), epoch=1, lr=1e-05, speed=1.835 step/s, elapsed=10:49:26, eta=04:18:52 +[2026-04-15 16:24:54,202][trainer.accelerators.base_accelerator][INFO] - Training progress: step=71550/100000 (71.55%), epoch=1, lr=1e-05, speed=1.835 step/s, elapsed=10:49:44, eta=04:18:21 +[2026-04-15 16:25:12,081][trainer.accelerators.base_accelerator][INFO] - Training progress: step=71600/100000 (71.60%), epoch=1, lr=1e-05, speed=1.836 step/s, elapsed=10:50:02, eta=04:17:50 +[2026-04-15 16:25:29,921][trainer.accelerators.base_accelerator][INFO] - Training progress: step=71650/100000 (71.65%), epoch=1, lr=1e-05, speed=1.836 step/s, elapsed=10:50:20, eta=04:17:19 +[2026-04-15 16:25:47,783][trainer.accelerators.base_accelerator][INFO] - Training progress: step=71700/100000 (71.70%), epoch=1, lr=1e-05, speed=1.837 step/s, elapsed=10:50:38, eta=04:16:48 +[2026-04-15 16:26:05,721][trainer.accelerators.base_accelerator][INFO] - Training progress: step=71750/100000 (71.75%), epoch=1, lr=1e-05, speed=1.837 step/s, elapsed=10:50:56, eta=04:16:17 +[2026-04-15 16:26:23,524][trainer.accelerators.base_accelerator][INFO] - Training progress: step=71800/100000 (71.80%), epoch=1, lr=1e-05, speed=1.838 step/s, elapsed=10:51:14, eta=04:15:46 +[2026-04-15 16:26:41,381][trainer.accelerators.base_accelerator][INFO] - Training progress: step=71850/100000 (71.85%), epoch=1, lr=1e-05, speed=1.838 step/s, elapsed=10:51:32, eta=04:15:15 +[2026-04-15 16:26:59,710][trainer.accelerators.base_accelerator][INFO] - Training progress: step=71900/100000 (71.90%), epoch=1, lr=1e-05, speed=1.838 step/s, elapsed=10:51:50, eta=04:14:45 +[2026-04-15 16:27:17,582][trainer.accelerators.base_accelerator][INFO] - Training progress: step=71950/100000 (71.95%), epoch=1, lr=1e-05, speed=1.839 step/s, elapsed=10:52:08, eta=04:14:14 +[2026-04-15 16:27:35,468][trainer.accelerators.base_accelerator][INFO] - Training progress: step=72000/100000 (72.00%), epoch=1, lr=1e-05, speed=1.839 step/s, elapsed=10:52:26, eta=04:13:43 +[2026-04-15 16:27:35,493][__main__][INFO] - ========== EVAL START (periodic@gstep=72000) ========== +[2026-04-15 16:27:35,493][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-15 16:27:35,493][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 16:27:59,567][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.102485656738281, 'accuracy': 0.5176470588235295, 'num_samples': 425, 'test_unique_accuracy': 0.5069444444444444, 'test_unique_num_samples': 432} +[2026-04-15 16:27:59,567][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-15 16:27:59,567][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 16:28:14,672][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.102485656738281, 'accuracy': 0.5176470588235295, 'num_samples': 425, 'test_unique_accuracy': 0.5023148148148148, 'test_unique_num_samples': 432} +[2026-04-15 16:28:14,672][__main__][INFO] - ========== EVAL END (periodic@gstep=72000) ========== +[2026-04-15 16:28:14,672][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.106982231140137, 'accuracy': 0.5176470588235295, 'num_samples': 425, 'test_unique_accuracy': 0.5023148148148148, 'test_unique_num_samples': 432} +[2026-04-15 16:28:14,683][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.5176470588235295 is not better than 0.5788235294117647 of logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep32000, skipping checkpoint +[2026-04-15 16:28:32,558][trainer.accelerators.base_accelerator][INFO] - Training progress: step=72050/100000 (72.05%), epoch=1, lr=1e-05, speed=1.838 step/s, elapsed=10:53:23, eta=04:13:27 +[2026-04-15 16:28:50,467][trainer.accelerators.base_accelerator][INFO] - Training progress: step=72100/100000 (72.10%), epoch=1, lr=1e-05, speed=1.838 step/s, elapsed=10:53:41, eta=04:12:57 +[2026-04-15 16:29:08,335][trainer.accelerators.base_accelerator][INFO] - Training progress: step=72150/100000 (72.15%), epoch=1, lr=1e-05, speed=1.839 step/s, elapsed=10:53:59, eta=04:12:26 +[2026-04-15 16:29:26,202][trainer.accelerators.base_accelerator][INFO] - Training progress: step=72200/100000 (72.20%), epoch=1, lr=1e-05, speed=1.839 step/s, elapsed=10:54:16, eta=04:11:55 +[2026-04-15 16:29:44,131][trainer.accelerators.base_accelerator][INFO] - Training progress: step=72250/100000 (72.25%), epoch=1, lr=1e-05, speed=1.840 step/s, elapsed=10:54:34, eta=04:11:24 +[2026-04-15 16:30:02,026][trainer.accelerators.base_accelerator][INFO] - Training progress: step=72300/100000 (72.30%), epoch=1, lr=1e-05, speed=1.840 step/s, elapsed=10:54:52, eta=04:10:54 +[2026-04-15 16:30:19,853][trainer.accelerators.base_accelerator][INFO] - Training progress: step=72350/100000 (72.35%), epoch=1, lr=1e-05, speed=1.840 step/s, elapsed=10:55:10, eta=04:10:23 +[2026-04-15 16:30:37,691][trainer.accelerators.base_accelerator][INFO] - Training progress: step=72400/100000 (72.40%), epoch=1, lr=1e-05, speed=1.841 step/s, elapsed=10:55:28, eta=04:09:52 +[2026-04-15 16:30:55,449][trainer.accelerators.base_accelerator][INFO] - Training progress: step=72450/100000 (72.45%), epoch=1, lr=1e-05, speed=1.841 step/s, elapsed=10:55:46, eta=04:09:21 +[2026-04-15 16:31:13,334][trainer.accelerators.base_accelerator][INFO] - Training progress: step=72500/100000 (72.50%), epoch=1, lr=1e-05, speed=1.842 step/s, elapsed=10:56:04, eta=04:08:51 +[2026-04-15 16:31:31,227][trainer.accelerators.base_accelerator][INFO] - Training progress: step=72550/100000 (72.55%), epoch=1, lr=1e-05, speed=1.842 step/s, elapsed=10:56:21, eta=04:08:20 +[2026-04-15 16:31:49,063][trainer.accelerators.base_accelerator][INFO] - Training progress: step=72600/100000 (72.60%), epoch=1, lr=1e-05, speed=1.843 step/s, elapsed=10:56:39, eta=04:07:49 +[2026-04-15 16:32:06,958][trainer.accelerators.base_accelerator][INFO] - Training progress: step=72650/100000 (72.65%), epoch=1, lr=1e-05, speed=1.843 step/s, elapsed=10:56:57, eta=04:07:19 +[2026-04-15 16:32:24,844][trainer.accelerators.base_accelerator][INFO] - Training progress: step=72700/100000 (72.70%), epoch=1, lr=1e-05, speed=1.844 step/s, elapsed=10:57:15, eta=04:06:48 +[2026-04-15 16:32:42,741][trainer.accelerators.base_accelerator][INFO] - Training progress: step=72750/100000 (72.75%), epoch=1, lr=1e-05, speed=1.844 step/s, elapsed=10:57:33, eta=04:06:18 +[2026-04-15 16:33:00,591][trainer.accelerators.base_accelerator][INFO] - Training progress: step=72800/100000 (72.80%), epoch=1, lr=1e-05, speed=1.844 step/s, elapsed=10:57:51, eta=04:05:47 +[2026-04-15 16:33:18,472][trainer.accelerators.base_accelerator][INFO] - Training progress: step=72850/100000 (72.85%), epoch=1, lr=1e-05, speed=1.845 step/s, elapsed=10:58:09, eta=04:05:16 +[2026-04-15 16:33:36,390][trainer.accelerators.base_accelerator][INFO] - Training progress: step=72900/100000 (72.90%), epoch=1, lr=1e-05, speed=1.845 step/s, elapsed=10:58:27, eta=04:04:46 +[2026-04-15 16:33:54,734][trainer.accelerators.base_accelerator][INFO] - Training progress: step=72950/100000 (72.95%), epoch=1, lr=1e-05, speed=1.846 step/s, elapsed=10:58:45, eta=04:04:16 +[2026-04-15 16:34:12,581][trainer.accelerators.base_accelerator][INFO] - Training progress: step=73000/100000 (73.00%), epoch=1, lr=1e-05, speed=1.846 step/s, elapsed=10:59:03, eta=04:03:45 +[2026-04-15 16:34:12,606][__main__][INFO] - ========== EVAL START (periodic@gstep=73000) ========== +[2026-04-15 16:34:12,606][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-15 16:34:12,606][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 16:34:28,529][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.106982231140137, 'accuracy': 0.5058823529411764, 'num_samples': 425, 'test_unique_accuracy': 0.5023148148148148, 'test_unique_num_samples': 432} +[2026-04-15 16:34:28,530][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-15 16:34:28,530][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 16:34:43,657][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.106982231140137, 'accuracy': 0.5058823529411764, 'num_samples': 425, 'test_unique_accuracy': 0.47453703703703703, 'test_unique_num_samples': 432} +[2026-04-15 16:34:43,657][__main__][INFO] - ========== EVAL END (periodic@gstep=73000) ========== +[2026-04-15 16:34:43,657][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.108048439025879, 'accuracy': 0.5058823529411764, 'num_samples': 425, 'test_unique_accuracy': 0.47453703703703703, 'test_unique_num_samples': 432} +[2026-04-15 16:34:43,686][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.5058823529411764 is not better than 0.5788235294117647 of logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep32000, skipping checkpoint +[2026-04-15 16:35:01,584][trainer.accelerators.base_accelerator][INFO] - Training progress: step=73050/100000 (73.05%), epoch=1, lr=1e-05, speed=1.845 step/s, elapsed=10:59:52, eta=04:03:26 +[2026-04-15 16:35:19,513][trainer.accelerators.base_accelerator][INFO] - Training progress: step=73100/100000 (73.10%), epoch=1, lr=1e-05, speed=1.845 step/s, elapsed=11:00:10, eta=04:02:56 +[2026-04-15 16:35:37,363][trainer.accelerators.base_accelerator][INFO] - Training progress: step=73150/100000 (73.15%), epoch=1, lr=1e-05, speed=1.846 step/s, elapsed=11:00:28, eta=04:02:25 +[2026-04-15 16:35:55,139][trainer.accelerators.base_accelerator][INFO] - Training progress: step=73200/100000 (73.20%), epoch=1, lr=1e-05, speed=1.846 step/s, elapsed=11:00:45, eta=04:01:55 +[2026-04-15 16:36:12,987][trainer.accelerators.base_accelerator][INFO] - Training progress: step=73250/100000 (73.25%), epoch=1, lr=1e-05, speed=1.847 step/s, elapsed=11:01:03, eta=04:01:24 +[2026-04-15 16:36:30,890][trainer.accelerators.base_accelerator][INFO] - Training progress: step=73300/100000 (73.30%), epoch=1, lr=1e-05, speed=1.847 step/s, elapsed=11:01:21, eta=04:00:54 +[2026-04-15 16:36:48,787][trainer.accelerators.base_accelerator][INFO] - Training progress: step=73350/100000 (73.35%), epoch=1, lr=1e-05, speed=1.848 step/s, elapsed=11:01:39, eta=04:00:23 +[2026-04-15 16:37:06,683][trainer.accelerators.base_accelerator][INFO] - Training progress: step=73400/100000 (73.40%), epoch=1, lr=1e-05, speed=1.848 step/s, elapsed=11:01:57, eta=03:59:53 +[2026-04-15 16:37:24,546][trainer.accelerators.base_accelerator][INFO] - Training progress: step=73450/100000 (73.45%), epoch=1, lr=1e-05, speed=1.848 step/s, elapsed=11:02:15, eta=03:59:23 +[2026-04-15 16:37:42,396][trainer.accelerators.base_accelerator][INFO] - Training progress: step=73500/100000 (73.50%), epoch=1, lr=1e-05, speed=1.849 step/s, elapsed=11:02:33, eta=03:58:52 +[2026-04-15 16:38:00,311][trainer.accelerators.base_accelerator][INFO] - Training progress: step=73550/100000 (73.55%), epoch=1, lr=1e-05, speed=1.849 step/s, elapsed=11:02:50, eta=03:58:22 +[2026-04-15 16:38:18,250][trainer.accelerators.base_accelerator][INFO] - Training progress: step=73600/100000 (73.60%), epoch=1, lr=1e-05, speed=1.850 step/s, elapsed=11:03:08, eta=03:57:52 +[2026-04-15 16:38:36,092][trainer.accelerators.base_accelerator][INFO] - Training progress: step=73650/100000 (73.65%), epoch=1, lr=1e-05, speed=1.850 step/s, elapsed=11:03:26, eta=03:57:21 +[2026-04-15 16:38:53,972][trainer.accelerators.base_accelerator][INFO] - Training progress: step=73700/100000 (73.70%), epoch=1, lr=1e-05, speed=1.851 step/s, elapsed=11:03:44, eta=03:56:51 +[2026-04-15 16:39:11,790][trainer.accelerators.base_accelerator][INFO] - Training progress: step=73750/100000 (73.75%), epoch=1, lr=1e-05, speed=1.851 step/s, elapsed=11:04:02, eta=03:56:21 +[2026-04-15 16:39:29,622][trainer.accelerators.base_accelerator][INFO] - Training progress: step=73800/100000 (73.80%), epoch=1, lr=1e-05, speed=1.851 step/s, elapsed=11:04:20, eta=03:55:50 +[2026-04-15 16:39:47,524][trainer.accelerators.base_accelerator][INFO] - Training progress: step=73850/100000 (73.85%), epoch=1, lr=1e-05, speed=1.852 step/s, elapsed=11:04:38, eta=03:55:20 +[2026-04-15 16:40:05,372][trainer.accelerators.base_accelerator][INFO] - Training progress: step=73900/100000 (73.90%), epoch=1, lr=1e-05, speed=1.852 step/s, elapsed=11:04:56, eta=03:54:50 +[2026-04-15 16:40:23,195][trainer.accelerators.base_accelerator][INFO] - Training progress: step=73950/100000 (73.95%), epoch=1, lr=1e-05, speed=1.853 step/s, elapsed=11:05:13, eta=03:54:20 +[2026-04-15 16:40:41,105][trainer.accelerators.base_accelerator][INFO] - Training progress: step=74000/100000 (74.00%), epoch=1, lr=1e-05, speed=1.853 step/s, elapsed=11:05:31, eta=03:53:50 +[2026-04-15 16:40:41,130][__main__][INFO] - ========== EVAL START (periodic@gstep=74000) ========== +[2026-04-15 16:40:41,131][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-15 16:40:41,131][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 16:41:02,264][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.108048439025879, 'accuracy': 0.48470588235294115, 'num_samples': 425, 'test_unique_accuracy': 0.47453703703703703, 'test_unique_num_samples': 432} +[2026-04-15 16:41:02,264][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-15 16:41:02,264][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 16:41:17,458][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.108048439025879, 'accuracy': 0.48470588235294115, 'num_samples': 425, 'test_unique_accuracy': 0.47453703703703703, 'test_unique_num_samples': 432} +[2026-04-15 16:41:17,459][__main__][INFO] - ========== EVAL END (periodic@gstep=74000) ========== +[2026-04-15 16:41:17,459][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.104482650756836, 'accuracy': 0.48470588235294115, 'num_samples': 425, 'test_unique_accuracy': 0.47453703703703703, 'test_unique_num_samples': 432} +[2026-04-15 16:41:17,462][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.48470588235294115 is not better than 0.5788235294117647 of logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep32000, skipping checkpoint +[2026-04-15 16:41:35,306][trainer.accelerators.base_accelerator][INFO] - Training progress: step=74050/100000 (74.05%), epoch=1, lr=1e-05, speed=1.852 step/s, elapsed=11:06:25, eta=03:53:32 +[2026-04-15 16:41:53,134][trainer.accelerators.base_accelerator][INFO] - Training progress: step=74100/100000 (74.10%), epoch=1, lr=1e-05, speed=1.852 step/s, elapsed=11:06:43, eta=03:53:02 +[2026-04-15 16:42:11,047][trainer.accelerators.base_accelerator][INFO] - Training progress: step=74150/100000 (74.15%), epoch=1, lr=1e-05, speed=1.853 step/s, elapsed=11:07:01, eta=03:52:32 +[2026-04-15 16:42:28,833][trainer.accelerators.base_accelerator][INFO] - Training progress: step=74200/100000 (74.20%), epoch=1, lr=1e-05, speed=1.853 step/s, elapsed=11:07:19, eta=03:52:02 +[2026-04-15 16:42:46,710][trainer.accelerators.base_accelerator][INFO] - Training progress: step=74250/100000 (74.25%), epoch=1, lr=1e-05, speed=1.854 step/s, elapsed=11:07:37, eta=03:51:31 +[2026-04-15 16:43:04,588][trainer.accelerators.base_accelerator][INFO] - Training progress: step=74300/100000 (74.30%), epoch=1, lr=1e-05, speed=1.854 step/s, elapsed=11:07:55, eta=03:51:01 +[2026-04-15 16:43:22,516][trainer.accelerators.base_accelerator][INFO] - Training progress: step=74350/100000 (74.35%), epoch=1, lr=1e-05, speed=1.854 step/s, elapsed=11:08:13, eta=03:50:31 +[2026-04-15 16:43:40,448][trainer.accelerators.base_accelerator][INFO] - Training progress: step=74400/100000 (74.40%), epoch=1, lr=1e-05, speed=1.855 step/s, elapsed=11:08:31, eta=03:50:01 +[2026-04-15 16:43:58,200][trainer.accelerators.base_accelerator][INFO] - Training progress: step=74450/100000 (74.45%), epoch=1, lr=1e-05, speed=1.855 step/s, elapsed=11:08:48, eta=03:49:31 +[2026-04-15 16:44:16,092][trainer.accelerators.base_accelerator][INFO] - Training progress: step=74500/100000 (74.50%), epoch=1, lr=1e-05, speed=1.856 step/s, elapsed=11:09:06, eta=03:49:01 +[2026-04-15 16:44:34,036][trainer.accelerators.base_accelerator][INFO] - Training progress: step=74550/100000 (74.55%), epoch=1, lr=1e-05, speed=1.856 step/s, elapsed=11:09:24, eta=03:48:31 +[2026-04-15 16:44:51,929][trainer.accelerators.base_accelerator][INFO] - Training progress: step=74600/100000 (74.60%), epoch=1, lr=1e-05, speed=1.857 step/s, elapsed=11:09:42, eta=03:48:01 +[2026-04-15 16:45:09,725][trainer.accelerators.base_accelerator][INFO] - Training progress: step=74650/100000 (74.65%), epoch=1, lr=1e-05, speed=1.857 step/s, elapsed=11:10:00, eta=03:47:31 +[2026-04-15 16:45:27,623][trainer.accelerators.base_accelerator][INFO] - Training progress: step=74700/100000 (74.70%), epoch=1, lr=1e-05, speed=1.857 step/s, elapsed=11:10:18, eta=03:47:01 +[2026-04-15 16:45:45,458][trainer.accelerators.base_accelerator][INFO] - Training progress: step=74750/100000 (74.75%), epoch=1, lr=1e-05, speed=1.858 step/s, elapsed=11:10:36, eta=03:46:31 +[2026-04-15 16:46:03,301][trainer.accelerators.base_accelerator][INFO] - Training progress: step=74800/100000 (74.80%), epoch=1, lr=1e-05, speed=1.858 step/s, elapsed=11:10:53, eta=03:46:01 +[2026-04-15 16:46:21,179][trainer.accelerators.base_accelerator][INFO] - Training progress: step=74850/100000 (74.85%), epoch=1, lr=1e-05, speed=1.859 step/s, elapsed=11:11:11, eta=03:45:31 +[2026-04-15 16:46:39,003][trainer.accelerators.base_accelerator][INFO] - Training progress: step=74900/100000 (74.90%), epoch=1, lr=1e-05, speed=1.859 step/s, elapsed=11:11:29, eta=03:45:01 +[2026-04-15 16:46:56,872][trainer.accelerators.base_accelerator][INFO] - Training progress: step=74950/100000 (74.95%), epoch=1, lr=1e-05, speed=1.859 step/s, elapsed=11:11:47, eta=03:44:31 +[2026-04-15 16:47:14,744][trainer.accelerators.base_accelerator][INFO] - Training progress: step=75000/100000 (75.00%), epoch=1, lr=1e-05, speed=1.860 step/s, elapsed=11:12:05, eta=03:44:01 +[2026-04-15 16:47:14,767][__main__][INFO] - ========== EVAL START (periodic@gstep=75000) ========== +[2026-04-15 16:47:14,768][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-15 16:47:14,768][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 16:47:30,774][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.104482650756836, 'accuracy': 0.48, 'num_samples': 425, 'test_unique_accuracy': 0.47453703703703703, 'test_unique_num_samples': 432} +[2026-04-15 16:47:30,775][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-15 16:47:30,775][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 16:47:45,881][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.104482650756836, 'accuracy': 0.48, 'num_samples': 425, 'test_unique_accuracy': 0.5092592592592593, 'test_unique_num_samples': 432} +[2026-04-15 16:47:45,881][__main__][INFO] - ========== EVAL END (periodic@gstep=75000) ========== +[2026-04-15 16:47:45,881][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.110730171203613, 'accuracy': 0.48, 'num_samples': 425, 'test_unique_accuracy': 0.5092592592592593, 'test_unique_num_samples': 432} +[2026-04-15 16:47:45,885][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.48 is not better than 0.5788235294117647 of logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep32000, skipping checkpoint +[2026-04-15 16:48:04,308][trainer.accelerators.base_accelerator][INFO] - Training progress: step=75050/100000 (75.05%), epoch=1, lr=1e-05, speed=1.859 step/s, elapsed=11:12:54, eta=03:43:42 +[2026-04-15 16:48:22,216][trainer.accelerators.base_accelerator][INFO] - Training progress: step=75100/100000 (75.10%), epoch=1, lr=1e-05, speed=1.859 step/s, elapsed=11:13:12, eta=03:43:12 +[2026-04-15 16:48:39,995][trainer.accelerators.base_accelerator][INFO] - Training progress: step=75150/100000 (75.15%), epoch=1, lr=1e-05, speed=1.860 step/s, elapsed=11:13:30, eta=03:42:42 +[2026-04-15 16:48:57,807][trainer.accelerators.base_accelerator][INFO] - Training progress: step=75200/100000 (75.20%), epoch=1, lr=1e-05, speed=1.860 step/s, elapsed=11:13:48, eta=03:42:12 +[2026-04-15 16:49:15,756][trainer.accelerators.base_accelerator][INFO] - Training progress: step=75250/100000 (75.25%), epoch=1, lr=1e-05, speed=1.860 step/s, elapsed=11:14:06, eta=03:41:42 +[2026-04-15 16:49:33,587][trainer.accelerators.base_accelerator][INFO] - Training progress: step=75300/100000 (75.30%), epoch=1, lr=1e-05, speed=1.861 step/s, elapsed=11:14:24, eta=03:41:13 +[2026-04-15 16:49:51,455][trainer.accelerators.base_accelerator][INFO] - Training progress: step=75350/100000 (75.35%), epoch=1, lr=1e-05, speed=1.861 step/s, elapsed=11:14:42, eta=03:40:43 +[2026-04-15 16:50:09,299][trainer.accelerators.base_accelerator][INFO] - Training progress: step=75400/100000 (75.40%), epoch=1, lr=1e-05, speed=1.862 step/s, elapsed=11:14:59, eta=03:40:13 +[2026-04-15 16:50:27,178][trainer.accelerators.base_accelerator][INFO] - Training progress: step=75450/100000 (75.45%), epoch=1, lr=1e-05, speed=1.862 step/s, elapsed=11:15:17, eta=03:39:43 +[2026-04-15 16:50:45,082][trainer.accelerators.base_accelerator][INFO] - Training progress: step=75500/100000 (75.50%), epoch=1, lr=1e-05, speed=1.863 step/s, elapsed=11:15:35, eta=03:39:13 +[2026-04-15 16:51:02,845][trainer.accelerators.base_accelerator][INFO] - Training progress: step=75550/100000 (75.55%), epoch=1, lr=1e-05, speed=1.863 step/s, elapsed=11:15:53, eta=03:38:44 +[2026-04-15 16:51:20,680][trainer.accelerators.base_accelerator][INFO] - Training progress: step=75600/100000 (75.60%), epoch=1, lr=1e-05, speed=1.863 step/s, elapsed=11:16:11, eta=03:38:14 +[2026-04-15 16:51:38,516][trainer.accelerators.base_accelerator][INFO] - Training progress: step=75650/100000 (75.65%), epoch=1, lr=1e-05, speed=1.864 step/s, elapsed=11:16:29, eta=03:37:44 +[2026-04-15 16:51:56,361][trainer.accelerators.base_accelerator][INFO] - Training progress: step=75700/100000 (75.70%), epoch=1, lr=1e-05, speed=1.864 step/s, elapsed=11:16:47, eta=03:37:15 +[2026-04-15 16:52:14,242][trainer.accelerators.base_accelerator][INFO] - Training progress: step=75750/100000 (75.75%), epoch=1, lr=1e-05, speed=1.865 step/s, elapsed=11:17:04, eta=03:36:45 +[2026-04-15 16:52:32,097][trainer.accelerators.base_accelerator][INFO] - Training progress: step=75800/100000 (75.80%), epoch=1, lr=1e-05, speed=1.865 step/s, elapsed=11:17:22, eta=03:36:15 +[2026-04-15 16:52:50,139][trainer.accelerators.base_accelerator][INFO] - Training progress: step=75850/100000 (75.85%), epoch=1, lr=1e-05, speed=1.865 step/s, elapsed=11:17:40, eta=03:35:46 +[2026-04-15 16:53:08,098][trainer.accelerators.base_accelerator][INFO] - Training progress: step=75900/100000 (75.90%), epoch=1, lr=1e-05, speed=1.866 step/s, elapsed=11:17:58, eta=03:35:16 +[2026-04-15 16:53:25,998][trainer.accelerators.base_accelerator][INFO] - Training progress: step=75950/100000 (75.95%), epoch=1, lr=1e-05, speed=1.866 step/s, elapsed=11:18:16, eta=03:34:46 +[2026-04-15 16:53:43,887][trainer.accelerators.base_accelerator][INFO] - Training progress: step=76000/100000 (76.00%), epoch=1, lr=1e-05, speed=1.867 step/s, elapsed=11:18:34, eta=03:34:17 +[2026-04-15 16:53:43,911][__main__][INFO] - ========== EVAL START (periodic@gstep=76000) ========== +[2026-04-15 16:53:43,911][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-15 16:53:43,911][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 16:54:06,310][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.110730171203613, 'accuracy': 0.5317647058823529, 'num_samples': 425, 'test_unique_accuracy': 0.5092592592592593, 'test_unique_num_samples': 432} +[2026-04-15 16:54:06,310][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-15 16:54:06,310][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 16:54:21,395][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.110730171203613, 'accuracy': 0.5317647058823529, 'num_samples': 425, 'test_unique_accuracy': 0.5046296296296297, 'test_unique_num_samples': 432} +[2026-04-15 16:54:21,396][__main__][INFO] - ========== EVAL END (periodic@gstep=76000) ========== +[2026-04-15 16:54:21,396][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.105347633361816, 'accuracy': 0.5317647058823529, 'num_samples': 425, 'test_unique_accuracy': 0.5046296296296297, 'test_unique_num_samples': 432} +[2026-04-15 16:54:21,444][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.5317647058823529 is not better than 0.5788235294117647 of logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep32000, skipping checkpoint +[2026-04-15 16:54:39,319][trainer.accelerators.base_accelerator][INFO] - Training progress: step=76050/100000 (76.05%), epoch=1, lr=1e-05, speed=1.865 step/s, elapsed=11:19:30, eta=03:33:59 +[2026-04-15 16:54:57,223][trainer.accelerators.base_accelerator][INFO] - Training progress: step=76100/100000 (76.10%), epoch=1, lr=1e-05, speed=1.866 step/s, elapsed=11:19:47, eta=03:33:29 +[2026-04-15 16:55:15,365][trainer.accelerators.base_accelerator][INFO] - Training progress: step=76150/100000 (76.15%), epoch=1, lr=1e-05, speed=1.866 step/s, elapsed=11:20:06, eta=03:33:00 +[2026-04-15 16:55:33,194][trainer.accelerators.base_accelerator][INFO] - Training progress: step=76200/100000 (76.20%), epoch=1, lr=1e-05, speed=1.867 step/s, elapsed=11:20:23, eta=03:32:30 +[2026-04-15 16:55:51,041][trainer.accelerators.base_accelerator][INFO] - Training progress: step=76250/100000 (76.25%), epoch=1, lr=1e-05, speed=1.867 step/s, elapsed=11:20:41, eta=03:32:01 +[2026-04-15 16:56:08,940][trainer.accelerators.base_accelerator][INFO] - Training progress: step=76300/100000 (76.30%), epoch=1, lr=1e-05, speed=1.867 step/s, elapsed=11:20:59, eta=03:31:31 +[2026-04-15 16:56:26,687][trainer.accelerators.base_accelerator][INFO] - Training progress: step=76350/100000 (76.35%), epoch=1, lr=1e-05, speed=1.868 step/s, elapsed=11:21:17, eta=03:31:02 +[2026-04-15 16:56:44,531][trainer.accelerators.base_accelerator][INFO] - Training progress: step=76400/100000 (76.40%), epoch=1, lr=1e-05, speed=1.868 step/s, elapsed=11:21:35, eta=03:30:32 +[2026-04-15 16:57:02,447][trainer.accelerators.base_accelerator][INFO] - Training progress: step=76450/100000 (76.45%), epoch=1, lr=1e-05, speed=1.869 step/s, elapsed=11:21:53, eta=03:30:03 +[2026-04-15 16:57:20,287][trainer.accelerators.base_accelerator][INFO] - Training progress: step=76500/100000 (76.50%), epoch=1, lr=1e-05, speed=1.869 step/s, elapsed=11:22:10, eta=03:29:33 +[2026-04-15 16:57:38,121][trainer.accelerators.base_accelerator][INFO] - Training progress: step=76550/100000 (76.55%), epoch=1, lr=1e-05, speed=1.869 step/s, elapsed=11:22:28, eta=03:29:04 +[2026-04-15 16:57:56,013][trainer.accelerators.base_accelerator][INFO] - Training progress: step=76600/100000 (76.60%), epoch=1, lr=1e-05, speed=1.870 step/s, elapsed=11:22:46, eta=03:28:34 +[2026-04-15 16:58:13,882][trainer.accelerators.base_accelerator][INFO] - Training progress: step=76650/100000 (76.65%), epoch=1, lr=1e-05, speed=1.870 step/s, elapsed=11:23:04, eta=03:28:05 +[2026-04-15 16:58:31,718][trainer.accelerators.base_accelerator][INFO] - Training progress: step=76700/100000 (76.70%), epoch=1, lr=1e-05, speed=1.871 step/s, elapsed=11:23:22, eta=03:27:35 +[2026-04-15 16:58:49,542][trainer.accelerators.base_accelerator][INFO] - Training progress: step=76750/100000 (76.75%), epoch=1, lr=1e-05, speed=1.871 step/s, elapsed=11:23:40, eta=03:27:06 +[2026-04-15 16:59:07,299][trainer.accelerators.base_accelerator][INFO] - Training progress: step=76800/100000 (76.80%), epoch=1, lr=1e-05, speed=1.871 step/s, elapsed=11:23:57, eta=03:26:36 +[2026-04-15 16:59:25,155][trainer.accelerators.base_accelerator][INFO] - Training progress: step=76850/100000 (76.85%), epoch=1, lr=1e-05, speed=1.872 step/s, elapsed=11:24:15, eta=03:26:07 +[2026-04-15 16:59:43,080][trainer.accelerators.base_accelerator][INFO] - Training progress: step=76900/100000 (76.90%), epoch=1, lr=1e-05, speed=1.872 step/s, elapsed=11:24:33, eta=03:25:38 +[2026-04-15 17:00:00,963][trainer.accelerators.base_accelerator][INFO] - Training progress: step=76950/100000 (76.95%), epoch=1, lr=1e-05, speed=1.873 step/s, elapsed=11:24:51, eta=03:25:08 +[2026-04-15 17:00:18,792][trainer.accelerators.base_accelerator][INFO] - Training progress: step=77000/100000 (77.00%), epoch=1, lr=1e-05, speed=1.873 step/s, elapsed=11:25:09, eta=03:24:39 +[2026-04-15 17:00:18,817][__main__][INFO] - ========== EVAL START (periodic@gstep=77000) ========== +[2026-04-15 17:00:18,817][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-15 17:00:18,817][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 17:00:34,462][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.105347633361816, 'accuracy': 0.4964705882352941, 'num_samples': 425, 'test_unique_accuracy': 0.5046296296296297, 'test_unique_num_samples': 432} +[2026-04-15 17:00:34,462][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-15 17:00:34,462][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 17:00:49,590][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.105347633361816, 'accuracy': 0.4964705882352941, 'num_samples': 425, 'test_unique_accuracy': 0.4861111111111111, 'test_unique_num_samples': 432} +[2026-04-15 17:00:49,590][__main__][INFO] - ========== EVAL END (periodic@gstep=77000) ========== +[2026-04-15 17:00:49,590][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.108530044555664, 'accuracy': 0.4964705882352941, 'num_samples': 425, 'test_unique_accuracy': 0.4861111111111111, 'test_unique_num_samples': 432} +[2026-04-15 17:00:49,611][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.4964705882352941 is not better than 0.5788235294117647 of logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep32000, skipping checkpoint +[2026-04-15 17:01:07,522][trainer.accelerators.base_accelerator][INFO] - Training progress: step=77050/100000 (77.05%), epoch=1, lr=1e-05, speed=1.872 step/s, elapsed=11:25:58, eta=03:24:19 +[2026-04-15 17:01:25,383][trainer.accelerators.base_accelerator][INFO] - Training progress: step=77100/100000 (77.10%), epoch=1, lr=1e-05, speed=1.872 step/s, elapsed=11:26:16, eta=03:23:49 +[2026-04-15 17:01:43,262][trainer.accelerators.base_accelerator][INFO] - Training progress: step=77150/100000 (77.15%), epoch=1, lr=1e-05, speed=1.873 step/s, elapsed=11:26:33, eta=03:23:20 +[2026-04-15 17:02:01,452][trainer.accelerators.base_accelerator][INFO] - Training progress: step=77200/100000 (77.20%), epoch=1, lr=1e-05, speed=1.873 step/s, elapsed=11:26:52, eta=03:22:51 +[2026-04-15 17:02:19,329][trainer.accelerators.base_accelerator][INFO] - Training progress: step=77250/100000 (77.25%), epoch=1, lr=1e-05, speed=1.874 step/s, elapsed=11:27:10, eta=03:22:22 +[2026-04-15 17:02:37,221][trainer.accelerators.base_accelerator][INFO] - Training progress: step=77300/100000 (77.30%), epoch=1, lr=1e-05, speed=1.874 step/s, elapsed=11:27:27, eta=03:21:52 +[2026-04-15 17:02:55,040][trainer.accelerators.base_accelerator][INFO] - Training progress: step=77350/100000 (77.35%), epoch=1, lr=1e-05, speed=1.874 step/s, elapsed=11:27:45, eta=03:21:23 +[2026-04-15 17:03:12,857][trainer.accelerators.base_accelerator][INFO] - Training progress: step=77400/100000 (77.40%), epoch=1, lr=1e-05, speed=1.875 step/s, elapsed=11:28:03, eta=03:20:54 +[2026-04-15 17:03:30,671][trainer.accelerators.base_accelerator][INFO] - Training progress: step=77450/100000 (77.45%), epoch=1, lr=1e-05, speed=1.875 step/s, elapsed=11:28:21, eta=03:20:25 +[2026-04-15 17:03:48,603][trainer.accelerators.base_accelerator][INFO] - Training progress: step=77500/100000 (77.50%), epoch=1, lr=1e-05, speed=1.876 step/s, elapsed=11:28:39, eta=03:19:55 +[2026-04-15 17:04:06,522][trainer.accelerators.base_accelerator][INFO] - Training progress: step=77550/100000 (77.55%), epoch=1, lr=1e-05, speed=1.876 step/s, elapsed=11:28:57, eta=03:19:26 +[2026-04-15 17:04:24,239][trainer.accelerators.base_accelerator][INFO] - Training progress: step=77600/100000 (77.60%), epoch=1, lr=1e-05, speed=1.876 step/s, elapsed=11:29:14, eta=03:18:57 +[2026-04-15 17:04:42,151][trainer.accelerators.base_accelerator][INFO] - Training progress: step=77650/100000 (77.65%), epoch=1, lr=1e-05, speed=1.877 step/s, elapsed=11:29:32, eta=03:18:28 +[2026-04-15 17:04:59,980][trainer.accelerators.base_accelerator][INFO] - Training progress: step=77700/100000 (77.70%), epoch=1, lr=1e-05, speed=1.877 step/s, elapsed=11:29:50, eta=03:17:59 +[2026-04-15 17:05:17,898][trainer.accelerators.base_accelerator][INFO] - Training progress: step=77750/100000 (77.75%), epoch=1, lr=1e-05, speed=1.878 step/s, elapsed=11:30:08, eta=03:17:30 +[2026-04-15 17:05:35,717][trainer.accelerators.base_accelerator][INFO] - Training progress: step=77800/100000 (77.80%), epoch=1, lr=1e-05, speed=1.878 step/s, elapsed=11:30:26, eta=03:17:00 +[2026-04-15 17:05:53,622][trainer.accelerators.base_accelerator][INFO] - Training progress: step=77850/100000 (77.85%), epoch=1, lr=1e-05, speed=1.878 step/s, elapsed=11:30:44, eta=03:16:31 +[2026-04-15 17:06:11,460][trainer.accelerators.base_accelerator][INFO] - Training progress: step=77900/100000 (77.90%), epoch=1, lr=1e-05, speed=1.879 step/s, elapsed=11:31:02, eta=03:16:02 +[2026-04-15 17:06:29,349][trainer.accelerators.base_accelerator][INFO] - Training progress: step=77950/100000 (77.95%), epoch=1, lr=1e-05, speed=1.879 step/s, elapsed=11:31:20, eta=03:15:33 +[2026-04-15 17:06:47,259][trainer.accelerators.base_accelerator][INFO] - Training progress: step=78000/100000 (78.00%), epoch=1, lr=1e-05, speed=1.880 step/s, elapsed=11:31:37, eta=03:15:04 +[2026-04-15 17:06:47,283][__main__][INFO] - ========== EVAL START (periodic@gstep=78000) ========== +[2026-04-15 17:06:47,283][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-15 17:06:47,284][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 17:07:04,803][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.108530044555664, 'accuracy': 0.5011764705882353, 'num_samples': 425, 'test_unique_accuracy': 0.4861111111111111, 'test_unique_num_samples': 432} +[2026-04-15 17:07:04,804][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-15 17:07:04,804][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 17:07:19,922][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.108530044555664, 'accuracy': 0.5011764705882353, 'num_samples': 425, 'test_unique_accuracy': 0.5092592592592593, 'test_unique_num_samples': 432} +[2026-04-15 17:07:19,922][__main__][INFO] - ========== EVAL END (periodic@gstep=78000) ========== +[2026-04-15 17:07:19,922][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.103867530822754, 'accuracy': 0.5011764705882353, 'num_samples': 425, 'test_unique_accuracy': 0.5092592592592593, 'test_unique_num_samples': 432} +[2026-04-15 17:07:19,926][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.5011764705882353 is not better than 0.5788235294117647 of logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep32000, skipping checkpoint +[2026-04-15 17:07:37,748][trainer.accelerators.base_accelerator][INFO] - Training progress: step=78050/100000 (78.05%), epoch=1, lr=1e-05, speed=1.879 step/s, elapsed=11:32:28, eta=03:14:44 +[2026-04-15 17:07:55,591][trainer.accelerators.base_accelerator][INFO] - Training progress: step=78100/100000 (78.10%), epoch=1, lr=1e-05, speed=1.879 step/s, elapsed=11:32:46, eta=03:14:15 +[2026-04-15 17:08:13,301][trainer.accelerators.base_accelerator][INFO] - Training progress: step=78150/100000 (78.15%), epoch=1, lr=1e-05, speed=1.879 step/s, elapsed=11:33:03, eta=03:13:46 +[2026-04-15 17:08:31,168][trainer.accelerators.base_accelerator][INFO] - Training progress: step=78200/100000 (78.20%), epoch=1, lr=1e-05, speed=1.880 step/s, elapsed=11:33:21, eta=03:13:17 +[2026-04-15 17:08:49,024][trainer.accelerators.base_accelerator][INFO] - Training progress: step=78250/100000 (78.25%), epoch=1, lr=1e-05, speed=1.880 step/s, elapsed=11:33:39, eta=03:12:48 +[2026-04-15 17:09:07,169][trainer.accelerators.base_accelerator][INFO] - Training progress: step=78300/100000 (78.30%), epoch=1, lr=1e-05, speed=1.881 step/s, elapsed=11:33:57, eta=03:12:19 +[2026-04-15 17:09:24,996][trainer.accelerators.base_accelerator][INFO] - Training progress: step=78350/100000 (78.35%), epoch=1, lr=1e-05, speed=1.881 step/s, elapsed=11:34:15, eta=03:11:50 +[2026-04-15 17:09:42,756][trainer.accelerators.base_accelerator][INFO] - Training progress: step=78400/100000 (78.40%), epoch=1, lr=1e-05, speed=1.881 step/s, elapsed=11:34:33, eta=03:11:21 +[2026-04-15 17:10:00,495][trainer.accelerators.base_accelerator][INFO] - Training progress: step=78450/100000 (78.45%), epoch=1, lr=1e-05, speed=1.882 step/s, elapsed=11:34:51, eta=03:10:52 +[2026-04-15 17:10:18,357][trainer.accelerators.base_accelerator][INFO] - Training progress: step=78500/100000 (78.50%), epoch=1, lr=1e-05, speed=1.882 step/s, elapsed=11:35:09, eta=03:10:23 +[2026-04-15 17:10:36,289][trainer.accelerators.base_accelerator][INFO] - Training progress: step=78550/100000 (78.55%), epoch=1, lr=1e-05, speed=1.882 step/s, elapsed=11:35:26, eta=03:09:54 +[2026-04-15 17:10:54,204][trainer.accelerators.base_accelerator][INFO] - Training progress: step=78600/100000 (78.60%), epoch=1, lr=1e-05, speed=1.883 step/s, elapsed=11:35:44, eta=03:09:25 +[2026-04-15 17:11:12,101][trainer.accelerators.base_accelerator][INFO] - Training progress: step=78650/100000 (78.65%), epoch=1, lr=1e-05, speed=1.883 step/s, elapsed=11:36:02, eta=03:08:56 +[2026-04-15 17:11:29,866][trainer.accelerators.base_accelerator][INFO] - Training progress: step=78700/100000 (78.70%), epoch=1, lr=1e-05, speed=1.884 step/s, elapsed=11:36:20, eta=03:08:27 +[2026-04-15 17:11:47,739][trainer.accelerators.base_accelerator][INFO] - Training progress: step=78750/100000 (78.75%), epoch=1, lr=1e-05, speed=1.884 step/s, elapsed=11:36:38, eta=03:07:58 +[2026-04-15 17:12:05,623][trainer.accelerators.base_accelerator][INFO] - Training progress: step=78800/100000 (78.80%), epoch=1, lr=1e-05, speed=1.884 step/s, elapsed=11:36:56, eta=03:07:30 +[2026-04-15 17:12:23,531][trainer.accelerators.base_accelerator][INFO] - Training progress: step=78850/100000 (78.85%), epoch=1, lr=1e-05, speed=1.885 step/s, elapsed=11:37:14, eta=03:07:01 +[2026-04-15 17:12:41,326][trainer.accelerators.base_accelerator][INFO] - Training progress: step=78900/100000 (78.90%), epoch=1, lr=1e-05, speed=1.885 step/s, elapsed=11:37:32, eta=03:06:32 +[2026-04-15 17:12:59,157][trainer.accelerators.base_accelerator][INFO] - Training progress: step=78950/100000 (78.95%), epoch=1, lr=1e-05, speed=1.886 step/s, elapsed=11:37:49, eta=03:06:03 +[2026-04-15 17:13:17,057][trainer.accelerators.base_accelerator][INFO] - Training progress: step=79000/100000 (79.00%), epoch=1, lr=1e-05, speed=1.886 step/s, elapsed=11:38:07, eta=03:05:34 +[2026-04-15 17:13:17,082][__main__][INFO] - ========== EVAL START (periodic@gstep=79000) ========== +[2026-04-15 17:13:17,082][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-15 17:13:17,083][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 17:13:32,514][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.103867530822754, 'accuracy': 0.5035294117647059, 'num_samples': 425, 'test_unique_accuracy': 0.5092592592592593, 'test_unique_num_samples': 432} +[2026-04-15 17:13:32,515][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-15 17:13:32,515][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 17:13:47,636][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.103867530822754, 'accuracy': 0.5035294117647059, 'num_samples': 425, 'test_unique_accuracy': 0.4537037037037037, 'test_unique_num_samples': 432} +[2026-04-15 17:13:47,636][__main__][INFO] - ========== EVAL END (periodic@gstep=79000) ========== +[2026-04-15 17:13:47,636][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.105001449584961, 'accuracy': 0.5035294117647059, 'num_samples': 425, 'test_unique_accuracy': 0.4537037037037037, 'test_unique_num_samples': 432} +[2026-04-15 17:13:47,640][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.5035294117647059 is not better than 0.5788235294117647 of logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep32000, skipping checkpoint +[2026-04-15 17:14:05,566][trainer.accelerators.base_accelerator][INFO] - Training progress: step=79050/100000 (79.05%), epoch=1, lr=1e-05, speed=1.885 step/s, elapsed=11:38:56, eta=03:05:14 +[2026-04-15 17:14:23,492][trainer.accelerators.base_accelerator][INFO] - Training progress: step=79100/100000 (79.10%), epoch=1, lr=1e-05, speed=1.885 step/s, elapsed=11:39:14, eta=03:04:45 +[2026-04-15 17:14:41,406][trainer.accelerators.base_accelerator][INFO] - Training progress: step=79150/100000 (79.15%), epoch=1, lr=1e-05, speed=1.886 step/s, elapsed=11:39:32, eta=03:04:16 +[2026-04-15 17:14:59,263][trainer.accelerators.base_accelerator][INFO] - Training progress: step=79200/100000 (79.20%), epoch=1, lr=1e-05, speed=1.886 step/s, elapsed=11:39:49, eta=03:03:47 +[2026-04-15 17:15:17,152][trainer.accelerators.base_accelerator][INFO] - Training progress: step=79250/100000 (79.25%), epoch=1, lr=1e-05, speed=1.887 step/s, elapsed=11:40:07, eta=03:03:18 +[2026-04-15 17:15:35,016][trainer.accelerators.base_accelerator][INFO] - Training progress: step=79300/100000 (79.30%), epoch=1, lr=1e-05, speed=1.887 step/s, elapsed=11:40:25, eta=03:02:50 +[2026-04-15 17:15:52,942][trainer.accelerators.base_accelerator][INFO] - Training progress: step=79350/100000 (79.35%), epoch=1, lr=1e-05, speed=1.887 step/s, elapsed=11:40:43, eta=03:02:21 +[2026-04-15 17:16:11,170][trainer.accelerators.base_accelerator][INFO] - Training progress: step=79400/100000 (79.40%), epoch=1, lr=1e-05, speed=1.888 step/s, elapsed=11:41:01, eta=03:01:52 +[2026-04-15 17:16:29,045][trainer.accelerators.base_accelerator][INFO] - Training progress: step=79450/100000 (79.45%), epoch=1, lr=1e-05, speed=1.888 step/s, elapsed=11:41:19, eta=03:01:24 +[2026-04-15 17:16:46,924][trainer.accelerators.base_accelerator][INFO] - Training progress: step=79500/100000 (79.50%), epoch=1, lr=1e-05, speed=1.888 step/s, elapsed=11:41:37, eta=03:00:55 +[2026-04-15 17:17:04,701][trainer.accelerators.base_accelerator][INFO] - Training progress: step=79550/100000 (79.55%), epoch=1, lr=1e-05, speed=1.889 step/s, elapsed=11:41:55, eta=03:00:26 +[2026-04-15 17:17:22,604][trainer.accelerators.base_accelerator][INFO] - Training progress: step=79600/100000 (79.60%), epoch=1, lr=1e-05, speed=1.889 step/s, elapsed=11:42:13, eta=02:59:57 +[2026-04-15 17:17:40,380][trainer.accelerators.base_accelerator][INFO] - Training progress: step=79650/100000 (79.65%), epoch=1, lr=1e-05, speed=1.890 step/s, elapsed=11:42:31, eta=02:59:29 +[2026-04-15 17:17:58,145][trainer.accelerators.base_accelerator][INFO] - Training progress: step=79700/100000 (79.70%), epoch=1, lr=1e-05, speed=1.890 step/s, elapsed=11:42:48, eta=02:59:00 +[2026-04-15 17:18:16,014][trainer.accelerators.base_accelerator][INFO] - Training progress: step=79750/100000 (79.75%), epoch=1, lr=1e-05, speed=1.890 step/s, elapsed=11:43:06, eta=02:58:31 +[2026-04-15 17:18:33,899][trainer.accelerators.base_accelerator][INFO] - Training progress: step=79800/100000 (79.80%), epoch=1, lr=1e-05, speed=1.891 step/s, elapsed=11:43:24, eta=02:58:03 +[2026-04-15 17:18:51,831][trainer.accelerators.base_accelerator][INFO] - Training progress: step=79850/100000 (79.85%), epoch=1, lr=1e-05, speed=1.891 step/s, elapsed=11:43:42, eta=02:57:34 +[2026-04-15 17:19:09,703][trainer.accelerators.base_accelerator][INFO] - Training progress: step=79900/100000 (79.90%), epoch=1, lr=1e-05, speed=1.892 step/s, elapsed=11:44:00, eta=02:57:06 +[2026-04-15 17:19:27,601][trainer.accelerators.base_accelerator][INFO] - Training progress: step=79950/100000 (79.95%), epoch=1, lr=1e-05, speed=1.892 step/s, elapsed=11:44:18, eta=02:56:37 +[2026-04-15 17:19:45,520][trainer.accelerators.base_accelerator][INFO] - Training progress: step=80000/100000 (80.00%), epoch=1, lr=1e-05, speed=1.892 step/s, elapsed=11:44:36, eta=02:56:09 +[2026-04-15 17:19:45,544][__main__][INFO] - ========== EVAL START (periodic@gstep=80000) ========== +[2026-04-15 17:19:45,545][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-15 17:19:45,545][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 17:20:04,582][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.105001449584961, 'accuracy': 0.49411764705882355, 'num_samples': 425, 'test_unique_accuracy': 0.4537037037037037, 'test_unique_num_samples': 432} +[2026-04-15 17:20:04,583][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-15 17:20:04,583][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 17:20:19,719][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.105001449584961, 'accuracy': 0.49411764705882355, 'num_samples': 425, 'test_unique_accuracy': 0.4930555555555556, 'test_unique_num_samples': 432} +[2026-04-15 17:20:19,720][__main__][INFO] - ========== EVAL END (periodic@gstep=80000) ========== +[2026-04-15 17:20:19,720][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.096512794494629, 'accuracy': 0.49411764705882355, 'num_samples': 425, 'test_unique_accuracy': 0.4930555555555556, 'test_unique_num_samples': 432} +[2026-04-15 17:20:19,823][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.49411764705882355 is not better than 0.5788235294117647 of logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep32000, skipping checkpoint +[2026-04-15 17:20:37,744][trainer.accelerators.base_accelerator][INFO] - Training progress: step=80050/100000 (80.05%), epoch=1, lr=1e-05, speed=1.891 step/s, elapsed=11:45:28, eta=02:55:49 +[2026-04-15 17:20:55,586][trainer.accelerators.base_accelerator][INFO] - Training progress: step=80100/100000 (80.10%), epoch=1, lr=1e-05, speed=1.892 step/s, elapsed=11:45:46, eta=02:55:20 +[2026-04-15 17:21:13,538][trainer.accelerators.base_accelerator][INFO] - Training progress: step=80150/100000 (80.15%), epoch=1, lr=1e-05, speed=1.892 step/s, elapsed=11:46:04, eta=02:54:51 +[2026-04-15 17:21:31,484][trainer.accelerators.base_accelerator][INFO] - Training progress: step=80200/100000 (80.20%), epoch=1, lr=1e-05, speed=1.892 step/s, elapsed=11:46:22, eta=02:54:23 +[2026-04-15 17:21:49,313][trainer.accelerators.base_accelerator][INFO] - Training progress: step=80250/100000 (80.25%), epoch=1, lr=1e-05, speed=1.893 step/s, elapsed=11:46:39, eta=02:53:54 +[2026-04-15 17:22:07,214][trainer.accelerators.base_accelerator][INFO] - Training progress: step=80300/100000 (80.30%), epoch=1, lr=1e-05, speed=1.893 step/s, elapsed=11:46:57, eta=02:53:26 +[2026-04-15 17:22:25,151][trainer.accelerators.base_accelerator][INFO] - Training progress: step=80350/100000 (80.35%), epoch=1, lr=1e-05, speed=1.893 step/s, elapsed=11:47:15, eta=02:52:57 +[2026-04-15 17:22:43,084][trainer.accelerators.base_accelerator][INFO] - Training progress: step=80400/100000 (80.40%), epoch=1, lr=1e-05, speed=1.894 step/s, elapsed=11:47:33, eta=02:52:29 +[2026-04-15 17:23:00,847][trainer.accelerators.base_accelerator][INFO] - Training progress: step=80450/100000 (80.45%), epoch=1, lr=1e-05, speed=1.894 step/s, elapsed=11:47:51, eta=02:52:00 +[2026-04-15 17:23:19,039][trainer.accelerators.base_accelerator][INFO] - Training progress: step=80500/100000 (80.50%), epoch=1, lr=1e-05, speed=1.895 step/s, elapsed=11:48:09, eta=02:51:32 +[2026-04-15 17:23:36,946][trainer.accelerators.base_accelerator][INFO] - Training progress: step=80550/100000 (80.55%), epoch=1, lr=1e-05, speed=1.895 step/s, elapsed=11:48:27, eta=02:51:04 +[2026-04-15 17:23:54,737][trainer.accelerators.base_accelerator][INFO] - Training progress: step=80600/100000 (80.60%), epoch=1, lr=1e-05, speed=1.895 step/s, elapsed=11:48:45, eta=02:50:35 +[2026-04-15 17:24:12,582][trainer.accelerators.base_accelerator][INFO] - Training progress: step=80650/100000 (80.65%), epoch=1, lr=1e-05, speed=1.896 step/s, elapsed=11:49:03, eta=02:50:07 +[2026-04-15 17:24:30,316][trainer.accelerators.base_accelerator][INFO] - Training progress: step=80700/100000 (80.70%), epoch=1, lr=1e-05, speed=1.896 step/s, elapsed=11:49:20, eta=02:49:38 +[2026-04-15 17:24:48,071][trainer.accelerators.base_accelerator][INFO] - Training progress: step=80750/100000 (80.75%), epoch=1, lr=1e-05, speed=1.896 step/s, elapsed=11:49:38, eta=02:49:10 +[2026-04-15 17:25:05,879][trainer.accelerators.base_accelerator][INFO] - Training progress: step=80800/100000 (80.80%), epoch=1, lr=1e-05, speed=1.897 step/s, elapsed=11:49:56, eta=02:48:41 +[2026-04-15 17:25:23,801][trainer.accelerators.base_accelerator][INFO] - Training progress: step=80850/100000 (80.85%), epoch=1, lr=1e-05, speed=1.897 step/s, elapsed=11:50:14, eta=02:48:13 +[2026-04-15 17:25:41,689][trainer.accelerators.base_accelerator][INFO] - Training progress: step=80900/100000 (80.90%), epoch=1, lr=1e-05, speed=1.898 step/s, elapsed=11:50:32, eta=02:47:45 +[2026-04-15 17:25:59,567][trainer.accelerators.base_accelerator][INFO] - Training progress: step=80950/100000 (80.95%), epoch=1, lr=1e-05, speed=1.898 step/s, elapsed=11:50:50, eta=02:47:16 +[2026-04-15 17:26:17,431][trainer.accelerators.base_accelerator][INFO] - Training progress: step=81000/100000 (81.00%), epoch=1, lr=1e-05, speed=1.898 step/s, elapsed=11:51:08, eta=02:46:48 +[2026-04-15 17:26:17,455][__main__][INFO] - ========== EVAL START (periodic@gstep=81000) ========== +[2026-04-15 17:26:17,455][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-15 17:26:17,455][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 17:26:32,672][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.096512794494629, 'accuracy': 0.48705882352941177, 'num_samples': 425, 'test_unique_accuracy': 0.4930555555555556, 'test_unique_num_samples': 432} +[2026-04-15 17:26:32,672][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-15 17:26:32,673][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 17:26:47,796][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.096512794494629, 'accuracy': 0.48705882352941177, 'num_samples': 425, 'test_unique_accuracy': 0.48148148148148145, 'test_unique_num_samples': 432} +[2026-04-15 17:26:47,796][__main__][INFO] - ========== EVAL END (periodic@gstep=81000) ========== +[2026-04-15 17:26:47,796][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.091438293457031, 'accuracy': 0.48705882352941177, 'num_samples': 425, 'test_unique_accuracy': 0.48148148148148145, 'test_unique_num_samples': 432} +[2026-04-15 17:26:47,819][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.48705882352941177 is not better than 0.5788235294117647 of logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep32000, skipping checkpoint +[2026-04-15 17:27:05,695][trainer.accelerators.base_accelerator][INFO] - Training progress: step=81050/100000 (81.05%), epoch=1, lr=1e-05, speed=1.897 step/s, elapsed=11:51:56, eta=02:46:27 +[2026-04-15 17:27:23,607][trainer.accelerators.base_accelerator][INFO] - Training progress: step=81100/100000 (81.10%), epoch=1, lr=1e-05, speed=1.898 step/s, elapsed=11:52:14, eta=02:45:59 +[2026-04-15 17:27:41,324][trainer.accelerators.base_accelerator][INFO] - Training progress: step=81150/100000 (81.15%), epoch=1, lr=1e-05, speed=1.898 step/s, elapsed=11:52:32, eta=02:45:30 +[2026-04-15 17:27:59,259][trainer.accelerators.base_accelerator][INFO] - Training progress: step=81200/100000 (81.20%), epoch=1, lr=1e-05, speed=1.899 step/s, elapsed=11:52:49, eta=02:45:02 +[2026-04-15 17:28:16,996][trainer.accelerators.base_accelerator][INFO] - Training progress: step=81250/100000 (81.25%), epoch=1, lr=1e-05, speed=1.899 step/s, elapsed=11:53:07, eta=02:44:34 +[2026-04-15 17:28:34,915][trainer.accelerators.base_accelerator][INFO] - Training progress: step=81300/100000 (81.30%), epoch=1, lr=1e-05, speed=1.899 step/s, elapsed=11:53:25, eta=02:44:05 +[2026-04-15 17:28:52,826][trainer.accelerators.base_accelerator][INFO] - Training progress: step=81350/100000 (81.35%), epoch=1, lr=1e-05, speed=1.900 step/s, elapsed=11:53:43, eta=02:43:37 +[2026-04-15 17:29:10,745][trainer.accelerators.base_accelerator][INFO] - Training progress: step=81400/100000 (81.40%), epoch=1, lr=1e-05, speed=1.900 step/s, elapsed=11:54:01, eta=02:43:09 +[2026-04-15 17:29:28,722][trainer.accelerators.base_accelerator][INFO] - Training progress: step=81450/100000 (81.45%), epoch=1, lr=1e-05, speed=1.900 step/s, elapsed=11:54:19, eta=02:42:41 +[2026-04-15 17:29:46,550][trainer.accelerators.base_accelerator][INFO] - Training progress: step=81500/100000 (81.50%), epoch=1, lr=1e-05, speed=1.901 step/s, elapsed=11:54:37, eta=02:42:12 +[2026-04-15 17:30:04,711][trainer.accelerators.base_accelerator][INFO] - Training progress: step=81550/100000 (81.55%), epoch=1, lr=1e-05, speed=1.901 step/s, elapsed=11:54:55, eta=02:41:44 +[2026-04-15 17:30:22,601][trainer.accelerators.base_accelerator][INFO] - Training progress: step=81600/100000 (81.60%), epoch=1, lr=1e-05, speed=1.902 step/s, elapsed=11:55:13, eta=02:41:16 +[2026-04-15 17:30:40,454][trainer.accelerators.base_accelerator][INFO] - Training progress: step=81650/100000 (81.65%), epoch=1, lr=1e-05, speed=1.902 step/s, elapsed=11:55:31, eta=02:40:48 +[2026-04-15 17:30:58,320][trainer.accelerators.base_accelerator][INFO] - Training progress: step=81700/100000 (81.70%), epoch=1, lr=1e-05, speed=1.902 step/s, elapsed=11:55:49, eta=02:40:20 +[2026-04-15 17:31:16,193][trainer.accelerators.base_accelerator][INFO] - Training progress: step=81750/100000 (81.75%), epoch=1, lr=1e-05, speed=1.903 step/s, elapsed=11:56:06, eta=02:39:51 +[2026-04-15 17:31:34,085][trainer.accelerators.base_accelerator][INFO] - Training progress: step=81800/100000 (81.80%), epoch=1, lr=1e-05, speed=1.903 step/s, elapsed=11:56:24, eta=02:39:23 +[2026-04-15 17:31:51,985][trainer.accelerators.base_accelerator][INFO] - Training progress: step=81850/100000 (81.85%), epoch=1, lr=1e-05, speed=1.903 step/s, elapsed=11:56:42, eta=02:38:55 +[2026-04-15 17:32:09,920][trainer.accelerators.base_accelerator][INFO] - Training progress: step=81900/100000 (81.90%), epoch=1, lr=1e-05, speed=1.904 step/s, elapsed=11:57:00, eta=02:38:27 +[2026-04-15 17:32:27,771][trainer.accelerators.base_accelerator][INFO] - Training progress: step=81950/100000 (81.95%), epoch=1, lr=1e-05, speed=1.904 step/s, elapsed=11:57:18, eta=02:37:59 +[2026-04-15 17:32:45,621][trainer.accelerators.base_accelerator][INFO] - Training progress: step=82000/100000 (82.00%), epoch=1, lr=1e-05, speed=1.904 step/s, elapsed=11:57:36, eta=02:37:31 +[2026-04-15 17:32:45,646][__main__][INFO] - ========== EVAL START (periodic@gstep=82000) ========== +[2026-04-15 17:32:45,646][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-15 17:32:45,647][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 17:33:02,002][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.091438293457031, 'accuracy': 0.49411764705882355, 'num_samples': 425, 'test_unique_accuracy': 0.48148148148148145, 'test_unique_num_samples': 432} +[2026-04-15 17:33:02,002][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-15 17:33:02,003][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 17:33:17,174][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.091438293457031, 'accuracy': 0.49411764705882355, 'num_samples': 425, 'test_unique_accuracy': 0.49074074074074076, 'test_unique_num_samples': 432} +[2026-04-15 17:33:17,175][__main__][INFO] - ========== EVAL END (periodic@gstep=82000) ========== +[2026-04-15 17:33:17,175][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.08539867401123, 'accuracy': 0.49411764705882355, 'num_samples': 425, 'test_unique_accuracy': 0.49074074074074076, 'test_unique_num_samples': 432} +[2026-04-15 17:33:17,178][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.49411764705882355 is not better than 0.5788235294117647 of logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep32000, skipping checkpoint +[2026-04-15 17:33:35,034][trainer.accelerators.base_accelerator][INFO] - Training progress: step=82050/100000 (82.05%), epoch=1, lr=1e-05, speed=1.903 step/s, elapsed=11:58:25, eta=02:37:10 +[2026-04-15 17:33:52,963][trainer.accelerators.base_accelerator][INFO] - Training progress: step=82100/100000 (82.10%), epoch=1, lr=1e-05, speed=1.904 step/s, elapsed=11:58:43, eta=02:36:42 +[2026-04-15 17:34:10,690][trainer.accelerators.base_accelerator][INFO] - Training progress: step=82150/100000 (82.15%), epoch=1, lr=1e-05, speed=1.904 step/s, elapsed=11:59:01, eta=02:36:13 +[2026-04-15 17:34:28,562][trainer.accelerators.base_accelerator][INFO] - Training progress: step=82200/100000 (82.20%), epoch=1, lr=1e-05, speed=1.905 step/s, elapsed=11:59:19, eta=02:35:45 +[2026-04-15 17:34:46,483][trainer.accelerators.base_accelerator][INFO] - Training progress: step=82250/100000 (82.25%), epoch=1, lr=1e-05, speed=1.905 step/s, elapsed=11:59:37, eta=02:35:17 +[2026-04-15 17:35:04,393][trainer.accelerators.base_accelerator][INFO] - Training progress: step=82300/100000 (82.30%), epoch=1, lr=1e-05, speed=1.905 step/s, elapsed=11:59:55, eta=02:34:49 +[2026-04-15 17:35:22,282][trainer.accelerators.base_accelerator][INFO] - Training progress: step=82350/100000 (82.35%), epoch=1, lr=1e-05, speed=1.906 step/s, elapsed=12:00:12, eta=02:34:21 +[2026-04-15 17:35:40,132][trainer.accelerators.base_accelerator][INFO] - Training progress: step=82400/100000 (82.40%), epoch=1, lr=1e-05, speed=1.906 step/s, elapsed=12:00:30, eta=02:33:53 +[2026-04-15 17:35:58,038][trainer.accelerators.base_accelerator][INFO] - Training progress: step=82450/100000 (82.45%), epoch=1, lr=1e-05, speed=1.906 step/s, elapsed=12:00:48, eta=02:33:25 +[2026-04-15 17:36:15,917][trainer.accelerators.base_accelerator][INFO] - Training progress: step=82500/100000 (82.50%), epoch=1, lr=1e-05, speed=1.907 step/s, elapsed=12:01:06, eta=02:32:57 +[2026-04-15 17:36:33,813][trainer.accelerators.base_accelerator][INFO] - Training progress: step=82550/100000 (82.55%), epoch=1, lr=1e-05, speed=1.907 step/s, elapsed=12:01:24, eta=02:32:29 +[2026-04-15 17:36:51,595][trainer.accelerators.base_accelerator][INFO] - Training progress: step=82600/100000 (82.60%), epoch=1, lr=1e-05, speed=1.908 step/s, elapsed=12:01:42, eta=02:32:01 +[2026-04-15 17:37:09,782][trainer.accelerators.base_accelerator][INFO] - Training progress: step=82650/100000 (82.65%), epoch=1, lr=1e-05, speed=1.908 step/s, elapsed=12:02:00, eta=02:31:33 +[2026-04-15 17:37:27,586][trainer.accelerators.base_accelerator][INFO] - Training progress: step=82700/100000 (82.70%), epoch=1, lr=1e-05, speed=1.908 step/s, elapsed=12:02:18, eta=02:31:05 +[2026-04-15 17:37:45,416][trainer.accelerators.base_accelerator][INFO] - Training progress: step=82750/100000 (82.75%), epoch=1, lr=1e-05, speed=1.909 step/s, elapsed=12:02:36, eta=02:30:37 +[2026-04-15 17:38:03,127][trainer.accelerators.base_accelerator][INFO] - Training progress: step=82800/100000 (82.80%), epoch=1, lr=1e-05, speed=1.909 step/s, elapsed=12:02:53, eta=02:30:10 +[2026-04-15 17:38:20,979][trainer.accelerators.base_accelerator][INFO] - Training progress: step=82850/100000 (82.85%), epoch=1, lr=1e-05, speed=1.909 step/s, elapsed=12:03:11, eta=02:29:42 +[2026-04-15 17:38:38,838][trainer.accelerators.base_accelerator][INFO] - Training progress: step=82900/100000 (82.90%), epoch=1, lr=1e-05, speed=1.910 step/s, elapsed=12:03:29, eta=02:29:14 +[2026-04-15 17:38:56,767][trainer.accelerators.base_accelerator][INFO] - Training progress: step=82950/100000 (82.95%), epoch=1, lr=1e-05, speed=1.910 step/s, elapsed=12:03:47, eta=02:28:46 +[2026-04-15 17:39:14,582][trainer.accelerators.base_accelerator][INFO] - Training progress: step=83000/100000 (83.00%), epoch=1, lr=1e-05, speed=1.910 step/s, elapsed=12:04:05, eta=02:28:18 +[2026-04-15 17:39:14,605][__main__][INFO] - ========== EVAL START (periodic@gstep=83000) ========== +[2026-04-15 17:39:14,606][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-15 17:39:14,606][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 17:39:30,062][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.08539867401123, 'accuracy': 0.5341176470588235, 'num_samples': 425, 'test_unique_accuracy': 0.49074074074074076, 'test_unique_num_samples': 432} +[2026-04-15 17:39:30,062][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-15 17:39:30,062][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 17:39:45,187][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.08539867401123, 'accuracy': 0.5341176470588235, 'num_samples': 425, 'test_unique_accuracy': 0.5023148148148148, 'test_unique_num_samples': 432} +[2026-04-15 17:39:45,187][__main__][INFO] - ========== EVAL END (periodic@gstep=83000) ========== +[2026-04-15 17:39:45,187][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.081873893737793, 'accuracy': 0.5341176470588235, 'num_samples': 425, 'test_unique_accuracy': 0.5023148148148148, 'test_unique_num_samples': 432} +[2026-04-15 17:39:45,191][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.5341176470588235 is not better than 0.5788235294117647 of logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep32000, skipping checkpoint +[2026-04-15 17:40:03,095][trainer.accelerators.base_accelerator][INFO] - Training progress: step=83050/100000 (83.05%), epoch=1, lr=1e-05, speed=1.909 step/s, elapsed=12:04:53, eta=02:27:56 +[2026-04-15 17:40:21,008][trainer.accelerators.base_accelerator][INFO] - Training progress: step=83100/100000 (83.10%), epoch=1, lr=1e-05, speed=1.910 step/s, elapsed=12:05:11, eta=02:27:28 +[2026-04-15 17:40:38,909][trainer.accelerators.base_accelerator][INFO] - Training progress: step=83150/100000 (83.15%), epoch=1, lr=1e-05, speed=1.910 step/s, elapsed=12:05:29, eta=02:27:01 +[2026-04-15 17:40:56,864][trainer.accelerators.base_accelerator][INFO] - Training progress: step=83200/100000 (83.20%), epoch=1, lr=1e-05, speed=1.911 step/s, elapsed=12:05:47, eta=02:26:33 +[2026-04-15 17:41:14,824][trainer.accelerators.base_accelerator][INFO] - Training progress: step=83250/100000 (83.25%), epoch=1, lr=1e-05, speed=1.911 step/s, elapsed=12:06:05, eta=02:26:05 +[2026-04-15 17:41:32,804][trainer.accelerators.base_accelerator][INFO] - Training progress: step=83300/100000 (83.30%), epoch=1, lr=1e-05, speed=1.911 step/s, elapsed=12:06:23, eta=02:25:37 +[2026-04-15 17:41:50,737][trainer.accelerators.base_accelerator][INFO] - Training progress: step=83350/100000 (83.35%), epoch=1, lr=1e-05, speed=1.912 step/s, elapsed=12:06:41, eta=02:25:09 +[2026-04-15 17:42:08,599][trainer.accelerators.base_accelerator][INFO] - Training progress: step=83400/100000 (83.40%), epoch=1, lr=1e-05, speed=1.912 step/s, elapsed=12:06:59, eta=02:24:42 +[2026-04-15 17:42:26,590][trainer.accelerators.base_accelerator][INFO] - Training progress: step=83450/100000 (83.45%), epoch=1, lr=1e-05, speed=1.912 step/s, elapsed=12:07:17, eta=02:24:14 +[2026-04-15 17:42:44,385][trainer.accelerators.base_accelerator][INFO] - Training progress: step=83500/100000 (83.50%), epoch=1, lr=1e-05, speed=1.913 step/s, elapsed=12:07:35, eta=02:23:46 +[2026-04-15 17:43:02,313][trainer.accelerators.base_accelerator][INFO] - Training progress: step=83550/100000 (83.55%), epoch=1, lr=1e-05, speed=1.913 step/s, elapsed=12:07:52, eta=02:23:18 +[2026-04-15 17:43:20,281][trainer.accelerators.base_accelerator][INFO] - Training progress: step=83600/100000 (83.60%), epoch=1, lr=1e-05, speed=1.913 step/s, elapsed=12:08:10, eta=02:22:50 +[2026-04-15 17:43:38,262][trainer.accelerators.base_accelerator][INFO] - Training progress: step=83650/100000 (83.65%), epoch=1, lr=1e-05, speed=1.914 step/s, elapsed=12:08:28, eta=02:22:23 +[2026-04-15 17:43:56,156][trainer.accelerators.base_accelerator][INFO] - Training progress: step=83700/100000 (83.70%), epoch=1, lr=1e-05, speed=1.914 step/s, elapsed=12:08:46, eta=02:21:55 +[2026-04-15 17:44:14,612][trainer.accelerators.base_accelerator][INFO] - Training progress: step=83750/100000 (83.75%), epoch=1, lr=1e-05, speed=1.914 step/s, elapsed=12:09:05, eta=02:21:27 +[2026-04-15 17:44:32,608][trainer.accelerators.base_accelerator][INFO] - Training progress: step=83800/100000 (83.80%), epoch=1, lr=1e-05, speed=1.915 step/s, elapsed=12:09:23, eta=02:21:00 +[2026-04-15 17:44:50,571][trainer.accelerators.base_accelerator][INFO] - Training progress: step=83850/100000 (83.85%), epoch=1, lr=1e-05, speed=1.915 step/s, elapsed=12:09:41, eta=02:20:32 +[2026-04-15 17:45:08,537][trainer.accelerators.base_accelerator][INFO] - Training progress: step=83900/100000 (83.90%), epoch=1, lr=1e-05, speed=1.916 step/s, elapsed=12:09:59, eta=02:20:04 +[2026-04-15 17:45:26,801][trainer.accelerators.base_accelerator][INFO] - Training progress: step=83950/100000 (83.95%), epoch=1, lr=1e-05, speed=1.916 step/s, elapsed=12:10:17, eta=02:19:37 +[2026-04-15 17:45:44,728][trainer.accelerators.base_accelerator][INFO] - Training progress: step=84000/100000 (84.00%), epoch=1, lr=1e-05, speed=1.916 step/s, elapsed=12:10:35, eta=02:19:09 +[2026-04-15 17:45:44,752][__main__][INFO] - ========== EVAL START (periodic@gstep=84000) ========== +[2026-04-15 17:45:44,752][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-15 17:45:44,753][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 17:46:03,427][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.081873893737793, 'accuracy': 0.4988235294117647, 'num_samples': 425, 'test_unique_accuracy': 0.5023148148148148, 'test_unique_num_samples': 432} +[2026-04-15 17:46:03,428][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-15 17:46:03,428][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 17:46:18,565][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.081873893737793, 'accuracy': 0.4988235294117647, 'num_samples': 425, 'test_unique_accuracy': 0.46064814814814814, 'test_unique_num_samples': 432} +[2026-04-15 17:46:18,565][__main__][INFO] - ========== EVAL END (periodic@gstep=84000) ========== +[2026-04-15 17:46:18,565][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.076461791992188, 'accuracy': 0.4988235294117647, 'num_samples': 425, 'test_unique_accuracy': 0.46064814814814814, 'test_unique_num_samples': 432} +[2026-04-15 17:46:18,612][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.4988235294117647 is not better than 0.5788235294117647 of logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep32000, skipping checkpoint +[2026-04-15 17:46:36,597][trainer.accelerators.base_accelerator][INFO] - Training progress: step=84050/100000 (84.05%), epoch=1, lr=1e-05, speed=1.915 step/s, elapsed=12:11:27, eta=02:18:48 +[2026-04-15 17:46:54,462][trainer.accelerators.base_accelerator][INFO] - Training progress: step=84100/100000 (84.10%), epoch=1, lr=1e-05, speed=1.915 step/s, elapsed=12:11:45, eta=02:18:20 +[2026-04-15 17:47:12,292][trainer.accelerators.base_accelerator][INFO] - Training progress: step=84150/100000 (84.15%), epoch=1, lr=1e-05, speed=1.916 step/s, elapsed=12:12:02, eta=02:17:53 +[2026-04-15 17:47:30,200][trainer.accelerators.base_accelerator][INFO] - Training progress: step=84200/100000 (84.20%), epoch=1, lr=1e-05, speed=1.916 step/s, elapsed=12:12:20, eta=02:17:25 +[2026-04-15 17:47:47,944][trainer.accelerators.base_accelerator][INFO] - Training progress: step=84250/100000 (84.25%), epoch=1, lr=1e-05, speed=1.917 step/s, elapsed=12:12:38, eta=02:16:57 +[2026-04-15 17:48:05,838][trainer.accelerators.base_accelerator][INFO] - Training progress: step=84300/100000 (84.30%), epoch=1, lr=1e-05, speed=1.917 step/s, elapsed=12:12:56, eta=02:16:30 +[2026-04-15 17:48:23,672][trainer.accelerators.base_accelerator][INFO] - Training progress: step=84350/100000 (84.35%), epoch=1, lr=1e-05, speed=1.917 step/s, elapsed=12:13:14, eta=02:16:02 +[2026-04-15 17:48:41,573][trainer.accelerators.base_accelerator][INFO] - Training progress: step=84400/100000 (84.40%), epoch=1, lr=1e-05, speed=1.918 step/s, elapsed=12:13:32, eta=02:15:34 +[2026-04-15 17:48:59,342][trainer.accelerators.base_accelerator][INFO] - Training progress: step=84450/100000 (84.45%), epoch=1, lr=1e-05, speed=1.918 step/s, elapsed=12:13:50, eta=02:15:07 +[2026-04-15 17:49:17,259][trainer.accelerators.base_accelerator][INFO] - Training progress: step=84500/100000 (84.50%), epoch=1, lr=1e-05, speed=1.918 step/s, elapsed=12:14:07, eta=02:14:39 +[2026-04-15 17:49:35,155][trainer.accelerators.base_accelerator][INFO] - Training progress: step=84550/100000 (84.55%), epoch=1, lr=1e-05, speed=1.919 step/s, elapsed=12:14:25, eta=02:14:12 +[2026-04-15 17:49:52,983][trainer.accelerators.base_accelerator][INFO] - Training progress: step=84600/100000 (84.60%), epoch=1, lr=1e-05, speed=1.919 step/s, elapsed=12:14:43, eta=02:13:44 +[2026-04-15 17:50:10,839][trainer.accelerators.base_accelerator][INFO] - Training progress: step=84650/100000 (84.65%), epoch=1, lr=1e-05, speed=1.919 step/s, elapsed=12:15:01, eta=02:13:17 +[2026-04-15 17:50:28,738][trainer.accelerators.base_accelerator][INFO] - Training progress: step=84700/100000 (84.70%), epoch=1, lr=1e-05, speed=1.920 step/s, elapsed=12:15:19, eta=02:12:49 +[2026-04-15 17:50:46,569][trainer.accelerators.base_accelerator][INFO] - Training progress: step=84750/100000 (84.75%), epoch=1, lr=1e-05, speed=1.920 step/s, elapsed=12:15:37, eta=02:12:22 +[2026-04-15 17:51:04,843][trainer.accelerators.base_accelerator][INFO] - Training progress: step=84800/100000 (84.80%), epoch=1, lr=1e-05, speed=1.920 step/s, elapsed=12:15:55, eta=02:11:54 +[2026-04-15 17:51:22,716][trainer.accelerators.base_accelerator][INFO] - Training progress: step=84850/100000 (84.85%), epoch=1, lr=1e-05, speed=1.921 step/s, elapsed=12:16:13, eta=02:11:27 +[2026-04-15 17:51:40,612][trainer.accelerators.base_accelerator][INFO] - Training progress: step=84900/100000 (84.90%), epoch=1, lr=1e-05, speed=1.921 step/s, elapsed=12:16:31, eta=02:10:59 +[2026-04-15 17:51:58,479][trainer.accelerators.base_accelerator][INFO] - Training progress: step=84950/100000 (84.95%), epoch=1, lr=1e-05, speed=1.922 step/s, elapsed=12:16:49, eta=02:10:32 +[2026-04-15 17:52:16,376][trainer.accelerators.base_accelerator][INFO] - Training progress: step=85000/100000 (85.00%), epoch=1, lr=1e-05, speed=1.922 step/s, elapsed=12:17:07, eta=02:10:04 +[2026-04-15 17:52:16,401][__main__][INFO] - ========== EVAL START (periodic@gstep=85000) ========== +[2026-04-15 17:52:16,402][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-15 17:52:16,402][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 17:52:31,861][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.076461791992188, 'accuracy': 0.5035294117647059, 'num_samples': 425, 'test_unique_accuracy': 0.46064814814814814, 'test_unique_num_samples': 432} +[2026-04-15 17:52:31,862][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-15 17:52:31,862][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 17:52:46,974][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.076461791992188, 'accuracy': 0.5035294117647059, 'num_samples': 425, 'test_unique_accuracy': 0.5625, 'test_unique_num_samples': 432} +[2026-04-15 17:52:46,974][__main__][INFO] - ========== EVAL END (periodic@gstep=85000) ========== +[2026-04-15 17:52:46,974][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.079926490783691, 'accuracy': 0.5035294117647059, 'num_samples': 425, 'test_unique_accuracy': 0.5625, 'test_unique_num_samples': 432} +[2026-04-15 17:52:47,002][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.5035294117647059 is not better than 0.5788235294117647 of logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep32000, skipping checkpoint +[2026-04-15 17:53:04,907][trainer.accelerators.base_accelerator][INFO] - Training progress: step=85050/100000 (85.05%), epoch=1, lr=1e-05, speed=1.921 step/s, elapsed=12:17:55, eta=02:09:42 +[2026-04-15 17:53:22,792][trainer.accelerators.base_accelerator][INFO] - Training progress: step=85100/100000 (85.10%), epoch=1, lr=1e-05, speed=1.921 step/s, elapsed=12:18:13, eta=02:09:15 +[2026-04-15 17:53:40,715][trainer.accelerators.base_accelerator][INFO] - Training progress: step=85150/100000 (85.15%), epoch=1, lr=1e-05, speed=1.922 step/s, elapsed=12:18:31, eta=02:08:47 +[2026-04-15 17:53:58,541][trainer.accelerators.base_accelerator][INFO] - Training progress: step=85200/100000 (85.20%), epoch=1, lr=1e-05, speed=1.922 step/s, elapsed=12:18:49, eta=02:08:20 +[2026-04-15 17:54:16,338][trainer.accelerators.base_accelerator][INFO] - Training progress: step=85250/100000 (85.25%), epoch=1, lr=1e-05, speed=1.922 step/s, elapsed=12:19:07, eta=02:07:52 +[2026-04-15 17:54:34,216][trainer.accelerators.base_accelerator][INFO] - Training progress: step=85300/100000 (85.30%), epoch=1, lr=1e-05, speed=1.923 step/s, elapsed=12:19:24, eta=02:07:25 +[2026-04-15 17:54:52,124][trainer.accelerators.base_accelerator][INFO] - Training progress: step=85350/100000 (85.35%), epoch=1, lr=1e-05, speed=1.923 step/s, elapsed=12:19:42, eta=02:06:58 +[2026-04-15 17:55:09,969][trainer.accelerators.base_accelerator][INFO] - Training progress: step=85400/100000 (85.40%), epoch=1, lr=1e-05, speed=1.923 step/s, elapsed=12:20:00, eta=02:06:30 +[2026-04-15 17:55:27,762][trainer.accelerators.base_accelerator][INFO] - Training progress: step=85450/100000 (85.45%), epoch=1, lr=1e-05, speed=1.924 step/s, elapsed=12:20:18, eta=02:06:03 +[2026-04-15 17:55:45,607][trainer.accelerators.base_accelerator][INFO] - Training progress: step=85500/100000 (85.50%), epoch=1, lr=1e-05, speed=1.924 step/s, elapsed=12:20:36, eta=02:05:35 +[2026-04-15 17:56:03,333][trainer.accelerators.base_accelerator][INFO] - Training progress: step=85550/100000 (85.55%), epoch=1, lr=1e-05, speed=1.924 step/s, elapsed=12:20:54, eta=02:05:08 +[2026-04-15 17:56:21,210][trainer.accelerators.base_accelerator][INFO] - Training progress: step=85600/100000 (85.60%), epoch=1, lr=1e-05, speed=1.925 step/s, elapsed=12:21:11, eta=02:04:41 +[2026-04-15 17:56:39,105][trainer.accelerators.base_accelerator][INFO] - Training progress: step=85650/100000 (85.65%), epoch=1, lr=1e-05, speed=1.925 step/s, elapsed=12:21:29, eta=02:04:13 +[2026-04-15 17:56:56,894][trainer.accelerators.base_accelerator][INFO] - Training progress: step=85700/100000 (85.70%), epoch=1, lr=1e-05, speed=1.926 step/s, elapsed=12:21:47, eta=02:03:46 +[2026-04-15 17:57:14,610][trainer.accelerators.base_accelerator][INFO] - Training progress: step=85750/100000 (85.75%), epoch=1, lr=1e-05, speed=1.926 step/s, elapsed=12:22:05, eta=02:03:19 +[2026-04-15 17:57:32,459][trainer.accelerators.base_accelerator][INFO] - Training progress: step=85800/100000 (85.80%), epoch=1, lr=1e-05, speed=1.926 step/s, elapsed=12:22:23, eta=02:02:51 +[2026-04-15 17:57:50,378][trainer.accelerators.base_accelerator][INFO] - Training progress: step=85850/100000 (85.85%), epoch=1, lr=1e-05, speed=1.927 step/s, elapsed=12:22:41, eta=02:02:24 +[2026-04-15 17:58:08,582][trainer.accelerators.base_accelerator][INFO] - Training progress: step=85900/100000 (85.90%), epoch=1, lr=1e-05, speed=1.927 step/s, elapsed=12:22:59, eta=02:01:57 +[2026-04-15 17:58:26,377][trainer.accelerators.base_accelerator][INFO] - Training progress: step=85950/100000 (85.95%), epoch=1, lr=1e-05, speed=1.927 step/s, elapsed=12:23:17, eta=02:01:30 +[2026-04-15 17:58:44,166][trainer.accelerators.base_accelerator][INFO] - Training progress: step=86000/100000 (86.00%), epoch=1, lr=1e-05, speed=1.928 step/s, elapsed=12:23:34, eta=02:01:02 +[2026-04-15 17:58:44,190][__main__][INFO] - ========== EVAL START (periodic@gstep=86000) ========== +[2026-04-15 17:58:44,190][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-15 17:58:44,190][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 17:59:00,189][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.079926490783691, 'accuracy': 0.49411764705882355, 'num_samples': 425, 'test_unique_accuracy': 0.5625, 'test_unique_num_samples': 432} +[2026-04-15 17:59:00,189][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-15 17:59:00,189][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 17:59:15,343][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.079926490783691, 'accuracy': 0.49411764705882355, 'num_samples': 425, 'test_unique_accuracy': 0.5162037037037037, 'test_unique_num_samples': 432} +[2026-04-15 17:59:15,343][__main__][INFO] - ========== EVAL END (periodic@gstep=86000) ========== +[2026-04-15 17:59:15,343][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.082944869995117, 'accuracy': 0.49411764705882355, 'num_samples': 425, 'test_unique_accuracy': 0.5162037037037037, 'test_unique_num_samples': 432} +[2026-04-15 17:59:15,347][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.49411764705882355 is not better than 0.5788235294117647 of logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep32000, skipping checkpoint +[2026-04-15 17:59:33,211][trainer.accelerators.base_accelerator][INFO] - Training progress: step=86050/100000 (86.05%), epoch=1, lr=1e-05, speed=1.927 step/s, elapsed=12:24:23, eta=02:00:40 +[2026-04-15 17:59:51,095][trainer.accelerators.base_accelerator][INFO] - Training progress: step=86100/100000 (86.10%), epoch=1, lr=1e-05, speed=1.927 step/s, elapsed=12:24:41, eta=02:00:13 +[2026-04-15 18:00:08,913][trainer.accelerators.base_accelerator][INFO] - Training progress: step=86150/100000 (86.15%), epoch=1, lr=1e-05, speed=1.927 step/s, elapsed=12:24:59, eta=01:59:46 +[2026-04-15 18:00:26,755][trainer.accelerators.base_accelerator][INFO] - Training progress: step=86200/100000 (86.20%), epoch=1, lr=1e-05, speed=1.928 step/s, elapsed=12:25:17, eta=01:59:18 +[2026-04-15 18:00:44,638][trainer.accelerators.base_accelerator][INFO] - Training progress: step=86250/100000 (86.25%), epoch=1, lr=1e-05, speed=1.928 step/s, elapsed=12:25:35, eta=01:58:51 +[2026-04-15 18:01:02,486][trainer.accelerators.base_accelerator][INFO] - Training progress: step=86300/100000 (86.30%), epoch=1, lr=1e-05, speed=1.928 step/s, elapsed=12:25:53, eta=01:58:24 +[2026-04-15 18:01:20,325][trainer.accelerators.base_accelerator][INFO] - Training progress: step=86350/100000 (86.35%), epoch=1, lr=1e-05, speed=1.929 step/s, elapsed=12:26:11, eta=01:57:57 +[2026-04-15 18:01:38,196][trainer.accelerators.base_accelerator][INFO] - Training progress: step=86400/100000 (86.40%), epoch=1, lr=1e-05, speed=1.929 step/s, elapsed=12:26:28, eta=01:57:30 +[2026-04-15 18:01:56,007][trainer.accelerators.base_accelerator][INFO] - Training progress: step=86450/100000 (86.45%), epoch=1, lr=1e-05, speed=1.929 step/s, elapsed=12:26:46, eta=01:57:02 +[2026-04-15 18:02:13,874][trainer.accelerators.base_accelerator][INFO] - Training progress: step=86500/100000 (86.50%), epoch=1, lr=1e-05, speed=1.930 step/s, elapsed=12:27:04, eta=01:56:35 +[2026-04-15 18:02:31,756][trainer.accelerators.base_accelerator][INFO] - Training progress: step=86550/100000 (86.55%), epoch=1, lr=1e-05, speed=1.930 step/s, elapsed=12:27:22, eta=01:56:08 +[2026-04-15 18:02:49,614][trainer.accelerators.base_accelerator][INFO] - Training progress: step=86600/100000 (86.60%), epoch=1, lr=1e-05, speed=1.930 step/s, elapsed=12:27:40, eta=01:55:41 +[2026-04-15 18:03:07,494][trainer.accelerators.base_accelerator][INFO] - Training progress: step=86650/100000 (86.65%), epoch=1, lr=1e-05, speed=1.931 step/s, elapsed=12:27:58, eta=01:55:14 +[2026-04-15 18:03:25,414][trainer.accelerators.base_accelerator][INFO] - Training progress: step=86700/100000 (86.70%), epoch=1, lr=1e-05, speed=1.931 step/s, elapsed=12:28:16, eta=01:54:47 +[2026-04-15 18:03:43,198][trainer.accelerators.base_accelerator][INFO] - Training progress: step=86750/100000 (86.75%), epoch=1, lr=1e-05, speed=1.931 step/s, elapsed=12:28:33, eta=01:54:20 +[2026-04-15 18:04:01,103][trainer.accelerators.base_accelerator][INFO] - Training progress: step=86800/100000 (86.80%), epoch=1, lr=1e-05, speed=1.932 step/s, elapsed=12:28:51, eta=01:53:52 +[2026-04-15 18:04:18,978][trainer.accelerators.base_accelerator][INFO] - Training progress: step=86850/100000 (86.85%), epoch=1, lr=1e-05, speed=1.932 step/s, elapsed=12:29:09, eta=01:53:25 +[2026-04-15 18:04:36,864][trainer.accelerators.base_accelerator][INFO] - Training progress: step=86900/100000 (86.90%), epoch=1, lr=1e-05, speed=1.933 step/s, elapsed=12:29:27, eta=01:52:58 +[2026-04-15 18:04:54,686][trainer.accelerators.base_accelerator][INFO] - Training progress: step=86950/100000 (86.95%), epoch=1, lr=1e-05, speed=1.933 step/s, elapsed=12:29:45, eta=01:52:31 +[2026-04-15 18:05:12,851][trainer.accelerators.base_accelerator][INFO] - Training progress: step=87000/100000 (87.00%), epoch=1, lr=1e-05, speed=1.933 step/s, elapsed=12:30:03, eta=01:52:04 +[2026-04-15 18:05:12,875][__main__][INFO] - ========== EVAL START (periodic@gstep=87000) ========== +[2026-04-15 18:05:12,875][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-15 18:05:12,875][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 18:05:28,531][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.082944869995117, 'accuracy': 0.5411764705882353, 'num_samples': 425, 'test_unique_accuracy': 0.5162037037037037, 'test_unique_num_samples': 432} +[2026-04-15 18:05:28,532][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-15 18:05:28,532][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 18:05:43,650][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.082944869995117, 'accuracy': 0.5411764705882353, 'num_samples': 425, 'test_unique_accuracy': 0.5092592592592593, 'test_unique_num_samples': 432} +[2026-04-15 18:05:43,650][__main__][INFO] - ========== EVAL END (periodic@gstep=87000) ========== +[2026-04-15 18:05:43,650][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.084892272949219, 'accuracy': 0.5411764705882353, 'num_samples': 425, 'test_unique_accuracy': 0.5092592592592593, 'test_unique_num_samples': 432} +[2026-04-15 18:05:43,653][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.5411764705882353 is not better than 0.5788235294117647 of logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep32000, skipping checkpoint +[2026-04-15 18:06:01,412][trainer.accelerators.base_accelerator][INFO] - Training progress: step=87050/100000 (87.05%), epoch=1, lr=1e-05, speed=1.932 step/s, elapsed=12:30:52, eta=01:51:42 +[2026-04-15 18:06:19,120][trainer.accelerators.base_accelerator][INFO] - Training progress: step=87100/100000 (87.10%), epoch=1, lr=1e-05, speed=1.933 step/s, elapsed=12:31:09, eta=01:51:15 +[2026-04-15 18:06:37,019][trainer.accelerators.base_accelerator][INFO] - Training progress: step=87150/100000 (87.15%), epoch=1, lr=1e-05, speed=1.933 step/s, elapsed=12:31:27, eta=01:50:48 +[2026-04-15 18:06:54,917][trainer.accelerators.base_accelerator][INFO] - Training progress: step=87200/100000 (87.20%), epoch=1, lr=1e-05, speed=1.933 step/s, elapsed=12:31:45, eta=01:50:21 +[2026-04-15 18:07:12,816][trainer.accelerators.base_accelerator][INFO] - Training progress: step=87250/100000 (87.25%), epoch=1, lr=1e-05, speed=1.934 step/s, elapsed=12:32:03, eta=01:49:53 +[2026-04-15 18:07:30,709][trainer.accelerators.base_accelerator][INFO] - Training progress: step=87300/100000 (87.30%), epoch=1, lr=1e-05, speed=1.934 step/s, elapsed=12:32:21, eta=01:49:26 +[2026-04-15 18:07:48,597][trainer.accelerators.base_accelerator][INFO] - Training progress: step=87350/100000 (87.35%), epoch=1, lr=1e-05, speed=1.934 step/s, elapsed=12:32:39, eta=01:48:59 +[2026-04-15 18:08:06,454][trainer.accelerators.base_accelerator][INFO] - Training progress: step=87400/100000 (87.40%), epoch=1, lr=1e-05, speed=1.935 step/s, elapsed=12:32:57, eta=01:48:32 +[2026-04-15 18:08:24,225][trainer.accelerators.base_accelerator][INFO] - Training progress: step=87450/100000 (87.45%), epoch=1, lr=1e-05, speed=1.935 step/s, elapsed=12:33:14, eta=01:48:05 +[2026-04-15 18:08:42,042][trainer.accelerators.base_accelerator][INFO] - Training progress: step=87500/100000 (87.50%), epoch=1, lr=1e-05, speed=1.935 step/s, elapsed=12:33:32, eta=01:47:38 +[2026-04-15 18:08:59,806][trainer.accelerators.base_accelerator][INFO] - Training progress: step=87550/100000 (87.55%), epoch=1, lr=1e-05, speed=1.936 step/s, elapsed=12:33:50, eta=01:47:11 +[2026-04-15 18:09:17,690][trainer.accelerators.base_accelerator][INFO] - Training progress: step=87600/100000 (87.60%), epoch=1, lr=1e-05, speed=1.936 step/s, elapsed=12:34:08, eta=01:46:45 +[2026-04-15 18:09:35,529][trainer.accelerators.base_accelerator][INFO] - Training progress: step=87650/100000 (87.65%), epoch=1, lr=1e-05, speed=1.936 step/s, elapsed=12:34:26, eta=01:46:18 +[2026-04-15 18:09:53,422][trainer.accelerators.base_accelerator][INFO] - Training progress: step=87700/100000 (87.70%), epoch=1, lr=1e-05, speed=1.937 step/s, elapsed=12:34:44, eta=01:45:51 +[2026-04-15 18:10:11,280][trainer.accelerators.base_accelerator][INFO] - Training progress: step=87750/100000 (87.75%), epoch=1, lr=1e-05, speed=1.937 step/s, elapsed=12:35:01, eta=01:45:24 +[2026-04-15 18:10:29,138][trainer.accelerators.base_accelerator][INFO] - Training progress: step=87800/100000 (87.80%), epoch=1, lr=1e-05, speed=1.937 step/s, elapsed=12:35:19, eta=01:44:57 +[2026-04-15 18:10:47,076][trainer.accelerators.base_accelerator][INFO] - Training progress: step=87850/100000 (87.85%), epoch=1, lr=1e-05, speed=1.938 step/s, elapsed=12:35:37, eta=01:44:30 +[2026-04-15 18:11:04,917][trainer.accelerators.base_accelerator][INFO] - Training progress: step=87900/100000 (87.90%), epoch=1, lr=1e-05, speed=1.938 step/s, elapsed=12:35:55, eta=01:44:03 +[2026-04-15 18:11:22,850][trainer.accelerators.base_accelerator][INFO] - Training progress: step=87950/100000 (87.95%), epoch=1, lr=1e-05, speed=1.938 step/s, elapsed=12:36:13, eta=01:43:36 +[2026-04-15 18:11:40,738][trainer.accelerators.base_accelerator][INFO] - Training progress: step=88000/100000 (88.00%), epoch=1, lr=1e-05, speed=1.939 step/s, elapsed=12:36:31, eta=01:43:09 +[2026-04-15 18:11:40,761][__main__][INFO] - ========== EVAL START (periodic@gstep=88000) ========== +[2026-04-15 18:11:40,762][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-15 18:11:40,762][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 18:11:59,678][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.084892272949219, 'accuracy': 0.5411764705882353, 'num_samples': 425, 'test_unique_accuracy': 0.5092592592592593, 'test_unique_num_samples': 432} +[2026-04-15 18:11:59,678][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-15 18:11:59,678][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 18:12:15,100][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.084892272949219, 'accuracy': 0.5411764705882353, 'num_samples': 425, 'test_unique_accuracy': 0.5162037037037037, 'test_unique_num_samples': 432} +[2026-04-15 18:12:15,100][__main__][INFO] - ========== EVAL END (periodic@gstep=88000) ========== +[2026-04-15 18:12:15,100][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.083283424377441, 'accuracy': 0.5411764705882353, 'num_samples': 425, 'test_unique_accuracy': 0.5162037037037037, 'test_unique_num_samples': 432} +[2026-04-15 18:12:15,130][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.5411764705882353 is not better than 0.5788235294117647 of logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep32000, skipping checkpoint +[2026-04-15 18:12:33,082][trainer.accelerators.base_accelerator][INFO] - Training progress: step=88050/100000 (88.05%), epoch=1, lr=1e-05, speed=1.938 step/s, elapsed=12:37:23, eta=01:42:47 +[2026-04-15 18:12:51,004][trainer.accelerators.base_accelerator][INFO] - Training progress: step=88100/100000 (88.10%), epoch=1, lr=1e-05, speed=1.938 step/s, elapsed=12:37:41, eta=01:42:20 +[2026-04-15 18:13:08,883][trainer.accelerators.base_accelerator][INFO] - Training progress: step=88150/100000 (88.15%), epoch=1, lr=1e-05, speed=1.938 step/s, elapsed=12:37:59, eta=01:41:53 +[2026-04-15 18:13:26,788][trainer.accelerators.base_accelerator][INFO] - Training progress: step=88200/100000 (88.20%), epoch=1, lr=1e-05, speed=1.939 step/s, elapsed=12:38:17, eta=01:41:26 +[2026-04-15 18:13:44,661][trainer.accelerators.base_accelerator][INFO] - Training progress: step=88250/100000 (88.25%), epoch=1, lr=1e-05, speed=1.939 step/s, elapsed=12:38:35, eta=01:41:00 +[2026-04-15 18:14:02,440][trainer.accelerators.base_accelerator][INFO] - Training progress: step=88300/100000 (88.30%), epoch=1, lr=1e-05, speed=1.939 step/s, elapsed=12:38:53, eta=01:40:33 +[2026-04-15 18:14:20,289][trainer.accelerators.base_accelerator][INFO] - Training progress: step=88350/100000 (88.35%), epoch=1, lr=1e-05, speed=1.940 step/s, elapsed=12:39:10, eta=01:40:06 +[2026-04-15 18:14:38,119][trainer.accelerators.base_accelerator][INFO] - Training progress: step=88400/100000 (88.40%), epoch=1, lr=1e-05, speed=1.940 step/s, elapsed=12:39:28, eta=01:39:39 +[2026-04-15 18:14:55,985][trainer.accelerators.base_accelerator][INFO] - Training progress: step=88450/100000 (88.45%), epoch=1, lr=1e-05, speed=1.940 step/s, elapsed=12:39:46, eta=01:39:12 +[2026-04-15 18:15:13,885][trainer.accelerators.base_accelerator][INFO] - Training progress: step=88500/100000 (88.50%), epoch=1, lr=1e-05, speed=1.941 step/s, elapsed=12:40:04, eta=01:38:46 +[2026-04-15 18:15:27,886][trainer.accelerators.base_accelerator][INFO] - Epoch 1 finished +[2026-04-15 18:15:33,067][trainer.accelerators.base_accelerator][INFO] - Training progress: step=88550/100000 (88.55%), epoch=2, lr=1e-05, speed=1.941 step/s, elapsed=12:40:23, eta=01:38:19 +[2026-04-15 18:15:51,017][trainer.accelerators.base_accelerator][INFO] - Training progress: step=88600/100000 (88.60%), epoch=2, lr=1e-05, speed=1.941 step/s, elapsed=12:40:41, eta=01:37:52 +[2026-04-15 18:16:08,792][trainer.accelerators.base_accelerator][INFO] - Training progress: step=88650/100000 (88.65%), epoch=2, lr=1e-05, speed=1.942 step/s, elapsed=12:40:59, eta=01:37:25 +[2026-04-15 18:16:26,574][trainer.accelerators.base_accelerator][INFO] - Training progress: step=88700/100000 (88.70%), epoch=2, lr=1e-05, speed=1.942 step/s, elapsed=12:41:17, eta=01:36:59 +[2026-04-15 18:16:44,491][trainer.accelerators.base_accelerator][INFO] - Training progress: step=88750/100000 (88.75%), epoch=2, lr=1e-05, speed=1.942 step/s, elapsed=12:41:35, eta=01:36:32 +[2026-04-15 18:17:02,283][trainer.accelerators.base_accelerator][INFO] - Training progress: step=88800/100000 (88.80%), epoch=2, lr=1e-05, speed=1.943 step/s, elapsed=12:41:52, eta=01:36:05 +[2026-04-15 18:17:20,117][trainer.accelerators.base_accelerator][INFO] - Training progress: step=88850/100000 (88.85%), epoch=2, lr=1e-05, speed=1.943 step/s, elapsed=12:42:10, eta=01:35:38 +[2026-04-15 18:17:37,959][trainer.accelerators.base_accelerator][INFO] - Training progress: step=88900/100000 (88.90%), epoch=2, lr=1e-05, speed=1.943 step/s, elapsed=12:42:28, eta=01:35:12 +[2026-04-15 18:17:55,881][trainer.accelerators.base_accelerator][INFO] - Training progress: step=88950/100000 (88.95%), epoch=2, lr=1e-05, speed=1.944 step/s, elapsed=12:42:46, eta=01:34:45 +[2026-04-15 18:18:13,723][trainer.accelerators.base_accelerator][INFO] - Training progress: step=89000/100000 (89.00%), epoch=2, lr=1e-05, speed=1.944 step/s, elapsed=12:43:04, eta=01:34:18 +[2026-04-15 18:18:13,747][__main__][INFO] - ========== EVAL START (periodic@gstep=89000) ========== +[2026-04-15 18:18:13,747][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-15 18:18:13,748][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 18:18:29,021][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.083283424377441, 'accuracy': 0.48705882352941177, 'num_samples': 425, 'test_unique_accuracy': 0.5162037037037037, 'test_unique_num_samples': 432} +[2026-04-15 18:18:29,021][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-15 18:18:29,021][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 18:18:44,162][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.083283424377441, 'accuracy': 0.48705882352941177, 'num_samples': 425, 'test_unique_accuracy': 0.4930555555555556, 'test_unique_num_samples': 432} +[2026-04-15 18:18:44,163][__main__][INFO] - ========== EVAL END (periodic@gstep=89000) ========== +[2026-04-15 18:18:44,163][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.079858779907227, 'accuracy': 0.48705882352941177, 'num_samples': 425, 'test_unique_accuracy': 0.4930555555555556, 'test_unique_num_samples': 432} +[2026-04-15 18:18:44,166][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.48705882352941177 is not better than 0.5788235294117647 of logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep32000, skipping checkpoint +[2026-04-15 18:19:02,380][trainer.accelerators.base_accelerator][INFO] - Training progress: step=89050/100000 (89.05%), epoch=2, lr=1e-05, speed=1.943 step/s, elapsed=12:43:53, eta=01:33:55 +[2026-04-15 18:19:20,207][trainer.accelerators.base_accelerator][INFO] - Training progress: step=89100/100000 (89.10%), epoch=2, lr=1e-05, speed=1.943 step/s, elapsed=12:44:10, eta=01:33:29 +[2026-04-15 18:19:38,045][trainer.accelerators.base_accelerator][INFO] - Training progress: step=89150/100000 (89.15%), epoch=2, lr=1e-05, speed=1.944 step/s, elapsed=12:44:28, eta=01:33:02 +[2026-04-15 18:19:55,831][trainer.accelerators.base_accelerator][INFO] - Training progress: step=89200/100000 (89.20%), epoch=2, lr=1e-05, speed=1.944 step/s, elapsed=12:44:46, eta=01:32:35 +[2026-04-15 18:20:13,689][trainer.accelerators.base_accelerator][INFO] - Training progress: step=89250/100000 (89.25%), epoch=2, lr=1e-05, speed=1.944 step/s, elapsed=12:45:04, eta=01:32:09 +[2026-04-15 18:20:31,581][trainer.accelerators.base_accelerator][INFO] - Training progress: step=89300/100000 (89.30%), epoch=2, lr=1e-05, speed=1.945 step/s, elapsed=12:45:22, eta=01:31:42 +[2026-04-15 18:20:49,483][trainer.accelerators.base_accelerator][INFO] - Training progress: step=89350/100000 (89.35%), epoch=2, lr=1e-05, speed=1.945 step/s, elapsed=12:45:40, eta=01:31:15 +[2026-04-15 18:21:07,327][trainer.accelerators.base_accelerator][INFO] - Training progress: step=89400/100000 (89.40%), epoch=2, lr=1e-05, speed=1.945 step/s, elapsed=12:45:58, eta=01:30:49 +[2026-04-15 18:21:25,218][trainer.accelerators.base_accelerator][INFO] - Training progress: step=89450/100000 (89.45%), epoch=2, lr=1e-05, speed=1.946 step/s, elapsed=12:46:15, eta=01:30:22 +[2026-04-15 18:21:43,002][trainer.accelerators.base_accelerator][INFO] - Training progress: step=89500/100000 (89.50%), epoch=2, lr=1e-05, speed=1.946 step/s, elapsed=12:46:33, eta=01:29:55 +[2026-04-15 18:22:00,756][trainer.accelerators.base_accelerator][INFO] - Training progress: step=89550/100000 (89.55%), epoch=2, lr=1e-05, speed=1.946 step/s, elapsed=12:46:51, eta=01:29:29 +[2026-04-15 18:22:18,640][trainer.accelerators.base_accelerator][INFO] - Training progress: step=89600/100000 (89.60%), epoch=2, lr=1e-05, speed=1.947 step/s, elapsed=12:47:09, eta=01:29:02 +[2026-04-15 18:22:36,496][trainer.accelerators.base_accelerator][INFO] - Training progress: step=89650/100000 (89.65%), epoch=2, lr=1e-05, speed=1.947 step/s, elapsed=12:47:27, eta=01:28:36 +[2026-04-15 18:22:54,231][trainer.accelerators.base_accelerator][INFO] - Training progress: step=89700/100000 (89.70%), epoch=2, lr=1e-05, speed=1.947 step/s, elapsed=12:47:44, eta=01:28:09 +[2026-04-15 18:23:11,976][trainer.accelerators.base_accelerator][INFO] - Training progress: step=89750/100000 (89.75%), epoch=2, lr=1e-05, speed=1.948 step/s, elapsed=12:48:02, eta=01:27:42 +[2026-04-15 18:23:29,699][trainer.accelerators.base_accelerator][INFO] - Training progress: step=89800/100000 (89.80%), epoch=2, lr=1e-05, speed=1.948 step/s, elapsed=12:48:20, eta=01:27:16 +[2026-04-15 18:23:47,591][trainer.accelerators.base_accelerator][INFO] - Training progress: step=89850/100000 (89.85%), epoch=2, lr=1e-05, speed=1.948 step/s, elapsed=12:48:38, eta=01:26:49 +[2026-04-15 18:24:05,414][trainer.accelerators.base_accelerator][INFO] - Training progress: step=89900/100000 (89.90%), epoch=2, lr=1e-05, speed=1.949 step/s, elapsed=12:48:56, eta=01:26:23 +[2026-04-15 18:24:23,237][trainer.accelerators.base_accelerator][INFO] - Training progress: step=89950/100000 (89.95%), epoch=2, lr=1e-05, speed=1.949 step/s, elapsed=12:49:13, eta=01:25:56 +[2026-04-15 18:24:41,087][trainer.accelerators.base_accelerator][INFO] - Training progress: step=90000/100000 (90.00%), epoch=2, lr=1e-05, speed=1.949 step/s, elapsed=12:49:31, eta=01:25:30 +[2026-04-15 18:24:41,112][__main__][INFO] - ========== EVAL START (periodic@gstep=90000) ========== +[2026-04-15 18:24:41,112][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-15 18:24:41,112][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 18:24:57,288][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.079858779907227, 'accuracy': 0.5058823529411764, 'num_samples': 425, 'test_unique_accuracy': 0.4930555555555556, 'test_unique_num_samples': 432} +[2026-04-15 18:24:57,288][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-15 18:24:57,289][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 18:25:12,421][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.079858779907227, 'accuracy': 0.5058823529411764, 'num_samples': 425, 'test_unique_accuracy': 0.4652777777777778, 'test_unique_num_samples': 432} +[2026-04-15 18:25:12,421][__main__][INFO] - ========== EVAL END (periodic@gstep=90000) ========== +[2026-04-15 18:25:12,422][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.084650993347168, 'accuracy': 0.5058823529411764, 'num_samples': 425, 'test_unique_accuracy': 0.4652777777777778, 'test_unique_num_samples': 432} +[2026-04-15 18:25:12,425][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.5058823529411764 is not better than 0.5788235294117647 of logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep32000, skipping checkpoint +[2026-04-15 18:25:30,310][trainer.accelerators.base_accelerator][INFO] - Training progress: step=90050/100000 (90.05%), epoch=2, lr=1e-05, speed=1.948 step/s, elapsed=12:50:20, eta=01:25:07 +[2026-04-15 18:25:48,460][trainer.accelerators.base_accelerator][INFO] - Training progress: step=90100/100000 (90.10%), epoch=2, lr=1e-05, speed=1.949 step/s, elapsed=12:50:39, eta=01:24:40 +[2026-04-15 18:26:06,341][trainer.accelerators.base_accelerator][INFO] - Training progress: step=90150/100000 (90.15%), epoch=2, lr=1e-05, speed=1.949 step/s, elapsed=12:50:57, eta=01:24:14 +[2026-04-15 18:26:24,173][trainer.accelerators.base_accelerator][INFO] - Training progress: step=90200/100000 (90.20%), epoch=2, lr=1e-05, speed=1.949 step/s, elapsed=12:51:14, eta=01:23:47 +[2026-04-15 18:26:42,030][trainer.accelerators.base_accelerator][INFO] - Training progress: step=90250/100000 (90.25%), epoch=2, lr=1e-05, speed=1.950 step/s, elapsed=12:51:32, eta=01:23:21 +[2026-04-15 18:26:59,874][trainer.accelerators.base_accelerator][INFO] - Training progress: step=90300/100000 (90.30%), epoch=2, lr=1e-05, speed=1.950 step/s, elapsed=12:51:50, eta=01:22:54 +[2026-04-15 18:27:17,721][trainer.accelerators.base_accelerator][INFO] - Training progress: step=90350/100000 (90.35%), epoch=2, lr=1e-05, speed=1.950 step/s, elapsed=12:52:08, eta=01:22:28 +[2026-04-15 18:27:35,497][trainer.accelerators.base_accelerator][INFO] - Training progress: step=90400/100000 (90.40%), epoch=2, lr=1e-05, speed=1.951 step/s, elapsed=12:52:26, eta=01:22:01 +[2026-04-15 18:27:53,213][trainer.accelerators.base_accelerator][INFO] - Training progress: step=90450/100000 (90.45%), epoch=2, lr=1e-05, speed=1.951 step/s, elapsed=12:52:43, eta=01:21:35 +[2026-04-15 18:28:11,071][trainer.accelerators.base_accelerator][INFO] - Training progress: step=90500/100000 (90.50%), epoch=2, lr=1e-05, speed=1.951 step/s, elapsed=12:53:01, eta=01:21:08 +[2026-04-15 18:28:28,980][trainer.accelerators.base_accelerator][INFO] - Training progress: step=90550/100000 (90.55%), epoch=2, lr=1e-05, speed=1.952 step/s, elapsed=12:53:19, eta=01:20:42 +[2026-04-15 18:28:46,835][trainer.accelerators.base_accelerator][INFO] - Training progress: step=90600/100000 (90.60%), epoch=2, lr=1e-05, speed=1.952 step/s, elapsed=12:53:37, eta=01:20:15 +[2026-04-15 18:29:04,638][trainer.accelerators.base_accelerator][INFO] - Training progress: step=90650/100000 (90.65%), epoch=2, lr=1e-05, speed=1.952 step/s, elapsed=12:53:55, eta=01:19:49 +[2026-04-15 18:29:22,434][trainer.accelerators.base_accelerator][INFO] - Training progress: step=90700/100000 (90.70%), epoch=2, lr=1e-05, speed=1.953 step/s, elapsed=12:54:13, eta=01:19:23 +[2026-04-15 18:29:40,226][trainer.accelerators.base_accelerator][INFO] - Training progress: step=90750/100000 (90.75%), epoch=2, lr=1e-05, speed=1.953 step/s, elapsed=12:54:30, eta=01:18:56 +[2026-04-15 18:29:58,058][trainer.accelerators.base_accelerator][INFO] - Training progress: step=90800/100000 (90.80%), epoch=2, lr=1e-05, speed=1.953 step/s, elapsed=12:54:48, eta=01:18:30 +[2026-04-15 18:30:15,779][trainer.accelerators.base_accelerator][INFO] - Training progress: step=90850/100000 (90.85%), epoch=2, lr=1e-05, speed=1.953 step/s, elapsed=12:55:06, eta=01:18:03 +[2026-04-15 18:30:33,672][trainer.accelerators.base_accelerator][INFO] - Training progress: step=90900/100000 (90.90%), epoch=2, lr=1e-05, speed=1.954 step/s, elapsed=12:55:24, eta=01:17:37 +[2026-04-15 18:30:51,482][trainer.accelerators.base_accelerator][INFO] - Training progress: step=90950/100000 (90.95%), epoch=2, lr=1e-05, speed=1.954 step/s, elapsed=12:55:42, eta=01:17:11 +[2026-04-15 18:31:09,330][trainer.accelerators.base_accelerator][INFO] - Training progress: step=91000/100000 (91.00%), epoch=2, lr=1e-05, speed=1.954 step/s, elapsed=12:56:00, eta=01:16:44 +[2026-04-15 18:31:09,354][__main__][INFO] - ========== EVAL START (periodic@gstep=91000) ========== +[2026-04-15 18:31:09,354][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-15 18:31:09,355][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 18:31:24,547][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.084650993347168, 'accuracy': 0.5247058823529411, 'num_samples': 425, 'test_unique_accuracy': 0.4652777777777778, 'test_unique_num_samples': 432} +[2026-04-15 18:31:24,548][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-15 18:31:24,548][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 18:31:39,687][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.084650993347168, 'accuracy': 0.5247058823529411, 'num_samples': 425, 'test_unique_accuracy': 0.4722222222222222, 'test_unique_num_samples': 432} +[2026-04-15 18:31:39,688][__main__][INFO] - ========== EVAL END (periodic@gstep=91000) ========== +[2026-04-15 18:31:39,688][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.083585739135742, 'accuracy': 0.5247058823529411, 'num_samples': 425, 'test_unique_accuracy': 0.4722222222222222, 'test_unique_num_samples': 432} +[2026-04-15 18:31:39,691][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.5247058823529411 is not better than 0.5788235294117647 of logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep32000, skipping checkpoint +[2026-04-15 18:31:57,559][trainer.accelerators.base_accelerator][INFO] - Training progress: step=91050/100000 (91.05%), epoch=2, lr=1e-05, speed=1.954 step/s, elapsed=12:56:48, eta=01:16:21 +[2026-04-15 18:32:15,398][trainer.accelerators.base_accelerator][INFO] - Training progress: step=91100/100000 (91.10%), epoch=2, lr=1e-05, speed=1.954 step/s, elapsed=12:57:06, eta=01:15:55 +[2026-04-15 18:32:33,220][trainer.accelerators.base_accelerator][INFO] - Training progress: step=91150/100000 (91.15%), epoch=2, lr=1e-05, speed=1.954 step/s, elapsed=12:57:23, eta=01:15:28 +[2026-04-15 18:32:51,410][trainer.accelerators.base_accelerator][INFO] - Training progress: step=91200/100000 (91.20%), epoch=2, lr=1e-05, speed=1.954 step/s, elapsed=12:57:42, eta=01:15:02 +[2026-04-15 18:33:09,258][trainer.accelerators.base_accelerator][INFO] - Training progress: step=91250/100000 (91.25%), epoch=2, lr=1e-05, speed=1.955 step/s, elapsed=12:57:59, eta=01:14:36 +[2026-04-15 18:33:27,066][trainer.accelerators.base_accelerator][INFO] - Training progress: step=91300/100000 (91.30%), epoch=2, lr=1e-05, speed=1.955 step/s, elapsed=12:58:17, eta=01:14:09 +[2026-04-15 18:33:44,933][trainer.accelerators.base_accelerator][INFO] - Training progress: step=91350/100000 (91.35%), epoch=2, lr=1e-05, speed=1.955 step/s, elapsed=12:58:35, eta=01:13:43 +[2026-04-15 18:34:02,797][trainer.accelerators.base_accelerator][INFO] - Training progress: step=91400/100000 (91.40%), epoch=2, lr=1e-05, speed=1.956 step/s, elapsed=12:58:53, eta=01:13:17 +[2026-04-15 18:34:20,626][trainer.accelerators.base_accelerator][INFO] - Training progress: step=91450/100000 (91.45%), epoch=2, lr=1e-05, speed=1.956 step/s, elapsed=12:59:11, eta=01:12:50 +[2026-04-15 18:34:38,538][trainer.accelerators.base_accelerator][INFO] - Training progress: step=91500/100000 (91.50%), epoch=2, lr=1e-05, speed=1.956 step/s, elapsed=12:59:29, eta=01:12:24 +[2026-04-15 18:34:56,430][trainer.accelerators.base_accelerator][INFO] - Training progress: step=91550/100000 (91.55%), epoch=2, lr=1e-05, speed=1.957 step/s, elapsed=12:59:47, eta=01:11:58 +[2026-04-15 18:35:14,343][trainer.accelerators.base_accelerator][INFO] - Training progress: step=91600/100000 (91.60%), epoch=2, lr=1e-05, speed=1.957 step/s, elapsed=13:00:05, eta=01:11:32 +[2026-04-15 18:35:32,188][trainer.accelerators.base_accelerator][INFO] - Training progress: step=91650/100000 (91.65%), epoch=2, lr=1e-05, speed=1.957 step/s, elapsed=13:00:22, eta=01:11:05 +[2026-04-15 18:35:50,050][trainer.accelerators.base_accelerator][INFO] - Training progress: step=91700/100000 (91.70%), epoch=2, lr=1e-05, speed=1.958 step/s, elapsed=13:00:40, eta=01:10:39 +[2026-04-15 18:36:07,939][trainer.accelerators.base_accelerator][INFO] - Training progress: step=91750/100000 (91.75%), epoch=2, lr=1e-05, speed=1.958 step/s, elapsed=13:00:58, eta=01:10:13 +[2026-04-15 18:36:25,817][trainer.accelerators.base_accelerator][INFO] - Training progress: step=91800/100000 (91.80%), epoch=2, lr=1e-05, speed=1.958 step/s, elapsed=13:01:16, eta=01:09:47 +[2026-04-15 18:36:43,676][trainer.accelerators.base_accelerator][INFO] - Training progress: step=91850/100000 (91.85%), epoch=2, lr=1e-05, speed=1.959 step/s, elapsed=13:01:34, eta=01:09:21 +[2026-04-15 18:37:01,597][trainer.accelerators.base_accelerator][INFO] - Training progress: step=91900/100000 (91.90%), epoch=2, lr=1e-05, speed=1.959 step/s, elapsed=13:01:52, eta=01:08:54 +[2026-04-15 18:37:19,469][trainer.accelerators.base_accelerator][INFO] - Training progress: step=91950/100000 (91.95%), epoch=2, lr=1e-05, speed=1.959 step/s, elapsed=13:02:10, eta=01:08:28 +[2026-04-15 18:37:37,268][trainer.accelerators.base_accelerator][INFO] - Training progress: step=92000/100000 (92.00%), epoch=2, lr=1e-05, speed=1.960 step/s, elapsed=13:02:27, eta=01:08:02 +[2026-04-15 18:37:37,292][__main__][INFO] - ========== EVAL START (periodic@gstep=92000) ========== +[2026-04-15 18:37:37,293][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-15 18:37:37,293][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 18:37:54,476][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.083585739135742, 'accuracy': 0.52, 'num_samples': 425, 'test_unique_accuracy': 0.4722222222222222, 'test_unique_num_samples': 432} +[2026-04-15 18:37:54,476][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-15 18:37:54,477][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 18:38:09,610][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.083585739135742, 'accuracy': 0.52, 'num_samples': 425, 'test_unique_accuracy': 0.5347222222222222, 'test_unique_num_samples': 432} +[2026-04-15 18:38:09,610][__main__][INFO] - ========== EVAL END (periodic@gstep=92000) ========== +[2026-04-15 18:38:09,611][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.096237182617188, 'accuracy': 0.52, 'num_samples': 425, 'test_unique_accuracy': 0.5347222222222222, 'test_unique_num_samples': 432} +[2026-04-15 18:38:09,647][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.52 is not better than 0.5788235294117647 of logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep32000, skipping checkpoint +[2026-04-15 18:38:27,501][trainer.accelerators.base_accelerator][INFO] - Training progress: step=92050/100000 (92.05%), epoch=2, lr=1e-05, speed=1.959 step/s, elapsed=13:03:18, eta=01:07:39 +[2026-04-15 18:38:45,385][trainer.accelerators.base_accelerator][INFO] - Training progress: step=92100/100000 (92.10%), epoch=2, lr=1e-05, speed=1.959 step/s, elapsed=13:03:36, eta=01:07:12 +[2026-04-15 18:39:03,169][trainer.accelerators.base_accelerator][INFO] - Training progress: step=92150/100000 (92.15%), epoch=2, lr=1e-05, speed=1.959 step/s, elapsed=13:03:53, eta=01:06:46 +[2026-04-15 18:39:21,085][trainer.accelerators.base_accelerator][INFO] - Training progress: step=92200/100000 (92.20%), epoch=2, lr=1e-05, speed=1.960 step/s, elapsed=13:04:11, eta=01:06:20 +[2026-04-15 18:39:38,978][trainer.accelerators.base_accelerator][INFO] - Training progress: step=92250/100000 (92.25%), epoch=2, lr=1e-05, speed=1.960 step/s, elapsed=13:04:29, eta=01:05:54 +[2026-04-15 18:39:57,215][trainer.accelerators.base_accelerator][INFO] - Training progress: step=92300/100000 (92.30%), epoch=2, lr=1e-05, speed=1.960 step/s, elapsed=13:04:47, eta=01:05:28 +[2026-04-15 18:40:15,068][trainer.accelerators.base_accelerator][INFO] - Training progress: step=92350/100000 (92.35%), epoch=2, lr=1e-05, speed=1.960 step/s, elapsed=13:05:05, eta=01:05:02 +[2026-04-15 18:40:32,885][trainer.accelerators.base_accelerator][INFO] - Training progress: step=92400/100000 (92.40%), epoch=2, lr=1e-05, speed=1.961 step/s, elapsed=13:05:23, eta=01:04:35 +[2026-04-15 18:40:50,763][trainer.accelerators.base_accelerator][INFO] - Training progress: step=92450/100000 (92.45%), epoch=2, lr=1e-05, speed=1.961 step/s, elapsed=13:05:41, eta=01:04:09 +[2026-04-15 18:41:08,687][trainer.accelerators.base_accelerator][INFO] - Training progress: step=92500/100000 (92.50%), epoch=2, lr=1e-05, speed=1.961 step/s, elapsed=13:05:59, eta=01:03:43 +[2026-04-15 18:41:26,542][trainer.accelerators.base_accelerator][INFO] - Training progress: step=92550/100000 (92.55%), epoch=2, lr=1e-05, speed=1.962 step/s, elapsed=13:06:17, eta=01:03:17 +[2026-04-15 18:41:44,324][trainer.accelerators.base_accelerator][INFO] - Training progress: step=92600/100000 (92.60%), epoch=2, lr=1e-05, speed=1.962 step/s, elapsed=13:06:35, eta=01:02:51 +[2026-04-15 18:42:02,061][trainer.accelerators.base_accelerator][INFO] - Training progress: step=92650/100000 (92.65%), epoch=2, lr=1e-05, speed=1.962 step/s, elapsed=13:06:52, eta=01:02:25 +[2026-04-15 18:42:19,925][trainer.accelerators.base_accelerator][INFO] - Training progress: step=92700/100000 (92.70%), epoch=2, lr=1e-05, speed=1.963 step/s, elapsed=13:07:10, eta=01:01:59 +[2026-04-15 18:42:37,907][trainer.accelerators.base_accelerator][INFO] - Training progress: step=92750/100000 (92.75%), epoch=2, lr=1e-05, speed=1.963 step/s, elapsed=13:07:28, eta=01:01:33 +[2026-04-15 18:42:55,726][trainer.accelerators.base_accelerator][INFO] - Training progress: step=92800/100000 (92.80%), epoch=2, lr=1e-05, speed=1.963 step/s, elapsed=13:07:46, eta=01:01:07 +[2026-04-15 18:43:13,562][trainer.accelerators.base_accelerator][INFO] - Training progress: step=92850/100000 (92.85%), epoch=2, lr=1e-05, speed=1.964 step/s, elapsed=13:08:04, eta=01:00:41 +[2026-04-15 18:43:31,359][trainer.accelerators.base_accelerator][INFO] - Training progress: step=92900/100000 (92.90%), epoch=2, lr=1e-05, speed=1.964 step/s, elapsed=13:08:22, eta=01:00:15 +[2026-04-15 18:43:49,298][trainer.accelerators.base_accelerator][INFO] - Training progress: step=92950/100000 (92.95%), epoch=2, lr=1e-05, speed=1.964 step/s, elapsed=13:08:39, eta=59:49 +[2026-04-15 18:44:07,157][trainer.accelerators.base_accelerator][INFO] - Training progress: step=93000/100000 (93.00%), epoch=2, lr=1e-05, speed=1.965 step/s, elapsed=13:08:57, eta=59:23 +[2026-04-15 18:44:07,181][__main__][INFO] - ========== EVAL START (periodic@gstep=93000) ========== +[2026-04-15 18:44:07,181][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-15 18:44:07,182][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 18:44:22,453][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.096237182617188, 'accuracy': 0.5458823529411765, 'num_samples': 425, 'test_unique_accuracy': 0.5347222222222222, 'test_unique_num_samples': 432} +[2026-04-15 18:44:22,453][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-15 18:44:22,453][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 18:44:37,617][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.096237182617188, 'accuracy': 0.5458823529411765, 'num_samples': 425, 'test_unique_accuracy': 0.4791666666666667, 'test_unique_num_samples': 432} +[2026-04-15 18:44:37,617][__main__][INFO] - ========== EVAL END (periodic@gstep=93000) ========== +[2026-04-15 18:44:37,617][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.098031044006348, 'accuracy': 0.5458823529411765, 'num_samples': 425, 'test_unique_accuracy': 0.4791666666666667, 'test_unique_num_samples': 432} +[2026-04-15 18:44:37,643][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.5458823529411765 is not better than 0.5788235294117647 of logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep32000, skipping checkpoint +[2026-04-15 18:44:55,598][trainer.accelerators.base_accelerator][INFO] - Training progress: step=93050/100000 (93.05%), epoch=2, lr=1e-05, speed=1.964 step/s, elapsed=13:09:46, eta=58:59 +[2026-04-15 18:45:13,427][trainer.accelerators.base_accelerator][INFO] - Training progress: step=93100/100000 (93.10%), epoch=2, lr=1e-05, speed=1.964 step/s, elapsed=13:10:04, eta=58:33 +[2026-04-15 18:45:31,294][trainer.accelerators.base_accelerator][INFO] - Training progress: step=93150/100000 (93.15%), epoch=2, lr=1e-05, speed=1.964 step/s, elapsed=13:10:21, eta=58:07 +[2026-04-15 18:45:49,067][trainer.accelerators.base_accelerator][INFO] - Training progress: step=93200/100000 (93.20%), epoch=2, lr=1e-05, speed=1.965 step/s, elapsed=13:10:39, eta=57:41 +[2026-04-15 18:46:06,977][trainer.accelerators.base_accelerator][INFO] - Training progress: step=93250/100000 (93.25%), epoch=2, lr=1e-05, speed=1.965 step/s, elapsed=13:10:57, eta=57:15 +[2026-04-15 18:46:24,843][trainer.accelerators.base_accelerator][INFO] - Training progress: step=93300/100000 (93.30%), epoch=2, lr=1e-05, speed=1.965 step/s, elapsed=13:11:15, eta=56:49 +[2026-04-15 18:46:42,994][trainer.accelerators.base_accelerator][INFO] - Training progress: step=93350/100000 (93.35%), epoch=2, lr=1e-05, speed=1.966 step/s, elapsed=13:11:33, eta=56:23 +[2026-04-15 18:47:00,862][trainer.accelerators.base_accelerator][INFO] - Training progress: step=93400/100000 (93.40%), epoch=2, lr=1e-05, speed=1.966 step/s, elapsed=13:11:51, eta=55:57 +[2026-04-15 18:47:18,758][trainer.accelerators.base_accelerator][INFO] - Training progress: step=93450/100000 (93.45%), epoch=2, lr=1e-05, speed=1.966 step/s, elapsed=13:12:09, eta=55:31 +[2026-04-15 18:47:36,650][trainer.accelerators.base_accelerator][INFO] - Training progress: step=93500/100000 (93.50%), epoch=2, lr=1e-05, speed=1.966 step/s, elapsed=13:12:27, eta=55:05 +[2026-04-15 18:47:54,432][trainer.accelerators.base_accelerator][INFO] - Training progress: step=93550/100000 (93.55%), epoch=2, lr=1e-05, speed=1.967 step/s, elapsed=13:12:45, eta=54:39 +[2026-04-15 18:48:12,190][trainer.accelerators.base_accelerator][INFO] - Training progress: step=93600/100000 (93.60%), epoch=2, lr=1e-05, speed=1.967 step/s, elapsed=13:13:02, eta=54:13 +[2026-04-15 18:48:30,042][trainer.accelerators.base_accelerator][INFO] - Training progress: step=93650/100000 (93.65%), epoch=2, lr=1e-05, speed=1.967 step/s, elapsed=13:13:20, eta=53:47 +[2026-04-15 18:48:47,859][trainer.accelerators.base_accelerator][INFO] - Training progress: step=93700/100000 (93.70%), epoch=2, lr=1e-05, speed=1.968 step/s, elapsed=13:13:38, eta=53:21 +[2026-04-15 18:49:05,700][trainer.accelerators.base_accelerator][INFO] - Training progress: step=93750/100000 (93.75%), epoch=2, lr=1e-05, speed=1.968 step/s, elapsed=13:13:56, eta=52:55 +[2026-04-15 18:49:23,538][trainer.accelerators.base_accelerator][INFO] - Training progress: step=93800/100000 (93.80%), epoch=2, lr=1e-05, speed=1.968 step/s, elapsed=13:14:14, eta=52:29 +[2026-04-15 18:49:41,283][trainer.accelerators.base_accelerator][INFO] - Training progress: step=93850/100000 (93.85%), epoch=2, lr=1e-05, speed=1.969 step/s, elapsed=13:14:31, eta=52:03 +[2026-04-15 18:49:59,101][trainer.accelerators.base_accelerator][INFO] - Training progress: step=93900/100000 (93.90%), epoch=2, lr=1e-05, speed=1.969 step/s, elapsed=13:14:49, eta=51:38 +[2026-04-15 18:50:16,890][trainer.accelerators.base_accelerator][INFO] - Training progress: step=93950/100000 (93.95%), epoch=2, lr=1e-05, speed=1.969 step/s, elapsed=13:15:07, eta=51:12 +[2026-04-15 18:50:34,776][trainer.accelerators.base_accelerator][INFO] - Training progress: step=94000/100000 (94.00%), epoch=2, lr=1e-05, speed=1.970 step/s, elapsed=13:15:25, eta=50:46 +[2026-04-15 18:50:34,801][__main__][INFO] - ========== EVAL START (periodic@gstep=94000) ========== +[2026-04-15 18:50:34,801][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-15 18:50:34,802][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 18:50:52,294][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.098031044006348, 'accuracy': 0.45647058823529413, 'num_samples': 425, 'test_unique_accuracy': 0.4791666666666667, 'test_unique_num_samples': 432} +[2026-04-15 18:50:52,295][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-15 18:50:52,295][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 18:51:07,428][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.098031044006348, 'accuracy': 0.45647058823529413, 'num_samples': 425, 'test_unique_accuracy': 0.5254629629629629, 'test_unique_num_samples': 432} +[2026-04-15 18:51:07,428][__main__][INFO] - ========== EVAL END (periodic@gstep=94000) ========== +[2026-04-15 18:51:07,428][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.10425090789795, 'accuracy': 0.45647058823529413, 'num_samples': 425, 'test_unique_accuracy': 0.5254629629629629, 'test_unique_num_samples': 432} +[2026-04-15 18:51:07,432][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.45647058823529413 is not better than 0.5788235294117647 of logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep32000, skipping checkpoint +[2026-04-15 18:51:25,302][trainer.accelerators.base_accelerator][INFO] - Training progress: step=94050/100000 (94.05%), epoch=2, lr=1e-05, speed=1.969 step/s, elapsed=13:16:15, eta=50:22 +[2026-04-15 18:51:43,201][trainer.accelerators.base_accelerator][INFO] - Training progress: step=94100/100000 (94.10%), epoch=2, lr=1e-05, speed=1.969 step/s, elapsed=13:16:33, eta=49:56 +[2026-04-15 18:52:01,089][trainer.accelerators.base_accelerator][INFO] - Training progress: step=94150/100000 (94.15%), epoch=2, lr=1e-05, speed=1.969 step/s, elapsed=13:16:51, eta=49:30 +[2026-04-15 18:52:18,986][trainer.accelerators.base_accelerator][INFO] - Training progress: step=94200/100000 (94.20%), epoch=2, lr=1e-05, speed=1.969 step/s, elapsed=13:17:09, eta=49:04 +[2026-04-15 18:52:36,829][trainer.accelerators.base_accelerator][INFO] - Training progress: step=94250/100000 (94.25%), epoch=2, lr=1e-05, speed=1.970 step/s, elapsed=13:17:27, eta=48:39 +[2026-04-15 18:52:54,745][trainer.accelerators.base_accelerator][INFO] - Training progress: step=94300/100000 (94.30%), epoch=2, lr=1e-05, speed=1.970 step/s, elapsed=13:17:45, eta=48:13 +[2026-04-15 18:53:12,645][trainer.accelerators.base_accelerator][INFO] - Training progress: step=94350/100000 (94.35%), epoch=2, lr=1e-05, speed=1.970 step/s, elapsed=13:18:03, eta=47:47 +[2026-04-15 18:53:30,518][trainer.accelerators.base_accelerator][INFO] - Training progress: step=94400/100000 (94.40%), epoch=2, lr=1e-05, speed=1.971 step/s, elapsed=13:18:21, eta=47:21 +[2026-04-15 18:53:48,725][trainer.accelerators.base_accelerator][INFO] - Training progress: step=94450/100000 (94.45%), epoch=2, lr=1e-05, speed=1.971 step/s, elapsed=13:18:39, eta=46:55 +[2026-04-15 18:54:06,649][trainer.accelerators.base_accelerator][INFO] - Training progress: step=94500/100000 (94.50%), epoch=2, lr=1e-05, speed=1.971 step/s, elapsed=13:18:57, eta=46:30 +[2026-04-15 18:54:24,458][trainer.accelerators.base_accelerator][INFO] - Training progress: step=94550/100000 (94.55%), epoch=2, lr=1e-05, speed=1.972 step/s, elapsed=13:19:15, eta=46:04 +[2026-04-15 18:54:42,342][trainer.accelerators.base_accelerator][INFO] - Training progress: step=94600/100000 (94.60%), epoch=2, lr=1e-05, speed=1.972 step/s, elapsed=13:19:33, eta=45:38 +[2026-04-15 18:55:00,212][trainer.accelerators.base_accelerator][INFO] - Training progress: step=94650/100000 (94.65%), epoch=2, lr=1e-05, speed=1.972 step/s, elapsed=13:19:50, eta=45:12 +[2026-04-15 18:55:18,068][trainer.accelerators.base_accelerator][INFO] - Training progress: step=94700/100000 (94.70%), epoch=2, lr=1e-05, speed=1.973 step/s, elapsed=13:20:08, eta=44:46 +[2026-04-15 18:55:35,956][trainer.accelerators.base_accelerator][INFO] - Training progress: step=94750/100000 (94.75%), epoch=2, lr=1e-05, speed=1.973 step/s, elapsed=13:20:26, eta=44:21 +[2026-04-15 18:55:53,766][trainer.accelerators.base_accelerator][INFO] - Training progress: step=94800/100000 (94.80%), epoch=2, lr=1e-05, speed=1.973 step/s, elapsed=13:20:44, eta=43:55 +[2026-04-15 18:56:11,602][trainer.accelerators.base_accelerator][INFO] - Training progress: step=94850/100000 (94.85%), epoch=2, lr=1e-05, speed=1.973 step/s, elapsed=13:21:02, eta=43:29 +[2026-04-15 18:56:29,516][trainer.accelerators.base_accelerator][INFO] - Training progress: step=94900/100000 (94.90%), epoch=2, lr=1e-05, speed=1.974 step/s, elapsed=13:21:20, eta=43:03 +[2026-04-15 18:56:47,337][trainer.accelerators.base_accelerator][INFO] - Training progress: step=94950/100000 (94.95%), epoch=2, lr=1e-05, speed=1.974 step/s, elapsed=13:21:38, eta=42:38 +[2026-04-15 18:57:05,139][trainer.accelerators.base_accelerator][INFO] - Training progress: step=95000/100000 (95.00%), epoch=2, lr=1e-05, speed=1.974 step/s, elapsed=13:21:55, eta=42:12 +[2026-04-15 18:57:05,164][__main__][INFO] - ========== EVAL START (periodic@gstep=95000) ========== +[2026-04-15 18:57:05,165][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-15 18:57:05,165][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 18:57:21,131][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.10425090789795, 'accuracy': 0.4964705882352941, 'num_samples': 425, 'test_unique_accuracy': 0.5254629629629629, 'test_unique_num_samples': 432} +[2026-04-15 18:57:21,132][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-15 18:57:21,132][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 18:57:36,257][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.10425090789795, 'accuracy': 0.4964705882352941, 'num_samples': 425, 'test_unique_accuracy': 0.4930555555555556, 'test_unique_num_samples': 432} +[2026-04-15 18:57:36,258][__main__][INFO] - ========== EVAL END (periodic@gstep=95000) ========== +[2026-04-15 18:57:36,258][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.109404563903809, 'accuracy': 0.4964705882352941, 'num_samples': 425, 'test_unique_accuracy': 0.4930555555555556, 'test_unique_num_samples': 432} +[2026-04-15 18:57:36,261][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.4964705882352941 is not better than 0.5788235294117647 of logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep32000, skipping checkpoint +[2026-04-15 18:57:54,152][trainer.accelerators.base_accelerator][INFO] - Training progress: step=95050/100000 (95.05%), epoch=2, lr=1e-05, speed=1.973 step/s, elapsed=13:22:44, eta=41:48 +[2026-04-15 18:58:12,032][trainer.accelerators.base_accelerator][INFO] - Training progress: step=95100/100000 (95.10%), epoch=2, lr=1e-05, speed=1.974 step/s, elapsed=13:23:02, eta=41:22 +[2026-04-15 18:58:29,942][trainer.accelerators.base_accelerator][INFO] - Training progress: step=95150/100000 (95.15%), epoch=2, lr=1e-05, speed=1.974 step/s, elapsed=13:23:20, eta=40:56 +[2026-04-15 18:58:47,780][trainer.accelerators.base_accelerator][INFO] - Training progress: step=95200/100000 (95.20%), epoch=2, lr=1e-05, speed=1.974 step/s, elapsed=13:23:38, eta=40:31 +[2026-04-15 18:59:05,581][trainer.accelerators.base_accelerator][INFO] - Training progress: step=95250/100000 (95.25%), epoch=2, lr=1e-05, speed=1.975 step/s, elapsed=13:23:56, eta=40:05 +[2026-04-15 18:59:23,392][trainer.accelerators.base_accelerator][INFO] - Training progress: step=95300/100000 (95.30%), epoch=2, lr=1e-05, speed=1.975 step/s, elapsed=13:24:14, eta=39:39 +[2026-04-15 18:59:41,893][trainer.accelerators.base_accelerator][INFO] - Training progress: step=95350/100000 (95.35%), epoch=2, lr=1e-05, speed=1.975 step/s, elapsed=13:24:32, eta=39:14 +[2026-04-15 18:59:59,805][trainer.accelerators.base_accelerator][INFO] - Training progress: step=95400/100000 (95.40%), epoch=2, lr=1e-05, speed=1.976 step/s, elapsed=13:24:50, eta=38:48 +[2026-04-15 19:00:17,704][trainer.accelerators.base_accelerator][INFO] - Training progress: step=95450/100000 (95.45%), epoch=2, lr=1e-05, speed=1.976 step/s, elapsed=13:25:08, eta=38:22 +[2026-04-15 19:00:35,604][trainer.accelerators.base_accelerator][INFO] - Training progress: step=95500/100000 (95.50%), epoch=2, lr=1e-05, speed=1.976 step/s, elapsed=13:25:26, eta=37:57 +[2026-04-15 19:00:55,724][trainer.accelerators.base_accelerator][INFO] - Training progress: step=95550/100000 (95.55%), epoch=2, lr=1e-05, speed=1.976 step/s, elapsed=13:25:46, eta=37:31 +[2026-04-15 19:01:13,595][trainer.accelerators.base_accelerator][INFO] - Training progress: step=95600/100000 (95.60%), epoch=2, lr=1e-05, speed=1.977 step/s, elapsed=13:26:04, eta=37:05 +[2026-04-15 19:01:31,313][trainer.accelerators.base_accelerator][INFO] - Training progress: step=95650/100000 (95.65%), epoch=2, lr=1e-05, speed=1.977 step/s, elapsed=13:26:21, eta=36:40 +[2026-04-15 19:01:49,030][trainer.accelerators.base_accelerator][INFO] - Training progress: step=95700/100000 (95.70%), epoch=2, lr=1e-05, speed=1.977 step/s, elapsed=13:26:39, eta=36:14 +[2026-04-15 19:02:06,889][trainer.accelerators.base_accelerator][INFO] - Training progress: step=95750/100000 (95.75%), epoch=2, lr=1e-05, speed=1.978 step/s, elapsed=13:26:57, eta=35:49 +[2026-04-15 19:02:24,799][trainer.accelerators.base_accelerator][INFO] - Training progress: step=95800/100000 (95.80%), epoch=2, lr=1e-05, speed=1.978 step/s, elapsed=13:27:15, eta=35:23 +[2026-04-15 19:02:42,701][trainer.accelerators.base_accelerator][INFO] - Training progress: step=95850/100000 (95.85%), epoch=2, lr=1e-05, speed=1.978 step/s, elapsed=13:27:33, eta=34:57 +[2026-04-15 19:03:00,605][trainer.accelerators.base_accelerator][INFO] - Training progress: step=95900/100000 (95.90%), epoch=2, lr=1e-05, speed=1.978 step/s, elapsed=13:27:51, eta=34:32 +[2026-04-15 19:03:18,439][trainer.accelerators.base_accelerator][INFO] - Training progress: step=95950/100000 (95.95%), epoch=2, lr=1e-05, speed=1.979 step/s, elapsed=13:28:09, eta=34:06 +[2026-04-15 19:03:36,356][trainer.accelerators.base_accelerator][INFO] - Training progress: step=96000/100000 (96.00%), epoch=2, lr=1e-05, speed=1.979 step/s, elapsed=13:28:27, eta=33:41 +[2026-04-15 19:03:36,381][__main__][INFO] - ========== EVAL START (periodic@gstep=96000) ========== +[2026-04-15 19:03:36,381][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-15 19:03:36,382][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 19:03:55,084][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.109404563903809, 'accuracy': 0.5011764705882353, 'num_samples': 425, 'test_unique_accuracy': 0.4930555555555556, 'test_unique_num_samples': 432} +[2026-04-15 19:03:55,084][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-15 19:03:55,084][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 19:04:10,207][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.109404563903809, 'accuracy': 0.5011764705882353, 'num_samples': 425, 'test_unique_accuracy': 0.49537037037037035, 'test_unique_num_samples': 432} +[2026-04-15 19:04:10,207][__main__][INFO] - ========== EVAL END (periodic@gstep=96000) ========== +[2026-04-15 19:04:10,207][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.106423377990723, 'accuracy': 0.5011764705882353, 'num_samples': 425, 'test_unique_accuracy': 0.49537037037037035, 'test_unique_num_samples': 432} +[2026-04-15 19:04:10,211][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.5011764705882353 is not better than 0.5788235294117647 of logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep32000, skipping checkpoint +[2026-04-15 19:04:28,110][trainer.accelerators.base_accelerator][INFO] - Training progress: step=96050/100000 (96.05%), epoch=2, lr=1e-05, speed=1.978 step/s, elapsed=13:29:18, eta=33:16 +[2026-04-15 19:04:45,991][trainer.accelerators.base_accelerator][INFO] - Training progress: step=96100/100000 (96.10%), epoch=2, lr=1e-05, speed=1.978 step/s, elapsed=13:29:36, eta=32:51 +[2026-04-15 19:05:03,913][trainer.accelerators.base_accelerator][INFO] - Training progress: step=96150/100000 (96.15%), epoch=2, lr=1e-05, speed=1.979 step/s, elapsed=13:29:54, eta=32:25 +[2026-04-15 19:05:21,799][trainer.accelerators.base_accelerator][INFO] - Training progress: step=96200/100000 (96.20%), epoch=2, lr=1e-05, speed=1.979 step/s, elapsed=13:30:12, eta=32:00 +[2026-04-15 19:05:39,669][trainer.accelerators.base_accelerator][INFO] - Training progress: step=96250/100000 (96.25%), epoch=2, lr=1e-05, speed=1.979 step/s, elapsed=13:30:30, eta=31:34 +[2026-04-15 19:06:01,867][trainer.accelerators.base_accelerator][INFO] - Training progress: step=96300/100000 (96.30%), epoch=2, lr=1e-05, speed=1.979 step/s, elapsed=13:30:52, eta=31:09 +[2026-04-15 19:06:19,804][trainer.accelerators.base_accelerator][INFO] - Training progress: step=96350/100000 (96.35%), epoch=2, lr=1e-05, speed=1.980 step/s, elapsed=13:31:10, eta=30:43 +[2026-04-15 19:06:41,594][trainer.accelerators.base_accelerator][INFO] - Training progress: step=96400/100000 (96.40%), epoch=2, lr=1e-05, speed=1.980 step/s, elapsed=13:31:32, eta=30:18 +[2026-04-15 19:06:59,696][trainer.accelerators.base_accelerator][INFO] - Training progress: step=96450/100000 (96.45%), epoch=2, lr=1e-05, speed=1.980 step/s, elapsed=13:31:50, eta=29:52 +[2026-04-15 19:07:17,551][trainer.accelerators.base_accelerator][INFO] - Training progress: step=96500/100000 (96.50%), epoch=2, lr=1e-05, speed=1.980 step/s, elapsed=13:32:08, eta=29:27 +[2026-04-15 19:07:36,079][trainer.accelerators.base_accelerator][INFO] - Training progress: step=96550/100000 (96.55%), epoch=2, lr=1e-05, speed=1.981 step/s, elapsed=13:32:26, eta=29:01 +[2026-04-15 19:07:54,510][trainer.accelerators.base_accelerator][INFO] - Training progress: step=96600/100000 (96.60%), epoch=2, lr=1e-05, speed=1.981 step/s, elapsed=13:32:45, eta=28:36 +[2026-04-15 19:08:12,371][trainer.accelerators.base_accelerator][INFO] - Training progress: step=96650/100000 (96.65%), epoch=2, lr=1e-05, speed=1.981 step/s, elapsed=13:33:03, eta=28:10 +[2026-04-15 19:08:30,136][trainer.accelerators.base_accelerator][INFO] - Training progress: step=96700/100000 (96.70%), epoch=2, lr=1e-05, speed=1.982 step/s, elapsed=13:33:20, eta=27:45 +[2026-04-15 19:08:47,924][trainer.accelerators.base_accelerator][INFO] - Training progress: step=96750/100000 (96.75%), epoch=2, lr=1e-05, speed=1.982 step/s, elapsed=13:33:38, eta=27:19 +[2026-04-15 19:09:05,782][trainer.accelerators.base_accelerator][INFO] - Training progress: step=96800/100000 (96.80%), epoch=2, lr=1e-05, speed=1.982 step/s, elapsed=13:33:56, eta=26:54 +[2026-04-15 19:09:23,624][trainer.accelerators.base_accelerator][INFO] - Training progress: step=96850/100000 (96.85%), epoch=2, lr=1e-05, speed=1.982 step/s, elapsed=13:34:14, eta=26:28 +[2026-04-15 19:09:41,536][trainer.accelerators.base_accelerator][INFO] - Training progress: step=96900/100000 (96.90%), epoch=2, lr=1e-05, speed=1.983 step/s, elapsed=13:34:32, eta=26:03 +[2026-04-15 19:09:59,373][trainer.accelerators.base_accelerator][INFO] - Training progress: step=96950/100000 (96.95%), epoch=2, lr=1e-05, speed=1.983 step/s, elapsed=13:34:50, eta=25:38 +[2026-04-15 19:10:17,250][trainer.accelerators.base_accelerator][INFO] - Training progress: step=97000/100000 (97.00%), epoch=2, lr=1e-05, speed=1.983 step/s, elapsed=13:35:07, eta=25:12 +[2026-04-15 19:10:17,275][__main__][INFO] - ========== EVAL START (periodic@gstep=97000) ========== +[2026-04-15 19:10:17,275][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-15 19:10:17,275][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 19:10:34,779][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.106423377990723, 'accuracy': 0.48470588235294115, 'num_samples': 425, 'test_unique_accuracy': 0.49537037037037035, 'test_unique_num_samples': 432} +[2026-04-15 19:10:34,781][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-15 19:10:34,781][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 19:10:50,033][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.106423377990723, 'accuracy': 0.48470588235294115, 'num_samples': 425, 'test_unique_accuracy': 0.48842592592592593, 'test_unique_num_samples': 432} +[2026-04-15 19:10:50,033][__main__][INFO] - ========== EVAL END (periodic@gstep=97000) ========== +[2026-04-15 19:10:50,043][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.108707427978516, 'accuracy': 0.48470588235294115, 'num_samples': 425, 'test_unique_accuracy': 0.48842592592592593, 'test_unique_num_samples': 432} +[2026-04-15 19:10:50,103][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.48470588235294115 is not better than 0.5788235294117647 of logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep32000, skipping checkpoint +[2026-04-15 19:11:07,999][trainer.accelerators.base_accelerator][INFO] - Training progress: step=97050/100000 (97.05%), epoch=2, lr=1e-05, speed=1.982 step/s, elapsed=13:35:58, eta=24:48 +[2026-04-15 19:11:25,865][trainer.accelerators.base_accelerator][INFO] - Training progress: step=97100/100000 (97.10%), epoch=2, lr=1e-05, speed=1.983 step/s, elapsed=13:36:16, eta=24:22 +[2026-04-15 19:11:43,717][trainer.accelerators.base_accelerator][INFO] - Training progress: step=97150/100000 (97.15%), epoch=2, lr=1e-05, speed=1.983 step/s, elapsed=13:36:34, eta=23:57 +[2026-04-15 19:12:01,611][trainer.accelerators.base_accelerator][INFO] - Training progress: step=97200/100000 (97.20%), epoch=2, lr=1e-05, speed=1.983 step/s, elapsed=13:36:52, eta=23:31 +[2026-04-15 19:12:19,457][trainer.accelerators.base_accelerator][INFO] - Training progress: step=97250/100000 (97.25%), epoch=2, lr=1e-05, speed=1.983 step/s, elapsed=13:37:10, eta=23:06 +[2026-04-15 19:12:37,320][trainer.accelerators.base_accelerator][INFO] - Training progress: step=97300/100000 (97.30%), epoch=2, lr=1e-05, speed=1.984 step/s, elapsed=13:37:28, eta=22:41 +[2026-04-15 19:12:55,180][trainer.accelerators.base_accelerator][INFO] - Training progress: step=97350/100000 (97.35%), epoch=2, lr=1e-05, speed=1.984 step/s, elapsed=13:37:45, eta=22:15 +[2026-04-15 19:13:13,050][trainer.accelerators.base_accelerator][INFO] - Training progress: step=97400/100000 (97.40%), epoch=2, lr=1e-05, speed=1.984 step/s, elapsed=13:38:03, eta=21:50 +[2026-04-15 19:13:30,904][trainer.accelerators.base_accelerator][INFO] - Training progress: step=97450/100000 (97.45%), epoch=2, lr=1e-05, speed=1.985 step/s, elapsed=13:38:21, eta=21:24 +[2026-04-15 19:13:48,615][trainer.accelerators.base_accelerator][INFO] - Training progress: step=97500/100000 (97.50%), epoch=2, lr=1e-05, speed=1.985 step/s, elapsed=13:38:39, eta=20:59 +[2026-04-15 19:14:06,312][trainer.accelerators.base_accelerator][INFO] - Training progress: step=97550/100000 (97.55%), epoch=2, lr=1e-05, speed=1.985 step/s, elapsed=13:38:56, eta=20:34 +[2026-04-15 19:14:24,125][trainer.accelerators.base_accelerator][INFO] - Training progress: step=97600/100000 (97.60%), epoch=2, lr=1e-05, speed=1.986 step/s, elapsed=13:39:14, eta=20:08 +[2026-04-15 19:14:42,008][trainer.accelerators.base_accelerator][INFO] - Training progress: step=97650/100000 (97.65%), epoch=2, lr=1e-05, speed=1.986 step/s, elapsed=13:39:32, eta=19:43 +[2026-04-15 19:15:00,221][trainer.accelerators.base_accelerator][INFO] - Training progress: step=97700/100000 (97.70%), epoch=2, lr=1e-05, speed=1.986 step/s, elapsed=13:39:50, eta=19:18 +[2026-04-15 19:15:18,076][trainer.accelerators.base_accelerator][INFO] - Training progress: step=97750/100000 (97.75%), epoch=2, lr=1e-05, speed=1.986 step/s, elapsed=13:40:08, eta=18:52 +[2026-04-15 19:15:35,828][trainer.accelerators.base_accelerator][INFO] - Training progress: step=97800/100000 (97.80%), epoch=2, lr=1e-05, speed=1.987 step/s, elapsed=13:40:26, eta=18:27 +[2026-04-15 19:15:53,708][trainer.accelerators.base_accelerator][INFO] - Training progress: step=97850/100000 (97.85%), epoch=2, lr=1e-05, speed=1.987 step/s, elapsed=13:40:44, eta=18:02 +[2026-04-15 19:16:11,917][trainer.accelerators.base_accelerator][INFO] - Training progress: step=97900/100000 (97.90%), epoch=2, lr=1e-05, speed=1.987 step/s, elapsed=13:41:02, eta=17:36 +[2026-04-15 19:16:32,195][trainer.accelerators.base_accelerator][INFO] - Training progress: step=97950/100000 (97.95%), epoch=2, lr=1e-05, speed=1.988 step/s, elapsed=13:41:22, eta=17:11 +[2026-04-15 19:16:49,992][trainer.accelerators.base_accelerator][INFO] - Training progress: step=98000/100000 (98.00%), epoch=2, lr=1e-05, speed=1.988 step/s, elapsed=13:41:40, eta=16:46 +[2026-04-15 19:16:50,016][__main__][INFO] - ========== EVAL START (periodic@gstep=98000) ========== +[2026-04-15 19:16:50,017][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-15 19:16:50,017][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 19:17:05,520][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.108707427978516, 'accuracy': 0.5223529411764706, 'num_samples': 425, 'test_unique_accuracy': 0.48842592592592593, 'test_unique_num_samples': 432} +[2026-04-15 19:17:05,520][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-15 19:17:05,520][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 19:17:20,802][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.108707427978516, 'accuracy': 0.5223529411764706, 'num_samples': 425, 'test_unique_accuracy': 0.5347222222222222, 'test_unique_num_samples': 432} +[2026-04-15 19:17:20,802][__main__][INFO] - ========== EVAL END (periodic@gstep=98000) ========== +[2026-04-15 19:17:20,803][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.117445945739746, 'accuracy': 0.5223529411764706, 'num_samples': 425, 'test_unique_accuracy': 0.5347222222222222, 'test_unique_num_samples': 432} +[2026-04-15 19:17:20,807][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.5223529411764706 is not better than 0.5788235294117647 of logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep32000, skipping checkpoint +[2026-04-15 19:17:38,679][trainer.accelerators.base_accelerator][INFO] - Training progress: step=98050/100000 (98.05%), epoch=2, lr=1e-05, speed=1.987 step/s, elapsed=13:42:29, eta=16:21 +[2026-04-15 19:17:56,580][trainer.accelerators.base_accelerator][INFO] - Training progress: step=98100/100000 (98.10%), epoch=2, lr=1e-05, speed=1.987 step/s, elapsed=13:42:47, eta=15:56 +[2026-04-15 19:18:14,411][trainer.accelerators.base_accelerator][INFO] - Training progress: step=98150/100000 (98.15%), epoch=2, lr=1e-05, speed=1.987 step/s, elapsed=13:43:05, eta=15:30 +[2026-04-15 19:18:32,310][trainer.accelerators.base_accelerator][INFO] - Training progress: step=98200/100000 (98.20%), epoch=2, lr=1e-05, speed=1.988 step/s, elapsed=13:43:22, eta=15:05 +[2026-04-15 19:18:50,215][trainer.accelerators.base_accelerator][INFO] - Training progress: step=98250/100000 (98.25%), epoch=2, lr=1e-05, speed=1.988 step/s, elapsed=13:43:40, eta=14:40 +[2026-04-15 19:19:07,994][trainer.accelerators.base_accelerator][INFO] - Training progress: step=98300/100000 (98.30%), epoch=2, lr=1e-05, speed=1.988 step/s, elapsed=13:43:58, eta=14:14 +[2026-04-15 19:19:25,880][trainer.accelerators.base_accelerator][INFO] - Training progress: step=98350/100000 (98.35%), epoch=2, lr=1e-05, speed=1.989 step/s, elapsed=13:44:16, eta=13:49 +[2026-04-15 19:19:43,782][trainer.accelerators.base_accelerator][INFO] - Training progress: step=98400/100000 (98.40%), epoch=2, lr=1e-05, speed=1.989 step/s, elapsed=13:44:34, eta=13:24 +[2026-04-15 19:20:01,625][trainer.accelerators.base_accelerator][INFO] - Training progress: step=98450/100000 (98.45%), epoch=2, lr=1e-05, speed=1.989 step/s, elapsed=13:44:52, eta=12:59 +[2026-04-15 19:20:19,486][trainer.accelerators.base_accelerator][INFO] - Training progress: step=98500/100000 (98.50%), epoch=2, lr=1e-05, speed=1.989 step/s, elapsed=13:45:10, eta=12:33 +[2026-04-15 19:20:37,281][trainer.accelerators.base_accelerator][INFO] - Training progress: step=98550/100000 (98.55%), epoch=2, lr=1e-05, speed=1.990 step/s, elapsed=13:45:27, eta=12:08 +[2026-04-15 19:20:55,157][trainer.accelerators.base_accelerator][INFO] - Training progress: step=98600/100000 (98.60%), epoch=2, lr=1e-05, speed=1.990 step/s, elapsed=13:45:45, eta=11:43 +[2026-04-15 19:21:13,104][trainer.accelerators.base_accelerator][INFO] - Training progress: step=98650/100000 (98.65%), epoch=2, lr=1e-05, speed=1.990 step/s, elapsed=13:46:03, eta=11:18 +[2026-04-15 19:21:30,965][trainer.accelerators.base_accelerator][INFO] - Training progress: step=98700/100000 (98.70%), epoch=2, lr=1e-05, speed=1.991 step/s, elapsed=13:46:21, eta=10:53 +[2026-04-15 19:21:48,793][trainer.accelerators.base_accelerator][INFO] - Training progress: step=98750/100000 (98.75%), epoch=2, lr=1e-05, speed=1.991 step/s, elapsed=13:46:39, eta=10:27 +[2026-04-15 19:22:07,300][trainer.accelerators.base_accelerator][INFO] - Training progress: step=98800/100000 (98.80%), epoch=2, lr=1e-05, speed=1.991 step/s, elapsed=13:46:57, eta=10:02 +[2026-04-15 19:22:25,163][trainer.accelerators.base_accelerator][INFO] - Training progress: step=98850/100000 (98.85%), epoch=2, lr=1e-05, speed=1.992 step/s, elapsed=13:47:15, eta=09:37 +[2026-04-15 19:22:43,078][trainer.accelerators.base_accelerator][INFO] - Training progress: step=98900/100000 (98.90%), epoch=2, lr=1e-05, speed=1.992 step/s, elapsed=13:47:33, eta=09:12 +[2026-04-15 19:23:00,959][trainer.accelerators.base_accelerator][INFO] - Training progress: step=98950/100000 (98.95%), epoch=2, lr=1e-05, speed=1.992 step/s, elapsed=13:47:51, eta=08:47 +[2026-04-15 19:23:18,804][trainer.accelerators.base_accelerator][INFO] - Training progress: step=99000/100000 (99.00%), epoch=2, lr=1e-05, speed=1.992 step/s, elapsed=13:48:09, eta=08:21 +[2026-04-15 19:23:18,829][__main__][INFO] - ========== EVAL START (periodic@gstep=99000) ========== +[2026-04-15 19:23:18,829][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-15 19:23:18,830][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 19:23:33,914][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.117445945739746, 'accuracy': 0.5317647058823529, 'num_samples': 425, 'test_unique_accuracy': 0.5347222222222222, 'test_unique_num_samples': 432} +[2026-04-15 19:23:33,915][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-15 19:23:33,915][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 19:23:49,037][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.117445945739746, 'accuracy': 0.5317647058823529, 'num_samples': 425, 'test_unique_accuracy': 0.5115740740740741, 'test_unique_num_samples': 432} +[2026-04-15 19:23:49,038][__main__][INFO] - ========== EVAL END (periodic@gstep=99000) ========== +[2026-04-15 19:23:49,038][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.116291046142578, 'accuracy': 0.5317647058823529, 'num_samples': 425, 'test_unique_accuracy': 0.5115740740740741, 'test_unique_num_samples': 432} +[2026-04-15 19:23:49,044][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.5317647058823529 is not better than 0.5788235294117647 of logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep32000, skipping checkpoint +[2026-04-15 19:24:06,880][trainer.accelerators.base_accelerator][INFO] - Training progress: step=99050/100000 (99.05%), epoch=2, lr=1e-05, speed=1.991 step/s, elapsed=13:48:57, eta=07:57 +[2026-04-15 19:24:24,753][trainer.accelerators.base_accelerator][INFO] - Training progress: step=99100/100000 (99.10%), epoch=2, lr=1e-05, speed=1.992 step/s, elapsed=13:49:15, eta=07:31 +[2026-04-15 19:24:42,644][trainer.accelerators.base_accelerator][INFO] - Training progress: step=99150/100000 (99.15%), epoch=2, lr=1e-05, speed=1.992 step/s, elapsed=13:49:33, eta=07:06 +[2026-04-15 19:25:00,489][trainer.accelerators.base_accelerator][INFO] - Training progress: step=99200/100000 (99.20%), epoch=2, lr=1e-05, speed=1.992 step/s, elapsed=13:49:51, eta=06:41 +[2026-04-15 19:25:18,414][trainer.accelerators.base_accelerator][INFO] - Training progress: step=99250/100000 (99.25%), epoch=2, lr=1e-05, speed=1.993 step/s, elapsed=13:50:09, eta=06:16 +[2026-04-15 19:25:36,212][trainer.accelerators.base_accelerator][INFO] - Training progress: step=99300/100000 (99.30%), epoch=2, lr=1e-05, speed=1.993 step/s, elapsed=13:50:26, eta=05:51 +[2026-04-15 19:25:54,021][trainer.accelerators.base_accelerator][INFO] - Training progress: step=99350/100000 (99.35%), epoch=2, lr=1e-05, speed=1.993 step/s, elapsed=13:50:44, eta=05:26 +[2026-04-15 19:26:11,869][trainer.accelerators.base_accelerator][INFO] - Training progress: step=99400/100000 (99.40%), epoch=2, lr=1e-05, speed=1.993 step/s, elapsed=13:51:02, eta=05:00 +[2026-04-15 19:26:29,671][trainer.accelerators.base_accelerator][INFO] - Training progress: step=99450/100000 (99.45%), epoch=2, lr=1e-05, speed=1.994 step/s, elapsed=13:51:20, eta=04:35 +[2026-04-15 19:26:47,528][trainer.accelerators.base_accelerator][INFO] - Training progress: step=99500/100000 (99.50%), epoch=2, lr=1e-05, speed=1.994 step/s, elapsed=13:51:38, eta=04:10 +[2026-04-15 19:27:05,238][trainer.accelerators.base_accelerator][INFO] - Training progress: step=99550/100000 (99.55%), epoch=2, lr=1e-05, speed=1.994 step/s, elapsed=13:51:55, eta=03:45 +[2026-04-15 19:27:23,087][trainer.accelerators.base_accelerator][INFO] - Training progress: step=99600/100000 (99.60%), epoch=2, lr=1e-05, speed=1.995 step/s, elapsed=13:52:13, eta=03:20 +[2026-04-15 19:27:40,974][trainer.accelerators.base_accelerator][INFO] - Training progress: step=99650/100000 (99.65%), epoch=2, lr=1e-05, speed=1.995 step/s, elapsed=13:52:31, eta=02:55 +[2026-04-15 19:27:58,879][trainer.accelerators.base_accelerator][INFO] - Training progress: step=99700/100000 (99.70%), epoch=2, lr=1e-05, speed=1.995 step/s, elapsed=13:52:49, eta=02:30 +[2026-04-15 19:28:16,656][trainer.accelerators.base_accelerator][INFO] - Training progress: step=99750/100000 (99.75%), epoch=2, lr=1e-05, speed=1.996 step/s, elapsed=13:53:07, eta=02:05 +[2026-04-15 19:28:34,568][trainer.accelerators.base_accelerator][INFO] - Training progress: step=99800/100000 (99.80%), epoch=2, lr=1e-05, speed=1.996 step/s, elapsed=13:53:25, eta=01:40 +[2026-04-15 19:28:52,482][trainer.accelerators.base_accelerator][INFO] - Training progress: step=99850/100000 (99.85%), epoch=2, lr=1e-05, speed=1.996 step/s, elapsed=13:53:43, eta=01:15 +[2026-04-15 19:29:10,663][trainer.accelerators.base_accelerator][INFO] - Training progress: step=99900/100000 (99.90%), epoch=2, lr=1e-05, speed=1.996 step/s, elapsed=13:54:01, eta=00:50 +[2026-04-15 19:29:28,546][trainer.accelerators.base_accelerator][INFO] - Training progress: step=99950/100000 (99.95%), epoch=2, lr=1e-05, speed=1.997 step/s, elapsed=13:54:19, eta=00:25 +[2026-04-15 19:29:46,405][trainer.accelerators.base_accelerator][INFO] - Training progress: step=100000/100000 (100.00%), epoch=2, lr=1e-05, speed=1.997 step/s, elapsed=13:54:37, eta=00:00 +[2026-04-15 19:29:46,414][__main__][INFO] - ========== EVAL START (final@gstep=100000) ========== +[2026-04-15 19:29:46,414][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-15 19:29:46,414][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 19:30:05,935][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.116291046142578, 'accuracy': 0.5270588235294118, 'num_samples': 425, 'test_unique_accuracy': 0.5115740740740741, 'test_unique_num_samples': 432} +[2026-04-15 19:30:05,936][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-15 19:30:05,936][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 19:30:21,040][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.116291046142578, 'accuracy': 0.5270588235294118, 'num_samples': 425, 'test_unique_accuracy': 0.49074074074074076, 'test_unique_num_samples': 432} +[2026-04-15 19:30:21,040][__main__][INFO] - ========== EVAL END (final@gstep=100000) ========== +[2026-04-15 19:30:21,040][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.118317604064941, 'accuracy': 0.5270588235294118, 'num_samples': 425, 'test_unique_accuracy': 0.49074074074074076, 'test_unique_num_samples': 432} +[2026-04-15 19:30:21,057][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.5270588235294118 is not better than 0.5788235294117647 of logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep32000, skipping checkpoint +[2026-04-15 19:31:04,377][root][INFO] - gcc -pthread -B /g/data/rr81/aev/compiler_compat -DNDEBUG -fwrapv -O2 -Wall -fPIC -O2 -isystem /g/data/rr81/aev/include -fPIC -O2 -isystem /g/data/rr81/aev/include -fPIC -c /scratch/rr81/ma5430/tmp/tmp7curprgz/test.c -o /scratch/rr81/ma5430/tmp/tmp7curprgz/test.o +[2026-04-15 19:31:05,095][root][INFO] - gcc -pthread -B /g/data/rr81/aev/compiler_compat /scratch/rr81/ma5430/tmp/tmp7curprgz/test.o -laio -o /scratch/rr81/ma5430/tmp/tmp7curprgz/a.out +[2026-04-15 19:31:06,024][trainer.accelerators.base_accelerator][WARNING] - Falling back to direct model unwrap because DeepSpeed import failed: CUDA_HOME does not exist, unable to compile CUDA op(s) +[2026-04-15 19:31:06,028][trainer.accelerators.base_accelerator][INFO] - Saving final checkpoint to logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-final +[2026-04-15 19:31:09,191][trainer.accelerators.base_accelerator][INFO] - Saved checkpoint to logs/v7/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-final diff --git a/lrm/lrm_sana/logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/.hydra/config.yaml b/lrm/lrm_sana/logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/.hydra/config.yaml new file mode 100644 index 0000000000000000000000000000000000000000..ff76ae4b83b9e7a1ffd2a6fc5a096eccf72aa561 --- /dev/null +++ b/lrm/lrm_sana/logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/.hydra/config.yaml @@ -0,0 +1,126 @@ +accelerator: + _target_: trainer.accelerators.debug_accelerator.DebugAccelerator + output_dir: ${output_dir} + mixed_precision: BF16 + gradient_accumulation_steps: 1 + log_with: null + debug: + activate: false + port: 5900 + seed: 42 + resume_from_checkpoint: true + max_steps: 100000 + num_epochs: 10 + validate_steps: 1000 + generalization_validate_steps: 500 + eval_on_start: false + project_name: reward_model + run_name: step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951 + max_grad_norm: 1.0 + save_steps: ${accelerator.validate_steps} + metric_name: accuracy + metric_mode: MAX + limit_num_checkpoints: 1 + save_only_if_best: true + dynamo_backend: 'NO' + keep_best_ckpts: true + progress_log_interval: 50 +task: + limit_examples_to_wandb: 50 + _target_: trainer.tasks.step_sana_task.StepSanaTask + pretrained_model_name_or_path: ${model.pretrained_model_name_or_path} + tokenizer_subfolder: tokenizer + label_0_column_name: ${dataset.label_0_column_name} + label_1_column_name: ${dataset.label_1_column_name} + input_ids_column_name: ${dataset.input_ids_column_name} + input_ids_2_column_name: ${dataset.input_ids_2_column_name} + pixels_0_column_name: ${dataset.pixels_0_column_name} + pixels_1_column_name: ${dataset.pixels_1_column_name} + timestep_column_name: ${dataset.timestep_column_name} + constant_timestep: ${dataset.constant_timestep} +model: + _target_: trainer.models.sana_preference_model.SanaPreferenceModel + pretrained_model_name_or_path: Efficient-Large-Model/Sana_600M_512px_diffusers + pretrained_vae_name_or_path: '' + model_profile: sana_600m_512 + projection_dim: 1024 + logit_scale_init_value: 2.6592 + freeze_text_encoder: false + guidance_scale: 2.5 + noise_offset: false + noise_offset_coeff: 0.05 + max_sequence_length: 300 + max_sequence_length_2: 300 + image_size: 512 +criterion: + _target_: trainer.criterions.step_clip_criterion_sana.StepSanaCLIPCriterion + is_distributed: false + label_0_column_name: ${dataset.label_0_column_name} + label_1_column_name: ${dataset.label_1_column_name} + input_ids_column_name: ${dataset.input_ids_column_name} + input_ids_2_column_name: ${dataset.input_ids_2_column_name} + pixels_0_column_name: ${dataset.pixels_0_column_name} + pixels_1_column_name: ${dataset.pixels_1_column_name} + num_examples_per_prompt_column_name: ${dataset.num_examples_per_prompt_column_name} + timestep_column_name: ${dataset.timestep_column_name} + loss_type: pair + batch_coeff: 1.0 + aux_loss_coeff: 1.0 +dataset: + train_split_name: train + valid_split_name: validation_unique + test_split_name: test_unique + batch_size: 4 + num_workers: 2 + drop_last: true + _target_: trainer.datasets.step_sana_hf_dataset.StepSanaHFDataset + dataset_name: pickapic-anonymous/pickapic_v1 + dataset_config_name: null + from_disk: false + cache_dir: null + caption_column_name: caption + input_ids_column_name: input_ids + input_ids_2_column_name: input_ids_2 + image_0_column_name: jpg_0 + image_1_column_name: jpg_1 + label_0_column_name: label_0 + label_1_column_name: label_1 + are_different_column_name: are_different + has_label_column_name: has_label + pixels_0_column_name: pixel_values_0 + pixels_1_column_name: pixel_values_1 + timestep_column_name: timestep + constant_timestep: 1 + variable_timestep: true + largest_timestep: 951 + compare_between_timestep: false + timestep_comparison_column_name: timestep_comparison + timestep_interval: 1 + num_examples_per_prompt_column_name: num_example_per_prompt + keep_only_different: false + keep_only_with_label: false + keep_only_with_label_in_non_train: true + keep_only_with_pesudo_preference: true + pseudo_preference_path: /g/data/rr81/LPO/lrm/lrm_sana/vqa_aes_clip_score_mp.csv + filter_strategy: 2 + processor: + pretrained_model_name_or_path: ${model.pretrained_model_name_or_path} + max_sequence_length: ${model.max_sequence_length} + max_sequence_length_2: ${model.max_sequence_length_2} + image_size: ${model.image_size} + random_crop: false + no_hflip: true + limit_examples_per_prompt: -1 + only_on_best: false +optimizer: + _target_: trainer.optimizers.adamw.BaseAdamW + lr: 1.0e-05 +lr_scheduler: + _target_: trainer.lr_schedulers.constant_with_warmup.instantiate_dummy_lr_scheduler + lr: ${optimizer.lr} + lr_warmup_steps: 1000 + total_num_steps: ${accelerator.max_steps} +debug: + activate: false + port: 5900 +output_dir: logs/v8/${accelerator.project_name}/${accelerator.run_name} diff --git a/lrm/lrm_sana/logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/.hydra/hydra.yaml b/lrm/lrm_sana/logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/.hydra/hydra.yaml new file mode 100644 index 0000000000000000000000000000000000000000..b8119953572821749b82ab92dcbd71d67d7710f9 --- /dev/null +++ b/lrm/lrm_sana/logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/.hydra/hydra.yaml @@ -0,0 +1,172 @@ +hydra: + run: + dir: ${output_dir} + sweep: + dir: multirun/${now:%Y-%m-%d}/${now:%H-%M-%S} + subdir: ${hydra.job.num} + launcher: + _target_: hydra._internal.core_plugins.basic_launcher.BasicLauncher + sweeper: + _target_: hydra._internal.core_plugins.basic_sweeper.BasicSweeper + max_batch_size: null + params: null + help: + app_name: ${hydra.job.name} + header: '${hydra.help.app_name} is powered by Hydra. + + ' + footer: 'Powered by Hydra (https://hydra.cc) + + Use --hydra-help to view Hydra specific help + + ' + template: '${hydra.help.header} + + == Configuration groups == + + Compose your configuration from those groups (group=option) + + + $APP_CONFIG_GROUPS + + + == Config == + + Override anything in the config (foo.bar=value) + + + $CONFIG + + + ${hydra.help.footer} + + ' + hydra_help: + template: 'Hydra (${hydra.runtime.version}) + + See https://hydra.cc for more info. + + + == Flags == + + $FLAGS_HELP + + + == Configuration groups == + + Compose your configuration from those groups (For example, append hydra/job_logging=disabled + to command line) + + + $HYDRA_CONFIG_GROUPS + + + Use ''--cfg hydra'' to Show the Hydra config. + + ' + hydra_help: ??? + hydra_logging: + version: 1 + formatters: + simple: + format: '[%(asctime)s][HYDRA] %(message)s' + handlers: + console: + class: logging.StreamHandler + formatter: simple + stream: ext://sys.stdout + root: + level: INFO + handlers: + - console + loggers: + logging_example: + level: DEBUG + disable_existing_loggers: false + job_logging: + version: 1 + formatters: + simple: + format: '[%(asctime)s][%(name)s][%(levelname)s] - %(message)s' + handlers: + console: + class: logging.StreamHandler + formatter: simple + stream: ext://sys.stdout + file: + class: logging.FileHandler + formatter: simple + filename: ${hydra.runtime.output_dir}/${hydra.job.name}.log + root: + level: INFO + handlers: + - console + - file + disable_existing_loggers: false + env: {} + mode: RUN + searchpath: [] + callbacks: {} + output_subdir: .hydra + overrides: + hydra: + - hydra.mode=RUN + task: + - accelerator.mixed_precision=BF16 + - model.model_profile=sana_600m_512 + - model.pretrained_model_name_or_path=Efficient-Large-Model/Sana_600M_512px_diffusers + - model.image_size=512 + - accelerator.run_name=step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951 + - accelerator.log_with=null + - accelerator=debug + - criterion.is_distributed=false + - dataset.pseudo_preference_path=/g/data/rr81/LPO/lrm/lrm_sana/vqa_aes_clip_score_mp.csv + - dataset.valid_split_name=validation_unique + - dataset.test_split_name=test_unique + job: + name: train + chdir: null + override_dirname: accelerator.log_with=null,accelerator.mixed_precision=BF16,accelerator.run_name=step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951,accelerator=debug,criterion.is_distributed=false,dataset.pseudo_preference_path=/g/data/rr81/LPO/lrm/lrm_sana/vqa_aes_clip_score_mp.csv,dataset.test_split_name=test_unique,dataset.valid_split_name=validation_unique,model.image_size=512,model.model_profile=sana_600m_512,model.pretrained_model_name_or_path=Efficient-Large-Model/Sana_600M_512px_diffusers + id: ??? + num: ??? + config_name: step_sana_base + env_set: {} + env_copy: [] + config: + override_dirname: + kv_sep: '=' + item_sep: ',' + exclude_keys: [] + runtime: + version: 1.3.2 + version_base: '1.3' + cwd: /g/data/rr81/LPO/lrm/lrm_sana + config_sources: + - path: hydra.conf + schema: pkg + provider: hydra + - path: /g/data/rr81/LPO/lrm/lrm_sana/trainer/conf + schema: file + provider: main + - path: '' + schema: structured + provider: schema + output_dir: /g/data/rr81/LPO/lrm/lrm_sana/logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951 + choices: + lr_scheduler: constant_with_warmup + optimizer: adamw + dataset: step_sana + criterion: step_clip_sana + model: step_sana_base + task: step_sana + accelerator: debug + hydra/env: default + hydra/callbacks: null + hydra/job_logging: default + hydra/hydra_logging: default + hydra/hydra_help: default + hydra/help: default + hydra/sweeper: basic + hydra/launcher: basic + hydra/output: default + verbose: false diff --git a/lrm/lrm_sana/logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/.hydra/overrides.yaml b/lrm/lrm_sana/logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/.hydra/overrides.yaml new file mode 100644 index 0000000000000000000000000000000000000000..70b5f1288287baf490e700a136bba21d4f0c18d7 --- /dev/null +++ b/lrm/lrm_sana/logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/.hydra/overrides.yaml @@ -0,0 +1,11 @@ +- accelerator.mixed_precision=BF16 +- model.model_profile=sana_600m_512 +- model.pretrained_model_name_or_path=Efficient-Large-Model/Sana_600M_512px_diffusers +- model.image_size=512 +- accelerator.run_name=step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951 +- accelerator.log_with=null +- accelerator=debug +- criterion.is_distributed=false +- dataset.pseudo_preference_path=/g/data/rr81/LPO/lrm/lrm_sana/vqa_aes_clip_score_mp.csv +- dataset.valid_split_name=validation_unique +- dataset.test_split_name=test_unique diff --git a/lrm/lrm_sana/logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-final/text_encoder/config.json b/lrm/lrm_sana/logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-final/text_encoder/config.json new file mode 100644 index 0000000000000000000000000000000000000000..8da873be68310ce47a9449694a8743a9960e16dc --- /dev/null +++ b/lrm/lrm_sana/logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-final/text_encoder/config.json @@ -0,0 +1,63 @@ +{ + "architectures": [ + "Gemma2Model" + ], + "attention_bias": false, + "attention_dropout": 0.0, + "attn_logit_softcapping": 50.0, + "bos_token_id": 2, + "cache_implementation": "hybrid", + "dtype": "bfloat16", + "eos_token_id": [ + 1, + 107 + ], + "final_logit_softcapping": 30.0, + "head_dim": 256, + "hidden_act": "gelu_pytorch_tanh", + "hidden_activation": "gelu_pytorch_tanh", + "hidden_size": 2304, + "initializer_range": 0.02, + "intermediate_size": 9216, + "layer_types": [ + "sliding_attention", + "full_attention", + "sliding_attention", + "full_attention", + "sliding_attention", + "full_attention", + "sliding_attention", + "full_attention", + "sliding_attention", + "full_attention", + "sliding_attention", + "full_attention", + "sliding_attention", + "full_attention", + "sliding_attention", + "full_attention", + "sliding_attention", + "full_attention", + "sliding_attention", + "full_attention", + "sliding_attention", + "full_attention", + "sliding_attention", + "full_attention", + "sliding_attention", + "full_attention" + ], + "max_position_embeddings": 8192, + "model_type": "gemma2", + "num_attention_heads": 8, + "num_hidden_layers": 26, + "num_key_value_heads": 4, + "pad_token_id": 0, + "query_pre_attn_scalar": 256, + "rms_norm_eps": 1e-06, + "rope_theta": 10000.0, + "sliding_window": 4096, + "transformers_version": "4.57.6", + "use_cache": true, + "vocab_size": 256000 +} diff --git a/lrm/lrm_sana/logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-final/training_stage.json b/lrm/lrm_sana/logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-final/training_stage.json new file mode 100644 index 0000000000000000000000000000000000000000..657d29cbd6c43183acdcc2643a1b895b11cf0132 --- /dev/null +++ b/lrm/lrm_sana/logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-final/training_stage.json @@ -0,0 +1,14 @@ +{ + "epoch": 2, + "step": 11462, + "global_step": 100000, + "step_loss": 0.0, + "lr": 1e-05, + "metrics": { + "logit_scale": 15.953969955444336, + "accuracy": 0.49411764705882355, + "num_samples": 425, + "test_unique_accuracy": 0.4930555555555556, + "test_unique_num_samples": 432 + } +} \ No newline at end of file diff --git a/lrm/lrm_sana/logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-final/transformer/config.json b/lrm/lrm_sana/logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-final/transformer/config.json new file mode 100644 index 0000000000000000000000000000000000000000..d3a24a14e0aff9a6e41a16a821f56257ff8ab814 --- /dev/null +++ b/lrm/lrm_sana/logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-final/transformer/config.json @@ -0,0 +1,26 @@ +{ + "_class_name": "SanaTransformer2DModel", + "_diffusers_version": "0.36.0", + "_name_or_path": "Efficient-Large-Model/Sana_600M_512px_diffusers", + "attention_bias": false, + "attention_head_dim": 32, + "caption_channels": 2304, + "cross_attention_dim": 1152, + "cross_attention_head_dim": 72, + "dropout": 0.0, + "guidance_embeds": false, + "guidance_embeds_scale": 0.1, + "in_channels": 32, + "interpolation_scale": null, + "mlp_ratio": 2.5, + "norm_elementwise_affine": false, + "norm_eps": 1e-06, + "num_attention_heads": 36, + "num_cross_attention_heads": 16, + "num_layers": 28, + "out_channels": 32, + "patch_size": 1, + "qk_norm": null, + "sample_size": 16, + "timestep_scale": 1.0 +} diff --git a/lrm/lrm_sana/logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep32000/training_stage.json b/lrm/lrm_sana/logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep32000/training_stage.json new file mode 100644 index 0000000000000000000000000000000000000000..078c8b78434788255ba8c697b486371efed35712 --- /dev/null +++ b/lrm/lrm_sana/logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep32000/training_stage.json @@ -0,0 +1,14 @@ +{ + "epoch": 0, + "step": 32000, + "global_step": 32000, + "step_loss": 0.0, + "lr": 1e-05, + "metrics": { + "logit_scale": 14.247028350830078, + "accuracy": 0.5364705882352941, + "num_samples": 425, + "test_unique_accuracy": 0.5092592592592593, + "test_unique_num_samples": 432 + } +} \ No newline at end of file diff --git a/lrm/lrm_sana/logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep33000/training_stage.json b/lrm/lrm_sana/logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep33000/training_stage.json new file mode 100644 index 0000000000000000000000000000000000000000..17f606ffe1625a027e879073aafaba7cf04e4b36 --- /dev/null +++ b/lrm/lrm_sana/logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep33000/training_stage.json @@ -0,0 +1,14 @@ +{ + "epoch": 0, + "step": 33000, + "global_step": 33000, + "step_loss": 0.0, + "lr": 1e-05, + "metrics": { + "logit_scale": 14.255379676818848, + "accuracy": 0.56, + "num_samples": 425, + "test_unique_accuracy": 0.5162037037037037, + "test_unique_num_samples": 432 + } +} \ No newline at end of file diff --git a/lrm/lrm_sana/logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep76000/training_stage.json b/lrm/lrm_sana/logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep76000/training_stage.json new file mode 100644 index 0000000000000000000000000000000000000000..4e66c2139f8bbc7869fd9e8f933a59776557b4ff --- /dev/null +++ b/lrm/lrm_sana/logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep76000/training_stage.json @@ -0,0 +1,14 @@ +{ + "epoch": 1, + "step": 31731, + "global_step": 76000, + "step_loss": 0.0, + "lr": 1e-05, + "metrics": { + "logit_scale": 15.195332527160645, + "accuracy": 0.5741176470588235, + "num_samples": 425, + "test_unique_accuracy": 0.5162037037037037, + "test_unique_num_samples": 432 + } +} \ No newline at end of file diff --git a/lrm/lrm_sana/logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/config.yaml b/lrm/lrm_sana/logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/config.yaml new file mode 100644 index 0000000000000000000000000000000000000000..b52e06e347b539bbb9990e20a233a9a1fd04811b --- /dev/null +++ b/lrm/lrm_sana/logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/config.yaml @@ -0,0 +1,126 @@ +accelerator: + _target_: trainer.accelerators.debug_accelerator.DebugAccelerator + output_dir: logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951 + mixed_precision: BF16 + gradient_accumulation_steps: 1 + log_with: null + debug: + activate: false + port: 5900 + seed: 42 + resume_from_checkpoint: true + max_steps: 100000 + num_epochs: 10 + validate_steps: 1000 + generalization_validate_steps: 500 + eval_on_start: false + project_name: reward_model + run_name: step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951 + max_grad_norm: 1.0 + save_steps: 1000 + metric_name: accuracy + metric_mode: MAX + limit_num_checkpoints: 1 + save_only_if_best: true + dynamo_backend: 'NO' + keep_best_ckpts: true + progress_log_interval: 50 +task: + limit_examples_to_wandb: 50 + _target_: trainer.tasks.step_sana_task.StepSanaTask + pretrained_model_name_or_path: Efficient-Large-Model/Sana_600M_512px_diffusers + tokenizer_subfolder: tokenizer + label_0_column_name: label_0 + label_1_column_name: label_1 + input_ids_column_name: input_ids + input_ids_2_column_name: input_ids_2 + pixels_0_column_name: pixel_values_0 + pixels_1_column_name: pixel_values_1 + timestep_column_name: timestep + constant_timestep: 1 +model: + _target_: trainer.models.sana_preference_model.SanaPreferenceModel + pretrained_model_name_or_path: Efficient-Large-Model/Sana_600M_512px_diffusers + pretrained_vae_name_or_path: '' + model_profile: sana_600m_512 + projection_dim: 1024 + logit_scale_init_value: 2.6592 + freeze_text_encoder: false + guidance_scale: 2.5 + noise_offset: false + noise_offset_coeff: 0.05 + max_sequence_length: 300 + max_sequence_length_2: 300 + image_size: 512 +criterion: + _target_: trainer.criterions.step_clip_criterion_sana.StepSanaCLIPCriterion + is_distributed: false + label_0_column_name: label_0 + label_1_column_name: label_1 + input_ids_column_name: input_ids + input_ids_2_column_name: input_ids_2 + pixels_0_column_name: pixel_values_0 + pixels_1_column_name: pixel_values_1 + num_examples_per_prompt_column_name: num_example_per_prompt + timestep_column_name: timestep + loss_type: pair + batch_coeff: 1.0 + aux_loss_coeff: 1.0 +dataset: + train_split_name: train + valid_split_name: validation_unique + test_split_name: test_unique + batch_size: 4 + num_workers: 2 + drop_last: true + _target_: trainer.datasets.step_sana_hf_dataset.StepSanaHFDataset + dataset_name: pickapic-anonymous/pickapic_v1 + dataset_config_name: null + from_disk: false + cache_dir: null + caption_column_name: caption + input_ids_column_name: input_ids + input_ids_2_column_name: input_ids_2 + image_0_column_name: jpg_0 + image_1_column_name: jpg_1 + label_0_column_name: label_0 + label_1_column_name: label_1 + are_different_column_name: are_different + has_label_column_name: has_label + pixels_0_column_name: pixel_values_0 + pixels_1_column_name: pixel_values_1 + timestep_column_name: timestep + constant_timestep: 1 + variable_timestep: true + largest_timestep: 951 + compare_between_timestep: false + timestep_comparison_column_name: timestep_comparison + timestep_interval: 1 + num_examples_per_prompt_column_name: num_example_per_prompt + keep_only_different: false + keep_only_with_label: false + keep_only_with_label_in_non_train: true + keep_only_with_pesudo_preference: true + pseudo_preference_path: /g/data/rr81/LPO/lrm/lrm_sana/vqa_aes_clip_score_mp.csv + filter_strategy: 2 + processor: + pretrained_model_name_or_path: Efficient-Large-Model/Sana_600M_512px_diffusers + max_sequence_length: 300 + max_sequence_length_2: 300 + image_size: 512 + random_crop: false + no_hflip: true + limit_examples_per_prompt: -1 + only_on_best: false +optimizer: + _target_: trainer.optimizers.adamw.BaseAdamW + lr: 1.0e-05 +lr_scheduler: + _target_: trainer.lr_schedulers.constant_with_warmup.instantiate_dummy_lr_scheduler + lr: 1.0e-05 + lr_warmup_steps: 1000 + total_num_steps: 100000 +debug: + activate: false + port: 5900 +output_dir: logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951 diff --git a/lrm/lrm_sana/logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/train.log b/lrm/lrm_sana/logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/train.log new file mode 100644 index 0000000000000000000000000000000000000000..85c4349cfd201d68a2898b2aa4c2777bb32e4235 --- /dev/null +++ b/lrm/lrm_sana/logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/train.log @@ -0,0 +1,3137 @@ +[2026-04-15 23:18:21,956][accelerate.utils.other][WARNING] - Detected kernel version 4.18.0, which is below the recommended minimum of 5.5.0; this can cause the process to hang. It is recommended to upgrade the kernel to the minimum version or higher. +[2026-04-15 23:18:21,958][trainer.accelerators.base_accelerator][INFO] - Setting seed 42 +[2026-04-15 23:18:22,440][trainer.accelerators.base_accelerator][INFO] - Initialized accelerator: rank=0 +[2026-04-15 23:18:22,485][__main__][INFO] - Config can be found in logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/config.yaml +[2026-04-15 23:18:22,485][__main__][INFO] - Loading task +[2026-04-15 23:18:23,708][__main__][INFO] - Loading model +[2026-04-15 23:18:37,219][__main__][INFO] - Loading criterion +[2026-04-15 23:18:37,220][__main__][INFO] - Loading optimizer +[2026-04-15 23:18:37,228][__main__][INFO] - Loading lr scheduler +[2026-04-15 23:18:37,228][__main__][INFO] - Loading dataloaders +[2026-04-15 23:18:37,228][trainer.datasets.step_sana_hf_dataset][INFO] - Using step-aware datasets +[2026-04-15 23:18:37,229][trainer.datasets.step_sana_hf_dataset][INFO] - Loading train dataset +[2026-04-15 23:18:37,229][trainer.datasets.step_sana_hf_dataset][INFO] - Batch size is 4 +[2026-04-15 23:18:37,233][trainer.datasets.step_sana_hf_dataset][INFO] - Loading cached offline split 'train' from 387 parquet shards +[2026-04-15 23:18:39,468][trainer.datasets.step_sana_hf_dataset][INFO] - Loaded 583747 examples from train dataset +[2026-04-15 23:18:40,472][trainer.datasets.step_sana_hf_dataset][INFO] - Keeping only examples with pesudo preference, filter_strategy: 2 +[2026-04-15 23:18:40,479][trainer.datasets.step_sana_hf_dataset][INFO] - Loaded 583747 examples from train dataset +[2026-04-15 23:18:40,660][trainer.datasets.step_sana_hf_dataset][INFO] - Kept 177076 examples from train dataset +[2026-04-15 23:18:40,661][trainer.datasets.step_sana_hf_dataset][INFO] - Loaded 177076 examples from train dataset +[2026-04-15 23:18:41,501][trainer.datasets.step_sana_hf_dataset][INFO] - Using step-aware datasets +[2026-04-15 23:18:41,501][trainer.datasets.step_sana_hf_dataset][INFO] - Loading validation_unique dataset +[2026-04-15 23:18:41,501][trainer.datasets.step_sana_hf_dataset][INFO] - Batch size is 4 +[2026-04-15 23:18:41,502][trainer.datasets.step_sana_hf_dataset][INFO] - Loading cached offline split 'validation_unique' from 1 parquet shards +[2026-04-15 23:18:41,512][trainer.datasets.step_sana_hf_dataset][INFO] - Loaded 500 examples from validation_unique dataset +[2026-04-15 23:18:41,512][trainer.datasets.step_sana_hf_dataset][INFO] - Keeping only examples with label in validation_unique split +[2026-04-15 23:18:41,771][trainer.datasets.step_sana_hf_dataset][INFO] - Kept 425 examples from validation_unique dataset +[2026-04-15 23:18:41,771][trainer.datasets.step_sana_hf_dataset][INFO] - Loaded 425 examples from validation_unique dataset +[2026-04-15 23:18:42,676][trainer.datasets.step_sana_hf_dataset][INFO] - Using step-aware datasets +[2026-04-15 23:18:42,677][trainer.datasets.step_sana_hf_dataset][INFO] - Loading test_unique dataset +[2026-04-15 23:18:42,677][trainer.datasets.step_sana_hf_dataset][INFO] - Batch size is 4 +[2026-04-15 23:18:42,677][trainer.datasets.step_sana_hf_dataset][INFO] - Loading cached offline split 'test_unique' from 1 parquet shards +[2026-04-15 23:18:42,688][trainer.datasets.step_sana_hf_dataset][INFO] - Loaded 500 examples from test_unique dataset +[2026-04-15 23:18:42,688][trainer.datasets.step_sana_hf_dataset][INFO] - Keeping only examples with label in test_unique split +[2026-04-15 23:18:42,949][trainer.datasets.step_sana_hf_dataset][INFO] - Kept 432 examples from test_unique dataset +[2026-04-15 23:18:42,949][trainer.datasets.step_sana_hf_dataset][INFO] - Loaded 432 examples from test_unique dataset +[2026-04-15 23:18:48,636][trainer.accelerators.base_accelerator][INFO] - No checkpoint found, training from scratch +[2026-04-15 23:18:48,636][trainer.accelerators.base_accelerator][INFO] - num_update_steps_per_epoch = 44269 +[2026-04-15 23:18:48,637][trainer.accelerators.base_accelerator][INFO] - num_batches = 44269 +[2026-04-15 23:18:48,637][trainer.accelerators.base_accelerator][INFO] - num_epochs = 3 +[2026-04-15 23:18:48,662][trainer.accelerators.base_accelerator][INFO] - Initializing trackers +[2026-04-15 23:18:48,662][trainer.accelerators.base_accelerator][INFO] - Training config: +[2026-04-15 23:18:48,746][trainer.accelerators.base_accelerator][INFO] - nvidia-smi stats: {'gpu_0_mem_used_gb': 7.3779296875} +[2026-04-15 23:18:48,746][trainer.accelerators.base_accelerator][INFO] - ***** Running training ***** +[2026-04-15 23:18:48,747][trainer.accelerators.base_accelerator][INFO] - Instantaneous batch size per device = 4 +[2026-04-15 23:18:48,747][trainer.accelerators.base_accelerator][INFO] - Total train batch size (w. parallel, distributed & accumulation) = 4 +[2026-04-15 23:18:48,747][trainer.accelerators.base_accelerator][INFO] - Gradient Accumulation steps = 1 +[2026-04-15 23:18:48,747][trainer.accelerators.base_accelerator][INFO] - Total warmup steps = 1000 +[2026-04-15 23:18:48,747][trainer.accelerators.base_accelerator][INFO] - Total training steps = 100000 +[2026-04-15 23:18:48,748][trainer.accelerators.base_accelerator][INFO] - Total epochs = 3 +[2026-04-15 23:18:48,748][trainer.accelerators.base_accelerator][INFO] - Steps per epoch = 44269 +[2026-04-15 23:18:48,748][trainer.accelerators.base_accelerator][INFO] - Update steps per epoch = 44269 +[2026-04-15 23:18:48,748][trainer.accelerators.base_accelerator][INFO] - Total optimization steps = 100000 +[2026-04-15 23:18:48,748][trainer.accelerators.base_accelerator][INFO] - Mixed precision = bf16 +[2026-04-15 23:18:48,748][trainer.accelerators.base_accelerator][INFO] - World size = 1 +[2026-04-15 23:18:48,750][__main__][INFO] - task: StepSanaTask +[2026-04-15 23:18:48,750][__main__][INFO] - model: SanaPreferenceModel +[2026-04-15 23:18:48,757][__main__][INFO] - num. model params: 3520M +[2026-04-15 23:18:48,764][__main__][INFO] - num. model trainable params: 3208M +[2026-04-15 23:18:48,765][__main__][INFO] - criterion: StepSanaCLIPCriterion +[2026-04-15 23:18:48,765][__main__][INFO] - num. train examples: 177076 +[2026-04-15 23:18:48,765][__main__][INFO] - num. valid examples: 425 +[2026-04-15 23:18:48,765][__main__][INFO] - num. test examples: 432 +[2026-04-15 23:18:48,789][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.284856796264648} +[2026-04-15 23:18:48,790][__main__][INFO] - ========== TRAIN LOOP START (eval_on_start=False, validate_steps=1000, progress_log_interval=50) ========== +[2026-04-15 23:18:55,091][trainer.accelerators.base_accelerator][INFO] - Training progress: step=1/100000 (0.00%), epoch=0, lr=0.0, speed=0.158 step/s, elapsed=00:06, eta=176:11:09 +[2026-04-15 23:19:16,887][trainer.accelerators.base_accelerator][INFO] - Training progress: step=50/100000 (0.05%), epoch=0, lr=5.000000000000001e-07, speed=1.777 step/s, elapsed=00:28, eta=15:37:28 +[2026-04-15 23:19:39,135][trainer.accelerators.base_accelerator][INFO] - Training progress: step=100/100000 (0.10%), epoch=0, lr=1.0000000000000002e-06, speed=1.985 step/s, elapsed=00:50, eta=13:58:55 +[2026-04-15 23:20:01,365][trainer.accelerators.base_accelerator][INFO] - Training progress: step=150/100000 (0.15%), epoch=0, lr=1.5e-06, speed=2.066 step/s, elapsed=01:12, eta=13:25:38 +[2026-04-15 23:20:23,493][trainer.accelerators.base_accelerator][INFO] - Training progress: step=200/100000 (0.20%), epoch=0, lr=2.0000000000000003e-06, speed=2.111 step/s, elapsed=01:34, eta=13:07:57 +[2026-04-15 23:20:45,667][trainer.accelerators.base_accelerator][INFO] - Training progress: step=250/100000 (0.25%), epoch=0, lr=2.5e-06, speed=2.138 step/s, elapsed=01:56, eta=12:57:30 +[2026-04-15 23:21:08,183][trainer.accelerators.base_accelerator][INFO] - Training progress: step=300/100000 (0.30%), epoch=0, lr=3e-06, speed=2.152 step/s, elapsed=02:19, eta=12:52:18 +[2026-04-15 23:21:30,374][trainer.accelerators.base_accelerator][INFO] - Training progress: step=350/100000 (0.35%), epoch=0, lr=3.5e-06, speed=2.166 step/s, elapsed=02:41, eta=12:46:57 +[2026-04-15 23:21:52,502][trainer.accelerators.base_accelerator][INFO] - Training progress: step=400/100000 (0.40%), epoch=0, lr=4.000000000000001e-06, speed=2.177 step/s, elapsed=03:03, eta=12:42:34 +[2026-04-15 23:22:14,570][trainer.accelerators.base_accelerator][INFO] - Training progress: step=450/100000 (0.45%), epoch=0, lr=4.5e-06, speed=2.186 step/s, elapsed=03:25, eta=12:38:52 +[2026-04-15 23:22:38,001][trainer.accelerators.base_accelerator][INFO] - Training progress: step=500/100000 (0.50%), epoch=0, lr=5e-06, speed=2.181 step/s, elapsed=03:49, eta=12:40:21 +[2026-04-15 23:23:08,951][trainer.accelerators.base_accelerator][INFO] - Training progress: step=550/100000 (0.55%), epoch=0, lr=5.500000000000001e-06, speed=2.114 step/s, elapsed=04:20, eta=13:04:03 +[2026-04-15 23:23:32,995][trainer.accelerators.base_accelerator][INFO] - Training progress: step=600/100000 (0.60%), epoch=0, lr=6e-06, speed=2.111 step/s, elapsed=04:44, eta=13:04:50 +[2026-04-15 23:23:57,537][trainer.accelerators.base_accelerator][INFO] - Training progress: step=650/100000 (0.65%), epoch=0, lr=6.5000000000000004e-06, speed=2.105 step/s, elapsed=05:08, eta=13:06:37 +[2026-04-15 23:24:20,822][trainer.accelerators.base_accelerator][INFO] - Training progress: step=700/100000 (0.70%), epoch=0, lr=7e-06, speed=2.108 step/s, elapsed=05:32, eta=13:05:06 +[2026-04-15 23:24:44,769][trainer.accelerators.base_accelerator][INFO] - Training progress: step=750/100000 (0.75%), epoch=0, lr=7.500000000000001e-06, speed=2.107 step/s, elapsed=05:56, eta=13:05:13 +[2026-04-15 23:25:19,739][trainer.accelerators.base_accelerator][INFO] - Training progress: step=800/100000 (0.80%), epoch=0, lr=8.000000000000001e-06, speed=2.046 step/s, elapsed=06:30, eta=13:28:02 +[2026-04-15 23:26:55,005][trainer.accelerators.base_accelerator][INFO] - Training progress: step=850/100000 (0.85%), epoch=0, lr=8.5e-06, speed=1.748 step/s, elapsed=08:06, eta=15:45:20 +[2026-04-15 23:27:41,988][trainer.accelerators.base_accelerator][INFO] - Training progress: step=900/100000 (0.90%), epoch=0, lr=9e-06, speed=1.688 step/s, elapsed=08:53, eta=16:18:35 +[2026-04-15 23:28:04,365][trainer.accelerators.base_accelerator][INFO] - Training progress: step=950/100000 (0.95%), epoch=0, lr=9.5e-06, speed=1.710 step/s, elapsed=09:15, eta=16:05:30 +[2026-04-15 23:28:26,581][trainer.accelerators.base_accelerator][INFO] - Training progress: step=1000/100000 (1.00%), epoch=0, lr=1e-05, speed=1.731 step/s, elapsed=09:37, eta=15:53:25 +[2026-04-15 23:28:26,619][__main__][INFO] - ========== EVAL START (periodic@gstep=1000) ========== +[2026-04-15 23:28:26,619][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-15 23:28:26,619][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 23:28:53,554][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.284856796264648, 'accuracy': 0.5035294117647059, 'num_samples': 425} +[2026-04-15 23:28:53,554][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-15 23:28:53,555][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 23:29:08,800][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.284856796264648, 'accuracy': 0.5035294117647059, 'num_samples': 425, 'test_unique_accuracy': 0.5023148148148148, 'test_unique_num_samples': 432} +[2026-04-15 23:29:08,800][__main__][INFO] - ========== EVAL END (periodic@gstep=1000) ========== +[2026-04-15 23:29:08,814][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.2732572555542, 'accuracy': 0.5035294117647059, 'num_samples': 425, 'test_unique_accuracy': 0.5023148148148148, 'test_unique_num_samples': 432} +[2026-04-15 23:29:08,821][trainer.accelerators.base_accelerator][INFO] - Not cleaning up checkpoints as only 0 checkpoints found +[2026-04-15 23:29:08,824][trainer.accelerators.base_accelerator][INFO] - Saving checkpoint to logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep1000 +[2026-04-15 23:29:08,826][accelerate.accelerator][INFO] - Saving current state to logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep1000 +[2026-04-15 23:29:20,128][accelerate.checkpointing][INFO] - Model weights saved in logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep1000/model.safetensors +[2026-04-15 23:29:35,471][accelerate.checkpointing][INFO] - Optimizer state saved in logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep1000/optimizer.bin +[2026-04-15 23:29:35,515][accelerate.checkpointing][INFO] - Scheduler state saved in logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep1000/scheduler.bin +[2026-04-15 23:29:35,515][accelerate.checkpointing][INFO] - Sampler state for dataloader 0 saved in logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep1000/sampler.bin +[2026-04-15 23:29:35,516][accelerate.checkpointing][INFO] - Sampler state for dataloader 1 saved in logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep1000/sampler_1.bin +[2026-04-15 23:29:35,516][accelerate.checkpointing][INFO] - Sampler state for dataloader 2 saved in logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep1000/sampler_2.bin +[2026-04-15 23:29:35,659][accelerate.checkpointing][INFO] - Random states saved in logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep1000/random_states_0.pkl +[2026-04-15 23:29:35,705][trainer.accelerators.base_accelerator][INFO] - Saved checkpoint to logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep1000 +[2026-04-15 23:29:58,011][trainer.accelerators.base_accelerator][INFO] - Training progress: step=1050/100000 (1.05%), epoch=0, lr=1e-05, speed=1.569 step/s, elapsed=11:09, eta=17:31:10 +[2026-04-15 23:30:20,224][trainer.accelerators.base_accelerator][INFO] - Training progress: step=1100/100000 (1.10%), epoch=0, lr=1e-05, speed=1.591 step/s, elapsed=11:31, eta=17:16:09 +[2026-04-15 23:30:42,658][trainer.accelerators.base_accelerator][INFO] - Training progress: step=1150/100000 (1.15%), epoch=0, lr=1e-05, speed=1.611 step/s, elapsed=11:53, eta=17:02:45 +[2026-04-15 23:31:04,877][trainer.accelerators.base_accelerator][INFO] - Training progress: step=1200/100000 (1.20%), epoch=0, lr=1e-05, speed=1.630 step/s, elapsed=12:16, eta=16:50:07 +[2026-04-15 23:31:28,004][trainer.accelerators.base_accelerator][INFO] - Training progress: step=1250/100000 (1.25%), epoch=0, lr=1e-05, speed=1.646 step/s, elapsed=12:39, eta=16:39:41 +[2026-04-15 23:31:50,153][trainer.accelerators.base_accelerator][INFO] - Training progress: step=1300/100000 (1.30%), epoch=0, lr=1e-05, speed=1.664 step/s, elapsed=13:01, eta=16:28:46 +[2026-04-15 23:32:12,489][trainer.accelerators.base_accelerator][INFO] - Training progress: step=1350/100000 (1.35%), epoch=0, lr=1e-05, speed=1.680 step/s, elapsed=13:23, eta=16:18:52 +[2026-04-15 23:32:34,598][trainer.accelerators.base_accelerator][INFO] - Training progress: step=1400/100000 (1.40%), epoch=0, lr=1e-05, speed=1.695 step/s, elapsed=13:45, eta=16:09:23 +[2026-04-15 23:32:56,721][trainer.accelerators.base_accelerator][INFO] - Training progress: step=1450/100000 (1.45%), epoch=0, lr=1e-05, speed=1.710 step/s, elapsed=14:07, eta=16:00:32 +[2026-04-15 23:33:18,797][trainer.accelerators.base_accelerator][INFO] - Training progress: step=1500/100000 (1.50%), epoch=0, lr=1e-05, speed=1.724 step/s, elapsed=14:30, eta=15:52:13 +[2026-04-15 23:33:40,941][trainer.accelerators.base_accelerator][INFO] - Training progress: step=1550/100000 (1.55%), epoch=0, lr=1e-05, speed=1.737 step/s, elapsed=14:52, eta=15:44:28 +[2026-04-15 23:34:03,106][trainer.accelerators.base_accelerator][INFO] - Training progress: step=1600/100000 (1.60%), epoch=0, lr=1e-05, speed=1.750 step/s, elapsed=15:14, eta=15:37:12 +[2026-04-15 23:34:25,186][trainer.accelerators.base_accelerator][INFO] - Training progress: step=1650/100000 (1.65%), epoch=0, lr=1e-05, speed=1.762 step/s, elapsed=15:36, eta=15:30:17 +[2026-04-15 23:34:47,336][trainer.accelerators.base_accelerator][INFO] - Training progress: step=1700/100000 (1.70%), epoch=0, lr=1e-05, speed=1.773 step/s, elapsed=15:58, eta=15:23:48 +[2026-04-15 23:35:09,407][trainer.accelerators.base_accelerator][INFO] - Training progress: step=1750/100000 (1.75%), epoch=0, lr=1e-05, speed=1.785 step/s, elapsed=16:20, eta=15:17:36 +[2026-04-15 23:35:31,569][trainer.accelerators.base_accelerator][INFO] - Training progress: step=1800/100000 (1.80%), epoch=0, lr=1e-05, speed=1.795 step/s, elapsed=16:42, eta=15:11:49 +[2026-04-15 23:35:54,003][trainer.accelerators.base_accelerator][INFO] - Training progress: step=1850/100000 (1.85%), epoch=0, lr=1e-05, speed=1.804 step/s, elapsed=17:05, eta=15:06:33 +[2026-04-15 23:36:16,007][trainer.accelerators.base_accelerator][INFO] - Training progress: step=1900/100000 (1.90%), epoch=0, lr=1e-05, speed=1.814 step/s, elapsed=17:27, eta=15:01:11 +[2026-04-15 23:36:38,090][trainer.accelerators.base_accelerator][INFO] - Training progress: step=1950/100000 (1.95%), epoch=0, lr=1e-05, speed=1.824 step/s, elapsed=17:49, eta=14:56:08 +[2026-04-15 23:37:00,142][trainer.accelerators.base_accelerator][INFO] - Training progress: step=2000/100000 (2.00%), epoch=0, lr=1e-05, speed=1.833 step/s, elapsed=18:11, eta=14:51:18 +[2026-04-15 23:37:00,180][__main__][INFO] - ========== EVAL START (periodic@gstep=2000) ========== +[2026-04-15 23:37:00,181][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-15 23:37:00,181][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 23:37:15,229][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.2732572555542, 'accuracy': 0.5270588235294118, 'num_samples': 425, 'test_unique_accuracy': 0.5023148148148148, 'test_unique_num_samples': 432} +[2026-04-15 23:37:15,229][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-15 23:37:15,229][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 23:37:30,311][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.2732572555542, 'accuracy': 0.5270588235294118, 'num_samples': 425, 'test_unique_accuracy': 0.4398148148148148, 'test_unique_num_samples': 432} +[2026-04-15 23:37:30,311][__main__][INFO] - ========== EVAL END (periodic@gstep=2000) ========== +[2026-04-15 23:37:30,311][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.2468843460083, 'accuracy': 0.5270588235294118, 'num_samples': 425, 'test_unique_accuracy': 0.4398148148148148, 'test_unique_num_samples': 432} +[2026-04-15 23:37:30,335][trainer.accelerators.base_accelerator][INFO] - Not cleaning up checkpoints as only 1 checkpoints found +[2026-04-15 23:37:30,337][trainer.accelerators.base_accelerator][INFO] - Saving checkpoint to logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep2000 +[2026-04-15 23:37:30,338][accelerate.accelerator][INFO] - Saving current state to logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep2000 +[2026-04-15 23:37:51,210][accelerate.checkpointing][INFO] - Model weights saved in logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep2000/model.safetensors +[2026-04-15 23:38:07,453][accelerate.checkpointing][INFO] - Optimizer state saved in logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep2000/optimizer.bin +[2026-04-15 23:38:07,455][accelerate.checkpointing][INFO] - Scheduler state saved in logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep2000/scheduler.bin +[2026-04-15 23:38:07,455][accelerate.checkpointing][INFO] - Sampler state for dataloader 0 saved in logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep2000/sampler.bin +[2026-04-15 23:38:07,455][accelerate.checkpointing][INFO] - Sampler state for dataloader 1 saved in logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep2000/sampler_1.bin +[2026-04-15 23:38:07,455][accelerate.checkpointing][INFO] - Sampler state for dataloader 2 saved in logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep2000/sampler_2.bin +[2026-04-15 23:38:07,471][accelerate.checkpointing][INFO] - Random states saved in logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep2000/random_states_0.pkl +[2026-04-15 23:38:07,528][trainer.accelerators.base_accelerator][INFO] - Saved checkpoint to logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep2000 +[2026-04-15 23:38:29,758][trainer.accelerators.base_accelerator][INFO] - Training progress: step=2050/100000 (2.05%), epoch=0, lr=1e-05, speed=1.736 step/s, elapsed=19:41, eta=15:40:29 +[2026-04-15 23:38:51,888][trainer.accelerators.base_accelerator][INFO] - Training progress: step=2100/100000 (2.10%), epoch=0, lr=1e-05, speed=1.745 step/s, elapsed=20:03, eta=15:34:49 +[2026-04-15 23:39:14,016][trainer.accelerators.base_accelerator][INFO] - Training progress: step=2150/100000 (2.15%), epoch=0, lr=1e-05, speed=1.755 step/s, elapsed=20:25, eta=15:29:23 +[2026-04-15 23:39:36,266][trainer.accelerators.base_accelerator][INFO] - Training progress: step=2200/100000 (2.20%), epoch=0, lr=1e-05, speed=1.764 step/s, elapsed=20:47, eta=15:24:17 +[2026-04-15 23:39:58,484][trainer.accelerators.base_accelerator][INFO] - Training progress: step=2250/100000 (2.25%), epoch=0, lr=1e-05, speed=1.772 step/s, elapsed=21:09, eta=15:19:22 +[2026-04-15 23:40:20,599][trainer.accelerators.base_accelerator][INFO] - Training progress: step=2300/100000 (2.30%), epoch=0, lr=1e-05, speed=1.780 step/s, elapsed=21:31, eta=15:14:35 +[2026-04-15 23:40:42,764][trainer.accelerators.base_accelerator][INFO] - Training progress: step=2350/100000 (2.35%), epoch=0, lr=1e-05, speed=1.788 step/s, elapsed=21:54, eta=15:10:01 +[2026-04-15 23:41:05,272][trainer.accelerators.base_accelerator][INFO] - Training progress: step=2400/100000 (2.40%), epoch=0, lr=1e-05, speed=1.796 step/s, elapsed=22:16, eta=15:05:51 +[2026-04-15 23:41:27,279][trainer.accelerators.base_accelerator][INFO] - Training progress: step=2450/100000 (2.45%), epoch=0, lr=1e-05, speed=1.803 step/s, elapsed=22:38, eta=15:01:31 +[2026-04-15 23:41:49,430][trainer.accelerators.base_accelerator][INFO] - Training progress: step=2500/100000 (2.50%), epoch=0, lr=1e-05, speed=1.811 step/s, elapsed=23:00, eta=14:57:26 +[2026-04-15 23:42:11,592][trainer.accelerators.base_accelerator][INFO] - Training progress: step=2550/100000 (2.55%), epoch=0, lr=1e-05, speed=1.818 step/s, elapsed=23:22, eta=14:53:30 +[2026-04-15 23:42:33,769][trainer.accelerators.base_accelerator][INFO] - Training progress: step=2600/100000 (2.60%), epoch=0, lr=1e-05, speed=1.825 step/s, elapsed=23:45, eta=14:49:43 +[2026-04-15 23:42:55,958][trainer.accelerators.base_accelerator][INFO] - Training progress: step=2650/100000 (2.65%), epoch=0, lr=1e-05, speed=1.831 step/s, elapsed=24:07, eta=14:46:04 +[2026-04-15 23:43:18,125][trainer.accelerators.base_accelerator][INFO] - Training progress: step=2700/100000 (2.70%), epoch=0, lr=1e-05, speed=1.838 step/s, elapsed=24:29, eta=14:42:31 +[2026-04-15 23:43:40,273][trainer.accelerators.base_accelerator][INFO] - Training progress: step=2750/100000 (2.75%), epoch=0, lr=1e-05, speed=1.844 step/s, elapsed=24:51, eta=14:39:05 +[2026-04-15 23:44:02,366][trainer.accelerators.base_accelerator][INFO] - Training progress: step=2800/100000 (2.80%), epoch=0, lr=1e-05, speed=1.850 step/s, elapsed=25:13, eta=14:35:44 +[2026-04-15 23:44:24,579][trainer.accelerators.base_accelerator][INFO] - Training progress: step=2850/100000 (2.85%), epoch=0, lr=1e-05, speed=1.856 step/s, elapsed=25:35, eta=14:32:32 +[2026-04-15 23:44:46,680][trainer.accelerators.base_accelerator][INFO] - Training progress: step=2900/100000 (2.90%), epoch=0, lr=1e-05, speed=1.861 step/s, elapsed=25:57, eta=14:29:23 +[2026-04-15 23:45:08,821][trainer.accelerators.base_accelerator][INFO] - Training progress: step=2950/100000 (2.95%), epoch=0, lr=1e-05, speed=1.867 step/s, elapsed=26:20, eta=14:26:21 +[2026-04-15 23:45:30,961][trainer.accelerators.base_accelerator][INFO] - Training progress: step=3000/100000 (3.00%), epoch=0, lr=1e-05, speed=1.872 step/s, elapsed=26:42, eta=14:23:24 +[2026-04-15 23:45:31,000][__main__][INFO] - ========== EVAL START (periodic@gstep=3000) ========== +[2026-04-15 23:45:31,001][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-15 23:45:31,001][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 23:45:46,393][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.2468843460083, 'accuracy': 0.5270588235294118, 'num_samples': 425, 'test_unique_accuracy': 0.4398148148148148, 'test_unique_num_samples': 432} +[2026-04-15 23:45:46,393][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-15 23:45:46,393][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 23:46:01,472][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.2468843460083, 'accuracy': 0.5270588235294118, 'num_samples': 425, 'test_unique_accuracy': 0.5, 'test_unique_num_samples': 432} +[2026-04-15 23:46:01,472][__main__][INFO] - ========== EVAL END (periodic@gstep=3000) ========== +[2026-04-15 23:46:01,473][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.237821578979492, 'accuracy': 0.5270588235294118, 'num_samples': 425, 'test_unique_accuracy': 0.5, 'test_unique_num_samples': 432} +[2026-04-15 23:46:01,479][trainer.accelerators.base_accelerator][INFO] - Found 2 checkpoints in logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951 +[2026-04-15 23:46:01,482][trainer.accelerators.base_accelerator][INFO] - Saving checkpoint to logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep3000 +[2026-04-15 23:46:01,483][accelerate.accelerator][INFO] - Saving current state to logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep3000 +[2026-04-15 23:46:23,548][accelerate.checkpointing][INFO] - Model weights saved in logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep3000/model.safetensors +[2026-04-15 23:46:58,613][accelerate.checkpointing][INFO] - Optimizer state saved in logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep3000/optimizer.bin +[2026-04-15 23:46:58,616][accelerate.checkpointing][INFO] - Scheduler state saved in logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep3000/scheduler.bin +[2026-04-15 23:46:58,616][accelerate.checkpointing][INFO] - Sampler state for dataloader 0 saved in logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep3000/sampler.bin +[2026-04-15 23:46:58,616][accelerate.checkpointing][INFO] - Sampler state for dataloader 1 saved in logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep3000/sampler_1.bin +[2026-04-15 23:46:58,616][accelerate.checkpointing][INFO] - Sampler state for dataloader 2 saved in logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep3000/sampler_2.bin +[2026-04-15 23:46:58,654][accelerate.checkpointing][INFO] - Random states saved in logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep3000/random_states_0.pkl +[2026-04-15 23:46:58,682][trainer.accelerators.base_accelerator][INFO] - Saved checkpoint to logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep3000 +[2026-04-15 23:47:20,851][trainer.accelerators.base_accelerator][INFO] - Training progress: step=3050/100000 (3.05%), epoch=0, lr=1e-05, speed=1.781 step/s, elapsed=28:32, eta=15:07:02 +[2026-04-15 23:47:43,014][trainer.accelerators.base_accelerator][INFO] - Training progress: step=3100/100000 (3.10%), epoch=0, lr=1e-05, speed=1.788 step/s, elapsed=28:54, eta=15:03:29 +[2026-04-15 23:48:05,271][trainer.accelerators.base_accelerator][INFO] - Training progress: step=3150/100000 (3.15%), epoch=0, lr=1e-05, speed=1.793 step/s, elapsed=29:16, eta=15:00:06 +[2026-04-15 23:48:27,350][trainer.accelerators.base_accelerator][INFO] - Training progress: step=3200/100000 (3.20%), epoch=0, lr=1e-05, speed=1.799 step/s, elapsed=29:38, eta=14:56:42 +[2026-04-15 23:48:49,454][trainer.accelerators.base_accelerator][INFO] - Training progress: step=3250/100000 (3.25%), epoch=0, lr=1e-05, speed=1.805 step/s, elapsed=30:00, eta=14:53:25 +[2026-04-15 23:49:11,552][trainer.accelerators.base_accelerator][INFO] - Training progress: step=3300/100000 (3.30%), epoch=0, lr=1e-05, speed=1.810 step/s, elapsed=30:22, eta=14:50:13 +[2026-04-15 23:49:33,687][trainer.accelerators.base_accelerator][INFO] - Training progress: step=3350/100000 (3.35%), epoch=0, lr=1e-05, speed=1.816 step/s, elapsed=30:44, eta=14:47:07 +[2026-04-15 23:49:55,791][trainer.accelerators.base_accelerator][INFO] - Training progress: step=3400/100000 (3.40%), epoch=0, lr=1e-05, speed=1.821 step/s, elapsed=31:07, eta=14:44:05 +[2026-04-15 23:50:20,481][trainer.accelerators.base_accelerator][INFO] - Training progress: step=3450/100000 (3.45%), epoch=0, lr=1e-05, speed=1.824 step/s, elapsed=31:31, eta=14:42:21 +[2026-04-15 23:50:42,629][trainer.accelerators.base_accelerator][INFO] - Training progress: step=3500/100000 (3.50%), epoch=0, lr=1e-05, speed=1.829 step/s, elapsed=31:53, eta=14:39:28 +[2026-04-15 23:51:04,677][trainer.accelerators.base_accelerator][INFO] - Training progress: step=3550/100000 (3.55%), epoch=0, lr=1e-05, speed=1.834 step/s, elapsed=32:15, eta=14:36:37 +[2026-04-15 23:51:26,808][trainer.accelerators.base_accelerator][INFO] - Training progress: step=3600/100000 (3.60%), epoch=0, lr=1e-05, speed=1.839 step/s, elapsed=32:38, eta=14:33:52 +[2026-04-15 23:51:48,895][trainer.accelerators.base_accelerator][INFO] - Training progress: step=3650/100000 (3.65%), epoch=0, lr=1e-05, speed=1.843 step/s, elapsed=33:00, eta=14:31:10 +[2026-04-15 23:52:11,011][trainer.accelerators.base_accelerator][INFO] - Training progress: step=3700/100000 (3.70%), epoch=0, lr=1e-05, speed=1.848 step/s, elapsed=33:22, eta=14:28:32 +[2026-04-15 23:52:33,069][trainer.accelerators.base_accelerator][INFO] - Training progress: step=3750/100000 (3.75%), epoch=0, lr=1e-05, speed=1.852 step/s, elapsed=33:44, eta=14:25:57 +[2026-04-15 23:52:55,201][trainer.accelerators.base_accelerator][INFO] - Training progress: step=3800/100000 (3.80%), epoch=0, lr=1e-05, speed=1.857 step/s, elapsed=34:06, eta=14:23:27 +[2026-04-15 23:53:17,291][trainer.accelerators.base_accelerator][INFO] - Training progress: step=3850/100000 (3.85%), epoch=0, lr=1e-05, speed=1.861 step/s, elapsed=34:28, eta=14:20:59 +[2026-04-15 23:53:39,363][trainer.accelerators.base_accelerator][INFO] - Training progress: step=3900/100000 (3.90%), epoch=0, lr=1e-05, speed=1.865 step/s, elapsed=34:50, eta=14:18:34 +[2026-04-15 23:54:01,719][trainer.accelerators.base_accelerator][INFO] - Training progress: step=3950/100000 (3.95%), epoch=0, lr=1e-05, speed=1.869 step/s, elapsed=35:12, eta=14:16:19 +[2026-04-15 23:54:23,837][trainer.accelerators.base_accelerator][INFO] - Training progress: step=4000/100000 (4.00%), epoch=0, lr=1e-05, speed=1.873 step/s, elapsed=35:35, eta=14:14:02 +[2026-04-15 23:54:23,875][__main__][INFO] - ========== EVAL START (periodic@gstep=4000) ========== +[2026-04-15 23:54:23,875][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-15 23:54:23,876][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 23:54:40,683][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.237821578979492, 'accuracy': 0.4752941176470588, 'num_samples': 425, 'test_unique_accuracy': 0.5, 'test_unique_num_samples': 432} +[2026-04-15 23:54:40,683][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-15 23:54:40,684][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-15 23:54:55,767][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.237821578979492, 'accuracy': 0.4752941176470588, 'num_samples': 425, 'test_unique_accuracy': 0.5324074074074074, 'test_unique_num_samples': 432} +[2026-04-15 23:54:55,767][__main__][INFO] - ========== EVAL END (periodic@gstep=4000) ========== +[2026-04-15 23:54:55,767][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.225308418273926, 'accuracy': 0.4752941176470588, 'num_samples': 425, 'test_unique_accuracy': 0.5324074074074074, 'test_unique_num_samples': 432} +[2026-04-15 23:54:55,790][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.4752941176470588 is not better than 0.5270588235294118 of logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep3000, skipping checkpoint +[2026-04-15 23:55:17,962][trainer.accelerators.base_accelerator][INFO] - Training progress: step=4050/100000 (4.05%), epoch=0, lr=1e-05, speed=1.850 step/s, elapsed=36:29, eta=14:24:25 +[2026-04-15 23:55:40,078][trainer.accelerators.base_accelerator][INFO] - Training progress: step=4100/100000 (4.10%), epoch=0, lr=1e-05, speed=1.854 step/s, elapsed=36:51, eta=14:22:03 +[2026-04-15 23:56:02,156][trainer.accelerators.base_accelerator][INFO] - Training progress: step=4150/100000 (4.15%), epoch=0, lr=1e-05, speed=1.858 step/s, elapsed=37:13, eta=14:19:43 +[2026-04-15 23:56:24,212][trainer.accelerators.base_accelerator][INFO] - Training progress: step=4200/100000 (4.20%), epoch=0, lr=1e-05, speed=1.862 step/s, elapsed=37:35, eta=14:17:26 +[2026-04-15 23:56:46,389][trainer.accelerators.base_accelerator][INFO] - Training progress: step=4250/100000 (4.25%), epoch=0, lr=1e-05, speed=1.866 step/s, elapsed=37:57, eta=14:15:13 +[2026-04-15 23:57:08,658][trainer.accelerators.base_accelerator][INFO] - Training progress: step=4300/100000 (4.30%), epoch=0, lr=1e-05, speed=1.870 step/s, elapsed=38:19, eta=14:13:06 +[2026-04-15 23:57:30,803][trainer.accelerators.base_accelerator][INFO] - Training progress: step=4350/100000 (4.35%), epoch=0, lr=1e-05, speed=1.873 step/s, elapsed=38:42, eta=14:10:58 +[2026-04-15 23:57:52,947][trainer.accelerators.base_accelerator][INFO] - Training progress: step=4400/100000 (4.40%), epoch=0, lr=1e-05, speed=1.877 step/s, elapsed=39:04, eta=14:08:53 +[2026-04-15 23:58:15,105][trainer.accelerators.base_accelerator][INFO] - Training progress: step=4450/100000 (4.45%), epoch=0, lr=1e-05, speed=1.881 step/s, elapsed=39:26, eta=14:06:50 +[2026-04-15 23:58:37,651][trainer.accelerators.base_accelerator][INFO] - Training progress: step=4500/100000 (4.50%), epoch=0, lr=1e-05, speed=1.884 step/s, elapsed=39:48, eta=14:04:57 +[2026-04-15 23:58:59,790][trainer.accelerators.base_accelerator][INFO] - Training progress: step=4550/100000 (4.55%), epoch=0, lr=1e-05, speed=1.887 step/s, elapsed=40:11, eta=14:02:58 +[2026-04-15 23:59:21,900][trainer.accelerators.base_accelerator][INFO] - Training progress: step=4600/100000 (4.60%), epoch=0, lr=1e-05, speed=1.891 step/s, elapsed=40:33, eta=14:01:01 +[2026-04-15 23:59:44,002][trainer.accelerators.base_accelerator][INFO] - Training progress: step=4650/100000 (4.65%), epoch=0, lr=1e-05, speed=1.894 step/s, elapsed=40:55, eta=13:59:05 +[2026-04-16 00:00:06,082][trainer.accelerators.base_accelerator][INFO] - Training progress: step=4700/100000 (4.70%), epoch=0, lr=1e-05, speed=1.897 step/s, elapsed=41:17, eta=13:57:11 +[2026-04-16 00:00:28,144][trainer.accelerators.base_accelerator][INFO] - Training progress: step=4750/100000 (4.75%), epoch=0, lr=1e-05, speed=1.900 step/s, elapsed=41:39, eta=13:55:19 +[2026-04-16 00:00:50,267][trainer.accelerators.base_accelerator][INFO] - Training progress: step=4800/100000 (4.80%), epoch=0, lr=1e-05, speed=1.904 step/s, elapsed=42:01, eta=13:53:30 +[2026-04-16 00:01:12,332][trainer.accelerators.base_accelerator][INFO] - Training progress: step=4850/100000 (4.85%), epoch=0, lr=1e-05, speed=1.907 step/s, elapsed=42:23, eta=13:51:41 +[2026-04-16 00:01:34,439][trainer.accelerators.base_accelerator][INFO] - Training progress: step=4900/100000 (4.90%), epoch=0, lr=1e-05, speed=1.910 step/s, elapsed=42:45, eta=13:49:55 +[2026-04-16 00:01:56,664][trainer.accelerators.base_accelerator][INFO] - Training progress: step=4950/100000 (4.95%), epoch=0, lr=1e-05, speed=1.913 step/s, elapsed=43:07, eta=13:48:13 +[2026-04-16 00:02:18,869][trainer.accelerators.base_accelerator][INFO] - Training progress: step=5000/100000 (5.00%), epoch=0, lr=1e-05, speed=1.916 step/s, elapsed=43:30, eta=13:46:32 +[2026-04-16 00:02:18,908][__main__][INFO] - ========== EVAL START (periodic@gstep=5000) ========== +[2026-04-16 00:02:18,908][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-16 00:02:18,908][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 00:02:34,033][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.225308418273926, 'accuracy': 0.5152941176470588, 'num_samples': 425, 'test_unique_accuracy': 0.5324074074074074, 'test_unique_num_samples': 432} +[2026-04-16 00:02:34,034][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-16 00:02:34,034][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 00:02:49,167][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.225308418273926, 'accuracy': 0.5152941176470588, 'num_samples': 425, 'test_unique_accuracy': 0.47453703703703703, 'test_unique_num_samples': 432} +[2026-04-16 00:02:49,167][__main__][INFO] - ========== EVAL END (periodic@gstep=5000) ========== +[2026-04-16 00:02:49,168][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.218055725097656, 'accuracy': 0.5152941176470588, 'num_samples': 425, 'test_unique_accuracy': 0.47453703703703703, 'test_unique_num_samples': 432} +[2026-04-16 00:02:49,171][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.5152941176470588 is not better than 0.5270588235294118 of logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep3000, skipping checkpoint +[2026-04-16 00:03:11,557][trainer.accelerators.base_accelerator][INFO] - Training progress: step=5050/100000 (5.05%), epoch=0, lr=1e-05, speed=1.896 step/s, elapsed=44:22, eta=13:54:26 +[2026-04-16 00:03:33,560][trainer.accelerators.base_accelerator][INFO] - Training progress: step=5100/100000 (5.10%), epoch=0, lr=1e-05, speed=1.900 step/s, elapsed=44:44, eta=13:52:38 +[2026-04-16 00:03:55,670][trainer.accelerators.base_accelerator][INFO] - Training progress: step=5150/100000 (5.15%), epoch=0, lr=1e-05, speed=1.903 step/s, elapsed=45:06, eta=13:50:54 +[2026-04-16 00:04:17,729][trainer.accelerators.base_accelerator][INFO] - Training progress: step=5200/100000 (5.20%), epoch=0, lr=1e-05, speed=1.905 step/s, elapsed=45:28, eta=13:49:11 +[2026-04-16 00:04:39,828][trainer.accelerators.base_accelerator][INFO] - Training progress: step=5250/100000 (5.25%), epoch=0, lr=1e-05, speed=1.908 step/s, elapsed=45:51, eta=13:47:30 +[2026-04-16 00:05:01,965][trainer.accelerators.base_accelerator][INFO] - Training progress: step=5300/100000 (5.30%), epoch=0, lr=1e-05, speed=1.911 step/s, elapsed=46:13, eta=13:45:51 +[2026-04-16 00:05:24,440][trainer.accelerators.base_accelerator][INFO] - Training progress: step=5350/100000 (5.35%), epoch=0, lr=1e-05, speed=1.914 step/s, elapsed=46:35, eta=13:44:20 +[2026-04-16 00:05:46,539][trainer.accelerators.base_accelerator][INFO] - Training progress: step=5400/100000 (5.40%), epoch=0, lr=1e-05, speed=1.916 step/s, elapsed=46:57, eta=13:42:43 +[2026-04-16 00:06:08,546][trainer.accelerators.base_accelerator][INFO] - Training progress: step=5450/100000 (5.45%), epoch=0, lr=1e-05, speed=1.919 step/s, elapsed=47:19, eta=13:41:06 +[2026-04-16 00:06:30,744][trainer.accelerators.base_accelerator][INFO] - Training progress: step=5500/100000 (5.50%), epoch=0, lr=1e-05, speed=1.922 step/s, elapsed=47:41, eta=13:39:34 +[2026-04-16 00:06:52,843][trainer.accelerators.base_accelerator][INFO] - Training progress: step=5550/100000 (5.55%), epoch=0, lr=1e-05, speed=1.924 step/s, elapsed=48:04, eta=13:38:01 +[2026-04-16 00:07:14,929][trainer.accelerators.base_accelerator][INFO] - Training progress: step=5600/100000 (5.60%), epoch=0, lr=1e-05, speed=1.927 step/s, elapsed=48:26, eta=13:36:29 +[2026-04-16 00:07:37,412][trainer.accelerators.base_accelerator][INFO] - Training progress: step=5650/100000 (5.65%), epoch=0, lr=1e-05, speed=1.929 step/s, elapsed=48:48, eta=13:35:06 +[2026-04-16 00:07:59,539][trainer.accelerators.base_accelerator][INFO] - Training progress: step=5700/100000 (5.70%), epoch=0, lr=1e-05, speed=1.932 step/s, elapsed=49:10, eta=13:33:37 +[2026-04-16 00:08:21,691][trainer.accelerators.base_accelerator][INFO] - Training progress: step=5750/100000 (5.75%), epoch=0, lr=1e-05, speed=1.934 step/s, elapsed=49:32, eta=13:32:10 +[2026-04-16 00:08:43,783][trainer.accelerators.base_accelerator][INFO] - Training progress: step=5800/100000 (5.80%), epoch=0, lr=1e-05, speed=1.937 step/s, elapsed=49:55, eta=13:30:43 +[2026-04-16 00:09:05,887][trainer.accelerators.base_accelerator][INFO] - Training progress: step=5850/100000 (5.85%), epoch=0, lr=1e-05, speed=1.939 step/s, elapsed=50:17, eta=13:29:17 +[2026-04-16 00:09:27,982][trainer.accelerators.base_accelerator][INFO] - Training progress: step=5900/100000 (5.90%), epoch=0, lr=1e-05, speed=1.941 step/s, elapsed=50:39, eta=13:27:53 +[2026-04-16 00:09:50,301][trainer.accelerators.base_accelerator][INFO] - Training progress: step=5950/100000 (5.95%), epoch=0, lr=1e-05, speed=1.943 step/s, elapsed=51:01, eta=13:26:33 +[2026-04-16 00:10:12,391][trainer.accelerators.base_accelerator][INFO] - Training progress: step=6000/100000 (6.00%), epoch=0, lr=1e-05, speed=1.946 step/s, elapsed=51:23, eta=13:25:10 +[2026-04-16 00:10:12,430][__main__][INFO] - ========== EVAL START (periodic@gstep=6000) ========== +[2026-04-16 00:10:12,431][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-16 00:10:12,431][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 00:10:27,523][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.218055725097656, 'accuracy': 0.5011764705882353, 'num_samples': 425, 'test_unique_accuracy': 0.47453703703703703, 'test_unique_num_samples': 432} +[2026-04-16 00:10:27,523][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-16 00:10:27,523][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 00:10:42,732][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.218055725097656, 'accuracy': 0.5011764705882353, 'num_samples': 425, 'test_unique_accuracy': 0.4976851851851852, 'test_unique_num_samples': 432} +[2026-04-16 00:10:42,732][__main__][INFO] - ========== EVAL END (periodic@gstep=6000) ========== +[2026-04-16 00:10:42,732][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.214221954345703, 'accuracy': 0.5011764705882353, 'num_samples': 425, 'test_unique_accuracy': 0.4976851851851852, 'test_unique_num_samples': 432} +[2026-04-16 00:10:42,736][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.5011764705882353 is not better than 0.5270588235294118 of logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep3000, skipping checkpoint +[2026-04-16 00:11:04,835][trainer.accelerators.base_accelerator][INFO] - Training progress: step=6050/100000 (6.05%), epoch=0, lr=1e-05, speed=1.929 step/s, elapsed=52:16, eta=13:31:40 +[2026-04-16 00:11:26,934][trainer.accelerators.base_accelerator][INFO] - Training progress: step=6100/100000 (6.10%), epoch=0, lr=1e-05, speed=1.931 step/s, elapsed=52:38, eta=13:30:15 +[2026-04-16 00:11:49,023][trainer.accelerators.base_accelerator][INFO] - Training progress: step=6150/100000 (6.15%), epoch=0, lr=1e-05, speed=1.934 step/s, elapsed=53:00, eta=13:28:51 +[2026-04-16 00:12:11,448][trainer.accelerators.base_accelerator][INFO] - Training progress: step=6200/100000 (6.20%), epoch=0, lr=1e-05, speed=1.936 step/s, elapsed=53:22, eta=13:27:33 +[2026-04-16 00:12:33,581][trainer.accelerators.base_accelerator][INFO] - Training progress: step=6250/100000 (6.25%), epoch=0, lr=1e-05, speed=1.938 step/s, elapsed=53:44, eta=13:26:12 +[2026-04-16 00:12:55,664][trainer.accelerators.base_accelerator][INFO] - Training progress: step=6300/100000 (6.30%), epoch=0, lr=1e-05, speed=1.940 step/s, elapsed=54:06, eta=13:24:51 +[2026-04-16 00:13:17,772][trainer.accelerators.base_accelerator][INFO] - Training progress: step=6350/100000 (6.35%), epoch=0, lr=1e-05, speed=1.942 step/s, elapsed=54:29, eta=13:23:31 +[2026-04-16 00:13:40,163][trainer.accelerators.base_accelerator][INFO] - Training progress: step=6400/100000 (6.40%), epoch=0, lr=1e-05, speed=1.944 step/s, elapsed=54:51, eta=13:22:16 +[2026-04-16 00:14:02,244][trainer.accelerators.base_accelerator][INFO] - Training progress: step=6450/100000 (6.45%), epoch=0, lr=1e-05, speed=1.947 step/s, elapsed=55:13, eta=13:20:58 +[2026-04-16 00:14:24,356][trainer.accelerators.base_accelerator][INFO] - Training progress: step=6500/100000 (6.50%), epoch=0, lr=1e-05, speed=1.949 step/s, elapsed=55:35, eta=13:19:41 +[2026-04-16 00:14:46,466][trainer.accelerators.base_accelerator][INFO] - Training progress: step=6550/100000 (6.55%), epoch=0, lr=1e-05, speed=1.951 step/s, elapsed=55:57, eta=13:18:25 +[2026-04-16 00:15:08,552][trainer.accelerators.base_accelerator][INFO] - Training progress: step=6600/100000 (6.60%), epoch=0, lr=1e-05, speed=1.953 step/s, elapsed=56:19, eta=13:17:09 +[2026-04-16 00:15:30,924][trainer.accelerators.base_accelerator][INFO] - Training progress: step=6650/100000 (6.65%), epoch=0, lr=1e-05, speed=1.955 step/s, elapsed=56:42, eta=13:15:58 +[2026-04-16 00:15:52,993][trainer.accelerators.base_accelerator][INFO] - Training progress: step=6700/100000 (6.70%), epoch=0, lr=1e-05, speed=1.957 step/s, elapsed=57:04, eta=13:14:43 +[2026-04-16 00:16:15,114][trainer.accelerators.base_accelerator][INFO] - Training progress: step=6750/100000 (6.75%), epoch=0, lr=1e-05, speed=1.959 step/s, elapsed=57:26, eta=13:13:30 +[2026-04-16 00:16:37,249][trainer.accelerators.base_accelerator][INFO] - Training progress: step=6800/100000 (6.80%), epoch=0, lr=1e-05, speed=1.961 step/s, elapsed=57:48, eta=13:12:18 +[2026-04-16 00:16:59,356][trainer.accelerators.base_accelerator][INFO] - Training progress: step=6850/100000 (6.85%), epoch=0, lr=1e-05, speed=1.962 step/s, elapsed=58:10, eta=13:11:07 +[2026-04-16 00:17:21,757][trainer.accelerators.base_accelerator][INFO] - Training progress: step=6900/100000 (6.90%), epoch=0, lr=1e-05, speed=1.964 step/s, elapsed=58:33, eta=13:10:00 +[2026-04-16 00:17:43,871][trainer.accelerators.base_accelerator][INFO] - Training progress: step=6950/100000 (6.95%), epoch=0, lr=1e-05, speed=1.966 step/s, elapsed=58:55, eta=13:08:49 +[2026-04-16 00:18:05,946][trainer.accelerators.base_accelerator][INFO] - Training progress: step=7000/100000 (7.00%), epoch=0, lr=1e-05, speed=1.968 step/s, elapsed=59:17, eta=13:07:39 +[2026-04-16 00:18:05,984][__main__][INFO] - ========== EVAL START (periodic@gstep=7000) ========== +[2026-04-16 00:18:05,985][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-16 00:18:05,985][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 00:18:21,047][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.214221954345703, 'accuracy': 0.5223529411764706, 'num_samples': 425, 'test_unique_accuracy': 0.4976851851851852, 'test_unique_num_samples': 432} +[2026-04-16 00:18:21,047][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-16 00:18:21,047][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 00:18:36,143][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.214221954345703, 'accuracy': 0.5223529411764706, 'num_samples': 425, 'test_unique_accuracy': 0.4722222222222222, 'test_unique_num_samples': 432} +[2026-04-16 00:18:36,143][__main__][INFO] - ========== EVAL END (periodic@gstep=7000) ========== +[2026-04-16 00:18:36,143][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.205789566040039, 'accuracy': 0.5223529411764706, 'num_samples': 425, 'test_unique_accuracy': 0.4722222222222222, 'test_unique_num_samples': 432} +[2026-04-16 00:18:36,146][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.5223529411764706 is not better than 0.5270588235294118 of logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep3000, skipping checkpoint +[2026-04-16 00:18:58,220][trainer.accelerators.base_accelerator][INFO] - Training progress: step=7050/100000 (7.05%), epoch=0, lr=1e-05, speed=1.953 step/s, elapsed=01:00:09, eta=13:13:08 +[2026-04-16 00:19:20,235][trainer.accelerators.base_accelerator][INFO] - Training progress: step=7100/100000 (7.10%), epoch=0, lr=1e-05, speed=1.955 step/s, elapsed=01:00:31, eta=13:11:56 +[2026-04-16 00:19:42,507][trainer.accelerators.base_accelerator][INFO] - Training progress: step=7150/100000 (7.15%), epoch=0, lr=1e-05, speed=1.957 step/s, elapsed=01:00:53, eta=13:10:47 +[2026-04-16 00:20:04,545][trainer.accelerators.base_accelerator][INFO] - Training progress: step=7200/100000 (7.20%), epoch=0, lr=1e-05, speed=1.959 step/s, elapsed=01:01:15, eta=13:09:36 +[2026-04-16 00:20:26,590][trainer.accelerators.base_accelerator][INFO] - Training progress: step=7250/100000 (7.25%), epoch=0, lr=1e-05, speed=1.961 step/s, elapsed=01:01:37, eta=13:08:26 +[2026-04-16 00:20:48,684][trainer.accelerators.base_accelerator][INFO] - Training progress: step=7300/100000 (7.30%), epoch=0, lr=1e-05, speed=1.962 step/s, elapsed=01:01:59, eta=13:07:18 +[2026-04-16 00:21:10,822][trainer.accelerators.base_accelerator][INFO] - Training progress: step=7350/100000 (7.35%), epoch=0, lr=1e-05, speed=1.964 step/s, elapsed=01:02:22, eta=13:06:10 +[2026-04-16 00:21:32,924][trainer.accelerators.base_accelerator][INFO] - Training progress: step=7400/100000 (7.40%), epoch=0, lr=1e-05, speed=1.966 step/s, elapsed=01:02:44, eta=13:05:03 +[2026-04-16 00:21:55,333][trainer.accelerators.base_accelerator][INFO] - Training progress: step=7450/100000 (7.45%), epoch=0, lr=1e-05, speed=1.967 step/s, elapsed=01:03:06, eta=13:04:00 +[2026-04-16 00:22:17,452][trainer.accelerators.base_accelerator][INFO] - Training progress: step=7500/100000 (7.50%), epoch=0, lr=1e-05, speed=1.969 step/s, elapsed=01:03:28, eta=13:02:54 +[2026-04-16 00:22:39,493][trainer.accelerators.base_accelerator][INFO] - Training progress: step=7550/100000 (7.55%), epoch=0, lr=1e-05, speed=1.971 step/s, elapsed=01:03:50, eta=13:01:47 +[2026-04-16 00:23:01,626][trainer.accelerators.base_accelerator][INFO] - Training progress: step=7600/100000 (7.60%), epoch=0, lr=1e-05, speed=1.973 step/s, elapsed=01:04:12, eta=13:00:42 +[2026-04-16 00:23:23,754][trainer.accelerators.base_accelerator][INFO] - Training progress: step=7650/100000 (7.65%), epoch=0, lr=1e-05, speed=1.974 step/s, elapsed=01:04:35, eta=12:59:38 +[2026-04-16 00:23:45,773][trainer.accelerators.base_accelerator][INFO] - Training progress: step=7700/100000 (7.70%), epoch=0, lr=1e-05, speed=1.976 step/s, elapsed=01:04:57, eta=12:58:33 +[2026-04-16 00:24:08,069][trainer.accelerators.base_accelerator][INFO] - Training progress: step=7750/100000 (7.75%), epoch=0, lr=1e-05, speed=1.977 step/s, elapsed=01:05:19, eta=12:57:32 +[2026-04-16 00:24:29,943][trainer.accelerators.base_accelerator][INFO] - Training progress: step=7800/100000 (7.80%), epoch=0, lr=1e-05, speed=1.979 step/s, elapsed=01:05:41, eta=12:56:26 +[2026-04-16 00:24:52,001][trainer.accelerators.base_accelerator][INFO] - Training progress: step=7850/100000 (7.85%), epoch=0, lr=1e-05, speed=1.981 step/s, elapsed=01:06:03, eta=12:55:24 +[2026-04-16 00:25:14,020][trainer.accelerators.base_accelerator][INFO] - Training progress: step=7900/100000 (7.90%), epoch=0, lr=1e-05, speed=1.982 step/s, elapsed=01:06:25, eta=12:54:21 +[2026-04-16 00:25:36,145][trainer.accelerators.base_accelerator][INFO] - Training progress: step=7950/100000 (7.95%), epoch=0, lr=1e-05, speed=1.984 step/s, elapsed=01:06:47, eta=12:53:20 +[2026-04-16 00:25:58,249][trainer.accelerators.base_accelerator][INFO] - Training progress: step=8000/100000 (8.00%), epoch=0, lr=1e-05, speed=1.985 step/s, elapsed=01:07:09, eta=12:52:19 +[2026-04-16 00:25:58,288][__main__][INFO] - ========== EVAL START (periodic@gstep=8000) ========== +[2026-04-16 00:25:58,288][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-16 00:25:58,288][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 00:26:13,375][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.205789566040039, 'accuracy': 0.48705882352941177, 'num_samples': 425, 'test_unique_accuracy': 0.4722222222222222, 'test_unique_num_samples': 432} +[2026-04-16 00:26:13,376][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-16 00:26:13,376][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 00:26:28,458][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.205789566040039, 'accuracy': 0.48705882352941177, 'num_samples': 425, 'test_unique_accuracy': 0.44212962962962965, 'test_unique_num_samples': 432} +[2026-04-16 00:26:28,458][__main__][INFO] - ========== EVAL END (periodic@gstep=8000) ========== +[2026-04-16 00:26:28,458][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.199830055236816, 'accuracy': 0.48705882352941177, 'num_samples': 425, 'test_unique_accuracy': 0.44212962962962965, 'test_unique_num_samples': 432} +[2026-04-16 00:26:28,462][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.48705882352941177 is not better than 0.5270588235294118 of logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep3000, skipping checkpoint +[2026-04-16 00:26:50,752][trainer.accelerators.base_accelerator][INFO] - Training progress: step=8050/100000 (8.05%), epoch=0, lr=1e-05, speed=1.972 step/s, elapsed=01:08:02, eta=12:57:06 +[2026-04-16 00:27:12,751][trainer.accelerators.base_accelerator][INFO] - Training progress: step=8100/100000 (8.10%), epoch=0, lr=1e-05, speed=1.974 step/s, elapsed=01:08:24, eta=12:56:02 +[2026-04-16 00:27:34,828][trainer.accelerators.base_accelerator][INFO] - Training progress: step=8150/100000 (8.15%), epoch=0, lr=1e-05, speed=1.975 step/s, elapsed=01:08:46, eta=12:55:00 +[2026-04-16 00:27:56,908][trainer.accelerators.base_accelerator][INFO] - Training progress: step=8200/100000 (8.20%), epoch=0, lr=1e-05, speed=1.977 step/s, elapsed=01:09:08, eta=12:53:59 +[2026-04-16 00:28:19,066][trainer.accelerators.base_accelerator][INFO] - Training progress: step=8250/100000 (8.25%), epoch=0, lr=1e-05, speed=1.978 step/s, elapsed=01:09:30, eta=12:52:58 +[2026-04-16 00:28:41,420][trainer.accelerators.base_accelerator][INFO] - Training progress: step=8300/100000 (8.30%), epoch=0, lr=1e-05, speed=1.980 step/s, elapsed=01:09:52, eta=12:52:01 +[2026-04-16 00:29:03,551][trainer.accelerators.base_accelerator][INFO] - Training progress: step=8350/100000 (8.35%), epoch=0, lr=1e-05, speed=1.981 step/s, elapsed=01:10:14, eta=12:51:01 +[2026-04-16 00:29:25,622][trainer.accelerators.base_accelerator][INFO] - Training progress: step=8400/100000 (8.40%), epoch=0, lr=1e-05, speed=1.983 step/s, elapsed=01:10:36, eta=12:50:02 +[2026-04-16 00:29:47,665][trainer.accelerators.base_accelerator][INFO] - Training progress: step=8450/100000 (8.45%), epoch=0, lr=1e-05, speed=1.984 step/s, elapsed=01:10:58, eta=12:49:02 +[2026-04-16 00:30:09,724][trainer.accelerators.base_accelerator][INFO] - Training progress: step=8500/100000 (8.50%), epoch=0, lr=1e-05, speed=1.986 step/s, elapsed=01:11:20, eta=12:48:03 +[2026-04-16 00:30:32,095][trainer.accelerators.base_accelerator][INFO] - Training progress: step=8550/100000 (8.55%), epoch=0, lr=1e-05, speed=1.987 step/s, elapsed=01:11:43, eta=12:47:08 +[2026-04-16 00:30:54,220][trainer.accelerators.base_accelerator][INFO] - Training progress: step=8600/100000 (8.60%), epoch=0, lr=1e-05, speed=1.988 step/s, elapsed=01:12:05, eta=12:46:10 +[2026-04-16 00:31:16,268][trainer.accelerators.base_accelerator][INFO] - Training progress: step=8650/100000 (8.65%), epoch=0, lr=1e-05, speed=1.990 step/s, elapsed=01:12:27, eta=12:45:12 +[2026-04-16 00:31:38,375][trainer.accelerators.base_accelerator][INFO] - Training progress: step=8700/100000 (8.70%), epoch=0, lr=1e-05, speed=1.991 step/s, elapsed=01:12:49, eta=12:44:15 +[2026-04-16 00:32:00,480][trainer.accelerators.base_accelerator][INFO] - Training progress: step=8750/100000 (8.75%), epoch=0, lr=1e-05, speed=1.992 step/s, elapsed=01:13:11, eta=12:43:19 +[2026-04-16 00:32:22,811][trainer.accelerators.base_accelerator][INFO] - Training progress: step=8800/100000 (8.80%), epoch=0, lr=1e-05, speed=1.994 step/s, elapsed=01:13:34, eta=12:42:25 +[2026-04-16 00:32:44,924][trainer.accelerators.base_accelerator][INFO] - Training progress: step=8850/100000 (8.85%), epoch=0, lr=1e-05, speed=1.995 step/s, elapsed=01:13:56, eta=12:41:30 +[2026-04-16 00:33:06,928][trainer.accelerators.base_accelerator][INFO] - Training progress: step=8900/100000 (8.90%), epoch=0, lr=1e-05, speed=1.996 step/s, elapsed=01:14:18, eta=12:40:33 +[2026-04-16 00:33:29,062][trainer.accelerators.base_accelerator][INFO] - Training progress: step=8950/100000 (8.95%), epoch=0, lr=1e-05, speed=1.998 step/s, elapsed=01:14:40, eta=12:39:39 +[2026-04-16 00:33:51,160][trainer.accelerators.base_accelerator][INFO] - Training progress: step=9000/100000 (9.00%), epoch=0, lr=1e-05, speed=1.999 step/s, elapsed=01:15:02, eta=12:38:44 +[2026-04-16 00:33:51,199][__main__][INFO] - ========== EVAL START (periodic@gstep=9000) ========== +[2026-04-16 00:33:51,199][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-16 00:33:51,199][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 00:34:07,172][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.199830055236816, 'accuracy': 0.5176470588235295, 'num_samples': 425, 'test_unique_accuracy': 0.44212962962962965, 'test_unique_num_samples': 432} +[2026-04-16 00:34:07,173][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-16 00:34:07,173][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 00:34:22,249][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.199830055236816, 'accuracy': 0.5176470588235295, 'num_samples': 425, 'test_unique_accuracy': 0.5115740740740741, 'test_unique_num_samples': 432} +[2026-04-16 00:34:22,249][__main__][INFO] - ========== EVAL END (periodic@gstep=9000) ========== +[2026-04-16 00:34:22,249][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.193527221679688, 'accuracy': 0.5176470588235295, 'num_samples': 425, 'test_unique_accuracy': 0.5115740740740741, 'test_unique_num_samples': 432} +[2026-04-16 00:34:22,253][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.5176470588235295 is not better than 0.5270588235294118 of logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep3000, skipping checkpoint +[2026-04-16 00:34:44,289][trainer.accelerators.base_accelerator][INFO] - Training progress: step=9050/100000 (9.05%), epoch=0, lr=1e-05, speed=1.987 step/s, elapsed=01:15:55, eta=12:43:01 +[2026-04-16 00:35:06,689][trainer.accelerators.base_accelerator][INFO] - Training progress: step=9100/100000 (9.10%), epoch=0, lr=1e-05, speed=1.988 step/s, elapsed=01:16:17, eta=12:42:09 +[2026-04-16 00:35:28,778][trainer.accelerators.base_accelerator][INFO] - Training progress: step=9150/100000 (9.15%), epoch=0, lr=1e-05, speed=1.989 step/s, elapsed=01:16:40, eta=12:41:13 +[2026-04-16 00:35:50,860][trainer.accelerators.base_accelerator][INFO] - Training progress: step=9200/100000 (9.20%), epoch=0, lr=1e-05, speed=1.990 step/s, elapsed=01:17:02, eta=12:40:18 +[2026-04-16 00:36:13,016][trainer.accelerators.base_accelerator][INFO] - Training progress: step=9250/100000 (9.25%), epoch=0, lr=1e-05, speed=1.992 step/s, elapsed=01:17:24, eta=12:39:24 +[2026-04-16 00:36:35,172][trainer.accelerators.base_accelerator][INFO] - Training progress: step=9300/100000 (9.30%), epoch=0, lr=1e-05, speed=1.993 step/s, elapsed=01:17:46, eta=12:38:30 +[2026-04-16 00:36:57,336][trainer.accelerators.base_accelerator][INFO] - Training progress: step=9350/100000 (9.35%), epoch=0, lr=1e-05, speed=1.994 step/s, elapsed=01:18:08, eta=12:37:36 +[2026-04-16 00:37:19,486][trainer.accelerators.base_accelerator][INFO] - Training progress: step=9400/100000 (9.40%), epoch=0, lr=1e-05, speed=1.995 step/s, elapsed=01:18:30, eta=12:36:43 +[2026-04-16 00:37:41,586][trainer.accelerators.base_accelerator][INFO] - Training progress: step=9450/100000 (9.45%), epoch=0, lr=1e-05, speed=1.997 step/s, elapsed=01:18:52, eta=12:35:50 +[2026-04-16 00:38:03,710][trainer.accelerators.base_accelerator][INFO] - Training progress: step=9500/100000 (9.50%), epoch=0, lr=1e-05, speed=1.998 step/s, elapsed=01:19:14, eta=12:34:57 +[2026-04-16 00:38:25,799][trainer.accelerators.base_accelerator][INFO] - Training progress: step=9550/100000 (9.55%), epoch=0, lr=1e-05, speed=1.999 step/s, elapsed=01:19:37, eta=12:34:04 +[2026-04-16 00:38:47,827][trainer.accelerators.base_accelerator][INFO] - Training progress: step=9600/100000 (9.60%), epoch=0, lr=1e-05, speed=2.000 step/s, elapsed=01:19:59, eta=12:33:11 +[2026-04-16 00:39:09,990][trainer.accelerators.base_accelerator][INFO] - Training progress: step=9650/100000 (9.65%), epoch=0, lr=1e-05, speed=2.002 step/s, elapsed=01:20:21, eta=12:32:19 +[2026-04-16 00:39:32,380][trainer.accelerators.base_accelerator][INFO] - Training progress: step=9700/100000 (9.70%), epoch=0, lr=1e-05, speed=2.003 step/s, elapsed=01:20:43, eta=12:31:30 +[2026-04-16 00:39:54,515][trainer.accelerators.base_accelerator][INFO] - Training progress: step=9750/100000 (9.75%), epoch=0, lr=1e-05, speed=2.004 step/s, elapsed=01:21:05, eta=12:30:39 +[2026-04-16 00:40:16,667][trainer.accelerators.base_accelerator][INFO] - Training progress: step=9800/100000 (9.80%), epoch=0, lr=1e-05, speed=2.005 step/s, elapsed=01:21:27, eta=12:29:48 +[2026-04-16 00:40:38,828][trainer.accelerators.base_accelerator][INFO] - Training progress: step=9850/100000 (9.85%), epoch=0, lr=1e-05, speed=2.006 step/s, elapsed=01:21:50, eta=12:28:58 +[2026-04-16 00:41:00,993][trainer.accelerators.base_accelerator][INFO] - Training progress: step=9900/100000 (9.90%), epoch=0, lr=1e-05, speed=2.007 step/s, elapsed=01:22:12, eta=12:28:08 +[2026-04-16 00:41:23,081][trainer.accelerators.base_accelerator][INFO] - Training progress: step=9950/100000 (9.95%), epoch=0, lr=1e-05, speed=2.008 step/s, elapsed=01:22:34, eta=12:27:17 +[2026-04-16 00:41:45,177][trainer.accelerators.base_accelerator][INFO] - Training progress: step=10000/100000 (10.00%), epoch=0, lr=1e-05, speed=2.009 step/s, elapsed=01:22:56, eta=12:26:27 +[2026-04-16 00:41:45,217][__main__][INFO] - ========== EVAL START (periodic@gstep=10000) ========== +[2026-04-16 00:41:45,217][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-16 00:41:45,217][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 00:42:04,822][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.193527221679688, 'accuracy': 0.47058823529411764, 'num_samples': 425, 'test_unique_accuracy': 0.5115740740740741, 'test_unique_num_samples': 432} +[2026-04-16 00:42:04,823][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-16 00:42:04,823][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 00:42:19,959][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.193527221679688, 'accuracy': 0.47058823529411764, 'num_samples': 425, 'test_unique_accuracy': 0.4976851851851852, 'test_unique_num_samples': 432} +[2026-04-16 00:42:19,959][__main__][INFO] - ========== EVAL END (periodic@gstep=10000) ========== +[2026-04-16 00:42:19,959][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.193591117858887, 'accuracy': 0.47058823529411764, 'num_samples': 425, 'test_unique_accuracy': 0.4976851851851852, 'test_unique_num_samples': 432} +[2026-04-16 00:42:19,980][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.47058823529411764 is not better than 0.5270588235294118 of logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep3000, skipping checkpoint +[2026-04-16 00:42:42,208][trainer.accelerators.base_accelerator][INFO] - Training progress: step=10050/100000 (10.05%), epoch=0, lr=1e-05, speed=1.997 step/s, elapsed=01:23:53, eta=12:30:50 +[2026-04-16 00:43:04,334][trainer.accelerators.base_accelerator][INFO] - Training progress: step=10100/100000 (10.10%), epoch=0, lr=1e-05, speed=1.998 step/s, elapsed=01:24:15, eta=12:29:59 +[2026-04-16 00:43:26,724][trainer.accelerators.base_accelerator][INFO] - Training progress: step=10150/100000 (10.15%), epoch=0, lr=1e-05, speed=1.999 step/s, elapsed=01:24:37, eta=12:29:11 +[2026-04-16 00:43:48,936][trainer.accelerators.base_accelerator][INFO] - Training progress: step=10200/100000 (10.20%), epoch=0, lr=1e-05, speed=2.000 step/s, elapsed=01:25:00, eta=12:28:21 +[2026-04-16 00:44:11,082][trainer.accelerators.base_accelerator][INFO] - Training progress: step=10250/100000 (10.25%), epoch=0, lr=1e-05, speed=2.001 step/s, elapsed=01:25:22, eta=12:27:31 +[2026-04-16 00:44:33,310][trainer.accelerators.base_accelerator][INFO] - Training progress: step=10300/100000 (10.30%), epoch=0, lr=1e-05, speed=2.002 step/s, elapsed=01:25:44, eta=12:26:42 +[2026-04-16 00:44:55,462][trainer.accelerators.base_accelerator][INFO] - Training progress: step=10350/100000 (10.35%), epoch=0, lr=1e-05, speed=2.003 step/s, elapsed=01:26:06, eta=12:25:53 +[2026-04-16 00:45:17,848][trainer.accelerators.base_accelerator][INFO] - Training progress: step=10400/100000 (10.40%), epoch=0, lr=1e-05, speed=2.004 step/s, elapsed=01:26:29, eta=12:25:06 +[2026-04-16 00:45:40,018][trainer.accelerators.base_accelerator][INFO] - Training progress: step=10450/100000 (10.45%), epoch=0, lr=1e-05, speed=2.005 step/s, elapsed=01:26:51, eta=12:24:17 +[2026-04-16 00:46:02,139][trainer.accelerators.base_accelerator][INFO] - Training progress: step=10500/100000 (10.50%), epoch=0, lr=1e-05, speed=2.006 step/s, elapsed=01:27:13, eta=12:23:28 +[2026-04-16 00:46:24,142][trainer.accelerators.base_accelerator][INFO] - Training progress: step=10550/100000 (10.55%), epoch=0, lr=1e-05, speed=2.007 step/s, elapsed=01:27:35, eta=12:22:38 +[2026-04-16 00:46:46,272][trainer.accelerators.base_accelerator][INFO] - Training progress: step=10600/100000 (10.60%), epoch=0, lr=1e-05, speed=2.009 step/s, elapsed=01:27:57, eta=12:21:50 +[2026-04-16 00:47:08,595][trainer.accelerators.base_accelerator][INFO] - Training progress: step=10650/100000 (10.65%), epoch=0, lr=1e-05, speed=2.009 step/s, elapsed=01:28:19, eta=12:21:03 +[2026-04-16 00:47:30,707][trainer.accelerators.base_accelerator][INFO] - Training progress: step=10700/100000 (10.70%), epoch=0, lr=1e-05, speed=2.011 step/s, elapsed=01:28:41, eta=12:20:15 +[2026-04-16 00:47:52,821][trainer.accelerators.base_accelerator][INFO] - Training progress: step=10750/100000 (10.75%), epoch=0, lr=1e-05, speed=2.012 step/s, elapsed=01:29:04, eta=12:19:28 +[2026-04-16 00:48:15,009][trainer.accelerators.base_accelerator][INFO] - Training progress: step=10800/100000 (10.80%), epoch=0, lr=1e-05, speed=2.013 step/s, elapsed=01:29:26, eta=12:18:41 +[2026-04-16 00:48:37,142][trainer.accelerators.base_accelerator][INFO] - Training progress: step=10850/100000 (10.85%), epoch=0, lr=1e-05, speed=2.014 step/s, elapsed=01:29:48, eta=12:17:54 +[2026-04-16 00:48:59,714][trainer.accelerators.base_accelerator][INFO] - Training progress: step=10900/100000 (10.90%), epoch=0, lr=1e-05, speed=2.014 step/s, elapsed=01:30:10, eta=12:17:10 +[2026-04-16 00:49:21,853][trainer.accelerators.base_accelerator][INFO] - Training progress: step=10950/100000 (10.95%), epoch=0, lr=1e-05, speed=2.015 step/s, elapsed=01:30:33, eta=12:16:24 +[2026-04-16 00:49:43,962][trainer.accelerators.base_accelerator][INFO] - Training progress: step=11000/100000 (11.00%), epoch=0, lr=1e-05, speed=2.016 step/s, elapsed=01:30:55, eta=12:15:37 +[2026-04-16 00:49:44,001][__main__][INFO] - ========== EVAL START (periodic@gstep=11000) ========== +[2026-04-16 00:49:44,002][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-16 00:49:44,002][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 00:49:59,108][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.193591117858887, 'accuracy': 0.4894117647058824, 'num_samples': 425, 'test_unique_accuracy': 0.4976851851851852, 'test_unique_num_samples': 432} +[2026-04-16 00:49:59,108][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-16 00:49:59,109][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 00:50:14,283][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.193591117858887, 'accuracy': 0.4894117647058824, 'num_samples': 425, 'test_unique_accuracy': 0.4837962962962963, 'test_unique_num_samples': 432} +[2026-04-16 00:50:14,284][__main__][INFO] - ========== EVAL END (periodic@gstep=11000) ========== +[2026-04-16 00:50:14,284][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.195280075073242, 'accuracy': 0.4894117647058824, 'num_samples': 425, 'test_unique_accuracy': 0.4837962962962963, 'test_unique_num_samples': 432} +[2026-04-16 00:50:14,476][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.4894117647058824 is not better than 0.5270588235294118 of logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep3000, skipping checkpoint +[2026-04-16 00:50:36,655][trainer.accelerators.base_accelerator][INFO] - Training progress: step=11050/100000 (11.05%), epoch=0, lr=1e-05, speed=2.006 step/s, elapsed=01:31:47, eta=12:18:57 +[2026-04-16 00:50:58,799][trainer.accelerators.base_accelerator][INFO] - Training progress: step=11100/100000 (11.10%), epoch=0, lr=1e-05, speed=2.007 step/s, elapsed=01:32:10, eta=12:18:10 +[2026-04-16 00:51:20,992][trainer.accelerators.base_accelerator][INFO] - Training progress: step=11150/100000 (11.15%), epoch=0, lr=1e-05, speed=2.008 step/s, elapsed=01:32:32, eta=12:17:23 +[2026-04-16 00:51:43,164][trainer.accelerators.base_accelerator][INFO] - Training progress: step=11200/100000 (11.20%), epoch=0, lr=1e-05, speed=2.009 step/s, elapsed=01:32:54, eta=12:16:37 +[2026-04-16 00:52:05,276][trainer.accelerators.base_accelerator][INFO] - Training progress: step=11250/100000 (11.25%), epoch=0, lr=1e-05, speed=2.010 step/s, elapsed=01:33:16, eta=12:15:50 +[2026-04-16 00:52:27,387][trainer.accelerators.base_accelerator][INFO] - Training progress: step=11300/100000 (11.30%), epoch=0, lr=1e-05, speed=2.011 step/s, elapsed=01:33:38, eta=12:15:03 +[2026-04-16 00:52:49,829][trainer.accelerators.base_accelerator][INFO] - Training progress: step=11350/100000 (11.35%), epoch=0, lr=1e-05, speed=2.012 step/s, elapsed=01:34:01, eta=12:14:20 +[2026-04-16 00:53:11,983][trainer.accelerators.base_accelerator][INFO] - Training progress: step=11400/100000 (11.40%), epoch=0, lr=1e-05, speed=2.013 step/s, elapsed=01:34:23, eta=12:13:34 +[2026-04-16 00:53:34,138][trainer.accelerators.base_accelerator][INFO] - Training progress: step=11450/100000 (11.45%), epoch=0, lr=1e-05, speed=2.014 step/s, elapsed=01:34:45, eta=12:12:48 +[2026-04-16 00:53:56,197][trainer.accelerators.base_accelerator][INFO] - Training progress: step=11500/100000 (11.50%), epoch=0, lr=1e-05, speed=2.015 step/s, elapsed=01:35:07, eta=12:12:02 +[2026-04-16 00:54:18,285][trainer.accelerators.base_accelerator][INFO] - Training progress: step=11550/100000 (11.55%), epoch=0, lr=1e-05, speed=2.016 step/s, elapsed=01:35:29, eta=12:11:16 +[2026-04-16 00:54:40,301][trainer.accelerators.base_accelerator][INFO] - Training progress: step=11600/100000 (11.60%), epoch=0, lr=1e-05, speed=2.017 step/s, elapsed=01:35:51, eta=12:10:30 +[2026-04-16 00:55:02,469][trainer.accelerators.base_accelerator][INFO] - Training progress: step=11650/100000 (11.65%), epoch=0, lr=1e-05, speed=2.018 step/s, elapsed=01:36:13, eta=12:09:46 +[2026-04-16 00:55:24,595][trainer.accelerators.base_accelerator][INFO] - Training progress: step=11700/100000 (11.70%), epoch=0, lr=1e-05, speed=2.019 step/s, elapsed=01:36:35, eta=12:09:01 +[2026-04-16 00:55:46,713][trainer.accelerators.base_accelerator][INFO] - Training progress: step=11750/100000 (11.75%), epoch=0, lr=1e-05, speed=2.020 step/s, elapsed=01:36:57, eta=12:08:16 +[2026-04-16 00:56:08,855][trainer.accelerators.base_accelerator][INFO] - Training progress: step=11800/100000 (11.80%), epoch=0, lr=1e-05, speed=2.021 step/s, elapsed=01:37:20, eta=12:07:32 +[2026-04-16 00:56:30,793][trainer.accelerators.base_accelerator][INFO] - Training progress: step=11850/100000 (11.85%), epoch=0, lr=1e-05, speed=2.021 step/s, elapsed=01:37:42, eta=12:06:46 +[2026-04-16 00:56:52,941][trainer.accelerators.base_accelerator][INFO] - Training progress: step=11900/100000 (11.90%), epoch=0, lr=1e-05, speed=2.022 step/s, elapsed=01:38:04, eta=12:06:02 +[2026-04-16 00:57:15,365][trainer.accelerators.base_accelerator][INFO] - Training progress: step=11950/100000 (11.95%), epoch=0, lr=1e-05, speed=2.023 step/s, elapsed=01:38:26, eta=12:05:21 +[2026-04-16 00:57:37,448][trainer.accelerators.base_accelerator][INFO] - Training progress: step=12000/100000 (12.00%), epoch=0, lr=1e-05, speed=2.024 step/s, elapsed=01:38:48, eta=12:04:37 +[2026-04-16 00:57:37,485][__main__][INFO] - ========== EVAL START (periodic@gstep=12000) ========== +[2026-04-16 00:57:37,485][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-16 00:57:37,485][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 00:57:52,777][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.195280075073242, 'accuracy': 0.47058823529411764, 'num_samples': 425, 'test_unique_accuracy': 0.4837962962962963, 'test_unique_num_samples': 432} +[2026-04-16 00:57:52,777][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-16 00:57:52,777][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 00:58:07,856][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.195280075073242, 'accuracy': 0.47058823529411764, 'num_samples': 425, 'test_unique_accuracy': 0.5092592592592593, 'test_unique_num_samples': 432} +[2026-04-16 00:58:07,856][__main__][INFO] - ========== EVAL END (periodic@gstep=12000) ========== +[2026-04-16 00:58:07,856][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.19540786743164, 'accuracy': 0.47058823529411764, 'num_samples': 425, 'test_unique_accuracy': 0.5092592592592593, 'test_unique_num_samples': 432} +[2026-04-16 00:58:07,859][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.47058823529411764 is not better than 0.5270588235294118 of logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep3000, skipping checkpoint +[2026-04-16 00:58:29,974][trainer.accelerators.base_accelerator][INFO] - Training progress: step=12050/100000 (12.05%), epoch=0, lr=1e-05, speed=2.015 step/s, elapsed=01:39:41, eta=12:07:35 +[2026-04-16 00:58:52,100][trainer.accelerators.base_accelerator][INFO] - Training progress: step=12100/100000 (12.10%), epoch=0, lr=1e-05, speed=2.016 step/s, elapsed=01:40:03, eta=12:06:51 +[2026-04-16 00:59:14,288][trainer.accelerators.base_accelerator][INFO] - Training progress: step=12150/100000 (12.15%), epoch=0, lr=1e-05, speed=2.016 step/s, elapsed=01:40:25, eta=12:06:07 +[2026-04-16 00:59:36,218][trainer.accelerators.base_accelerator][INFO] - Training progress: step=12200/100000 (12.20%), epoch=0, lr=1e-05, speed=2.017 step/s, elapsed=01:40:47, eta=12:05:21 +[2026-04-16 00:59:58,628][trainer.accelerators.base_accelerator][INFO] - Training progress: step=12250/100000 (12.25%), epoch=0, lr=1e-05, speed=2.018 step/s, elapsed=01:41:09, eta=12:04:40 +[2026-04-16 01:00:20,631][trainer.accelerators.base_accelerator][INFO] - Training progress: step=12300/100000 (12.30%), epoch=0, lr=1e-05, speed=2.019 step/s, elapsed=01:41:31, eta=12:03:55 +[2026-04-16 01:00:42,761][trainer.accelerators.base_accelerator][INFO] - Training progress: step=12350/100000 (12.35%), epoch=0, lr=1e-05, speed=2.020 step/s, elapsed=01:41:54, eta=12:03:12 +[2026-04-16 01:01:04,848][trainer.accelerators.base_accelerator][INFO] - Training progress: step=12400/100000 (12.40%), epoch=0, lr=1e-05, speed=2.021 step/s, elapsed=01:42:16, eta=12:02:28 +[2026-04-16 01:01:26,965][trainer.accelerators.base_accelerator][INFO] - Training progress: step=12450/100000 (12.45%), epoch=0, lr=1e-05, speed=2.022 step/s, elapsed=01:42:38, eta=12:01:45 +[2026-04-16 01:01:49,303][trainer.accelerators.base_accelerator][INFO] - Training progress: step=12500/100000 (12.50%), epoch=0, lr=1e-05, speed=2.022 step/s, elapsed=01:43:00, eta=12:01:03 +[2026-04-16 01:02:11,372][trainer.accelerators.base_accelerator][INFO] - Training progress: step=12550/100000 (12.55%), epoch=0, lr=1e-05, speed=2.023 step/s, elapsed=01:43:22, eta=12:00:20 +[2026-04-16 01:02:33,465][trainer.accelerators.base_accelerator][INFO] - Training progress: step=12600/100000 (12.60%), epoch=0, lr=1e-05, speed=2.024 step/s, elapsed=01:43:44, eta=11:59:37 +[2026-04-16 01:02:55,565][trainer.accelerators.base_accelerator][INFO] - Training progress: step=12650/100000 (12.65%), epoch=0, lr=1e-05, speed=2.025 step/s, elapsed=01:44:06, eta=11:58:55 +[2026-04-16 01:03:17,674][trainer.accelerators.base_accelerator][INFO] - Training progress: step=12700/100000 (12.70%), epoch=0, lr=1e-05, speed=2.026 step/s, elapsed=01:44:28, eta=11:58:12 +[2026-04-16 01:03:40,030][trainer.accelerators.base_accelerator][INFO] - Training progress: step=12750/100000 (12.75%), epoch=0, lr=1e-05, speed=2.027 step/s, elapsed=01:44:51, eta=11:57:32 +[2026-04-16 01:04:02,137][trainer.accelerators.base_accelerator][INFO] - Training progress: step=12800/100000 (12.80%), epoch=0, lr=1e-05, speed=2.027 step/s, elapsed=01:45:13, eta=11:56:49 +[2026-04-16 01:04:24,192][trainer.accelerators.base_accelerator][INFO] - Training progress: step=12850/100000 (12.85%), epoch=0, lr=1e-05, speed=2.028 step/s, elapsed=01:45:35, eta=11:56:07 +[2026-04-16 01:04:46,278][trainer.accelerators.base_accelerator][INFO] - Training progress: step=12900/100000 (12.90%), epoch=0, lr=1e-05, speed=2.029 step/s, elapsed=01:45:57, eta=11:55:25 +[2026-04-16 01:05:08,452][trainer.accelerators.base_accelerator][INFO] - Training progress: step=12950/100000 (12.95%), epoch=0, lr=1e-05, speed=2.030 step/s, elapsed=01:46:19, eta=11:54:44 +[2026-04-16 01:05:30,768][trainer.accelerators.base_accelerator][INFO] - Training progress: step=13000/100000 (13.00%), epoch=0, lr=1e-05, speed=2.031 step/s, elapsed=01:46:42, eta=11:54:04 +[2026-04-16 01:05:30,810][__main__][INFO] - ========== EVAL START (periodic@gstep=13000) ========== +[2026-04-16 01:05:30,810][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-16 01:05:30,810][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 01:05:45,995][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.19540786743164, 'accuracy': 0.4611764705882353, 'num_samples': 425, 'test_unique_accuracy': 0.5092592592592593, 'test_unique_num_samples': 432} +[2026-04-16 01:05:45,996][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-16 01:05:45,996][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 01:06:01,095][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.19540786743164, 'accuracy': 0.4611764705882353, 'num_samples': 425, 'test_unique_accuracy': 0.5069444444444444, 'test_unique_num_samples': 432} +[2026-04-16 01:06:01,095][__main__][INFO] - ========== EVAL END (periodic@gstep=13000) ========== +[2026-04-16 01:06:01,095][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.187213897705078, 'accuracy': 0.4611764705882353, 'num_samples': 425, 'test_unique_accuracy': 0.5069444444444444, 'test_unique_num_samples': 432} +[2026-04-16 01:06:01,099][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.4611764705882353 is not better than 0.5270588235294118 of logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep3000, skipping checkpoint +[2026-04-16 01:06:23,162][trainer.accelerators.base_accelerator][INFO] - Training progress: step=13050/100000 (13.05%), epoch=0, lr=1e-05, speed=2.022 step/s, elapsed=01:47:34, eta=11:56:44 +[2026-04-16 01:06:45,239][trainer.accelerators.base_accelerator][INFO] - Training progress: step=13100/100000 (13.10%), epoch=0, lr=1e-05, speed=2.023 step/s, elapsed=01:47:56, eta=11:56:02 +[2026-04-16 01:07:07,323][trainer.accelerators.base_accelerator][INFO] - Training progress: step=13150/100000 (13.15%), epoch=0, lr=1e-05, speed=2.024 step/s, elapsed=01:48:18, eta=11:55:20 +[2026-04-16 01:07:29,463][trainer.accelerators.base_accelerator][INFO] - Training progress: step=13200/100000 (13.20%), epoch=0, lr=1e-05, speed=2.024 step/s, elapsed=01:48:40, eta=11:54:38 +[2026-04-16 01:07:51,909][trainer.accelerators.base_accelerator][INFO] - Training progress: step=13250/100000 (13.25%), epoch=0, lr=1e-05, speed=2.025 step/s, elapsed=01:49:03, eta=11:53:59 +[2026-04-16 01:08:13,981][trainer.accelerators.base_accelerator][INFO] - Training progress: step=13300/100000 (13.30%), epoch=0, lr=1e-05, speed=2.026 step/s, elapsed=01:49:25, eta=11:53:17 +[2026-04-16 01:08:36,077][trainer.accelerators.base_accelerator][INFO] - Training progress: step=13350/100000 (13.35%), epoch=0, lr=1e-05, speed=2.027 step/s, elapsed=01:49:47, eta=11:52:35 +[2026-04-16 01:08:58,252][trainer.accelerators.base_accelerator][INFO] - Training progress: step=13400/100000 (13.40%), epoch=0, lr=1e-05, speed=2.027 step/s, elapsed=01:50:09, eta=11:51:55 +[2026-04-16 01:09:20,371][trainer.accelerators.base_accelerator][INFO] - Training progress: step=13450/100000 (13.45%), epoch=0, lr=1e-05, speed=2.028 step/s, elapsed=01:50:31, eta=11:51:14 +[2026-04-16 01:09:42,748][trainer.accelerators.base_accelerator][INFO] - Training progress: step=13500/100000 (13.50%), epoch=0, lr=1e-05, speed=2.029 step/s, elapsed=01:50:53, eta=11:50:34 +[2026-04-16 01:10:04,927][trainer.accelerators.base_accelerator][INFO] - Training progress: step=13550/100000 (13.55%), epoch=0, lr=1e-05, speed=2.030 step/s, elapsed=01:51:16, eta=11:49:54 +[2026-04-16 01:10:27,001][trainer.accelerators.base_accelerator][INFO] - Training progress: step=13600/100000 (13.60%), epoch=0, lr=1e-05, speed=2.030 step/s, elapsed=01:51:38, eta=11:49:13 +[2026-04-16 01:10:49,097][trainer.accelerators.base_accelerator][INFO] - Training progress: step=13650/100000 (13.65%), epoch=0, lr=1e-05, speed=2.031 step/s, elapsed=01:52:00, eta=11:48:32 +[2026-04-16 01:11:11,150][trainer.accelerators.base_accelerator][INFO] - Training progress: step=13700/100000 (13.70%), epoch=0, lr=1e-05, speed=2.032 step/s, elapsed=01:52:22, eta=11:47:52 +[2026-04-16 01:11:33,283][trainer.accelerators.base_accelerator][INFO] - Training progress: step=13750/100000 (13.75%), epoch=0, lr=1e-05, speed=2.033 step/s, elapsed=01:52:44, eta=11:47:12 +[2026-04-16 01:11:55,642][trainer.accelerators.base_accelerator][INFO] - Training progress: step=13800/100000 (13.80%), epoch=0, lr=1e-05, speed=2.033 step/s, elapsed=01:53:06, eta=11:46:33 +[2026-04-16 01:12:17,699][trainer.accelerators.base_accelerator][INFO] - Training progress: step=13850/100000 (13.85%), epoch=0, lr=1e-05, speed=2.034 step/s, elapsed=01:53:28, eta=11:45:53 +[2026-04-16 01:12:39,716][trainer.accelerators.base_accelerator][INFO] - Training progress: step=13900/100000 (13.90%), epoch=0, lr=1e-05, speed=2.035 step/s, elapsed=01:53:50, eta=11:45:12 +[2026-04-16 01:13:01,853][trainer.accelerators.base_accelerator][INFO] - Training progress: step=13950/100000 (13.95%), epoch=0, lr=1e-05, speed=2.036 step/s, elapsed=01:54:13, eta=11:44:33 +[2026-04-16 01:13:23,818][trainer.accelerators.base_accelerator][INFO] - Training progress: step=14000/100000 (14.00%), epoch=0, lr=1e-05, speed=2.036 step/s, elapsed=01:54:35, eta=11:43:52 +[2026-04-16 01:13:23,850][__main__][INFO] - ========== EVAL START (periodic@gstep=14000) ========== +[2026-04-16 01:13:23,850][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-16 01:13:23,850][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 01:13:41,939][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.187213897705078, 'accuracy': 0.5058823529411764, 'num_samples': 425, 'test_unique_accuracy': 0.5069444444444444, 'test_unique_num_samples': 432} +[2026-04-16 01:13:41,939][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-16 01:13:41,939][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 01:13:57,389][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.187213897705078, 'accuracy': 0.5058823529411764, 'num_samples': 425, 'test_unique_accuracy': 0.5046296296296297, 'test_unique_num_samples': 432} +[2026-04-16 01:13:57,389][__main__][INFO] - ========== EVAL END (periodic@gstep=14000) ========== +[2026-04-16 01:13:57,389][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.187576293945312, 'accuracy': 0.5058823529411764, 'num_samples': 425, 'test_unique_accuracy': 0.5046296296296297, 'test_unique_num_samples': 432} +[2026-04-16 01:13:57,393][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.5058823529411764 is not better than 0.5270588235294118 of logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep3000, skipping checkpoint +[2026-04-16 01:14:19,445][trainer.accelerators.base_accelerator][INFO] - Training progress: step=14050/100000 (14.05%), epoch=0, lr=1e-05, speed=2.027 step/s, elapsed=01:55:30, eta=11:46:38 +[2026-04-16 01:14:41,531][trainer.accelerators.base_accelerator][INFO] - Training progress: step=14100/100000 (14.10%), epoch=0, lr=1e-05, speed=2.028 step/s, elapsed=01:55:52, eta=11:45:57 +[2026-04-16 01:15:03,608][trainer.accelerators.base_accelerator][INFO] - Training progress: step=14150/100000 (14.15%), epoch=0, lr=1e-05, speed=2.029 step/s, elapsed=01:56:14, eta=11:45:17 +[2026-04-16 01:15:25,742][trainer.accelerators.base_accelerator][INFO] - Training progress: step=14200/100000 (14.20%), epoch=0, lr=1e-05, speed=2.029 step/s, elapsed=01:56:36, eta=11:44:37 +[2026-04-16 01:15:47,855][trainer.accelerators.base_accelerator][INFO] - Training progress: step=14250/100000 (14.25%), epoch=0, lr=1e-05, speed=2.030 step/s, elapsed=01:56:59, eta=11:43:57 +[2026-04-16 01:16:10,027][trainer.accelerators.base_accelerator][INFO] - Training progress: step=14300/100000 (14.30%), epoch=0, lr=1e-05, speed=2.031 step/s, elapsed=01:57:21, eta=11:43:18 +[2026-04-16 01:16:32,069][trainer.accelerators.base_accelerator][INFO] - Training progress: step=14350/100000 (14.35%), epoch=0, lr=1e-05, speed=2.032 step/s, elapsed=01:57:43, eta=11:42:38 +[2026-04-16 01:16:54,171][trainer.accelerators.base_accelerator][INFO] - Training progress: step=14400/100000 (14.40%), epoch=0, lr=1e-05, speed=2.032 step/s, elapsed=01:58:05, eta=11:41:58 +[2026-04-16 01:17:16,297][trainer.accelerators.base_accelerator][INFO] - Training progress: step=14450/100000 (14.45%), epoch=0, lr=1e-05, speed=2.033 step/s, elapsed=01:58:27, eta=11:41:19 +[2026-04-16 01:17:38,382][trainer.accelerators.base_accelerator][INFO] - Training progress: step=14500/100000 (14.50%), epoch=0, lr=1e-05, speed=2.034 step/s, elapsed=01:58:49, eta=11:40:40 +[2026-04-16 01:18:00,428][trainer.accelerators.base_accelerator][INFO] - Training progress: step=14550/100000 (14.55%), epoch=0, lr=1e-05, speed=2.034 step/s, elapsed=01:59:11, eta=11:40:00 +[2026-04-16 01:18:22,558][trainer.accelerators.base_accelerator][INFO] - Training progress: step=14600/100000 (14.60%), epoch=0, lr=1e-05, speed=2.035 step/s, elapsed=01:59:33, eta=11:39:21 +[2026-04-16 01:18:44,949][trainer.accelerators.base_accelerator][INFO] - Training progress: step=14650/100000 (14.65%), epoch=0, lr=1e-05, speed=2.036 step/s, elapsed=01:59:56, eta=11:38:44 +[2026-04-16 01:19:07,088][trainer.accelerators.base_accelerator][INFO] - Training progress: step=14700/100000 (14.70%), epoch=0, lr=1e-05, speed=2.036 step/s, elapsed=02:00:18, eta=11:38:06 +[2026-04-16 01:19:29,153][trainer.accelerators.base_accelerator][INFO] - Training progress: step=14750/100000 (14.75%), epoch=0, lr=1e-05, speed=2.037 step/s, elapsed=02:00:40, eta=11:37:27 +[2026-04-16 01:19:51,155][trainer.accelerators.base_accelerator][INFO] - Training progress: step=14800/100000 (14.80%), epoch=0, lr=1e-05, speed=2.038 step/s, elapsed=02:01:02, eta=11:36:47 +[2026-04-16 01:20:13,298][trainer.accelerators.base_accelerator][INFO] - Training progress: step=14850/100000 (14.85%), epoch=0, lr=1e-05, speed=2.039 step/s, elapsed=02:01:24, eta=11:36:09 +[2026-04-16 01:20:35,305][trainer.accelerators.base_accelerator][INFO] - Training progress: step=14900/100000 (14.90%), epoch=0, lr=1e-05, speed=2.039 step/s, elapsed=02:01:46, eta=11:35:30 +[2026-04-16 01:20:57,304][trainer.accelerators.base_accelerator][INFO] - Training progress: step=14950/100000 (14.95%), epoch=0, lr=1e-05, speed=2.040 step/s, elapsed=02:02:08, eta=11:34:51 +[2026-04-16 01:21:19,430][trainer.accelerators.base_accelerator][INFO] - Training progress: step=15000/100000 (15.00%), epoch=0, lr=1e-05, speed=2.041 step/s, elapsed=02:02:30, eta=11:34:13 +[2026-04-16 01:21:19,469][__main__][INFO] - ========== EVAL START (periodic@gstep=15000) ========== +[2026-04-16 01:21:19,469][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-16 01:21:19,470][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 01:21:34,601][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.187576293945312, 'accuracy': 0.4611764705882353, 'num_samples': 425, 'test_unique_accuracy': 0.5046296296296297, 'test_unique_num_samples': 432} +[2026-04-16 01:21:34,601][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-16 01:21:34,601][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 01:21:49,710][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.187576293945312, 'accuracy': 0.4611764705882353, 'num_samples': 425, 'test_unique_accuracy': 0.5092592592592593, 'test_unique_num_samples': 432} +[2026-04-16 01:21:49,710][__main__][INFO] - ========== EVAL END (periodic@gstep=15000) ========== +[2026-04-16 01:21:49,711][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.190770149230957, 'accuracy': 0.4611764705882353, 'num_samples': 425, 'test_unique_accuracy': 0.5092592592592593, 'test_unique_num_samples': 432} +[2026-04-16 01:21:49,714][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.4611764705882353 is not better than 0.5270588235294118 of logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep3000, skipping checkpoint +[2026-04-16 01:22:11,777][trainer.accelerators.base_accelerator][INFO] - Training progress: step=15050/100000 (15.05%), epoch=0, lr=1e-05, speed=2.033 step/s, elapsed=02:03:23, eta=11:36:26 +[2026-04-16 01:22:33,833][trainer.accelerators.base_accelerator][INFO] - Training progress: step=15100/100000 (15.10%), epoch=0, lr=1e-05, speed=2.034 step/s, elapsed=02:03:45, eta=11:35:47 +[2026-04-16 01:22:56,302][trainer.accelerators.base_accelerator][INFO] - Training progress: step=15150/100000 (15.15%), epoch=0, lr=1e-05, speed=2.034 step/s, elapsed=02:04:07, eta=11:35:11 +[2026-04-16 01:23:18,328][trainer.accelerators.base_accelerator][INFO] - Training progress: step=15200/100000 (15.20%), epoch=0, lr=1e-05, speed=2.035 step/s, elapsed=02:04:29, eta=11:34:32 +[2026-04-16 01:23:40,455][trainer.accelerators.base_accelerator][INFO] - Training progress: step=15250/100000 (15.25%), epoch=0, lr=1e-05, speed=2.036 step/s, elapsed=02:04:51, eta=11:33:54 +[2026-04-16 01:24:02,574][trainer.accelerators.base_accelerator][INFO] - Training progress: step=15300/100000 (15.30%), epoch=0, lr=1e-05, speed=2.036 step/s, elapsed=02:05:13, eta=11:33:16 +[2026-04-16 01:24:24,645][trainer.accelerators.base_accelerator][INFO] - Training progress: step=15350/100000 (15.35%), epoch=0, lr=1e-05, speed=2.037 step/s, elapsed=02:05:35, eta=11:32:37 +[2026-04-16 01:24:46,690][trainer.accelerators.base_accelerator][INFO] - Training progress: step=15400/100000 (15.40%), epoch=0, lr=1e-05, speed=2.038 step/s, elapsed=02:05:57, eta=11:31:59 +[2026-04-16 01:25:08,848][trainer.accelerators.base_accelerator][INFO] - Training progress: step=15450/100000 (15.45%), epoch=0, lr=1e-05, speed=2.038 step/s, elapsed=02:06:20, eta=11:31:22 +[2026-04-16 01:25:30,996][trainer.accelerators.base_accelerator][INFO] - Training progress: step=15500/100000 (15.50%), epoch=0, lr=1e-05, speed=2.039 step/s, elapsed=02:06:42, eta=11:30:44 +[2026-04-16 01:25:53,150][trainer.accelerators.base_accelerator][INFO] - Training progress: step=15550/100000 (15.55%), epoch=0, lr=1e-05, speed=2.040 step/s, elapsed=02:07:04, eta=11:30:07 +[2026-04-16 01:26:15,283][trainer.accelerators.base_accelerator][INFO] - Training progress: step=15600/100000 (15.60%), epoch=0, lr=1e-05, speed=2.040 step/s, elapsed=02:07:26, eta=11:29:29 +[2026-04-16 01:26:37,747][trainer.accelerators.base_accelerator][INFO] - Training progress: step=15650/100000 (15.65%), epoch=0, lr=1e-05, speed=2.041 step/s, elapsed=02:07:48, eta=11:28:54 +[2026-04-16 01:26:59,858][trainer.accelerators.base_accelerator][INFO] - Training progress: step=15700/100000 (15.70%), epoch=0, lr=1e-05, speed=2.041 step/s, elapsed=02:08:11, eta=11:28:16 +[2026-04-16 01:27:21,965][trainer.accelerators.base_accelerator][INFO] - Training progress: step=15750/100000 (15.75%), epoch=0, lr=1e-05, speed=2.042 step/s, elapsed=02:08:33, eta=11:27:39 +[2026-04-16 01:27:44,035][trainer.accelerators.base_accelerator][INFO] - Training progress: step=15800/100000 (15.80%), epoch=0, lr=1e-05, speed=2.043 step/s, elapsed=02:08:55, eta=11:27:02 +[2026-04-16 01:28:06,157][trainer.accelerators.base_accelerator][INFO] - Training progress: step=15850/100000 (15.85%), epoch=0, lr=1e-05, speed=2.043 step/s, elapsed=02:09:17, eta=11:26:25 +[2026-04-16 01:28:28,285][trainer.accelerators.base_accelerator][INFO] - Training progress: step=15900/100000 (15.90%), epoch=0, lr=1e-05, speed=2.044 step/s, elapsed=02:09:39, eta=11:25:48 +[2026-04-16 01:28:50,353][trainer.accelerators.base_accelerator][INFO] - Training progress: step=15950/100000 (15.95%), epoch=0, lr=1e-05, speed=2.044 step/s, elapsed=02:10:01, eta=11:25:11 +[2026-04-16 01:29:12,475][trainer.accelerators.base_accelerator][INFO] - Training progress: step=16000/100000 (16.00%), epoch=0, lr=1e-05, speed=2.045 step/s, elapsed=02:10:23, eta=11:24:34 +[2026-04-16 01:29:12,514][__main__][INFO] - ========== EVAL START (periodic@gstep=16000) ========== +[2026-04-16 01:29:12,515][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-16 01:29:12,515][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 01:29:27,623][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.190770149230957, 'accuracy': 0.5152941176470588, 'num_samples': 425, 'test_unique_accuracy': 0.5092592592592593, 'test_unique_num_samples': 432} +[2026-04-16 01:29:27,624][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-16 01:29:27,624][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 01:29:42,730][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.190770149230957, 'accuracy': 0.5152941176470588, 'num_samples': 425, 'test_unique_accuracy': 0.4930555555555556, 'test_unique_num_samples': 432} +[2026-04-16 01:29:42,730][__main__][INFO] - ========== EVAL END (periodic@gstep=16000) ========== +[2026-04-16 01:29:42,730][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.185104370117188, 'accuracy': 0.5152941176470588, 'num_samples': 425, 'test_unique_accuracy': 0.4930555555555556, 'test_unique_num_samples': 432} +[2026-04-16 01:29:42,733][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.5152941176470588 is not better than 0.5270588235294118 of logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep3000, skipping checkpoint +[2026-04-16 01:30:04,794][trainer.accelerators.base_accelerator][INFO] - Training progress: step=16050/100000 (16.05%), epoch=0, lr=1e-05, speed=2.038 step/s, elapsed=02:11:16, eta=11:26:35 +[2026-04-16 01:30:27,342][trainer.accelerators.base_accelerator][INFO] - Training progress: step=16100/100000 (16.10%), epoch=0, lr=1e-05, speed=2.038 step/s, elapsed=02:11:38, eta=11:26:00 +[2026-04-16 01:30:49,507][trainer.accelerators.base_accelerator][INFO] - Training progress: step=16150/100000 (16.15%), epoch=0, lr=1e-05, speed=2.039 step/s, elapsed=02:12:00, eta=11:25:24 +[2026-04-16 01:31:11,628][trainer.accelerators.base_accelerator][INFO] - Training progress: step=16200/100000 (16.20%), epoch=0, lr=1e-05, speed=2.040 step/s, elapsed=02:12:22, eta=11:24:47 +[2026-04-16 01:31:33,913][trainer.accelerators.base_accelerator][INFO] - Training progress: step=16250/100000 (16.25%), epoch=0, lr=1e-05, speed=2.040 step/s, elapsed=02:12:45, eta=11:24:11 +[2026-04-16 01:31:56,128][trainer.accelerators.base_accelerator][INFO] - Training progress: step=16300/100000 (16.30%), epoch=0, lr=1e-05, speed=2.041 step/s, elapsed=02:13:07, eta=11:23:34 +[2026-04-16 01:32:18,265][trainer.accelerators.base_accelerator][INFO] - Training progress: step=16350/100000 (16.35%), epoch=0, lr=1e-05, speed=2.041 step/s, elapsed=02:13:29, eta=11:22:58 +[2026-04-16 01:32:40,478][trainer.accelerators.base_accelerator][INFO] - Training progress: step=16400/100000 (16.40%), epoch=0, lr=1e-05, speed=2.042 step/s, elapsed=02:13:51, eta=11:22:22 +[2026-04-16 01:33:02,590][trainer.accelerators.base_accelerator][INFO] - Training progress: step=16450/100000 (16.45%), epoch=0, lr=1e-05, speed=2.043 step/s, elapsed=02:14:13, eta=11:21:45 +[2026-04-16 01:33:24,784][trainer.accelerators.base_accelerator][INFO] - Training progress: step=16500/100000 (16.50%), epoch=0, lr=1e-05, speed=2.043 step/s, elapsed=02:14:36, eta=11:21:09 +[2026-04-16 01:33:47,074][trainer.accelerators.base_accelerator][INFO] - Training progress: step=16550/100000 (16.55%), epoch=0, lr=1e-05, speed=2.044 step/s, elapsed=02:14:58, eta=11:20:34 +[2026-04-16 01:34:09,222][trainer.accelerators.base_accelerator][INFO] - Training progress: step=16600/100000 (16.60%), epoch=0, lr=1e-05, speed=2.044 step/s, elapsed=02:15:20, eta=11:19:58 +[2026-04-16 01:34:31,306][trainer.accelerators.base_accelerator][INFO] - Training progress: step=16650/100000 (16.65%), epoch=0, lr=1e-05, speed=2.045 step/s, elapsed=02:15:42, eta=11:19:21 +[2026-04-16 01:34:53,828][trainer.accelerators.base_accelerator][INFO] - Training progress: step=16700/100000 (16.70%), epoch=0, lr=1e-05, speed=2.045 step/s, elapsed=02:16:05, eta=11:18:47 +[2026-04-16 01:35:15,990][trainer.accelerators.base_accelerator][INFO] - Training progress: step=16750/100000 (16.75%), epoch=0, lr=1e-05, speed=2.046 step/s, elapsed=02:16:27, eta=11:18:11 +[2026-04-16 01:35:38,178][trainer.accelerators.base_accelerator][INFO] - Training progress: step=16800/100000 (16.80%), epoch=0, lr=1e-05, speed=2.046 step/s, elapsed=02:16:49, eta=11:17:36 +[2026-04-16 01:36:00,240][trainer.accelerators.base_accelerator][INFO] - Training progress: step=16850/100000 (16.85%), epoch=0, lr=1e-05, speed=2.047 step/s, elapsed=02:17:11, eta=11:17:00 +[2026-04-16 01:36:22,313][trainer.accelerators.base_accelerator][INFO] - Training progress: step=16900/100000 (16.90%), epoch=0, lr=1e-05, speed=2.048 step/s, elapsed=02:17:33, eta=11:16:24 +[2026-04-16 01:36:44,358][trainer.accelerators.base_accelerator][INFO] - Training progress: step=16950/100000 (16.95%), epoch=0, lr=1e-05, speed=2.048 step/s, elapsed=02:17:55, eta=11:15:48 +[2026-04-16 01:37:06,367][trainer.accelerators.base_accelerator][INFO] - Training progress: step=17000/100000 (17.00%), epoch=0, lr=1e-05, speed=2.049 step/s, elapsed=02:18:17, eta=11:15:11 +[2026-04-16 01:37:06,406][__main__][INFO] - ========== EVAL START (periodic@gstep=17000) ========== +[2026-04-16 01:37:06,406][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-16 01:37:06,406][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 01:37:21,870][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.185104370117188, 'accuracy': 0.5105882352941177, 'num_samples': 425, 'test_unique_accuracy': 0.4930555555555556, 'test_unique_num_samples': 432} +[2026-04-16 01:37:21,871][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-16 01:37:21,871][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 01:37:36,991][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.185104370117188, 'accuracy': 0.5105882352941177, 'num_samples': 425, 'test_unique_accuracy': 0.5046296296296297, 'test_unique_num_samples': 432} +[2026-04-16 01:37:36,991][__main__][INFO] - ========== EVAL END (periodic@gstep=17000) ========== +[2026-04-16 01:37:36,992][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.188353538513184, 'accuracy': 0.5105882352941177, 'num_samples': 425, 'test_unique_accuracy': 0.5046296296296297, 'test_unique_num_samples': 432} +[2026-04-16 01:37:36,996][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.5105882352941177 is not better than 0.5270588235294118 of logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep3000, skipping checkpoint +[2026-04-16 01:37:59,133][trainer.accelerators.base_accelerator][INFO] - Training progress: step=17050/100000 (17.05%), epoch=0, lr=1e-05, speed=2.042 step/s, elapsed=02:19:10, eta=11:17:05 +[2026-04-16 01:38:21,226][trainer.accelerators.base_accelerator][INFO] - Training progress: step=17100/100000 (17.10%), epoch=0, lr=1e-05, speed=2.042 step/s, elapsed=02:19:32, eta=11:16:29 +[2026-04-16 01:38:43,306][trainer.accelerators.base_accelerator][INFO] - Training progress: step=17150/100000 (17.15%), epoch=0, lr=1e-05, speed=2.043 step/s, elapsed=02:19:54, eta=11:15:53 +[2026-04-16 01:39:05,489][trainer.accelerators.base_accelerator][INFO] - Training progress: step=17200/100000 (17.20%), epoch=0, lr=1e-05, speed=2.044 step/s, elapsed=02:20:16, eta=11:15:17 +[2026-04-16 01:39:28,004][trainer.accelerators.base_accelerator][INFO] - Training progress: step=17250/100000 (17.25%), epoch=0, lr=1e-05, speed=2.044 step/s, elapsed=02:20:39, eta=11:14:43 +[2026-04-16 01:39:50,077][trainer.accelerators.base_accelerator][INFO] - Training progress: step=17300/100000 (17.30%), epoch=0, lr=1e-05, speed=2.045 step/s, elapsed=02:21:01, eta=11:14:08 +[2026-04-16 01:40:12,106][trainer.accelerators.base_accelerator][INFO] - Training progress: step=17350/100000 (17.35%), epoch=0, lr=1e-05, speed=2.045 step/s, elapsed=02:21:23, eta=11:13:32 +[2026-04-16 01:40:34,267][trainer.accelerators.base_accelerator][INFO] - Training progress: step=17400/100000 (17.40%), epoch=0, lr=1e-05, speed=2.046 step/s, elapsed=02:21:45, eta=11:12:56 +[2026-04-16 01:40:56,323][trainer.accelerators.base_accelerator][INFO] - Training progress: step=17450/100000 (17.45%), epoch=0, lr=1e-05, speed=2.046 step/s, elapsed=02:22:07, eta=11:12:21 +[2026-04-16 01:41:18,368][trainer.accelerators.base_accelerator][INFO] - Training progress: step=17500/100000 (17.50%), epoch=0, lr=1e-05, speed=2.047 step/s, elapsed=02:22:29, eta=11:11:45 +[2026-04-16 01:41:40,483][trainer.accelerators.base_accelerator][INFO] - Training progress: step=17550/100000 (17.55%), epoch=0, lr=1e-05, speed=2.047 step/s, elapsed=02:22:51, eta=11:11:10 +[2026-04-16 01:42:02,558][trainer.accelerators.base_accelerator][INFO] - Training progress: step=17600/100000 (17.60%), epoch=0, lr=1e-05, speed=2.048 step/s, elapsed=02:23:13, eta=11:10:34 +[2026-04-16 01:42:24,746][trainer.accelerators.base_accelerator][INFO] - Training progress: step=17650/100000 (17.65%), epoch=0, lr=1e-05, speed=2.049 step/s, elapsed=02:23:35, eta=11:09:59 +[2026-04-16 01:42:47,098][trainer.accelerators.base_accelerator][INFO] - Training progress: step=17700/100000 (17.70%), epoch=0, lr=1e-05, speed=2.049 step/s, elapsed=02:23:58, eta=11:09:25 +[2026-04-16 01:43:09,168][trainer.accelerators.base_accelerator][INFO] - Training progress: step=17750/100000 (17.75%), epoch=0, lr=1e-05, speed=2.050 step/s, elapsed=02:24:20, eta=11:08:50 +[2026-04-16 01:43:31,199][trainer.accelerators.base_accelerator][INFO] - Training progress: step=17800/100000 (17.80%), epoch=0, lr=1e-05, speed=2.050 step/s, elapsed=02:24:42, eta=11:08:15 +[2026-04-16 01:43:53,301][trainer.accelerators.base_accelerator][INFO] - Training progress: step=17850/100000 (17.85%), epoch=0, lr=1e-05, speed=2.051 step/s, elapsed=02:25:04, eta=11:07:40 +[2026-04-16 01:44:15,368][trainer.accelerators.base_accelerator][INFO] - Training progress: step=17900/100000 (17.90%), epoch=0, lr=1e-05, speed=2.051 step/s, elapsed=02:25:26, eta=11:07:05 +[2026-04-16 01:44:37,576][trainer.accelerators.base_accelerator][INFO] - Training progress: step=17950/100000 (17.95%), epoch=0, lr=1e-05, speed=2.052 step/s, elapsed=02:25:48, eta=11:06:31 +[2026-04-16 01:44:59,652][trainer.accelerators.base_accelerator][INFO] - Training progress: step=18000/100000 (18.00%), epoch=0, lr=1e-05, speed=2.052 step/s, elapsed=02:26:10, eta=11:05:56 +[2026-04-16 01:44:59,690][__main__][INFO] - ========== EVAL START (periodic@gstep=18000) ========== +[2026-04-16 01:44:59,690][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-16 01:44:59,691][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 01:45:15,988][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.188353538513184, 'accuracy': 0.4988235294117647, 'num_samples': 425, 'test_unique_accuracy': 0.5046296296296297, 'test_unique_num_samples': 432} +[2026-04-16 01:45:15,989][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-16 01:45:15,989][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 01:45:31,127][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.188353538513184, 'accuracy': 0.4988235294117647, 'num_samples': 425, 'test_unique_accuracy': 0.4930555555555556, 'test_unique_num_samples': 432} +[2026-04-16 01:45:31,127][__main__][INFO] - ========== EVAL END (periodic@gstep=18000) ========== +[2026-04-16 01:45:31,127][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.191081047058105, 'accuracy': 0.4988235294117647, 'num_samples': 425, 'test_unique_accuracy': 0.4930555555555556, 'test_unique_num_samples': 432} +[2026-04-16 01:45:31,131][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.4988235294117647 is not better than 0.5270588235294118 of logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep3000, skipping checkpoint +[2026-04-16 01:45:53,197][trainer.accelerators.base_accelerator][INFO] - Training progress: step=18050/100000 (18.05%), epoch=0, lr=1e-05, speed=2.045 step/s, elapsed=02:27:04, eta=11:07:44 +[2026-04-16 01:46:15,301][trainer.accelerators.base_accelerator][INFO] - Training progress: step=18100/100000 (18.10%), epoch=0, lr=1e-05, speed=2.046 step/s, elapsed=02:27:26, eta=11:07:09 +[2026-04-16 01:46:37,373][trainer.accelerators.base_accelerator][INFO] - Training progress: step=18150/100000 (18.15%), epoch=0, lr=1e-05, speed=2.047 step/s, elapsed=02:27:48, eta=11:06:34 +[2026-04-16 01:46:59,757][trainer.accelerators.base_accelerator][INFO] - Training progress: step=18200/100000 (18.20%), epoch=0, lr=1e-05, speed=2.047 step/s, elapsed=02:28:11, eta=11:06:00 +[2026-04-16 01:47:21,815][trainer.accelerators.base_accelerator][INFO] - Training progress: step=18250/100000 (18.25%), epoch=0, lr=1e-05, speed=2.048 step/s, elapsed=02:28:33, eta=11:05:25 +[2026-04-16 01:47:43,989][trainer.accelerators.base_accelerator][INFO] - Training progress: step=18300/100000 (18.30%), epoch=0, lr=1e-05, speed=2.048 step/s, elapsed=02:28:55, eta=11:04:51 +[2026-04-16 01:48:06,170][trainer.accelerators.base_accelerator][INFO] - Training progress: step=18350/100000 (18.35%), epoch=0, lr=1e-05, speed=2.049 step/s, elapsed=02:29:17, eta=11:04:16 +[2026-04-16 01:48:28,225][trainer.accelerators.base_accelerator][INFO] - Training progress: step=18400/100000 (18.40%), epoch=0, lr=1e-05, speed=2.049 step/s, elapsed=02:29:39, eta=11:03:42 +[2026-04-16 01:48:50,341][trainer.accelerators.base_accelerator][INFO] - Training progress: step=18450/100000 (18.45%), epoch=0, lr=1e-05, speed=2.050 step/s, elapsed=02:30:01, eta=11:03:07 +[2026-04-16 01:49:12,333][trainer.accelerators.base_accelerator][INFO] - Training progress: step=18500/100000 (18.50%), epoch=0, lr=1e-05, speed=2.050 step/s, elapsed=02:30:23, eta=11:02:32 +[2026-04-16 01:49:34,464][trainer.accelerators.base_accelerator][INFO] - Training progress: step=18550/100000 (18.55%), epoch=0, lr=1e-05, speed=2.051 step/s, elapsed=02:30:45, eta=11:01:58 +[2026-04-16 01:49:56,502][trainer.accelerators.base_accelerator][INFO] - Training progress: step=18600/100000 (18.60%), epoch=0, lr=1e-05, speed=2.051 step/s, elapsed=02:31:07, eta=11:01:23 +[2026-04-16 01:50:18,502][trainer.accelerators.base_accelerator][INFO] - Training progress: step=18650/100000 (18.65%), epoch=0, lr=1e-05, speed=2.052 step/s, elapsed=02:31:29, eta=11:00:48 +[2026-04-16 01:50:40,648][trainer.accelerators.base_accelerator][INFO] - Training progress: step=18700/100000 (18.70%), epoch=0, lr=1e-05, speed=2.052 step/s, elapsed=02:31:51, eta=11:00:14 +[2026-04-16 01:51:02,779][trainer.accelerators.base_accelerator][INFO] - Training progress: step=18750/100000 (18.75%), epoch=0, lr=1e-05, speed=2.053 step/s, elapsed=02:32:14, eta=10:59:40 +[2026-04-16 01:51:25,195][trainer.accelerators.base_accelerator][INFO] - Training progress: step=18800/100000 (18.80%), epoch=0, lr=1e-05, speed=2.053 step/s, elapsed=02:32:36, eta=10:59:08 +[2026-04-16 01:51:47,334][trainer.accelerators.base_accelerator][INFO] - Training progress: step=18850/100000 (18.85%), epoch=0, lr=1e-05, speed=2.054 step/s, elapsed=02:32:58, eta=10:58:34 +[2026-04-16 01:52:09,474][trainer.accelerators.base_accelerator][INFO] - Training progress: step=18900/100000 (18.90%), epoch=0, lr=1e-05, speed=2.054 step/s, elapsed=02:33:20, eta=10:58:00 +[2026-04-16 01:52:31,562][trainer.accelerators.base_accelerator][INFO] - Training progress: step=18950/100000 (18.95%), epoch=0, lr=1e-05, speed=2.055 step/s, elapsed=02:33:42, eta=10:57:26 +[2026-04-16 01:52:53,598][trainer.accelerators.base_accelerator][INFO] - Training progress: step=19000/100000 (19.00%), epoch=0, lr=1e-05, speed=2.055 step/s, elapsed=02:34:04, eta=10:56:52 +[2026-04-16 01:52:53,637][__main__][INFO] - ========== EVAL START (periodic@gstep=19000) ========== +[2026-04-16 01:52:53,637][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-16 01:52:53,637][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 01:53:08,767][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.191081047058105, 'accuracy': 0.4752941176470588, 'num_samples': 425, 'test_unique_accuracy': 0.4930555555555556, 'test_unique_num_samples': 432} +[2026-04-16 01:53:08,768][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-16 01:53:08,768][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 01:53:23,900][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.191081047058105, 'accuracy': 0.4752941176470588, 'num_samples': 425, 'test_unique_accuracy': 0.4652777777777778, 'test_unique_num_samples': 432} +[2026-04-16 01:53:23,900][__main__][INFO] - ========== EVAL END (periodic@gstep=19000) ========== +[2026-04-16 01:53:23,900][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.19131088256836, 'accuracy': 0.4752941176470588, 'num_samples': 425, 'test_unique_accuracy': 0.4652777777777778, 'test_unique_num_samples': 432} +[2026-04-16 01:53:23,904][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.4752941176470588 is not better than 0.5270588235294118 of logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep3000, skipping checkpoint +[2026-04-16 01:53:46,038][trainer.accelerators.base_accelerator][INFO] - Training progress: step=19050/100000 (19.05%), epoch=0, lr=1e-05, speed=2.049 step/s, elapsed=02:34:57, eta=10:58:27 +[2026-04-16 01:54:08,182][trainer.accelerators.base_accelerator][INFO] - Training progress: step=19100/100000 (19.10%), epoch=0, lr=1e-05, speed=2.049 step/s, elapsed=02:35:19, eta=10:57:53 +[2026-04-16 01:54:30,277][trainer.accelerators.base_accelerator][INFO] - Training progress: step=19150/100000 (19.15%), epoch=0, lr=1e-05, speed=2.050 step/s, elapsed=02:35:41, eta=10:57:19 +[2026-04-16 01:54:52,716][trainer.accelerators.base_accelerator][INFO] - Training progress: step=19200/100000 (19.20%), epoch=0, lr=1e-05, speed=2.050 step/s, elapsed=02:36:03, eta=10:56:46 +[2026-04-16 01:55:14,906][trainer.accelerators.base_accelerator][INFO] - Training progress: step=19250/100000 (19.25%), epoch=0, lr=1e-05, speed=2.051 step/s, elapsed=02:36:26, eta=10:56:13 +[2026-04-16 01:55:36,946][trainer.accelerators.base_accelerator][INFO] - Training progress: step=19300/100000 (19.30%), epoch=0, lr=1e-05, speed=2.051 step/s, elapsed=02:36:48, eta=10:55:38 +[2026-04-16 01:55:59,026][trainer.accelerators.base_accelerator][INFO] - Training progress: step=19350/100000 (19.35%), epoch=0, lr=1e-05, speed=2.052 step/s, elapsed=02:37:10, eta=10:55:05 +[2026-04-16 01:56:21,111][trainer.accelerators.base_accelerator][INFO] - Training progress: step=19400/100000 (19.40%), epoch=0, lr=1e-05, speed=2.052 step/s, elapsed=02:37:32, eta=10:54:31 +[2026-04-16 01:56:43,515][trainer.accelerators.base_accelerator][INFO] - Training progress: step=19450/100000 (19.45%), epoch=0, lr=1e-05, speed=2.053 step/s, elapsed=02:37:54, eta=10:53:58 +[2026-04-16 01:57:05,647][trainer.accelerators.base_accelerator][INFO] - Training progress: step=19500/100000 (19.50%), epoch=0, lr=1e-05, speed=2.053 step/s, elapsed=02:38:16, eta=10:53:25 +[2026-04-16 01:57:27,828][trainer.accelerators.base_accelerator][INFO] - Training progress: step=19550/100000 (19.55%), epoch=0, lr=1e-05, speed=2.054 step/s, elapsed=02:38:39, eta=10:52:51 +[2026-04-16 01:57:49,871][trainer.accelerators.base_accelerator][INFO] - Training progress: step=19600/100000 (19.60%), epoch=0, lr=1e-05, speed=2.054 step/s, elapsed=02:39:01, eta=10:52:18 +[2026-04-16 01:58:12,027][trainer.accelerators.base_accelerator][INFO] - Training progress: step=19650/100000 (19.65%), epoch=0, lr=1e-05, speed=2.055 step/s, elapsed=02:39:23, eta=10:51:44 +[2026-04-16 01:58:34,359][trainer.accelerators.base_accelerator][INFO] - Training progress: step=19700/100000 (19.70%), epoch=0, lr=1e-05, speed=2.055 step/s, elapsed=02:39:45, eta=10:51:12 +[2026-04-16 01:58:56,459][trainer.accelerators.base_accelerator][INFO] - Training progress: step=19750/100000 (19.75%), epoch=0, lr=1e-05, speed=2.056 step/s, elapsed=02:40:07, eta=10:50:38 +[2026-04-16 01:59:18,618][trainer.accelerators.base_accelerator][INFO] - Training progress: step=19800/100000 (19.80%), epoch=0, lr=1e-05, speed=2.056 step/s, elapsed=02:40:29, eta=10:50:05 +[2026-04-16 01:59:40,680][trainer.accelerators.base_accelerator][INFO] - Training progress: step=19850/100000 (19.85%), epoch=0, lr=1e-05, speed=2.057 step/s, elapsed=02:40:51, eta=10:49:32 +[2026-04-16 02:00:02,754][trainer.accelerators.base_accelerator][INFO] - Training progress: step=19900/100000 (19.90%), epoch=0, lr=1e-05, speed=2.057 step/s, elapsed=02:41:14, eta=10:48:59 +[2026-04-16 02:00:25,168][trainer.accelerators.base_accelerator][INFO] - Training progress: step=19950/100000 (19.95%), epoch=0, lr=1e-05, speed=2.057 step/s, elapsed=02:41:36, eta=10:48:27 +[2026-04-16 02:00:47,104][trainer.accelerators.base_accelerator][INFO] - Training progress: step=20000/100000 (20.00%), epoch=0, lr=1e-05, speed=2.058 step/s, elapsed=02:41:58, eta=10:47:53 +[2026-04-16 02:00:47,143][__main__][INFO] - ========== EVAL START (periodic@gstep=20000) ========== +[2026-04-16 02:00:47,143][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-16 02:00:47,143][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 02:01:02,292][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.19131088256836, 'accuracy': 0.48705882352941177, 'num_samples': 425, 'test_unique_accuracy': 0.4652777777777778, 'test_unique_num_samples': 432} +[2026-04-16 02:01:02,293][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-16 02:01:02,293][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 02:01:17,400][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.19131088256836, 'accuracy': 0.48705882352941177, 'num_samples': 425, 'test_unique_accuracy': 0.5069444444444444, 'test_unique_num_samples': 432} +[2026-04-16 02:01:17,400][__main__][INFO] - ========== EVAL END (periodic@gstep=20000) ========== +[2026-04-16 02:01:17,400][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.194451332092285, 'accuracy': 0.48705882352941177, 'num_samples': 425, 'test_unique_accuracy': 0.5069444444444444, 'test_unique_num_samples': 432} +[2026-04-16 02:01:17,403][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.48705882352941177 is not better than 0.5270588235294118 of logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep3000, skipping checkpoint +[2026-04-16 02:01:39,480][trainer.accelerators.base_accelerator][INFO] - Training progress: step=20050/100000 (20.05%), epoch=0, lr=1e-05, speed=2.052 step/s, elapsed=02:42:50, eta=10:49:21 +[2026-04-16 02:02:01,479][trainer.accelerators.base_accelerator][INFO] - Training progress: step=20100/100000 (20.10%), epoch=0, lr=1e-05, speed=2.053 step/s, elapsed=02:43:12, eta=10:48:47 +[2026-04-16 02:02:23,530][trainer.accelerators.base_accelerator][INFO] - Training progress: step=20150/100000 (20.15%), epoch=0, lr=1e-05, speed=2.053 step/s, elapsed=02:43:34, eta=10:48:13 +[2026-04-16 02:02:45,653][trainer.accelerators.base_accelerator][INFO] - Training progress: step=20200/100000 (20.20%), epoch=0, lr=1e-05, speed=2.053 step/s, elapsed=02:43:56, eta=10:47:40 +[2026-04-16 02:03:07,818][trainer.accelerators.base_accelerator][INFO] - Training progress: step=20250/100000 (20.25%), epoch=0, lr=1e-05, speed=2.054 step/s, elapsed=02:44:19, eta=10:47:07 +[2026-04-16 02:03:29,858][trainer.accelerators.base_accelerator][INFO] - Training progress: step=20300/100000 (20.30%), epoch=0, lr=1e-05, speed=2.054 step/s, elapsed=02:44:41, eta=10:46:34 +[2026-04-16 02:03:51,979][trainer.accelerators.base_accelerator][INFO] - Training progress: step=20350/100000 (20.35%), epoch=0, lr=1e-05, speed=2.055 step/s, elapsed=02:45:03, eta=10:46:01 +[2026-04-16 02:04:14,150][trainer.accelerators.base_accelerator][INFO] - Training progress: step=20400/100000 (20.40%), epoch=0, lr=1e-05, speed=2.055 step/s, elapsed=02:45:25, eta=10:45:28 +[2026-04-16 02:04:36,517][trainer.accelerators.base_accelerator][INFO] - Training progress: step=20450/100000 (20.45%), epoch=0, lr=1e-05, speed=2.056 step/s, elapsed=02:45:47, eta=10:44:56 +[2026-04-16 02:04:58,539][trainer.accelerators.base_accelerator][INFO] - Training progress: step=20500/100000 (20.50%), epoch=0, lr=1e-05, speed=2.056 step/s, elapsed=02:46:09, eta=10:44:23 +[2026-04-16 02:05:20,547][trainer.accelerators.base_accelerator][INFO] - Training progress: step=20550/100000 (20.55%), epoch=0, lr=1e-05, speed=2.057 step/s, elapsed=02:46:31, eta=10:43:50 +[2026-04-16 02:05:42,641][trainer.accelerators.base_accelerator][INFO] - Training progress: step=20600/100000 (20.60%), epoch=0, lr=1e-05, speed=2.057 step/s, elapsed=02:46:53, eta=10:43:17 +[2026-04-16 02:06:04,739][trainer.accelerators.base_accelerator][INFO] - Training progress: step=20650/100000 (20.65%), epoch=0, lr=1e-05, speed=2.058 step/s, elapsed=02:47:15, eta=10:42:44 +[2026-04-16 02:06:26,862][trainer.accelerators.base_accelerator][INFO] - Training progress: step=20700/100000 (20.70%), epoch=0, lr=1e-05, speed=2.058 step/s, elapsed=02:47:38, eta=10:42:11 +[2026-04-16 02:06:48,997][trainer.accelerators.base_accelerator][INFO] - Training progress: step=20750/100000 (20.75%), epoch=0, lr=1e-05, speed=2.058 step/s, elapsed=02:48:00, eta=10:41:39 +[2026-04-16 02:07:10,922][trainer.accelerators.base_accelerator][INFO] - Training progress: step=20800/100000 (20.80%), epoch=0, lr=1e-05, speed=2.059 step/s, elapsed=02:48:22, eta=10:41:05 +[2026-04-16 02:07:32,974][trainer.accelerators.base_accelerator][INFO] - Training progress: step=20850/100000 (20.85%), epoch=0, lr=1e-05, speed=2.059 step/s, elapsed=02:48:44, eta=10:40:33 +[2026-04-16 02:07:55,007][trainer.accelerators.base_accelerator][INFO] - Training progress: step=20900/100000 (20.90%), epoch=0, lr=1e-05, speed=2.060 step/s, elapsed=02:49:06, eta=10:40:00 +[2026-04-16 02:08:17,102][trainer.accelerators.base_accelerator][INFO] - Training progress: step=20950/100000 (20.95%), epoch=0, lr=1e-05, speed=2.060 step/s, elapsed=02:49:28, eta=10:39:27 +[2026-04-16 02:08:39,194][trainer.accelerators.base_accelerator][INFO] - Training progress: step=21000/100000 (21.00%), epoch=0, lr=1e-05, speed=2.061 step/s, elapsed=02:49:50, eta=10:38:55 +[2026-04-16 02:08:39,233][__main__][INFO] - ========== EVAL START (periodic@gstep=21000) ========== +[2026-04-16 02:08:39,233][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-16 02:08:39,233][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 02:08:54,614][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.194451332092285, 'accuracy': 0.5011764705882353, 'num_samples': 425, 'test_unique_accuracy': 0.5069444444444444, 'test_unique_num_samples': 432} +[2026-04-16 02:08:54,615][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-16 02:08:54,615][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 02:09:10,093][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.194451332092285, 'accuracy': 0.5011764705882353, 'num_samples': 425, 'test_unique_accuracy': 0.44907407407407407, 'test_unique_num_samples': 432} +[2026-04-16 02:09:10,093][__main__][INFO] - ========== EVAL END (periodic@gstep=21000) ========== +[2026-04-16 02:09:10,093][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.201745986938477, 'accuracy': 0.5011764705882353, 'num_samples': 425, 'test_unique_accuracy': 0.44907407407407407, 'test_unique_num_samples': 432} +[2026-04-16 02:09:10,098][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.5011764705882353 is not better than 0.5270588235294118 of logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep3000, skipping checkpoint +[2026-04-16 02:09:32,171][trainer.accelerators.base_accelerator][INFO] - Training progress: step=21050/100000 (21.05%), epoch=0, lr=1e-05, speed=2.055 step/s, elapsed=02:50:43, eta=10:40:18 +[2026-04-16 02:09:54,315][trainer.accelerators.base_accelerator][INFO] - Training progress: step=21100/100000 (21.10%), epoch=0, lr=1e-05, speed=2.055 step/s, elapsed=02:51:05, eta=10:39:46 +[2026-04-16 02:10:16,388][trainer.accelerators.base_accelerator][INFO] - Training progress: step=21150/100000 (21.15%), epoch=0, lr=1e-05, speed=2.056 step/s, elapsed=02:51:27, eta=10:39:13 +[2026-04-16 02:10:38,546][trainer.accelerators.base_accelerator][INFO] - Training progress: step=21200/100000 (21.20%), epoch=0, lr=1e-05, speed=2.056 step/s, elapsed=02:51:49, eta=10:38:41 +[2026-04-16 02:11:00,673][trainer.accelerators.base_accelerator][INFO] - Training progress: step=21250/100000 (21.25%), epoch=0, lr=1e-05, speed=2.057 step/s, elapsed=02:52:11, eta=10:38:08 +[2026-04-16 02:11:22,875][trainer.accelerators.base_accelerator][INFO] - Training progress: step=21300/100000 (21.30%), epoch=0, lr=1e-05, speed=2.057 step/s, elapsed=02:52:34, eta=10:37:36 +[2026-04-16 02:11:45,021][trainer.accelerators.base_accelerator][INFO] - Training progress: step=21350/100000 (21.35%), epoch=0, lr=1e-05, speed=2.058 step/s, elapsed=02:52:56, eta=10:37:04 +[2026-04-16 02:12:07,098][trainer.accelerators.base_accelerator][INFO] - Training progress: step=21400/100000 (21.40%), epoch=0, lr=1e-05, speed=2.058 step/s, elapsed=02:53:18, eta=10:36:32 +[2026-04-16 02:12:29,270][trainer.accelerators.base_accelerator][INFO] - Training progress: step=21450/100000 (21.45%), epoch=0, lr=1e-05, speed=2.058 step/s, elapsed=02:53:40, eta=10:35:59 +[2026-04-16 02:12:51,826][trainer.accelerators.base_accelerator][INFO] - Training progress: step=21500/100000 (21.50%), epoch=0, lr=1e-05, speed=2.059 step/s, elapsed=02:54:03, eta=10:35:29 +[2026-04-16 02:13:14,175][trainer.accelerators.base_accelerator][INFO] - Training progress: step=21550/100000 (21.55%), epoch=0, lr=1e-05, speed=2.059 step/s, elapsed=02:54:25, eta=10:34:58 +[2026-04-16 02:13:36,254][trainer.accelerators.base_accelerator][INFO] - Training progress: step=21600/100000 (21.60%), epoch=0, lr=1e-05, speed=2.060 step/s, elapsed=02:54:47, eta=10:34:25 +[2026-04-16 02:13:58,483][trainer.accelerators.base_accelerator][INFO] - Training progress: step=21650/100000 (21.65%), epoch=0, lr=1e-05, speed=2.060 step/s, elapsed=02:55:09, eta=10:33:54 +[2026-04-16 02:14:20,593][trainer.accelerators.base_accelerator][INFO] - Training progress: step=21700/100000 (21.70%), epoch=0, lr=1e-05, speed=2.060 step/s, elapsed=02:55:31, eta=10:33:22 +[2026-04-16 02:14:42,720][trainer.accelerators.base_accelerator][INFO] - Training progress: step=21750/100000 (21.75%), epoch=0, lr=1e-05, speed=2.061 step/s, elapsed=02:55:53, eta=10:32:50 +[2026-04-16 02:15:04,979][trainer.accelerators.base_accelerator][INFO] - Training progress: step=21800/100000 (21.80%), epoch=0, lr=1e-05, speed=2.061 step/s, elapsed=02:56:16, eta=10:32:18 +[2026-04-16 02:15:27,095][trainer.accelerators.base_accelerator][INFO] - Training progress: step=21850/100000 (21.85%), epoch=0, lr=1e-05, speed=2.062 step/s, elapsed=02:56:38, eta=10:31:46 +[2026-04-16 02:15:49,230][trainer.accelerators.base_accelerator][INFO] - Training progress: step=21900/100000 (21.90%), epoch=0, lr=1e-05, speed=2.062 step/s, elapsed=02:57:00, eta=10:31:14 +[2026-04-16 02:16:11,608][trainer.accelerators.base_accelerator][INFO] - Training progress: step=21950/100000 (21.95%), epoch=0, lr=1e-05, speed=2.062 step/s, elapsed=02:57:22, eta=10:30:43 +[2026-04-16 02:16:34,125][trainer.accelerators.base_accelerator][INFO] - Training progress: step=22000/100000 (22.00%), epoch=0, lr=1e-05, speed=2.063 step/s, elapsed=02:57:45, eta=10:30:13 +[2026-04-16 02:16:34,163][__main__][INFO] - ========== EVAL START (periodic@gstep=22000) ========== +[2026-04-16 02:16:34,164][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-16 02:16:34,164][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 02:16:50,691][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.201745986938477, 'accuracy': 0.4588235294117647, 'num_samples': 425, 'test_unique_accuracy': 0.44907407407407407, 'test_unique_num_samples': 432} +[2026-04-16 02:16:50,692][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-16 02:16:50,692][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 02:17:05,840][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.201745986938477, 'accuracy': 0.4588235294117647, 'num_samples': 425, 'test_unique_accuracy': 0.49537037037037035, 'test_unique_num_samples': 432} +[2026-04-16 02:17:05,840][__main__][INFO] - ========== EVAL END (periodic@gstep=22000) ========== +[2026-04-16 02:17:05,841][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.203364372253418, 'accuracy': 0.4588235294117647, 'num_samples': 425, 'test_unique_accuracy': 0.49537037037037035, 'test_unique_num_samples': 432} +[2026-04-16 02:17:05,845][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.4588235294117647 is not better than 0.5270588235294118 of logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep3000, skipping checkpoint +[2026-04-16 02:17:27,986][trainer.accelerators.base_accelerator][INFO] - Training progress: step=22050/100000 (22.05%), epoch=0, lr=1e-05, speed=2.057 step/s, elapsed=02:58:39, eta=10:31:34 +[2026-04-16 02:17:50,159][trainer.accelerators.base_accelerator][INFO] - Training progress: step=22100/100000 (22.10%), epoch=0, lr=1e-05, speed=2.057 step/s, elapsed=02:59:01, eta=10:31:02 +[2026-04-16 02:18:12,347][trainer.accelerators.base_accelerator][INFO] - Training progress: step=22150/100000 (22.15%), epoch=0, lr=1e-05, speed=2.058 step/s, elapsed=02:59:23, eta=10:30:30 +[2026-04-16 02:18:34,536][trainer.accelerators.base_accelerator][INFO] - Training progress: step=22200/100000 (22.20%), epoch=0, lr=1e-05, speed=2.058 step/s, elapsed=02:59:45, eta=10:29:58 +[2026-04-16 02:18:56,691][trainer.accelerators.base_accelerator][INFO] - Training progress: step=22250/100000 (22.25%), epoch=0, lr=1e-05, speed=2.059 step/s, elapsed=03:00:07, eta=10:29:27 +[2026-04-16 02:19:18,911][trainer.accelerators.base_accelerator][INFO] - Training progress: step=22300/100000 (22.30%), epoch=0, lr=1e-05, speed=2.059 step/s, elapsed=03:00:30, eta=10:28:55 +[2026-04-16 02:19:40,995][trainer.accelerators.base_accelerator][INFO] - Training progress: step=22350/100000 (22.35%), epoch=0, lr=1e-05, speed=2.059 step/s, elapsed=03:00:52, eta=10:28:23 +[2026-04-16 02:20:03,072][trainer.accelerators.base_accelerator][INFO] - Training progress: step=22400/100000 (22.40%), epoch=0, lr=1e-05, speed=2.060 step/s, elapsed=03:01:14, eta=10:27:51 +[2026-04-16 02:20:25,231][trainer.accelerators.base_accelerator][INFO] - Training progress: step=22450/100000 (22.45%), epoch=0, lr=1e-05, speed=2.060 step/s, elapsed=03:01:36, eta=10:27:20 +[2026-04-16 02:20:47,330][trainer.accelerators.base_accelerator][INFO] - Training progress: step=22500/100000 (22.50%), epoch=0, lr=1e-05, speed=2.061 step/s, elapsed=03:01:58, eta=10:26:48 +[2026-04-16 02:21:09,715][trainer.accelerators.base_accelerator][INFO] - Training progress: step=22550/100000 (22.55%), epoch=0, lr=1e-05, speed=2.061 step/s, elapsed=03:02:20, eta=10:26:17 +[2026-04-16 02:21:35,380][trainer.accelerators.base_accelerator][INFO] - Training progress: step=22600/100000 (22.60%), epoch=0, lr=1e-05, speed=2.061 step/s, elapsed=03:02:46, eta=10:25:58 +[2026-04-16 02:22:03,200][trainer.accelerators.base_accelerator][INFO] - Training progress: step=22650/100000 (22.65%), epoch=0, lr=1e-05, speed=2.060 step/s, elapsed=03:03:14, eta=10:25:46 +[2026-04-16 02:22:43,199][trainer.accelerators.base_accelerator][INFO] - Training progress: step=22700/100000 (22.70%), epoch=0, lr=1e-05, speed=2.057 step/s, elapsed=03:03:54, eta=10:26:15 +[2026-04-16 02:23:05,586][trainer.accelerators.base_accelerator][INFO] - Training progress: step=22750/100000 (22.75%), epoch=0, lr=1e-05, speed=2.058 step/s, elapsed=03:04:16, eta=10:25:44 +[2026-04-16 02:23:27,725][trainer.accelerators.base_accelerator][INFO] - Training progress: step=22800/100000 (22.80%), epoch=0, lr=1e-05, speed=2.058 step/s, elapsed=03:04:38, eta=10:25:13 +[2026-04-16 02:23:49,861][trainer.accelerators.base_accelerator][INFO] - Training progress: step=22850/100000 (22.85%), epoch=0, lr=1e-05, speed=2.058 step/s, elapsed=03:05:01, eta=10:24:41 +[2026-04-16 02:24:11,938][trainer.accelerators.base_accelerator][INFO] - Training progress: step=22900/100000 (22.90%), epoch=0, lr=1e-05, speed=2.059 step/s, elapsed=03:05:23, eta=10:24:09 +[2026-04-16 02:24:34,062][trainer.accelerators.base_accelerator][INFO] - Training progress: step=22950/100000 (22.95%), epoch=0, lr=1e-05, speed=2.059 step/s, elapsed=03:05:45, eta=10:23:38 +[2026-04-16 02:24:56,203][trainer.accelerators.base_accelerator][INFO] - Training progress: step=23000/100000 (23.00%), epoch=0, lr=1e-05, speed=2.060 step/s, elapsed=03:06:07, eta=10:23:06 +[2026-04-16 02:24:56,242][__main__][INFO] - ========== EVAL START (periodic@gstep=23000) ========== +[2026-04-16 02:24:56,243][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-16 02:24:56,243][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 02:25:12,104][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.203364372253418, 'accuracy': 0.5247058823529411, 'num_samples': 425, 'test_unique_accuracy': 0.49537037037037035, 'test_unique_num_samples': 432} +[2026-04-16 02:25:12,105][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-16 02:25:12,106][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 02:25:27,317][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.203364372253418, 'accuracy': 0.5247058823529411, 'num_samples': 425, 'test_unique_accuracy': 0.49537037037037035, 'test_unique_num_samples': 432} +[2026-04-16 02:25:27,317][__main__][INFO] - ========== EVAL END (periodic@gstep=23000) ========== +[2026-04-16 02:25:27,318][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.206304550170898, 'accuracy': 0.5247058823529411, 'num_samples': 425, 'test_unique_accuracy': 0.49537037037037035, 'test_unique_num_samples': 432} +[2026-04-16 02:25:27,365][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.5247058823529411 is not better than 0.5270588235294118 of logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep3000, skipping checkpoint +[2026-04-16 02:25:52,764][trainer.accelerators.base_accelerator][INFO] - Training progress: step=23050/100000 (23.05%), epoch=0, lr=1e-05, speed=2.054 step/s, elapsed=03:07:04, eta=10:24:30 +[2026-04-16 02:26:28,948][trainer.accelerators.base_accelerator][INFO] - Training progress: step=23100/100000 (23.10%), epoch=0, lr=1e-05, speed=2.051 step/s, elapsed=03:07:40, eta=10:24:45 +[2026-04-16 02:26:59,956][trainer.accelerators.base_accelerator][INFO] - Training progress: step=23150/100000 (23.15%), epoch=0, lr=1e-05, speed=2.050 step/s, elapsed=03:08:11, eta=10:24:42 +[2026-04-16 02:27:36,371][trainer.accelerators.base_accelerator][INFO] - Training progress: step=23200/100000 (23.20%), epoch=0, lr=1e-05, speed=2.048 step/s, elapsed=03:08:47, eta=10:24:58 +[2026-04-16 02:28:00,512][trainer.accelerators.base_accelerator][INFO] - Training progress: step=23250/100000 (23.25%), epoch=0, lr=1e-05, speed=2.048 step/s, elapsed=03:09:11, eta=10:24:33 +[2026-04-16 02:28:22,620][trainer.accelerators.base_accelerator][INFO] - Training progress: step=23300/100000 (23.30%), epoch=0, lr=1e-05, speed=2.049 step/s, elapsed=03:09:33, eta=10:24:01 +[2026-04-16 02:28:45,289][trainer.accelerators.base_accelerator][INFO] - Training progress: step=23350/100000 (23.35%), epoch=0, lr=1e-05, speed=2.049 step/s, elapsed=03:09:56, eta=10:23:30 +[2026-04-16 02:29:07,399][trainer.accelerators.base_accelerator][INFO] - Training progress: step=23400/100000 (23.40%), epoch=0, lr=1e-05, speed=2.049 step/s, elapsed=03:10:18, eta=10:22:59 +[2026-04-16 02:29:29,477][trainer.accelerators.base_accelerator][INFO] - Training progress: step=23450/100000 (23.45%), epoch=0, lr=1e-05, speed=2.050 step/s, elapsed=03:10:40, eta=10:22:27 +[2026-04-16 02:29:51,626][trainer.accelerators.base_accelerator][INFO] - Training progress: step=23500/100000 (23.50%), epoch=0, lr=1e-05, speed=2.050 step/s, elapsed=03:11:02, eta=10:21:55 +[2026-04-16 02:30:14,495][trainer.accelerators.base_accelerator][INFO] - Training progress: step=23550/100000 (23.55%), epoch=0, lr=1e-05, speed=2.050 step/s, elapsed=03:11:25, eta=10:21:26 +[2026-04-16 02:30:36,549][trainer.accelerators.base_accelerator][INFO] - Training progress: step=23600/100000 (23.60%), epoch=0, lr=1e-05, speed=2.051 step/s, elapsed=03:11:47, eta=10:20:54 +[2026-04-16 02:30:58,587][trainer.accelerators.base_accelerator][INFO] - Training progress: step=23650/100000 (23.65%), epoch=0, lr=1e-05, speed=2.051 step/s, elapsed=03:12:09, eta=10:20:22 +[2026-04-16 02:31:20,667][trainer.accelerators.base_accelerator][INFO] - Training progress: step=23700/100000 (23.70%), epoch=0, lr=1e-05, speed=2.052 step/s, elapsed=03:12:31, eta=10:19:50 +[2026-04-16 02:31:42,811][trainer.accelerators.base_accelerator][INFO] - Training progress: step=23750/100000 (23.75%), epoch=0, lr=1e-05, speed=2.052 step/s, elapsed=03:12:54, eta=10:19:18 +[2026-04-16 02:32:04,855][trainer.accelerators.base_accelerator][INFO] - Training progress: step=23800/100000 (23.80%), epoch=0, lr=1e-05, speed=2.052 step/s, elapsed=03:13:16, eta=10:18:47 +[2026-04-16 02:32:26,991][trainer.accelerators.base_accelerator][INFO] - Training progress: step=23850/100000 (23.85%), epoch=0, lr=1e-05, speed=2.053 step/s, elapsed=03:13:38, eta=10:18:15 +[2026-04-16 02:32:49,064][trainer.accelerators.base_accelerator][INFO] - Training progress: step=23900/100000 (23.90%), epoch=0, lr=1e-05, speed=2.053 step/s, elapsed=03:14:00, eta=10:17:43 +[2026-04-16 02:33:11,145][trainer.accelerators.base_accelerator][INFO] - Training progress: step=23950/100000 (23.95%), epoch=0, lr=1e-05, speed=2.054 step/s, elapsed=03:14:22, eta=10:17:12 +[2026-04-16 02:33:33,175][trainer.accelerators.base_accelerator][INFO] - Training progress: step=24000/100000 (24.00%), epoch=0, lr=1e-05, speed=2.054 step/s, elapsed=03:14:44, eta=10:16:40 +[2026-04-16 02:33:33,213][__main__][INFO] - ========== EVAL START (periodic@gstep=24000) ========== +[2026-04-16 02:33:33,213][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-16 02:33:33,213][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 02:33:49,243][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.206304550170898, 'accuracy': 0.4470588235294118, 'num_samples': 425, 'test_unique_accuracy': 0.49537037037037035, 'test_unique_num_samples': 432} +[2026-04-16 02:33:49,243][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-16 02:33:49,244][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 02:34:04,833][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.206304550170898, 'accuracy': 0.4470588235294118, 'num_samples': 425, 'test_unique_accuracy': 0.4652777777777778, 'test_unique_num_samples': 432} +[2026-04-16 02:34:04,833][__main__][INFO] - ========== EVAL END (periodic@gstep=24000) ========== +[2026-04-16 02:34:04,834][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.20814323425293, 'accuracy': 0.4470588235294118, 'num_samples': 425, 'test_unique_accuracy': 0.4652777777777778, 'test_unique_num_samples': 432} +[2026-04-16 02:34:04,839][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.4470588235294118 is not better than 0.5270588235294118 of logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep3000, skipping checkpoint +[2026-04-16 02:34:26,904][trainer.accelerators.base_accelerator][INFO] - Training progress: step=24050/100000 (24.05%), epoch=0, lr=1e-05, speed=2.049 step/s, elapsed=03:15:38, eta=10:17:49 +[2026-04-16 02:34:48,992][trainer.accelerators.base_accelerator][INFO] - Training progress: step=24100/100000 (24.10%), epoch=0, lr=1e-05, speed=2.049 step/s, elapsed=03:16:00, eta=10:17:17 +[2026-04-16 02:35:11,177][trainer.accelerators.base_accelerator][INFO] - Training progress: step=24150/100000 (24.15%), epoch=0, lr=1e-05, speed=2.050 step/s, elapsed=03:16:22, eta=10:16:46 +[2026-04-16 02:35:33,311][trainer.accelerators.base_accelerator][INFO] - Training progress: step=24200/100000 (24.20%), epoch=0, lr=1e-05, speed=2.050 step/s, elapsed=03:16:44, eta=10:16:14 +[2026-04-16 02:35:55,725][trainer.accelerators.base_accelerator][INFO] - Training progress: step=24250/100000 (24.25%), epoch=0, lr=1e-05, speed=2.050 step/s, elapsed=03:17:06, eta=10:15:44 +[2026-04-16 02:36:17,835][trainer.accelerators.base_accelerator][INFO] - Training progress: step=24300/100000 (24.30%), epoch=0, lr=1e-05, speed=2.051 step/s, elapsed=03:17:29, eta=10:15:12 +[2026-04-16 02:36:39,882][trainer.accelerators.base_accelerator][INFO] - Training progress: step=24350/100000 (24.35%), epoch=0, lr=1e-05, speed=2.051 step/s, elapsed=03:17:51, eta=10:14:40 +[2026-04-16 02:37:02,047][trainer.accelerators.base_accelerator][INFO] - Training progress: step=24400/100000 (24.40%), epoch=0, lr=1e-05, speed=2.052 step/s, elapsed=03:18:13, eta=10:14:09 +[2026-04-16 02:37:24,143][trainer.accelerators.base_accelerator][INFO] - Training progress: step=24450/100000 (24.45%), epoch=0, lr=1e-05, speed=2.052 step/s, elapsed=03:18:35, eta=10:13:38 +[2026-04-16 02:37:46,443][trainer.accelerators.base_accelerator][INFO] - Training progress: step=24500/100000 (24.50%), epoch=0, lr=1e-05, speed=2.052 step/s, elapsed=03:18:57, eta=10:13:07 +[2026-04-16 02:38:08,574][trainer.accelerators.base_accelerator][INFO] - Training progress: step=24550/100000 (24.55%), epoch=0, lr=1e-05, speed=2.053 step/s, elapsed=03:19:19, eta=10:12:36 +[2026-04-16 02:38:30,669][trainer.accelerators.base_accelerator][INFO] - Training progress: step=24600/100000 (24.60%), epoch=0, lr=1e-05, speed=2.053 step/s, elapsed=03:19:41, eta=10:12:05 +[2026-04-16 02:38:52,695][trainer.accelerators.base_accelerator][INFO] - Training progress: step=24650/100000 (24.65%), epoch=0, lr=1e-05, speed=2.053 step/s, elapsed=03:20:03, eta=10:11:33 +[2026-04-16 02:39:24,128][trainer.accelerators.base_accelerator][INFO] - Training progress: step=24700/100000 (24.70%), epoch=0, lr=1e-05, speed=2.052 step/s, elapsed=03:20:35, eta=10:11:30 +[2026-04-16 02:41:23,430][trainer.accelerators.base_accelerator][INFO] - Training progress: step=24750/100000 (24.75%), epoch=0, lr=1e-05, speed=2.036 step/s, elapsed=03:22:34, eta=10:15:55 +[2026-04-16 02:41:54,431][trainer.accelerators.base_accelerator][INFO] - Training progress: step=24800/100000 (24.80%), epoch=0, lr=1e-05, speed=2.035 step/s, elapsed=03:23:05, eta=10:15:50 +[2026-04-16 02:42:16,556][trainer.accelerators.base_accelerator][INFO] - Training progress: step=24850/100000 (24.85%), epoch=0, lr=1e-05, speed=2.036 step/s, elapsed=03:23:27, eta=10:15:18 +[2026-04-16 02:42:38,630][trainer.accelerators.base_accelerator][INFO] - Training progress: step=24900/100000 (24.90%), epoch=0, lr=1e-05, speed=2.036 step/s, elapsed=03:23:49, eta=10:14:46 +[2026-04-16 02:43:02,071][trainer.accelerators.base_accelerator][INFO] - Training progress: step=24950/100000 (24.95%), epoch=0, lr=1e-05, speed=2.036 step/s, elapsed=03:24:13, eta=10:14:18 +[2026-04-16 02:43:24,190][trainer.accelerators.base_accelerator][INFO] - Training progress: step=25000/100000 (25.00%), epoch=0, lr=1e-05, speed=2.037 step/s, elapsed=03:24:35, eta=10:13:46 +[2026-04-16 02:43:24,229][__main__][INFO] - ========== EVAL START (periodic@gstep=25000) ========== +[2026-04-16 02:43:24,229][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-16 02:43:24,229][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 02:43:39,247][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.20814323425293, 'accuracy': 0.5223529411764706, 'num_samples': 425, 'test_unique_accuracy': 0.4652777777777778, 'test_unique_num_samples': 432} +[2026-04-16 02:43:39,248][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-16 02:43:39,248][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 02:43:54,386][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.20814323425293, 'accuracy': 0.5223529411764706, 'num_samples': 425, 'test_unique_accuracy': 0.5046296296296297, 'test_unique_num_samples': 432} +[2026-04-16 02:43:54,386][__main__][INFO] - ========== EVAL END (periodic@gstep=25000) ========== +[2026-04-16 02:43:54,386][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.214357376098633, 'accuracy': 0.5223529411764706, 'num_samples': 425, 'test_unique_accuracy': 0.5046296296296297, 'test_unique_num_samples': 432} +[2026-04-16 02:43:54,391][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.5223529411764706 is not better than 0.5270588235294118 of logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep3000, skipping checkpoint +[2026-04-16 02:44:16,552][trainer.accelerators.base_accelerator][INFO] - Training progress: step=25050/100000 (25.05%), epoch=0, lr=1e-05, speed=2.032 step/s, elapsed=03:25:27, eta=10:14:44 +[2026-04-16 02:44:38,641][trainer.accelerators.base_accelerator][INFO] - Training progress: step=25100/100000 (25.10%), epoch=0, lr=1e-05, speed=2.032 step/s, elapsed=03:25:49, eta=10:14:12 +[2026-04-16 02:45:00,793][trainer.accelerators.base_accelerator][INFO] - Training progress: step=25150/100000 (25.15%), epoch=0, lr=1e-05, speed=2.033 step/s, elapsed=03:26:12, eta=10:13:40 +[2026-04-16 02:45:23,003][trainer.accelerators.base_accelerator][INFO] - Training progress: step=25200/100000 (25.20%), epoch=0, lr=1e-05, speed=2.033 step/s, elapsed=03:26:34, eta=10:13:09 +[2026-04-16 02:45:45,129][trainer.accelerators.base_accelerator][INFO] - Training progress: step=25250/100000 (25.25%), epoch=0, lr=1e-05, speed=2.034 step/s, elapsed=03:26:56, eta=10:12:37 +[2026-04-16 02:46:07,260][trainer.accelerators.base_accelerator][INFO] - Training progress: step=25300/100000 (25.30%), epoch=0, lr=1e-05, speed=2.034 step/s, elapsed=03:27:18, eta=10:12:05 +[2026-04-16 02:46:29,724][trainer.accelerators.base_accelerator][INFO] - Training progress: step=25350/100000 (25.35%), epoch=0, lr=1e-05, speed=2.034 step/s, elapsed=03:27:40, eta=10:11:34 +[2026-04-16 02:46:51,904][trainer.accelerators.base_accelerator][INFO] - Training progress: step=25400/100000 (25.40%), epoch=0, lr=1e-05, speed=2.035 step/s, elapsed=03:28:03, eta=10:11:03 +[2026-04-16 02:47:13,996][trainer.accelerators.base_accelerator][INFO] - Training progress: step=25450/100000 (25.45%), epoch=0, lr=1e-05, speed=2.035 step/s, elapsed=03:28:25, eta=10:10:31 +[2026-04-16 02:47:36,151][trainer.accelerators.base_accelerator][INFO] - Training progress: step=25500/100000 (25.50%), epoch=0, lr=1e-05, speed=2.036 step/s, elapsed=03:28:47, eta=10:09:59 +[2026-04-16 02:47:58,171][trainer.accelerators.base_accelerator][INFO] - Training progress: step=25550/100000 (25.55%), epoch=0, lr=1e-05, speed=2.036 step/s, elapsed=03:29:09, eta=10:09:27 +[2026-04-16 02:48:20,311][trainer.accelerators.base_accelerator][INFO] - Training progress: step=25600/100000 (25.60%), epoch=0, lr=1e-05, speed=2.036 step/s, elapsed=03:29:31, eta=10:08:56 +[2026-04-16 02:48:42,396][trainer.accelerators.base_accelerator][INFO] - Training progress: step=25650/100000 (25.65%), epoch=0, lr=1e-05, speed=2.037 step/s, elapsed=03:29:53, eta=10:08:24 +[2026-04-16 02:49:04,533][trainer.accelerators.base_accelerator][INFO] - Training progress: step=25700/100000 (25.70%), epoch=0, lr=1e-05, speed=2.037 step/s, elapsed=03:30:15, eta=10:07:52 +[2026-04-16 02:49:26,670][trainer.accelerators.base_accelerator][INFO] - Training progress: step=25750/100000 (25.75%), epoch=0, lr=1e-05, speed=2.038 step/s, elapsed=03:30:37, eta=10:07:21 +[2026-04-16 02:49:48,943][trainer.accelerators.base_accelerator][INFO] - Training progress: step=25800/100000 (25.80%), epoch=0, lr=1e-05, speed=2.038 step/s, elapsed=03:31:00, eta=10:06:50 +[2026-04-16 02:50:11,019][trainer.accelerators.base_accelerator][INFO] - Training progress: step=25850/100000 (25.85%), epoch=0, lr=1e-05, speed=2.038 step/s, elapsed=03:31:22, eta=10:06:18 +[2026-04-16 02:51:44,793][trainer.accelerators.base_accelerator][INFO] - Training progress: step=25900/100000 (25.90%), epoch=0, lr=1e-05, speed=2.027 step/s, elapsed=03:32:56, eta=10:09:12 +[2026-04-16 02:53:24,097][trainer.accelerators.base_accelerator][INFO] - Training progress: step=25950/100000 (25.95%), epoch=0, lr=1e-05, speed=2.015 step/s, elapsed=03:34:35, eta=10:12:20 +[2026-04-16 02:54:50,341][trainer.accelerators.base_accelerator][INFO] - Training progress: step=26000/100000 (26.00%), epoch=0, lr=1e-05, speed=2.006 step/s, elapsed=03:36:01, eta=10:14:50 +[2026-04-16 02:54:50,391][__main__][INFO] - ========== EVAL START (periodic@gstep=26000) ========== +[2026-04-16 02:54:50,391][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-16 02:54:50,391][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 02:55:33,773][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.214357376098633, 'accuracy': 0.49411764705882355, 'num_samples': 425, 'test_unique_accuracy': 0.5046296296296297, 'test_unique_num_samples': 432} +[2026-04-16 02:55:33,775][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-16 02:55:33,775][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 02:56:16,415][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.214357376098633, 'accuracy': 0.49411764705882355, 'num_samples': 425, 'test_unique_accuracy': 0.5023148148148148, 'test_unique_num_samples': 432} +[2026-04-16 02:56:16,417][__main__][INFO] - ========== EVAL END (periodic@gstep=26000) ========== +[2026-04-16 02:56:16,419][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.217753410339355, 'accuracy': 0.49411764705882355, 'num_samples': 425, 'test_unique_accuracy': 0.5023148148148148, 'test_unique_num_samples': 432} +[2026-04-16 02:56:16,426][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.49411764705882355 is not better than 0.5270588235294118 of logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep3000, skipping checkpoint +[2026-04-16 02:56:54,948][trainer.accelerators.base_accelerator][INFO] - Training progress: step=26050/100000 (26.05%), epoch=0, lr=1e-05, speed=1.991 step/s, elapsed=03:38:06, eta=10:19:08 +[2026-04-16 02:57:17,133][trainer.accelerators.base_accelerator][INFO] - Training progress: step=26100/100000 (26.10%), epoch=0, lr=1e-05, speed=1.991 step/s, elapsed=03:38:28, eta=10:18:35 +[2026-04-16 02:58:24,631][trainer.accelerators.base_accelerator][INFO] - Training progress: step=26150/100000 (26.15%), epoch=0, lr=1e-05, speed=1.985 step/s, elapsed=03:39:35, eta=10:20:09 +[2026-04-16 02:58:55,986][trainer.accelerators.base_accelerator][INFO] - Training progress: step=26200/100000 (26.20%), epoch=0, lr=1e-05, speed=1.984 step/s, elapsed=03:40:07, eta=10:20:02 +[2026-04-16 02:59:29,589][trainer.accelerators.base_accelerator][INFO] - Training progress: step=26250/100000 (26.25%), epoch=0, lr=1e-05, speed=1.983 step/s, elapsed=03:40:40, eta=10:20:00 +[2026-04-16 03:00:01,371][trainer.accelerators.base_accelerator][INFO] - Training progress: step=26300/100000 (26.30%), epoch=0, lr=1e-05, speed=1.982 step/s, elapsed=03:41:12, eta=10:19:53 +[2026-04-16 03:00:27,883][trainer.accelerators.base_accelerator][INFO] - Training progress: step=26350/100000 (26.35%), epoch=0, lr=1e-05, speed=1.981 step/s, elapsed=03:41:39, eta=10:19:31 +[2026-04-16 03:00:50,190][trainer.accelerators.base_accelerator][INFO] - Training progress: step=26400/100000 (26.40%), epoch=0, lr=1e-05, speed=1.982 step/s, elapsed=03:42:01, eta=10:18:58 +[2026-04-16 03:01:12,520][trainer.accelerators.base_accelerator][INFO] - Training progress: step=26450/100000 (26.45%), epoch=0, lr=1e-05, speed=1.982 step/s, elapsed=03:42:23, eta=10:18:25 +[2026-04-16 03:01:34,877][trainer.accelerators.base_accelerator][INFO] - Training progress: step=26500/100000 (26.50%), epoch=0, lr=1e-05, speed=1.983 step/s, elapsed=03:42:46, eta=10:17:52 +[2026-04-16 03:01:57,154][trainer.accelerators.base_accelerator][INFO] - Training progress: step=26550/100000 (26.55%), epoch=0, lr=1e-05, speed=1.983 step/s, elapsed=03:43:08, eta=10:17:18 +[2026-04-16 03:02:19,478][trainer.accelerators.base_accelerator][INFO] - Training progress: step=26600/100000 (26.60%), epoch=0, lr=1e-05, speed=1.983 step/s, elapsed=03:43:30, eta=10:16:45 +[2026-04-16 03:02:41,768][trainer.accelerators.base_accelerator][INFO] - Training progress: step=26650/100000 (26.65%), epoch=0, lr=1e-05, speed=1.984 step/s, elapsed=03:43:53, eta=10:16:12 +[2026-04-16 03:03:04,017][trainer.accelerators.base_accelerator][INFO] - Training progress: step=26700/100000 (26.70%), epoch=0, lr=1e-05, speed=1.984 step/s, elapsed=03:44:15, eta=10:15:38 +[2026-04-16 03:03:26,113][trainer.accelerators.base_accelerator][INFO] - Training progress: step=26750/100000 (26.75%), epoch=0, lr=1e-05, speed=1.985 step/s, elapsed=03:44:37, eta=10:15:05 +[2026-04-16 03:03:48,298][trainer.accelerators.base_accelerator][INFO] - Training progress: step=26800/100000 (26.80%), epoch=0, lr=1e-05, speed=1.985 step/s, elapsed=03:44:59, eta=10:14:31 +[2026-04-16 03:04:10,459][trainer.accelerators.base_accelerator][INFO] - Training progress: step=26850/100000 (26.85%), epoch=0, lr=1e-05, speed=1.986 step/s, elapsed=03:45:21, eta=10:13:58 +[2026-04-16 03:04:32,571][trainer.accelerators.base_accelerator][INFO] - Training progress: step=26900/100000 (26.90%), epoch=0, lr=1e-05, speed=1.986 step/s, elapsed=03:45:43, eta=10:13:24 +[2026-04-16 03:04:55,175][trainer.accelerators.base_accelerator][INFO] - Training progress: step=26950/100000 (26.95%), epoch=0, lr=1e-05, speed=1.987 step/s, elapsed=03:46:06, eta=10:12:52 +[2026-04-16 03:05:17,209][trainer.accelerators.base_accelerator][INFO] - Training progress: step=27000/100000 (27.00%), epoch=0, lr=1e-05, speed=1.987 step/s, elapsed=03:46:28, eta=10:12:19 +[2026-04-16 03:05:17,248][__main__][INFO] - ========== EVAL START (periodic@gstep=27000) ========== +[2026-04-16 03:05:17,248][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-16 03:05:17,248][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 03:05:32,435][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.217753410339355, 'accuracy': 0.4988235294117647, 'num_samples': 425, 'test_unique_accuracy': 0.5023148148148148, 'test_unique_num_samples': 432} +[2026-04-16 03:05:32,436][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-16 03:05:32,436][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 03:05:47,564][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.217753410339355, 'accuracy': 0.4988235294117647, 'num_samples': 425, 'test_unique_accuracy': 0.4976851851851852, 'test_unique_num_samples': 432} +[2026-04-16 03:05:47,564][__main__][INFO] - ========== EVAL END (periodic@gstep=27000) ========== +[2026-04-16 03:05:47,565][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.22360610961914, 'accuracy': 0.4988235294117647, 'num_samples': 425, 'test_unique_accuracy': 0.4976851851851852, 'test_unique_num_samples': 432} +[2026-04-16 03:05:47,571][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.4988235294117647 is not better than 0.5270588235294118 of logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep3000, skipping checkpoint +[2026-04-16 03:06:09,881][trainer.accelerators.base_accelerator][INFO] - Training progress: step=27050/100000 (27.05%), epoch=0, lr=1e-05, speed=1.983 step/s, elapsed=03:47:21, eta=10:13:08 +[2026-04-16 03:06:31,933][trainer.accelerators.base_accelerator][INFO] - Training progress: step=27100/100000 (27.10%), epoch=0, lr=1e-05, speed=1.983 step/s, elapsed=03:47:43, eta=10:12:34 +[2026-04-16 03:06:54,050][trainer.accelerators.base_accelerator][INFO] - Training progress: step=27150/100000 (27.15%), epoch=0, lr=1e-05, speed=1.984 step/s, elapsed=03:48:05, eta=10:12:00 +[2026-04-16 03:07:16,155][trainer.accelerators.base_accelerator][INFO] - Training progress: step=27200/100000 (27.20%), epoch=0, lr=1e-05, speed=1.984 step/s, elapsed=03:48:27, eta=10:11:27 +[2026-04-16 03:07:38,323][trainer.accelerators.base_accelerator][INFO] - Training progress: step=27250/100000 (27.25%), epoch=0, lr=1e-05, speed=1.985 step/s, elapsed=03:48:49, eta=10:10:54 +[2026-04-16 03:08:00,488][trainer.accelerators.base_accelerator][INFO] - Training progress: step=27300/100000 (27.30%), epoch=0, lr=1e-05, speed=1.985 step/s, elapsed=03:49:11, eta=10:10:20 +[2026-04-16 03:08:22,680][trainer.accelerators.base_accelerator][INFO] - Training progress: step=27350/100000 (27.35%), epoch=0, lr=1e-05, speed=1.986 step/s, elapsed=03:49:33, eta=10:09:47 +[2026-04-16 03:08:45,116][trainer.accelerators.base_accelerator][INFO] - Training progress: step=27400/100000 (27.40%), epoch=0, lr=1e-05, speed=1.986 step/s, elapsed=03:49:56, eta=10:09:15 +[2026-04-16 03:09:07,296][trainer.accelerators.base_accelerator][INFO] - Training progress: step=27450/100000 (27.45%), epoch=0, lr=1e-05, speed=1.986 step/s, elapsed=03:50:18, eta=10:08:42 +[2026-04-16 03:09:29,536][trainer.accelerators.base_accelerator][INFO] - Training progress: step=27500/100000 (27.50%), epoch=0, lr=1e-05, speed=1.987 step/s, elapsed=03:50:40, eta=10:08:09 +[2026-04-16 03:09:51,580][trainer.accelerators.base_accelerator][INFO] - Training progress: step=27550/100000 (27.55%), epoch=0, lr=1e-05, speed=1.987 step/s, elapsed=03:51:02, eta=10:07:35 +[2026-04-16 03:10:13,799][trainer.accelerators.base_accelerator][INFO] - Training progress: step=27600/100000 (27.60%), epoch=0, lr=1e-05, speed=1.988 step/s, elapsed=03:51:25, eta=10:07:03 +[2026-04-16 03:10:35,920][trainer.accelerators.base_accelerator][INFO] - Training progress: step=27650/100000 (27.65%), epoch=0, lr=1e-05, speed=1.988 step/s, elapsed=03:51:47, eta=10:06:30 +[2026-04-16 03:10:58,091][trainer.accelerators.base_accelerator][INFO] - Training progress: step=27700/100000 (27.70%), epoch=0, lr=1e-05, speed=1.989 step/s, elapsed=03:52:09, eta=10:05:57 +[2026-04-16 03:11:20,222][trainer.accelerators.base_accelerator][INFO] - Training progress: step=27750/100000 (27.75%), epoch=0, lr=1e-05, speed=1.989 step/s, elapsed=03:52:31, eta=10:05:24 +[2026-04-16 03:11:42,343][trainer.accelerators.base_accelerator][INFO] - Training progress: step=27800/100000 (27.80%), epoch=0, lr=1e-05, speed=1.989 step/s, elapsed=03:52:53, eta=10:04:51 +[2026-04-16 03:12:04,412][trainer.accelerators.base_accelerator][INFO] - Training progress: step=27850/100000 (27.85%), epoch=0, lr=1e-05, speed=1.990 step/s, elapsed=03:53:15, eta=10:04:18 +[2026-04-16 03:12:26,837][trainer.accelerators.base_accelerator][INFO] - Training progress: step=27900/100000 (27.90%), epoch=0, lr=1e-05, speed=1.990 step/s, elapsed=03:53:38, eta=10:03:45 +[2026-04-16 03:12:48,755][trainer.accelerators.base_accelerator][INFO] - Training progress: step=27950/100000 (27.95%), epoch=0, lr=1e-05, speed=1.991 step/s, elapsed=03:54:00, eta=10:03:12 +[2026-04-16 03:13:10,881][trainer.accelerators.base_accelerator][INFO] - Training progress: step=28000/100000 (28.00%), epoch=0, lr=1e-05, speed=1.991 step/s, elapsed=03:54:22, eta=10:02:39 +[2026-04-16 03:13:10,920][__main__][INFO] - ========== EVAL START (periodic@gstep=28000) ========== +[2026-04-16 03:13:10,921][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-16 03:13:10,921][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 03:13:25,957][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.22360610961914, 'accuracy': 0.5011764705882353, 'num_samples': 425, 'test_unique_accuracy': 0.4976851851851852, 'test_unique_num_samples': 432} +[2026-04-16 03:13:25,957][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-16 03:13:25,957][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 03:13:41,093][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.22360610961914, 'accuracy': 0.5011764705882353, 'num_samples': 425, 'test_unique_accuracy': 0.5300925925925926, 'test_unique_num_samples': 432} +[2026-04-16 03:13:41,094][__main__][INFO] - ========== EVAL END (periodic@gstep=28000) ========== +[2026-04-16 03:13:41,094][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.227705955505371, 'accuracy': 0.5011764705882353, 'num_samples': 425, 'test_unique_accuracy': 0.5300925925925926, 'test_unique_num_samples': 432} +[2026-04-16 03:13:41,098][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.5011764705882353 is not better than 0.5270588235294118 of logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep3000, skipping checkpoint +[2026-04-16 03:14:03,142][trainer.accelerators.base_accelerator][INFO] - Training progress: step=28050/100000 (28.05%), epoch=0, lr=1e-05, speed=1.987 step/s, elapsed=03:55:14, eta=10:03:24 +[2026-04-16 03:14:25,281][trainer.accelerators.base_accelerator][INFO] - Training progress: step=28100/100000 (28.10%), epoch=0, lr=1e-05, speed=1.988 step/s, elapsed=03:55:36, eta=10:02:51 +[2026-04-16 03:14:47,657][trainer.accelerators.base_accelerator][INFO] - Training progress: step=28150/100000 (28.15%), epoch=0, lr=1e-05, speed=1.988 step/s, elapsed=03:55:58, eta=10:02:19 +[2026-04-16 03:15:09,785][trainer.accelerators.base_accelerator][INFO] - Training progress: step=28200/100000 (28.20%), epoch=0, lr=1e-05, speed=1.989 step/s, elapsed=03:56:21, eta=10:01:46 +[2026-04-16 03:15:31,988][trainer.accelerators.base_accelerator][INFO] - Training progress: step=28250/100000 (28.25%), epoch=0, lr=1e-05, speed=1.989 step/s, elapsed=03:56:43, eta=10:01:13 +[2026-04-16 03:15:54,096][trainer.accelerators.base_accelerator][INFO] - Training progress: step=28300/100000 (28.30%), epoch=0, lr=1e-05, speed=1.989 step/s, elapsed=03:57:05, eta=10:00:40 +[2026-04-16 03:16:16,182][trainer.accelerators.base_accelerator][INFO] - Training progress: step=28350/100000 (28.35%), epoch=0, lr=1e-05, speed=1.990 step/s, elapsed=03:57:27, eta=10:00:08 +[2026-04-16 03:16:38,548][trainer.accelerators.base_accelerator][INFO] - Training progress: step=28400/100000 (28.40%), epoch=0, lr=1e-05, speed=1.990 step/s, elapsed=03:57:49, eta=09:59:35 +[2026-04-16 03:17:00,699][trainer.accelerators.base_accelerator][INFO] - Training progress: step=28450/100000 (28.45%), epoch=0, lr=1e-05, speed=1.991 step/s, elapsed=03:58:11, eta=09:59:03 +[2026-04-16 03:17:22,754][trainer.accelerators.base_accelerator][INFO] - Training progress: step=28500/100000 (28.50%), epoch=0, lr=1e-05, speed=1.991 step/s, elapsed=03:58:34, eta=09:58:30 +[2026-04-16 03:17:44,789][trainer.accelerators.base_accelerator][INFO] - Training progress: step=28550/100000 (28.55%), epoch=0, lr=1e-05, speed=1.991 step/s, elapsed=03:58:56, eta=09:57:57 +[2026-04-16 03:18:06,769][trainer.accelerators.base_accelerator][INFO] - Training progress: step=28600/100000 (28.60%), epoch=0, lr=1e-05, speed=1.992 step/s, elapsed=03:59:18, eta=09:57:24 +[2026-04-16 03:18:29,150][trainer.accelerators.base_accelerator][INFO] - Training progress: step=28650/100000 (28.65%), epoch=0, lr=1e-05, speed=1.992 step/s, elapsed=03:59:40, eta=09:56:52 +[2026-04-16 03:18:51,169][trainer.accelerators.base_accelerator][INFO] - Training progress: step=28700/100000 (28.70%), epoch=0, lr=1e-05, speed=1.993 step/s, elapsed=04:00:02, eta=09:56:20 +[2026-04-16 03:19:13,272][trainer.accelerators.base_accelerator][INFO] - Training progress: step=28750/100000 (28.75%), epoch=0, lr=1e-05, speed=1.993 step/s, elapsed=04:00:24, eta=09:55:47 +[2026-04-16 03:19:35,388][trainer.accelerators.base_accelerator][INFO] - Training progress: step=28800/100000 (28.80%), epoch=0, lr=1e-05, speed=1.994 step/s, elapsed=04:00:46, eta=09:55:15 +[2026-04-16 03:19:57,471][trainer.accelerators.base_accelerator][INFO] - Training progress: step=28850/100000 (28.85%), epoch=0, lr=1e-05, speed=1.994 step/s, elapsed=04:01:08, eta=09:54:42 +[2026-04-16 03:20:19,864][trainer.accelerators.base_accelerator][INFO] - Training progress: step=28900/100000 (28.90%), epoch=0, lr=1e-05, speed=1.994 step/s, elapsed=04:01:31, eta=09:54:11 +[2026-04-16 03:20:41,960][trainer.accelerators.base_accelerator][INFO] - Training progress: step=28950/100000 (28.95%), epoch=0, lr=1e-05, speed=1.995 step/s, elapsed=04:01:53, eta=09:53:38 +[2026-04-16 03:21:04,049][trainer.accelerators.base_accelerator][INFO] - Training progress: step=29000/100000 (29.00%), epoch=0, lr=1e-05, speed=1.995 step/s, elapsed=04:02:15, eta=09:53:06 +[2026-04-16 03:21:04,089][__main__][INFO] - ========== EVAL START (periodic@gstep=29000) ========== +[2026-04-16 03:21:04,089][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-16 03:21:04,089][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 03:21:19,202][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.227705955505371, 'accuracy': 0.4964705882352941, 'num_samples': 425, 'test_unique_accuracy': 0.5300925925925926, 'test_unique_num_samples': 432} +[2026-04-16 03:21:19,202][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-16 03:21:19,203][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 03:21:34,356][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.227705955505371, 'accuracy': 0.4964705882352941, 'num_samples': 425, 'test_unique_accuracy': 0.4652777777777778, 'test_unique_num_samples': 432} +[2026-04-16 03:21:34,356][__main__][INFO] - ========== EVAL END (periodic@gstep=29000) ========== +[2026-04-16 03:21:34,356][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.239057540893555, 'accuracy': 0.4964705882352941, 'num_samples': 425, 'test_unique_accuracy': 0.4652777777777778, 'test_unique_num_samples': 432} +[2026-04-16 03:21:34,359][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.4964705882352941 is not better than 0.5270588235294118 of logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep3000, skipping checkpoint +[2026-04-16 03:21:56,475][trainer.accelerators.base_accelerator][INFO] - Training progress: step=29050/100000 (29.05%), epoch=0, lr=1e-05, speed=1.991 step/s, elapsed=04:03:07, eta=09:53:48 +[2026-04-16 03:22:18,556][trainer.accelerators.base_accelerator][INFO] - Training progress: step=29100/100000 (29.10%), epoch=0, lr=1e-05, speed=1.992 step/s, elapsed=04:03:29, eta=09:53:15 +[2026-04-16 03:22:40,546][trainer.accelerators.base_accelerator][INFO] - Training progress: step=29150/100000 (29.15%), epoch=0, lr=1e-05, speed=1.992 step/s, elapsed=04:03:51, eta=09:52:43 +[2026-04-16 03:23:02,941][trainer.accelerators.base_accelerator][INFO] - Training progress: step=29200/100000 (29.20%), epoch=0, lr=1e-05, speed=1.993 step/s, elapsed=04:04:14, eta=09:52:11 +[2026-04-16 03:23:24,943][trainer.accelerators.base_accelerator][INFO] - Training progress: step=29250/100000 (29.25%), epoch=0, lr=1e-05, speed=1.993 step/s, elapsed=04:04:36, eta=09:51:38 +[2026-04-16 03:23:47,096][trainer.accelerators.base_accelerator][INFO] - Training progress: step=29300/100000 (29.30%), epoch=0, lr=1e-05, speed=1.993 step/s, elapsed=04:04:58, eta=09:51:06 +[2026-04-16 03:24:09,235][trainer.accelerators.base_accelerator][INFO] - Training progress: step=29350/100000 (29.35%), epoch=0, lr=1e-05, speed=1.994 step/s, elapsed=04:05:20, eta=09:50:34 +[2026-04-16 03:24:31,324][trainer.accelerators.base_accelerator][INFO] - Training progress: step=29400/100000 (29.40%), epoch=0, lr=1e-05, speed=1.994 step/s, elapsed=04:05:42, eta=09:50:02 +[2026-04-16 03:24:53,377][trainer.accelerators.base_accelerator][INFO] - Training progress: step=29450/100000 (29.45%), epoch=0, lr=1e-05, speed=1.995 step/s, elapsed=04:06:04, eta=09:49:29 +[2026-04-16 03:25:15,509][trainer.accelerators.base_accelerator][INFO] - Training progress: step=29500/100000 (29.50%), epoch=0, lr=1e-05, speed=1.995 step/s, elapsed=04:06:26, eta=09:48:57 +[2026-04-16 03:25:37,590][trainer.accelerators.base_accelerator][INFO] - Training progress: step=29550/100000 (29.55%), epoch=0, lr=1e-05, speed=1.995 step/s, elapsed=04:06:48, eta=09:48:25 +[2026-04-16 03:25:59,733][trainer.accelerators.base_accelerator][INFO] - Training progress: step=29600/100000 (29.60%), epoch=0, lr=1e-05, speed=1.996 step/s, elapsed=04:07:10, eta=09:47:53 +[2026-04-16 03:26:21,919][trainer.accelerators.base_accelerator][INFO] - Training progress: step=29650/100000 (29.65%), epoch=0, lr=1e-05, speed=1.996 step/s, elapsed=04:07:33, eta=09:47:21 +[2026-04-16 03:26:44,097][trainer.accelerators.base_accelerator][INFO] - Training progress: step=29700/100000 (29.70%), epoch=0, lr=1e-05, speed=1.997 step/s, elapsed=04:07:55, eta=09:46:49 +[2026-04-16 03:27:06,254][trainer.accelerators.base_accelerator][INFO] - Training progress: step=29750/100000 (29.75%), epoch=0, lr=1e-05, speed=1.997 step/s, elapsed=04:08:17, eta=09:46:18 +[2026-04-16 03:27:28,377][trainer.accelerators.base_accelerator][INFO] - Training progress: step=29800/100000 (29.80%), epoch=0, lr=1e-05, speed=1.997 step/s, elapsed=04:08:39, eta=09:45:46 +[2026-04-16 03:27:50,756][trainer.accelerators.base_accelerator][INFO] - Training progress: step=29850/100000 (29.85%), epoch=0, lr=1e-05, speed=1.998 step/s, elapsed=04:09:02, eta=09:45:14 +[2026-04-16 03:28:12,906][trainer.accelerators.base_accelerator][INFO] - Training progress: step=29900/100000 (29.90%), epoch=0, lr=1e-05, speed=1.998 step/s, elapsed=04:09:24, eta=09:44:43 +[2026-04-16 03:28:35,047][trainer.accelerators.base_accelerator][INFO] - Training progress: step=29950/100000 (29.95%), epoch=0, lr=1e-05, speed=1.998 step/s, elapsed=04:09:46, eta=09:44:11 +[2026-04-16 03:28:57,159][trainer.accelerators.base_accelerator][INFO] - Training progress: step=30000/100000 (30.00%), epoch=0, lr=1e-05, speed=1.999 step/s, elapsed=04:10:08, eta=09:43:39 +[2026-04-16 03:28:57,198][__main__][INFO] - ========== EVAL START (periodic@gstep=30000) ========== +[2026-04-16 03:28:57,198][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-16 03:28:57,198][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 03:29:12,262][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.239057540893555, 'accuracy': 0.47058823529411764, 'num_samples': 425, 'test_unique_accuracy': 0.4652777777777778, 'test_unique_num_samples': 432} +[2026-04-16 03:29:12,263][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-16 03:29:12,263][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 03:29:27,395][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.239057540893555, 'accuracy': 0.47058823529411764, 'num_samples': 425, 'test_unique_accuracy': 0.49074074074074076, 'test_unique_num_samples': 432} +[2026-04-16 03:29:27,395][__main__][INFO] - ========== EVAL END (periodic@gstep=30000) ========== +[2026-04-16 03:29:27,395][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.242341041564941, 'accuracy': 0.47058823529411764, 'num_samples': 425, 'test_unique_accuracy': 0.49074074074074076, 'test_unique_num_samples': 432} +[2026-04-16 03:29:27,399][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.47058823529411764 is not better than 0.5270588235294118 of logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep3000, skipping checkpoint +[2026-04-16 03:29:49,440][trainer.accelerators.base_accelerator][INFO] - Training progress: step=30050/100000 (30.05%), epoch=0, lr=1e-05, speed=1.995 step/s, elapsed=04:11:00, eta=09:44:18 +[2026-04-16 03:30:11,562][trainer.accelerators.base_accelerator][INFO] - Training progress: step=30100/100000 (30.10%), epoch=0, lr=1e-05, speed=1.996 step/s, elapsed=04:11:22, eta=09:43:46 +[2026-04-16 03:30:33,696][trainer.accelerators.base_accelerator][INFO] - Training progress: step=30150/100000 (30.15%), epoch=0, lr=1e-05, speed=1.996 step/s, elapsed=04:11:44, eta=09:43:14 +[2026-04-16 03:30:56,147][trainer.accelerators.base_accelerator][INFO] - Training progress: step=30200/100000 (30.20%), epoch=0, lr=1e-05, speed=1.996 step/s, elapsed=04:12:07, eta=09:42:43 +[2026-04-16 03:31:18,213][trainer.accelerators.base_accelerator][INFO] - Training progress: step=30250/100000 (30.25%), epoch=0, lr=1e-05, speed=1.997 step/s, elapsed=04:12:29, eta=09:42:11 +[2026-04-16 03:31:40,265][trainer.accelerators.base_accelerator][INFO] - Training progress: step=30300/100000 (30.30%), epoch=0, lr=1e-05, speed=1.997 step/s, elapsed=04:12:51, eta=09:41:39 +[2026-04-16 03:32:02,406][trainer.accelerators.base_accelerator][INFO] - Training progress: step=30350/100000 (30.35%), epoch=0, lr=1e-05, speed=1.998 step/s, elapsed=04:13:13, eta=09:41:07 +[2026-04-16 03:32:24,525][trainer.accelerators.base_accelerator][INFO] - Training progress: step=30400/100000 (30.40%), epoch=0, lr=1e-05, speed=1.998 step/s, elapsed=04:13:35, eta=09:40:36 +[2026-04-16 03:32:46,849][trainer.accelerators.base_accelerator][INFO] - Training progress: step=30450/100000 (30.45%), epoch=0, lr=1e-05, speed=1.998 step/s, elapsed=04:13:58, eta=09:40:04 +[2026-04-16 03:33:08,990][trainer.accelerators.base_accelerator][INFO] - Training progress: step=30500/100000 (30.50%), epoch=0, lr=1e-05, speed=1.999 step/s, elapsed=04:14:20, eta=09:39:33 +[2026-04-16 03:33:31,075][trainer.accelerators.base_accelerator][INFO] - Training progress: step=30550/100000 (30.55%), epoch=0, lr=1e-05, speed=1.999 step/s, elapsed=04:14:42, eta=09:39:01 +[2026-04-16 03:33:53,167][trainer.accelerators.base_accelerator][INFO] - Training progress: step=30600/100000 (30.60%), epoch=0, lr=1e-05, speed=1.999 step/s, elapsed=04:15:04, eta=09:38:30 +[2026-04-16 03:34:15,269][trainer.accelerators.base_accelerator][INFO] - Training progress: step=30650/100000 (30.65%), epoch=0, lr=1e-05, speed=2.000 step/s, elapsed=04:15:26, eta=09:37:58 +[2026-04-16 03:34:37,614][trainer.accelerators.base_accelerator][INFO] - Training progress: step=30700/100000 (30.70%), epoch=0, lr=1e-05, speed=2.000 step/s, elapsed=04:15:48, eta=09:37:27 +[2026-04-16 03:34:59,763][trainer.accelerators.base_accelerator][INFO] - Training progress: step=30750/100000 (30.75%), epoch=0, lr=1e-05, speed=2.001 step/s, elapsed=04:16:11, eta=09:36:56 +[2026-04-16 03:35:21,805][trainer.accelerators.base_accelerator][INFO] - Training progress: step=30800/100000 (30.80%), epoch=0, lr=1e-05, speed=2.001 step/s, elapsed=04:16:33, eta=09:36:24 +[2026-04-16 03:35:43,934][trainer.accelerators.base_accelerator][INFO] - Training progress: step=30850/100000 (30.85%), epoch=0, lr=1e-05, speed=2.001 step/s, elapsed=04:16:55, eta=09:35:53 +[2026-04-16 03:36:06,046][trainer.accelerators.base_accelerator][INFO] - Training progress: step=30900/100000 (30.90%), epoch=0, lr=1e-05, speed=2.002 step/s, elapsed=04:17:17, eta=09:35:21 +[2026-04-16 03:36:28,367][trainer.accelerators.base_accelerator][INFO] - Training progress: step=30950/100000 (30.95%), epoch=0, lr=1e-05, speed=2.002 step/s, elapsed=04:17:39, eta=09:34:50 +[2026-04-16 03:36:50,456][trainer.accelerators.base_accelerator][INFO] - Training progress: step=31000/100000 (31.00%), epoch=0, lr=1e-05, speed=2.002 step/s, elapsed=04:18:01, eta=09:34:19 +[2026-04-16 03:36:50,495][__main__][INFO] - ========== EVAL START (periodic@gstep=31000) ========== +[2026-04-16 03:36:50,495][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-16 03:36:50,495][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 03:37:05,516][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.242341041564941, 'accuracy': 0.5152941176470588, 'num_samples': 425, 'test_unique_accuracy': 0.49074074074074076, 'test_unique_num_samples': 432} +[2026-04-16 03:37:05,516][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-16 03:37:05,516][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 03:37:20,763][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.242341041564941, 'accuracy': 0.5152941176470588, 'num_samples': 425, 'test_unique_accuracy': 0.4444444444444444, 'test_unique_num_samples': 432} +[2026-04-16 03:37:20,763][__main__][INFO] - ========== EVAL END (periodic@gstep=31000) ========== +[2026-04-16 03:37:20,763][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.244612693786621, 'accuracy': 0.5152941176470588, 'num_samples': 425, 'test_unique_accuracy': 0.4444444444444444, 'test_unique_num_samples': 432} +[2026-04-16 03:37:20,766][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.5152941176470588 is not better than 0.5270588235294118 of logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep3000, skipping checkpoint +[2026-04-16 03:37:42,846][trainer.accelerators.base_accelerator][INFO] - Training progress: step=31050/100000 (31.05%), epoch=0, lr=1e-05, speed=1.999 step/s, elapsed=04:18:54, eta=09:34:55 +[2026-04-16 03:38:05,037][trainer.accelerators.base_accelerator][INFO] - Training progress: step=31100/100000 (31.10%), epoch=0, lr=1e-05, speed=1.999 step/s, elapsed=04:19:16, eta=09:34:23 +[2026-04-16 03:38:27,144][trainer.accelerators.base_accelerator][INFO] - Training progress: step=31150/100000 (31.15%), epoch=0, lr=1e-05, speed=2.000 step/s, elapsed=04:19:38, eta=09:33:52 +[2026-04-16 03:38:49,552][trainer.accelerators.base_accelerator][INFO] - Training progress: step=31200/100000 (31.20%), epoch=0, lr=1e-05, speed=2.000 step/s, elapsed=04:20:00, eta=09:33:21 +[2026-04-16 03:39:11,705][trainer.accelerators.base_accelerator][INFO] - Training progress: step=31250/100000 (31.25%), epoch=0, lr=1e-05, speed=2.000 step/s, elapsed=04:20:22, eta=09:32:50 +[2026-04-16 03:39:33,806][trainer.accelerators.base_accelerator][INFO] - Training progress: step=31300/100000 (31.30%), epoch=0, lr=1e-05, speed=2.001 step/s, elapsed=04:20:45, eta=09:32:19 +[2026-04-16 03:40:54,958][trainer.accelerators.base_accelerator][INFO] - Training progress: step=31350/100000 (31.35%), epoch=0, lr=1e-05, speed=1.993 step/s, elapsed=04:22:06, eta=09:33:57 +[2026-04-16 03:42:00,439][trainer.accelerators.base_accelerator][INFO] - Training progress: step=31400/100000 (31.40%), epoch=0, lr=1e-05, speed=1.988 step/s, elapsed=04:23:11, eta=09:35:00 +[2026-04-16 03:42:48,197][trainer.accelerators.base_accelerator][INFO] - Training progress: step=31450/100000 (31.45%), epoch=0, lr=1e-05, speed=1.986 step/s, elapsed=04:23:59, eta=09:35:24 +[2026-04-16 03:43:41,892][trainer.accelerators.base_accelerator][INFO] - Training progress: step=31500/100000 (31.50%), epoch=0, lr=1e-05, speed=1.982 step/s, elapsed=04:24:53, eta=09:36:01 +[2026-04-16 03:44:39,338][trainer.accelerators.base_accelerator][INFO] - Training progress: step=31550/100000 (31.55%), epoch=0, lr=1e-05, speed=1.978 step/s, elapsed=04:25:50, eta=09:36:45 +[2026-04-16 03:45:08,567][trainer.accelerators.base_accelerator][INFO] - Training progress: step=31600/100000 (31.60%), epoch=0, lr=1e-05, speed=1.977 step/s, elapsed=04:26:19, eta=09:36:29 +[2026-04-16 03:45:50,672][trainer.accelerators.base_accelerator][INFO] - Training progress: step=31650/100000 (31.65%), epoch=0, lr=1e-05, speed=1.975 step/s, elapsed=04:27:01, eta=09:36:40 +[2026-04-16 03:46:12,957][trainer.accelerators.base_accelerator][INFO] - Training progress: step=31700/100000 (31.70%), epoch=0, lr=1e-05, speed=1.976 step/s, elapsed=04:27:24, eta=09:36:08 +[2026-04-16 03:46:35,160][trainer.accelerators.base_accelerator][INFO] - Training progress: step=31750/100000 (31.75%), epoch=0, lr=1e-05, speed=1.976 step/s, elapsed=04:27:46, eta=09:35:36 +[2026-04-16 03:46:57,415][trainer.accelerators.base_accelerator][INFO] - Training progress: step=31800/100000 (31.80%), epoch=0, lr=1e-05, speed=1.977 step/s, elapsed=04:28:08, eta=09:35:04 +[2026-04-16 03:47:19,657][trainer.accelerators.base_accelerator][INFO] - Training progress: step=31850/100000 (31.85%), epoch=0, lr=1e-05, speed=1.977 step/s, elapsed=04:28:30, eta=09:34:32 +[2026-04-16 03:47:49,126][trainer.accelerators.base_accelerator][INFO] - Training progress: step=31900/100000 (31.90%), epoch=0, lr=1e-05, speed=1.976 step/s, elapsed=04:29:00, eta=09:34:16 +[2026-04-16 03:48:11,324][trainer.accelerators.base_accelerator][INFO] - Training progress: step=31950/100000 (31.95%), epoch=0, lr=1e-05, speed=1.977 step/s, elapsed=04:29:22, eta=09:33:44 +[2026-04-16 03:48:36,116][trainer.accelerators.base_accelerator][INFO] - Training progress: step=32000/100000 (32.00%), epoch=0, lr=1e-05, speed=1.977 step/s, elapsed=04:29:47, eta=09:33:18 +[2026-04-16 03:48:36,156][__main__][INFO] - ========== EVAL START (periodic@gstep=32000) ========== +[2026-04-16 03:48:36,157][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-16 03:48:36,157][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 03:48:52,214][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.244612693786621, 'accuracy': 0.5364705882352941, 'num_samples': 425, 'test_unique_accuracy': 0.4444444444444444, 'test_unique_num_samples': 432} +[2026-04-16 03:48:52,214][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-16 03:48:52,214][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 03:49:08,087][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.244612693786621, 'accuracy': 0.5364705882352941, 'num_samples': 425, 'test_unique_accuracy': 0.5092592592592593, 'test_unique_num_samples': 432} +[2026-04-16 03:49:08,089][__main__][INFO] - ========== EVAL END (periodic@gstep=32000) ========== +[2026-04-16 03:49:08,089][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.247028350830078, 'accuracy': 0.5364705882352941, 'num_samples': 425, 'test_unique_accuracy': 0.5092592592592593, 'test_unique_num_samples': 432} +[2026-04-16 03:49:08,133][trainer.accelerators.base_accelerator][INFO] - Found 3 checkpoints in logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951 +[2026-04-16 03:49:08,138][trainer.accelerators.base_accelerator][INFO] - Deleting checkpoint logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep1000 +[2026-04-16 03:49:08,394][trainer.accelerators.base_accelerator][INFO] - Saving checkpoint to logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep32000 +[2026-04-16 03:49:08,396][accelerate.accelerator][INFO] - Saving current state to logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep32000 +[2026-04-16 03:49:19,483][accelerate.checkpointing][INFO] - Model weights saved in logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep32000/model.safetensors +[2026-04-16 03:49:57,396][accelerate.checkpointing][INFO] - Optimizer state saved in logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep32000/optimizer.bin +[2026-04-16 03:49:57,504][accelerate.checkpointing][INFO] - Scheduler state saved in logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep32000/scheduler.bin +[2026-04-16 03:49:57,505][accelerate.checkpointing][INFO] - Sampler state for dataloader 0 saved in logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep32000/sampler.bin +[2026-04-16 03:49:57,505][accelerate.checkpointing][INFO] - Sampler state for dataloader 1 saved in logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep32000/sampler_1.bin +[2026-04-16 03:49:57,505][accelerate.checkpointing][INFO] - Sampler state for dataloader 2 saved in logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep32000/sampler_2.bin +[2026-04-16 03:49:57,614][accelerate.checkpointing][INFO] - Random states saved in logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep32000/random_states_0.pkl +[2026-04-16 03:49:57,740][trainer.accelerators.base_accelerator][INFO] - Saved checkpoint to logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep32000 +[2026-04-16 03:50:20,778][trainer.accelerators.base_accelerator][INFO] - Training progress: step=32050/100000 (32.05%), epoch=0, lr=1e-05, speed=1.967 step/s, elapsed=04:31:32, eta=09:35:41 +[2026-04-16 03:50:42,940][trainer.accelerators.base_accelerator][INFO] - Training progress: step=32100/100000 (32.10%), epoch=0, lr=1e-05, speed=1.968 step/s, elapsed=04:31:54, eta=09:35:08 +[2026-04-16 03:51:05,163][trainer.accelerators.base_accelerator][INFO] - Training progress: step=32150/100000 (32.15%), epoch=0, lr=1e-05, speed=1.968 step/s, elapsed=04:32:16, eta=09:34:36 +[2026-04-16 03:51:27,261][trainer.accelerators.base_accelerator][INFO] - Training progress: step=32200/100000 (32.20%), epoch=0, lr=1e-05, speed=1.968 step/s, elapsed=04:32:38, eta=09:34:04 +[2026-04-16 03:51:49,373][trainer.accelerators.base_accelerator][INFO] - Training progress: step=32250/100000 (32.25%), epoch=0, lr=1e-05, speed=1.969 step/s, elapsed=04:33:00, eta=09:33:32 +[2026-04-16 03:52:11,597][trainer.accelerators.base_accelerator][INFO] - Training progress: step=32300/100000 (32.30%), epoch=0, lr=1e-05, speed=1.969 step/s, elapsed=04:33:22, eta=09:32:59 +[2026-04-16 03:52:33,618][trainer.accelerators.base_accelerator][INFO] - Training progress: step=32350/100000 (32.35%), epoch=0, lr=1e-05, speed=1.970 step/s, elapsed=04:33:44, eta=09:32:27 +[2026-04-16 03:52:55,587][trainer.accelerators.base_accelerator][INFO] - Training progress: step=32400/100000 (32.40%), epoch=0, lr=1e-05, speed=1.970 step/s, elapsed=04:34:06, eta=09:31:55 +[2026-04-16 03:53:17,634][trainer.accelerators.base_accelerator][INFO] - Training progress: step=32450/100000 (32.45%), epoch=0, lr=1e-05, speed=1.970 step/s, elapsed=04:34:28, eta=09:31:22 +[2026-04-16 03:53:39,660][trainer.accelerators.base_accelerator][INFO] - Training progress: step=32500/100000 (32.50%), epoch=0, lr=1e-05, speed=1.971 step/s, elapsed=04:34:50, eta=09:30:50 +[2026-04-16 03:54:01,751][trainer.accelerators.base_accelerator][INFO] - Training progress: step=32550/100000 (32.55%), epoch=0, lr=1e-05, speed=1.971 step/s, elapsed=04:35:13, eta=09:30:18 +[2026-04-16 03:54:23,872][trainer.accelerators.base_accelerator][INFO] - Training progress: step=32600/100000 (32.60%), epoch=0, lr=1e-05, speed=1.972 step/s, elapsed=04:35:35, eta=09:29:46 +[2026-04-16 03:54:46,174][trainer.accelerators.base_accelerator][INFO] - Training progress: step=32650/100000 (32.65%), epoch=0, lr=1e-05, speed=1.972 step/s, elapsed=04:35:57, eta=09:29:14 +[2026-04-16 03:55:08,194][trainer.accelerators.base_accelerator][INFO] - Training progress: step=32700/100000 (32.70%), epoch=0, lr=1e-05, speed=1.972 step/s, elapsed=04:36:19, eta=09:28:42 +[2026-04-16 03:55:30,197][trainer.accelerators.base_accelerator][INFO] - Training progress: step=32750/100000 (32.75%), epoch=0, lr=1e-05, speed=1.973 step/s, elapsed=04:36:41, eta=09:28:09 +[2026-04-16 03:55:52,262][trainer.accelerators.base_accelerator][INFO] - Training progress: step=32800/100000 (32.80%), epoch=0, lr=1e-05, speed=1.973 step/s, elapsed=04:37:03, eta=09:27:37 +[2026-04-16 03:56:14,378][trainer.accelerators.base_accelerator][INFO] - Training progress: step=32850/100000 (32.85%), epoch=0, lr=1e-05, speed=1.973 step/s, elapsed=04:37:25, eta=09:27:05 +[2026-04-16 03:56:36,484][trainer.accelerators.base_accelerator][INFO] - Training progress: step=32900/100000 (32.90%), epoch=0, lr=1e-05, speed=1.974 step/s, elapsed=04:37:47, eta=09:26:34 +[2026-04-16 03:56:58,597][trainer.accelerators.base_accelerator][INFO] - Training progress: step=32950/100000 (32.95%), epoch=0, lr=1e-05, speed=1.974 step/s, elapsed=04:38:09, eta=09:26:02 +[2026-04-16 03:57:20,717][trainer.accelerators.base_accelerator][INFO] - Training progress: step=33000/100000 (33.00%), epoch=0, lr=1e-05, speed=1.975 step/s, elapsed=04:38:31, eta=09:25:30 +[2026-04-16 03:57:20,757][__main__][INFO] - ========== EVAL START (periodic@gstep=33000) ========== +[2026-04-16 03:57:20,757][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-16 03:57:20,757][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 03:57:35,848][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.247028350830078, 'accuracy': 0.56, 'num_samples': 425, 'test_unique_accuracy': 0.5092592592592593, 'test_unique_num_samples': 432} +[2026-04-16 03:57:35,848][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-16 03:57:35,848][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 03:57:51,203][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.247028350830078, 'accuracy': 0.56, 'num_samples': 425, 'test_unique_accuracy': 0.5162037037037037, 'test_unique_num_samples': 432} +[2026-04-16 03:57:51,203][__main__][INFO] - ========== EVAL END (periodic@gstep=33000) ========== +[2026-04-16 03:57:51,203][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.255379676818848, 'accuracy': 0.56, 'num_samples': 425, 'test_unique_accuracy': 0.5162037037037037, 'test_unique_num_samples': 432} +[2026-04-16 03:57:51,209][trainer.accelerators.base_accelerator][INFO] - Found 3 checkpoints in logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951 +[2026-04-16 03:57:51,211][trainer.accelerators.base_accelerator][INFO] - Deleting checkpoint logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep2000 +[2026-04-16 03:57:51,237][trainer.accelerators.base_accelerator][INFO] - Saving checkpoint to logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep33000 +[2026-04-16 03:57:51,238][accelerate.accelerator][INFO] - Saving current state to logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep33000 +[2026-04-16 03:58:08,677][accelerate.checkpointing][INFO] - Model weights saved in logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep33000/model.safetensors +[2026-04-16 03:58:44,589][accelerate.checkpointing][INFO] - Optimizer state saved in logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep33000/optimizer.bin +[2026-04-16 03:58:44,714][accelerate.checkpointing][INFO] - Scheduler state saved in logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep33000/scheduler.bin +[2026-04-16 03:58:44,715][accelerate.checkpointing][INFO] - Sampler state for dataloader 0 saved in logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep33000/sampler.bin +[2026-04-16 03:58:44,715][accelerate.checkpointing][INFO] - Sampler state for dataloader 1 saved in logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep33000/sampler_1.bin +[2026-04-16 03:58:44,715][accelerate.checkpointing][INFO] - Sampler state for dataloader 2 saved in logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep33000/sampler_2.bin +[2026-04-16 03:58:44,885][accelerate.checkpointing][INFO] - Random states saved in logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep33000/random_states_0.pkl +[2026-04-16 03:58:45,051][trainer.accelerators.base_accelerator][INFO] - Saved checkpoint to logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep33000 +[2026-04-16 03:59:07,237][trainer.accelerators.base_accelerator][INFO] - Training progress: step=33050/100000 (33.05%), epoch=0, lr=1e-05, speed=1.965 step/s, elapsed=04:40:18, eta=09:27:49 +[2026-04-16 03:59:29,318][trainer.accelerators.base_accelerator][INFO] - Training progress: step=33100/100000 (33.10%), epoch=0, lr=1e-05, speed=1.965 step/s, elapsed=04:40:40, eta=09:27:17 +[2026-04-16 04:00:06,894][trainer.accelerators.base_accelerator][INFO] - Training progress: step=33150/100000 (33.15%), epoch=0, lr=1e-05, speed=1.964 step/s, elapsed=04:41:18, eta=09:27:16 +[2026-04-16 04:00:29,092][trainer.accelerators.base_accelerator][INFO] - Training progress: step=33200/100000 (33.20%), epoch=0, lr=1e-05, speed=1.964 step/s, elapsed=04:41:40, eta=09:26:44 +[2026-04-16 04:00:51,548][trainer.accelerators.base_accelerator][INFO] - Training progress: step=33250/100000 (33.25%), epoch=0, lr=1e-05, speed=1.965 step/s, elapsed=04:42:02, eta=09:26:12 +[2026-04-16 04:01:13,694][trainer.accelerators.base_accelerator][INFO] - Training progress: step=33300/100000 (33.30%), epoch=0, lr=1e-05, speed=1.965 step/s, elapsed=04:42:24, eta=09:25:40 +[2026-04-16 04:01:35,701][trainer.accelerators.base_accelerator][INFO] - Training progress: step=33350/100000 (33.35%), epoch=0, lr=1e-05, speed=1.966 step/s, elapsed=04:42:46, eta=09:25:08 +[2026-04-16 04:01:57,831][trainer.accelerators.base_accelerator][INFO] - Training progress: step=33400/100000 (33.40%), epoch=0, lr=1e-05, speed=1.966 step/s, elapsed=04:43:09, eta=09:24:36 +[2026-04-16 04:02:20,003][trainer.accelerators.base_accelerator][INFO] - Training progress: step=33450/100000 (33.45%), epoch=0, lr=1e-05, speed=1.966 step/s, elapsed=04:43:31, eta=09:24:04 +[2026-04-16 04:02:42,160][trainer.accelerators.base_accelerator][INFO] - Training progress: step=33500/100000 (33.50%), epoch=0, lr=1e-05, speed=1.967 step/s, elapsed=04:43:53, eta=09:23:32 +[2026-04-16 04:03:04,227][trainer.accelerators.base_accelerator][INFO] - Training progress: step=33550/100000 (33.55%), epoch=0, lr=1e-05, speed=1.967 step/s, elapsed=04:44:15, eta=09:23:00 +[2026-04-16 04:03:26,485][trainer.accelerators.base_accelerator][INFO] - Training progress: step=33600/100000 (33.60%), epoch=0, lr=1e-05, speed=1.967 step/s, elapsed=04:44:37, eta=09:22:28 +[2026-04-16 04:03:49,257][trainer.accelerators.base_accelerator][INFO] - Training progress: step=33650/100000 (33.65%), epoch=0, lr=1e-05, speed=1.968 step/s, elapsed=04:45:00, eta=09:21:58 +[2026-04-16 04:04:11,329][trainer.accelerators.base_accelerator][INFO] - Training progress: step=33700/100000 (33.70%), epoch=0, lr=1e-05, speed=1.968 step/s, elapsed=04:45:22, eta=09:21:26 +[2026-04-16 04:04:33,455][trainer.accelerators.base_accelerator][INFO] - Training progress: step=33750/100000 (33.75%), epoch=0, lr=1e-05, speed=1.969 step/s, elapsed=04:45:44, eta=09:20:54 +[2026-04-16 04:04:55,868][trainer.accelerators.base_accelerator][INFO] - Training progress: step=33800/100000 (33.80%), epoch=0, lr=1e-05, speed=1.969 step/s, elapsed=04:46:07, eta=09:20:23 +[2026-04-16 04:05:18,021][trainer.accelerators.base_accelerator][INFO] - Training progress: step=33850/100000 (33.85%), epoch=0, lr=1e-05, speed=1.969 step/s, elapsed=04:46:29, eta=09:19:51 +[2026-04-16 04:05:40,150][trainer.accelerators.base_accelerator][INFO] - Training progress: step=33900/100000 (33.90%), epoch=0, lr=1e-05, speed=1.970 step/s, elapsed=04:46:51, eta=09:19:19 +[2026-04-16 04:06:02,284][trainer.accelerators.base_accelerator][INFO] - Training progress: step=33950/100000 (33.95%), epoch=0, lr=1e-05, speed=1.970 step/s, elapsed=04:47:13, eta=09:18:47 +[2026-04-16 04:06:24,404][trainer.accelerators.base_accelerator][INFO] - Training progress: step=34000/100000 (34.00%), epoch=0, lr=1e-05, speed=1.970 step/s, elapsed=04:47:35, eta=09:18:16 +[2026-04-16 04:06:24,443][__main__][INFO] - ========== EVAL START (periodic@gstep=34000) ========== +[2026-04-16 04:06:24,443][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-16 04:06:24,444][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 04:06:39,789][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.255379676818848, 'accuracy': 0.5011764705882353, 'num_samples': 425, 'test_unique_accuracy': 0.5162037037037037, 'test_unique_num_samples': 432} +[2026-04-16 04:06:39,790][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-16 04:06:39,790][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 04:06:54,983][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.255379676818848, 'accuracy': 0.5011764705882353, 'num_samples': 425, 'test_unique_accuracy': 0.5115740740740741, 'test_unique_num_samples': 432} +[2026-04-16 04:06:54,983][__main__][INFO] - ========== EVAL END (periodic@gstep=34000) ========== +[2026-04-16 04:06:54,984][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.259210586547852, 'accuracy': 0.5011764705882353, 'num_samples': 425, 'test_unique_accuracy': 0.5115740740740741, 'test_unique_num_samples': 432} +[2026-04-16 04:06:54,989][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.5011764705882353 is not better than 0.56 of logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep33000, skipping checkpoint +[2026-04-16 04:07:17,438][trainer.accelerators.base_accelerator][INFO] - Training progress: step=34050/100000 (34.05%), epoch=0, lr=1e-05, speed=1.967 step/s, elapsed=04:48:28, eta=09:18:44 +[2026-04-16 04:07:39,574][trainer.accelerators.base_accelerator][INFO] - Training progress: step=34100/100000 (34.10%), epoch=0, lr=1e-05, speed=1.968 step/s, elapsed=04:48:50, eta=09:18:12 +[2026-04-16 04:08:01,684][trainer.accelerators.base_accelerator][INFO] - Training progress: step=34150/100000 (34.15%), epoch=0, lr=1e-05, speed=1.968 step/s, elapsed=04:49:12, eta=09:17:40 +[2026-04-16 04:08:23,790][trainer.accelerators.base_accelerator][INFO] - Training progress: step=34200/100000 (34.20%), epoch=0, lr=1e-05, speed=1.968 step/s, elapsed=04:49:35, eta=09:17:09 +[2026-04-16 04:08:45,926][trainer.accelerators.base_accelerator][INFO] - Training progress: step=34250/100000 (34.25%), epoch=0, lr=1e-05, speed=1.969 step/s, elapsed=04:49:57, eta=09:16:37 +[2026-04-16 04:09:08,407][trainer.accelerators.base_accelerator][INFO] - Training progress: step=34300/100000 (34.30%), epoch=0, lr=1e-05, speed=1.969 step/s, elapsed=04:50:19, eta=09:16:06 +[2026-04-16 04:09:30,476][trainer.accelerators.base_accelerator][INFO] - Training progress: step=34350/100000 (34.35%), epoch=0, lr=1e-05, speed=1.969 step/s, elapsed=04:50:41, eta=09:15:34 +[2026-04-16 04:09:52,718][trainer.accelerators.base_accelerator][INFO] - Training progress: step=34400/100000 (34.40%), epoch=0, lr=1e-05, speed=1.970 step/s, elapsed=04:51:03, eta=09:15:03 +[2026-04-16 04:10:14,779][trainer.accelerators.base_accelerator][INFO] - Training progress: step=34450/100000 (34.45%), epoch=0, lr=1e-05, speed=1.970 step/s, elapsed=04:51:26, eta=09:14:31 +[2026-04-16 04:10:37,212][trainer.accelerators.base_accelerator][INFO] - Training progress: step=34500/100000 (34.50%), epoch=0, lr=1e-05, speed=1.970 step/s, elapsed=04:51:48, eta=09:14:00 +[2026-04-16 04:10:59,247][trainer.accelerators.base_accelerator][INFO] - Training progress: step=34550/100000 (34.55%), epoch=0, lr=1e-05, speed=1.971 step/s, elapsed=04:52:10, eta=09:13:29 +[2026-04-16 04:11:21,397][trainer.accelerators.base_accelerator][INFO] - Training progress: step=34600/100000 (34.60%), epoch=0, lr=1e-05, speed=1.971 step/s, elapsed=04:52:32, eta=09:12:57 +[2026-04-16 04:11:43,588][trainer.accelerators.base_accelerator][INFO] - Training progress: step=34650/100000 (34.65%), epoch=0, lr=1e-05, speed=1.972 step/s, elapsed=04:52:54, eta=09:12:26 +[2026-04-16 04:12:05,615][trainer.accelerators.base_accelerator][INFO] - Training progress: step=34700/100000 (34.70%), epoch=0, lr=1e-05, speed=1.972 step/s, elapsed=04:53:16, eta=09:11:54 +[2026-04-16 04:12:28,004][trainer.accelerators.base_accelerator][INFO] - Training progress: step=34750/100000 (34.75%), epoch=0, lr=1e-05, speed=1.972 step/s, elapsed=04:53:39, eta=09:11:23 +[2026-04-16 04:12:50,079][trainer.accelerators.base_accelerator][INFO] - Training progress: step=34800/100000 (34.80%), epoch=0, lr=1e-05, speed=1.973 step/s, elapsed=04:54:01, eta=09:10:52 +[2026-04-16 04:13:12,127][trainer.accelerators.base_accelerator][INFO] - Training progress: step=34850/100000 (34.85%), epoch=0, lr=1e-05, speed=1.973 step/s, elapsed=04:54:23, eta=09:10:20 +[2026-04-16 04:13:34,043][trainer.accelerators.base_accelerator][INFO] - Training progress: step=34900/100000 (34.90%), epoch=0, lr=1e-05, speed=1.973 step/s, elapsed=04:54:45, eta=09:09:48 +[2026-04-16 04:13:56,151][trainer.accelerators.base_accelerator][INFO] - Training progress: step=34950/100000 (34.95%), epoch=0, lr=1e-05, speed=1.974 step/s, elapsed=04:55:07, eta=09:09:17 +[2026-04-16 04:14:18,469][trainer.accelerators.base_accelerator][INFO] - Training progress: step=35000/100000 (35.00%), epoch=0, lr=1e-05, speed=1.974 step/s, elapsed=04:55:29, eta=09:08:46 +[2026-04-16 04:14:18,507][__main__][INFO] - ========== EVAL START (periodic@gstep=35000) ========== +[2026-04-16 04:14:18,507][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-16 04:14:18,508][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 04:14:33,566][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.259210586547852, 'accuracy': 0.5058823529411764, 'num_samples': 425, 'test_unique_accuracy': 0.5115740740740741, 'test_unique_num_samples': 432} +[2026-04-16 04:14:33,566][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-16 04:14:33,566][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 04:14:48,677][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.259210586547852, 'accuracy': 0.5058823529411764, 'num_samples': 425, 'test_unique_accuracy': 0.4837962962962963, 'test_unique_num_samples': 432} +[2026-04-16 04:14:48,678][__main__][INFO] - ========== EVAL END (periodic@gstep=35000) ========== +[2026-04-16 04:14:48,678][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.265714645385742, 'accuracy': 0.5058823529411764, 'num_samples': 425, 'test_unique_accuracy': 0.4837962962962963, 'test_unique_num_samples': 432} +[2026-04-16 04:14:48,681][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.5058823529411764 is not better than 0.56 of logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep33000, skipping checkpoint +[2026-04-16 04:15:10,749][trainer.accelerators.base_accelerator][INFO] - Training progress: step=35050/100000 (35.05%), epoch=0, lr=1e-05, speed=1.971 step/s, elapsed=04:56:22, eta=09:09:11 +[2026-04-16 04:15:32,885][trainer.accelerators.base_accelerator][INFO] - Training progress: step=35100/100000 (35.10%), epoch=0, lr=1e-05, speed=1.971 step/s, elapsed=04:56:44, eta=09:08:39 +[2026-04-16 04:15:54,970][trainer.accelerators.base_accelerator][INFO] - Training progress: step=35150/100000 (35.15%), epoch=0, lr=1e-05, speed=1.972 step/s, elapsed=04:57:06, eta=09:08:08 +[2026-04-16 04:16:17,030][trainer.accelerators.base_accelerator][INFO] - Training progress: step=35200/100000 (35.20%), epoch=0, lr=1e-05, speed=1.972 step/s, elapsed=04:57:28, eta=09:07:37 +[2026-04-16 04:16:39,052][trainer.accelerators.base_accelerator][INFO] - Training progress: step=35250/100000 (35.25%), epoch=0, lr=1e-05, speed=1.973 step/s, elapsed=04:57:50, eta=09:07:05 +[2026-04-16 04:17:01,178][trainer.accelerators.base_accelerator][INFO] - Training progress: step=35300/100000 (35.30%), epoch=0, lr=1e-05, speed=1.973 step/s, elapsed=04:58:12, eta=09:06:34 +[2026-04-16 04:17:23,178][trainer.accelerators.base_accelerator][INFO] - Training progress: step=35350/100000 (35.35%), epoch=0, lr=1e-05, speed=1.973 step/s, elapsed=04:58:34, eta=09:06:02 +[2026-04-16 04:17:45,251][trainer.accelerators.base_accelerator][INFO] - Training progress: step=35400/100000 (35.40%), epoch=0, lr=1e-05, speed=1.974 step/s, elapsed=04:58:56, eta=09:05:31 +[2026-04-16 04:18:07,243][trainer.accelerators.base_accelerator][INFO] - Training progress: step=35450/100000 (35.45%), epoch=0, lr=1e-05, speed=1.974 step/s, elapsed=04:59:18, eta=09:05:00 +[2026-04-16 04:18:29,666][trainer.accelerators.base_accelerator][INFO] - Training progress: step=35500/100000 (35.50%), epoch=0, lr=1e-05, speed=1.974 step/s, elapsed=04:59:40, eta=09:04:29 +[2026-04-16 04:18:51,713][trainer.accelerators.base_accelerator][INFO] - Training progress: step=35550/100000 (35.55%), epoch=0, lr=1e-05, speed=1.975 step/s, elapsed=05:00:02, eta=09:03:58 +[2026-04-16 04:19:13,834][trainer.accelerators.base_accelerator][INFO] - Training progress: step=35600/100000 (35.60%), epoch=0, lr=1e-05, speed=1.975 step/s, elapsed=05:00:25, eta=09:03:27 +[2026-04-16 04:19:35,829][trainer.accelerators.base_accelerator][INFO] - Training progress: step=35650/100000 (35.65%), epoch=0, lr=1e-05, speed=1.975 step/s, elapsed=05:00:47, eta=09:02:55 +[2026-04-16 04:19:57,855][trainer.accelerators.base_accelerator][INFO] - Training progress: step=35700/100000 (35.70%), epoch=0, lr=1e-05, speed=1.976 step/s, elapsed=05:01:09, eta=09:02:24 +[2026-04-16 04:20:19,882][trainer.accelerators.base_accelerator][INFO] - Training progress: step=35750/100000 (35.75%), epoch=0, lr=1e-05, speed=1.976 step/s, elapsed=05:01:31, eta=09:01:53 +[2026-04-16 04:20:41,918][trainer.accelerators.base_accelerator][INFO] - Training progress: step=35800/100000 (35.80%), epoch=0, lr=1e-05, speed=1.976 step/s, elapsed=05:01:53, eta=09:01:22 +[2026-04-16 04:21:04,105][trainer.accelerators.base_accelerator][INFO] - Training progress: step=35850/100000 (35.85%), epoch=0, lr=1e-05, speed=1.977 step/s, elapsed=05:02:15, eta=09:00:51 +[2026-04-16 04:21:26,149][trainer.accelerators.base_accelerator][INFO] - Training progress: step=35900/100000 (35.90%), epoch=0, lr=1e-05, speed=1.977 step/s, elapsed=05:02:37, eta=09:00:20 +[2026-04-16 04:21:48,206][trainer.accelerators.base_accelerator][INFO] - Training progress: step=35950/100000 (35.95%), epoch=0, lr=1e-05, speed=1.978 step/s, elapsed=05:02:59, eta=08:59:49 +[2026-04-16 04:22:10,348][trainer.accelerators.base_accelerator][INFO] - Training progress: step=36000/100000 (36.00%), epoch=0, lr=1e-05, speed=1.978 step/s, elapsed=05:03:21, eta=08:59:18 +[2026-04-16 04:22:10,387][__main__][INFO] - ========== EVAL START (periodic@gstep=36000) ========== +[2026-04-16 04:22:10,388][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-16 04:22:10,388][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 04:22:25,555][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.265714645385742, 'accuracy': 0.5223529411764706, 'num_samples': 425, 'test_unique_accuracy': 0.4837962962962963, 'test_unique_num_samples': 432} +[2026-04-16 04:22:25,555][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-16 04:22:25,555][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 04:22:40,695][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.265714645385742, 'accuracy': 0.5223529411764706, 'num_samples': 425, 'test_unique_accuracy': 0.49537037037037035, 'test_unique_num_samples': 432} +[2026-04-16 04:22:40,695][__main__][INFO] - ========== EVAL END (periodic@gstep=36000) ========== +[2026-04-16 04:22:40,696][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.276208877563477, 'accuracy': 0.5223529411764706, 'num_samples': 425, 'test_unique_accuracy': 0.49537037037037035, 'test_unique_num_samples': 432} +[2026-04-16 04:22:40,699][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.5223529411764706 is not better than 0.56 of logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep33000, skipping checkpoint +[2026-04-16 04:23:03,061][trainer.accelerators.base_accelerator][INFO] - Training progress: step=36050/100000 (36.05%), epoch=0, lr=1e-05, speed=1.975 step/s, elapsed=05:04:14, eta=08:59:41 +[2026-04-16 04:23:25,282][trainer.accelerators.base_accelerator][INFO] - Training progress: step=36100/100000 (36.10%), epoch=0, lr=1e-05, speed=1.975 step/s, elapsed=05:04:36, eta=08:59:10 +[2026-04-16 04:23:47,385][trainer.accelerators.base_accelerator][INFO] - Training progress: step=36150/100000 (36.15%), epoch=0, lr=1e-05, speed=1.976 step/s, elapsed=05:04:58, eta=08:58:39 +[2026-04-16 04:24:09,538][trainer.accelerators.base_accelerator][INFO] - Training progress: step=36200/100000 (36.20%), epoch=0, lr=1e-05, speed=1.976 step/s, elapsed=05:05:20, eta=08:58:09 +[2026-04-16 04:24:31,665][trainer.accelerators.base_accelerator][INFO] - Training progress: step=36250/100000 (36.25%), epoch=0, lr=1e-05, speed=1.976 step/s, elapsed=05:05:42, eta=08:57:38 +[2026-04-16 04:24:54,026][trainer.accelerators.base_accelerator][INFO] - Training progress: step=36300/100000 (36.30%), epoch=0, lr=1e-05, speed=1.977 step/s, elapsed=05:06:05, eta=08:57:07 +[2026-04-16 04:25:16,184][trainer.accelerators.base_accelerator][INFO] - Training progress: step=36350/100000 (36.35%), epoch=0, lr=1e-05, speed=1.977 step/s, elapsed=05:06:27, eta=08:56:36 +[2026-04-16 04:25:38,255][trainer.accelerators.base_accelerator][INFO] - Training progress: step=36400/100000 (36.40%), epoch=0, lr=1e-05, speed=1.977 step/s, elapsed=05:06:49, eta=08:56:06 +[2026-04-16 04:26:00,403][trainer.accelerators.base_accelerator][INFO] - Training progress: step=36450/100000 (36.45%), epoch=0, lr=1e-05, speed=1.978 step/s, elapsed=05:07:11, eta=08:55:35 +[2026-04-16 04:26:22,517][trainer.accelerators.base_accelerator][INFO] - Training progress: step=36500/100000 (36.50%), epoch=0, lr=1e-05, speed=1.978 step/s, elapsed=05:07:33, eta=08:55:04 +[2026-04-16 04:26:44,786][trainer.accelerators.base_accelerator][INFO] - Training progress: step=36550/100000 (36.55%), epoch=0, lr=1e-05, speed=1.978 step/s, elapsed=05:07:56, eta=08:54:33 +[2026-04-16 04:27:06,782][trainer.accelerators.base_accelerator][INFO] - Training progress: step=36600/100000 (36.60%), epoch=0, lr=1e-05, speed=1.979 step/s, elapsed=05:08:18, eta=08:54:03 +[2026-04-16 04:27:28,838][trainer.accelerators.base_accelerator][INFO] - Training progress: step=36650/100000 (36.65%), epoch=0, lr=1e-05, speed=1.979 step/s, elapsed=05:08:40, eta=08:53:32 +[2026-04-16 04:27:50,938][trainer.accelerators.base_accelerator][INFO] - Training progress: step=36700/100000 (36.70%), epoch=0, lr=1e-05, speed=1.979 step/s, elapsed=05:09:02, eta=08:53:01 +[2026-04-16 04:28:13,018][trainer.accelerators.base_accelerator][INFO] - Training progress: step=36750/100000 (36.75%), epoch=0, lr=1e-05, speed=1.980 step/s, elapsed=05:09:24, eta=08:52:30 +[2026-04-16 04:28:35,041][trainer.accelerators.base_accelerator][INFO] - Training progress: step=36800/100000 (36.80%), epoch=0, lr=1e-05, speed=1.980 step/s, elapsed=05:09:46, eta=08:51:59 +[2026-04-16 04:28:57,394][trainer.accelerators.base_accelerator][INFO] - Training progress: step=36850/100000 (36.85%), epoch=0, lr=1e-05, speed=1.980 step/s, elapsed=05:10:08, eta=08:51:29 +[2026-04-16 04:29:19,495][trainer.accelerators.base_accelerator][INFO] - Training progress: step=36900/100000 (36.90%), epoch=0, lr=1e-05, speed=1.981 step/s, elapsed=05:10:30, eta=08:50:59 +[2026-04-16 04:29:41,454][trainer.accelerators.base_accelerator][INFO] - Training progress: step=36950/100000 (36.95%), epoch=0, lr=1e-05, speed=1.981 step/s, elapsed=05:10:52, eta=08:50:28 +[2026-04-16 04:30:03,439][trainer.accelerators.base_accelerator][INFO] - Training progress: step=37000/100000 (37.00%), epoch=0, lr=1e-05, speed=1.981 step/s, elapsed=05:11:14, eta=08:49:57 +[2026-04-16 04:30:03,478][__main__][INFO] - ========== EVAL START (periodic@gstep=37000) ========== +[2026-04-16 04:30:03,478][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-16 04:30:03,478][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 04:30:18,538][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.276208877563477, 'accuracy': 0.508235294117647, 'num_samples': 425, 'test_unique_accuracy': 0.49537037037037035, 'test_unique_num_samples': 432} +[2026-04-16 04:30:18,538][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-16 04:30:18,539][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 04:30:33,651][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.276208877563477, 'accuracy': 0.508235294117647, 'num_samples': 425, 'test_unique_accuracy': 0.5069444444444444, 'test_unique_num_samples': 432} +[2026-04-16 04:30:33,651][__main__][INFO] - ========== EVAL END (periodic@gstep=37000) ========== +[2026-04-16 04:30:33,651][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.281638145446777, 'accuracy': 0.508235294117647, 'num_samples': 425, 'test_unique_accuracy': 0.5069444444444444, 'test_unique_num_samples': 432} +[2026-04-16 04:30:33,654][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.508235294117647 is not better than 0.56 of logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep33000, skipping checkpoint +[2026-04-16 04:30:55,635][trainer.accelerators.base_accelerator][INFO] - Training progress: step=37050/100000 (37.05%), epoch=0, lr=1e-05, speed=1.978 step/s, elapsed=05:12:06, eta=08:50:18 +[2026-04-16 04:31:17,909][trainer.accelerators.base_accelerator][INFO] - Training progress: step=37100/100000 (37.10%), epoch=0, lr=1e-05, speed=1.979 step/s, elapsed=05:12:29, eta=08:49:47 +[2026-04-16 04:31:39,940][trainer.accelerators.base_accelerator][INFO] - Training progress: step=37150/100000 (37.15%), epoch=0, lr=1e-05, speed=1.979 step/s, elapsed=05:12:51, eta=08:49:16 +[2026-04-16 04:32:02,063][trainer.accelerators.base_accelerator][INFO] - Training progress: step=37200/100000 (37.20%), epoch=0, lr=1e-05, speed=1.979 step/s, elapsed=05:13:13, eta=08:48:46 +[2026-04-16 04:32:24,188][trainer.accelerators.base_accelerator][INFO] - Training progress: step=37250/100000 (37.25%), epoch=0, lr=1e-05, speed=1.980 step/s, elapsed=05:13:35, eta=08:48:15 +[2026-04-16 04:32:46,116][trainer.accelerators.base_accelerator][INFO] - Training progress: step=37300/100000 (37.30%), epoch=0, lr=1e-05, speed=1.980 step/s, elapsed=05:13:57, eta=08:47:44 +[2026-04-16 04:33:08,216][trainer.accelerators.base_accelerator][INFO] - Training progress: step=37350/100000 (37.35%), epoch=0, lr=1e-05, speed=1.980 step/s, elapsed=05:14:19, eta=08:47:14 +[2026-04-16 04:33:30,266][trainer.accelerators.base_accelerator][INFO] - Training progress: step=37400/100000 (37.40%), epoch=0, lr=1e-05, speed=1.981 step/s, elapsed=05:14:41, eta=08:46:43 +[2026-04-16 04:33:52,310][trainer.accelerators.base_accelerator][INFO] - Training progress: step=37450/100000 (37.45%), epoch=0, lr=1e-05, speed=1.981 step/s, elapsed=05:15:03, eta=08:46:13 +[2026-04-16 04:34:14,413][trainer.accelerators.base_accelerator][INFO] - Training progress: step=37500/100000 (37.50%), epoch=0, lr=1e-05, speed=1.981 step/s, elapsed=05:15:25, eta=08:45:42 +[2026-04-16 04:34:36,485][trainer.accelerators.base_accelerator][INFO] - Training progress: step=37550/100000 (37.55%), epoch=0, lr=1e-05, speed=1.982 step/s, elapsed=05:15:47, eta=08:45:12 +[2026-04-16 04:34:58,605][trainer.accelerators.base_accelerator][INFO] - Training progress: step=37600/100000 (37.60%), epoch=0, lr=1e-05, speed=1.982 step/s, elapsed=05:16:09, eta=08:44:41 +[2026-04-16 04:35:20,672][trainer.accelerators.base_accelerator][INFO] - Training progress: step=37650/100000 (37.65%), epoch=0, lr=1e-05, speed=1.982 step/s, elapsed=05:16:31, eta=08:44:11 +[2026-04-16 04:35:42,730][trainer.accelerators.base_accelerator][INFO] - Training progress: step=37700/100000 (37.70%), epoch=0, lr=1e-05, speed=1.983 step/s, elapsed=05:16:53, eta=08:43:40 +[2026-04-16 04:36:05,064][trainer.accelerators.base_accelerator][INFO] - Training progress: step=37750/100000 (37.75%), epoch=0, lr=1e-05, speed=1.983 step/s, elapsed=05:17:16, eta=08:43:11 +[2026-04-16 04:36:27,164][trainer.accelerators.base_accelerator][INFO] - Training progress: step=37800/100000 (37.80%), epoch=0, lr=1e-05, speed=1.983 step/s, elapsed=05:17:38, eta=08:42:40 +[2026-04-16 04:36:49,293][trainer.accelerators.base_accelerator][INFO] - Training progress: step=37850/100000 (37.85%), epoch=0, lr=1e-05, speed=1.984 step/s, elapsed=05:18:00, eta=08:42:10 +[2026-04-16 04:37:11,411][trainer.accelerators.base_accelerator][INFO] - Training progress: step=37900/100000 (37.90%), epoch=0, lr=1e-05, speed=1.984 step/s, elapsed=05:18:22, eta=08:41:40 +[2026-04-16 04:37:33,442][trainer.accelerators.base_accelerator][INFO] - Training progress: step=37950/100000 (37.95%), epoch=0, lr=1e-05, speed=1.984 step/s, elapsed=05:18:44, eta=08:41:09 +[2026-04-16 04:37:55,577][trainer.accelerators.base_accelerator][INFO] - Training progress: step=38000/100000 (38.00%), epoch=0, lr=1e-05, speed=1.985 step/s, elapsed=05:19:06, eta=08:40:39 +[2026-04-16 04:37:55,616][__main__][INFO] - ========== EVAL START (periodic@gstep=38000) ========== +[2026-04-16 04:37:55,616][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-16 04:37:55,616][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 04:38:10,689][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.281638145446777, 'accuracy': 0.5223529411764706, 'num_samples': 425, 'test_unique_accuracy': 0.5069444444444444, 'test_unique_num_samples': 432} +[2026-04-16 04:38:10,689][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-16 04:38:10,689][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 04:38:25,779][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.281638145446777, 'accuracy': 0.5223529411764706, 'num_samples': 425, 'test_unique_accuracy': 0.5092592592592593, 'test_unique_num_samples': 432} +[2026-04-16 04:38:25,779][__main__][INFO] - ========== EVAL END (periodic@gstep=38000) ========== +[2026-04-16 04:38:25,780][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.28669548034668, 'accuracy': 0.5223529411764706, 'num_samples': 425, 'test_unique_accuracy': 0.5092592592592593, 'test_unique_num_samples': 432} +[2026-04-16 04:38:25,783][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.5223529411764706 is not better than 0.56 of logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep33000, skipping checkpoint +[2026-04-16 04:38:47,847][trainer.accelerators.base_accelerator][INFO] - Training progress: step=38050/100000 (38.05%), epoch=0, lr=1e-05, speed=1.982 step/s, elapsed=05:19:59, eta=08:40:58 +[2026-04-16 04:39:10,018][trainer.accelerators.base_accelerator][INFO] - Training progress: step=38100/100000 (38.10%), epoch=0, lr=1e-05, speed=1.982 step/s, elapsed=05:20:21, eta=08:40:28 +[2026-04-16 04:39:32,410][trainer.accelerators.base_accelerator][INFO] - Training progress: step=38150/100000 (38.15%), epoch=0, lr=1e-05, speed=1.982 step/s, elapsed=05:20:43, eta=08:39:58 +[2026-04-16 04:39:54,605][trainer.accelerators.base_accelerator][INFO] - Training progress: step=38200/100000 (38.20%), epoch=0, lr=1e-05, speed=1.983 step/s, elapsed=05:21:05, eta=08:39:28 +[2026-04-16 04:40:16,670][trainer.accelerators.base_accelerator][INFO] - Training progress: step=38250/100000 (38.25%), epoch=0, lr=1e-05, speed=1.983 step/s, elapsed=05:21:27, eta=08:38:58 +[2026-04-16 04:40:38,807][trainer.accelerators.base_accelerator][INFO] - Training progress: step=38300/100000 (38.30%), epoch=0, lr=1e-05, speed=1.983 step/s, elapsed=05:21:50, eta=08:38:27 +[2026-04-16 04:41:01,009][trainer.accelerators.base_accelerator][INFO] - Training progress: step=38350/100000 (38.35%), epoch=0, lr=1e-05, speed=1.984 step/s, elapsed=05:22:12, eta=08:37:57 +[2026-04-16 04:41:23,381][trainer.accelerators.base_accelerator][INFO] - Training progress: step=38400/100000 (38.40%), epoch=0, lr=1e-05, speed=1.984 step/s, elapsed=05:22:34, eta=08:37:28 +[2026-04-16 04:41:45,447][trainer.accelerators.base_accelerator][INFO] - Training progress: step=38450/100000 (38.45%), epoch=0, lr=1e-05, speed=1.984 step/s, elapsed=05:22:56, eta=08:36:57 +[2026-04-16 04:42:07,547][trainer.accelerators.base_accelerator][INFO] - Training progress: step=38500/100000 (38.50%), epoch=0, lr=1e-05, speed=1.985 step/s, elapsed=05:23:18, eta=08:36:27 +[2026-04-16 04:42:29,641][trainer.accelerators.base_accelerator][INFO] - Training progress: step=38550/100000 (38.55%), epoch=0, lr=1e-05, speed=1.985 step/s, elapsed=05:23:40, eta=08:35:57 +[2026-04-16 04:43:13,065][trainer.accelerators.base_accelerator][INFO] - Training progress: step=38600/100000 (38.60%), epoch=0, lr=1e-05, speed=1.983 step/s, elapsed=05:24:24, eta=08:36:01 +[2026-04-16 04:45:00,060][trainer.accelerators.base_accelerator][INFO] - Training progress: step=38650/100000 (38.65%), epoch=0, lr=1e-05, speed=1.975 step/s, elapsed=05:26:11, eta=08:37:45 +[2026-04-16 04:45:58,550][trainer.accelerators.base_accelerator][INFO] - Training progress: step=38700/100000 (38.70%), epoch=0, lr=1e-05, speed=1.971 step/s, elapsed=05:27:09, eta=08:38:13 +[2026-04-16 04:46:20,865][trainer.accelerators.base_accelerator][INFO] - Training progress: step=38750/100000 (38.75%), epoch=0, lr=1e-05, speed=1.972 step/s, elapsed=05:27:32, eta=08:37:43 +[2026-04-16 04:46:43,171][trainer.accelerators.base_accelerator][INFO] - Training progress: step=38800/100000 (38.80%), epoch=0, lr=1e-05, speed=1.972 step/s, elapsed=05:27:54, eta=08:37:12 +[2026-04-16 04:47:05,328][trainer.accelerators.base_accelerator][INFO] - Training progress: step=38850/100000 (38.85%), epoch=0, lr=1e-05, speed=1.972 step/s, elapsed=05:28:16, eta=08:36:42 +[2026-04-16 04:47:27,425][trainer.accelerators.base_accelerator][INFO] - Training progress: step=38900/100000 (38.90%), epoch=0, lr=1e-05, speed=1.973 step/s, elapsed=05:28:38, eta=08:36:12 +[2026-04-16 04:47:50,199][trainer.accelerators.base_accelerator][INFO] - Training progress: step=38950/100000 (38.95%), epoch=0, lr=1e-05, speed=1.973 step/s, elapsed=05:29:01, eta=08:35:42 +[2026-04-16 04:48:12,319][trainer.accelerators.base_accelerator][INFO] - Training progress: step=39000/100000 (39.00%), epoch=0, lr=1e-05, speed=1.973 step/s, elapsed=05:29:23, eta=08:35:12 +[2026-04-16 04:48:12,358][__main__][INFO] - ========== EVAL START (periodic@gstep=39000) ========== +[2026-04-16 04:48:12,359][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-16 04:48:12,359][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 04:48:28,894][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.28669548034668, 'accuracy': 0.4964705882352941, 'num_samples': 425, 'test_unique_accuracy': 0.5092592592592593, 'test_unique_num_samples': 432} +[2026-04-16 04:48:28,894][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-16 04:48:28,894][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 04:48:44,072][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.28669548034668, 'accuracy': 0.4964705882352941, 'num_samples': 425, 'test_unique_accuracy': 0.4861111111111111, 'test_unique_num_samples': 432} +[2026-04-16 04:48:44,072][__main__][INFO] - ========== EVAL END (periodic@gstep=39000) ========== +[2026-04-16 04:48:44,073][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.292449951171875, 'accuracy': 0.4964705882352941, 'num_samples': 425, 'test_unique_accuracy': 0.4861111111111111, 'test_unique_num_samples': 432} +[2026-04-16 04:48:44,077][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.4964705882352941 is not better than 0.56 of logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep33000, skipping checkpoint +[2026-04-16 04:49:06,195][trainer.accelerators.base_accelerator][INFO] - Training progress: step=39050/100000 (39.05%), epoch=0, lr=1e-05, speed=1.970 step/s, elapsed=05:30:17, eta=08:35:31 +[2026-04-16 04:49:28,357][trainer.accelerators.base_accelerator][INFO] - Training progress: step=39100/100000 (39.10%), epoch=0, lr=1e-05, speed=1.971 step/s, elapsed=05:30:39, eta=08:35:01 +[2026-04-16 04:49:50,557][trainer.accelerators.base_accelerator][INFO] - Training progress: step=39150/100000 (39.15%), epoch=0, lr=1e-05, speed=1.971 step/s, elapsed=05:31:01, eta=08:34:30 +[2026-04-16 04:50:12,734][trainer.accelerators.base_accelerator][INFO] - Training progress: step=39200/100000 (39.20%), epoch=0, lr=1e-05, speed=1.971 step/s, elapsed=05:31:23, eta=08:34:00 +[2026-04-16 04:50:34,896][trainer.accelerators.base_accelerator][INFO] - Training progress: step=39250/100000 (39.25%), epoch=0, lr=1e-05, speed=1.972 step/s, elapsed=05:31:46, eta=08:33:30 +[2026-04-16 04:50:57,014][trainer.accelerators.base_accelerator][INFO] - Training progress: step=39300/100000 (39.30%), epoch=0, lr=1e-05, speed=1.972 step/s, elapsed=05:32:08, eta=08:32:59 +[2026-04-16 04:51:19,470][trainer.accelerators.base_accelerator][INFO] - Training progress: step=39350/100000 (39.35%), epoch=0, lr=1e-05, speed=1.972 step/s, elapsed=05:32:30, eta=08:32:29 +[2026-04-16 04:51:41,504][trainer.accelerators.base_accelerator][INFO] - Training progress: step=39400/100000 (39.40%), epoch=0, lr=1e-05, speed=1.973 step/s, elapsed=05:32:52, eta=08:31:59 +[2026-04-16 04:52:03,517][trainer.accelerators.base_accelerator][INFO] - Training progress: step=39450/100000 (39.45%), epoch=0, lr=1e-05, speed=1.973 step/s, elapsed=05:33:14, eta=08:31:29 +[2026-04-16 04:52:25,585][trainer.accelerators.base_accelerator][INFO] - Training progress: step=39500/100000 (39.50%), epoch=0, lr=1e-05, speed=1.973 step/s, elapsed=05:33:36, eta=08:30:58 +[2026-04-16 04:52:47,567][trainer.accelerators.base_accelerator][INFO] - Training progress: step=39550/100000 (39.55%), epoch=0, lr=1e-05, speed=1.974 step/s, elapsed=05:33:58, eta=08:30:28 +[2026-04-16 04:54:03,236][trainer.accelerators.base_accelerator][INFO] - Training progress: step=39600/100000 (39.60%), epoch=0, lr=1e-05, speed=1.969 step/s, elapsed=05:35:14, eta=08:31:19 +[2026-04-16 04:54:59,212][trainer.accelerators.base_accelerator][INFO] - Training progress: step=39650/100000 (39.65%), epoch=0, lr=1e-05, speed=1.966 step/s, elapsed=05:36:10, eta=08:31:40 +[2026-04-16 04:56:19,558][trainer.accelerators.base_accelerator][INFO] - Training progress: step=39700/100000 (39.70%), epoch=0, lr=1e-05, speed=1.960 step/s, elapsed=05:37:30, eta=08:32:38 +[2026-04-16 04:57:53,740][trainer.accelerators.base_accelerator][INFO] - Training progress: step=39750/100000 (39.75%), epoch=0, lr=1e-05, speed=1.954 step/s, elapsed=05:39:04, eta=08:33:57 +[2026-04-16 04:58:25,320][trainer.accelerators.base_accelerator][INFO] - Training progress: step=39800/100000 (39.80%), epoch=0, lr=1e-05, speed=1.953 step/s, elapsed=05:39:36, eta=08:33:40 +[2026-04-16 04:58:47,543][trainer.accelerators.base_accelerator][INFO] - Training progress: step=39850/100000 (39.85%), epoch=0, lr=1e-05, speed=1.954 step/s, elapsed=05:39:58, eta=08:33:10 +[2026-04-16 04:59:09,734][trainer.accelerators.base_accelerator][INFO] - Training progress: step=39900/100000 (39.90%), epoch=0, lr=1e-05, speed=1.954 step/s, elapsed=05:40:20, eta=08:32:39 +[2026-04-16 04:59:31,979][trainer.accelerators.base_accelerator][INFO] - Training progress: step=39950/100000 (39.95%), epoch=0, lr=1e-05, speed=1.954 step/s, elapsed=05:40:43, eta=08:32:08 +[2026-04-16 04:59:54,586][trainer.accelerators.base_accelerator][INFO] - Training progress: step=40000/100000 (40.00%), epoch=0, lr=1e-05, speed=1.954 step/s, elapsed=05:41:05, eta=08:31:38 +[2026-04-16 04:59:54,625][__main__][INFO] - ========== EVAL START (periodic@gstep=40000) ========== +[2026-04-16 04:59:54,625][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-16 04:59:54,625][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 05:00:09,803][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.292449951171875, 'accuracy': 0.4964705882352941, 'num_samples': 425, 'test_unique_accuracy': 0.4861111111111111, 'test_unique_num_samples': 432} +[2026-04-16 05:00:09,803][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-16 05:00:09,803][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 05:00:25,002][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.292449951171875, 'accuracy': 0.4964705882352941, 'num_samples': 425, 'test_unique_accuracy': 0.5300925925925926, 'test_unique_num_samples': 432} +[2026-04-16 05:00:25,002][__main__][INFO] - ========== EVAL END (periodic@gstep=40000) ========== +[2026-04-16 05:00:25,003][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.297941207885742, 'accuracy': 0.4964705882352941, 'num_samples': 425, 'test_unique_accuracy': 0.5300925925925926, 'test_unique_num_samples': 432} +[2026-04-16 05:00:25,008][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.4964705882352941 is not better than 0.56 of logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep33000, skipping checkpoint +[2026-04-16 05:00:48,011][trainer.accelerators.base_accelerator][INFO] - Training progress: step=40050/100000 (40.05%), epoch=0, lr=1e-05, speed=1.952 step/s, elapsed=05:41:59, eta=08:31:54 +[2026-04-16 05:01:10,292][trainer.accelerators.base_accelerator][INFO] - Training progress: step=40100/100000 (40.10%), epoch=0, lr=1e-05, speed=1.952 step/s, elapsed=05:42:21, eta=08:31:24 +[2026-04-16 05:01:32,555][trainer.accelerators.base_accelerator][INFO] - Training progress: step=40150/100000 (40.15%), epoch=0, lr=1e-05, speed=1.952 step/s, elapsed=05:42:43, eta=08:30:53 +[2026-04-16 05:01:54,687][trainer.accelerators.base_accelerator][INFO] - Training progress: step=40200/100000 (40.20%), epoch=0, lr=1e-05, speed=1.953 step/s, elapsed=05:43:05, eta=08:30:22 +[2026-04-16 05:02:16,810][trainer.accelerators.base_accelerator][INFO] - Training progress: step=40250/100000 (40.25%), epoch=0, lr=1e-05, speed=1.953 step/s, elapsed=05:43:28, eta=08:29:52 +[2026-04-16 05:02:38,905][trainer.accelerators.base_accelerator][INFO] - Training progress: step=40300/100000 (40.30%), epoch=0, lr=1e-05, speed=1.953 step/s, elapsed=05:43:50, eta=08:29:21 +[2026-04-16 05:03:01,148][trainer.accelerators.base_accelerator][INFO] - Training progress: step=40350/100000 (40.35%), epoch=0, lr=1e-05, speed=1.954 step/s, elapsed=05:44:12, eta=08:28:50 +[2026-04-16 05:03:23,299][trainer.accelerators.base_accelerator][INFO] - Training progress: step=40400/100000 (40.40%), epoch=0, lr=1e-05, speed=1.954 step/s, elapsed=05:44:34, eta=08:28:20 +[2026-04-16 05:03:45,946][trainer.accelerators.base_accelerator][INFO] - Training progress: step=40450/100000 (40.45%), epoch=0, lr=1e-05, speed=1.954 step/s, elapsed=05:44:57, eta=08:27:50 +[2026-04-16 05:04:07,866][trainer.accelerators.base_accelerator][INFO] - Training progress: step=40500/100000 (40.50%), epoch=0, lr=1e-05, speed=1.955 step/s, elapsed=05:45:19, eta=08:27:19 +[2026-04-16 05:04:30,073][trainer.accelerators.base_accelerator][INFO] - Training progress: step=40550/100000 (40.55%), epoch=0, lr=1e-05, speed=1.955 step/s, elapsed=05:45:41, eta=08:26:48 +[2026-04-16 05:04:52,262][trainer.accelerators.base_accelerator][INFO] - Training progress: step=40600/100000 (40.60%), epoch=0, lr=1e-05, speed=1.955 step/s, elapsed=05:46:03, eta=08:26:18 +[2026-04-16 05:05:14,580][trainer.accelerators.base_accelerator][INFO] - Training progress: step=40650/100000 (40.65%), epoch=0, lr=1e-05, speed=1.956 step/s, elapsed=05:46:25, eta=08:25:47 +[2026-04-16 05:05:36,743][trainer.accelerators.base_accelerator][INFO] - Training progress: step=40700/100000 (40.70%), epoch=0, lr=1e-05, speed=1.956 step/s, elapsed=05:46:47, eta=08:25:17 +[2026-04-16 05:05:58,947][trainer.accelerators.base_accelerator][INFO] - Training progress: step=40750/100000 (40.75%), epoch=0, lr=1e-05, speed=1.956 step/s, elapsed=05:47:10, eta=08:24:46 +[2026-04-16 05:06:21,115][trainer.accelerators.base_accelerator][INFO] - Training progress: step=40800/100000 (40.80%), epoch=0, lr=1e-05, speed=1.957 step/s, elapsed=05:47:32, eta=08:24:16 +[2026-04-16 05:06:42,855][trainer.accelerators.base_accelerator][INFO] - Training progress: step=40850/100000 (40.85%), epoch=0, lr=1e-05, speed=1.957 step/s, elapsed=05:47:54, eta=08:23:45 +[2026-04-16 05:07:05,200][trainer.accelerators.base_accelerator][INFO] - Training progress: step=40900/100000 (40.90%), epoch=0, lr=1e-05, speed=1.957 step/s, elapsed=05:48:16, eta=08:23:15 +[2026-04-16 05:07:27,336][trainer.accelerators.base_accelerator][INFO] - Training progress: step=40950/100000 (40.95%), epoch=0, lr=1e-05, speed=1.958 step/s, elapsed=05:48:38, eta=08:22:44 +[2026-04-16 05:07:49,457][trainer.accelerators.base_accelerator][INFO] - Training progress: step=41000/100000 (41.00%), epoch=0, lr=1e-05, speed=1.958 step/s, elapsed=05:49:00, eta=08:22:14 +[2026-04-16 05:07:49,497][__main__][INFO] - ========== EVAL START (periodic@gstep=41000) ========== +[2026-04-16 05:07:49,497][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-16 05:07:49,497][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 05:08:04,671][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.297941207885742, 'accuracy': 0.5388235294117647, 'num_samples': 425, 'test_unique_accuracy': 0.5300925925925926, 'test_unique_num_samples': 432} +[2026-04-16 05:08:04,671][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-16 05:08:04,671][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 05:08:19,887][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.297941207885742, 'accuracy': 0.5388235294117647, 'num_samples': 425, 'test_unique_accuracy': 0.5, 'test_unique_num_samples': 432} +[2026-04-16 05:08:19,887][__main__][INFO] - ========== EVAL END (periodic@gstep=41000) ========== +[2026-04-16 05:08:19,887][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.303098678588867, 'accuracy': 0.5388235294117647, 'num_samples': 425, 'test_unique_accuracy': 0.5, 'test_unique_num_samples': 432} +[2026-04-16 05:08:19,891][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.5388235294117647 is not better than 0.56 of logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep33000, skipping checkpoint +[2026-04-16 05:08:41,992][trainer.accelerators.base_accelerator][INFO] - Training progress: step=41050/100000 (41.05%), epoch=0, lr=1e-05, speed=1.955 step/s, elapsed=05:49:53, eta=08:22:27 +[2026-04-16 05:09:04,118][trainer.accelerators.base_accelerator][INFO] - Training progress: step=41100/100000 (41.10%), epoch=0, lr=1e-05, speed=1.956 step/s, elapsed=05:50:15, eta=08:21:56 +[2026-04-16 05:09:26,210][trainer.accelerators.base_accelerator][INFO] - Training progress: step=41150/100000 (41.15%), epoch=0, lr=1e-05, speed=1.956 step/s, elapsed=05:50:37, eta=08:21:26 +[2026-04-16 05:09:48,488][trainer.accelerators.base_accelerator][INFO] - Training progress: step=41200/100000 (41.20%), epoch=0, lr=1e-05, speed=1.956 step/s, elapsed=05:50:59, eta=08:20:56 +[2026-04-16 05:10:10,982][trainer.accelerators.base_accelerator][INFO] - Training progress: step=41250/100000 (41.25%), epoch=0, lr=1e-05, speed=1.957 step/s, elapsed=05:51:22, eta=08:20:26 +[2026-04-16 05:10:33,093][trainer.accelerators.base_accelerator][INFO] - Training progress: step=41300/100000 (41.30%), epoch=0, lr=1e-05, speed=1.957 step/s, elapsed=05:51:44, eta=08:19:55 +[2026-04-16 05:10:55,252][trainer.accelerators.base_accelerator][INFO] - Training progress: step=41350/100000 (41.35%), epoch=0, lr=1e-05, speed=1.957 step/s, elapsed=05:52:06, eta=08:19:25 +[2026-04-16 05:11:17,246][trainer.accelerators.base_accelerator][INFO] - Training progress: step=41400/100000 (41.40%), epoch=0, lr=1e-05, speed=1.958 step/s, elapsed=05:52:28, eta=08:18:54 +[2026-04-16 05:11:39,774][trainer.accelerators.base_accelerator][INFO] - Training progress: step=41450/100000 (41.45%), epoch=0, lr=1e-05, speed=1.958 step/s, elapsed=05:52:51, eta=08:18:25 +[2026-04-16 05:12:01,852][trainer.accelerators.base_accelerator][INFO] - Training progress: step=41500/100000 (41.50%), epoch=0, lr=1e-05, speed=1.958 step/s, elapsed=05:53:13, eta=08:17:54 +[2026-04-16 05:12:24,005][trainer.accelerators.base_accelerator][INFO] - Training progress: step=41550/100000 (41.55%), epoch=0, lr=1e-05, speed=1.958 step/s, elapsed=05:53:35, eta=08:17:24 +[2026-04-16 05:12:46,024][trainer.accelerators.base_accelerator][INFO] - Training progress: step=41600/100000 (41.60%), epoch=0, lr=1e-05, speed=1.959 step/s, elapsed=05:53:57, eta=08:16:53 +[2026-04-16 05:13:08,398][trainer.accelerators.base_accelerator][INFO] - Training progress: step=41650/100000 (41.65%), epoch=0, lr=1e-05, speed=1.959 step/s, elapsed=05:54:19, eta=08:16:23 +[2026-04-16 05:13:30,450][trainer.accelerators.base_accelerator][INFO] - Training progress: step=41700/100000 (41.70%), epoch=0, lr=1e-05, speed=1.959 step/s, elapsed=05:54:41, eta=08:15:53 +[2026-04-16 05:13:52,553][trainer.accelerators.base_accelerator][INFO] - Training progress: step=41750/100000 (41.75%), epoch=0, lr=1e-05, speed=1.960 step/s, elapsed=05:55:03, eta=08:15:23 +[2026-04-16 05:14:14,594][trainer.accelerators.base_accelerator][INFO] - Training progress: step=41800/100000 (41.80%), epoch=0, lr=1e-05, speed=1.960 step/s, elapsed=05:55:25, eta=08:14:52 +[2026-04-16 05:14:36,677][trainer.accelerators.base_accelerator][INFO] - Training progress: step=41850/100000 (41.85%), epoch=0, lr=1e-05, speed=1.960 step/s, elapsed=05:55:47, eta=08:14:22 +[2026-04-16 05:14:59,621][trainer.accelerators.base_accelerator][INFO] - Training progress: step=41900/100000 (41.90%), epoch=0, lr=1e-05, speed=1.961 step/s, elapsed=05:56:10, eta=08:13:53 +[2026-04-16 05:15:21,778][trainer.accelerators.base_accelerator][INFO] - Training progress: step=41950/100000 (41.95%), epoch=0, lr=1e-05, speed=1.961 step/s, elapsed=05:56:33, eta=08:13:23 +[2026-04-16 05:15:43,879][trainer.accelerators.base_accelerator][INFO] - Training progress: step=42000/100000 (42.00%), epoch=0, lr=1e-05, speed=1.961 step/s, elapsed=05:56:55, eta=08:12:53 +[2026-04-16 05:15:43,917][__main__][INFO] - ========== EVAL START (periodic@gstep=42000) ========== +[2026-04-16 05:15:43,918][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-16 05:15:43,918][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 05:15:59,120][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.303098678588867, 'accuracy': 0.4988235294117647, 'num_samples': 425, 'test_unique_accuracy': 0.5, 'test_unique_num_samples': 432} +[2026-04-16 05:15:59,121][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-16 05:15:59,121][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 05:16:14,213][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.303098678588867, 'accuracy': 0.4988235294117647, 'num_samples': 425, 'test_unique_accuracy': 0.5231481481481481, 'test_unique_num_samples': 432} +[2026-04-16 05:16:14,213][__main__][INFO] - ========== EVAL END (periodic@gstep=42000) ========== +[2026-04-16 05:16:14,214][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.3103609085083, 'accuracy': 0.4988235294117647, 'num_samples': 425, 'test_unique_accuracy': 0.5231481481481481, 'test_unique_num_samples': 432} +[2026-04-16 05:16:14,219][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.4988235294117647 is not better than 0.56 of logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep33000, skipping checkpoint +[2026-04-16 05:16:36,342][trainer.accelerators.base_accelerator][INFO] - Training progress: step=42050/100000 (42.05%), epoch=0, lr=1e-05, speed=1.959 step/s, elapsed=05:57:47, eta=08:13:04 +[2026-04-16 05:16:58,559][trainer.accelerators.base_accelerator][INFO] - Training progress: step=42100/100000 (42.10%), epoch=0, lr=1e-05, speed=1.959 step/s, elapsed=05:58:09, eta=08:12:34 +[2026-04-16 05:17:20,689][trainer.accelerators.base_accelerator][INFO] - Training progress: step=42150/100000 (42.15%), epoch=0, lr=1e-05, speed=1.959 step/s, elapsed=05:58:31, eta=08:12:04 +[2026-04-16 05:17:42,812][trainer.accelerators.base_accelerator][INFO] - Training progress: step=42200/100000 (42.20%), epoch=0, lr=1e-05, speed=1.960 step/s, elapsed=05:58:54, eta=08:11:34 +[2026-04-16 05:18:05,380][trainer.accelerators.base_accelerator][INFO] - Training progress: step=42250/100000 (42.25%), epoch=0, lr=1e-05, speed=1.960 step/s, elapsed=05:59:16, eta=08:11:04 +[2026-04-16 05:18:27,616][trainer.accelerators.base_accelerator][INFO] - Training progress: step=42300/100000 (42.30%), epoch=0, lr=1e-05, speed=1.960 step/s, elapsed=05:59:38, eta=08:10:35 +[2026-04-16 05:18:49,792][trainer.accelerators.base_accelerator][INFO] - Training progress: step=42350/100000 (42.35%), epoch=0, lr=1e-05, speed=1.961 step/s, elapsed=06:00:01, eta=08:10:04 +[2026-04-16 05:19:11,955][trainer.accelerators.base_accelerator][INFO] - Training progress: step=42400/100000 (42.40%), epoch=0, lr=1e-05, speed=1.961 step/s, elapsed=06:00:23, eta=08:09:34 +[2026-04-16 05:19:34,069][trainer.accelerators.base_accelerator][INFO] - Training progress: step=42450/100000 (42.45%), epoch=0, lr=1e-05, speed=1.961 step/s, elapsed=06:00:45, eta=08:09:04 +[2026-04-16 05:19:56,185][trainer.accelerators.base_accelerator][INFO] - Training progress: step=42500/100000 (42.50%), epoch=0, lr=1e-05, speed=1.961 step/s, elapsed=06:01:07, eta=08:08:34 +[2026-04-16 05:20:18,285][trainer.accelerators.base_accelerator][INFO] - Training progress: step=42550/100000 (42.55%), epoch=0, lr=1e-05, speed=1.962 step/s, elapsed=06:01:29, eta=08:08:04 +[2026-04-16 05:20:40,435][trainer.accelerators.base_accelerator][INFO] - Training progress: step=42600/100000 (42.60%), epoch=0, lr=1e-05, speed=1.962 step/s, elapsed=06:01:51, eta=08:07:34 +[2026-04-16 05:21:02,535][trainer.accelerators.base_accelerator][INFO] - Training progress: step=42650/100000 (42.65%), epoch=0, lr=1e-05, speed=1.962 step/s, elapsed=06:02:13, eta=08:07:04 +[2026-04-16 05:21:24,654][trainer.accelerators.base_accelerator][INFO] - Training progress: step=42700/100000 (42.70%), epoch=0, lr=1e-05, speed=1.963 step/s, elapsed=06:02:35, eta=08:06:34 +[2026-04-16 05:21:46,833][trainer.accelerators.base_accelerator][INFO] - Training progress: step=42750/100000 (42.75%), epoch=0, lr=1e-05, speed=1.963 step/s, elapsed=06:02:58, eta=08:06:04 +[2026-04-16 05:22:08,940][trainer.accelerators.base_accelerator][INFO] - Training progress: step=42800/100000 (42.80%), epoch=0, lr=1e-05, speed=1.963 step/s, elapsed=06:03:20, eta=08:05:34 +[2026-04-16 05:22:30,993][trainer.accelerators.base_accelerator][INFO] - Training progress: step=42850/100000 (42.85%), epoch=0, lr=1e-05, speed=1.964 step/s, elapsed=06:03:42, eta=08:05:04 +[2026-04-16 05:22:53,458][trainer.accelerators.base_accelerator][INFO] - Training progress: step=42900/100000 (42.90%), epoch=0, lr=1e-05, speed=1.964 step/s, elapsed=06:04:04, eta=08:04:35 +[2026-04-16 05:23:15,606][trainer.accelerators.base_accelerator][INFO] - Training progress: step=42950/100000 (42.95%), epoch=0, lr=1e-05, speed=1.964 step/s, elapsed=06:04:26, eta=08:04:05 +[2026-04-16 05:23:37,765][trainer.accelerators.base_accelerator][INFO] - Training progress: step=43000/100000 (43.00%), epoch=0, lr=1e-05, speed=1.964 step/s, elapsed=06:04:49, eta=08:03:35 +[2026-04-16 05:23:37,805][__main__][INFO] - ========== EVAL START (periodic@gstep=43000) ========== +[2026-04-16 05:23:37,805][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-16 05:23:37,805][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 05:23:53,135][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.3103609085083, 'accuracy': 0.4682352941176471, 'num_samples': 425, 'test_unique_accuracy': 0.5231481481481481, 'test_unique_num_samples': 432} +[2026-04-16 05:23:53,135][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-16 05:23:53,135][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 05:24:08,314][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.3103609085083, 'accuracy': 0.4682352941176471, 'num_samples': 425, 'test_unique_accuracy': 0.5208333333333334, 'test_unique_num_samples': 432} +[2026-04-16 05:24:08,315][__main__][INFO] - ========== EVAL END (periodic@gstep=43000) ========== +[2026-04-16 05:24:08,315][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.32117748260498, 'accuracy': 0.4682352941176471, 'num_samples': 425, 'test_unique_accuracy': 0.5208333333333334, 'test_unique_num_samples': 432} +[2026-04-16 05:24:08,321][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.4682352941176471 is not better than 0.56 of logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep33000, skipping checkpoint +[2026-04-16 05:24:30,390][trainer.accelerators.base_accelerator][INFO] - Training progress: step=43050/100000 (43.05%), epoch=0, lr=1e-05, speed=1.962 step/s, elapsed=06:05:41, eta=08:03:46 +[2026-04-16 05:24:52,486][trainer.accelerators.base_accelerator][INFO] - Training progress: step=43100/100000 (43.10%), epoch=0, lr=1e-05, speed=1.962 step/s, elapsed=06:06:03, eta=08:03:16 +[2026-04-16 05:25:14,654][trainer.accelerators.base_accelerator][INFO] - Training progress: step=43150/100000 (43.15%), epoch=0, lr=1e-05, speed=1.963 step/s, elapsed=06:06:25, eta=08:02:46 +[2026-04-16 05:25:36,771][trainer.accelerators.base_accelerator][INFO] - Training progress: step=43200/100000 (43.20%), epoch=0, lr=1e-05, speed=1.963 step/s, elapsed=06:06:48, eta=08:02:16 +[2026-04-16 05:25:58,957][trainer.accelerators.base_accelerator][INFO] - Training progress: step=43250/100000 (43.25%), epoch=0, lr=1e-05, speed=1.963 step/s, elapsed=06:07:10, eta=08:01:46 +[2026-04-16 05:26:21,108][trainer.accelerators.base_accelerator][INFO] - Training progress: step=43300/100000 (43.30%), epoch=0, lr=1e-05, speed=1.964 step/s, elapsed=06:07:32, eta=08:01:16 +[2026-04-16 05:26:43,468][trainer.accelerators.base_accelerator][INFO] - Training progress: step=43350/100000 (43.35%), epoch=0, lr=1e-05, speed=1.964 step/s, elapsed=06:07:54, eta=08:00:47 +[2026-04-16 05:27:05,550][trainer.accelerators.base_accelerator][INFO] - Training progress: step=43400/100000 (43.40%), epoch=0, lr=1e-05, speed=1.964 step/s, elapsed=06:08:16, eta=08:00:17 +[2026-04-16 05:27:27,670][trainer.accelerators.base_accelerator][INFO] - Training progress: step=43450/100000 (43.45%), epoch=0, lr=1e-05, speed=1.964 step/s, elapsed=06:08:38, eta=07:59:47 +[2026-04-16 05:27:49,755][trainer.accelerators.base_accelerator][INFO] - Training progress: step=43500/100000 (43.50%), epoch=0, lr=1e-05, speed=1.965 step/s, elapsed=06:09:01, eta=07:59:17 +[2026-04-16 05:28:11,836][trainer.accelerators.base_accelerator][INFO] - Training progress: step=43550/100000 (43.55%), epoch=0, lr=1e-05, speed=1.965 step/s, elapsed=06:09:23, eta=07:58:48 +[2026-04-16 05:28:33,920][trainer.accelerators.base_accelerator][INFO] - Training progress: step=43600/100000 (43.60%), epoch=0, lr=1e-05, speed=1.965 step/s, elapsed=06:09:45, eta=07:58:18 +[2026-04-16 05:28:56,015][trainer.accelerators.base_accelerator][INFO] - Training progress: step=43650/100000 (43.65%), epoch=0, lr=1e-05, speed=1.966 step/s, elapsed=06:10:07, eta=07:57:48 +[2026-04-16 05:29:18,112][trainer.accelerators.base_accelerator][INFO] - Training progress: step=43700/100000 (43.70%), epoch=0, lr=1e-05, speed=1.966 step/s, elapsed=06:10:29, eta=07:57:18 +[2026-04-16 05:29:40,296][trainer.accelerators.base_accelerator][INFO] - Training progress: step=43750/100000 (43.75%), epoch=0, lr=1e-05, speed=1.966 step/s, elapsed=06:10:51, eta=07:56:49 +[2026-04-16 05:30:02,307][trainer.accelerators.base_accelerator][INFO] - Training progress: step=43800/100000 (43.80%), epoch=0, lr=1e-05, speed=1.966 step/s, elapsed=06:11:13, eta=07:56:19 +[2026-04-16 05:30:24,662][trainer.accelerators.base_accelerator][INFO] - Training progress: step=43850/100000 (43.85%), epoch=0, lr=1e-05, speed=1.967 step/s, elapsed=06:11:35, eta=07:55:49 +[2026-04-16 05:30:46,800][trainer.accelerators.base_accelerator][INFO] - Training progress: step=43900/100000 (43.90%), epoch=0, lr=1e-05, speed=1.967 step/s, elapsed=06:11:58, eta=07:55:20 +[2026-04-16 05:31:08,925][trainer.accelerators.base_accelerator][INFO] - Training progress: step=43950/100000 (43.95%), epoch=0, lr=1e-05, speed=1.967 step/s, elapsed=06:12:20, eta=07:54:50 +[2026-04-16 05:31:30,965][trainer.accelerators.base_accelerator][INFO] - Training progress: step=44000/100000 (44.00%), epoch=0, lr=1e-05, speed=1.968 step/s, elapsed=06:12:42, eta=07:54:21 +[2026-04-16 05:31:31,003][__main__][INFO] - ========== EVAL START (periodic@gstep=44000) ========== +[2026-04-16 05:31:31,004][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-16 05:31:31,004][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 05:31:46,043][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.32117748260498, 'accuracy': 0.46588235294117647, 'num_samples': 425, 'test_unique_accuracy': 0.5208333333333334, 'test_unique_num_samples': 432} +[2026-04-16 05:31:46,043][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-16 05:31:46,043][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 05:32:01,159][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.32117748260498, 'accuracy': 0.46588235294117647, 'num_samples': 425, 'test_unique_accuracy': 0.48842592592592593, 'test_unique_num_samples': 432} +[2026-04-16 05:32:01,159][__main__][INFO] - ========== EVAL END (periodic@gstep=44000) ========== +[2026-04-16 05:32:01,159][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.323163986206055, 'accuracy': 0.46588235294117647, 'num_samples': 425, 'test_unique_accuracy': 0.48842592592592593, 'test_unique_num_samples': 432} +[2026-04-16 05:32:01,163][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.46588235294117647 is not better than 0.56 of logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep33000, skipping checkpoint +[2026-04-16 05:32:23,252][trainer.accelerators.base_accelerator][INFO] - Training progress: step=44050/100000 (44.05%), epoch=0, lr=1e-05, speed=1.965 step/s, elapsed=06:13:34, eta=07:54:29 +[2026-04-16 05:32:45,345][trainer.accelerators.base_accelerator][INFO] - Training progress: step=44100/100000 (44.10%), epoch=0, lr=1e-05, speed=1.966 step/s, elapsed=06:13:56, eta=07:54:00 +[2026-04-16 05:33:07,762][trainer.accelerators.base_accelerator][INFO] - Training progress: step=44150/100000 (44.15%), epoch=0, lr=1e-05, speed=1.966 step/s, elapsed=06:14:19, eta=07:53:30 +[2026-04-16 05:33:29,883][trainer.accelerators.base_accelerator][INFO] - Training progress: step=44200/100000 (44.20%), epoch=0, lr=1e-05, speed=1.966 step/s, elapsed=06:14:41, eta=07:53:01 +[2026-04-16 05:33:52,015][trainer.accelerators.base_accelerator][INFO] - Training progress: step=44250/100000 (44.25%), epoch=0, lr=1e-05, speed=1.966 step/s, elapsed=06:15:03, eta=07:52:31 +[2026-04-16 05:34:00,852][trainer.accelerators.base_accelerator][INFO] - Epoch 0 finished +[2026-04-16 05:34:15,257][trainer.accelerators.base_accelerator][INFO] - Training progress: step=44300/100000 (44.30%), epoch=1, lr=1e-05, speed=1.967 step/s, elapsed=06:15:26, eta=07:52:03 +[2026-04-16 05:34:37,339][trainer.accelerators.base_accelerator][INFO] - Training progress: step=44350/100000 (44.35%), epoch=1, lr=1e-05, speed=1.967 step/s, elapsed=06:15:48, eta=07:51:33 +[2026-04-16 05:34:59,933][trainer.accelerators.base_accelerator][INFO] - Training progress: step=44400/100000 (44.40%), epoch=1, lr=1e-05, speed=1.967 step/s, elapsed=06:16:11, eta=07:51:04 +[2026-04-16 05:35:21,957][trainer.accelerators.base_accelerator][INFO] - Training progress: step=44450/100000 (44.45%), epoch=1, lr=1e-05, speed=1.967 step/s, elapsed=06:16:33, eta=07:50:35 +[2026-04-16 05:35:44,128][trainer.accelerators.base_accelerator][INFO] - Training progress: step=44500/100000 (44.50%), epoch=1, lr=1e-05, speed=1.968 step/s, elapsed=06:16:55, eta=07:50:05 +[2026-04-16 05:36:06,232][trainer.accelerators.base_accelerator][INFO] - Training progress: step=44550/100000 (44.55%), epoch=1, lr=1e-05, speed=1.968 step/s, elapsed=06:17:17, eta=07:49:36 +[2026-04-16 05:36:28,586][trainer.accelerators.base_accelerator][INFO] - Training progress: step=44600/100000 (44.60%), epoch=1, lr=1e-05, speed=1.968 step/s, elapsed=06:17:39, eta=07:49:06 +[2026-04-16 05:36:50,643][trainer.accelerators.base_accelerator][INFO] - Training progress: step=44650/100000 (44.65%), epoch=1, lr=1e-05, speed=1.969 step/s, elapsed=06:18:01, eta=07:48:37 +[2026-04-16 05:37:12,763][trainer.accelerators.base_accelerator][INFO] - Training progress: step=44700/100000 (44.70%), epoch=1, lr=1e-05, speed=1.969 step/s, elapsed=06:18:24, eta=07:48:07 +[2026-04-16 05:37:34,868][trainer.accelerators.base_accelerator][INFO] - Training progress: step=44750/100000 (44.75%), epoch=1, lr=1e-05, speed=1.969 step/s, elapsed=06:18:46, eta=07:47:38 +[2026-04-16 05:37:56,991][trainer.accelerators.base_accelerator][INFO] - Training progress: step=44800/100000 (44.80%), epoch=1, lr=1e-05, speed=1.969 step/s, elapsed=06:19:08, eta=07:47:09 +[2026-04-16 05:38:19,369][trainer.accelerators.base_accelerator][INFO] - Training progress: step=44850/100000 (44.85%), epoch=1, lr=1e-05, speed=1.970 step/s, elapsed=06:19:30, eta=07:46:39 +[2026-04-16 05:38:41,517][trainer.accelerators.base_accelerator][INFO] - Training progress: step=44900/100000 (44.90%), epoch=1, lr=1e-05, speed=1.970 step/s, elapsed=06:19:52, eta=07:46:10 +[2026-04-16 05:39:03,410][trainer.accelerators.base_accelerator][INFO] - Training progress: step=44950/100000 (44.95%), epoch=1, lr=1e-05, speed=1.970 step/s, elapsed=06:20:14, eta=07:45:40 +[2026-04-16 05:39:25,515][trainer.accelerators.base_accelerator][INFO] - Training progress: step=45000/100000 (45.00%), epoch=1, lr=1e-05, speed=1.971 step/s, elapsed=06:20:36, eta=07:45:11 +[2026-04-16 05:39:25,556][__main__][INFO] - ========== EVAL START (periodic@gstep=45000) ========== +[2026-04-16 05:39:25,556][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-16 05:39:25,556][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 05:39:40,717][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.323163986206055, 'accuracy': 0.508235294117647, 'num_samples': 425, 'test_unique_accuracy': 0.48842592592592593, 'test_unique_num_samples': 432} +[2026-04-16 05:39:40,718][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-16 05:39:40,718][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 05:39:55,934][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.323163986206055, 'accuracy': 0.508235294117647, 'num_samples': 425, 'test_unique_accuracy': 0.4930555555555556, 'test_unique_num_samples': 432} +[2026-04-16 05:39:55,934][__main__][INFO] - ========== EVAL END (periodic@gstep=45000) ========== +[2026-04-16 05:39:55,934][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.353041648864746, 'accuracy': 0.508235294117647, 'num_samples': 425, 'test_unique_accuracy': 0.4930555555555556, 'test_unique_num_samples': 432} +[2026-04-16 05:39:55,937][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.508235294117647 is not better than 0.56 of logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep33000, skipping checkpoint +[2026-04-16 05:40:18,022][trainer.accelerators.base_accelerator][INFO] - Training progress: step=45050/100000 (45.05%), epoch=1, lr=1e-05, speed=1.968 step/s, elapsed=06:21:29, eta=07:45:19 +[2026-04-16 05:40:40,202][trainer.accelerators.base_accelerator][INFO] - Training progress: step=45100/100000 (45.10%), epoch=1, lr=1e-05, speed=1.968 step/s, elapsed=06:21:51, eta=07:44:49 +[2026-04-16 05:41:02,655][trainer.accelerators.base_accelerator][INFO] - Training progress: step=45150/100000 (45.15%), epoch=1, lr=1e-05, speed=1.969 step/s, elapsed=06:22:13, eta=07:44:21 +[2026-04-16 05:41:24,787][trainer.accelerators.base_accelerator][INFO] - Training progress: step=45200/100000 (45.20%), epoch=1, lr=1e-05, speed=1.969 step/s, elapsed=06:22:36, eta=07:43:51 +[2026-04-16 05:41:46,961][trainer.accelerators.base_accelerator][INFO] - Training progress: step=45250/100000 (45.25%), epoch=1, lr=1e-05, speed=1.969 step/s, elapsed=06:22:58, eta=07:43:22 +[2026-04-16 05:42:09,024][trainer.accelerators.base_accelerator][INFO] - Training progress: step=45300/100000 (45.30%), epoch=1, lr=1e-05, speed=1.970 step/s, elapsed=06:23:20, eta=07:42:52 +[2026-04-16 05:42:31,064][trainer.accelerators.base_accelerator][INFO] - Training progress: step=45350/100000 (45.35%), epoch=1, lr=1e-05, speed=1.970 step/s, elapsed=06:23:42, eta=07:42:23 +[2026-04-16 05:42:53,136][trainer.accelerators.base_accelerator][INFO] - Training progress: step=45400/100000 (45.40%), epoch=1, lr=1e-05, speed=1.970 step/s, elapsed=06:24:04, eta=07:41:54 +[2026-04-16 05:43:15,280][trainer.accelerators.base_accelerator][INFO] - Training progress: step=45450/100000 (45.45%), epoch=1, lr=1e-05, speed=1.970 step/s, elapsed=06:24:26, eta=07:41:24 +[2026-04-16 05:43:37,387][trainer.accelerators.base_accelerator][INFO] - Training progress: step=45500/100000 (45.50%), epoch=1, lr=1e-05, speed=1.971 step/s, elapsed=06:24:48, eta=07:40:55 +[2026-04-16 05:43:59,471][trainer.accelerators.base_accelerator][INFO] - Training progress: step=45550/100000 (45.55%), epoch=1, lr=1e-05, speed=1.971 step/s, elapsed=06:25:10, eta=07:40:26 +[2026-04-16 05:44:21,578][trainer.accelerators.base_accelerator][INFO] - Training progress: step=45600/100000 (45.60%), epoch=1, lr=1e-05, speed=1.971 step/s, elapsed=06:25:32, eta=07:39:57 +[2026-04-16 05:44:43,641][trainer.accelerators.base_accelerator][INFO] - Training progress: step=45650/100000 (45.65%), epoch=1, lr=1e-05, speed=1.972 step/s, elapsed=06:25:54, eta=07:39:27 +[2026-04-16 05:45:05,771][trainer.accelerators.base_accelerator][INFO] - Training progress: step=45700/100000 (45.70%), epoch=1, lr=1e-05, speed=1.972 step/s, elapsed=06:26:17, eta=07:38:58 +[2026-04-16 05:45:27,765][trainer.accelerators.base_accelerator][INFO] - Training progress: step=45750/100000 (45.75%), epoch=1, lr=1e-05, speed=1.972 step/s, elapsed=06:26:39, eta=07:38:29 +[2026-04-16 05:45:50,145][trainer.accelerators.base_accelerator][INFO] - Training progress: step=45800/100000 (45.80%), epoch=1, lr=1e-05, speed=1.972 step/s, elapsed=06:27:01, eta=07:38:00 +[2026-04-16 05:46:12,133][trainer.accelerators.base_accelerator][INFO] - Training progress: step=45850/100000 (45.85%), epoch=1, lr=1e-05, speed=1.973 step/s, elapsed=06:27:23, eta=07:37:31 +[2026-04-16 05:46:34,224][trainer.accelerators.base_accelerator][INFO] - Training progress: step=45900/100000 (45.90%), epoch=1, lr=1e-05, speed=1.973 step/s, elapsed=06:27:45, eta=07:37:01 +[2026-04-16 05:46:56,336][trainer.accelerators.base_accelerator][INFO] - Training progress: step=45950/100000 (45.95%), epoch=1, lr=1e-05, speed=1.973 step/s, elapsed=06:28:07, eta=07:36:32 +[2026-04-16 05:47:18,485][trainer.accelerators.base_accelerator][INFO] - Training progress: step=46000/100000 (46.00%), epoch=1, lr=1e-05, speed=1.973 step/s, elapsed=06:28:29, eta=07:36:03 +[2026-04-16 05:47:18,523][__main__][INFO] - ========== EVAL START (periodic@gstep=46000) ========== +[2026-04-16 05:47:18,523][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-16 05:47:18,523][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 05:47:33,616][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.353041648864746, 'accuracy': 0.4541176470588235, 'num_samples': 425, 'test_unique_accuracy': 0.4930555555555556, 'test_unique_num_samples': 432} +[2026-04-16 05:47:33,616][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-16 05:47:33,616][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 05:47:48,738][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.353041648864746, 'accuracy': 0.4541176470588235, 'num_samples': 425, 'test_unique_accuracy': 0.45601851851851855, 'test_unique_num_samples': 432} +[2026-04-16 05:47:48,738][__main__][INFO] - ========== EVAL END (periodic@gstep=46000) ========== +[2026-04-16 05:47:48,738][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.394274711608887, 'accuracy': 0.4541176470588235, 'num_samples': 425, 'test_unique_accuracy': 0.45601851851851855, 'test_unique_num_samples': 432} +[2026-04-16 05:47:48,742][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.4541176470588235 is not better than 0.56 of logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep33000, skipping checkpoint +[2026-04-16 05:48:10,804][trainer.accelerators.base_accelerator][INFO] - Training progress: step=46050/100000 (46.05%), epoch=1, lr=1e-05, speed=1.971 step/s, elapsed=06:29:22, eta=07:36:09 +[2026-04-16 05:48:32,939][trainer.accelerators.base_accelerator][INFO] - Training progress: step=46100/100000 (46.10%), epoch=1, lr=1e-05, speed=1.971 step/s, elapsed=06:29:44, eta=07:35:40 +[2026-04-16 05:48:55,333][trainer.accelerators.base_accelerator][INFO] - Training progress: step=46150/100000 (46.15%), epoch=1, lr=1e-05, speed=1.972 step/s, elapsed=06:30:06, eta=07:35:11 +[2026-04-16 05:49:17,462][trainer.accelerators.base_accelerator][INFO] - Training progress: step=46200/100000 (46.20%), epoch=1, lr=1e-05, speed=1.972 step/s, elapsed=06:30:28, eta=07:34:42 +[2026-04-16 05:49:39,630][trainer.accelerators.base_accelerator][INFO] - Training progress: step=46250/100000 (46.25%), epoch=1, lr=1e-05, speed=1.972 step/s, elapsed=06:30:50, eta=07:34:13 +[2026-04-16 05:50:01,803][trainer.accelerators.base_accelerator][INFO] - Training progress: step=46300/100000 (46.30%), epoch=1, lr=1e-05, speed=1.972 step/s, elapsed=06:31:13, eta=07:33:44 +[2026-04-16 05:50:23,981][trainer.accelerators.base_accelerator][INFO] - Training progress: step=46350/100000 (46.35%), epoch=1, lr=1e-05, speed=1.973 step/s, elapsed=06:31:35, eta=07:33:15 +[2026-04-16 05:50:46,370][trainer.accelerators.base_accelerator][INFO] - Training progress: step=46400/100000 (46.40%), epoch=1, lr=1e-05, speed=1.973 step/s, elapsed=06:31:57, eta=07:32:46 +[2026-04-16 05:51:08,406][trainer.accelerators.base_accelerator][INFO] - Training progress: step=46450/100000 (46.45%), epoch=1, lr=1e-05, speed=1.973 step/s, elapsed=06:32:19, eta=07:32:17 +[2026-04-16 05:51:30,500][trainer.accelerators.base_accelerator][INFO] - Training progress: step=46500/100000 (46.50%), epoch=1, lr=1e-05, speed=1.974 step/s, elapsed=06:32:41, eta=07:31:48 +[2026-04-16 05:51:52,606][trainer.accelerators.base_accelerator][INFO] - Training progress: step=46550/100000 (46.55%), epoch=1, lr=1e-05, speed=1.974 step/s, elapsed=06:33:03, eta=07:31:19 +[2026-04-16 05:52:14,733][trainer.accelerators.base_accelerator][INFO] - Training progress: step=46600/100000 (46.60%), epoch=1, lr=1e-05, speed=1.974 step/s, elapsed=06:33:25, eta=07:30:50 +[2026-04-16 05:52:36,846][trainer.accelerators.base_accelerator][INFO] - Training progress: step=46650/100000 (46.65%), epoch=1, lr=1e-05, speed=1.974 step/s, elapsed=06:33:48, eta=07:30:21 +[2026-04-16 05:52:59,289][trainer.accelerators.base_accelerator][INFO] - Training progress: step=46700/100000 (46.70%), epoch=1, lr=1e-05, speed=1.975 step/s, elapsed=06:34:10, eta=07:29:53 +[2026-04-16 05:53:21,430][trainer.accelerators.base_accelerator][INFO] - Training progress: step=46750/100000 (46.75%), epoch=1, lr=1e-05, speed=1.975 step/s, elapsed=06:34:32, eta=07:29:24 +[2026-04-16 05:53:43,619][trainer.accelerators.base_accelerator][INFO] - Training progress: step=46800/100000 (46.80%), epoch=1, lr=1e-05, speed=1.975 step/s, elapsed=06:34:54, eta=07:28:55 +[2026-04-16 05:54:05,738][trainer.accelerators.base_accelerator][INFO] - Training progress: step=46850/100000 (46.85%), epoch=1, lr=1e-05, speed=1.975 step/s, elapsed=06:35:16, eta=07:28:26 +[2026-04-16 05:54:27,926][trainer.accelerators.base_accelerator][INFO] - Training progress: step=46900/100000 (46.90%), epoch=1, lr=1e-05, speed=1.976 step/s, elapsed=06:35:39, eta=07:27:57 +[2026-04-16 05:54:50,279][trainer.accelerators.base_accelerator][INFO] - Training progress: step=46950/100000 (46.95%), epoch=1, lr=1e-05, speed=1.976 step/s, elapsed=06:36:01, eta=07:27:28 +[2026-04-16 05:55:12,428][trainer.accelerators.base_accelerator][INFO] - Training progress: step=47000/100000 (47.00%), epoch=1, lr=1e-05, speed=1.976 step/s, elapsed=06:36:23, eta=07:26:59 +[2026-04-16 05:55:12,467][__main__][INFO] - ========== EVAL START (periodic@gstep=47000) ========== +[2026-04-16 05:55:12,467][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-16 05:55:12,468][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 05:55:27,518][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.394274711608887, 'accuracy': 0.4752941176470588, 'num_samples': 425, 'test_unique_accuracy': 0.45601851851851855, 'test_unique_num_samples': 432} +[2026-04-16 05:55:27,518][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-16 05:55:27,518][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 05:55:42,630][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.394274711608887, 'accuracy': 0.4752941176470588, 'num_samples': 425, 'test_unique_accuracy': 0.5069444444444444, 'test_unique_num_samples': 432} +[2026-04-16 05:55:42,630][__main__][INFO] - ========== EVAL END (periodic@gstep=47000) ========== +[2026-04-16 05:55:42,630][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.436563491821289, 'accuracy': 0.4752941176470588, 'num_samples': 425, 'test_unique_accuracy': 0.5069444444444444, 'test_unique_num_samples': 432} +[2026-04-16 05:55:42,633][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.4752941176470588 is not better than 0.56 of logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep33000, skipping checkpoint +[2026-04-16 05:56:04,576][trainer.accelerators.base_accelerator][INFO] - Training progress: step=47050/100000 (47.05%), epoch=1, lr=1e-05, speed=1.974 step/s, elapsed=06:37:15, eta=07:27:04 +[2026-04-16 05:56:26,683][trainer.accelerators.base_accelerator][INFO] - Training progress: step=47100/100000 (47.10%), epoch=1, lr=1e-05, speed=1.974 step/s, elapsed=06:37:37, eta=07:26:35 +[2026-04-16 05:56:48,807][trainer.accelerators.base_accelerator][INFO] - Training progress: step=47150/100000 (47.15%), epoch=1, lr=1e-05, speed=1.974 step/s, elapsed=06:38:00, eta=07:26:06 +[2026-04-16 05:57:10,891][trainer.accelerators.base_accelerator][INFO] - Training progress: step=47200/100000 (47.20%), epoch=1, lr=1e-05, speed=1.975 step/s, elapsed=06:38:22, eta=07:25:37 +[2026-04-16 05:57:33,015][trainer.accelerators.base_accelerator][INFO] - Training progress: step=47250/100000 (47.25%), epoch=1, lr=1e-05, speed=1.975 step/s, elapsed=06:38:44, eta=07:25:09 +[2026-04-16 05:57:55,097][trainer.accelerators.base_accelerator][INFO] - Training progress: step=47300/100000 (47.30%), epoch=1, lr=1e-05, speed=1.975 step/s, elapsed=06:39:06, eta=07:24:40 +[2026-04-16 05:58:17,163][trainer.accelerators.base_accelerator][INFO] - Training progress: step=47350/100000 (47.35%), epoch=1, lr=1e-05, speed=1.976 step/s, elapsed=06:39:28, eta=07:24:11 +[2026-04-16 05:58:39,574][trainer.accelerators.base_accelerator][INFO] - Training progress: step=47400/100000 (47.40%), epoch=1, lr=1e-05, speed=1.976 step/s, elapsed=06:39:50, eta=07:23:42 +[2026-04-16 05:59:01,678][trainer.accelerators.base_accelerator][INFO] - Training progress: step=47450/100000 (47.45%), epoch=1, lr=1e-05, speed=1.976 step/s, elapsed=06:40:12, eta=07:23:13 +[2026-04-16 05:59:23,667][trainer.accelerators.base_accelerator][INFO] - Training progress: step=47500/100000 (47.50%), epoch=1, lr=1e-05, speed=1.976 step/s, elapsed=06:40:34, eta=07:22:44 +[2026-04-16 05:59:45,742][trainer.accelerators.base_accelerator][INFO] - Training progress: step=47550/100000 (47.55%), epoch=1, lr=1e-05, speed=1.977 step/s, elapsed=06:40:56, eta=07:22:16 +[2026-04-16 06:00:07,863][trainer.accelerators.base_accelerator][INFO] - Training progress: step=47600/100000 (47.60%), epoch=1, lr=1e-05, speed=1.977 step/s, elapsed=06:41:19, eta=07:21:47 +[2026-04-16 06:00:29,938][trainer.accelerators.base_accelerator][INFO] - Training progress: step=47650/100000 (47.65%), epoch=1, lr=1e-05, speed=1.977 step/s, elapsed=06:41:41, eta=07:21:18 +[2026-04-16 06:00:51,992][trainer.accelerators.base_accelerator][INFO] - Training progress: step=47700/100000 (47.70%), epoch=1, lr=1e-05, speed=1.977 step/s, elapsed=06:42:03, eta=07:20:49 +[2026-04-16 06:01:14,087][trainer.accelerators.base_accelerator][INFO] - Training progress: step=47750/100000 (47.75%), epoch=1, lr=1e-05, speed=1.978 step/s, elapsed=06:42:25, eta=07:20:20 +[2026-04-16 06:01:36,228][trainer.accelerators.base_accelerator][INFO] - Training progress: step=47800/100000 (47.80%), epoch=1, lr=1e-05, speed=1.978 step/s, elapsed=06:42:47, eta=07:19:52 +[2026-04-16 06:01:58,193][trainer.accelerators.base_accelerator][INFO] - Training progress: step=47850/100000 (47.85%), epoch=1, lr=1e-05, speed=1.978 step/s, elapsed=06:43:09, eta=07:19:23 +[2026-04-16 06:02:20,216][trainer.accelerators.base_accelerator][INFO] - Training progress: step=47900/100000 (47.90%), epoch=1, lr=1e-05, speed=1.978 step/s, elapsed=06:43:31, eta=07:18:54 +[2026-04-16 06:02:42,309][trainer.accelerators.base_accelerator][INFO] - Training progress: step=47950/100000 (47.95%), epoch=1, lr=1e-05, speed=1.979 step/s, elapsed=06:43:53, eta=07:18:25 +[2026-04-16 06:03:04,595][trainer.accelerators.base_accelerator][INFO] - Training progress: step=48000/100000 (48.00%), epoch=1, lr=1e-05, speed=1.979 step/s, elapsed=06:44:15, eta=07:17:57 +[2026-04-16 06:03:04,634][__main__][INFO] - ========== EVAL START (periodic@gstep=48000) ========== +[2026-04-16 06:03:04,634][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-16 06:03:04,635][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 06:03:19,766][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.436563491821289, 'accuracy': 0.45647058823529413, 'num_samples': 425, 'test_unique_accuracy': 0.5069444444444444, 'test_unique_num_samples': 432} +[2026-04-16 06:03:19,766][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-16 06:03:19,766][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 06:03:34,973][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.436563491821289, 'accuracy': 0.45647058823529413, 'num_samples': 425, 'test_unique_accuracy': 0.48842592592592593, 'test_unique_num_samples': 432} +[2026-04-16 06:03:34,973][__main__][INFO] - ========== EVAL END (periodic@gstep=48000) ========== +[2026-04-16 06:03:34,973][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.471385955810547, 'accuracy': 0.45647058823529413, 'num_samples': 425, 'test_unique_accuracy': 0.48842592592592593, 'test_unique_num_samples': 432} +[2026-04-16 06:03:34,976][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.45647058823529413 is not better than 0.56 of logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep33000, skipping checkpoint +[2026-04-16 06:03:57,084][trainer.accelerators.base_accelerator][INFO] - Training progress: step=48050/100000 (48.05%), epoch=1, lr=1e-05, speed=1.977 step/s, elapsed=06:45:08, eta=07:18:01 +[2026-04-16 06:04:19,264][trainer.accelerators.base_accelerator][INFO] - Training progress: step=48100/100000 (48.10%), epoch=1, lr=1e-05, speed=1.977 step/s, elapsed=06:45:30, eta=07:17:32 +[2026-04-16 06:04:41,311][trainer.accelerators.base_accelerator][INFO] - Training progress: step=48150/100000 (48.15%), epoch=1, lr=1e-05, speed=1.977 step/s, elapsed=06:45:52, eta=07:17:03 +[2026-04-16 06:05:03,463][trainer.accelerators.base_accelerator][INFO] - Training progress: step=48200/100000 (48.20%), epoch=1, lr=1e-05, speed=1.977 step/s, elapsed=06:46:14, eta=07:16:35 +[2026-04-16 06:05:25,887][trainer.accelerators.base_accelerator][INFO] - Training progress: step=48250/100000 (48.25%), epoch=1, lr=1e-05, speed=1.978 step/s, elapsed=06:46:37, eta=07:16:06 +[2026-04-16 06:05:47,966][trainer.accelerators.base_accelerator][INFO] - Training progress: step=48300/100000 (48.30%), epoch=1, lr=1e-05, speed=1.978 step/s, elapsed=06:46:59, eta=07:15:38 +[2026-04-16 06:06:10,024][trainer.accelerators.base_accelerator][INFO] - Training progress: step=48350/100000 (48.35%), epoch=1, lr=1e-05, speed=1.978 step/s, elapsed=06:47:21, eta=07:15:09 +[2026-04-16 06:06:32,097][trainer.accelerators.base_accelerator][INFO] - Training progress: step=48400/100000 (48.40%), epoch=1, lr=1e-05, speed=1.978 step/s, elapsed=06:47:43, eta=07:14:40 +[2026-04-16 06:06:54,177][trainer.accelerators.base_accelerator][INFO] - Training progress: step=48450/100000 (48.45%), epoch=1, lr=1e-05, speed=1.979 step/s, elapsed=06:48:05, eta=07:14:12 +[2026-04-16 06:07:16,517][trainer.accelerators.base_accelerator][INFO] - Training progress: step=48500/100000 (48.50%), epoch=1, lr=1e-05, speed=1.979 step/s, elapsed=06:48:27, eta=07:13:43 +[2026-04-16 06:07:38,485][trainer.accelerators.base_accelerator][INFO] - Training progress: step=48550/100000 (48.55%), epoch=1, lr=1e-05, speed=1.979 step/s, elapsed=06:48:49, eta=07:13:14 +[2026-04-16 06:08:00,584][trainer.accelerators.base_accelerator][INFO] - Training progress: step=48600/100000 (48.60%), epoch=1, lr=1e-05, speed=1.979 step/s, elapsed=06:49:11, eta=07:12:46 +[2026-04-16 06:08:22,703][trainer.accelerators.base_accelerator][INFO] - Training progress: step=48650/100000 (48.65%), epoch=1, lr=1e-05, speed=1.980 step/s, elapsed=06:49:33, eta=07:12:17 +[2026-04-16 06:08:44,802][trainer.accelerators.base_accelerator][INFO] - Training progress: step=48700/100000 (48.70%), epoch=1, lr=1e-05, speed=1.980 step/s, elapsed=06:49:56, eta=07:11:49 +[2026-04-16 06:09:06,978][trainer.accelerators.base_accelerator][INFO] - Training progress: step=48750/100000 (48.75%), epoch=1, lr=1e-05, speed=1.980 step/s, elapsed=06:50:18, eta=07:11:20 +[2026-04-16 06:09:29,320][trainer.accelerators.base_accelerator][INFO] - Training progress: step=48800/100000 (48.80%), epoch=1, lr=1e-05, speed=1.980 step/s, elapsed=06:50:40, eta=07:10:52 +[2026-04-16 06:09:51,478][trainer.accelerators.base_accelerator][INFO] - Training progress: step=48850/100000 (48.85%), epoch=1, lr=1e-05, speed=1.981 step/s, elapsed=06:51:02, eta=07:10:23 +[2026-04-16 06:10:13,545][trainer.accelerators.base_accelerator][INFO] - Training progress: step=48900/100000 (48.90%), epoch=1, lr=1e-05, speed=1.981 step/s, elapsed=06:51:24, eta=07:09:55 +[2026-04-16 06:10:35,710][trainer.accelerators.base_accelerator][INFO] - Training progress: step=48950/100000 (48.95%), epoch=1, lr=1e-05, speed=1.981 step/s, elapsed=06:51:46, eta=07:09:26 +[2026-04-16 06:10:57,829][trainer.accelerators.base_accelerator][INFO] - Training progress: step=49000/100000 (49.00%), epoch=1, lr=1e-05, speed=1.981 step/s, elapsed=06:52:09, eta=07:08:58 +[2026-04-16 06:10:57,868][__main__][INFO] - ========== EVAL START (periodic@gstep=49000) ========== +[2026-04-16 06:10:57,868][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-16 06:10:57,869][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 06:11:12,911][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.471385955810547, 'accuracy': 0.4894117647058824, 'num_samples': 425, 'test_unique_accuracy': 0.48842592592592593, 'test_unique_num_samples': 432} +[2026-04-16 06:11:12,912][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-16 06:11:12,912][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 06:11:28,348][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.471385955810547, 'accuracy': 0.4894117647058824, 'num_samples': 425, 'test_unique_accuracy': 0.5185185185185185, 'test_unique_num_samples': 432} +[2026-04-16 06:11:28,348][__main__][INFO] - ========== EVAL END (periodic@gstep=49000) ========== +[2026-04-16 06:11:28,348][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.506343841552734, 'accuracy': 0.4894117647058824, 'num_samples': 425, 'test_unique_accuracy': 0.5185185185185185, 'test_unique_num_samples': 432} +[2026-04-16 06:11:28,351][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.4894117647058824 is not better than 0.56 of logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep33000, skipping checkpoint +[2026-04-16 06:11:50,341][trainer.accelerators.base_accelerator][INFO] - Training progress: step=49050/100000 (49.05%), epoch=1, lr=1e-05, speed=1.979 step/s, elapsed=06:53:01, eta=07:09:01 +[2026-04-16 06:12:12,506][trainer.accelerators.base_accelerator][INFO] - Training progress: step=49100/100000 (49.10%), epoch=1, lr=1e-05, speed=1.980 step/s, elapsed=06:53:23, eta=07:08:33 +[2026-04-16 06:12:34,648][trainer.accelerators.base_accelerator][INFO] - Training progress: step=49150/100000 (49.15%), epoch=1, lr=1e-05, speed=1.980 step/s, elapsed=06:53:45, eta=07:08:04 +[2026-04-16 06:12:56,720][trainer.accelerators.base_accelerator][INFO] - Training progress: step=49200/100000 (49.20%), epoch=1, lr=1e-05, speed=1.980 step/s, elapsed=06:54:07, eta=07:07:36 +[2026-04-16 06:13:18,730][trainer.accelerators.base_accelerator][INFO] - Training progress: step=49250/100000 (49.25%), epoch=1, lr=1e-05, speed=1.980 step/s, elapsed=06:54:29, eta=07:07:07 +[2026-04-16 06:13:40,877][trainer.accelerators.base_accelerator][INFO] - Training progress: step=49300/100000 (49.30%), epoch=1, lr=1e-05, speed=1.981 step/s, elapsed=06:54:52, eta=07:06:39 +[2026-04-16 06:14:02,994][trainer.accelerators.base_accelerator][INFO] - Training progress: step=49350/100000 (49.35%), epoch=1, lr=1e-05, speed=1.981 step/s, elapsed=06:55:14, eta=07:06:10 +[2026-04-16 06:14:25,138][trainer.accelerators.base_accelerator][INFO] - Training progress: step=49400/100000 (49.40%), epoch=1, lr=1e-05, speed=1.981 step/s, elapsed=06:55:36, eta=07:05:42 +[2026-04-16 06:14:47,229][trainer.accelerators.base_accelerator][INFO] - Training progress: step=49450/100000 (49.45%), epoch=1, lr=1e-05, speed=1.981 step/s, elapsed=06:55:58, eta=07:05:13 +[2026-04-16 06:15:09,382][trainer.accelerators.base_accelerator][INFO] - Training progress: step=49500/100000 (49.50%), epoch=1, lr=1e-05, speed=1.982 step/s, elapsed=06:56:20, eta=07:04:45 +[2026-04-16 06:15:31,561][trainer.accelerators.base_accelerator][INFO] - Training progress: step=49550/100000 (49.55%), epoch=1, lr=1e-05, speed=1.982 step/s, elapsed=06:56:42, eta=07:04:16 +[2026-04-16 06:15:53,529][trainer.accelerators.base_accelerator][INFO] - Training progress: step=49600/100000 (49.60%), epoch=1, lr=1e-05, speed=1.982 step/s, elapsed=06:57:04, eta=07:03:48 +[2026-04-16 06:16:15,946][trainer.accelerators.base_accelerator][INFO] - Training progress: step=49650/100000 (49.65%), epoch=1, lr=1e-05, speed=1.982 step/s, elapsed=06:57:27, eta=07:03:20 +[2026-04-16 06:16:38,026][trainer.accelerators.base_accelerator][INFO] - Training progress: step=49700/100000 (49.70%), epoch=1, lr=1e-05, speed=1.983 step/s, elapsed=06:57:49, eta=07:02:51 +[2026-04-16 06:17:00,214][trainer.accelerators.base_accelerator][INFO] - Training progress: step=49750/100000 (49.75%), epoch=1, lr=1e-05, speed=1.983 step/s, elapsed=06:58:11, eta=07:02:23 +[2026-04-16 06:17:22,289][trainer.accelerators.base_accelerator][INFO] - Training progress: step=49800/100000 (49.80%), epoch=1, lr=1e-05, speed=1.983 step/s, elapsed=06:58:33, eta=07:01:55 +[2026-04-16 06:17:44,374][trainer.accelerators.base_accelerator][INFO] - Training progress: step=49850/100000 (49.85%), epoch=1, lr=1e-05, speed=1.983 step/s, elapsed=06:58:55, eta=07:01:26 +[2026-04-16 06:18:06,495][trainer.accelerators.base_accelerator][INFO] - Training progress: step=49900/100000 (49.90%), epoch=1, lr=1e-05, speed=1.983 step/s, elapsed=06:59:17, eta=07:00:58 +[2026-04-16 06:18:28,610][trainer.accelerators.base_accelerator][INFO] - Training progress: step=49950/100000 (49.95%), epoch=1, lr=1e-05, speed=1.984 step/s, elapsed=06:59:39, eta=07:00:30 +[2026-04-16 06:18:50,712][trainer.accelerators.base_accelerator][INFO] - Training progress: step=50000/100000 (50.00%), epoch=1, lr=1e-05, speed=1.984 step/s, elapsed=07:00:01, eta=07:00:01 +[2026-04-16 06:18:50,751][__main__][INFO] - ========== EVAL START (periodic@gstep=50000) ========== +[2026-04-16 06:18:50,751][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-16 06:18:50,751][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 06:19:07,156][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.506343841552734, 'accuracy': 0.4988235294117647, 'num_samples': 425, 'test_unique_accuracy': 0.5185185185185185, 'test_unique_num_samples': 432} +[2026-04-16 06:19:07,156][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-16 06:19:07,157][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 06:19:22,275][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.506343841552734, 'accuracy': 0.4988235294117647, 'num_samples': 425, 'test_unique_accuracy': 0.5277777777777778, 'test_unique_num_samples': 432} +[2026-04-16 06:19:22,275][__main__][INFO] - ========== EVAL END (periodic@gstep=50000) ========== +[2026-04-16 06:19:22,276][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.542621612548828, 'accuracy': 0.4988235294117647, 'num_samples': 425, 'test_unique_accuracy': 0.5277777777777778, 'test_unique_num_samples': 432} +[2026-04-16 06:19:22,279][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.4988235294117647 is not better than 0.56 of logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep33000, skipping checkpoint +[2026-04-16 06:19:44,404][trainer.accelerators.base_accelerator][INFO] - Training progress: step=50050/100000 (50.05%), epoch=1, lr=1e-05, speed=1.982 step/s, elapsed=07:00:55, eta=07:00:05 +[2026-04-16 06:20:06,532][trainer.accelerators.base_accelerator][INFO] - Training progress: step=50100/100000 (50.10%), epoch=1, lr=1e-05, speed=1.982 step/s, elapsed=07:01:17, eta=06:59:36 +[2026-04-16 06:20:29,019][trainer.accelerators.base_accelerator][INFO] - Training progress: step=50150/100000 (50.15%), epoch=1, lr=1e-05, speed=1.982 step/s, elapsed=07:01:40, eta=06:59:08 +[2026-04-16 06:20:51,119][trainer.accelerators.base_accelerator][INFO] - Training progress: step=50200/100000 (50.20%), epoch=1, lr=1e-05, speed=1.982 step/s, elapsed=07:02:02, eta=06:58:40 +[2026-04-16 06:21:13,219][trainer.accelerators.base_accelerator][INFO] - Training progress: step=50250/100000 (50.25%), epoch=1, lr=1e-05, speed=1.983 step/s, elapsed=07:02:24, eta=06:58:12 +[2026-04-16 06:21:35,296][trainer.accelerators.base_accelerator][INFO] - Training progress: step=50300/100000 (50.30%), epoch=1, lr=1e-05, speed=1.983 step/s, elapsed=07:02:46, eta=06:57:43 +[2026-04-16 06:21:57,255][trainer.accelerators.base_accelerator][INFO] - Training progress: step=50350/100000 (50.35%), epoch=1, lr=1e-05, speed=1.983 step/s, elapsed=07:03:08, eta=06:57:15 +[2026-04-16 06:22:19,374][trainer.accelerators.base_accelerator][INFO] - Training progress: step=50400/100000 (50.40%), epoch=1, lr=1e-05, speed=1.983 step/s, elapsed=07:03:30, eta=06:56:47 +[2026-04-16 06:22:41,373][trainer.accelerators.base_accelerator][INFO] - Training progress: step=50450/100000 (50.45%), epoch=1, lr=1e-05, speed=1.984 step/s, elapsed=07:03:52, eta=06:56:18 +[2026-04-16 06:23:03,464][trainer.accelerators.base_accelerator][INFO] - Training progress: step=50500/100000 (50.50%), epoch=1, lr=1e-05, speed=1.984 step/s, elapsed=07:04:14, eta=06:55:50 +[2026-04-16 06:23:25,641][trainer.accelerators.base_accelerator][INFO] - Training progress: step=50550/100000 (50.55%), epoch=1, lr=1e-05, speed=1.984 step/s, elapsed=07:04:36, eta=06:55:22 +[2026-04-16 06:23:47,778][trainer.accelerators.base_accelerator][INFO] - Training progress: step=50600/100000 (50.60%), epoch=1, lr=1e-05, speed=1.984 step/s, elapsed=07:04:59, eta=06:54:54 +[2026-04-16 06:24:10,180][trainer.accelerators.base_accelerator][INFO] - Training progress: step=50650/100000 (50.65%), epoch=1, lr=1e-05, speed=1.985 step/s, elapsed=07:05:21, eta=06:54:26 +[2026-04-16 06:24:32,282][trainer.accelerators.base_accelerator][INFO] - Training progress: step=50700/100000 (50.70%), epoch=1, lr=1e-05, speed=1.985 step/s, elapsed=07:05:43, eta=06:53:58 +[2026-04-16 06:24:54,395][trainer.accelerators.base_accelerator][INFO] - Training progress: step=50750/100000 (50.75%), epoch=1, lr=1e-05, speed=1.985 step/s, elapsed=07:06:05, eta=06:53:30 +[2026-04-16 06:25:16,436][trainer.accelerators.base_accelerator][INFO] - Training progress: step=50800/100000 (50.80%), epoch=1, lr=1e-05, speed=1.985 step/s, elapsed=07:06:27, eta=06:53:01 +[2026-04-16 06:25:38,674][trainer.accelerators.base_accelerator][INFO] - Training progress: step=50850/100000 (50.85%), epoch=1, lr=1e-05, speed=1.986 step/s, elapsed=07:06:49, eta=06:52:33 +[2026-04-16 06:26:00,766][trainer.accelerators.base_accelerator][INFO] - Training progress: step=50900/100000 (50.90%), epoch=1, lr=1e-05, speed=1.986 step/s, elapsed=07:07:12, eta=06:52:05 +[2026-04-16 06:26:22,879][trainer.accelerators.base_accelerator][INFO] - Training progress: step=50950/100000 (50.95%), epoch=1, lr=1e-05, speed=1.986 step/s, elapsed=07:07:34, eta=06:51:37 +[2026-04-16 06:26:45,061][trainer.accelerators.base_accelerator][INFO] - Training progress: step=51000/100000 (51.00%), epoch=1, lr=1e-05, speed=1.986 step/s, elapsed=07:07:56, eta=06:51:09 +[2026-04-16 06:26:45,101][__main__][INFO] - ========== EVAL START (periodic@gstep=51000) ========== +[2026-04-16 06:26:45,101][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-16 06:26:45,101][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 06:27:00,157][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.542621612548828, 'accuracy': 0.5176470588235295, 'num_samples': 425, 'test_unique_accuracy': 0.5277777777777778, 'test_unique_num_samples': 432} +[2026-04-16 06:27:00,157][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-16 06:27:00,158][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 06:27:15,319][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.542621612548828, 'accuracy': 0.5176470588235295, 'num_samples': 425, 'test_unique_accuracy': 0.5277777777777778, 'test_unique_num_samples': 432} +[2026-04-16 06:27:15,319][__main__][INFO] - ========== EVAL END (periodic@gstep=51000) ========== +[2026-04-16 06:27:15,320][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.57716178894043, 'accuracy': 0.5176470588235295, 'num_samples': 425, 'test_unique_accuracy': 0.5277777777777778, 'test_unique_num_samples': 432} +[2026-04-16 06:27:15,325][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.5176470588235295 is not better than 0.56 of logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep33000, skipping checkpoint +[2026-04-16 06:27:37,526][trainer.accelerators.base_accelerator][INFO] - Training progress: step=51050/100000 (51.05%), epoch=1, lr=1e-05, speed=1.984 step/s, elapsed=07:08:48, eta=06:51:10 +[2026-04-16 06:27:59,953][trainer.accelerators.base_accelerator][INFO] - Training progress: step=51100/100000 (51.10%), epoch=1, lr=1e-05, speed=1.984 step/s, elapsed=07:09:11, eta=06:50:42 +[2026-04-16 06:28:22,073][trainer.accelerators.base_accelerator][INFO] - Training progress: step=51150/100000 (51.15%), epoch=1, lr=1e-05, speed=1.985 step/s, elapsed=07:09:33, eta=06:50:14 +[2026-04-16 06:28:44,221][trainer.accelerators.base_accelerator][INFO] - Training progress: step=51200/100000 (51.20%), epoch=1, lr=1e-05, speed=1.985 step/s, elapsed=07:09:55, eta=06:49:46 +[2026-04-16 06:29:06,374][trainer.accelerators.base_accelerator][INFO] - Training progress: step=51250/100000 (51.25%), epoch=1, lr=1e-05, speed=1.985 step/s, elapsed=07:10:17, eta=06:49:18 +[2026-04-16 06:29:28,400][trainer.accelerators.base_accelerator][INFO] - Training progress: step=51300/100000 (51.30%), epoch=1, lr=1e-05, speed=1.985 step/s, elapsed=07:10:39, eta=06:48:50 +[2026-04-16 06:29:50,574][trainer.accelerators.base_accelerator][INFO] - Training progress: step=51350/100000 (51.35%), epoch=1, lr=1e-05, speed=1.986 step/s, elapsed=07:11:01, eta=06:48:22 +[2026-04-16 06:30:12,869][trainer.accelerators.base_accelerator][INFO] - Training progress: step=51400/100000 (51.40%), epoch=1, lr=1e-05, speed=1.986 step/s, elapsed=07:11:24, eta=06:47:54 +[2026-04-16 06:30:57,144][trainer.accelerators.base_accelerator][INFO] - Training progress: step=51450/100000 (51.45%), epoch=1, lr=1e-05, speed=1.984 step/s, elapsed=07:12:08, eta=06:47:46 +[2026-04-16 06:32:45,208][trainer.accelerators.base_accelerator][INFO] - Training progress: step=51500/100000 (51.50%), epoch=1, lr=1e-05, speed=1.978 step/s, elapsed=07:13:56, eta=06:48:39 +[2026-04-16 06:33:40,864][trainer.accelerators.base_accelerator][INFO] - Training progress: step=51550/100000 (51.55%), epoch=1, lr=1e-05, speed=1.976 step/s, elapsed=07:14:52, eta=06:48:43 +[2026-04-16 06:34:03,056][trainer.accelerators.base_accelerator][INFO] - Training progress: step=51600/100000 (51.60%), epoch=1, lr=1e-05, speed=1.976 step/s, elapsed=07:15:14, eta=06:48:14 +[2026-04-16 06:34:25,291][trainer.accelerators.base_accelerator][INFO] - Training progress: step=51650/100000 (51.65%), epoch=1, lr=1e-05, speed=1.976 step/s, elapsed=07:15:36, eta=06:47:46 +[2026-04-16 06:34:47,517][trainer.accelerators.base_accelerator][INFO] - Training progress: step=51700/100000 (51.70%), epoch=1, lr=1e-05, speed=1.976 step/s, elapsed=07:15:58, eta=06:47:18 +[2026-04-16 06:35:11,099][trainer.accelerators.base_accelerator][INFO] - Training progress: step=51750/100000 (51.75%), epoch=1, lr=1e-05, speed=1.977 step/s, elapsed=07:16:22, eta=06:46:51 +[2026-04-16 06:35:33,303][trainer.accelerators.base_accelerator][INFO] - Training progress: step=51800/100000 (51.80%), epoch=1, lr=1e-05, speed=1.977 step/s, elapsed=07:16:44, eta=06:46:23 +[2026-04-16 06:35:55,466][trainer.accelerators.base_accelerator][INFO] - Training progress: step=51850/100000 (51.85%), epoch=1, lr=1e-05, speed=1.977 step/s, elapsed=07:17:06, eta=06:45:55 +[2026-04-16 06:36:17,616][trainer.accelerators.base_accelerator][INFO] - Training progress: step=51900/100000 (51.90%), epoch=1, lr=1e-05, speed=1.977 step/s, elapsed=07:17:28, eta=06:45:26 +[2026-04-16 06:36:39,737][trainer.accelerators.base_accelerator][INFO] - Training progress: step=51950/100000 (51.95%), epoch=1, lr=1e-05, speed=1.977 step/s, elapsed=07:17:50, eta=06:44:58 +[2026-04-16 06:37:01,868][trainer.accelerators.base_accelerator][INFO] - Training progress: step=52000/100000 (52.00%), epoch=1, lr=1e-05, speed=1.978 step/s, elapsed=07:18:13, eta=06:44:30 +[2026-04-16 06:37:01,906][__main__][INFO] - ========== EVAL START (periodic@gstep=52000) ========== +[2026-04-16 06:37:01,906][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-16 06:37:01,906][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 06:37:17,291][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.57716178894043, 'accuracy': 0.5105882352941177, 'num_samples': 425, 'test_unique_accuracy': 0.5277777777777778, 'test_unique_num_samples': 432} +[2026-04-16 06:37:17,291][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-16 06:37:17,292][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 06:37:32,418][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.57716178894043, 'accuracy': 0.5105882352941177, 'num_samples': 425, 'test_unique_accuracy': 0.4976851851851852, 'test_unique_num_samples': 432} +[2026-04-16 06:37:32,418][__main__][INFO] - ========== EVAL END (periodic@gstep=52000) ========== +[2026-04-16 06:37:32,419][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.615982055664062, 'accuracy': 0.5105882352941177, 'num_samples': 425, 'test_unique_accuracy': 0.4976851851851852, 'test_unique_num_samples': 432} +[2026-04-16 06:37:32,423][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.5105882352941177 is not better than 0.56 of logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep33000, skipping checkpoint +[2026-04-16 06:37:54,324][trainer.accelerators.base_accelerator][INFO] - Training progress: step=52050/100000 (52.05%), epoch=1, lr=1e-05, speed=1.976 step/s, elapsed=07:19:05, eta=06:44:30 +[2026-04-16 06:38:16,454][trainer.accelerators.base_accelerator][INFO] - Training progress: step=52100/100000 (52.10%), epoch=1, lr=1e-05, speed=1.976 step/s, elapsed=07:19:27, eta=06:44:02 +[2026-04-16 06:38:38,944][trainer.accelerators.base_accelerator][INFO] - Training progress: step=52150/100000 (52.15%), epoch=1, lr=1e-05, speed=1.976 step/s, elapsed=07:19:50, eta=06:43:34 +[2026-04-16 06:39:01,053][trainer.accelerators.base_accelerator][INFO] - Training progress: step=52200/100000 (52.20%), epoch=1, lr=1e-05, speed=1.976 step/s, elapsed=07:20:12, eta=06:43:05 +[2026-04-16 06:39:23,184][trainer.accelerators.base_accelerator][INFO] - Training progress: step=52250/100000 (52.25%), epoch=1, lr=1e-05, speed=1.977 step/s, elapsed=07:20:34, eta=06:42:37 +[2026-04-16 06:39:45,266][trainer.accelerators.base_accelerator][INFO] - Training progress: step=52300/100000 (52.30%), epoch=1, lr=1e-05, speed=1.977 step/s, elapsed=07:20:56, eta=06:42:09 +[2026-04-16 06:40:07,358][trainer.accelerators.base_accelerator][INFO] - Training progress: step=52350/100000 (52.35%), epoch=1, lr=1e-05, speed=1.977 step/s, elapsed=07:21:18, eta=06:41:41 +[2026-04-16 06:40:29,450][trainer.accelerators.base_accelerator][INFO] - Training progress: step=52400/100000 (52.40%), epoch=1, lr=1e-05, speed=1.977 step/s, elapsed=07:21:40, eta=06:41:13 +[2026-04-16 06:40:51,853][trainer.accelerators.base_accelerator][INFO] - Training progress: step=52450/100000 (52.45%), epoch=1, lr=1e-05, speed=1.978 step/s, elapsed=07:22:03, eta=06:40:45 +[2026-04-16 06:41:13,874][trainer.accelerators.base_accelerator][INFO] - Training progress: step=52500/100000 (52.50%), epoch=1, lr=1e-05, speed=1.978 step/s, elapsed=07:22:25, eta=06:40:17 +[2026-04-16 06:43:06,890][trainer.accelerators.base_accelerator][INFO] - Training progress: step=52550/100000 (52.55%), epoch=1, lr=1e-05, speed=1.971 step/s, elapsed=07:24:18, eta=06:41:10 +[2026-04-16 06:43:34,442][trainer.accelerators.base_accelerator][INFO] - Training progress: step=52600/100000 (52.60%), epoch=1, lr=1e-05, speed=1.971 step/s, elapsed=07:24:45, eta=06:40:47 +[2026-04-16 06:44:41,307][trainer.accelerators.base_accelerator][INFO] - Training progress: step=52650/100000 (52.65%), epoch=1, lr=1e-05, speed=1.968 step/s, elapsed=07:25:52, eta=06:40:59 +[2026-04-16 06:46:04,475][trainer.accelerators.base_accelerator][INFO] - Training progress: step=52700/100000 (52.70%), epoch=1, lr=1e-05, speed=1.964 step/s, elapsed=07:27:15, eta=06:41:25 +[2026-04-16 06:46:58,566][trainer.accelerators.base_accelerator][INFO] - Training progress: step=52750/100000 (52.75%), epoch=1, lr=1e-05, speed=1.962 step/s, elapsed=07:28:09, eta=06:41:26 +[2026-04-16 06:47:20,560][trainer.accelerators.base_accelerator][INFO] - Training progress: step=52800/100000 (52.80%), epoch=1, lr=1e-05, speed=1.962 step/s, elapsed=07:28:31, eta=06:40:57 +[2026-04-16 06:47:42,605][trainer.accelerators.base_accelerator][INFO] - Training progress: step=52850/100000 (52.85%), epoch=1, lr=1e-05, speed=1.962 step/s, elapsed=07:28:53, eta=06:40:28 +[2026-04-16 06:48:04,731][trainer.accelerators.base_accelerator][INFO] - Training progress: step=52900/100000 (52.90%), epoch=1, lr=1e-05, speed=1.962 step/s, elapsed=07:29:15, eta=06:40:00 +[2026-04-16 06:48:26,745][trainer.accelerators.base_accelerator][INFO] - Training progress: step=52950/100000 (52.95%), epoch=1, lr=1e-05, speed=1.963 step/s, elapsed=07:29:37, eta=06:39:31 +[2026-04-16 06:48:48,786][trainer.accelerators.base_accelerator][INFO] - Training progress: step=53000/100000 (53.00%), epoch=1, lr=1e-05, speed=1.963 step/s, elapsed=07:30:00, eta=06:39:03 +[2026-04-16 06:48:48,824][__main__][INFO] - ========== EVAL START (periodic@gstep=53000) ========== +[2026-04-16 06:48:48,825][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-16 06:48:48,825][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 06:49:03,869][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.615982055664062, 'accuracy': 0.48470588235294115, 'num_samples': 425, 'test_unique_accuracy': 0.4976851851851852, 'test_unique_num_samples': 432} +[2026-04-16 06:49:03,869][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-16 06:49:03,869][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 06:49:19,035][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.615982055664062, 'accuracy': 0.48470588235294115, 'num_samples': 425, 'test_unique_accuracy': 0.49537037037037035, 'test_unique_num_samples': 432} +[2026-04-16 06:49:19,035][__main__][INFO] - ========== EVAL END (periodic@gstep=53000) ========== +[2026-04-16 06:49:19,036][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.652902603149414, 'accuracy': 0.48470588235294115, 'num_samples': 425, 'test_unique_accuracy': 0.49537037037037035, 'test_unique_num_samples': 432} +[2026-04-16 06:49:19,041][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.48470588235294115 is not better than 0.56 of logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep33000, skipping checkpoint +[2026-04-16 06:49:41,915][trainer.accelerators.base_accelerator][INFO] - Training progress: step=53050/100000 (53.05%), epoch=1, lr=1e-05, speed=1.961 step/s, elapsed=07:30:53, eta=06:39:02 +[2026-04-16 06:50:03,970][trainer.accelerators.base_accelerator][INFO] - Training progress: step=53100/100000 (53.10%), epoch=1, lr=1e-05, speed=1.961 step/s, elapsed=07:31:15, eta=06:38:33 +[2026-04-16 06:50:26,072][trainer.accelerators.base_accelerator][INFO] - Training progress: step=53150/100000 (53.15%), epoch=1, lr=1e-05, speed=1.961 step/s, elapsed=07:31:37, eta=06:38:05 +[2026-04-16 06:50:48,156][trainer.accelerators.base_accelerator][INFO] - Training progress: step=53200/100000 (53.20%), epoch=1, lr=1e-05, speed=1.962 step/s, elapsed=07:31:59, eta=06:37:36 +[2026-04-16 06:51:10,286][trainer.accelerators.base_accelerator][INFO] - Training progress: step=53250/100000 (53.25%), epoch=1, lr=1e-05, speed=1.962 step/s, elapsed=07:32:21, eta=06:37:08 +[2026-04-16 06:51:32,569][trainer.accelerators.base_accelerator][INFO] - Training progress: step=53300/100000 (53.30%), epoch=1, lr=1e-05, speed=1.962 step/s, elapsed=07:32:43, eta=06:36:40 +[2026-04-16 06:51:54,696][trainer.accelerators.base_accelerator][INFO] - Training progress: step=53350/100000 (53.35%), epoch=1, lr=1e-05, speed=1.962 step/s, elapsed=07:33:05, eta=06:36:11 +[2026-04-16 06:52:16,702][trainer.accelerators.base_accelerator][INFO] - Training progress: step=53400/100000 (53.40%), epoch=1, lr=1e-05, speed=1.963 step/s, elapsed=07:33:27, eta=06:35:43 +[2026-04-16 06:52:38,806][trainer.accelerators.base_accelerator][INFO] - Training progress: step=53450/100000 (53.45%), epoch=1, lr=1e-05, speed=1.963 step/s, elapsed=07:33:50, eta=06:35:14 +[2026-04-16 06:53:00,875][trainer.accelerators.base_accelerator][INFO] - Training progress: step=53500/100000 (53.50%), epoch=1, lr=1e-05, speed=1.963 step/s, elapsed=07:34:12, eta=06:34:46 +[2026-04-16 06:53:23,250][trainer.accelerators.base_accelerator][INFO] - Training progress: step=53550/100000 (53.55%), epoch=1, lr=1e-05, speed=1.963 step/s, elapsed=07:34:34, eta=06:34:18 +[2026-04-16 06:53:45,360][trainer.accelerators.base_accelerator][INFO] - Training progress: step=53600/100000 (53.60%), epoch=1, lr=1e-05, speed=1.964 step/s, elapsed=07:34:56, eta=06:33:49 +[2026-04-16 06:54:07,368][trainer.accelerators.base_accelerator][INFO] - Training progress: step=53650/100000 (53.65%), epoch=1, lr=1e-05, speed=1.964 step/s, elapsed=07:35:18, eta=06:33:21 +[2026-04-16 06:54:29,456][trainer.accelerators.base_accelerator][INFO] - Training progress: step=53700/100000 (53.70%), epoch=1, lr=1e-05, speed=1.964 step/s, elapsed=07:35:40, eta=06:32:53 +[2026-04-16 06:54:51,558][trainer.accelerators.base_accelerator][INFO] - Training progress: step=53750/100000 (53.75%), epoch=1, lr=1e-05, speed=1.964 step/s, elapsed=07:36:02, eta=06:32:24 +[2026-04-16 06:55:13,626][trainer.accelerators.base_accelerator][INFO] - Training progress: step=53800/100000 (53.80%), epoch=1, lr=1e-05, speed=1.965 step/s, elapsed=07:36:24, eta=06:31:56 +[2026-04-16 06:55:35,944][trainer.accelerators.base_accelerator][INFO] - Training progress: step=53850/100000 (53.85%), epoch=1, lr=1e-05, speed=1.965 step/s, elapsed=07:36:47, eta=06:31:28 +[2026-04-16 06:55:58,048][trainer.accelerators.base_accelerator][INFO] - Training progress: step=53900/100000 (53.90%), epoch=1, lr=1e-05, speed=1.965 step/s, elapsed=07:37:09, eta=06:30:59 +[2026-04-16 06:56:20,088][trainer.accelerators.base_accelerator][INFO] - Training progress: step=53950/100000 (53.95%), epoch=1, lr=1e-05, speed=1.965 step/s, elapsed=07:37:31, eta=06:30:31 +[2026-04-16 06:56:42,206][trainer.accelerators.base_accelerator][INFO] - Training progress: step=54000/100000 (54.00%), epoch=1, lr=1e-05, speed=1.966 step/s, elapsed=07:37:53, eta=06:30:03 +[2026-04-16 06:56:42,245][__main__][INFO] - ========== EVAL START (periodic@gstep=54000) ========== +[2026-04-16 06:56:42,246][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-16 06:56:42,246][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 06:56:57,485][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.652902603149414, 'accuracy': 0.4776470588235294, 'num_samples': 425, 'test_unique_accuracy': 0.49537037037037035, 'test_unique_num_samples': 432} +[2026-04-16 06:56:57,486][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-16 06:56:57,486][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 06:57:12,720][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.652902603149414, 'accuracy': 0.4776470588235294, 'num_samples': 425, 'test_unique_accuracy': 0.47685185185185186, 'test_unique_num_samples': 432} +[2026-04-16 06:57:12,721][__main__][INFO] - ========== EVAL END (periodic@gstep=54000) ========== +[2026-04-16 06:57:12,721][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.684364318847656, 'accuracy': 0.4776470588235294, 'num_samples': 425, 'test_unique_accuracy': 0.47685185185185186, 'test_unique_num_samples': 432} +[2026-04-16 06:57:12,756][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.4776470588235294 is not better than 0.56 of logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep33000, skipping checkpoint +[2026-04-16 06:57:34,921][trainer.accelerators.base_accelerator][INFO] - Training progress: step=54050/100000 (54.05%), epoch=1, lr=1e-05, speed=1.964 step/s, elapsed=07:38:46, eta=06:30:01 +[2026-04-16 06:58:02,347][trainer.accelerators.base_accelerator][INFO] - Training progress: step=54100/100000 (54.10%), epoch=1, lr=1e-05, speed=1.963 step/s, elapsed=07:39:13, eta=06:29:37 +[2026-04-16 06:58:25,285][trainer.accelerators.base_accelerator][INFO] - Training progress: step=54150/100000 (54.15%), epoch=1, lr=1e-05, speed=1.964 step/s, elapsed=07:39:36, eta=06:29:09 +[2026-04-16 06:58:53,173][trainer.accelerators.base_accelerator][INFO] - Training progress: step=54200/100000 (54.20%), epoch=1, lr=1e-05, speed=1.963 step/s, elapsed=07:40:04, eta=06:28:46 +[2026-04-16 06:59:50,337][trainer.accelerators.base_accelerator][INFO] - Training progress: step=54250/100000 (54.25%), epoch=1, lr=1e-05, speed=1.961 step/s, elapsed=07:41:01, eta=06:28:47 +[2026-04-16 07:00:12,433][trainer.accelerators.base_accelerator][INFO] - Training progress: step=54300/100000 (54.30%), epoch=1, lr=1e-05, speed=1.961 step/s, elapsed=07:41:23, eta=06:28:19 +[2026-04-16 07:00:34,575][trainer.accelerators.base_accelerator][INFO] - Training progress: step=54350/100000 (54.35%), epoch=1, lr=1e-05, speed=1.962 step/s, elapsed=07:41:45, eta=06:27:50 +[2026-04-16 07:00:56,683][trainer.accelerators.base_accelerator][INFO] - Training progress: step=54400/100000 (54.40%), epoch=1, lr=1e-05, speed=1.962 step/s, elapsed=07:42:07, eta=06:27:22 +[2026-04-16 07:01:18,734][trainer.accelerators.base_accelerator][INFO] - Training progress: step=54450/100000 (54.45%), epoch=1, lr=1e-05, speed=1.962 step/s, elapsed=07:42:29, eta=06:26:54 +[2026-04-16 07:01:50,182][trainer.accelerators.base_accelerator][INFO] - Training progress: step=54500/100000 (54.50%), epoch=1, lr=1e-05, speed=1.962 step/s, elapsed=07:43:01, eta=06:26:33 +[2026-04-16 07:02:13,063][trainer.accelerators.base_accelerator][INFO] - Training progress: step=54550/100000 (54.55%), epoch=1, lr=1e-05, speed=1.962 step/s, elapsed=07:43:24, eta=06:26:06 +[2026-04-16 07:02:39,244][trainer.accelerators.base_accelerator][INFO] - Training progress: step=54600/100000 (54.60%), epoch=1, lr=1e-05, speed=1.962 step/s, elapsed=07:43:50, eta=06:25:41 +[2026-04-16 07:03:02,348][trainer.accelerators.base_accelerator][INFO] - Training progress: step=54650/100000 (54.65%), epoch=1, lr=1e-05, speed=1.962 step/s, elapsed=07:44:13, eta=06:25:13 +[2026-04-16 07:03:24,509][trainer.accelerators.base_accelerator][INFO] - Training progress: step=54700/100000 (54.70%), epoch=1, lr=1e-05, speed=1.962 step/s, elapsed=07:44:35, eta=06:24:45 +[2026-04-16 07:03:47,185][trainer.accelerators.base_accelerator][INFO] - Training progress: step=54750/100000 (54.75%), epoch=1, lr=1e-05, speed=1.962 step/s, elapsed=07:44:58, eta=06:24:17 +[2026-04-16 07:04:09,285][trainer.accelerators.base_accelerator][INFO] - Training progress: step=54800/100000 (54.80%), epoch=1, lr=1e-05, speed=1.963 step/s, elapsed=07:45:20, eta=06:23:49 +[2026-04-16 07:04:31,241][trainer.accelerators.base_accelerator][INFO] - Training progress: step=54850/100000 (54.85%), epoch=1, lr=1e-05, speed=1.963 step/s, elapsed=07:45:42, eta=06:23:20 +[2026-04-16 07:04:53,270][trainer.accelerators.base_accelerator][INFO] - Training progress: step=54900/100000 (54.90%), epoch=1, lr=1e-05, speed=1.963 step/s, elapsed=07:46:04, eta=06:22:52 +[2026-04-16 07:05:15,392][trainer.accelerators.base_accelerator][INFO] - Training progress: step=54950/100000 (54.95%), epoch=1, lr=1e-05, speed=1.963 step/s, elapsed=07:46:26, eta=06:22:24 +[2026-04-16 07:05:37,504][trainer.accelerators.base_accelerator][INFO] - Training progress: step=55000/100000 (55.00%), epoch=1, lr=1e-05, speed=1.964 step/s, elapsed=07:46:48, eta=06:21:56 +[2026-04-16 07:05:37,543][__main__][INFO] - ========== EVAL START (periodic@gstep=55000) ========== +[2026-04-16 07:05:37,543][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-16 07:05:37,543][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 07:05:53,221][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.684364318847656, 'accuracy': 0.5058823529411764, 'num_samples': 425, 'test_unique_accuracy': 0.47685185185185186, 'test_unique_num_samples': 432} +[2026-04-16 07:05:53,221][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-16 07:05:53,221][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 07:06:08,402][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.684364318847656, 'accuracy': 0.5058823529411764, 'num_samples': 425, 'test_unique_accuracy': 0.48842592592592593, 'test_unique_num_samples': 432} +[2026-04-16 07:06:08,403][__main__][INFO] - ========== EVAL END (periodic@gstep=55000) ========== +[2026-04-16 07:06:08,404][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.707720756530762, 'accuracy': 0.5058823529411764, 'num_samples': 425, 'test_unique_accuracy': 0.48842592592592593, 'test_unique_num_samples': 432} +[2026-04-16 07:06:08,408][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.5058823529411764 is not better than 0.56 of logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep33000, skipping checkpoint +[2026-04-16 07:06:30,493][trainer.accelerators.base_accelerator][INFO] - Training progress: step=55050/100000 (55.05%), epoch=1, lr=1e-05, speed=1.962 step/s, elapsed=07:47:41, eta=06:21:53 +[2026-04-16 07:06:52,484][trainer.accelerators.base_accelerator][INFO] - Training progress: step=55100/100000 (55.10%), epoch=1, lr=1e-05, speed=1.962 step/s, elapsed=07:48:03, eta=06:21:24 +[2026-04-16 07:07:14,637][trainer.accelerators.base_accelerator][INFO] - Training progress: step=55150/100000 (55.15%), epoch=1, lr=1e-05, speed=1.962 step/s, elapsed=07:48:25, eta=06:20:56 +[2026-04-16 07:07:36,709][trainer.accelerators.base_accelerator][INFO] - Training progress: step=55200/100000 (55.20%), epoch=1, lr=1e-05, speed=1.962 step/s, elapsed=07:48:47, eta=06:20:28 +[2026-04-16 07:07:59,180][trainer.accelerators.base_accelerator][INFO] - Training progress: step=55250/100000 (55.25%), epoch=1, lr=1e-05, speed=1.963 step/s, elapsed=07:49:10, eta=06:20:00 +[2026-04-16 07:08:21,332][trainer.accelerators.base_accelerator][INFO] - Training progress: step=55300/100000 (55.30%), epoch=1, lr=1e-05, speed=1.963 step/s, elapsed=07:49:32, eta=06:19:32 +[2026-04-16 07:08:43,458][trainer.accelerators.base_accelerator][INFO] - Training progress: step=55350/100000 (55.35%), epoch=1, lr=1e-05, speed=1.963 step/s, elapsed=07:49:54, eta=06:19:04 +[2026-04-16 07:09:05,576][trainer.accelerators.base_accelerator][INFO] - Training progress: step=55400/100000 (55.40%), epoch=1, lr=1e-05, speed=1.963 step/s, elapsed=07:50:16, eta=06:18:36 +[2026-04-16 07:09:27,586][trainer.accelerators.base_accelerator][INFO] - Training progress: step=55450/100000 (55.45%), epoch=1, lr=1e-05, speed=1.964 step/s, elapsed=07:50:38, eta=06:18:07 +[2026-04-16 07:09:49,620][trainer.accelerators.base_accelerator][INFO] - Training progress: step=55500/100000 (55.50%), epoch=1, lr=1e-05, speed=1.964 step/s, elapsed=07:51:00, eta=06:17:39 +[2026-04-16 07:10:11,726][trainer.accelerators.base_accelerator][INFO] - Training progress: step=55550/100000 (55.55%), epoch=1, lr=1e-05, speed=1.964 step/s, elapsed=07:51:22, eta=06:17:11 +[2026-04-16 07:10:37,946][trainer.accelerators.base_accelerator][INFO] - Training progress: step=55600/100000 (55.60%), epoch=1, lr=1e-05, speed=1.964 step/s, elapsed=07:51:49, eta=06:16:46 +[2026-04-16 07:11:00,061][trainer.accelerators.base_accelerator][INFO] - Training progress: step=55650/100000 (55.65%), epoch=1, lr=1e-05, speed=1.964 step/s, elapsed=07:52:11, eta=06:16:18 +[2026-04-16 07:13:10,678][trainer.accelerators.base_accelerator][INFO] - Training progress: step=55700/100000 (55.70%), epoch=1, lr=1e-05, speed=1.957 step/s, elapsed=07:54:21, eta=06:17:16 +[2026-04-16 07:13:56,099][trainer.accelerators.base_accelerator][INFO] - Training progress: step=55750/100000 (55.75%), epoch=1, lr=1e-05, speed=1.956 step/s, elapsed=07:55:07, eta=06:17:06 +[2026-04-16 07:14:19,409][trainer.accelerators.base_accelerator][INFO] - Training progress: step=55800/100000 (55.80%), epoch=1, lr=1e-05, speed=1.956 step/s, elapsed=07:55:30, eta=06:16:39 +[2026-04-16 07:14:41,503][trainer.accelerators.base_accelerator][INFO] - Training progress: step=55850/100000 (55.85%), epoch=1, lr=1e-05, speed=1.956 step/s, elapsed=07:55:52, eta=06:16:11 +[2026-04-16 07:15:03,690][trainer.accelerators.base_accelerator][INFO] - Training progress: step=55900/100000 (55.90%), epoch=1, lr=1e-05, speed=1.956 step/s, elapsed=07:56:14, eta=06:15:43 +[2026-04-16 07:15:25,873][trainer.accelerators.base_accelerator][INFO] - Training progress: step=55950/100000 (55.95%), epoch=1, lr=1e-05, speed=1.956 step/s, elapsed=07:56:37, eta=06:15:14 +[2026-04-16 07:15:48,055][trainer.accelerators.base_accelerator][INFO] - Training progress: step=56000/100000 (56.00%), epoch=1, lr=1e-05, speed=1.957 step/s, elapsed=07:56:59, eta=06:14:46 +[2026-04-16 07:15:48,094][__main__][INFO] - ========== EVAL START (periodic@gstep=56000) ========== +[2026-04-16 07:15:48,094][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-16 07:15:48,095][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 07:16:03,560][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.707720756530762, 'accuracy': 0.4752941176470588, 'num_samples': 425, 'test_unique_accuracy': 0.48842592592592593, 'test_unique_num_samples': 432} +[2026-04-16 07:16:03,561][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-16 07:16:03,561][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 07:16:18,714][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.707720756530762, 'accuracy': 0.4752941176470588, 'num_samples': 425, 'test_unique_accuracy': 0.5046296296296297, 'test_unique_num_samples': 432} +[2026-04-16 07:16:18,714][__main__][INFO] - ========== EVAL END (periodic@gstep=56000) ========== +[2026-04-16 07:16:18,715][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.73575496673584, 'accuracy': 0.4752941176470588, 'num_samples': 425, 'test_unique_accuracy': 0.5046296296296297, 'test_unique_num_samples': 432} +[2026-04-16 07:16:18,720][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.4752941176470588 is not better than 0.56 of logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep33000, skipping checkpoint +[2026-04-16 07:16:40,829][trainer.accelerators.base_accelerator][INFO] - Training progress: step=56050/100000 (56.05%), epoch=1, lr=1e-05, speed=1.955 step/s, elapsed=07:57:52, eta=06:14:42 +[2026-04-16 07:17:03,543][trainer.accelerators.base_accelerator][INFO] - Training progress: step=56100/100000 (56.10%), epoch=1, lr=1e-05, speed=1.955 step/s, elapsed=07:58:14, eta=06:14:14 +[2026-04-16 07:17:25,654][trainer.accelerators.base_accelerator][INFO] - Training progress: step=56150/100000 (56.15%), epoch=1, lr=1e-05, speed=1.955 step/s, elapsed=07:58:36, eta=06:13:46 +[2026-04-16 07:17:47,735][trainer.accelerators.base_accelerator][INFO] - Training progress: step=56200/100000 (56.20%), epoch=1, lr=1e-05, speed=1.956 step/s, elapsed=07:58:58, eta=06:13:18 +[2026-04-16 07:18:09,930][trainer.accelerators.base_accelerator][INFO] - Training progress: step=56250/100000 (56.25%), epoch=1, lr=1e-05, speed=1.956 step/s, elapsed=07:59:21, eta=06:12:49 +[2026-04-16 07:18:32,104][trainer.accelerators.base_accelerator][INFO] - Training progress: step=56300/100000 (56.30%), epoch=1, lr=1e-05, speed=1.956 step/s, elapsed=07:59:43, eta=06:12:21 +[2026-04-16 07:18:54,360][trainer.accelerators.base_accelerator][INFO] - Training progress: step=56350/100000 (56.35%), epoch=1, lr=1e-05, speed=1.956 step/s, elapsed=08:00:05, eta=06:11:53 +[2026-04-16 07:19:16,360][trainer.accelerators.base_accelerator][INFO] - Training progress: step=56400/100000 (56.40%), epoch=1, lr=1e-05, speed=1.956 step/s, elapsed=08:00:27, eta=06:11:25 +[2026-04-16 07:19:38,407][trainer.accelerators.base_accelerator][INFO] - Training progress: step=56450/100000 (56.45%), epoch=1, lr=1e-05, speed=1.957 step/s, elapsed=08:00:49, eta=06:10:56 +[2026-04-16 07:20:00,461][trainer.accelerators.base_accelerator][INFO] - Training progress: step=56500/100000 (56.50%), epoch=1, lr=1e-05, speed=1.957 step/s, elapsed=08:01:11, eta=06:10:28 +[2026-04-16 07:20:22,903][trainer.accelerators.base_accelerator][INFO] - Training progress: step=56550/100000 (56.55%), epoch=1, lr=1e-05, speed=1.957 step/s, elapsed=08:01:34, eta=06:10:00 +[2026-04-16 07:20:44,986][trainer.accelerators.base_accelerator][INFO] - Training progress: step=56600/100000 (56.60%), epoch=1, lr=1e-05, speed=1.957 step/s, elapsed=08:01:56, eta=06:09:32 +[2026-04-16 07:21:06,981][trainer.accelerators.base_accelerator][INFO] - Training progress: step=56650/100000 (56.65%), epoch=1, lr=1e-05, speed=1.958 step/s, elapsed=08:02:18, eta=06:09:04 +[2026-04-16 07:21:29,053][trainer.accelerators.base_accelerator][INFO] - Training progress: step=56700/100000 (56.70%), epoch=1, lr=1e-05, speed=1.958 step/s, elapsed=08:02:40, eta=06:08:36 +[2026-04-16 07:21:51,175][trainer.accelerators.base_accelerator][INFO] - Training progress: step=56750/100000 (56.75%), epoch=1, lr=1e-05, speed=1.958 step/s, elapsed=08:03:02, eta=06:08:07 +[2026-04-16 07:22:13,515][trainer.accelerators.base_accelerator][INFO] - Training progress: step=56800/100000 (56.80%), epoch=1, lr=1e-05, speed=1.958 step/s, elapsed=08:03:24, eta=06:07:39 +[2026-04-16 07:23:44,512][trainer.accelerators.base_accelerator][INFO] - Training progress: step=56850/100000 (56.85%), epoch=1, lr=1e-05, speed=1.954 step/s, elapsed=08:04:55, eta=06:08:04 +[2026-04-16 07:24:30,543][trainer.accelerators.base_accelerator][INFO] - Training progress: step=56900/100000 (56.90%), epoch=1, lr=1e-05, speed=1.953 step/s, elapsed=08:05:41, eta=06:07:54 +[2026-04-16 07:25:28,257][trainer.accelerators.base_accelerator][INFO] - Training progress: step=56950/100000 (56.95%), epoch=1, lr=1e-05, speed=1.950 step/s, elapsed=08:06:39, eta=06:07:52 +[2026-04-16 07:26:45,525][trainer.accelerators.base_accelerator][INFO] - Training progress: step=57000/100000 (57.00%), epoch=1, lr=1e-05, speed=1.947 step/s, elapsed=08:07:56, eta=06:08:05 +[2026-04-16 07:26:45,551][__main__][INFO] - ========== EVAL START (periodic@gstep=57000) ========== +[2026-04-16 07:26:45,551][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-16 07:26:45,551][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 07:27:52,556][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.73575496673584, 'accuracy': 0.4894117647058824, 'num_samples': 425, 'test_unique_accuracy': 0.5046296296296297, 'test_unique_num_samples': 432} +[2026-04-16 07:27:52,559][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-16 07:27:52,560][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 07:28:26,451][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.73575496673584, 'accuracy': 0.4894117647058824, 'num_samples': 425, 'test_unique_accuracy': 0.5046296296296297, 'test_unique_num_samples': 432} +[2026-04-16 07:28:26,452][__main__][INFO] - ========== EVAL END (periodic@gstep=57000) ========== +[2026-04-16 07:28:26,454][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.769704818725586, 'accuracy': 0.4894117647058824, 'num_samples': 425, 'test_unique_accuracy': 0.5046296296296297, 'test_unique_num_samples': 432} +[2026-04-16 07:28:26,460][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.4894117647058824 is not better than 0.56 of logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep33000, skipping checkpoint +[2026-04-16 07:29:03,561][trainer.accelerators.base_accelerator][INFO] - Training progress: step=57050/100000 (57.05%), epoch=1, lr=1e-05, speed=1.939 step/s, elapsed=08:10:14, eta=06:09:04 +[2026-04-16 07:29:26,900][trainer.accelerators.base_accelerator][INFO] - Training progress: step=57100/100000 (57.10%), epoch=1, lr=1e-05, speed=1.940 step/s, elapsed=08:10:38, eta=06:08:37 +[2026-04-16 07:29:49,122][trainer.accelerators.base_accelerator][INFO] - Training progress: step=57150/100000 (57.15%), epoch=1, lr=1e-05, speed=1.940 step/s, elapsed=08:11:00, eta=06:08:08 +[2026-04-16 07:30:11,281][trainer.accelerators.base_accelerator][INFO] - Training progress: step=57200/100000 (57.20%), epoch=1, lr=1e-05, speed=1.940 step/s, elapsed=08:11:22, eta=06:07:40 +[2026-04-16 07:30:33,443][trainer.accelerators.base_accelerator][INFO] - Training progress: step=57250/100000 (57.25%), epoch=1, lr=1e-05, speed=1.940 step/s, elapsed=08:11:44, eta=06:07:11 +[2026-04-16 07:30:55,598][trainer.accelerators.base_accelerator][INFO] - Training progress: step=57300/100000 (57.30%), epoch=1, lr=1e-05, speed=1.941 step/s, elapsed=08:12:06, eta=06:06:43 +[2026-04-16 07:31:18,321][trainer.accelerators.base_accelerator][INFO] - Training progress: step=57350/100000 (57.35%), epoch=1, lr=1e-05, speed=1.941 step/s, elapsed=08:12:29, eta=06:06:15 +[2026-04-16 07:31:40,533][trainer.accelerators.base_accelerator][INFO] - Training progress: step=57400/100000 (57.40%), epoch=1, lr=1e-05, speed=1.941 step/s, elapsed=08:12:51, eta=06:05:47 +[2026-04-16 07:32:02,665][trainer.accelerators.base_accelerator][INFO] - Training progress: step=57450/100000 (57.45%), epoch=1, lr=1e-05, speed=1.941 step/s, elapsed=08:13:13, eta=06:05:18 +[2026-04-16 07:32:24,806][trainer.accelerators.base_accelerator][INFO] - Training progress: step=57500/100000 (57.50%), epoch=1, lr=1e-05, speed=1.942 step/s, elapsed=08:13:36, eta=06:04:50 +[2026-04-16 07:32:46,949][trainer.accelerators.base_accelerator][INFO] - Training progress: step=57550/100000 (57.55%), epoch=1, lr=1e-05, speed=1.942 step/s, elapsed=08:13:58, eta=06:04:21 +[2026-04-16 07:33:09,093][trainer.accelerators.base_accelerator][INFO] - Training progress: step=57600/100000 (57.60%), epoch=1, lr=1e-05, speed=1.942 step/s, elapsed=08:14:20, eta=06:03:53 +[2026-04-16 07:33:31,687][trainer.accelerators.base_accelerator][INFO] - Training progress: step=57650/100000 (57.65%), epoch=1, lr=1e-05, speed=1.942 step/s, elapsed=08:14:42, eta=06:03:25 +[2026-04-16 07:33:53,865][trainer.accelerators.base_accelerator][INFO] - Training progress: step=57700/100000 (57.70%), epoch=1, lr=1e-05, speed=1.942 step/s, elapsed=08:15:05, eta=06:02:56 +[2026-04-16 07:34:15,794][trainer.accelerators.base_accelerator][INFO] - Training progress: step=57750/100000 (57.75%), epoch=1, lr=1e-05, speed=1.943 step/s, elapsed=08:15:27, eta=06:02:28 +[2026-04-16 07:34:37,943][trainer.accelerators.base_accelerator][INFO] - Training progress: step=57800/100000 (57.80%), epoch=1, lr=1e-05, speed=1.943 step/s, elapsed=08:15:49, eta=06:02:00 +[2026-04-16 07:35:00,043][trainer.accelerators.base_accelerator][INFO] - Training progress: step=57850/100000 (57.85%), epoch=1, lr=1e-05, speed=1.943 step/s, elapsed=08:16:11, eta=06:01:31 +[2026-04-16 07:35:22,218][trainer.accelerators.base_accelerator][INFO] - Training progress: step=57900/100000 (57.90%), epoch=1, lr=1e-05, speed=1.943 step/s, elapsed=08:16:33, eta=06:01:03 +[2026-04-16 07:36:43,846][trainer.accelerators.base_accelerator][INFO] - Training progress: step=57950/100000 (57.95%), epoch=1, lr=1e-05, speed=1.940 step/s, elapsed=08:17:55, eta=06:01:18 +[2026-04-16 07:38:34,453][trainer.accelerators.base_accelerator][INFO] - Training progress: step=58000/100000 (58.00%), epoch=1, lr=1e-05, speed=1.934 step/s, elapsed=08:19:45, eta=06:01:53 +[2026-04-16 07:38:34,478][__main__][INFO] - ========== EVAL START (periodic@gstep=58000) ========== +[2026-04-16 07:38:34,478][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-16 07:38:34,478][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 07:39:06,049][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.769704818725586, 'accuracy': 0.4988235294117647, 'num_samples': 425, 'test_unique_accuracy': 0.5046296296296297, 'test_unique_num_samples': 432} +[2026-04-16 07:39:06,052][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-16 07:39:06,052][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 07:39:30,630][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.769704818725586, 'accuracy': 0.4988235294117647, 'num_samples': 425, 'test_unique_accuracy': 0.5185185185185185, 'test_unique_num_samples': 432} +[2026-04-16 07:39:30,631][__main__][INFO] - ========== EVAL END (periodic@gstep=58000) ========== +[2026-04-16 07:39:30,632][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.795503616333008, 'accuracy': 0.4988235294117647, 'num_samples': 425, 'test_unique_accuracy': 0.5185185185185185, 'test_unique_num_samples': 432} +[2026-04-16 07:39:30,638][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.4988235294117647 is not better than 0.56 of logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep33000, skipping checkpoint +[2026-04-16 07:40:03,751][trainer.accelerators.base_accelerator][INFO] - Training progress: step=58050/100000 (58.05%), epoch=1, lr=1e-05, speed=1.930 step/s, elapsed=08:21:15, eta=06:02:13 +[2026-04-16 07:40:25,956][trainer.accelerators.base_accelerator][INFO] - Training progress: step=58100/100000 (58.10%), epoch=1, lr=1e-05, speed=1.930 step/s, elapsed=08:21:37, eta=06:01:45 +[2026-04-16 07:40:48,128][trainer.accelerators.base_accelerator][INFO] - Training progress: step=58150/100000 (58.15%), epoch=1, lr=1e-05, speed=1.931 step/s, elapsed=08:21:59, eta=06:01:16 +[2026-04-16 07:41:10,854][trainer.accelerators.base_accelerator][INFO] - Training progress: step=58200/100000 (58.20%), epoch=1, lr=1e-05, speed=1.931 step/s, elapsed=08:22:22, eta=06:00:48 +[2026-04-16 07:41:33,856][trainer.accelerators.base_accelerator][INFO] - Training progress: step=58250/100000 (58.25%), epoch=1, lr=1e-05, speed=1.931 step/s, elapsed=08:22:45, eta=06:00:20 +[2026-04-16 07:41:55,970][trainer.accelerators.base_accelerator][INFO] - Training progress: step=58300/100000 (58.30%), epoch=1, lr=1e-05, speed=1.931 step/s, elapsed=08:23:07, eta=05:59:51 +[2026-04-16 07:42:17,967][trainer.accelerators.base_accelerator][INFO] - Training progress: step=58350/100000 (58.35%), epoch=1, lr=1e-05, speed=1.932 step/s, elapsed=08:23:29, eta=05:59:23 +[2026-04-16 07:42:40,554][trainer.accelerators.base_accelerator][INFO] - Training progress: step=58400/100000 (58.40%), epoch=1, lr=1e-05, speed=1.932 step/s, elapsed=08:23:51, eta=05:58:54 +[2026-04-16 07:43:02,714][trainer.accelerators.base_accelerator][INFO] - Training progress: step=58450/100000 (58.45%), epoch=1, lr=1e-05, speed=1.932 step/s, elapsed=08:24:13, eta=05:58:26 +[2026-04-16 07:43:24,924][trainer.accelerators.base_accelerator][INFO] - Training progress: step=58500/100000 (58.50%), epoch=1, lr=1e-05, speed=1.932 step/s, elapsed=08:24:36, eta=05:57:57 +[2026-04-16 07:43:47,172][trainer.accelerators.base_accelerator][INFO] - Training progress: step=58550/100000 (58.55%), epoch=1, lr=1e-05, speed=1.932 step/s, elapsed=08:24:58, eta=05:57:29 +[2026-04-16 07:44:09,237][trainer.accelerators.base_accelerator][INFO] - Training progress: step=58600/100000 (58.60%), epoch=1, lr=1e-05, speed=1.933 step/s, elapsed=08:25:20, eta=05:57:00 +[2026-04-16 07:44:31,482][trainer.accelerators.base_accelerator][INFO] - Training progress: step=58650/100000 (58.65%), epoch=1, lr=1e-05, speed=1.933 step/s, elapsed=08:25:42, eta=05:56:32 +[2026-04-16 07:44:53,615][trainer.accelerators.base_accelerator][INFO] - Training progress: step=58700/100000 (58.70%), epoch=1, lr=1e-05, speed=1.933 step/s, elapsed=08:26:04, eta=05:56:04 +[2026-04-16 07:45:15,781][trainer.accelerators.base_accelerator][INFO] - Training progress: step=58750/100000 (58.75%), epoch=1, lr=1e-05, speed=1.933 step/s, elapsed=08:26:27, eta=05:55:35 +[2026-04-16 07:45:37,887][trainer.accelerators.base_accelerator][INFO] - Training progress: step=58800/100000 (58.80%), epoch=1, lr=1e-05, speed=1.934 step/s, elapsed=08:26:49, eta=05:55:07 +[2026-04-16 07:46:00,068][trainer.accelerators.base_accelerator][INFO] - Training progress: step=58850/100000 (58.85%), epoch=1, lr=1e-05, speed=1.934 step/s, elapsed=08:27:11, eta=05:54:38 +[2026-04-16 07:46:22,402][trainer.accelerators.base_accelerator][INFO] - Training progress: step=58900/100000 (58.90%), epoch=1, lr=1e-05, speed=1.934 step/s, elapsed=08:27:33, eta=05:54:10 +[2026-04-16 07:46:44,485][trainer.accelerators.base_accelerator][INFO] - Training progress: step=58950/100000 (58.95%), epoch=1, lr=1e-05, speed=1.934 step/s, elapsed=08:27:55, eta=05:53:41 +[2026-04-16 07:47:06,590][trainer.accelerators.base_accelerator][INFO] - Training progress: step=59000/100000 (59.00%), epoch=1, lr=1e-05, speed=1.935 step/s, elapsed=08:28:17, eta=05:53:13 +[2026-04-16 07:47:06,628][__main__][INFO] - ========== EVAL START (periodic@gstep=59000) ========== +[2026-04-16 07:47:06,629][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-16 07:47:06,629][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 07:47:21,744][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.795503616333008, 'accuracy': 0.4964705882352941, 'num_samples': 425, 'test_unique_accuracy': 0.5185185185185185, 'test_unique_num_samples': 432} +[2026-04-16 07:47:21,745][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-16 07:47:21,745][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 07:47:36,880][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.795503616333008, 'accuracy': 0.4964705882352941, 'num_samples': 425, 'test_unique_accuracy': 0.5300925925925926, 'test_unique_num_samples': 432} +[2026-04-16 07:47:36,880][__main__][INFO] - ========== EVAL END (periodic@gstep=59000) ========== +[2026-04-16 07:47:36,881][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.820926666259766, 'accuracy': 0.4964705882352941, 'num_samples': 425, 'test_unique_accuracy': 0.5300925925925926, 'test_unique_num_samples': 432} +[2026-04-16 07:47:36,886][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.4964705882352941 is not better than 0.56 of logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep33000, skipping checkpoint +[2026-04-16 07:47:59,042][trainer.accelerators.base_accelerator][INFO] - Training progress: step=59050/100000 (59.05%), epoch=1, lr=1e-05, speed=1.933 step/s, elapsed=08:29:10, eta=05:53:06 +[2026-04-16 07:49:47,215][trainer.accelerators.base_accelerator][INFO] - Training progress: step=59100/100000 (59.10%), epoch=1, lr=1e-05, speed=1.928 step/s, elapsed=08:30:58, eta=05:53:37 +[2026-04-16 07:50:23,836][trainer.accelerators.base_accelerator][INFO] - Training progress: step=59150/100000 (59.15%), epoch=1, lr=1e-05, speed=1.927 step/s, elapsed=08:31:35, eta=05:53:18 +[2026-04-16 07:51:32,276][trainer.accelerators.base_accelerator][INFO] - Training progress: step=59200/100000 (59.20%), epoch=1, lr=1e-05, speed=1.924 step/s, elapsed=08:32:43, eta=05:53:21 +[2026-04-16 07:51:54,426][trainer.accelerators.base_accelerator][INFO] - Training progress: step=59250/100000 (59.25%), epoch=1, lr=1e-05, speed=1.925 step/s, elapsed=08:33:05, eta=05:52:53 +[2026-04-16 07:52:16,469][trainer.accelerators.base_accelerator][INFO] - Training progress: step=59300/100000 (59.30%), epoch=1, lr=1e-05, speed=1.925 step/s, elapsed=08:33:27, eta=05:52:24 +[2026-04-16 07:52:38,584][trainer.accelerators.base_accelerator][INFO] - Training progress: step=59350/100000 (59.35%), epoch=1, lr=1e-05, speed=1.925 step/s, elapsed=08:33:49, eta=05:51:55 +[2026-04-16 07:53:00,748][trainer.accelerators.base_accelerator][INFO] - Training progress: step=59400/100000 (59.40%), epoch=1, lr=1e-05, speed=1.925 step/s, elapsed=08:34:11, eta=05:51:27 +[2026-04-16 07:53:22,887][trainer.accelerators.base_accelerator][INFO] - Training progress: step=59450/100000 (59.45%), epoch=1, lr=1e-05, speed=1.926 step/s, elapsed=08:34:34, eta=05:50:58 +[2026-04-16 07:53:45,050][trainer.accelerators.base_accelerator][INFO] - Training progress: step=59500/100000 (59.50%), epoch=1, lr=1e-05, speed=1.926 step/s, elapsed=08:34:56, eta=05:50:30 +[2026-04-16 07:54:07,048][trainer.accelerators.base_accelerator][INFO] - Training progress: step=59550/100000 (59.55%), epoch=1, lr=1e-05, speed=1.926 step/s, elapsed=08:35:18, eta=05:50:01 +[2026-04-16 07:54:29,168][trainer.accelerators.base_accelerator][INFO] - Training progress: step=59600/100000 (59.60%), epoch=1, lr=1e-05, speed=1.926 step/s, elapsed=08:35:40, eta=05:49:33 +[2026-04-16 07:54:51,263][trainer.accelerators.base_accelerator][INFO] - Training progress: step=59650/100000 (59.65%), epoch=1, lr=1e-05, speed=1.927 step/s, elapsed=08:36:02, eta=05:49:04 +[2026-04-16 07:55:13,554][trainer.accelerators.base_accelerator][INFO] - Training progress: step=59700/100000 (59.70%), epoch=1, lr=1e-05, speed=1.927 step/s, elapsed=08:36:24, eta=05:48:36 +[2026-04-16 07:55:39,241][trainer.accelerators.base_accelerator][INFO] - Training progress: step=59750/100000 (59.75%), epoch=1, lr=1e-05, speed=1.927 step/s, elapsed=08:36:50, eta=05:48:09 +[2026-04-16 07:56:01,296][trainer.accelerators.base_accelerator][INFO] - Training progress: step=59800/100000 (59.80%), epoch=1, lr=1e-05, speed=1.927 step/s, elapsed=08:37:12, eta=05:47:41 +[2026-04-16 07:56:23,815][trainer.accelerators.base_accelerator][INFO] - Training progress: step=59850/100000 (59.85%), epoch=1, lr=1e-05, speed=1.927 step/s, elapsed=08:37:35, eta=05:47:13 +[2026-04-16 07:56:45,919][trainer.accelerators.base_accelerator][INFO] - Training progress: step=59900/100000 (59.90%), epoch=1, lr=1e-05, speed=1.927 step/s, elapsed=08:37:57, eta=05:46:44 +[2026-04-16 07:57:07,969][trainer.accelerators.base_accelerator][INFO] - Training progress: step=59950/100000 (59.95%), epoch=1, lr=1e-05, speed=1.928 step/s, elapsed=08:38:19, eta=05:46:16 +[2026-04-16 07:57:30,085][trainer.accelerators.base_accelerator][INFO] - Training progress: step=60000/100000 (60.00%), epoch=1, lr=1e-05, speed=1.928 step/s, elapsed=08:38:41, eta=05:45:47 +[2026-04-16 07:57:30,124][__main__][INFO] - ========== EVAL START (periodic@gstep=60000) ========== +[2026-04-16 07:57:30,124][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-16 07:57:30,124][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 07:57:45,424][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.820926666259766, 'accuracy': 0.4964705882352941, 'num_samples': 425, 'test_unique_accuracy': 0.5300925925925926, 'test_unique_num_samples': 432} +[2026-04-16 07:57:45,425][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-16 07:57:45,425][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 07:58:00,566][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.820926666259766, 'accuracy': 0.4964705882352941, 'num_samples': 425, 'test_unique_accuracy': 0.4861111111111111, 'test_unique_num_samples': 432} +[2026-04-16 07:58:00,566][__main__][INFO] - ========== EVAL END (periodic@gstep=60000) ========== +[2026-04-16 07:58:00,567][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.853610038757324, 'accuracy': 0.4964705882352941, 'num_samples': 425, 'test_unique_accuracy': 0.4861111111111111, 'test_unique_num_samples': 432} +[2026-04-16 07:58:00,571][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.4964705882352941 is not better than 0.56 of logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep33000, skipping checkpoint +[2026-04-16 07:58:22,565][trainer.accelerators.base_accelerator][INFO] - Training progress: step=60050/100000 (60.05%), epoch=1, lr=1e-05, speed=1.926 step/s, elapsed=08:39:33, eta=05:45:39 +[2026-04-16 07:58:44,640][trainer.accelerators.base_accelerator][INFO] - Training progress: step=60100/100000 (60.10%), epoch=1, lr=1e-05, speed=1.927 step/s, elapsed=08:39:55, eta=05:45:10 +[2026-04-16 07:59:06,666][trainer.accelerators.base_accelerator][INFO] - Training progress: step=60150/100000 (60.15%), epoch=1, lr=1e-05, speed=1.927 step/s, elapsed=08:40:17, eta=05:44:42 +[2026-04-16 07:59:28,791][trainer.accelerators.base_accelerator][INFO] - Training progress: step=60200/100000 (60.20%), epoch=1, lr=1e-05, speed=1.927 step/s, elapsed=08:40:40, eta=05:44:13 +[2026-04-16 07:59:50,842][trainer.accelerators.base_accelerator][INFO] - Training progress: step=60250/100000 (60.25%), epoch=1, lr=1e-05, speed=1.927 step/s, elapsed=08:41:02, eta=05:43:45 +[2026-04-16 08:00:12,976][trainer.accelerators.base_accelerator][INFO] - Training progress: step=60300/100000 (60.30%), epoch=1, lr=1e-05, speed=1.927 step/s, elapsed=08:41:24, eta=05:43:16 +[2026-04-16 08:00:35,325][trainer.accelerators.base_accelerator][INFO] - Training progress: step=60350/100000 (60.35%), epoch=1, lr=1e-05, speed=1.928 step/s, elapsed=08:41:46, eta=05:42:48 +[2026-04-16 08:00:57,389][trainer.accelerators.base_accelerator][INFO] - Training progress: step=60400/100000 (60.40%), epoch=1, lr=1e-05, speed=1.928 step/s, elapsed=08:42:08, eta=05:42:19 +[2026-04-16 08:01:19,209][trainer.accelerators.base_accelerator][INFO] - Training progress: step=60450/100000 (60.45%), epoch=1, lr=1e-05, speed=1.928 step/s, elapsed=08:42:30, eta=05:41:51 +[2026-04-16 08:01:41,315][trainer.accelerators.base_accelerator][INFO] - Training progress: step=60500/100000 (60.50%), epoch=1, lr=1e-05, speed=1.928 step/s, elapsed=08:42:52, eta=05:41:22 +[2026-04-16 08:02:03,451][trainer.accelerators.base_accelerator][INFO] - Training progress: step=60550/100000 (60.55%), epoch=1, lr=1e-05, speed=1.929 step/s, elapsed=08:43:14, eta=05:40:54 +[2026-04-16 08:02:25,570][trainer.accelerators.base_accelerator][INFO] - Training progress: step=60600/100000 (60.60%), epoch=1, lr=1e-05, speed=1.929 step/s, elapsed=08:43:36, eta=05:40:26 +[2026-04-16 08:02:47,572][trainer.accelerators.base_accelerator][INFO] - Training progress: step=60650/100000 (60.65%), epoch=1, lr=1e-05, speed=1.929 step/s, elapsed=08:43:58, eta=05:39:57 +[2026-04-16 08:03:09,611][trainer.accelerators.base_accelerator][INFO] - Training progress: step=60700/100000 (60.70%), epoch=1, lr=1e-05, speed=1.929 step/s, elapsed=08:44:20, eta=05:39:29 +[2026-04-16 08:03:31,698][trainer.accelerators.base_accelerator][INFO] - Training progress: step=60750/100000 (60.75%), epoch=1, lr=1e-05, speed=1.930 step/s, elapsed=08:44:42, eta=05:39:00 +[2026-04-16 08:03:54,261][trainer.accelerators.base_accelerator][INFO] - Training progress: step=60800/100000 (60.80%), epoch=1, lr=1e-05, speed=1.930 step/s, elapsed=08:45:05, eta=05:38:32 +[2026-04-16 08:05:51,221][trainer.accelerators.base_accelerator][INFO] - Training progress: step=60850/100000 (60.85%), epoch=1, lr=1e-05, speed=1.924 step/s, elapsed=08:47:02, eta=05:39:05 +[2026-04-16 08:07:03,894][trainer.accelerators.base_accelerator][INFO] - Training progress: step=60900/100000 (60.90%), epoch=1, lr=1e-05, speed=1.921 step/s, elapsed=08:48:15, eta=05:39:09 +[2026-04-16 08:08:29,527][trainer.accelerators.base_accelerator][INFO] - Training progress: step=60950/100000 (60.95%), epoch=1, lr=1e-05, speed=1.918 step/s, elapsed=08:49:40, eta=05:39:21 +[2026-04-16 08:09:12,723][trainer.accelerators.base_accelerator][INFO] - Training progress: step=61000/100000 (61.00%), epoch=1, lr=1e-05, speed=1.917 step/s, elapsed=08:50:23, eta=05:39:06 +[2026-04-16 08:09:12,764][__main__][INFO] - ========== EVAL START (periodic@gstep=61000) ========== +[2026-04-16 08:09:12,765][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-16 08:09:12,765][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 08:09:52,172][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.853610038757324, 'accuracy': 0.5270588235294118, 'num_samples': 425, 'test_unique_accuracy': 0.4861111111111111, 'test_unique_num_samples': 432} +[2026-04-16 08:09:52,176][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-16 08:09:52,177][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 08:10:17,302][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.853610038757324, 'accuracy': 0.5270588235294118, 'num_samples': 425, 'test_unique_accuracy': 0.4699074074074074, 'test_unique_num_samples': 432} +[2026-04-16 08:10:17,308][__main__][INFO] - ========== EVAL END (periodic@gstep=61000) ========== +[2026-04-16 08:10:17,314][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.876128196716309, 'accuracy': 0.5270588235294118, 'num_samples': 425, 'test_unique_accuracy': 0.4699074074074074, 'test_unique_num_samples': 432} +[2026-04-16 08:10:17,330][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.5270588235294118 is not better than 0.56 of logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep33000, skipping checkpoint +[2026-04-16 08:10:58,024][trainer.accelerators.base_accelerator][INFO] - Training progress: step=61050/100000 (61.05%), epoch=1, lr=1e-05, speed=1.912 step/s, elapsed=08:52:09, eta=05:39:30 +[2026-04-16 08:11:24,650][trainer.accelerators.base_accelerator][INFO] - Training progress: step=61100/100000 (61.10%), epoch=1, lr=1e-05, speed=1.912 step/s, elapsed=08:52:35, eta=05:39:05 +[2026-04-16 08:11:46,890][trainer.accelerators.base_accelerator][INFO] - Training progress: step=61150/100000 (61.15%), epoch=1, lr=1e-05, speed=1.912 step/s, elapsed=08:52:58, eta=05:38:36 +[2026-04-16 08:12:09,081][trainer.accelerators.base_accelerator][INFO] - Training progress: step=61200/100000 (61.20%), epoch=1, lr=1e-05, speed=1.912 step/s, elapsed=08:53:20, eta=05:38:07 +[2026-04-16 08:12:31,278][trainer.accelerators.base_accelerator][INFO] - Training progress: step=61250/100000 (61.25%), epoch=1, lr=1e-05, speed=1.913 step/s, elapsed=08:53:42, eta=05:37:39 +[2026-04-16 08:12:54,165][trainer.accelerators.base_accelerator][INFO] - Training progress: step=61300/100000 (61.30%), epoch=1, lr=1e-05, speed=1.913 step/s, elapsed=08:54:05, eta=05:37:10 +[2026-04-16 08:13:16,283][trainer.accelerators.base_accelerator][INFO] - Training progress: step=61350/100000 (61.35%), epoch=1, lr=1e-05, speed=1.913 step/s, elapsed=08:54:27, eta=05:36:42 +[2026-04-16 08:13:40,241][trainer.accelerators.base_accelerator][INFO] - Training progress: step=61400/100000 (61.40%), epoch=1, lr=1e-05, speed=1.913 step/s, elapsed=08:54:51, eta=05:36:14 +[2026-04-16 08:14:02,217][trainer.accelerators.base_accelerator][INFO] - Training progress: step=61450/100000 (61.45%), epoch=1, lr=1e-05, speed=1.914 step/s, elapsed=08:55:13, eta=05:35:46 +[2026-04-16 08:14:24,387][trainer.accelerators.base_accelerator][INFO] - Training progress: step=61500/100000 (61.50%), epoch=1, lr=1e-05, speed=1.914 step/s, elapsed=08:55:35, eta=05:35:17 +[2026-04-16 08:14:46,443][trainer.accelerators.base_accelerator][INFO] - Training progress: step=61550/100000 (61.55%), epoch=1, lr=1e-05, speed=1.914 step/s, elapsed=08:55:57, eta=05:34:48 +[2026-04-16 08:15:08,668][trainer.accelerators.base_accelerator][INFO] - Training progress: step=61600/100000 (61.60%), epoch=1, lr=1e-05, speed=1.914 step/s, elapsed=08:56:19, eta=05:34:20 +[2026-04-16 08:15:30,776][trainer.accelerators.base_accelerator][INFO] - Training progress: step=61650/100000 (61.65%), epoch=1, lr=1e-05, speed=1.914 step/s, elapsed=08:56:42, eta=05:33:51 +[2026-04-16 08:15:52,933][trainer.accelerators.base_accelerator][INFO] - Training progress: step=61700/100000 (61.70%), epoch=1, lr=1e-05, speed=1.915 step/s, elapsed=08:57:04, eta=05:33:23 +[2026-04-16 08:16:15,175][trainer.accelerators.base_accelerator][INFO] - Training progress: step=61750/100000 (61.75%), epoch=1, lr=1e-05, speed=1.915 step/s, elapsed=08:57:26, eta=05:32:54 +[2026-04-16 08:16:37,261][trainer.accelerators.base_accelerator][INFO] - Training progress: step=61800/100000 (61.80%), epoch=1, lr=1e-05, speed=1.915 step/s, elapsed=08:57:48, eta=05:32:25 +[2026-04-16 08:16:59,419][trainer.accelerators.base_accelerator][INFO] - Training progress: step=61850/100000 (61.85%), epoch=1, lr=1e-05, speed=1.915 step/s, elapsed=08:58:10, eta=05:31:57 +[2026-04-16 08:17:21,948][trainer.accelerators.base_accelerator][INFO] - Training progress: step=61900/100000 (61.90%), epoch=1, lr=1e-05, speed=1.916 step/s, elapsed=08:58:33, eta=05:31:29 +[2026-04-16 08:17:52,053][trainer.accelerators.base_accelerator][INFO] - Training progress: step=61950/100000 (61.95%), epoch=1, lr=1e-05, speed=1.915 step/s, elapsed=08:59:03, eta=05:31:05 +[2026-04-16 08:18:14,207][trainer.accelerators.base_accelerator][INFO] - Training progress: step=62000/100000 (62.00%), epoch=1, lr=1e-05, speed=1.916 step/s, elapsed=08:59:25, eta=05:30:36 +[2026-04-16 08:18:14,245][__main__][INFO] - ========== EVAL START (periodic@gstep=62000) ========== +[2026-04-16 08:18:14,245][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-16 08:18:14,246][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 08:18:29,634][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.876128196716309, 'accuracy': 0.4752941176470588, 'num_samples': 425, 'test_unique_accuracy': 0.4699074074074074, 'test_unique_num_samples': 432} +[2026-04-16 08:18:29,635][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-16 08:18:29,635][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 08:18:44,801][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.876128196716309, 'accuracy': 0.4752941176470588, 'num_samples': 425, 'test_unique_accuracy': 0.5185185185185185, 'test_unique_num_samples': 432} +[2026-04-16 08:18:44,801][__main__][INFO] - ========== EVAL END (periodic@gstep=62000) ========== +[2026-04-16 08:18:44,802][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.896302223205566, 'accuracy': 0.4752941176470588, 'num_samples': 425, 'test_unique_accuracy': 0.5185185185185185, 'test_unique_num_samples': 432} +[2026-04-16 08:18:44,806][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.4752941176470588 is not better than 0.56 of logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep33000, skipping checkpoint +[2026-04-16 08:19:06,846][trainer.accelerators.base_accelerator][INFO] - Training progress: step=62050/100000 (62.05%), epoch=1, lr=1e-05, speed=1.914 step/s, elapsed=09:00:18, eta=05:30:27 +[2026-04-16 08:19:29,008][trainer.accelerators.base_accelerator][INFO] - Training progress: step=62100/100000 (62.10%), epoch=1, lr=1e-05, speed=1.914 step/s, elapsed=09:00:40, eta=05:29:58 +[2026-04-16 08:19:51,092][trainer.accelerators.base_accelerator][INFO] - Training progress: step=62150/100000 (62.15%), epoch=1, lr=1e-05, speed=1.915 step/s, elapsed=09:01:02, eta=05:29:29 +[2026-04-16 08:20:13,151][trainer.accelerators.base_accelerator][INFO] - Training progress: step=62200/100000 (62.20%), epoch=1, lr=1e-05, speed=1.915 step/s, elapsed=09:01:24, eta=05:29:01 +[2026-04-16 08:20:35,847][trainer.accelerators.base_accelerator][INFO] - Training progress: step=62250/100000 (62.25%), epoch=1, lr=1e-05, speed=1.915 step/s, elapsed=09:01:47, eta=05:28:33 +[2026-04-16 08:20:57,941][trainer.accelerators.base_accelerator][INFO] - Training progress: step=62300/100000 (62.30%), epoch=1, lr=1e-05, speed=1.915 step/s, elapsed=09:02:09, eta=05:28:04 +[2026-04-16 08:21:20,000][trainer.accelerators.base_accelerator][INFO] - Training progress: step=62350/100000 (62.35%), epoch=1, lr=1e-05, speed=1.915 step/s, elapsed=09:02:31, eta=05:27:36 +[2026-04-16 08:21:42,111][trainer.accelerators.base_accelerator][INFO] - Training progress: step=62400/100000 (62.40%), epoch=1, lr=1e-05, speed=1.916 step/s, elapsed=09:02:53, eta=05:27:07 +[2026-04-16 08:22:04,107][trainer.accelerators.base_accelerator][INFO] - Training progress: step=62450/100000 (62.45%), epoch=1, lr=1e-05, speed=1.916 step/s, elapsed=09:03:15, eta=05:26:38 +[2026-04-16 08:22:26,164][trainer.accelerators.base_accelerator][INFO] - Training progress: step=62500/100000 (62.50%), epoch=1, lr=1e-05, speed=1.916 step/s, elapsed=09:03:37, eta=05:26:10 +[2026-04-16 08:22:48,547][trainer.accelerators.base_accelerator][INFO] - Training progress: step=62550/100000 (62.55%), epoch=1, lr=1e-05, speed=1.916 step/s, elapsed=09:03:59, eta=05:25:42 +[2026-04-16 08:23:10,586][trainer.accelerators.base_accelerator][INFO] - Training progress: step=62600/100000 (62.60%), epoch=1, lr=1e-05, speed=1.917 step/s, elapsed=09:04:21, eta=05:25:13 +[2026-04-16 08:23:32,709][trainer.accelerators.base_accelerator][INFO] - Training progress: step=62650/100000 (62.65%), epoch=1, lr=1e-05, speed=1.917 step/s, elapsed=09:04:43, eta=05:24:45 +[2026-04-16 08:23:54,810][trainer.accelerators.base_accelerator][INFO] - Training progress: step=62700/100000 (62.70%), epoch=1, lr=1e-05, speed=1.917 step/s, elapsed=09:05:06, eta=05:24:16 +[2026-04-16 08:24:16,758][trainer.accelerators.base_accelerator][INFO] - Training progress: step=62750/100000 (62.75%), epoch=1, lr=1e-05, speed=1.917 step/s, elapsed=09:05:28, eta=05:23:48 +[2026-04-16 08:24:38,749][trainer.accelerators.base_accelerator][INFO] - Training progress: step=62800/100000 (62.80%), epoch=1, lr=1e-05, speed=1.918 step/s, elapsed=09:05:50, eta=05:23:19 +[2026-04-16 08:25:00,864][trainer.accelerators.base_accelerator][INFO] - Training progress: step=62850/100000 (62.85%), epoch=1, lr=1e-05, speed=1.918 step/s, elapsed=09:06:12, eta=05:22:51 +[2026-04-16 08:25:23,292][trainer.accelerators.base_accelerator][INFO] - Training progress: step=62900/100000 (62.90%), epoch=1, lr=1e-05, speed=1.918 step/s, elapsed=09:06:34, eta=05:22:23 +[2026-04-16 08:25:45,413][trainer.accelerators.base_accelerator][INFO] - Training progress: step=62950/100000 (62.95%), epoch=1, lr=1e-05, speed=1.918 step/s, elapsed=09:06:56, eta=05:21:54 +[2026-04-16 08:26:07,509][trainer.accelerators.base_accelerator][INFO] - Training progress: step=63000/100000 (63.00%), epoch=1, lr=1e-05, speed=1.918 step/s, elapsed=09:07:18, eta=05:21:26 +[2026-04-16 08:26:07,547][__main__][INFO] - ========== EVAL START (periodic@gstep=63000) ========== +[2026-04-16 08:26:07,547][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-16 08:26:07,547][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 08:26:22,547][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.896302223205566, 'accuracy': 0.48, 'num_samples': 425, 'test_unique_accuracy': 0.5185185185185185, 'test_unique_num_samples': 432} +[2026-04-16 08:26:22,548][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-16 08:26:22,548][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 08:26:37,609][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.896302223205566, 'accuracy': 0.48, 'num_samples': 425, 'test_unique_accuracy': 0.48842592592592593, 'test_unique_num_samples': 432} +[2026-04-16 08:26:37,610][__main__][INFO] - ========== EVAL END (periodic@gstep=63000) ========== +[2026-04-16 08:26:37,610][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.91658878326416, 'accuracy': 0.48, 'num_samples': 425, 'test_unique_accuracy': 0.48842592592592593, 'test_unique_num_samples': 432} +[2026-04-16 08:26:37,613][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.48 is not better than 0.56 of logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep33000, skipping checkpoint +[2026-04-16 08:26:59,610][trainer.accelerators.base_accelerator][INFO] - Training progress: step=63050/100000 (63.05%), epoch=1, lr=1e-05, speed=1.917 step/s, elapsed=09:08:10, eta=05:21:15 +[2026-04-16 08:27:21,752][trainer.accelerators.base_accelerator][INFO] - Training progress: step=63100/100000 (63.10%), epoch=1, lr=1e-05, speed=1.917 step/s, elapsed=09:08:33, eta=05:20:47 +[2026-04-16 08:27:44,139][trainer.accelerators.base_accelerator][INFO] - Training progress: step=63150/100000 (63.15%), epoch=1, lr=1e-05, speed=1.917 step/s, elapsed=09:08:55, eta=05:20:18 +[2026-04-16 08:28:06,257][trainer.accelerators.base_accelerator][INFO] - Training progress: step=63200/100000 (63.20%), epoch=1, lr=1e-05, speed=1.918 step/s, elapsed=09:09:17, eta=05:19:50 +[2026-04-16 08:28:28,343][trainer.accelerators.base_accelerator][INFO] - Training progress: step=63250/100000 (63.25%), epoch=1, lr=1e-05, speed=1.918 step/s, elapsed=09:09:39, eta=05:19:22 +[2026-04-16 08:28:50,297][trainer.accelerators.base_accelerator][INFO] - Training progress: step=63300/100000 (63.30%), epoch=1, lr=1e-05, speed=1.918 step/s, elapsed=09:10:01, eta=05:18:53 +[2026-04-16 08:29:12,404][trainer.accelerators.base_accelerator][INFO] - Training progress: step=63350/100000 (63.35%), epoch=1, lr=1e-05, speed=1.918 step/s, elapsed=09:10:23, eta=05:18:25 +[2026-04-16 08:29:34,646][trainer.accelerators.base_accelerator][INFO] - Training progress: step=63400/100000 (63.40%), epoch=1, lr=1e-05, speed=1.919 step/s, elapsed=09:10:45, eta=05:17:56 +[2026-04-16 08:29:56,731][trainer.accelerators.base_accelerator][INFO] - Training progress: step=63450/100000 (63.45%), epoch=1, lr=1e-05, speed=1.919 step/s, elapsed=09:11:07, eta=05:17:28 +[2026-04-16 08:30:18,781][trainer.accelerators.base_accelerator][INFO] - Training progress: step=63500/100000 (63.50%), epoch=1, lr=1e-05, speed=1.919 step/s, elapsed=09:11:30, eta=05:17:00 +[2026-04-16 08:30:40,881][trainer.accelerators.base_accelerator][INFO] - Training progress: step=63550/100000 (63.55%), epoch=1, lr=1e-05, speed=1.919 step/s, elapsed=09:11:52, eta=05:16:31 +[2026-04-16 08:31:02,939][trainer.accelerators.base_accelerator][INFO] - Training progress: step=63600/100000 (63.60%), epoch=1, lr=1e-05, speed=1.919 step/s, elapsed=09:12:14, eta=05:16:03 +[2026-04-16 08:31:25,318][trainer.accelerators.base_accelerator][INFO] - Training progress: step=63650/100000 (63.65%), epoch=1, lr=1e-05, speed=1.920 step/s, elapsed=09:12:36, eta=05:15:35 +[2026-04-16 08:31:47,460][trainer.accelerators.base_accelerator][INFO] - Training progress: step=63700/100000 (63.70%), epoch=1, lr=1e-05, speed=1.920 step/s, elapsed=09:12:58, eta=05:15:07 +[2026-04-16 08:32:09,542][trainer.accelerators.base_accelerator][INFO] - Training progress: step=63750/100000 (63.75%), epoch=1, lr=1e-05, speed=1.920 step/s, elapsed=09:13:20, eta=05:14:38 +[2026-04-16 08:32:31,607][trainer.accelerators.base_accelerator][INFO] - Training progress: step=63800/100000 (63.80%), epoch=1, lr=1e-05, speed=1.920 step/s, elapsed=09:13:42, eta=05:14:10 +[2026-04-16 08:32:53,693][trainer.accelerators.base_accelerator][INFO] - Training progress: step=63850/100000 (63.85%), epoch=1, lr=1e-05, speed=1.921 step/s, elapsed=09:14:04, eta=05:13:42 +[2026-04-16 08:33:16,054][trainer.accelerators.base_accelerator][INFO] - Training progress: step=63900/100000 (63.90%), epoch=1, lr=1e-05, speed=1.921 step/s, elapsed=09:14:27, eta=05:13:14 +[2026-04-16 08:33:38,126][trainer.accelerators.base_accelerator][INFO] - Training progress: step=63950/100000 (63.95%), epoch=1, lr=1e-05, speed=1.921 step/s, elapsed=09:14:49, eta=05:12:45 +[2026-04-16 08:34:00,240][trainer.accelerators.base_accelerator][INFO] - Training progress: step=64000/100000 (64.00%), epoch=1, lr=1e-05, speed=1.921 step/s, elapsed=09:15:11, eta=05:12:17 +[2026-04-16 08:34:00,279][__main__][INFO] - ========== EVAL START (periodic@gstep=64000) ========== +[2026-04-16 08:34:00,279][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-16 08:34:00,280][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 08:34:15,960][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.91658878326416, 'accuracy': 0.48705882352941177, 'num_samples': 425, 'test_unique_accuracy': 0.48842592592592593, 'test_unique_num_samples': 432} +[2026-04-16 08:34:15,960][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-16 08:34:15,961][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 08:34:31,136][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.91658878326416, 'accuracy': 0.48705882352941177, 'num_samples': 425, 'test_unique_accuracy': 0.46064814814814814, 'test_unique_num_samples': 432} +[2026-04-16 08:34:31,137][__main__][INFO] - ========== EVAL END (periodic@gstep=64000) ========== +[2026-04-16 08:34:31,139][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.935676574707031, 'accuracy': 0.48705882352941177, 'num_samples': 425, 'test_unique_accuracy': 0.46064814814814814, 'test_unique_num_samples': 432} +[2026-04-16 08:34:31,142][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.48705882352941177 is not better than 0.56 of logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep33000, skipping checkpoint +[2026-04-16 08:34:53,459][trainer.accelerators.base_accelerator][INFO] - Training progress: step=64050/100000 (64.05%), epoch=1, lr=1e-05, speed=1.920 step/s, elapsed=09:16:04, eta=05:12:06 +[2026-04-16 08:35:15,593][trainer.accelerators.base_accelerator][INFO] - Training progress: step=64100/100000 (64.10%), epoch=1, lr=1e-05, speed=1.920 step/s, elapsed=09:16:26, eta=05:11:38 +[2026-04-16 08:35:37,747][trainer.accelerators.base_accelerator][INFO] - Training progress: step=64150/100000 (64.15%), epoch=1, lr=1e-05, speed=1.920 step/s, elapsed=09:16:48, eta=05:11:10 +[2026-04-16 08:35:59,852][trainer.accelerators.base_accelerator][INFO] - Training progress: step=64200/100000 (64.20%), epoch=1, lr=1e-05, speed=1.920 step/s, elapsed=09:17:11, eta=05:10:42 +[2026-04-16 08:36:21,969][trainer.accelerators.base_accelerator][INFO] - Training progress: step=64250/100000 (64.25%), epoch=1, lr=1e-05, speed=1.921 step/s, elapsed=09:17:33, eta=05:10:14 +[2026-04-16 08:36:44,109][trainer.accelerators.base_accelerator][INFO] - Training progress: step=64300/100000 (64.30%), epoch=1, lr=1e-05, speed=1.921 step/s, elapsed=09:17:55, eta=05:09:45 +[2026-04-16 08:37:06,532][trainer.accelerators.base_accelerator][INFO] - Training progress: step=64350/100000 (64.35%), epoch=1, lr=1e-05, speed=1.921 step/s, elapsed=09:18:17, eta=05:09:17 +[2026-04-16 08:37:28,619][trainer.accelerators.base_accelerator][INFO] - Training progress: step=64400/100000 (64.40%), epoch=1, lr=1e-05, speed=1.921 step/s, elapsed=09:18:39, eta=05:08:49 +[2026-04-16 08:37:50,632][trainer.accelerators.base_accelerator][INFO] - Training progress: step=64450/100000 (64.45%), epoch=1, lr=1e-05, speed=1.921 step/s, elapsed=09:19:01, eta=05:08:21 +[2026-04-16 08:38:12,736][trainer.accelerators.base_accelerator][INFO] - Training progress: step=64500/100000 (64.50%), epoch=1, lr=1e-05, speed=1.922 step/s, elapsed=09:19:23, eta=05:07:53 +[2026-04-16 08:38:34,788][trainer.accelerators.base_accelerator][INFO] - Training progress: step=64550/100000 (64.55%), epoch=1, lr=1e-05, speed=1.922 step/s, elapsed=09:19:46, eta=05:07:25 +[2026-04-16 08:38:56,823][trainer.accelerators.base_accelerator][INFO] - Training progress: step=64600/100000 (64.60%), epoch=1, lr=1e-05, speed=1.922 step/s, elapsed=09:20:08, eta=05:06:56 +[2026-04-16 08:39:18,855][trainer.accelerators.base_accelerator][INFO] - Training progress: step=64650/100000 (64.65%), epoch=1, lr=1e-05, speed=1.922 step/s, elapsed=09:20:30, eta=05:06:28 +[2026-04-16 08:39:40,855][trainer.accelerators.base_accelerator][INFO] - Training progress: step=64700/100000 (64.70%), epoch=1, lr=1e-05, speed=1.923 step/s, elapsed=09:20:52, eta=05:06:00 +[2026-04-16 08:40:02,931][trainer.accelerators.base_accelerator][INFO] - Training progress: step=64750/100000 (64.75%), epoch=1, lr=1e-05, speed=1.923 step/s, elapsed=09:21:14, eta=05:05:32 +[2026-04-16 08:40:24,967][trainer.accelerators.base_accelerator][INFO] - Training progress: step=64800/100000 (64.80%), epoch=1, lr=1e-05, speed=1.923 step/s, elapsed=09:21:36, eta=05:05:04 +[2026-04-16 08:40:47,131][trainer.accelerators.base_accelerator][INFO] - Training progress: step=64850/100000 (64.85%), epoch=1, lr=1e-05, speed=1.923 step/s, elapsed=09:21:58, eta=05:04:36 +[2026-04-16 08:41:09,187][trainer.accelerators.base_accelerator][INFO] - Training progress: step=64900/100000 (64.90%), epoch=1, lr=1e-05, speed=1.924 step/s, elapsed=09:22:20, eta=05:04:07 +[2026-04-16 08:41:31,587][trainer.accelerators.base_accelerator][INFO] - Training progress: step=64950/100000 (64.95%), epoch=1, lr=1e-05, speed=1.924 step/s, elapsed=09:22:42, eta=05:03:39 +[2026-04-16 08:41:53,675][trainer.accelerators.base_accelerator][INFO] - Training progress: step=65000/100000 (65.00%), epoch=1, lr=1e-05, speed=1.924 step/s, elapsed=09:23:04, eta=05:03:11 +[2026-04-16 08:41:53,713][__main__][INFO] - ========== EVAL START (periodic@gstep=65000) ========== +[2026-04-16 08:41:53,714][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-16 08:41:53,714][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 08:42:08,779][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.935676574707031, 'accuracy': 0.49176470588235294, 'num_samples': 425, 'test_unique_accuracy': 0.46064814814814814, 'test_unique_num_samples': 432} +[2026-04-16 08:42:08,779][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-16 08:42:08,779][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 08:42:23,952][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.935676574707031, 'accuracy': 0.49176470588235294, 'num_samples': 425, 'test_unique_accuracy': 0.5208333333333334, 'test_unique_num_samples': 432} +[2026-04-16 08:42:23,952][__main__][INFO] - ========== EVAL END (periodic@gstep=65000) ========== +[2026-04-16 08:42:23,952][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.960817337036133, 'accuracy': 0.49176470588235294, 'num_samples': 425, 'test_unique_accuracy': 0.5208333333333334, 'test_unique_num_samples': 432} +[2026-04-16 08:42:23,955][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.49176470588235294 is not better than 0.56 of logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep33000, skipping checkpoint +[2026-04-16 08:42:46,037][trainer.accelerators.base_accelerator][INFO] - Training progress: step=65050/100000 (65.05%), epoch=1, lr=1e-05, speed=1.922 step/s, elapsed=09:23:57, eta=05:03:00 +[2026-04-16 08:43:08,048][trainer.accelerators.base_accelerator][INFO] - Training progress: step=65100/100000 (65.10%), epoch=1, lr=1e-05, speed=1.923 step/s, elapsed=09:24:19, eta=05:02:31 +[2026-04-16 08:43:30,044][trainer.accelerators.base_accelerator][INFO] - Training progress: step=65150/100000 (65.15%), epoch=1, lr=1e-05, speed=1.923 step/s, elapsed=09:24:41, eta=05:02:03 +[2026-04-16 08:43:52,114][trainer.accelerators.base_accelerator][INFO] - Training progress: step=65200/100000 (65.20%), epoch=1, lr=1e-05, speed=1.923 step/s, elapsed=09:25:03, eta=05:01:35 +[2026-04-16 08:44:14,232][trainer.accelerators.base_accelerator][INFO] - Training progress: step=65250/100000 (65.25%), epoch=1, lr=1e-05, speed=1.923 step/s, elapsed=09:25:25, eta=05:01:07 +[2026-04-16 08:44:36,274][trainer.accelerators.base_accelerator][INFO] - Training progress: step=65300/100000 (65.30%), epoch=1, lr=1e-05, speed=1.924 step/s, elapsed=09:25:47, eta=05:00:39 +[2026-04-16 08:44:58,221][trainer.accelerators.base_accelerator][INFO] - Training progress: step=65350/100000 (65.35%), epoch=1, lr=1e-05, speed=1.924 step/s, elapsed=09:26:09, eta=05:00:11 +[2026-04-16 08:45:20,677][trainer.accelerators.base_accelerator][INFO] - Training progress: step=65400/100000 (65.40%), epoch=1, lr=1e-05, speed=1.924 step/s, elapsed=09:26:31, eta=04:59:43 +[2026-04-16 08:45:42,789][trainer.accelerators.base_accelerator][INFO] - Training progress: step=65450/100000 (65.45%), epoch=1, lr=1e-05, speed=1.924 step/s, elapsed=09:26:54, eta=04:59:15 +[2026-04-16 08:46:04,870][trainer.accelerators.base_accelerator][INFO] - Training progress: step=65500/100000 (65.50%), epoch=1, lr=1e-05, speed=1.924 step/s, elapsed=09:27:16, eta=04:58:47 +[2026-04-16 08:46:26,954][trainer.accelerators.base_accelerator][INFO] - Training progress: step=65550/100000 (65.55%), epoch=1, lr=1e-05, speed=1.925 step/s, elapsed=09:27:38, eta=04:58:19 +[2026-04-16 08:46:48,964][trainer.accelerators.base_accelerator][INFO] - Training progress: step=65600/100000 (65.60%), epoch=1, lr=1e-05, speed=1.925 step/s, elapsed=09:28:00, eta=04:57:51 +[2026-04-16 08:47:11,027][trainer.accelerators.base_accelerator][INFO] - Training progress: step=65650/100000 (65.65%), epoch=1, lr=1e-05, speed=1.925 step/s, elapsed=09:28:22, eta=04:57:23 +[2026-04-16 08:47:33,006][trainer.accelerators.base_accelerator][INFO] - Training progress: step=65700/100000 (65.70%), epoch=1, lr=1e-05, speed=1.925 step/s, elapsed=09:28:44, eta=04:56:55 +[2026-04-16 08:47:55,052][trainer.accelerators.base_accelerator][INFO] - Training progress: step=65750/100000 (65.75%), epoch=1, lr=1e-05, speed=1.926 step/s, elapsed=09:29:06, eta=04:56:27 +[2026-04-16 08:48:17,014][trainer.accelerators.base_accelerator][INFO] - Training progress: step=65800/100000 (65.80%), epoch=1, lr=1e-05, speed=1.926 step/s, elapsed=09:29:28, eta=04:55:59 +[2026-04-16 08:48:39,076][trainer.accelerators.base_accelerator][INFO] - Training progress: step=65850/100000 (65.85%), epoch=1, lr=1e-05, speed=1.926 step/s, elapsed=09:29:50, eta=04:55:31 +[2026-04-16 08:49:01,446][trainer.accelerators.base_accelerator][INFO] - Training progress: step=65900/100000 (65.90%), epoch=1, lr=1e-05, speed=1.926 step/s, elapsed=09:30:12, eta=04:55:03 +[2026-04-16 08:49:23,501][trainer.accelerators.base_accelerator][INFO] - Training progress: step=65950/100000 (65.95%), epoch=1, lr=1e-05, speed=1.926 step/s, elapsed=09:30:34, eta=04:54:35 +[2026-04-16 08:49:45,577][trainer.accelerators.base_accelerator][INFO] - Training progress: step=66000/100000 (66.00%), epoch=1, lr=1e-05, speed=1.927 step/s, elapsed=09:30:56, eta=04:54:07 +[2026-04-16 08:49:45,615][__main__][INFO] - ========== EVAL START (periodic@gstep=66000) ========== +[2026-04-16 08:49:45,615][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-16 08:49:45,615][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 08:50:00,597][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.960817337036133, 'accuracy': 0.4894117647058824, 'num_samples': 425, 'test_unique_accuracy': 0.5208333333333334, 'test_unique_num_samples': 432} +[2026-04-16 08:50:00,597][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-16 08:50:00,597][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 08:50:15,664][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.960817337036133, 'accuracy': 0.4894117647058824, 'num_samples': 425, 'test_unique_accuracy': 0.5300925925925926, 'test_unique_num_samples': 432} +[2026-04-16 08:50:15,664][__main__][INFO] - ========== EVAL END (periodic@gstep=66000) ========== +[2026-04-16 08:50:15,665][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.979893684387207, 'accuracy': 0.4894117647058824, 'num_samples': 425, 'test_unique_accuracy': 0.5300925925925926, 'test_unique_num_samples': 432} +[2026-04-16 08:50:15,668][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.4894117647058824 is not better than 0.56 of logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep33000, skipping checkpoint +[2026-04-16 08:50:37,630][trainer.accelerators.base_accelerator][INFO] - Training progress: step=66050/100000 (66.05%), epoch=1, lr=1e-05, speed=1.925 step/s, elapsed=09:31:48, eta=04:53:54 +[2026-04-16 08:50:59,749][trainer.accelerators.base_accelerator][INFO] - Training progress: step=66100/100000 (66.10%), epoch=1, lr=1e-05, speed=1.925 step/s, elapsed=09:32:11, eta=04:53:26 +[2026-04-16 08:51:21,777][trainer.accelerators.base_accelerator][INFO] - Training progress: step=66150/100000 (66.15%), epoch=1, lr=1e-05, speed=1.926 step/s, elapsed=09:32:33, eta=04:52:58 +[2026-04-16 08:51:44,103][trainer.accelerators.base_accelerator][INFO] - Training progress: step=66200/100000 (66.20%), epoch=1, lr=1e-05, speed=1.926 step/s, elapsed=09:32:55, eta=04:52:31 +[2026-04-16 08:52:06,167][trainer.accelerators.base_accelerator][INFO] - Training progress: step=66250/100000 (66.25%), epoch=1, lr=1e-05, speed=1.926 step/s, elapsed=09:33:17, eta=04:52:03 +[2026-04-16 08:52:28,258][trainer.accelerators.base_accelerator][INFO] - Training progress: step=66300/100000 (66.30%), epoch=1, lr=1e-05, speed=1.926 step/s, elapsed=09:33:39, eta=04:51:35 +[2026-04-16 08:52:50,264][trainer.accelerators.base_accelerator][INFO] - Training progress: step=66350/100000 (66.35%), epoch=1, lr=1e-05, speed=1.926 step/s, elapsed=09:34:01, eta=04:51:07 +[2026-04-16 08:53:12,620][trainer.accelerators.base_accelerator][INFO] - Training progress: step=66400/100000 (66.40%), epoch=1, lr=1e-05, speed=1.927 step/s, elapsed=09:34:23, eta=04:50:39 +[2026-04-16 08:53:34,698][trainer.accelerators.base_accelerator][INFO] - Training progress: step=66450/100000 (66.45%), epoch=1, lr=1e-05, speed=1.927 step/s, elapsed=09:34:45, eta=04:50:11 +[2026-04-16 08:53:56,798][trainer.accelerators.base_accelerator][INFO] - Training progress: step=66500/100000 (66.50%), epoch=1, lr=1e-05, speed=1.927 step/s, elapsed=09:35:08, eta=04:49:43 +[2026-04-16 08:54:18,868][trainer.accelerators.base_accelerator][INFO] - Training progress: step=66550/100000 (66.55%), epoch=1, lr=1e-05, speed=1.927 step/s, elapsed=09:35:30, eta=04:49:15 +[2026-04-16 08:54:41,098][trainer.accelerators.base_accelerator][INFO] - Training progress: step=66600/100000 (66.60%), epoch=1, lr=1e-05, speed=1.928 step/s, elapsed=09:35:52, eta=04:48:48 +[2026-04-16 08:55:03,482][trainer.accelerators.base_accelerator][INFO] - Training progress: step=66650/100000 (66.65%), epoch=1, lr=1e-05, speed=1.928 step/s, elapsed=09:36:14, eta=04:48:20 +[2026-04-16 08:55:25,541][trainer.accelerators.base_accelerator][INFO] - Training progress: step=66700/100000 (66.70%), epoch=1, lr=1e-05, speed=1.928 step/s, elapsed=09:36:36, eta=04:47:52 +[2026-04-16 08:55:47,597][trainer.accelerators.base_accelerator][INFO] - Training progress: step=66750/100000 (66.75%), epoch=1, lr=1e-05, speed=1.928 step/s, elapsed=09:36:58, eta=04:47:24 +[2026-04-16 08:56:09,726][trainer.accelerators.base_accelerator][INFO] - Training progress: step=66800/100000 (66.80%), epoch=1, lr=1e-05, speed=1.928 step/s, elapsed=09:37:20, eta=04:46:56 +[2026-04-16 08:56:31,863][trainer.accelerators.base_accelerator][INFO] - Training progress: step=66850/100000 (66.85%), epoch=1, lr=1e-05, speed=1.929 step/s, elapsed=09:37:43, eta=04:46:28 +[2026-04-16 08:56:54,255][trainer.accelerators.base_accelerator][INFO] - Training progress: step=66900/100000 (66.90%), epoch=1, lr=1e-05, speed=1.929 step/s, elapsed=09:38:05, eta=04:46:01 +[2026-04-16 08:57:16,328][trainer.accelerators.base_accelerator][INFO] - Training progress: step=66950/100000 (66.95%), epoch=1, lr=1e-05, speed=1.929 step/s, elapsed=09:38:27, eta=04:45:33 +[2026-04-16 08:57:38,422][trainer.accelerators.base_accelerator][INFO] - Training progress: step=67000/100000 (67.00%), epoch=1, lr=1e-05, speed=1.929 step/s, elapsed=09:38:49, eta=04:45:05 +[2026-04-16 08:57:38,460][__main__][INFO] - ========== EVAL START (periodic@gstep=67000) ========== +[2026-04-16 08:57:38,460][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-16 08:57:38,461][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 08:57:53,538][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.979893684387207, 'accuracy': 0.48470588235294115, 'num_samples': 425, 'test_unique_accuracy': 0.5300925925925926, 'test_unique_num_samples': 432} +[2026-04-16 08:57:53,538][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-16 08:57:53,538][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 08:58:08,627][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 14.979893684387207, 'accuracy': 0.48470588235294115, 'num_samples': 425, 'test_unique_accuracy': 0.4930555555555556, 'test_unique_num_samples': 432} +[2026-04-16 08:58:08,628][__main__][INFO] - ========== EVAL END (periodic@gstep=67000) ========== +[2026-04-16 08:58:08,628][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 15.008869171142578, 'accuracy': 0.48470588235294115, 'num_samples': 425, 'test_unique_accuracy': 0.4930555555555556, 'test_unique_num_samples': 432} +[2026-04-16 08:58:08,631][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.48470588235294115 is not better than 0.56 of logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep33000, skipping checkpoint +[2026-04-16 08:58:30,717][trainer.accelerators.base_accelerator][INFO] - Training progress: step=67050/100000 (67.05%), epoch=1, lr=1e-05, speed=1.928 step/s, elapsed=09:39:41, eta=04:44:52 +[2026-04-16 08:58:52,853][trainer.accelerators.base_accelerator][INFO] - Training progress: step=67100/100000 (67.10%), epoch=1, lr=1e-05, speed=1.928 step/s, elapsed=09:40:04, eta=04:44:24 +[2026-04-16 08:59:14,941][trainer.accelerators.base_accelerator][INFO] - Training progress: step=67150/100000 (67.15%), epoch=1, lr=1e-05, speed=1.928 step/s, elapsed=09:40:26, eta=04:43:57 +[2026-04-16 08:59:37,108][trainer.accelerators.base_accelerator][INFO] - Training progress: step=67200/100000 (67.20%), epoch=1, lr=1e-05, speed=1.928 step/s, elapsed=09:40:48, eta=04:43:29 +[2026-04-16 08:59:59,518][trainer.accelerators.base_accelerator][INFO] - Training progress: step=67250/100000 (67.25%), epoch=1, lr=1e-05, speed=1.929 step/s, elapsed=09:41:10, eta=04:43:01 +[2026-04-16 09:00:21,533][trainer.accelerators.base_accelerator][INFO] - Training progress: step=67300/100000 (67.30%), epoch=1, lr=1e-05, speed=1.929 step/s, elapsed=09:41:32, eta=04:42:33 +[2026-04-16 09:00:43,606][trainer.accelerators.base_accelerator][INFO] - Training progress: step=67350/100000 (67.35%), epoch=1, lr=1e-05, speed=1.929 step/s, elapsed=09:41:54, eta=04:42:06 +[2026-04-16 09:01:05,733][trainer.accelerators.base_accelerator][INFO] - Training progress: step=67400/100000 (67.40%), epoch=1, lr=1e-05, speed=1.929 step/s, elapsed=09:42:16, eta=04:41:38 +[2026-04-16 09:01:27,833][trainer.accelerators.base_accelerator][INFO] - Training progress: step=67450/100000 (67.45%), epoch=1, lr=1e-05, speed=1.929 step/s, elapsed=09:42:39, eta=04:41:10 +[2026-04-16 09:01:49,886][trainer.accelerators.base_accelerator][INFO] - Training progress: step=67500/100000 (67.50%), epoch=1, lr=1e-05, speed=1.930 step/s, elapsed=09:43:01, eta=04:40:42 +[2026-04-16 09:02:12,005][trainer.accelerators.base_accelerator][INFO] - Training progress: step=67550/100000 (67.55%), epoch=1, lr=1e-05, speed=1.930 step/s, elapsed=09:43:23, eta=04:40:15 +[2026-04-16 09:02:34,101][trainer.accelerators.base_accelerator][INFO] - Training progress: step=67600/100000 (67.60%), epoch=1, lr=1e-05, speed=1.930 step/s, elapsed=09:43:45, eta=04:39:47 +[2026-04-16 09:02:56,173][trainer.accelerators.base_accelerator][INFO] - Training progress: step=67650/100000 (67.65%), epoch=1, lr=1e-05, speed=1.930 step/s, elapsed=09:44:07, eta=04:39:19 +[2026-04-16 09:03:18,274][trainer.accelerators.base_accelerator][INFO] - Training progress: step=67700/100000 (67.70%), epoch=1, lr=1e-05, speed=1.930 step/s, elapsed=09:44:29, eta=04:38:51 +[2026-04-16 09:03:40,345][trainer.accelerators.base_accelerator][INFO] - Training progress: step=67750/100000 (67.75%), epoch=1, lr=1e-05, speed=1.931 step/s, elapsed=09:44:51, eta=04:38:24 +[2026-04-16 09:04:02,389][trainer.accelerators.base_accelerator][INFO] - Training progress: step=67800/100000 (67.80%), epoch=1, lr=1e-05, speed=1.931 step/s, elapsed=09:45:13, eta=04:37:56 +[2026-04-16 09:04:24,686][trainer.accelerators.base_accelerator][INFO] - Training progress: step=67850/100000 (67.85%), epoch=1, lr=1e-05, speed=1.931 step/s, elapsed=09:45:35, eta=04:37:28 +[2026-04-16 09:04:46,767][trainer.accelerators.base_accelerator][INFO] - Training progress: step=67900/100000 (67.90%), epoch=1, lr=1e-05, speed=1.931 step/s, elapsed=09:45:58, eta=04:37:01 +[2026-04-16 09:05:08,866][trainer.accelerators.base_accelerator][INFO] - Training progress: step=67950/100000 (67.95%), epoch=1, lr=1e-05, speed=1.931 step/s, elapsed=09:46:20, eta=04:36:33 +[2026-04-16 09:05:30,941][trainer.accelerators.base_accelerator][INFO] - Training progress: step=68000/100000 (68.00%), epoch=1, lr=1e-05, speed=1.932 step/s, elapsed=09:46:42, eta=04:36:05 +[2026-04-16 09:05:30,980][__main__][INFO] - ========== EVAL START (periodic@gstep=68000) ========== +[2026-04-16 09:05:30,980][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-16 09:05:30,980][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 09:05:45,973][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 15.008869171142578, 'accuracy': 0.5035294117647059, 'num_samples': 425, 'test_unique_accuracy': 0.4930555555555556, 'test_unique_num_samples': 432} +[2026-04-16 09:05:45,973][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-16 09:05:45,973][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 09:06:01,059][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 15.008869171142578, 'accuracy': 0.5035294117647059, 'num_samples': 425, 'test_unique_accuracy': 0.5138888888888888, 'test_unique_num_samples': 432} +[2026-04-16 09:06:01,059][__main__][INFO] - ========== EVAL END (periodic@gstep=68000) ========== +[2026-04-16 09:06:01,060][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 15.025069236755371, 'accuracy': 0.5035294117647059, 'num_samples': 425, 'test_unique_accuracy': 0.5138888888888888, 'test_unique_num_samples': 432} +[2026-04-16 09:06:01,063][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.5035294117647059 is not better than 0.56 of logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep33000, skipping checkpoint +[2026-04-16 09:06:23,121][trainer.accelerators.base_accelerator][INFO] - Training progress: step=68050/100000 (68.05%), epoch=1, lr=1e-05, speed=1.930 step/s, elapsed=09:47:34, eta=04:35:52 +[2026-04-16 09:06:45,447][trainer.accelerators.base_accelerator][INFO] - Training progress: step=68100/100000 (68.10%), epoch=1, lr=1e-05, speed=1.930 step/s, elapsed=09:47:56, eta=04:35:24 +[2026-04-16 09:07:07,443][trainer.accelerators.base_accelerator][INFO] - Training progress: step=68150/100000 (68.15%), epoch=1, lr=1e-05, speed=1.931 step/s, elapsed=09:48:18, eta=04:34:56 +[2026-04-16 09:07:29,496][trainer.accelerators.base_accelerator][INFO] - Training progress: step=68200/100000 (68.20%), epoch=1, lr=1e-05, speed=1.931 step/s, elapsed=09:48:40, eta=04:34:29 +[2026-04-16 09:07:51,640][trainer.accelerators.base_accelerator][INFO] - Training progress: step=68250/100000 (68.25%), epoch=1, lr=1e-05, speed=1.931 step/s, elapsed=09:49:02, eta=04:34:01 +[2026-04-16 09:08:13,685][trainer.accelerators.base_accelerator][INFO] - Training progress: step=68300/100000 (68.30%), epoch=1, lr=1e-05, speed=1.931 step/s, elapsed=09:49:24, eta=04:33:33 +[2026-04-16 09:08:35,792][trainer.accelerators.base_accelerator][INFO] - Training progress: step=68350/100000 (68.35%), epoch=1, lr=1e-05, speed=1.931 step/s, elapsed=09:49:47, eta=04:33:06 +[2026-04-16 09:08:58,111][trainer.accelerators.base_accelerator][INFO] - Training progress: step=68400/100000 (68.40%), epoch=1, lr=1e-05, speed=1.932 step/s, elapsed=09:50:09, eta=04:32:38 +[2026-04-16 09:09:20,202][trainer.accelerators.base_accelerator][INFO] - Training progress: step=68450/100000 (68.45%), epoch=1, lr=1e-05, speed=1.932 step/s, elapsed=09:50:31, eta=04:32:11 +[2026-04-16 09:09:42,245][trainer.accelerators.base_accelerator][INFO] - Training progress: step=68500/100000 (68.50%), epoch=1, lr=1e-05, speed=1.932 step/s, elapsed=09:50:53, eta=04:31:43 +[2026-04-16 09:10:04,347][trainer.accelerators.base_accelerator][INFO] - Training progress: step=68550/100000 (68.55%), epoch=1, lr=1e-05, speed=1.932 step/s, elapsed=09:51:15, eta=04:31:15 +[2026-04-16 09:10:26,471][trainer.accelerators.base_accelerator][INFO] - Training progress: step=68600/100000 (68.60%), epoch=1, lr=1e-05, speed=1.933 step/s, elapsed=09:51:37, eta=04:30:48 +[2026-04-16 09:10:48,795][trainer.accelerators.base_accelerator][INFO] - Training progress: step=68650/100000 (68.65%), epoch=1, lr=1e-05, speed=1.933 step/s, elapsed=09:52:00, eta=04:30:20 +[2026-04-16 09:11:10,892][trainer.accelerators.base_accelerator][INFO] - Training progress: step=68700/100000 (68.70%), epoch=1, lr=1e-05, speed=1.933 step/s, elapsed=09:52:22, eta=04:29:53 +[2026-04-16 09:11:32,995][trainer.accelerators.base_accelerator][INFO] - Training progress: step=68750/100000 (68.75%), epoch=1, lr=1e-05, speed=1.933 step/s, elapsed=09:52:44, eta=04:29:25 +[2026-04-16 09:11:55,111][trainer.accelerators.base_accelerator][INFO] - Training progress: step=68800/100000 (68.80%), epoch=1, lr=1e-05, speed=1.933 step/s, elapsed=09:53:06, eta=04:28:58 +[2026-04-16 09:12:17,164][trainer.accelerators.base_accelerator][INFO] - Training progress: step=68850/100000 (68.85%), epoch=1, lr=1e-05, speed=1.934 step/s, elapsed=09:53:28, eta=04:28:30 +[2026-04-16 09:12:39,400][trainer.accelerators.base_accelerator][INFO] - Training progress: step=68900/100000 (68.90%), epoch=1, lr=1e-05, speed=1.934 step/s, elapsed=09:53:50, eta=04:28:02 +[2026-04-16 09:13:01,375][trainer.accelerators.base_accelerator][INFO] - Training progress: step=68950/100000 (68.95%), epoch=1, lr=1e-05, speed=1.934 step/s, elapsed=09:54:12, eta=04:27:35 +[2026-04-16 09:13:23,388][trainer.accelerators.base_accelerator][INFO] - Training progress: step=69000/100000 (69.00%), epoch=1, lr=1e-05, speed=1.934 step/s, elapsed=09:54:34, eta=04:27:07 +[2026-04-16 09:13:23,426][__main__][INFO] - ========== EVAL START (periodic@gstep=69000) ========== +[2026-04-16 09:13:23,427][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-16 09:13:23,427][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 09:13:38,451][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 15.025069236755371, 'accuracy': 0.4988235294117647, 'num_samples': 425, 'test_unique_accuracy': 0.5138888888888888, 'test_unique_num_samples': 432} +[2026-04-16 09:13:38,451][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-16 09:13:38,451][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 09:13:53,592][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 15.025069236755371, 'accuracy': 0.4988235294117647, 'num_samples': 425, 'test_unique_accuracy': 0.4976851851851852, 'test_unique_num_samples': 432} +[2026-04-16 09:13:53,592][__main__][INFO] - ========== EVAL END (periodic@gstep=69000) ========== +[2026-04-16 09:13:53,592][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 15.051164627075195, 'accuracy': 0.4988235294117647, 'num_samples': 425, 'test_unique_accuracy': 0.4976851851851852, 'test_unique_num_samples': 432} +[2026-04-16 09:13:53,595][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.4988235294117647 is not better than 0.56 of logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep33000, skipping checkpoint +[2026-04-16 09:14:15,684][trainer.accelerators.base_accelerator][INFO] - Training progress: step=69050/100000 (69.05%), epoch=1, lr=1e-05, speed=1.933 step/s, elapsed=09:55:26, eta=04:26:53 +[2026-04-16 09:14:37,791][trainer.accelerators.base_accelerator][INFO] - Training progress: step=69100/100000 (69.10%), epoch=1, lr=1e-05, speed=1.933 step/s, elapsed=09:55:49, eta=04:26:26 +[2026-04-16 09:14:59,807][trainer.accelerators.base_accelerator][INFO] - Training progress: step=69150/100000 (69.15%), epoch=1, lr=1e-05, speed=1.933 step/s, elapsed=09:56:11, eta=04:25:58 +[2026-04-16 09:15:21,910][trainer.accelerators.base_accelerator][INFO] - Training progress: step=69200/100000 (69.20%), epoch=1, lr=1e-05, speed=1.933 step/s, elapsed=09:56:33, eta=04:25:31 +[2026-04-16 09:15:43,956][trainer.accelerators.base_accelerator][INFO] - Training progress: step=69250/100000 (69.25%), epoch=1, lr=1e-05, speed=1.934 step/s, elapsed=09:56:55, eta=04:25:03 +[2026-04-16 09:16:06,289][trainer.accelerators.base_accelerator][INFO] - Training progress: step=69300/100000 (69.30%), epoch=1, lr=1e-05, speed=1.934 step/s, elapsed=09:57:17, eta=04:24:36 +[2026-04-16 09:16:28,332][trainer.accelerators.base_accelerator][INFO] - Training progress: step=69350/100000 (69.35%), epoch=1, lr=1e-05, speed=1.934 step/s, elapsed=09:57:39, eta=04:24:08 +[2026-04-16 09:16:50,384][trainer.accelerators.base_accelerator][INFO] - Training progress: step=69400/100000 (69.40%), epoch=1, lr=1e-05, speed=1.934 step/s, elapsed=09:58:01, eta=04:23:41 +[2026-04-16 09:17:12,477][trainer.accelerators.base_accelerator][INFO] - Training progress: step=69450/100000 (69.45%), epoch=1, lr=1e-05, speed=1.934 step/s, elapsed=09:58:23, eta=04:23:13 +[2026-04-16 09:17:34,601][trainer.accelerators.base_accelerator][INFO] - Training progress: step=69500/100000 (69.50%), epoch=1, lr=1e-05, speed=1.935 step/s, elapsed=09:58:45, eta=04:22:46 +[2026-04-16 09:17:56,723][trainer.accelerators.base_accelerator][INFO] - Training progress: step=69550/100000 (69.55%), epoch=1, lr=1e-05, speed=1.935 step/s, elapsed=09:59:07, eta=04:22:18 +[2026-04-16 09:18:18,826][trainer.accelerators.base_accelerator][INFO] - Training progress: step=69600/100000 (69.60%), epoch=1, lr=1e-05, speed=1.935 step/s, elapsed=09:59:30, eta=04:21:51 +[2026-04-16 09:18:40,891][trainer.accelerators.base_accelerator][INFO] - Training progress: step=69650/100000 (69.65%), epoch=1, lr=1e-05, speed=1.935 step/s, elapsed=09:59:52, eta=04:21:23 +[2026-04-16 09:19:02,970][trainer.accelerators.base_accelerator][INFO] - Training progress: step=69700/100000 (69.70%), epoch=1, lr=1e-05, speed=1.935 step/s, elapsed=10:00:14, eta=04:20:56 +[2026-04-16 09:19:25,091][trainer.accelerators.base_accelerator][INFO] - Training progress: step=69750/100000 (69.75%), epoch=1, lr=1e-05, speed=1.936 step/s, elapsed=10:00:36, eta=04:20:28 +[2026-04-16 09:19:47,174][trainer.accelerators.base_accelerator][INFO] - Training progress: step=69800/100000 (69.80%), epoch=1, lr=1e-05, speed=1.936 step/s, elapsed=10:00:58, eta=04:20:01 +[2026-04-16 09:20:09,258][trainer.accelerators.base_accelerator][INFO] - Training progress: step=69850/100000 (69.85%), epoch=1, lr=1e-05, speed=1.936 step/s, elapsed=10:01:20, eta=04:19:33 +[2026-04-16 09:20:31,683][trainer.accelerators.base_accelerator][INFO] - Training progress: step=69900/100000 (69.90%), epoch=1, lr=1e-05, speed=1.936 step/s, elapsed=10:01:42, eta=04:19:06 +[2026-04-16 09:20:53,758][trainer.accelerators.base_accelerator][INFO] - Training progress: step=69950/100000 (69.95%), epoch=1, lr=1e-05, speed=1.936 step/s, elapsed=10:02:05, eta=04:18:39 +[2026-04-16 09:21:15,833][trainer.accelerators.base_accelerator][INFO] - Training progress: step=70000/100000 (70.00%), epoch=1, lr=1e-05, speed=1.937 step/s, elapsed=10:02:27, eta=04:18:11 +[2026-04-16 09:21:15,872][__main__][INFO] - ========== EVAL START (periodic@gstep=70000) ========== +[2026-04-16 09:21:15,872][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-16 09:21:15,872][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 09:21:30,996][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 15.051164627075195, 'accuracy': 0.5364705882352941, 'num_samples': 425, 'test_unique_accuracy': 0.4976851851851852, 'test_unique_num_samples': 432} +[2026-04-16 09:21:30,997][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-16 09:21:30,997][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 09:21:46,179][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 15.051164627075195, 'accuracy': 0.5364705882352941, 'num_samples': 425, 'test_unique_accuracy': 0.4791666666666667, 'test_unique_num_samples': 432} +[2026-04-16 09:21:46,179][__main__][INFO] - ========== EVAL END (periodic@gstep=70000) ========== +[2026-04-16 09:21:46,180][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 15.073195457458496, 'accuracy': 0.5364705882352941, 'num_samples': 425, 'test_unique_accuracy': 0.4791666666666667, 'test_unique_num_samples': 432} +[2026-04-16 09:21:46,183][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.5364705882352941 is not better than 0.56 of logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep33000, skipping checkpoint +[2026-04-16 09:22:08,191][trainer.accelerators.base_accelerator][INFO] - Training progress: step=70050/100000 (70.05%), epoch=1, lr=1e-05, speed=1.935 step/s, elapsed=10:03:19, eta=04:17:57 +[2026-04-16 09:22:30,237][trainer.accelerators.base_accelerator][INFO] - Training progress: step=70100/100000 (70.10%), epoch=1, lr=1e-05, speed=1.935 step/s, elapsed=10:03:41, eta=04:17:29 +[2026-04-16 09:22:52,443][trainer.accelerators.base_accelerator][INFO] - Training progress: step=70150/100000 (70.15%), epoch=1, lr=1e-05, speed=1.936 step/s, elapsed=10:04:03, eta=04:17:02 +[2026-04-16 09:23:14,614][trainer.accelerators.base_accelerator][INFO] - Training progress: step=70200/100000 (70.20%), epoch=1, lr=1e-05, speed=1.936 step/s, elapsed=10:04:25, eta=04:16:34 +[2026-04-16 09:23:36,794][trainer.accelerators.base_accelerator][INFO] - Training progress: step=70250/100000 (70.25%), epoch=1, lr=1e-05, speed=1.936 step/s, elapsed=10:04:48, eta=04:16:07 +[2026-04-16 09:23:58,935][trainer.accelerators.base_accelerator][INFO] - Training progress: step=70300/100000 (70.30%), epoch=1, lr=1e-05, speed=1.936 step/s, elapsed=10:05:10, eta=04:15:40 +[2026-04-16 09:24:20,924][trainer.accelerators.base_accelerator][INFO] - Training progress: step=70350/100000 (70.35%), epoch=1, lr=1e-05, speed=1.936 step/s, elapsed=10:05:32, eta=04:15:12 +[2026-04-16 09:24:43,260][trainer.accelerators.base_accelerator][INFO] - Training progress: step=70400/100000 (70.40%), epoch=1, lr=1e-05, speed=1.936 step/s, elapsed=10:05:54, eta=04:14:45 +[2026-04-16 09:25:05,399][trainer.accelerators.base_accelerator][INFO] - Training progress: step=70450/100000 (70.45%), epoch=1, lr=1e-05, speed=1.937 step/s, elapsed=10:06:16, eta=04:14:18 +[2026-04-16 09:25:27,544][trainer.accelerators.base_accelerator][INFO] - Training progress: step=70500/100000 (70.50%), epoch=1, lr=1e-05, speed=1.937 step/s, elapsed=10:06:38, eta=04:13:50 +[2026-04-16 09:25:49,639][trainer.accelerators.base_accelerator][INFO] - Training progress: step=70550/100000 (70.55%), epoch=1, lr=1e-05, speed=1.937 step/s, elapsed=10:07:00, eta=04:13:23 +[2026-04-16 09:26:11,725][trainer.accelerators.base_accelerator][INFO] - Training progress: step=70600/100000 (70.60%), epoch=1, lr=1e-05, speed=1.937 step/s, elapsed=10:07:22, eta=04:12:55 +[2026-04-16 09:26:33,855][trainer.accelerators.base_accelerator][INFO] - Training progress: step=70650/100000 (70.65%), epoch=1, lr=1e-05, speed=1.937 step/s, elapsed=10:07:45, eta=04:12:28 +[2026-04-16 09:26:55,890][trainer.accelerators.base_accelerator][INFO] - Training progress: step=70700/100000 (70.70%), epoch=1, lr=1e-05, speed=1.938 step/s, elapsed=10:08:07, eta=04:12:01 +[2026-04-16 09:27:17,980][trainer.accelerators.base_accelerator][INFO] - Training progress: step=70750/100000 (70.75%), epoch=1, lr=1e-05, speed=1.938 step/s, elapsed=10:08:29, eta=04:11:33 +[2026-04-16 09:27:40,003][trainer.accelerators.base_accelerator][INFO] - Training progress: step=70800/100000 (70.80%), epoch=1, lr=1e-05, speed=1.938 step/s, elapsed=10:08:51, eta=04:11:06 +[2026-04-16 09:28:02,304][trainer.accelerators.base_accelerator][INFO] - Training progress: step=70850/100000 (70.85%), epoch=1, lr=1e-05, speed=1.938 step/s, elapsed=10:09:13, eta=04:10:39 +[2026-04-16 09:28:24,402][trainer.accelerators.base_accelerator][INFO] - Training progress: step=70900/100000 (70.90%), epoch=1, lr=1e-05, speed=1.938 step/s, elapsed=10:09:35, eta=04:10:12 +[2026-04-16 09:28:46,524][trainer.accelerators.base_accelerator][INFO] - Training progress: step=70950/100000 (70.95%), epoch=1, lr=1e-05, speed=1.939 step/s, elapsed=10:09:57, eta=04:09:44 +[2026-04-16 09:29:08,549][trainer.accelerators.base_accelerator][INFO] - Training progress: step=71000/100000 (71.00%), epoch=1, lr=1e-05, speed=1.939 step/s, elapsed=10:10:19, eta=04:09:17 +[2026-04-16 09:29:08,588][__main__][INFO] - ========== EVAL START (periodic@gstep=71000) ========== +[2026-04-16 09:29:08,588][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-16 09:29:08,588][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 09:29:23,749][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 15.073195457458496, 'accuracy': 0.5247058823529411, 'num_samples': 425, 'test_unique_accuracy': 0.4791666666666667, 'test_unique_num_samples': 432} +[2026-04-16 09:29:23,749][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-16 09:29:23,749][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 09:29:38,868][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 15.073195457458496, 'accuracy': 0.5247058823529411, 'num_samples': 425, 'test_unique_accuracy': 0.5069444444444444, 'test_unique_num_samples': 432} +[2026-04-16 09:29:38,868][__main__][INFO] - ========== EVAL END (periodic@gstep=71000) ========== +[2026-04-16 09:29:38,869][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 15.091132164001465, 'accuracy': 0.5247058823529411, 'num_samples': 425, 'test_unique_accuracy': 0.5069444444444444, 'test_unique_num_samples': 432} +[2026-04-16 09:29:38,871][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.5247058823529411 is not better than 0.56 of logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep33000, skipping checkpoint +[2026-04-16 09:30:00,934][trainer.accelerators.base_accelerator][INFO] - Training progress: step=71050/100000 (71.05%), epoch=1, lr=1e-05, speed=1.937 step/s, elapsed=10:11:12, eta=04:09:02 +[2026-04-16 09:30:22,944][trainer.accelerators.base_accelerator][INFO] - Training progress: step=71100/100000 (71.10%), epoch=1, lr=1e-05, speed=1.938 step/s, elapsed=10:11:34, eta=04:08:35 +[2026-04-16 09:30:45,408][trainer.accelerators.base_accelerator][INFO] - Training progress: step=71150/100000 (71.15%), epoch=1, lr=1e-05, speed=1.938 step/s, elapsed=10:11:56, eta=04:08:07 +[2026-04-16 09:31:07,504][trainer.accelerators.base_accelerator][INFO] - Training progress: step=71200/100000 (71.20%), epoch=1, lr=1e-05, speed=1.938 step/s, elapsed=10:12:18, eta=04:07:40 +[2026-04-16 09:31:29,640][trainer.accelerators.base_accelerator][INFO] - Training progress: step=71250/100000 (71.25%), epoch=1, lr=1e-05, speed=1.938 step/s, elapsed=10:12:40, eta=04:07:13 +[2026-04-16 09:31:51,706][trainer.accelerators.base_accelerator][INFO] - Training progress: step=71300/100000 (71.30%), epoch=1, lr=1e-05, speed=1.938 step/s, elapsed=10:13:02, eta=04:06:46 +[2026-04-16 09:32:13,734][trainer.accelerators.base_accelerator][INFO] - Training progress: step=71350/100000 (71.35%), epoch=1, lr=1e-05, speed=1.939 step/s, elapsed=10:13:24, eta=04:06:18 +[2026-04-16 09:32:36,124][trainer.accelerators.base_accelerator][INFO] - Training progress: step=71400/100000 (71.40%), epoch=1, lr=1e-05, speed=1.939 step/s, elapsed=10:13:47, eta=04:05:51 +[2026-04-16 09:32:58,251][trainer.accelerators.base_accelerator][INFO] - Training progress: step=71450/100000 (71.45%), epoch=1, lr=1e-05, speed=1.939 step/s, elapsed=10:14:09, eta=04:05:24 +[2026-04-16 09:33:20,354][trainer.accelerators.base_accelerator][INFO] - Training progress: step=71500/100000 (71.50%), epoch=1, lr=1e-05, speed=1.939 step/s, elapsed=10:14:31, eta=04:04:57 +[2026-04-16 09:33:42,372][trainer.accelerators.base_accelerator][INFO] - Training progress: step=71550/100000 (71.55%), epoch=1, lr=1e-05, speed=1.939 step/s, elapsed=10:14:53, eta=04:04:29 +[2026-04-16 09:34:04,500][trainer.accelerators.base_accelerator][INFO] - Training progress: step=71600/100000 (71.60%), epoch=1, lr=1e-05, speed=1.940 step/s, elapsed=10:15:15, eta=04:04:02 +[2026-04-16 09:34:26,688][trainer.accelerators.base_accelerator][INFO] - Training progress: step=71650/100000 (71.65%), epoch=1, lr=1e-05, speed=1.940 step/s, elapsed=10:15:37, eta=04:03:35 +[2026-04-16 09:34:48,782][trainer.accelerators.base_accelerator][INFO] - Training progress: step=71700/100000 (71.70%), epoch=1, lr=1e-05, speed=1.940 step/s, elapsed=10:16:00, eta=04:03:08 +[2026-04-16 09:35:10,904][trainer.accelerators.base_accelerator][INFO] - Training progress: step=71750/100000 (71.75%), epoch=1, lr=1e-05, speed=1.940 step/s, elapsed=10:16:22, eta=04:02:40 +[2026-04-16 09:35:33,014][trainer.accelerators.base_accelerator][INFO] - Training progress: step=71800/100000 (71.80%), epoch=1, lr=1e-05, speed=1.940 step/s, elapsed=10:16:44, eta=04:02:13 +[2026-04-16 09:35:55,426][trainer.accelerators.base_accelerator][INFO] - Training progress: step=71850/100000 (71.85%), epoch=1, lr=1e-05, speed=1.940 step/s, elapsed=10:17:06, eta=04:01:46 +[2026-04-16 09:36:17,549][trainer.accelerators.base_accelerator][INFO] - Training progress: step=71900/100000 (71.90%), epoch=1, lr=1e-05, speed=1.941 step/s, elapsed=10:17:28, eta=04:01:19 +[2026-04-16 09:36:39,562][trainer.accelerators.base_accelerator][INFO] - Training progress: step=71950/100000 (71.95%), epoch=1, lr=1e-05, speed=1.941 step/s, elapsed=10:17:50, eta=04:00:52 +[2026-04-16 09:37:01,554][trainer.accelerators.base_accelerator][INFO] - Training progress: step=72000/100000 (72.00%), epoch=1, lr=1e-05, speed=1.941 step/s, elapsed=10:18:12, eta=04:00:24 +[2026-04-16 09:37:01,593][__main__][INFO] - ========== EVAL START (periodic@gstep=72000) ========== +[2026-04-16 09:37:01,593][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-16 09:37:01,593][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 09:37:16,722][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 15.091132164001465, 'accuracy': 0.4894117647058824, 'num_samples': 425, 'test_unique_accuracy': 0.5069444444444444, 'test_unique_num_samples': 432} +[2026-04-16 09:37:16,723][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-16 09:37:16,723][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 09:37:31,886][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 15.091132164001465, 'accuracy': 0.4894117647058824, 'num_samples': 425, 'test_unique_accuracy': 0.5231481481481481, 'test_unique_num_samples': 432} +[2026-04-16 09:37:31,887][__main__][INFO] - ========== EVAL END (periodic@gstep=72000) ========== +[2026-04-16 09:37:31,887][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 15.118934631347656, 'accuracy': 0.4894117647058824, 'num_samples': 425, 'test_unique_accuracy': 0.5231481481481481, 'test_unique_num_samples': 432} +[2026-04-16 09:37:31,891][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.4894117647058824 is not better than 0.56 of logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep33000, skipping checkpoint +[2026-04-16 09:37:53,987][trainer.accelerators.base_accelerator][INFO] - Training progress: step=72050/100000 (72.05%), epoch=1, lr=1e-05, speed=1.940 step/s, elapsed=10:19:05, eta=04:00:09 +[2026-04-16 09:38:16,402][trainer.accelerators.base_accelerator][INFO] - Training progress: step=72100/100000 (72.10%), epoch=1, lr=1e-05, speed=1.940 step/s, elapsed=10:19:27, eta=03:59:42 +[2026-04-16 09:38:38,533][trainer.accelerators.base_accelerator][INFO] - Training progress: step=72150/100000 (72.15%), epoch=1, lr=1e-05, speed=1.940 step/s, elapsed=10:19:49, eta=03:59:15 +[2026-04-16 09:39:00,712][trainer.accelerators.base_accelerator][INFO] - Training progress: step=72200/100000 (72.20%), epoch=1, lr=1e-05, speed=1.940 step/s, elapsed=10:20:11, eta=03:58:48 +[2026-04-16 09:39:22,863][trainer.accelerators.base_accelerator][INFO] - Training progress: step=72250/100000 (72.25%), epoch=1, lr=1e-05, speed=1.940 step/s, elapsed=10:20:34, eta=03:58:20 +[2026-04-16 09:39:44,899][trainer.accelerators.base_accelerator][INFO] - Training progress: step=72300/100000 (72.30%), epoch=1, lr=1e-05, speed=1.941 step/s, elapsed=10:20:56, eta=03:57:53 +[2026-04-16 09:40:07,059][trainer.accelerators.base_accelerator][INFO] - Training progress: step=72350/100000 (72.35%), epoch=1, lr=1e-05, speed=1.941 step/s, elapsed=10:21:18, eta=03:57:26 +[2026-04-16 09:40:29,478][trainer.accelerators.base_accelerator][INFO] - Training progress: step=72400/100000 (72.40%), epoch=1, lr=1e-05, speed=1.941 step/s, elapsed=10:21:40, eta=03:56:59 +[2026-04-16 09:40:51,644][trainer.accelerators.base_accelerator][INFO] - Training progress: step=72450/100000 (72.45%), epoch=1, lr=1e-05, speed=1.941 step/s, elapsed=10:22:02, eta=03:56:32 +[2026-04-16 09:41:13,826][trainer.accelerators.base_accelerator][INFO] - Training progress: step=72500/100000 (72.50%), epoch=1, lr=1e-05, speed=1.941 step/s, elapsed=10:22:25, eta=03:56:05 +[2026-04-16 09:41:35,837][trainer.accelerators.base_accelerator][INFO] - Training progress: step=72550/100000 (72.55%), epoch=1, lr=1e-05, speed=1.942 step/s, elapsed=10:22:47, eta=03:55:38 +[2026-04-16 09:41:57,992][trainer.accelerators.base_accelerator][INFO] - Training progress: step=72600/100000 (72.60%), epoch=1, lr=1e-05, speed=1.942 step/s, elapsed=10:23:09, eta=03:55:11 +[2026-04-16 09:42:20,205][trainer.accelerators.base_accelerator][INFO] - Training progress: step=72650/100000 (72.65%), epoch=1, lr=1e-05, speed=1.942 step/s, elapsed=10:23:31, eta=03:54:44 +[2026-04-16 09:42:42,643][trainer.accelerators.base_accelerator][INFO] - Training progress: step=72700/100000 (72.70%), epoch=1, lr=1e-05, speed=1.942 step/s, elapsed=10:23:53, eta=03:54:17 +[2026-04-16 09:43:04,783][trainer.accelerators.base_accelerator][INFO] - Training progress: step=72750/100000 (72.75%), epoch=1, lr=1e-05, speed=1.942 step/s, elapsed=10:24:16, eta=03:53:49 +[2026-04-16 09:43:26,970][trainer.accelerators.base_accelerator][INFO] - Training progress: step=72800/100000 (72.80%), epoch=1, lr=1e-05, speed=1.942 step/s, elapsed=10:24:38, eta=03:53:22 +[2026-04-16 09:43:49,029][trainer.accelerators.base_accelerator][INFO] - Training progress: step=72850/100000 (72.85%), epoch=1, lr=1e-05, speed=1.943 step/s, elapsed=10:25:00, eta=03:52:55 +[2026-04-16 09:44:11,200][trainer.accelerators.base_accelerator][INFO] - Training progress: step=72900/100000 (72.90%), epoch=1, lr=1e-05, speed=1.943 step/s, elapsed=10:25:22, eta=03:52:28 +[2026-04-16 09:44:33,360][trainer.accelerators.base_accelerator][INFO] - Training progress: step=72950/100000 (72.95%), epoch=1, lr=1e-05, speed=1.943 step/s, elapsed=10:25:44, eta=03:52:01 +[2026-04-16 09:44:55,522][trainer.accelerators.base_accelerator][INFO] - Training progress: step=73000/100000 (73.00%), epoch=1, lr=1e-05, speed=1.943 step/s, elapsed=10:26:06, eta=03:51:34 +[2026-04-16 09:44:55,560][__main__][INFO] - ========== EVAL START (periodic@gstep=73000) ========== +[2026-04-16 09:44:55,561][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-16 09:44:55,561][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 09:45:11,026][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 15.118934631347656, 'accuracy': 0.5247058823529411, 'num_samples': 425, 'test_unique_accuracy': 0.5231481481481481, 'test_unique_num_samples': 432} +[2026-04-16 09:45:11,026][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-16 09:45:11,026][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 09:45:26,236][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 15.118934631347656, 'accuracy': 0.5247058823529411, 'num_samples': 425, 'test_unique_accuracy': 0.4837962962962963, 'test_unique_num_samples': 432} +[2026-04-16 09:45:26,236][__main__][INFO] - ========== EVAL END (periodic@gstep=73000) ========== +[2026-04-16 09:45:26,236][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 15.13896369934082, 'accuracy': 0.5247058823529411, 'num_samples': 425, 'test_unique_accuracy': 0.4837962962962963, 'test_unique_num_samples': 432} +[2026-04-16 09:45:26,242][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.5247058823529411 is not better than 0.56 of logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep33000, skipping checkpoint +[2026-04-16 09:45:48,339][trainer.accelerators.base_accelerator][INFO] - Training progress: step=73050/100000 (73.05%), epoch=1, lr=1e-05, speed=1.942 step/s, elapsed=10:26:59, eta=03:51:18 +[2026-04-16 09:46:10,486][trainer.accelerators.base_accelerator][INFO] - Training progress: step=73100/100000 (73.10%), epoch=1, lr=1e-05, speed=1.942 step/s, elapsed=10:27:21, eta=03:50:51 +[2026-04-16 09:46:32,577][trainer.accelerators.base_accelerator][INFO] - Training progress: step=73150/100000 (73.15%), epoch=1, lr=1e-05, speed=1.942 step/s, elapsed=10:27:43, eta=03:50:24 +[2026-04-16 09:46:54,615][trainer.accelerators.base_accelerator][INFO] - Training progress: step=73200/100000 (73.20%), epoch=1, lr=1e-05, speed=1.942 step/s, elapsed=10:28:05, eta=03:49:57 +[2026-04-16 09:47:16,990][trainer.accelerators.base_accelerator][INFO] - Training progress: step=73250/100000 (73.25%), epoch=1, lr=1e-05, speed=1.943 step/s, elapsed=10:28:28, eta=03:49:30 +[2026-04-16 09:47:39,058][trainer.accelerators.base_accelerator][INFO] - Training progress: step=73300/100000 (73.30%), epoch=1, lr=1e-05, speed=1.943 step/s, elapsed=10:28:50, eta=03:49:03 +[2026-04-16 09:48:01,111][trainer.accelerators.base_accelerator][INFO] - Training progress: step=73350/100000 (73.35%), epoch=1, lr=1e-05, speed=1.943 step/s, elapsed=10:29:12, eta=03:48:36 +[2026-04-16 09:48:23,220][trainer.accelerators.base_accelerator][INFO] - Training progress: step=73400/100000 (73.40%), epoch=1, lr=1e-05, speed=1.943 step/s, elapsed=10:29:34, eta=03:48:09 +[2026-04-16 09:48:45,269][trainer.accelerators.base_accelerator][INFO] - Training progress: step=73450/100000 (73.45%), epoch=1, lr=1e-05, speed=1.943 step/s, elapsed=10:29:56, eta=03:47:42 +[2026-04-16 09:49:07,350][trainer.accelerators.base_accelerator][INFO] - Training progress: step=73500/100000 (73.50%), epoch=1, lr=1e-05, speed=1.943 step/s, elapsed=10:30:18, eta=03:47:15 +[2026-04-16 09:49:29,695][trainer.accelerators.base_accelerator][INFO] - Training progress: step=73550/100000 (73.55%), epoch=1, lr=1e-05, speed=1.944 step/s, elapsed=10:30:40, eta=03:46:48 +[2026-04-16 09:49:51,759][trainer.accelerators.base_accelerator][INFO] - Training progress: step=73600/100000 (73.60%), epoch=1, lr=1e-05, speed=1.944 step/s, elapsed=10:31:03, eta=03:46:21 +[2026-04-16 09:50:13,809][trainer.accelerators.base_accelerator][INFO] - Training progress: step=73650/100000 (73.65%), epoch=1, lr=1e-05, speed=1.944 step/s, elapsed=10:31:25, eta=03:45:54 +[2026-04-16 09:50:35,941][trainer.accelerators.base_accelerator][INFO] - Training progress: step=73700/100000 (73.70%), epoch=1, lr=1e-05, speed=1.944 step/s, elapsed=10:31:47, eta=03:45:27 +[2026-04-16 09:50:57,983][trainer.accelerators.base_accelerator][INFO] - Training progress: step=73750/100000 (73.75%), epoch=1, lr=1e-05, speed=1.944 step/s, elapsed=10:32:09, eta=03:45:00 +[2026-04-16 09:51:20,354][trainer.accelerators.base_accelerator][INFO] - Training progress: step=73800/100000 (73.80%), epoch=1, lr=1e-05, speed=1.945 step/s, elapsed=10:32:31, eta=03:44:33 +[2026-04-16 09:51:42,498][trainer.accelerators.base_accelerator][INFO] - Training progress: step=73850/100000 (73.85%), epoch=1, lr=1e-05, speed=1.945 step/s, elapsed=10:32:53, eta=03:44:06 +[2026-04-16 09:52:04,401][trainer.accelerators.base_accelerator][INFO] - Training progress: step=73900/100000 (73.90%), epoch=1, lr=1e-05, speed=1.945 step/s, elapsed=10:33:15, eta=03:43:39 +[2026-04-16 09:52:26,563][trainer.accelerators.base_accelerator][INFO] - Training progress: step=73950/100000 (73.95%), epoch=1, lr=1e-05, speed=1.945 step/s, elapsed=10:33:37, eta=03:43:12 +[2026-04-16 09:52:48,658][trainer.accelerators.base_accelerator][INFO] - Training progress: step=74000/100000 (74.00%), epoch=1, lr=1e-05, speed=1.945 step/s, elapsed=10:33:59, eta=03:42:45 +[2026-04-16 09:52:48,697][__main__][INFO] - ========== EVAL START (periodic@gstep=74000) ========== +[2026-04-16 09:52:48,697][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-16 09:52:48,697][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 09:53:09,388][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 15.13896369934082, 'accuracy': 0.5035294117647059, 'num_samples': 425, 'test_unique_accuracy': 0.4837962962962963, 'test_unique_num_samples': 432} +[2026-04-16 09:53:09,388][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-16 09:53:09,388][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 09:53:24,537][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 15.13896369934082, 'accuracy': 0.5035294117647059, 'num_samples': 425, 'test_unique_accuracy': 0.47685185185185186, 'test_unique_num_samples': 432} +[2026-04-16 09:53:24,537][__main__][INFO] - ========== EVAL END (periodic@gstep=74000) ========== +[2026-04-16 09:53:24,537][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 15.162237167358398, 'accuracy': 0.5035294117647059, 'num_samples': 425, 'test_unique_accuracy': 0.47685185185185186, 'test_unique_num_samples': 432} +[2026-04-16 09:53:24,576][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.5035294117647059 is not better than 0.56 of logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep33000, skipping checkpoint +[2026-04-16 09:53:47,024][trainer.accelerators.base_accelerator][INFO] - Training progress: step=74050/100000 (74.05%), epoch=1, lr=1e-05, speed=1.944 step/s, elapsed=10:34:58, eta=03:42:31 +[2026-04-16 09:54:09,173][trainer.accelerators.base_accelerator][INFO] - Training progress: step=74100/100000 (74.10%), epoch=1, lr=1e-05, speed=1.944 step/s, elapsed=10:35:20, eta=03:42:04 +[2026-04-16 09:54:31,298][trainer.accelerators.base_accelerator][INFO] - Training progress: step=74150/100000 (74.15%), epoch=1, lr=1e-05, speed=1.944 step/s, elapsed=10:35:42, eta=03:41:37 +[2026-04-16 09:54:53,391][trainer.accelerators.base_accelerator][INFO] - Training progress: step=74200/100000 (74.20%), epoch=1, lr=1e-05, speed=1.944 step/s, elapsed=10:36:04, eta=03:41:10 +[2026-04-16 09:55:15,431][trainer.accelerators.base_accelerator][INFO] - Training progress: step=74250/100000 (74.25%), epoch=1, lr=1e-05, speed=1.944 step/s, elapsed=10:36:26, eta=03:40:43 +[2026-04-16 09:55:37,495][trainer.accelerators.base_accelerator][INFO] - Training progress: step=74300/100000 (74.30%), epoch=1, lr=1e-05, speed=1.945 step/s, elapsed=10:36:48, eta=03:40:16 +[2026-04-16 09:55:59,593][trainer.accelerators.base_accelerator][INFO] - Training progress: step=74350/100000 (74.35%), epoch=1, lr=1e-05, speed=1.945 step/s, elapsed=10:37:10, eta=03:39:49 +[2026-04-16 09:56:21,596][trainer.accelerators.base_accelerator][INFO] - Training progress: step=74400/100000 (74.40%), epoch=1, lr=1e-05, speed=1.945 step/s, elapsed=10:37:32, eta=03:39:22 +[2026-04-16 09:56:43,695][trainer.accelerators.base_accelerator][INFO] - Training progress: step=74450/100000 (74.45%), epoch=1, lr=1e-05, speed=1.945 step/s, elapsed=10:37:54, eta=03:38:55 +[2026-04-16 09:57:05,759][trainer.accelerators.base_accelerator][INFO] - Training progress: step=74500/100000 (74.50%), epoch=1, lr=1e-05, speed=1.945 step/s, elapsed=10:38:17, eta=03:38:28 +[2026-04-16 09:57:27,890][trainer.accelerators.base_accelerator][INFO] - Training progress: step=74550/100000 (74.55%), epoch=1, lr=1e-05, speed=1.946 step/s, elapsed=10:38:39, eta=03:38:01 +[2026-04-16 09:57:49,910][trainer.accelerators.base_accelerator][INFO] - Training progress: step=74600/100000 (74.60%), epoch=1, lr=1e-05, speed=1.946 step/s, elapsed=10:39:01, eta=03:37:34 +[2026-04-16 09:58:12,330][trainer.accelerators.base_accelerator][INFO] - Training progress: step=74650/100000 (74.65%), epoch=1, lr=1e-05, speed=1.946 step/s, elapsed=10:39:23, eta=03:37:07 +[2026-04-16 09:58:34,472][trainer.accelerators.base_accelerator][INFO] - Training progress: step=74700/100000 (74.70%), epoch=1, lr=1e-05, speed=1.946 step/s, elapsed=10:39:45, eta=03:36:40 +[2026-04-16 09:58:56,655][trainer.accelerators.base_accelerator][INFO] - Training progress: step=74750/100000 (74.75%), epoch=1, lr=1e-05, speed=1.946 step/s, elapsed=10:40:07, eta=03:36:13 +[2026-04-16 09:59:18,699][trainer.accelerators.base_accelerator][INFO] - Training progress: step=74800/100000 (74.80%), epoch=1, lr=1e-05, speed=1.946 step/s, elapsed=10:40:29, eta=03:35:46 +[2026-04-16 09:59:40,810][trainer.accelerators.base_accelerator][INFO] - Training progress: step=74850/100000 (74.85%), epoch=1, lr=1e-05, speed=1.947 step/s, elapsed=10:40:52, eta=03:35:20 +[2026-04-16 10:00:02,890][trainer.accelerators.base_accelerator][INFO] - Training progress: step=74900/100000 (74.90%), epoch=1, lr=1e-05, speed=1.947 step/s, elapsed=10:41:14, eta=03:34:53 +[2026-04-16 10:00:24,978][trainer.accelerators.base_accelerator][INFO] - Training progress: step=74950/100000 (74.95%), epoch=1, lr=1e-05, speed=1.947 step/s, elapsed=10:41:36, eta=03:34:26 +[2026-04-16 10:00:47,029][trainer.accelerators.base_accelerator][INFO] - Training progress: step=75000/100000 (75.00%), epoch=1, lr=1e-05, speed=1.947 step/s, elapsed=10:41:58, eta=03:33:59 +[2026-04-16 10:00:47,068][__main__][INFO] - ========== EVAL START (periodic@gstep=75000) ========== +[2026-04-16 10:00:47,068][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-16 10:00:47,068][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 10:01:02,165][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 15.162237167358398, 'accuracy': 0.45647058823529413, 'num_samples': 425, 'test_unique_accuracy': 0.47685185185185186, 'test_unique_num_samples': 432} +[2026-04-16 10:01:02,165][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-16 10:01:02,165][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 10:01:17,314][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 15.162237167358398, 'accuracy': 0.45647058823529413, 'num_samples': 425, 'test_unique_accuracy': 0.49537037037037035, 'test_unique_num_samples': 432} +[2026-04-16 10:01:17,314][__main__][INFO] - ========== EVAL END (periodic@gstep=75000) ========== +[2026-04-16 10:01:17,315][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 15.17788314819336, 'accuracy': 0.45647058823529413, 'num_samples': 425, 'test_unique_accuracy': 0.49537037037037035, 'test_unique_num_samples': 432} +[2026-04-16 10:01:17,318][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.45647058823529413 is not better than 0.56 of logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep33000, skipping checkpoint +[2026-04-16 10:01:39,234][trainer.accelerators.base_accelerator][INFO] - Training progress: step=75050/100000 (75.05%), epoch=1, lr=1e-05, speed=1.946 step/s, elapsed=10:42:50, eta=03:33:42 +[2026-04-16 10:02:01,339][trainer.accelerators.base_accelerator][INFO] - Training progress: step=75100/100000 (75.10%), epoch=1, lr=1e-05, speed=1.946 step/s, elapsed=10:43:12, eta=03:33:15 +[2026-04-16 10:02:23,727][trainer.accelerators.base_accelerator][INFO] - Training progress: step=75150/100000 (75.15%), epoch=1, lr=1e-05, speed=1.946 step/s, elapsed=10:43:34, eta=03:32:48 +[2026-04-16 10:02:45,783][trainer.accelerators.base_accelerator][INFO] - Training progress: step=75200/100000 (75.20%), epoch=1, lr=1e-05, speed=1.946 step/s, elapsed=10:43:57, eta=03:32:22 +[2026-04-16 10:03:07,811][trainer.accelerators.base_accelerator][INFO] - Training progress: step=75250/100000 (75.25%), epoch=1, lr=1e-05, speed=1.947 step/s, elapsed=10:44:19, eta=03:31:55 +[2026-04-16 10:03:29,886][trainer.accelerators.base_accelerator][INFO] - Training progress: step=75300/100000 (75.30%), epoch=1, lr=1e-05, speed=1.947 step/s, elapsed=10:44:41, eta=03:31:28 +[2026-04-16 10:03:51,972][trainer.accelerators.base_accelerator][INFO] - Training progress: step=75350/100000 (75.35%), epoch=1, lr=1e-05, speed=1.947 step/s, elapsed=10:45:03, eta=03:31:01 +[2026-04-16 10:04:14,010][trainer.accelerators.base_accelerator][INFO] - Training progress: step=75400/100000 (75.40%), epoch=1, lr=1e-05, speed=1.947 step/s, elapsed=10:45:25, eta=03:30:34 +[2026-04-16 10:04:36,120][trainer.accelerators.base_accelerator][INFO] - Training progress: step=75450/100000 (75.45%), epoch=1, lr=1e-05, speed=1.947 step/s, elapsed=10:45:47, eta=03:30:07 +[2026-04-16 10:04:58,239][trainer.accelerators.base_accelerator][INFO] - Training progress: step=75500/100000 (75.50%), epoch=1, lr=1e-05, speed=1.947 step/s, elapsed=10:46:09, eta=03:29:40 +[2026-04-16 10:05:20,298][trainer.accelerators.base_accelerator][INFO] - Training progress: step=75550/100000 (75.55%), epoch=1, lr=1e-05, speed=1.948 step/s, elapsed=10:46:31, eta=03:29:13 +[2026-04-16 10:05:42,384][trainer.accelerators.base_accelerator][INFO] - Training progress: step=75600/100000 (75.60%), epoch=1, lr=1e-05, speed=1.948 step/s, elapsed=10:46:53, eta=03:28:47 +[2026-04-16 10:06:04,784][trainer.accelerators.base_accelerator][INFO] - Training progress: step=75650/100000 (75.65%), epoch=1, lr=1e-05, speed=1.948 step/s, elapsed=10:47:16, eta=03:28:20 +[2026-04-16 10:06:26,874][trainer.accelerators.base_accelerator][INFO] - Training progress: step=75700/100000 (75.70%), epoch=1, lr=1e-05, speed=1.948 step/s, elapsed=10:47:38, eta=03:27:53 +[2026-04-16 10:06:49,046][trainer.accelerators.base_accelerator][INFO] - Training progress: step=75750/100000 (75.75%), epoch=1, lr=1e-05, speed=1.948 step/s, elapsed=10:48:00, eta=03:27:26 +[2026-04-16 10:07:11,127][trainer.accelerators.base_accelerator][INFO] - Training progress: step=75800/100000 (75.80%), epoch=1, lr=1e-05, speed=1.948 step/s, elapsed=10:48:22, eta=03:27:00 +[2026-04-16 10:07:33,157][trainer.accelerators.base_accelerator][INFO] - Training progress: step=75850/100000 (75.85%), epoch=1, lr=1e-05, speed=1.949 step/s, elapsed=10:48:44, eta=03:26:33 +[2026-04-16 10:07:55,238][trainer.accelerators.base_accelerator][INFO] - Training progress: step=75900/100000 (75.90%), epoch=1, lr=1e-05, speed=1.949 step/s, elapsed=10:49:06, eta=03:26:06 +[2026-04-16 10:08:17,291][trainer.accelerators.base_accelerator][INFO] - Training progress: step=75950/100000 (75.95%), epoch=1, lr=1e-05, speed=1.949 step/s, elapsed=10:49:28, eta=03:25:39 +[2026-04-16 10:08:39,226][trainer.accelerators.base_accelerator][INFO] - Training progress: step=76000/100000 (76.00%), epoch=1, lr=1e-05, speed=1.949 step/s, elapsed=10:49:50, eta=03:25:12 +[2026-04-16 10:08:39,264][__main__][INFO] - ========== EVAL START (periodic@gstep=76000) ========== +[2026-04-16 10:08:39,265][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-16 10:08:39,265][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 10:08:54,281][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 15.17788314819336, 'accuracy': 0.5741176470588235, 'num_samples': 425, 'test_unique_accuracy': 0.49537037037037035, 'test_unique_num_samples': 432} +[2026-04-16 10:08:54,281][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-16 10:08:54,282][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 10:09:09,397][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 15.17788314819336, 'accuracy': 0.5741176470588235, 'num_samples': 425, 'test_unique_accuracy': 0.5162037037037037, 'test_unique_num_samples': 432} +[2026-04-16 10:09:09,397][__main__][INFO] - ========== EVAL END (periodic@gstep=76000) ========== +[2026-04-16 10:09:09,397][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 15.195332527160645, 'accuracy': 0.5741176470588235, 'num_samples': 425, 'test_unique_accuracy': 0.5162037037037037, 'test_unique_num_samples': 432} +[2026-04-16 10:09:09,449][trainer.accelerators.base_accelerator][INFO] - Found 3 checkpoints in logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951 +[2026-04-16 10:09:09,455][trainer.accelerators.base_accelerator][INFO] - Deleting checkpoint logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep3000 +[2026-04-16 10:09:09,481][trainer.accelerators.base_accelerator][INFO] - Saving checkpoint to logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep76000 +[2026-04-16 10:09:09,483][accelerate.accelerator][INFO] - Saving current state to logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep76000 +[2026-04-16 10:09:23,507][accelerate.checkpointing][INFO] - Model weights saved in logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep76000/model.safetensors +[2026-04-16 10:09:51,154][accelerate.checkpointing][INFO] - Optimizer state saved in logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep76000/optimizer.bin +[2026-04-16 10:09:51,668][accelerate.checkpointing][INFO] - Scheduler state saved in logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep76000/scheduler.bin +[2026-04-16 10:09:51,668][accelerate.checkpointing][INFO] - Sampler state for dataloader 0 saved in logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep76000/sampler.bin +[2026-04-16 10:09:51,668][accelerate.checkpointing][INFO] - Sampler state for dataloader 1 saved in logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep76000/sampler_1.bin +[2026-04-16 10:09:51,669][accelerate.checkpointing][INFO] - Sampler state for dataloader 2 saved in logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep76000/sampler_2.bin +[2026-04-16 10:09:52,146][accelerate.checkpointing][INFO] - Random states saved in logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep76000/random_states_0.pkl +[2026-04-16 10:09:52,741][trainer.accelerators.base_accelerator][INFO] - Saved checkpoint to logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep76000 +[2026-04-16 10:10:14,984][trainer.accelerators.base_accelerator][INFO] - Training progress: step=76050/100000 (76.05%), epoch=1, lr=1e-05, speed=1.946 step/s, elapsed=10:51:26, eta=03:25:09 +[2026-04-16 10:10:37,671][trainer.accelerators.base_accelerator][INFO] - Training progress: step=76100/100000 (76.10%), epoch=1, lr=1e-05, speed=1.946 step/s, elapsed=10:51:48, eta=03:24:42 +[2026-04-16 10:10:59,779][trainer.accelerators.base_accelerator][INFO] - Training progress: step=76150/100000 (76.15%), epoch=1, lr=1e-05, speed=1.946 step/s, elapsed=10:52:11, eta=03:24:15 +[2026-04-16 10:11:21,833][trainer.accelerators.base_accelerator][INFO] - Training progress: step=76200/100000 (76.20%), epoch=1, lr=1e-05, speed=1.946 step/s, elapsed=10:52:33, eta=03:23:48 +[2026-04-16 10:11:43,975][trainer.accelerators.base_accelerator][INFO] - Training progress: step=76250/100000 (76.25%), epoch=1, lr=1e-05, speed=1.946 step/s, elapsed=10:52:55, eta=03:23:22 +[2026-04-16 10:12:06,103][trainer.accelerators.base_accelerator][INFO] - Training progress: step=76300/100000 (76.30%), epoch=1, lr=1e-05, speed=1.947 step/s, elapsed=10:53:17, eta=03:22:55 +[2026-04-16 10:12:28,094][trainer.accelerators.base_accelerator][INFO] - Training progress: step=76350/100000 (76.35%), epoch=1, lr=1e-05, speed=1.947 step/s, elapsed=10:53:39, eta=03:22:28 +[2026-04-16 10:12:50,157][trainer.accelerators.base_accelerator][INFO] - Training progress: step=76400/100000 (76.40%), epoch=1, lr=1e-05, speed=1.947 step/s, elapsed=10:54:01, eta=03:22:01 +[2026-04-16 10:13:12,247][trainer.accelerators.base_accelerator][INFO] - Training progress: step=76450/100000 (76.45%), epoch=1, lr=1e-05, speed=1.947 step/s, elapsed=10:54:23, eta=03:21:34 +[2026-04-16 10:13:34,356][trainer.accelerators.base_accelerator][INFO] - Training progress: step=76500/100000 (76.50%), epoch=1, lr=1e-05, speed=1.947 step/s, elapsed=10:54:45, eta=03:21:08 +[2026-04-16 10:13:56,457][trainer.accelerators.base_accelerator][INFO] - Training progress: step=76550/100000 (76.55%), epoch=1, lr=1e-05, speed=1.947 step/s, elapsed=10:55:07, eta=03:20:41 +[2026-04-16 10:14:18,580][trainer.accelerators.base_accelerator][INFO] - Training progress: step=76600/100000 (76.60%), epoch=1, lr=1e-05, speed=1.948 step/s, elapsed=10:55:29, eta=03:20:14 +[2026-04-16 10:14:40,510][trainer.accelerators.base_accelerator][INFO] - Training progress: step=76650/100000 (76.65%), epoch=1, lr=1e-05, speed=1.948 step/s, elapsed=10:55:51, eta=03:19:47 +[2026-04-16 10:15:02,818][trainer.accelerators.base_accelerator][INFO] - Training progress: step=76700/100000 (76.70%), epoch=1, lr=1e-05, speed=1.948 step/s, elapsed=10:56:14, eta=03:19:21 +[2026-04-16 10:15:24,914][trainer.accelerators.base_accelerator][INFO] - Training progress: step=76750/100000 (76.75%), epoch=1, lr=1e-05, speed=1.948 step/s, elapsed=10:56:36, eta=03:18:54 +[2026-04-16 10:15:47,001][trainer.accelerators.base_accelerator][INFO] - Training progress: step=76800/100000 (76.80%), epoch=1, lr=1e-05, speed=1.948 step/s, elapsed=10:56:58, eta=03:18:27 +[2026-04-16 10:16:09,102][trainer.accelerators.base_accelerator][INFO] - Training progress: step=76850/100000 (76.85%), epoch=1, lr=1e-05, speed=1.949 step/s, elapsed=10:57:20, eta=03:18:00 +[2026-04-16 10:16:31,197][trainer.accelerators.base_accelerator][INFO] - Training progress: step=76900/100000 (76.90%), epoch=1, lr=1e-05, speed=1.949 step/s, elapsed=10:57:42, eta=03:17:34 +[2026-04-16 10:16:53,257][trainer.accelerators.base_accelerator][INFO] - Training progress: step=76950/100000 (76.95%), epoch=1, lr=1e-05, speed=1.949 step/s, elapsed=10:58:04, eta=03:17:07 +[2026-04-16 10:17:15,380][trainer.accelerators.base_accelerator][INFO] - Training progress: step=77000/100000 (77.00%), epoch=1, lr=1e-05, speed=1.949 step/s, elapsed=10:58:26, eta=03:16:40 +[2026-04-16 10:17:15,419][__main__][INFO] - ========== EVAL START (periodic@gstep=77000) ========== +[2026-04-16 10:17:15,420][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-16 10:17:15,420][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 10:17:30,470][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 15.195332527160645, 'accuracy': 0.5011764705882353, 'num_samples': 425, 'test_unique_accuracy': 0.5162037037037037, 'test_unique_num_samples': 432} +[2026-04-16 10:17:30,471][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-16 10:17:30,471][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 10:17:45,677][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 15.195332527160645, 'accuracy': 0.5011764705882353, 'num_samples': 425, 'test_unique_accuracy': 0.45601851851851855, 'test_unique_num_samples': 432} +[2026-04-16 10:17:45,678][__main__][INFO] - ========== EVAL END (periodic@gstep=77000) ========== +[2026-04-16 10:17:45,678][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 15.224302291870117, 'accuracy': 0.5011764705882353, 'num_samples': 425, 'test_unique_accuracy': 0.45601851851851855, 'test_unique_num_samples': 432} +[2026-04-16 10:17:45,682][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.5011764705882353 is not better than 0.5741176470588235 of logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep76000, skipping checkpoint +[2026-04-16 10:18:07,728][trainer.accelerators.base_accelerator][INFO] - Training progress: step=77050/100000 (77.05%), epoch=1, lr=1e-05, speed=1.948 step/s, elapsed=10:59:18, eta=03:16:22 +[2026-04-16 10:18:29,821][trainer.accelerators.base_accelerator][INFO] - Training progress: step=77100/100000 (77.10%), epoch=1, lr=1e-05, speed=1.948 step/s, elapsed=10:59:41, eta=03:15:56 +[2026-04-16 10:18:51,925][trainer.accelerators.base_accelerator][INFO] - Training progress: step=77150/100000 (77.15%), epoch=1, lr=1e-05, speed=1.948 step/s, elapsed=11:00:03, eta=03:15:29 +[2026-04-16 10:19:14,091][trainer.accelerators.base_accelerator][INFO] - Training progress: step=77200/100000 (77.20%), epoch=1, lr=1e-05, speed=1.948 step/s, elapsed=11:00:25, eta=03:15:02 +[2026-04-16 10:19:36,508][trainer.accelerators.base_accelerator][INFO] - Training progress: step=77250/100000 (77.25%), epoch=1, lr=1e-05, speed=1.948 step/s, elapsed=11:00:47, eta=03:14:36 +[2026-04-16 10:19:58,637][trainer.accelerators.base_accelerator][INFO] - Training progress: step=77300/100000 (77.30%), epoch=1, lr=1e-05, speed=1.949 step/s, elapsed=11:01:09, eta=03:14:09 +[2026-04-16 10:20:20,801][trainer.accelerators.base_accelerator][INFO] - Training progress: step=77350/100000 (77.35%), epoch=1, lr=1e-05, speed=1.949 step/s, elapsed=11:01:32, eta=03:13:42 +[2026-04-16 10:20:42,896][trainer.accelerators.base_accelerator][INFO] - Training progress: step=77400/100000 (77.40%), epoch=1, lr=1e-05, speed=1.949 step/s, elapsed=11:01:54, eta=03:13:16 +[2026-04-16 10:21:04,850][trainer.accelerators.base_accelerator][INFO] - Training progress: step=77450/100000 (77.45%), epoch=1, lr=1e-05, speed=1.949 step/s, elapsed=11:02:16, eta=03:12:49 +[2026-04-16 10:21:26,887][trainer.accelerators.base_accelerator][INFO] - Training progress: step=77500/100000 (77.50%), epoch=1, lr=1e-05, speed=1.949 step/s, elapsed=11:02:38, eta=03:12:22 +[2026-04-16 10:21:48,896][trainer.accelerators.base_accelerator][INFO] - Training progress: step=77550/100000 (77.55%), epoch=1, lr=1e-05, speed=1.949 step/s, elapsed=11:03:00, eta=03:11:55 +[2026-04-16 10:22:11,011][trainer.accelerators.base_accelerator][INFO] - Training progress: step=77600/100000 (77.60%), epoch=1, lr=1e-05, speed=1.950 step/s, elapsed=11:03:22, eta=03:11:29 +[2026-04-16 10:22:33,183][trainer.accelerators.base_accelerator][INFO] - Training progress: step=77650/100000 (77.65%), epoch=1, lr=1e-05, speed=1.950 step/s, elapsed=11:03:44, eta=03:11:02 +[2026-04-16 10:22:55,626][trainer.accelerators.base_accelerator][INFO] - Training progress: step=77700/100000 (77.70%), epoch=1, lr=1e-05, speed=1.950 step/s, elapsed=11:04:06, eta=03:10:36 +[2026-04-16 10:23:17,728][trainer.accelerators.base_accelerator][INFO] - Training progress: step=77750/100000 (77.75%), epoch=1, lr=1e-05, speed=1.950 step/s, elapsed=11:04:28, eta=03:10:09 +[2026-04-16 10:23:39,705][trainer.accelerators.base_accelerator][INFO] - Training progress: step=77800/100000 (77.80%), epoch=1, lr=1e-05, speed=1.950 step/s, elapsed=11:04:50, eta=03:09:42 +[2026-04-16 10:24:01,858][trainer.accelerators.base_accelerator][INFO] - Training progress: step=77850/100000 (77.85%), epoch=1, lr=1e-05, speed=1.950 step/s, elapsed=11:05:13, eta=03:09:16 +[2026-04-16 10:24:23,970][trainer.accelerators.base_accelerator][INFO] - Training progress: step=77900/100000 (77.90%), epoch=1, lr=1e-05, speed=1.951 step/s, elapsed=11:05:35, eta=03:08:49 +[2026-04-16 10:24:46,016][trainer.accelerators.base_accelerator][INFO] - Training progress: step=77950/100000 (77.95%), epoch=1, lr=1e-05, speed=1.951 step/s, elapsed=11:05:57, eta=03:08:22 +[2026-04-16 10:25:08,123][trainer.accelerators.base_accelerator][INFO] - Training progress: step=78000/100000 (78.00%), epoch=1, lr=1e-05, speed=1.951 step/s, elapsed=11:06:19, eta=03:07:56 +[2026-04-16 10:25:08,162][__main__][INFO] - ========== EVAL START (periodic@gstep=78000) ========== +[2026-04-16 10:25:08,162][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-16 10:25:08,162][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 10:25:24,266][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 15.224302291870117, 'accuracy': 0.48470588235294115, 'num_samples': 425, 'test_unique_accuracy': 0.45601851851851855, 'test_unique_num_samples': 432} +[2026-04-16 10:25:24,266][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-16 10:25:24,266][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 10:25:39,487][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 15.224302291870117, 'accuracy': 0.48470588235294115, 'num_samples': 425, 'test_unique_accuracy': 0.47685185185185186, 'test_unique_num_samples': 432} +[2026-04-16 10:25:39,487][__main__][INFO] - ========== EVAL END (periodic@gstep=78000) ========== +[2026-04-16 10:25:39,488][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 15.241907119750977, 'accuracy': 0.48470588235294115, 'num_samples': 425, 'test_unique_accuracy': 0.47685185185185186, 'test_unique_num_samples': 432} +[2026-04-16 10:25:39,491][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.48470588235294115 is not better than 0.5741176470588235 of logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep76000, skipping checkpoint +[2026-04-16 10:26:01,528][trainer.accelerators.base_accelerator][INFO] - Training progress: step=78050/100000 (78.05%), epoch=1, lr=1e-05, speed=1.950 step/s, elapsed=11:07:12, eta=03:07:38 +[2026-04-16 10:26:23,905][trainer.accelerators.base_accelerator][INFO] - Training progress: step=78100/100000 (78.10%), epoch=1, lr=1e-05, speed=1.950 step/s, elapsed=11:07:35, eta=03:07:11 +[2026-04-16 10:26:45,995][trainer.accelerators.base_accelerator][INFO] - Training progress: step=78150/100000 (78.15%), epoch=1, lr=1e-05, speed=1.950 step/s, elapsed=11:07:57, eta=03:06:45 +[2026-04-16 10:27:08,058][trainer.accelerators.base_accelerator][INFO] - Training progress: step=78200/100000 (78.20%), epoch=1, lr=1e-05, speed=1.950 step/s, elapsed=11:08:19, eta=03:06:18 +[2026-04-16 10:27:30,067][trainer.accelerators.base_accelerator][INFO] - Training progress: step=78250/100000 (78.25%), epoch=1, lr=1e-05, speed=1.950 step/s, elapsed=11:08:41, eta=03:05:51 +[2026-04-16 10:27:52,115][trainer.accelerators.base_accelerator][INFO] - Training progress: step=78300/100000 (78.30%), epoch=1, lr=1e-05, speed=1.951 step/s, elapsed=11:09:03, eta=03:05:25 +[2026-04-16 10:28:14,419][trainer.accelerators.base_accelerator][INFO] - Training progress: step=78350/100000 (78.35%), epoch=1, lr=1e-05, speed=1.951 step/s, elapsed=11:09:25, eta=03:04:58 +[2026-04-16 10:28:36,543][trainer.accelerators.base_accelerator][INFO] - Training progress: step=78400/100000 (78.40%), epoch=1, lr=1e-05, speed=1.951 step/s, elapsed=11:09:47, eta=03:04:32 +[2026-04-16 10:28:58,582][trainer.accelerators.base_accelerator][INFO] - Training progress: step=78450/100000 (78.45%), epoch=1, lr=1e-05, speed=1.951 step/s, elapsed=11:10:09, eta=03:04:05 +[2026-04-16 10:29:20,704][trainer.accelerators.base_accelerator][INFO] - Training progress: step=78500/100000 (78.50%), epoch=1, lr=1e-05, speed=1.951 step/s, elapsed=11:10:31, eta=03:03:38 +[2026-04-16 10:29:43,131][trainer.accelerators.base_accelerator][INFO] - Training progress: step=78550/100000 (78.55%), epoch=1, lr=1e-05, speed=1.951 step/s, elapsed=11:10:54, eta=03:03:12 +[2026-04-16 10:30:05,240][trainer.accelerators.base_accelerator][INFO] - Training progress: step=78600/100000 (78.60%), epoch=1, lr=1e-05, speed=1.952 step/s, elapsed=11:11:16, eta=03:02:45 +[2026-04-16 10:30:27,253][trainer.accelerators.base_accelerator][INFO] - Training progress: step=78650/100000 (78.65%), epoch=1, lr=1e-05, speed=1.952 step/s, elapsed=11:11:38, eta=03:02:19 +[2026-04-16 10:30:49,221][trainer.accelerators.base_accelerator][INFO] - Training progress: step=78700/100000 (78.70%), epoch=1, lr=1e-05, speed=1.952 step/s, elapsed=11:12:00, eta=03:01:52 +[2026-04-16 10:31:11,370][trainer.accelerators.base_accelerator][INFO] - Training progress: step=78750/100000 (78.75%), epoch=1, lr=1e-05, speed=1.952 step/s, elapsed=11:12:22, eta=03:01:26 +[2026-04-16 10:31:33,728][trainer.accelerators.base_accelerator][INFO] - Training progress: step=78800/100000 (78.80%), epoch=1, lr=1e-05, speed=1.952 step/s, elapsed=11:12:44, eta=03:00:59 +[2026-04-16 10:31:55,832][trainer.accelerators.base_accelerator][INFO] - Training progress: step=78850/100000 (78.85%), epoch=1, lr=1e-05, speed=1.952 step/s, elapsed=11:13:07, eta=03:00:33 +[2026-04-16 10:32:17,904][trainer.accelerators.base_accelerator][INFO] - Training progress: step=78900/100000 (78.90%), epoch=1, lr=1e-05, speed=1.953 step/s, elapsed=11:13:29, eta=03:00:06 +[2026-04-16 10:32:39,958][trainer.accelerators.base_accelerator][INFO] - Training progress: step=78950/100000 (78.95%), epoch=1, lr=1e-05, speed=1.953 step/s, elapsed=11:13:51, eta=02:59:39 +[2026-04-16 10:33:02,094][trainer.accelerators.base_accelerator][INFO] - Training progress: step=79000/100000 (79.00%), epoch=1, lr=1e-05, speed=1.953 step/s, elapsed=11:14:13, eta=02:59:13 +[2026-04-16 10:33:02,134][__main__][INFO] - ========== EVAL START (periodic@gstep=79000) ========== +[2026-04-16 10:33:02,134][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-16 10:33:02,134][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 10:33:17,601][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 15.241907119750977, 'accuracy': 0.5035294117647059, 'num_samples': 425, 'test_unique_accuracy': 0.47685185185185186, 'test_unique_num_samples': 432} +[2026-04-16 10:33:17,601][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-16 10:33:17,602][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 10:33:32,790][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 15.241907119750977, 'accuracy': 0.5035294117647059, 'num_samples': 425, 'test_unique_accuracy': 0.4930555555555556, 'test_unique_num_samples': 432} +[2026-04-16 10:33:32,790][__main__][INFO] - ========== EVAL END (periodic@gstep=79000) ========== +[2026-04-16 10:33:32,791][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 15.259228706359863, 'accuracy': 0.5035294117647059, 'num_samples': 425, 'test_unique_accuracy': 0.4930555555555556, 'test_unique_num_samples': 432} +[2026-04-16 10:33:32,793][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.5035294117647059 is not better than 0.5741176470588235 of logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep76000, skipping checkpoint +[2026-04-16 10:33:54,888][trainer.accelerators.base_accelerator][INFO] - Training progress: step=79050/100000 (79.05%), epoch=1, lr=1e-05, speed=1.952 step/s, elapsed=11:15:06, eta=02:58:55 +[2026-04-16 10:34:16,947][trainer.accelerators.base_accelerator][INFO] - Training progress: step=79100/100000 (79.10%), epoch=1, lr=1e-05, speed=1.952 step/s, elapsed=11:15:28, eta=02:58:28 +[2026-04-16 10:34:39,014][trainer.accelerators.base_accelerator][INFO] - Training progress: step=79150/100000 (79.15%), epoch=1, lr=1e-05, speed=1.952 step/s, elapsed=11:15:50, eta=02:58:01 +[2026-04-16 10:35:01,141][trainer.accelerators.base_accelerator][INFO] - Training progress: step=79200/100000 (79.20%), epoch=1, lr=1e-05, speed=1.952 step/s, elapsed=11:16:12, eta=02:57:35 +[2026-04-16 10:35:23,254][trainer.accelerators.base_accelerator][INFO] - Training progress: step=79250/100000 (79.25%), epoch=1, lr=1e-05, speed=1.952 step/s, elapsed=11:16:34, eta=02:57:08 +[2026-04-16 10:35:45,297][trainer.accelerators.base_accelerator][INFO] - Training progress: step=79300/100000 (79.30%), epoch=1, lr=1e-05, speed=1.952 step/s, elapsed=11:16:56, eta=02:56:42 +[2026-04-16 10:36:07,346][trainer.accelerators.base_accelerator][INFO] - Training progress: step=79350/100000 (79.35%), epoch=1, lr=1e-05, speed=1.953 step/s, elapsed=11:17:18, eta=02:56:15 +[2026-04-16 10:36:29,437][trainer.accelerators.base_accelerator][INFO] - Training progress: step=79400/100000 (79.40%), epoch=1, lr=1e-05, speed=1.953 step/s, elapsed=11:17:40, eta=02:55:49 +[2026-04-16 10:36:51,502][trainer.accelerators.base_accelerator][INFO] - Training progress: step=79450/100000 (79.45%), epoch=1, lr=1e-05, speed=1.953 step/s, elapsed=11:18:02, eta=02:55:22 +[2026-04-16 10:37:13,639][trainer.accelerators.base_accelerator][INFO] - Training progress: step=79500/100000 (79.50%), epoch=1, lr=1e-05, speed=1.953 step/s, elapsed=11:18:24, eta=02:54:56 +[2026-04-16 10:37:35,720][trainer.accelerators.base_accelerator][INFO] - Training progress: step=79550/100000 (79.55%), epoch=1, lr=1e-05, speed=1.953 step/s, elapsed=11:18:46, eta=02:54:29 +[2026-04-16 10:37:58,132][trainer.accelerators.base_accelerator][INFO] - Training progress: step=79600/100000 (79.60%), epoch=1, lr=1e-05, speed=1.953 step/s, elapsed=11:19:09, eta=02:54:03 +[2026-04-16 10:38:20,298][trainer.accelerators.base_accelerator][INFO] - Training progress: step=79650/100000 (79.65%), epoch=1, lr=1e-05, speed=1.954 step/s, elapsed=11:19:31, eta=02:53:36 +[2026-04-16 10:38:42,390][trainer.accelerators.base_accelerator][INFO] - Training progress: step=79700/100000 (79.70%), epoch=1, lr=1e-05, speed=1.954 step/s, elapsed=11:19:53, eta=02:53:10 +[2026-04-16 10:39:04,460][trainer.accelerators.base_accelerator][INFO] - Training progress: step=79750/100000 (79.75%), epoch=1, lr=1e-05, speed=1.954 step/s, elapsed=11:20:15, eta=02:52:43 +[2026-04-16 10:39:26,530][trainer.accelerators.base_accelerator][INFO] - Training progress: step=79800/100000 (79.80%), epoch=1, lr=1e-05, speed=1.954 step/s, elapsed=11:20:37, eta=02:52:17 +[2026-04-16 10:39:48,644][trainer.accelerators.base_accelerator][INFO] - Training progress: step=79850/100000 (79.85%), epoch=1, lr=1e-05, speed=1.954 step/s, elapsed=11:20:59, eta=02:51:50 +[2026-04-16 10:40:10,685][trainer.accelerators.base_accelerator][INFO] - Training progress: step=79900/100000 (79.90%), epoch=1, lr=1e-05, speed=1.954 step/s, elapsed=11:21:21, eta=02:51:24 +[2026-04-16 10:40:32,839][trainer.accelerators.base_accelerator][INFO] - Training progress: step=79950/100000 (79.95%), epoch=1, lr=1e-05, speed=1.955 step/s, elapsed=11:21:44, eta=02:50:57 +[2026-04-16 10:40:54,930][trainer.accelerators.base_accelerator][INFO] - Training progress: step=80000/100000 (80.00%), epoch=1, lr=1e-05, speed=1.955 step/s, elapsed=11:22:06, eta=02:50:31 +[2026-04-16 10:40:54,969][__main__][INFO] - ========== EVAL START (periodic@gstep=80000) ========== +[2026-04-16 10:40:54,969][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-16 10:40:54,970][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 10:41:10,060][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 15.259228706359863, 'accuracy': 0.4823529411764706, 'num_samples': 425, 'test_unique_accuracy': 0.4930555555555556, 'test_unique_num_samples': 432} +[2026-04-16 10:41:10,060][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-16 10:41:10,060][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 10:41:25,194][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 15.259228706359863, 'accuracy': 0.4823529411764706, 'num_samples': 425, 'test_unique_accuracy': 0.5092592592592593, 'test_unique_num_samples': 432} +[2026-04-16 10:41:25,195][__main__][INFO] - ========== EVAL END (periodic@gstep=80000) ========== +[2026-04-16 10:41:25,195][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 15.27972412109375, 'accuracy': 0.4823529411764706, 'num_samples': 425, 'test_unique_accuracy': 0.5092592592592593, 'test_unique_num_samples': 432} +[2026-04-16 10:41:25,220][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.4823529411764706 is not better than 0.5741176470588235 of logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep76000, skipping checkpoint +[2026-04-16 10:41:47,381][trainer.accelerators.base_accelerator][INFO] - Training progress: step=80050/100000 (80.05%), epoch=1, lr=1e-05, speed=1.953 step/s, elapsed=11:22:58, eta=02:50:12 +[2026-04-16 10:42:09,559][trainer.accelerators.base_accelerator][INFO] - Training progress: step=80100/100000 (80.10%), epoch=1, lr=1e-05, speed=1.954 step/s, elapsed=11:23:20, eta=02:49:46 +[2026-04-16 10:42:31,954][trainer.accelerators.base_accelerator][INFO] - Training progress: step=80150/100000 (80.15%), epoch=1, lr=1e-05, speed=1.954 step/s, elapsed=11:23:43, eta=02:49:19 +[2026-04-16 10:42:54,008][trainer.accelerators.base_accelerator][INFO] - Training progress: step=80200/100000 (80.20%), epoch=1, lr=1e-05, speed=1.954 step/s, elapsed=11:24:05, eta=02:48:53 +[2026-04-16 10:43:16,009][trainer.accelerators.base_accelerator][INFO] - Training progress: step=80250/100000 (80.25%), epoch=1, lr=1e-05, speed=1.954 step/s, elapsed=11:24:27, eta=02:48:26 +[2026-04-16 10:43:38,037][trainer.accelerators.base_accelerator][INFO] - Training progress: step=80300/100000 (80.30%), epoch=1, lr=1e-05, speed=1.954 step/s, elapsed=11:24:49, eta=02:48:00 +[2026-04-16 10:44:00,161][trainer.accelerators.base_accelerator][INFO] - Training progress: step=80350/100000 (80.35%), epoch=1, lr=1e-05, speed=1.954 step/s, elapsed=11:25:11, eta=02:47:34 +[2026-04-16 10:44:22,285][trainer.accelerators.base_accelerator][INFO] - Training progress: step=80400/100000 (80.40%), epoch=1, lr=1e-05, speed=1.955 step/s, elapsed=11:25:33, eta=02:47:07 +[2026-04-16 10:44:44,482][trainer.accelerators.base_accelerator][INFO] - Training progress: step=80450/100000 (80.45%), epoch=1, lr=1e-05, speed=1.955 step/s, elapsed=11:25:55, eta=02:46:41 +[2026-04-16 10:45:06,598][trainer.accelerators.base_accelerator][INFO] - Training progress: step=80500/100000 (80.50%), epoch=1, lr=1e-05, speed=1.955 step/s, elapsed=11:26:17, eta=02:46:14 +[2026-04-16 10:45:28,758][trainer.accelerators.base_accelerator][INFO] - Training progress: step=80550/100000 (80.55%), epoch=1, lr=1e-05, speed=1.955 step/s, elapsed=11:26:40, eta=02:45:48 +[2026-04-16 10:45:50,887][trainer.accelerators.base_accelerator][INFO] - Training progress: step=80600/100000 (80.60%), epoch=1, lr=1e-05, speed=1.955 step/s, elapsed=11:27:02, eta=02:45:21 +[2026-04-16 10:46:13,235][trainer.accelerators.base_accelerator][INFO] - Training progress: step=80650/100000 (80.65%), epoch=1, lr=1e-05, speed=1.955 step/s, elapsed=11:27:24, eta=02:44:55 +[2026-04-16 10:46:35,351][trainer.accelerators.base_accelerator][INFO] - Training progress: step=80700/100000 (80.70%), epoch=1, lr=1e-05, speed=1.956 step/s, elapsed=11:27:46, eta=02:44:29 +[2026-04-16 10:46:57,408][trainer.accelerators.base_accelerator][INFO] - Training progress: step=80750/100000 (80.75%), epoch=1, lr=1e-05, speed=1.956 step/s, elapsed=11:28:08, eta=02:44:02 +[2026-04-16 10:47:19,539][trainer.accelerators.base_accelerator][INFO] - Training progress: step=80800/100000 (80.80%), epoch=1, lr=1e-05, speed=1.956 step/s, elapsed=11:28:30, eta=02:43:36 +[2026-04-16 10:47:41,659][trainer.accelerators.base_accelerator][INFO] - Training progress: step=80850/100000 (80.85%), epoch=1, lr=1e-05, speed=1.956 step/s, elapsed=11:28:52, eta=02:43:10 +[2026-04-16 10:48:03,815][trainer.accelerators.base_accelerator][INFO] - Training progress: step=80900/100000 (80.90%), epoch=1, lr=1e-05, speed=1.956 step/s, elapsed=11:29:15, eta=02:42:43 +[2026-04-16 10:48:25,915][trainer.accelerators.base_accelerator][INFO] - Training progress: step=80950/100000 (80.95%), epoch=1, lr=1e-05, speed=1.956 step/s, elapsed=11:29:37, eta=02:42:17 +[2026-04-16 10:48:48,000][trainer.accelerators.base_accelerator][INFO] - Training progress: step=81000/100000 (81.00%), epoch=1, lr=1e-05, speed=1.957 step/s, elapsed=11:29:59, eta=02:41:50 +[2026-04-16 10:48:48,039][__main__][INFO] - ========== EVAL START (periodic@gstep=81000) ========== +[2026-04-16 10:48:48,039][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-16 10:48:48,039][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 10:49:03,400][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 15.27972412109375, 'accuracy': 0.45647058823529413, 'num_samples': 425, 'test_unique_accuracy': 0.5092592592592593, 'test_unique_num_samples': 432} +[2026-04-16 10:49:03,401][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-16 10:49:03,401][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 10:49:18,528][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 15.27972412109375, 'accuracy': 0.45647058823529413, 'num_samples': 425, 'test_unique_accuracy': 0.4791666666666667, 'test_unique_num_samples': 432} +[2026-04-16 10:49:18,528][__main__][INFO] - ========== EVAL END (periodic@gstep=81000) ========== +[2026-04-16 10:49:18,528][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 15.299616813659668, 'accuracy': 0.45647058823529413, 'num_samples': 425, 'test_unique_accuracy': 0.4791666666666667, 'test_unique_num_samples': 432} +[2026-04-16 10:49:18,532][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.45647058823529413 is not better than 0.5741176470588235 of logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep76000, skipping checkpoint +[2026-04-16 10:49:40,818][trainer.accelerators.base_accelerator][INFO] - Training progress: step=81050/100000 (81.05%), epoch=1, lr=1e-05, speed=1.955 step/s, elapsed=11:30:52, eta=02:41:31 +[2026-04-16 10:50:02,945][trainer.accelerators.base_accelerator][INFO] - Training progress: step=81100/100000 (81.10%), epoch=1, lr=1e-05, speed=1.955 step/s, elapsed=11:31:14, eta=02:41:05 +[2026-04-16 10:50:25,073][trainer.accelerators.base_accelerator][INFO] - Training progress: step=81150/100000 (81.15%), epoch=1, lr=1e-05, speed=1.956 step/s, elapsed=11:31:36, eta=02:40:39 +[2026-04-16 10:50:47,185][trainer.accelerators.base_accelerator][INFO] - Training progress: step=81200/100000 (81.20%), epoch=1, lr=1e-05, speed=1.956 step/s, elapsed=11:31:58, eta=02:40:12 +[2026-04-16 10:51:09,255][trainer.accelerators.base_accelerator][INFO] - Training progress: step=81250/100000 (81.25%), epoch=1, lr=1e-05, speed=1.956 step/s, elapsed=11:32:20, eta=02:39:46 +[2026-04-16 10:51:31,607][trainer.accelerators.base_accelerator][INFO] - Training progress: step=81300/100000 (81.30%), epoch=1, lr=1e-05, speed=1.956 step/s, elapsed=11:32:42, eta=02:39:19 +[2026-04-16 10:51:53,639][trainer.accelerators.base_accelerator][INFO] - Training progress: step=81350/100000 (81.35%), epoch=1, lr=1e-05, speed=1.956 step/s, elapsed=11:33:04, eta=02:38:53 +[2026-04-16 10:52:15,697][trainer.accelerators.base_accelerator][INFO] - Training progress: step=81400/100000 (81.40%), epoch=1, lr=1e-05, speed=1.956 step/s, elapsed=11:33:26, eta=02:38:27 +[2026-04-16 10:52:37,829][trainer.accelerators.base_accelerator][INFO] - Training progress: step=81450/100000 (81.45%), epoch=1, lr=1e-05, speed=1.957 step/s, elapsed=11:33:49, eta=02:38:00 +[2026-04-16 10:53:00,293][trainer.accelerators.base_accelerator][INFO] - Training progress: step=81500/100000 (81.50%), epoch=1, lr=1e-05, speed=1.957 step/s, elapsed=11:34:11, eta=02:37:34 +[2026-04-16 10:53:22,431][trainer.accelerators.base_accelerator][INFO] - Training progress: step=81550/100000 (81.55%), epoch=1, lr=1e-05, speed=1.957 step/s, elapsed=11:34:33, eta=02:37:08 +[2026-04-16 10:53:44,469][trainer.accelerators.base_accelerator][INFO] - Training progress: step=81600/100000 (81.60%), epoch=1, lr=1e-05, speed=1.957 step/s, elapsed=11:34:55, eta=02:36:41 +[2026-04-16 10:54:06,597][trainer.accelerators.base_accelerator][INFO] - Training progress: step=81650/100000 (81.65%), epoch=1, lr=1e-05, speed=1.957 step/s, elapsed=11:35:17, eta=02:36:15 +[2026-04-16 10:54:28,757][trainer.accelerators.base_accelerator][INFO] - Training progress: step=81700/100000 (81.70%), epoch=1, lr=1e-05, speed=1.957 step/s, elapsed=11:35:40, eta=02:35:49 +[2026-04-16 10:54:51,086][trainer.accelerators.base_accelerator][INFO] - Training progress: step=81750/100000 (81.75%), epoch=1, lr=1e-05, speed=1.958 step/s, elapsed=11:36:02, eta=02:35:23 +[2026-04-16 10:55:13,053][trainer.accelerators.base_accelerator][INFO] - Training progress: step=81800/100000 (81.80%), epoch=1, lr=1e-05, speed=1.958 step/s, elapsed=11:36:24, eta=02:34:56 +[2026-04-16 10:55:35,153][trainer.accelerators.base_accelerator][INFO] - Training progress: step=81850/100000 (81.85%), epoch=1, lr=1e-05, speed=1.958 step/s, elapsed=11:36:46, eta=02:34:30 +[2026-04-16 10:55:57,200][trainer.accelerators.base_accelerator][INFO] - Training progress: step=81900/100000 (81.90%), epoch=1, lr=1e-05, speed=1.958 step/s, elapsed=11:37:08, eta=02:34:04 +[2026-04-16 10:56:19,187][trainer.accelerators.base_accelerator][INFO] - Training progress: step=81950/100000 (81.95%), epoch=1, lr=1e-05, speed=1.958 step/s, elapsed=11:37:30, eta=02:33:37 +[2026-04-16 10:56:41,536][trainer.accelerators.base_accelerator][INFO] - Training progress: step=82000/100000 (82.00%), epoch=1, lr=1e-05, speed=1.958 step/s, elapsed=11:37:52, eta=02:33:11 +[2026-04-16 10:56:41,574][__main__][INFO] - ========== EVAL START (periodic@gstep=82000) ========== +[2026-04-16 10:56:41,575][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-16 10:56:41,575][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 10:57:00,594][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 15.299616813659668, 'accuracy': 0.48470588235294115, 'num_samples': 425, 'test_unique_accuracy': 0.4791666666666667, 'test_unique_num_samples': 432} +[2026-04-16 10:57:00,595][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-16 10:57:00,595][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 10:57:15,765][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 15.299616813659668, 'accuracy': 0.48470588235294115, 'num_samples': 425, 'test_unique_accuracy': 0.4791666666666667, 'test_unique_num_samples': 432} +[2026-04-16 10:57:15,765][__main__][INFO] - ========== EVAL END (periodic@gstep=82000) ========== +[2026-04-16 10:57:15,765][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 15.313383102416992, 'accuracy': 0.48470588235294115, 'num_samples': 425, 'test_unique_accuracy': 0.4791666666666667, 'test_unique_num_samples': 432} +[2026-04-16 10:57:15,769][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.48470588235294115 is not better than 0.5741176470588235 of logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep76000, skipping checkpoint +[2026-04-16 10:57:37,848][trainer.accelerators.base_accelerator][INFO] - Training progress: step=82050/100000 (82.05%), epoch=1, lr=1e-05, speed=1.957 step/s, elapsed=11:38:49, eta=02:32:52 +[2026-04-16 10:57:59,957][trainer.accelerators.base_accelerator][INFO] - Training progress: step=82100/100000 (82.10%), epoch=1, lr=1e-05, speed=1.957 step/s, elapsed=11:39:11, eta=02:32:26 +[2026-04-16 10:58:22,010][trainer.accelerators.base_accelerator][INFO] - Training progress: step=82150/100000 (82.15%), epoch=1, lr=1e-05, speed=1.957 step/s, elapsed=11:39:33, eta=02:32:00 +[2026-04-16 10:58:44,025][trainer.accelerators.base_accelerator][INFO] - Training progress: step=82200/100000 (82.20%), epoch=1, lr=1e-05, speed=1.957 step/s, elapsed=11:39:55, eta=02:31:33 +[2026-04-16 10:59:06,144][trainer.accelerators.base_accelerator][INFO] - Training progress: step=82250/100000 (82.25%), epoch=1, lr=1e-05, speed=1.958 step/s, elapsed=11:40:17, eta=02:31:07 +[2026-04-16 10:59:28,273][trainer.accelerators.base_accelerator][INFO] - Training progress: step=82300/100000 (82.30%), epoch=1, lr=1e-05, speed=1.958 step/s, elapsed=11:40:39, eta=02:30:41 +[2026-04-16 10:59:50,309][trainer.accelerators.base_accelerator][INFO] - Training progress: step=82350/100000 (82.35%), epoch=1, lr=1e-05, speed=1.958 step/s, elapsed=11:41:01, eta=02:30:15 +[2026-04-16 11:00:12,427][trainer.accelerators.base_accelerator][INFO] - Training progress: step=82400/100000 (82.40%), epoch=1, lr=1e-05, speed=1.958 step/s, elapsed=11:41:23, eta=02:29:48 +[2026-04-16 11:00:34,566][trainer.accelerators.base_accelerator][INFO] - Training progress: step=82450/100000 (82.45%), epoch=1, lr=1e-05, speed=1.958 step/s, elapsed=11:41:45, eta=02:29:22 +[2026-04-16 11:00:56,969][trainer.accelerators.base_accelerator][INFO] - Training progress: step=82500/100000 (82.50%), epoch=1, lr=1e-05, speed=1.958 step/s, elapsed=11:42:08, eta=02:28:56 +[2026-04-16 11:01:19,044][trainer.accelerators.base_accelerator][INFO] - Training progress: step=82550/100000 (82.55%), epoch=1, lr=1e-05, speed=1.958 step/s, elapsed=11:42:30, eta=02:28:30 +[2026-04-16 11:01:41,220][trainer.accelerators.base_accelerator][INFO] - Training progress: step=82600/100000 (82.60%), epoch=1, lr=1e-05, speed=1.959 step/s, elapsed=11:42:52, eta=02:28:03 +[2026-04-16 11:02:03,255][trainer.accelerators.base_accelerator][INFO] - Training progress: step=82650/100000 (82.65%), epoch=1, lr=1e-05, speed=1.959 step/s, elapsed=11:43:14, eta=02:27:37 +[2026-04-16 11:02:25,266][trainer.accelerators.base_accelerator][INFO] - Training progress: step=82700/100000 (82.70%), epoch=1, lr=1e-05, speed=1.959 step/s, elapsed=11:43:36, eta=02:27:11 +[2026-04-16 11:02:47,346][trainer.accelerators.base_accelerator][INFO] - Training progress: step=82750/100000 (82.75%), epoch=1, lr=1e-05, speed=1.959 step/s, elapsed=11:43:58, eta=02:26:45 +[2026-04-16 11:03:09,469][trainer.accelerators.base_accelerator][INFO] - Training progress: step=82800/100000 (82.80%), epoch=1, lr=1e-05, speed=1.959 step/s, elapsed=11:44:20, eta=02:26:18 +[2026-04-16 11:03:31,590][trainer.accelerators.base_accelerator][INFO] - Training progress: step=82850/100000 (82.85%), epoch=1, lr=1e-05, speed=1.959 step/s, elapsed=11:44:42, eta=02:25:52 +[2026-04-16 11:03:53,686][trainer.accelerators.base_accelerator][INFO] - Training progress: step=82900/100000 (82.90%), epoch=1, lr=1e-05, speed=1.960 step/s, elapsed=11:45:04, eta=02:25:26 +[2026-04-16 11:04:15,771][trainer.accelerators.base_accelerator][INFO] - Training progress: step=82950/100000 (82.95%), epoch=1, lr=1e-05, speed=1.960 step/s, elapsed=11:45:27, eta=02:25:00 +[2026-04-16 11:04:37,919][trainer.accelerators.base_accelerator][INFO] - Training progress: step=83000/100000 (83.00%), epoch=1, lr=1e-05, speed=1.960 step/s, elapsed=11:45:49, eta=02:24:33 +[2026-04-16 11:04:37,958][__main__][INFO] - ========== EVAL START (periodic@gstep=83000) ========== +[2026-04-16 11:04:37,958][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-16 11:04:37,958][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 11:04:53,106][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 15.313383102416992, 'accuracy': 0.5223529411764706, 'num_samples': 425, 'test_unique_accuracy': 0.4791666666666667, 'test_unique_num_samples': 432} +[2026-04-16 11:04:53,106][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-16 11:04:53,106][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 11:05:08,292][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 15.313383102416992, 'accuracy': 0.5223529411764706, 'num_samples': 425, 'test_unique_accuracy': 0.5393518518518519, 'test_unique_num_samples': 432} +[2026-04-16 11:05:08,292][__main__][INFO] - ========== EVAL END (periodic@gstep=83000) ========== +[2026-04-16 11:05:08,292][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 15.342029571533203, 'accuracy': 0.5223529411764706, 'num_samples': 425, 'test_unique_accuracy': 0.5393518518518519, 'test_unique_num_samples': 432} +[2026-04-16 11:05:08,295][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.5223529411764706 is not better than 0.5741176470588235 of logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep76000, skipping checkpoint +[2026-04-16 11:05:30,732][trainer.accelerators.base_accelerator][INFO] - Training progress: step=83050/100000 (83.05%), epoch=1, lr=1e-05, speed=1.959 step/s, elapsed=11:46:41, eta=02:24:13 +[2026-04-16 11:05:52,877][trainer.accelerators.base_accelerator][INFO] - Training progress: step=83100/100000 (83.10%), epoch=1, lr=1e-05, speed=1.959 step/s, elapsed=11:47:04, eta=02:23:47 +[2026-04-16 11:06:14,928][trainer.accelerators.base_accelerator][INFO] - Training progress: step=83150/100000 (83.15%), epoch=1, lr=1e-05, speed=1.959 step/s, elapsed=11:47:26, eta=02:23:21 +[2026-04-16 11:06:37,033][trainer.accelerators.base_accelerator][INFO] - Training progress: step=83200/100000 (83.20%), epoch=1, lr=1e-05, speed=1.959 step/s, elapsed=11:47:48, eta=02:22:55 +[2026-04-16 11:06:59,060][trainer.accelerators.base_accelerator][INFO] - Training progress: step=83250/100000 (83.25%), epoch=1, lr=1e-05, speed=1.959 step/s, elapsed=11:48:10, eta=02:22:29 +[2026-04-16 11:07:21,200][trainer.accelerators.base_accelerator][INFO] - Training progress: step=83300/100000 (83.30%), epoch=1, lr=1e-05, speed=1.959 step/s, elapsed=11:48:32, eta=02:22:02 +[2026-04-16 11:07:43,400][trainer.accelerators.base_accelerator][INFO] - Training progress: step=83350/100000 (83.35%), epoch=1, lr=1e-05, speed=1.960 step/s, elapsed=11:48:54, eta=02:21:36 +[2026-04-16 11:08:05,592][trainer.accelerators.base_accelerator][INFO] - Training progress: step=83400/100000 (83.40%), epoch=1, lr=1e-05, speed=1.960 step/s, elapsed=11:49:16, eta=02:21:10 +[2026-04-16 11:08:27,734][trainer.accelerators.base_accelerator][INFO] - Training progress: step=83450/100000 (83.45%), epoch=1, lr=1e-05, speed=1.960 step/s, elapsed=11:49:38, eta=02:20:44 +[2026-04-16 11:08:49,891][trainer.accelerators.base_accelerator][INFO] - Training progress: step=83500/100000 (83.50%), epoch=1, lr=1e-05, speed=1.960 step/s, elapsed=11:50:01, eta=02:20:18 +[2026-04-16 11:09:12,295][trainer.accelerators.base_accelerator][INFO] - Training progress: step=83550/100000 (83.55%), epoch=1, lr=1e-05, speed=1.960 step/s, elapsed=11:50:23, eta=02:19:52 +[2026-04-16 11:09:34,469][trainer.accelerators.base_accelerator][INFO] - Training progress: step=83600/100000 (83.60%), epoch=1, lr=1e-05, speed=1.960 step/s, elapsed=11:50:45, eta=02:19:25 +[2026-04-16 11:09:56,588][trainer.accelerators.base_accelerator][INFO] - Training progress: step=83650/100000 (83.65%), epoch=1, lr=1e-05, speed=1.960 step/s, elapsed=11:51:07, eta=02:18:59 +[2026-04-16 11:10:18,769][trainer.accelerators.base_accelerator][INFO] - Training progress: step=83700/100000 (83.70%), epoch=1, lr=1e-05, speed=1.961 step/s, elapsed=11:51:30, eta=02:18:33 +[2026-04-16 11:10:40,907][trainer.accelerators.base_accelerator][INFO] - Training progress: step=83750/100000 (83.75%), epoch=1, lr=1e-05, speed=1.961 step/s, elapsed=11:51:52, eta=02:18:07 +[2026-04-16 11:11:03,029][trainer.accelerators.base_accelerator][INFO] - Training progress: step=83800/100000 (83.80%), epoch=1, lr=1e-05, speed=1.961 step/s, elapsed=11:52:14, eta=02:17:41 +[2026-04-16 11:11:25,163][trainer.accelerators.base_accelerator][INFO] - Training progress: step=83850/100000 (83.85%), epoch=1, lr=1e-05, speed=1.961 step/s, elapsed=11:52:36, eta=02:17:15 +[2026-04-16 11:11:47,351][trainer.accelerators.base_accelerator][INFO] - Training progress: step=83900/100000 (83.90%), epoch=1, lr=1e-05, speed=1.961 step/s, elapsed=11:52:58, eta=02:16:49 +[2026-04-16 11:12:09,479][trainer.accelerators.base_accelerator][INFO] - Training progress: step=83950/100000 (83.95%), epoch=1, lr=1e-05, speed=1.961 step/s, elapsed=11:53:20, eta=02:16:22 +[2026-04-16 11:12:31,548][trainer.accelerators.base_accelerator][INFO] - Training progress: step=84000/100000 (84.00%), epoch=1, lr=1e-05, speed=1.962 step/s, elapsed=11:53:42, eta=02:15:56 +[2026-04-16 11:12:31,587][__main__][INFO] - ========== EVAL START (periodic@gstep=84000) ========== +[2026-04-16 11:12:31,587][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-16 11:12:31,587][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 11:12:47,112][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 15.342029571533203, 'accuracy': 0.548235294117647, 'num_samples': 425, 'test_unique_accuracy': 0.5393518518518519, 'test_unique_num_samples': 432} +[2026-04-16 11:12:47,112][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-16 11:12:47,112][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 11:13:02,273][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 15.342029571533203, 'accuracy': 0.548235294117647, 'num_samples': 425, 'test_unique_accuracy': 0.4837962962962963, 'test_unique_num_samples': 432} +[2026-04-16 11:13:02,273][__main__][INFO] - ========== EVAL END (periodic@gstep=84000) ========== +[2026-04-16 11:13:02,273][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 15.360003471374512, 'accuracy': 0.548235294117647, 'num_samples': 425, 'test_unique_accuracy': 0.4837962962962963, 'test_unique_num_samples': 432} +[2026-04-16 11:13:02,583][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.548235294117647 is not better than 0.5741176470588235 of logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep76000, skipping checkpoint +[2026-04-16 11:13:24,697][trainer.accelerators.base_accelerator][INFO] - Training progress: step=84050/100000 (84.05%), epoch=1, lr=1e-05, speed=1.960 step/s, elapsed=11:54:35, eta=02:15:36 +[2026-04-16 11:13:46,767][trainer.accelerators.base_accelerator][INFO] - Training progress: step=84100/100000 (84.10%), epoch=1, lr=1e-05, speed=1.960 step/s, elapsed=11:54:58, eta=02:15:10 +[2026-04-16 11:14:08,885][trainer.accelerators.base_accelerator][INFO] - Training progress: step=84150/100000 (84.15%), epoch=1, lr=1e-05, speed=1.961 step/s, elapsed=11:55:20, eta=02:14:44 +[2026-04-16 11:14:30,974][trainer.accelerators.base_accelerator][INFO] - Training progress: step=84200/100000 (84.20%), epoch=1, lr=1e-05, speed=1.961 step/s, elapsed=11:55:42, eta=02:14:18 +[2026-04-16 11:14:53,483][trainer.accelerators.base_accelerator][INFO] - Training progress: step=84250/100000 (84.25%), epoch=1, lr=1e-05, speed=1.961 step/s, elapsed=11:56:04, eta=02:13:51 +[2026-04-16 11:15:15,529][trainer.accelerators.base_accelerator][INFO] - Training progress: step=84300/100000 (84.30%), epoch=1, lr=1e-05, speed=1.961 step/s, elapsed=11:56:26, eta=02:13:25 +[2026-04-16 11:15:37,471][trainer.accelerators.base_accelerator][INFO] - Training progress: step=84350/100000 (84.35%), epoch=1, lr=1e-05, speed=1.961 step/s, elapsed=11:56:48, eta=02:12:59 +[2026-04-16 11:15:59,565][trainer.accelerators.base_accelerator][INFO] - Training progress: step=84400/100000 (84.40%), epoch=1, lr=1e-05, speed=1.961 step/s, elapsed=11:57:10, eta=02:12:33 +[2026-04-16 11:16:21,624][trainer.accelerators.base_accelerator][INFO] - Training progress: step=84450/100000 (84.45%), epoch=1, lr=1e-05, speed=1.962 step/s, elapsed=11:57:32, eta=02:12:07 +[2026-04-16 11:16:43,671][trainer.accelerators.base_accelerator][INFO] - Training progress: step=84500/100000 (84.50%), epoch=1, lr=1e-05, speed=1.962 step/s, elapsed=11:57:54, eta=02:11:41 +[2026-04-16 11:17:05,973][trainer.accelerators.base_accelerator][INFO] - Training progress: step=84550/100000 (84.55%), epoch=1, lr=1e-05, speed=1.962 step/s, elapsed=11:58:17, eta=02:11:15 +[2026-04-16 11:17:28,075][trainer.accelerators.base_accelerator][INFO] - Training progress: step=84600/100000 (84.60%), epoch=1, lr=1e-05, speed=1.962 step/s, elapsed=11:58:39, eta=02:10:49 +[2026-04-16 11:17:50,226][trainer.accelerators.base_accelerator][INFO] - Training progress: step=84650/100000 (84.65%), epoch=1, lr=1e-05, speed=1.962 step/s, elapsed=11:59:01, eta=02:10:23 +[2026-04-16 11:18:12,306][trainer.accelerators.base_accelerator][INFO] - Training progress: step=84700/100000 (84.70%), epoch=1, lr=1e-05, speed=1.962 step/s, elapsed=11:59:23, eta=02:09:56 +[2026-04-16 11:18:34,490][trainer.accelerators.base_accelerator][INFO] - Training progress: step=84750/100000 (84.75%), epoch=1, lr=1e-05, speed=1.962 step/s, elapsed=11:59:45, eta=02:09:30 +[2026-04-16 11:18:56,791][trainer.accelerators.base_accelerator][INFO] - Training progress: step=84800/100000 (84.80%), epoch=1, lr=1e-05, speed=1.963 step/s, elapsed=12:00:08, eta=02:09:04 +[2026-04-16 11:19:18,902][trainer.accelerators.base_accelerator][INFO] - Training progress: step=84850/100000 (84.85%), epoch=1, lr=1e-05, speed=1.963 step/s, elapsed=12:00:30, eta=02:08:38 +[2026-04-16 11:19:41,050][trainer.accelerators.base_accelerator][INFO] - Training progress: step=84900/100000 (84.90%), epoch=1, lr=1e-05, speed=1.963 step/s, elapsed=12:00:52, eta=02:08:12 +[2026-04-16 11:20:03,164][trainer.accelerators.base_accelerator][INFO] - Training progress: step=84950/100000 (84.95%), epoch=1, lr=1e-05, speed=1.963 step/s, elapsed=12:01:14, eta=02:07:46 +[2026-04-16 11:20:25,233][trainer.accelerators.base_accelerator][INFO] - Training progress: step=85000/100000 (85.00%), epoch=1, lr=1e-05, speed=1.963 step/s, elapsed=12:01:36, eta=02:07:20 +[2026-04-16 11:20:25,272][__main__][INFO] - ========== EVAL START (periodic@gstep=85000) ========== +[2026-04-16 11:20:25,273][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-16 11:20:25,273][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 11:20:40,805][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 15.360003471374512, 'accuracy': 0.5129411764705882, 'num_samples': 425, 'test_unique_accuracy': 0.4837962962962963, 'test_unique_num_samples': 432} +[2026-04-16 11:20:40,805][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-16 11:20:40,805][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 11:20:55,947][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 15.360003471374512, 'accuracy': 0.5129411764705882, 'num_samples': 425, 'test_unique_accuracy': 0.4930555555555556, 'test_unique_num_samples': 432} +[2026-04-16 11:20:55,947][__main__][INFO] - ========== EVAL END (periodic@gstep=85000) ========== +[2026-04-16 11:20:55,948][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 15.386859893798828, 'accuracy': 0.5129411764705882, 'num_samples': 425, 'test_unique_accuracy': 0.4930555555555556, 'test_unique_num_samples': 432} +[2026-04-16 11:20:55,988][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.5129411764705882 is not better than 0.5741176470588235 of logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep76000, skipping checkpoint +[2026-04-16 11:21:18,353][trainer.accelerators.base_accelerator][INFO] - Training progress: step=85050/100000 (85.05%), epoch=1, lr=1e-05, speed=1.962 step/s, elapsed=12:02:29, eta=02:06:59 +[2026-04-16 11:21:40,474][trainer.accelerators.base_accelerator][INFO] - Training progress: step=85100/100000 (85.10%), epoch=1, lr=1e-05, speed=1.962 step/s, elapsed=12:02:51, eta=02:06:33 +[2026-04-16 11:22:02,500][trainer.accelerators.base_accelerator][INFO] - Training progress: step=85150/100000 (85.15%), epoch=1, lr=1e-05, speed=1.962 step/s, elapsed=12:03:13, eta=02:06:07 +[2026-04-16 11:22:24,576][trainer.accelerators.base_accelerator][INFO] - Training progress: step=85200/100000 (85.20%), epoch=1, lr=1e-05, speed=1.962 step/s, elapsed=12:03:35, eta=02:05:41 +[2026-04-16 11:22:46,650][trainer.accelerators.base_accelerator][INFO] - Training progress: step=85250/100000 (85.25%), epoch=1, lr=1e-05, speed=1.963 step/s, elapsed=12:03:57, eta=02:05:15 +[2026-04-16 11:23:08,676][trainer.accelerators.base_accelerator][INFO] - Training progress: step=85300/100000 (85.30%), epoch=1, lr=1e-05, speed=1.963 step/s, elapsed=12:04:19, eta=02:04:49 +[2026-04-16 11:23:30,742][trainer.accelerators.base_accelerator][INFO] - Training progress: step=85350/100000 (85.35%), epoch=1, lr=1e-05, speed=1.963 step/s, elapsed=12:04:41, eta=02:04:23 +[2026-04-16 11:23:52,818][trainer.accelerators.base_accelerator][INFO] - Training progress: step=85400/100000 (85.40%), epoch=1, lr=1e-05, speed=1.963 step/s, elapsed=12:05:04, eta=02:03:57 +[2026-04-16 11:24:14,887][trainer.accelerators.base_accelerator][INFO] - Training progress: step=85450/100000 (85.45%), epoch=1, lr=1e-05, speed=1.963 step/s, elapsed=12:05:26, eta=02:03:31 +[2026-04-16 11:24:36,993][trainer.accelerators.base_accelerator][INFO] - Training progress: step=85500/100000 (85.50%), epoch=1, lr=1e-05, speed=1.963 step/s, elapsed=12:05:48, eta=02:03:05 +[2026-04-16 11:24:59,132][trainer.accelerators.base_accelerator][INFO] - Training progress: step=85550/100000 (85.55%), epoch=1, lr=1e-05, speed=1.963 step/s, elapsed=12:06:10, eta=02:02:39 +[2026-04-16 11:25:21,136][trainer.accelerators.base_accelerator][INFO] - Training progress: step=85600/100000 (85.60%), epoch=1, lr=1e-05, speed=1.964 step/s, elapsed=12:06:32, eta=02:02:13 +[2026-04-16 11:25:43,488][trainer.accelerators.base_accelerator][INFO] - Training progress: step=85650/100000 (85.65%), epoch=1, lr=1e-05, speed=1.964 step/s, elapsed=12:06:54, eta=02:01:47 +[2026-04-16 11:26:05,518][trainer.accelerators.base_accelerator][INFO] - Training progress: step=85700/100000 (85.70%), epoch=1, lr=1e-05, speed=1.964 step/s, elapsed=12:07:16, eta=02:01:21 +[2026-04-16 11:26:27,621][trainer.accelerators.base_accelerator][INFO] - Training progress: step=85750/100000 (85.75%), epoch=1, lr=1e-05, speed=1.964 step/s, elapsed=12:07:38, eta=02:00:55 +[2026-04-16 11:26:49,707][trainer.accelerators.base_accelerator][INFO] - Training progress: step=85800/100000 (85.80%), epoch=1, lr=1e-05, speed=1.964 step/s, elapsed=12:08:00, eta=02:00:29 +[2026-04-16 11:27:11,706][trainer.accelerators.base_accelerator][INFO] - Training progress: step=85850/100000 (85.85%), epoch=1, lr=1e-05, speed=1.964 step/s, elapsed=12:08:22, eta=02:00:03 +[2026-04-16 11:27:33,805][trainer.accelerators.base_accelerator][INFO] - Training progress: step=85900/100000 (85.90%), epoch=1, lr=1e-05, speed=1.965 step/s, elapsed=12:08:45, eta=01:59:37 +[2026-04-16 11:27:55,938][trainer.accelerators.base_accelerator][INFO] - Training progress: step=85950/100000 (85.95%), epoch=1, lr=1e-05, speed=1.965 step/s, elapsed=12:09:07, eta=01:59:11 +[2026-04-16 11:28:18,063][trainer.accelerators.base_accelerator][INFO] - Training progress: step=86000/100000 (86.00%), epoch=1, lr=1e-05, speed=1.965 step/s, elapsed=12:09:29, eta=01:58:45 +[2026-04-16 11:28:18,101][__main__][INFO] - ========== EVAL START (periodic@gstep=86000) ========== +[2026-04-16 11:28:18,102][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-16 11:28:18,102][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 11:28:41,538][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 15.386859893798828, 'accuracy': 0.5105882352941177, 'num_samples': 425, 'test_unique_accuracy': 0.4930555555555556, 'test_unique_num_samples': 432} +[2026-04-16 11:28:41,538][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-16 11:28:41,538][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 11:28:56,726][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 15.386859893798828, 'accuracy': 0.5105882352941177, 'num_samples': 425, 'test_unique_accuracy': 0.49074074074074076, 'test_unique_num_samples': 432} +[2026-04-16 11:28:56,727][__main__][INFO] - ========== EVAL END (periodic@gstep=86000) ========== +[2026-04-16 11:28:56,727][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 15.409412384033203, 'accuracy': 0.5105882352941177, 'num_samples': 425, 'test_unique_accuracy': 0.49074074074074076, 'test_unique_num_samples': 432} +[2026-04-16 11:28:56,730][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.5105882352941177 is not better than 0.5741176470588235 of logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep76000, skipping checkpoint +[2026-04-16 11:29:18,732][trainer.accelerators.base_accelerator][INFO] - Training progress: step=86050/100000 (86.05%), epoch=1, lr=1e-05, speed=1.963 step/s, elapsed=12:10:29, eta=01:58:25 +[2026-04-16 11:29:40,848][trainer.accelerators.base_accelerator][INFO] - Training progress: step=86100/100000 (86.10%), epoch=1, lr=1e-05, speed=1.963 step/s, elapsed=12:10:52, eta=01:57:59 +[2026-04-16 11:30:02,904][trainer.accelerators.base_accelerator][INFO] - Training progress: step=86150/100000 (86.15%), epoch=1, lr=1e-05, speed=1.964 step/s, elapsed=12:11:14, eta=01:57:33 +[2026-04-16 11:30:25,207][trainer.accelerators.base_accelerator][INFO] - Training progress: step=86200/100000 (86.20%), epoch=1, lr=1e-05, speed=1.964 step/s, elapsed=12:11:36, eta=01:57:07 +[2026-04-16 11:30:47,393][trainer.accelerators.base_accelerator][INFO] - Training progress: step=86250/100000 (86.25%), epoch=1, lr=1e-05, speed=1.964 step/s, elapsed=12:11:58, eta=01:56:41 +[2026-04-16 11:31:09,405][trainer.accelerators.base_accelerator][INFO] - Training progress: step=86300/100000 (86.30%), epoch=1, lr=1e-05, speed=1.964 step/s, elapsed=12:12:20, eta=01:56:15 +[2026-04-16 11:31:31,556][trainer.accelerators.base_accelerator][INFO] - Training progress: step=86350/100000 (86.35%), epoch=1, lr=1e-05, speed=1.964 step/s, elapsed=12:12:42, eta=01:55:49 +[2026-04-16 11:31:53,644][trainer.accelerators.base_accelerator][INFO] - Training progress: step=86400/100000 (86.40%), epoch=1, lr=1e-05, speed=1.964 step/s, elapsed=12:13:04, eta=01:55:23 +[2026-04-16 11:32:15,756][trainer.accelerators.base_accelerator][INFO] - Training progress: step=86450/100000 (86.45%), epoch=1, lr=1e-05, speed=1.964 step/s, elapsed=12:13:27, eta=01:54:57 +[2026-04-16 11:32:37,861][trainer.accelerators.base_accelerator][INFO] - Training progress: step=86500/100000 (86.50%), epoch=1, lr=1e-05, speed=1.965 step/s, elapsed=12:13:49, eta=01:54:31 +[2026-04-16 11:32:59,956][trainer.accelerators.base_accelerator][INFO] - Training progress: step=86550/100000 (86.55%), epoch=1, lr=1e-05, speed=1.965 step/s, elapsed=12:14:11, eta=01:54:05 +[2026-04-16 11:33:22,073][trainer.accelerators.base_accelerator][INFO] - Training progress: step=86600/100000 (86.60%), epoch=1, lr=1e-05, speed=1.965 step/s, elapsed=12:14:33, eta=01:53:39 +[2026-04-16 11:33:44,428][trainer.accelerators.base_accelerator][INFO] - Training progress: step=86650/100000 (86.65%), epoch=1, lr=1e-05, speed=1.965 step/s, elapsed=12:14:55, eta=01:53:13 +[2026-04-16 11:34:06,503][trainer.accelerators.base_accelerator][INFO] - Training progress: step=86700/100000 (86.70%), epoch=1, lr=1e-05, speed=1.965 step/s, elapsed=12:15:17, eta=01:52:47 +[2026-04-16 11:34:28,585][trainer.accelerators.base_accelerator][INFO] - Training progress: step=86750/100000 (86.75%), epoch=1, lr=1e-05, speed=1.965 step/s, elapsed=12:15:39, eta=01:52:21 +[2026-04-16 11:34:50,629][trainer.accelerators.base_accelerator][INFO] - Training progress: step=86800/100000 (86.80%), epoch=1, lr=1e-05, speed=1.965 step/s, elapsed=12:16:01, eta=01:51:55 +[2026-04-16 11:35:12,665][trainer.accelerators.base_accelerator][INFO] - Training progress: step=86850/100000 (86.85%), epoch=1, lr=1e-05, speed=1.966 step/s, elapsed=12:16:23, eta=01:51:29 +[2026-04-16 11:35:34,802][trainer.accelerators.base_accelerator][INFO] - Training progress: step=86900/100000 (86.90%), epoch=1, lr=1e-05, speed=1.966 step/s, elapsed=12:16:46, eta=01:51:03 +[2026-04-16 11:35:56,931][trainer.accelerators.base_accelerator][INFO] - Training progress: step=86950/100000 (86.95%), epoch=1, lr=1e-05, speed=1.966 step/s, elapsed=12:17:08, eta=01:50:38 +[2026-04-16 11:36:18,973][trainer.accelerators.base_accelerator][INFO] - Training progress: step=87000/100000 (87.00%), epoch=1, lr=1e-05, speed=1.966 step/s, elapsed=12:17:30, eta=01:50:12 +[2026-04-16 11:36:19,012][__main__][INFO] - ========== EVAL START (periodic@gstep=87000) ========== +[2026-04-16 11:36:19,012][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-16 11:36:19,012][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 11:36:34,291][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 15.409412384033203, 'accuracy': 0.4823529411764706, 'num_samples': 425, 'test_unique_accuracy': 0.49074074074074076, 'test_unique_num_samples': 432} +[2026-04-16 11:36:34,292][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-16 11:36:34,292][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 11:36:49,515][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 15.409412384033203, 'accuracy': 0.4823529411764706, 'num_samples': 425, 'test_unique_accuracy': 0.4861111111111111, 'test_unique_num_samples': 432} +[2026-04-16 11:36:49,515][__main__][INFO] - ========== EVAL END (periodic@gstep=87000) ========== +[2026-04-16 11:36:49,516][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 15.427369117736816, 'accuracy': 0.4823529411764706, 'num_samples': 425, 'test_unique_accuracy': 0.4861111111111111, 'test_unique_num_samples': 432} +[2026-04-16 11:36:49,518][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.4823529411764706 is not better than 0.5741176470588235 of logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep76000, skipping checkpoint +[2026-04-16 11:37:11,894][trainer.accelerators.base_accelerator][INFO] - Training progress: step=87050/100000 (87.05%), epoch=1, lr=1e-05, speed=1.965 step/s, elapsed=12:18:23, eta=01:49:50 +[2026-04-16 11:37:33,972][trainer.accelerators.base_accelerator][INFO] - Training progress: step=87100/100000 (87.10%), epoch=1, lr=1e-05, speed=1.965 step/s, elapsed=12:18:45, eta=01:49:24 +[2026-04-16 11:37:56,092][trainer.accelerators.base_accelerator][INFO] - Training progress: step=87150/100000 (87.15%), epoch=1, lr=1e-05, speed=1.965 step/s, elapsed=12:19:07, eta=01:48:58 +[2026-04-16 11:38:18,265][trainer.accelerators.base_accelerator][INFO] - Training progress: step=87200/100000 (87.20%), epoch=1, lr=1e-05, speed=1.965 step/s, elapsed=12:19:29, eta=01:48:32 +[2026-04-16 11:38:40,465][trainer.accelerators.base_accelerator][INFO] - Training progress: step=87250/100000 (87.25%), epoch=1, lr=1e-05, speed=1.965 step/s, elapsed=12:19:51, eta=01:48:07 +[2026-04-16 11:39:02,920][trainer.accelerators.base_accelerator][INFO] - Training progress: step=87300/100000 (87.30%), epoch=1, lr=1e-05, speed=1.966 step/s, elapsed=12:20:14, eta=01:47:41 +[2026-04-16 11:39:25,030][trainer.accelerators.base_accelerator][INFO] - Training progress: step=87350/100000 (87.35%), epoch=1, lr=1e-05, speed=1.966 step/s, elapsed=12:20:36, eta=01:47:15 +[2026-04-16 11:39:47,190][trainer.accelerators.base_accelerator][INFO] - Training progress: step=87400/100000 (87.40%), epoch=1, lr=1e-05, speed=1.966 step/s, elapsed=12:20:58, eta=01:46:49 +[2026-04-16 11:40:09,267][trainer.accelerators.base_accelerator][INFO] - Training progress: step=87450/100000 (87.45%), epoch=1, lr=1e-05, speed=1.966 step/s, elapsed=12:21:20, eta=01:46:23 +[2026-04-16 11:40:31,392][trainer.accelerators.base_accelerator][INFO] - Training progress: step=87500/100000 (87.50%), epoch=1, lr=1e-05, speed=1.966 step/s, elapsed=12:21:42, eta=01:45:57 +[2026-04-16 11:40:53,813][trainer.accelerators.base_accelerator][INFO] - Training progress: step=87550/100000 (87.55%), epoch=1, lr=1e-05, speed=1.966 step/s, elapsed=12:22:05, eta=01:45:31 +[2026-04-16 11:41:15,887][trainer.accelerators.base_accelerator][INFO] - Training progress: step=87600/100000 (87.60%), epoch=1, lr=1e-05, speed=1.966 step/s, elapsed=12:22:27, eta=01:45:05 +[2026-04-16 11:41:38,014][trainer.accelerators.base_accelerator][INFO] - Training progress: step=87650/100000 (87.65%), epoch=1, lr=1e-05, speed=1.967 step/s, elapsed=12:22:49, eta=01:44:39 +[2026-04-16 11:42:00,187][trainer.accelerators.base_accelerator][INFO] - Training progress: step=87700/100000 (87.70%), epoch=1, lr=1e-05, speed=1.967 step/s, elapsed=12:23:11, eta=01:44:13 +[2026-04-16 11:42:22,618][trainer.accelerators.base_accelerator][INFO] - Training progress: step=87750/100000 (87.75%), epoch=1, lr=1e-05, speed=1.967 step/s, elapsed=12:23:33, eta=01:43:48 +[2026-04-16 11:42:44,767][trainer.accelerators.base_accelerator][INFO] - Training progress: step=87800/100000 (87.80%), epoch=1, lr=1e-05, speed=1.967 step/s, elapsed=12:23:56, eta=01:43:22 +[2026-04-16 11:43:06,870][trainer.accelerators.base_accelerator][INFO] - Training progress: step=87850/100000 (87.85%), epoch=1, lr=1e-05, speed=1.967 step/s, elapsed=12:24:18, eta=01:42:56 +[2026-04-16 11:43:28,953][trainer.accelerators.base_accelerator][INFO] - Training progress: step=87900/100000 (87.90%), epoch=1, lr=1e-05, speed=1.967 step/s, elapsed=12:24:40, eta=01:42:30 +[2026-04-16 11:43:51,066][trainer.accelerators.base_accelerator][INFO] - Training progress: step=87950/100000 (87.95%), epoch=1, lr=1e-05, speed=1.967 step/s, elapsed=12:25:02, eta=01:42:04 +[2026-04-16 11:44:13,539][trainer.accelerators.base_accelerator][INFO] - Training progress: step=88000/100000 (88.00%), epoch=1, lr=1e-05, speed=1.968 step/s, elapsed=12:25:24, eta=01:41:38 +[2026-04-16 11:44:13,579][__main__][INFO] - ========== EVAL START (periodic@gstep=88000) ========== +[2026-04-16 11:44:13,579][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-16 11:44:13,579][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 11:44:28,789][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 15.427369117736816, 'accuracy': 0.5294117647058824, 'num_samples': 425, 'test_unique_accuracy': 0.4861111111111111, 'test_unique_num_samples': 432} +[2026-04-16 11:44:28,790][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-16 11:44:28,790][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 11:44:43,945][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 15.427369117736816, 'accuracy': 0.5294117647058824, 'num_samples': 425, 'test_unique_accuracy': 0.4976851851851852, 'test_unique_num_samples': 432} +[2026-04-16 11:44:43,945][__main__][INFO] - ========== EVAL END (periodic@gstep=88000) ========== +[2026-04-16 11:44:43,945][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 15.451030731201172, 'accuracy': 0.5294117647058824, 'num_samples': 425, 'test_unique_accuracy': 0.4976851851851852, 'test_unique_num_samples': 432} +[2026-04-16 11:44:43,963][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.5294117647058824 is not better than 0.5741176470588235 of logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep76000, skipping checkpoint +[2026-04-16 11:45:06,059][trainer.accelerators.base_accelerator][INFO] - Training progress: step=88050/100000 (88.05%), epoch=1, lr=1e-05, speed=1.966 step/s, elapsed=12:26:17, eta=01:41:17 +[2026-04-16 11:45:28,075][trainer.accelerators.base_accelerator][INFO] - Training progress: step=88100/100000 (88.10%), epoch=1, lr=1e-05, speed=1.967 step/s, elapsed=12:26:39, eta=01:40:51 +[2026-04-16 11:45:50,137][trainer.accelerators.base_accelerator][INFO] - Training progress: step=88150/100000 (88.15%), epoch=1, lr=1e-05, speed=1.967 step/s, elapsed=12:27:01, eta=01:40:25 +[2026-04-16 11:46:12,227][trainer.accelerators.base_accelerator][INFO] - Training progress: step=88200/100000 (88.20%), epoch=1, lr=1e-05, speed=1.967 step/s, elapsed=12:27:23, eta=01:39:59 +[2026-04-16 11:46:34,320][trainer.accelerators.base_accelerator][INFO] - Training progress: step=88250/100000 (88.25%), epoch=1, lr=1e-05, speed=1.967 step/s, elapsed=12:27:45, eta=01:39:33 +[2026-04-16 11:46:56,488][trainer.accelerators.base_accelerator][INFO] - Training progress: step=88300/100000 (88.30%), epoch=1, lr=1e-05, speed=1.967 step/s, elapsed=12:28:07, eta=01:39:07 +[2026-04-16 11:47:18,637][trainer.accelerators.base_accelerator][INFO] - Training progress: step=88350/100000 (88.35%), epoch=1, lr=1e-05, speed=1.967 step/s, elapsed=12:28:29, eta=01:38:41 +[2026-04-16 11:47:40,636][trainer.accelerators.base_accelerator][INFO] - Training progress: step=88400/100000 (88.40%), epoch=1, lr=1e-05, speed=1.967 step/s, elapsed=12:28:51, eta=01:38:16 +[2026-04-16 11:48:02,792][trainer.accelerators.base_accelerator][INFO] - Training progress: step=88450/100000 (88.45%), epoch=1, lr=1e-05, speed=1.968 step/s, elapsed=12:29:14, eta=01:37:50 +[2026-04-16 11:48:24,855][trainer.accelerators.base_accelerator][INFO] - Training progress: step=88500/100000 (88.50%), epoch=1, lr=1e-05, speed=1.968 step/s, elapsed=12:29:36, eta=01:37:24 +[2026-04-16 11:48:42,305][trainer.accelerators.base_accelerator][INFO] - Epoch 1 finished +[2026-04-16 11:48:48,676][trainer.accelerators.base_accelerator][INFO] - Training progress: step=88550/100000 (88.55%), epoch=2, lr=1e-05, speed=1.968 step/s, elapsed=12:29:59, eta=01:36:58 +[2026-04-16 11:49:10,837][trainer.accelerators.base_accelerator][INFO] - Training progress: step=88600/100000 (88.60%), epoch=2, lr=1e-05, speed=1.968 step/s, elapsed=12:30:22, eta=01:36:32 +[2026-04-16 11:49:32,858][trainer.accelerators.base_accelerator][INFO] - Training progress: step=88650/100000 (88.65%), epoch=2, lr=1e-05, speed=1.968 step/s, elapsed=12:30:44, eta=01:36:07 +[2026-04-16 11:49:54,968][trainer.accelerators.base_accelerator][INFO] - Training progress: step=88700/100000 (88.70%), epoch=2, lr=1e-05, speed=1.968 step/s, elapsed=12:31:06, eta=01:35:41 +[2026-04-16 11:50:17,039][trainer.accelerators.base_accelerator][INFO] - Training progress: step=88750/100000 (88.75%), epoch=2, lr=1e-05, speed=1.968 step/s, elapsed=12:31:28, eta=01:35:15 +[2026-04-16 11:50:39,178][trainer.accelerators.base_accelerator][INFO] - Training progress: step=88800/100000 (88.80%), epoch=2, lr=1e-05, speed=1.969 step/s, elapsed=12:31:50, eta=01:34:49 +[2026-04-16 11:51:01,341][trainer.accelerators.base_accelerator][INFO] - Training progress: step=88850/100000 (88.85%), epoch=2, lr=1e-05, speed=1.969 step/s, elapsed=12:32:12, eta=01:34:23 +[2026-04-16 11:51:23,537][trainer.accelerators.base_accelerator][INFO] - Training progress: step=88900/100000 (88.90%), epoch=2, lr=1e-05, speed=1.969 step/s, elapsed=12:32:34, eta=01:33:57 +[2026-04-16 11:51:45,662][trainer.accelerators.base_accelerator][INFO] - Training progress: step=88950/100000 (88.95%), epoch=2, lr=1e-05, speed=1.969 step/s, elapsed=12:32:56, eta=01:33:32 +[2026-04-16 11:52:07,839][trainer.accelerators.base_accelerator][INFO] - Training progress: step=89000/100000 (89.00%), epoch=2, lr=1e-05, speed=1.969 step/s, elapsed=12:33:19, eta=01:33:06 +[2026-04-16 11:52:07,878][__main__][INFO] - ========== EVAL START (periodic@gstep=89000) ========== +[2026-04-16 11:52:07,879][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-16 11:52:07,879][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 11:52:22,969][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 15.451030731201172, 'accuracy': 0.5152941176470588, 'num_samples': 425, 'test_unique_accuracy': 0.4976851851851852, 'test_unique_num_samples': 432} +[2026-04-16 11:52:22,970][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-16 11:52:22,970][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 11:52:38,104][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 15.451030731201172, 'accuracy': 0.5152941176470588, 'num_samples': 425, 'test_unique_accuracy': 0.5277777777777778, 'test_unique_num_samples': 432} +[2026-04-16 11:52:38,104][__main__][INFO] - ========== EVAL END (periodic@gstep=89000) ========== +[2026-04-16 11:52:38,104][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 15.487062454223633, 'accuracy': 0.5152941176470588, 'num_samples': 425, 'test_unique_accuracy': 0.5277777777777778, 'test_unique_num_samples': 432} +[2026-04-16 11:52:38,122][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.5152941176470588 is not better than 0.5741176470588235 of logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep76000, skipping checkpoint +[2026-04-16 11:53:00,290][trainer.accelerators.base_accelerator][INFO] - Training progress: step=89050/100000 (89.05%), epoch=2, lr=1e-05, speed=1.968 step/s, elapsed=12:34:11, eta=01:32:44 +[2026-04-16 11:53:22,719][trainer.accelerators.base_accelerator][INFO] - Training progress: step=89100/100000 (89.10%), epoch=2, lr=1e-05, speed=1.968 step/s, elapsed=12:34:33, eta=01:32:18 +[2026-04-16 11:53:44,801][trainer.accelerators.base_accelerator][INFO] - Training progress: step=89150/100000 (89.15%), epoch=2, lr=1e-05, speed=1.968 step/s, elapsed=12:34:56, eta=01:31:52 +[2026-04-16 11:54:06,993][trainer.accelerators.base_accelerator][INFO] - Training progress: step=89200/100000 (89.20%), epoch=2, lr=1e-05, speed=1.968 step/s, elapsed=12:35:18, eta=01:31:26 +[2026-04-16 11:54:29,150][trainer.accelerators.base_accelerator][INFO] - Training progress: step=89250/100000 (89.25%), epoch=2, lr=1e-05, speed=1.968 step/s, elapsed=12:35:40, eta=01:31:01 +[2026-04-16 11:54:51,267][trainer.accelerators.base_accelerator][INFO] - Training progress: step=89300/100000 (89.30%), epoch=2, lr=1e-05, speed=1.969 step/s, elapsed=12:36:02, eta=01:30:35 +[2026-04-16 11:55:13,344][trainer.accelerators.base_accelerator][INFO] - Training progress: step=89350/100000 (89.35%), epoch=2, lr=1e-05, speed=1.969 step/s, elapsed=12:36:24, eta=01:30:09 +[2026-04-16 11:55:35,491][trainer.accelerators.base_accelerator][INFO] - Training progress: step=89400/100000 (89.40%), epoch=2, lr=1e-05, speed=1.969 step/s, elapsed=12:36:46, eta=01:29:43 +[2026-04-16 11:55:57,648][trainer.accelerators.base_accelerator][INFO] - Training progress: step=89450/100000 (89.45%), epoch=2, lr=1e-05, speed=1.969 step/s, elapsed=12:37:08, eta=01:29:18 +[2026-04-16 11:56:19,742][trainer.accelerators.base_accelerator][INFO] - Training progress: step=89500/100000 (89.50%), epoch=2, lr=1e-05, speed=1.969 step/s, elapsed=12:37:30, eta=01:28:52 +[2026-04-16 11:56:41,862][trainer.accelerators.base_accelerator][INFO] - Training progress: step=89550/100000 (89.55%), epoch=2, lr=1e-05, speed=1.969 step/s, elapsed=12:37:53, eta=01:28:26 +[2026-04-16 11:57:04,144][trainer.accelerators.base_accelerator][INFO] - Training progress: step=89600/100000 (89.60%), epoch=2, lr=1e-05, speed=1.969 step/s, elapsed=12:38:15, eta=01:28:00 +[2026-04-16 11:57:26,295][trainer.accelerators.base_accelerator][INFO] - Training progress: step=89650/100000 (89.65%), epoch=2, lr=1e-05, speed=1.970 step/s, elapsed=12:38:37, eta=01:27:34 +[2026-04-16 11:57:48,392][trainer.accelerators.base_accelerator][INFO] - Training progress: step=89700/100000 (89.70%), epoch=2, lr=1e-05, speed=1.970 step/s, elapsed=12:38:59, eta=01:27:09 +[2026-04-16 11:58:10,501][trainer.accelerators.base_accelerator][INFO] - Training progress: step=89750/100000 (89.75%), epoch=2, lr=1e-05, speed=1.970 step/s, elapsed=12:39:21, eta=01:26:43 +[2026-04-16 11:58:32,558][trainer.accelerators.base_accelerator][INFO] - Training progress: step=89800/100000 (89.80%), epoch=2, lr=1e-05, speed=1.970 step/s, elapsed=12:39:43, eta=01:26:17 +[2026-04-16 11:58:54,656][trainer.accelerators.base_accelerator][INFO] - Training progress: step=89850/100000 (89.85%), epoch=2, lr=1e-05, speed=1.970 step/s, elapsed=12:40:05, eta=01:25:51 +[2026-04-16 11:59:16,769][trainer.accelerators.base_accelerator][INFO] - Training progress: step=89900/100000 (89.90%), epoch=2, lr=1e-05, speed=1.970 step/s, elapsed=12:40:28, eta=01:25:26 +[2026-04-16 11:59:38,914][trainer.accelerators.base_accelerator][INFO] - Training progress: step=89950/100000 (89.95%), epoch=2, lr=1e-05, speed=1.970 step/s, elapsed=12:40:50, eta=01:25:00 +[2026-04-16 12:00:00,968][trainer.accelerators.base_accelerator][INFO] - Training progress: step=90000/100000 (90.00%), epoch=2, lr=1e-05, speed=1.971 step/s, elapsed=12:41:12, eta=01:24:34 +[2026-04-16 12:00:01,007][__main__][INFO] - ========== EVAL START (periodic@gstep=90000) ========== +[2026-04-16 12:00:01,008][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-16 12:00:01,008][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 12:00:22,684][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 15.487062454223633, 'accuracy': 0.48470588235294115, 'num_samples': 425, 'test_unique_accuracy': 0.5277777777777778, 'test_unique_num_samples': 432} +[2026-04-16 12:00:22,685][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-16 12:00:22,685][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 12:00:37,914][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 15.487062454223633, 'accuracy': 0.48470588235294115, 'num_samples': 425, 'test_unique_accuracy': 0.4699074074074074, 'test_unique_num_samples': 432} +[2026-04-16 12:00:37,914][__main__][INFO] - ========== EVAL END (periodic@gstep=90000) ========== +[2026-04-16 12:00:37,914][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 15.532841682434082, 'accuracy': 0.48470588235294115, 'num_samples': 425, 'test_unique_accuracy': 0.4699074074074074, 'test_unique_num_samples': 432} +[2026-04-16 12:00:37,918][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.48470588235294115 is not better than 0.5741176470588235 of logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep76000, skipping checkpoint +[2026-04-16 12:01:00,239][trainer.accelerators.base_accelerator][INFO] - Training progress: step=90050/100000 (90.05%), epoch=2, lr=1e-05, speed=1.969 step/s, elapsed=12:42:11, eta=01:24:13 +[2026-04-16 12:01:22,409][trainer.accelerators.base_accelerator][INFO] - Training progress: step=90100/100000 (90.10%), epoch=2, lr=1e-05, speed=1.969 step/s, elapsed=12:42:33, eta=01:23:47 +[2026-04-16 12:01:44,709][trainer.accelerators.base_accelerator][INFO] - Training progress: step=90150/100000 (90.15%), epoch=2, lr=1e-05, speed=1.969 step/s, elapsed=12:42:55, eta=01:23:21 +[2026-04-16 12:02:06,571][trainer.accelerators.base_accelerator][INFO] - Training progress: step=90200/100000 (90.20%), epoch=2, lr=1e-05, speed=1.970 step/s, elapsed=12:43:17, eta=01:22:55 +[2026-04-16 12:02:28,808][trainer.accelerators.base_accelerator][INFO] - Training progress: step=90250/100000 (90.25%), epoch=2, lr=1e-05, speed=1.970 step/s, elapsed=12:43:40, eta=01:22:30 +[2026-04-16 12:02:50,934][trainer.accelerators.base_accelerator][INFO] - Training progress: step=90300/100000 (90.30%), epoch=2, lr=1e-05, speed=1.970 step/s, elapsed=12:44:02, eta=01:22:04 +[2026-04-16 12:03:13,033][trainer.accelerators.base_accelerator][INFO] - Training progress: step=90350/100000 (90.35%), epoch=2, lr=1e-05, speed=1.970 step/s, elapsed=12:44:24, eta=01:21:38 +[2026-04-16 12:03:35,210][trainer.accelerators.base_accelerator][INFO] - Training progress: step=90400/100000 (90.40%), epoch=2, lr=1e-05, speed=1.970 step/s, elapsed=12:44:46, eta=01:21:12 +[2026-04-16 12:03:57,413][trainer.accelerators.base_accelerator][INFO] - Training progress: step=90450/100000 (90.45%), epoch=2, lr=1e-05, speed=1.970 step/s, elapsed=12:45:08, eta=01:20:47 +[2026-04-16 12:04:19,506][trainer.accelerators.base_accelerator][INFO] - Training progress: step=90500/100000 (90.50%), epoch=2, lr=1e-05, speed=1.970 step/s, elapsed=12:45:30, eta=01:20:21 +[2026-04-16 12:04:41,455][trainer.accelerators.base_accelerator][INFO] - Training progress: step=90550/100000 (90.55%), epoch=2, lr=1e-05, speed=1.971 step/s, elapsed=12:45:52, eta=01:19:55 +[2026-04-16 12:05:03,618][trainer.accelerators.base_accelerator][INFO] - Training progress: step=90600/100000 (90.60%), epoch=2, lr=1e-05, speed=1.971 step/s, elapsed=12:46:14, eta=01:19:30 +[2026-04-16 12:05:26,066][trainer.accelerators.base_accelerator][INFO] - Training progress: step=90650/100000 (90.65%), epoch=2, lr=1e-05, speed=1.971 step/s, elapsed=12:46:37, eta=01:19:04 +[2026-04-16 12:05:48,188][trainer.accelerators.base_accelerator][INFO] - Training progress: step=90700/100000 (90.70%), epoch=2, lr=1e-05, speed=1.971 step/s, elapsed=12:46:59, eta=01:18:38 +[2026-04-16 12:06:10,235][trainer.accelerators.base_accelerator][INFO] - Training progress: step=90750/100000 (90.75%), epoch=2, lr=1e-05, speed=1.971 step/s, elapsed=12:47:21, eta=01:18:12 +[2026-04-16 12:06:32,394][trainer.accelerators.base_accelerator][INFO] - Training progress: step=90800/100000 (90.80%), epoch=2, lr=1e-05, speed=1.971 step/s, elapsed=12:47:43, eta=01:17:47 +[2026-04-16 12:06:54,557][trainer.accelerators.base_accelerator][INFO] - Training progress: step=90850/100000 (90.85%), epoch=2, lr=1e-05, speed=1.971 step/s, elapsed=12:48:05, eta=01:17:21 +[2026-04-16 12:07:16,712][trainer.accelerators.base_accelerator][INFO] - Training progress: step=90900/100000 (90.90%), epoch=2, lr=1e-05, speed=1.971 step/s, elapsed=12:48:27, eta=01:16:55 +[2026-04-16 12:07:38,727][trainer.accelerators.base_accelerator][INFO] - Training progress: step=90950/100000 (90.95%), epoch=2, lr=1e-05, speed=1.972 step/s, elapsed=12:48:49, eta=01:16:30 +[2026-04-16 12:08:00,825][trainer.accelerators.base_accelerator][INFO] - Training progress: step=91000/100000 (91.00%), epoch=2, lr=1e-05, speed=1.972 step/s, elapsed=12:49:12, eta=01:16:04 +[2026-04-16 12:08:00,864][__main__][INFO] - ========== EVAL START (periodic@gstep=91000) ========== +[2026-04-16 12:08:00,864][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-16 12:08:00,865][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 12:08:16,050][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 15.532841682434082, 'accuracy': 0.5152941176470588, 'num_samples': 425, 'test_unique_accuracy': 0.4699074074074074, 'test_unique_num_samples': 432} +[2026-04-16 12:08:16,051][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-16 12:08:16,051][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 12:08:31,240][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 15.532841682434082, 'accuracy': 0.5152941176470588, 'num_samples': 425, 'test_unique_accuracy': 0.49537037037037035, 'test_unique_num_samples': 432} +[2026-04-16 12:08:31,240][__main__][INFO] - ========== EVAL END (periodic@gstep=91000) ========== +[2026-04-16 12:08:31,240][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 15.573884963989258, 'accuracy': 0.5152941176470588, 'num_samples': 425, 'test_unique_accuracy': 0.49537037037037035, 'test_unique_num_samples': 432} +[2026-04-16 12:08:31,244][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.5152941176470588 is not better than 0.5741176470588235 of logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep76000, skipping checkpoint +[2026-04-16 12:08:53,376][trainer.accelerators.base_accelerator][INFO] - Training progress: step=91050/100000 (91.05%), epoch=2, lr=1e-05, speed=1.971 step/s, elapsed=12:50:04, eta=01:15:41 +[2026-04-16 12:09:15,474][trainer.accelerators.base_accelerator][INFO] - Training progress: step=91100/100000 (91.10%), epoch=2, lr=1e-05, speed=1.971 step/s, elapsed=12:50:26, eta=01:15:16 +[2026-04-16 12:09:37,657][trainer.accelerators.base_accelerator][INFO] - Training progress: step=91150/100000 (91.15%), epoch=2, lr=1e-05, speed=1.971 step/s, elapsed=12:50:48, eta=01:14:50 +[2026-04-16 12:10:00,049][trainer.accelerators.base_accelerator][INFO] - Training progress: step=91200/100000 (91.20%), epoch=2, lr=1e-05, speed=1.971 step/s, elapsed=12:51:11, eta=01:14:24 +[2026-04-16 12:10:22,176][trainer.accelerators.base_accelerator][INFO] - Training progress: step=91250/100000 (91.25%), epoch=2, lr=1e-05, speed=1.971 step/s, elapsed=12:51:33, eta=01:13:59 +[2026-04-16 12:10:44,298][trainer.accelerators.base_accelerator][INFO] - Training progress: step=91300/100000 (91.30%), epoch=2, lr=1e-05, speed=1.971 step/s, elapsed=12:51:55, eta=01:13:33 +[2026-04-16 12:11:06,262][trainer.accelerators.base_accelerator][INFO] - Training progress: step=91350/100000 (91.35%), epoch=2, lr=1e-05, speed=1.971 step/s, elapsed=12:52:17, eta=01:13:07 +[2026-04-16 12:11:28,376][trainer.accelerators.base_accelerator][INFO] - Training progress: step=91400/100000 (91.40%), epoch=2, lr=1e-05, speed=1.972 step/s, elapsed=12:52:39, eta=01:12:42 +[2026-04-16 12:11:50,478][trainer.accelerators.base_accelerator][INFO] - Training progress: step=91450/100000 (91.45%), epoch=2, lr=1e-05, speed=1.972 step/s, elapsed=12:53:01, eta=01:12:16 +[2026-04-16 12:12:12,567][trainer.accelerators.base_accelerator][INFO] - Training progress: step=91500/100000 (91.50%), epoch=2, lr=1e-05, speed=1.972 step/s, elapsed=12:53:23, eta=01:11:50 +[2026-04-16 12:12:34,659][trainer.accelerators.base_accelerator][INFO] - Training progress: step=91550/100000 (91.55%), epoch=2, lr=1e-05, speed=1.972 step/s, elapsed=12:53:45, eta=01:11:25 +[2026-04-16 12:12:56,694][trainer.accelerators.base_accelerator][INFO] - Training progress: step=91600/100000 (91.60%), epoch=2, lr=1e-05, speed=1.972 step/s, elapsed=12:54:07, eta=01:10:59 +[2026-04-16 12:13:19,074][trainer.accelerators.base_accelerator][INFO] - Training progress: step=91650/100000 (91.65%), epoch=2, lr=1e-05, speed=1.972 step/s, elapsed=12:54:30, eta=01:10:33 +[2026-04-16 12:13:41,123][trainer.accelerators.base_accelerator][INFO] - Training progress: step=91700/100000 (91.70%), epoch=2, lr=1e-05, speed=1.972 step/s, elapsed=12:54:52, eta=01:10:08 +[2026-04-16 12:14:03,091][trainer.accelerators.base_accelerator][INFO] - Training progress: step=91750/100000 (91.75%), epoch=2, lr=1e-05, speed=1.973 step/s, elapsed=12:55:14, eta=01:09:42 +[2026-04-16 12:14:25,181][trainer.accelerators.base_accelerator][INFO] - Training progress: step=91800/100000 (91.80%), epoch=2, lr=1e-05, speed=1.973 step/s, elapsed=12:55:36, eta=01:09:16 +[2026-04-16 12:14:47,264][trainer.accelerators.base_accelerator][INFO] - Training progress: step=91850/100000 (91.85%), epoch=2, lr=1e-05, speed=1.973 step/s, elapsed=12:55:58, eta=01:08:51 +[2026-04-16 12:15:09,408][trainer.accelerators.base_accelerator][INFO] - Training progress: step=91900/100000 (91.90%), epoch=2, lr=1e-05, speed=1.973 step/s, elapsed=12:56:20, eta=01:08:25 +[2026-04-16 12:15:31,493][trainer.accelerators.base_accelerator][INFO] - Training progress: step=91950/100000 (91.95%), epoch=2, lr=1e-05, speed=1.973 step/s, elapsed=12:56:42, eta=01:07:59 +[2026-04-16 12:15:53,578][trainer.accelerators.base_accelerator][INFO] - Training progress: step=92000/100000 (92.00%), epoch=2, lr=1e-05, speed=1.973 step/s, elapsed=12:57:04, eta=01:07:34 +[2026-04-16 12:15:53,619][__main__][INFO] - ========== EVAL START (periodic@gstep=92000) ========== +[2026-04-16 12:15:53,619][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-16 12:15:53,619][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 12:16:08,784][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 15.573884963989258, 'accuracy': 0.49411764705882355, 'num_samples': 425, 'test_unique_accuracy': 0.49537037037037035, 'test_unique_num_samples': 432} +[2026-04-16 12:16:08,784][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-16 12:16:08,784][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 12:16:23,958][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 15.573884963989258, 'accuracy': 0.49411764705882355, 'num_samples': 425, 'test_unique_accuracy': 0.4976851851851852, 'test_unique_num_samples': 432} +[2026-04-16 12:16:23,958][__main__][INFO] - ========== EVAL END (periodic@gstep=92000) ========== +[2026-04-16 12:16:23,958][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 15.61843204498291, 'accuracy': 0.49411764705882355, 'num_samples': 425, 'test_unique_accuracy': 0.4976851851851852, 'test_unique_num_samples': 432} +[2026-04-16 12:16:23,993][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.49411764705882355 is not better than 0.5741176470588235 of logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep76000, skipping checkpoint +[2026-04-16 12:16:46,175][trainer.accelerators.base_accelerator][INFO] - Training progress: step=92050/100000 (92.05%), epoch=2, lr=1e-05, speed=1.972 step/s, elapsed=12:57:57, eta=01:07:11 +[2026-04-16 12:17:08,663][trainer.accelerators.base_accelerator][INFO] - Training progress: step=92100/100000 (92.10%), epoch=2, lr=1e-05, speed=1.972 step/s, elapsed=12:58:19, eta=01:06:45 +[2026-04-16 12:17:30,795][trainer.accelerators.base_accelerator][INFO] - Training progress: step=92150/100000 (92.15%), epoch=2, lr=1e-05, speed=1.972 step/s, elapsed=12:58:42, eta=01:06:20 +[2026-04-16 12:17:52,715][trainer.accelerators.base_accelerator][INFO] - Training progress: step=92200/100000 (92.20%), epoch=2, lr=1e-05, speed=1.972 step/s, elapsed=12:59:03, eta=01:05:54 +[2026-04-16 12:18:14,747][trainer.accelerators.base_accelerator][INFO] - Training progress: step=92250/100000 (92.25%), epoch=2, lr=1e-05, speed=1.973 step/s, elapsed=12:59:25, eta=01:05:28 +[2026-04-16 12:18:36,852][trainer.accelerators.base_accelerator][INFO] - Training progress: step=92300/100000 (92.30%), epoch=2, lr=1e-05, speed=1.973 step/s, elapsed=12:59:48, eta=01:05:03 +[2026-04-16 12:18:58,890][trainer.accelerators.base_accelerator][INFO] - Training progress: step=92350/100000 (92.35%), epoch=2, lr=1e-05, speed=1.973 step/s, elapsed=13:00:10, eta=01:04:37 +[2026-04-16 12:19:21,042][trainer.accelerators.base_accelerator][INFO] - Training progress: step=92400/100000 (92.40%), epoch=2, lr=1e-05, speed=1.973 step/s, elapsed=13:00:32, eta=01:04:12 +[2026-04-16 12:19:43,163][trainer.accelerators.base_accelerator][INFO] - Training progress: step=92450/100000 (92.45%), epoch=2, lr=1e-05, speed=1.973 step/s, elapsed=13:00:54, eta=01:03:46 +[2026-04-16 12:20:05,257][trainer.accelerators.base_accelerator][INFO] - Training progress: step=92500/100000 (92.50%), epoch=2, lr=1e-05, speed=1.973 step/s, elapsed=13:01:16, eta=01:03:20 +[2026-04-16 12:20:27,358][trainer.accelerators.base_accelerator][INFO] - Training progress: step=92550/100000 (92.55%), epoch=2, lr=1e-05, speed=1.973 step/s, elapsed=13:01:38, eta=01:02:55 +[2026-04-16 12:20:49,540][trainer.accelerators.base_accelerator][INFO] - Training progress: step=92600/100000 (92.60%), epoch=2, lr=1e-05, speed=1.974 step/s, elapsed=13:02:00, eta=01:02:29 +[2026-04-16 12:21:11,682][trainer.accelerators.base_accelerator][INFO] - Training progress: step=92650/100000 (92.65%), epoch=2, lr=1e-05, speed=1.974 step/s, elapsed=13:02:22, eta=01:02:04 +[2026-04-16 12:21:33,844][trainer.accelerators.base_accelerator][INFO] - Training progress: step=92700/100000 (92.70%), epoch=2, lr=1e-05, speed=1.974 step/s, elapsed=13:02:45, eta=01:01:38 +[2026-04-16 12:21:56,126][trainer.accelerators.base_accelerator][INFO] - Training progress: step=92750/100000 (92.75%), epoch=2, lr=1e-05, speed=1.974 step/s, elapsed=13:03:07, eta=01:01:12 +[2026-04-16 12:22:18,194][trainer.accelerators.base_accelerator][INFO] - Training progress: step=92800/100000 (92.80%), epoch=2, lr=1e-05, speed=1.974 step/s, elapsed=13:03:29, eta=01:00:47 +[2026-04-16 12:22:40,136][trainer.accelerators.base_accelerator][INFO] - Training progress: step=92850/100000 (92.85%), epoch=2, lr=1e-05, speed=1.974 step/s, elapsed=13:03:51, eta=01:00:21 +[2026-04-16 12:23:02,298][trainer.accelerators.base_accelerator][INFO] - Training progress: step=92900/100000 (92.90%), epoch=2, lr=1e-05, speed=1.974 step/s, elapsed=13:04:13, eta=59:56 +[2026-04-16 12:23:24,328][trainer.accelerators.base_accelerator][INFO] - Training progress: step=92950/100000 (92.95%), epoch=2, lr=1e-05, speed=1.974 step/s, elapsed=13:04:35, eta=59:30 +[2026-04-16 12:23:46,338][trainer.accelerators.base_accelerator][INFO] - Training progress: step=93000/100000 (93.00%), epoch=2, lr=1e-05, speed=1.975 step/s, elapsed=13:04:57, eta=59:04 +[2026-04-16 12:23:46,377][__main__][INFO] - ========== EVAL START (periodic@gstep=93000) ========== +[2026-04-16 12:23:46,377][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-16 12:23:46,377][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 12:24:03,834][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 15.61843204498291, 'accuracy': 0.5011764705882353, 'num_samples': 425, 'test_unique_accuracy': 0.4976851851851852, 'test_unique_num_samples': 432} +[2026-04-16 12:24:03,834][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-16 12:24:03,834][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 12:24:19,004][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 15.61843204498291, 'accuracy': 0.5011764705882353, 'num_samples': 425, 'test_unique_accuracy': 0.46296296296296297, 'test_unique_num_samples': 432} +[2026-04-16 12:24:19,005][__main__][INFO] - ========== EVAL END (periodic@gstep=93000) ========== +[2026-04-16 12:24:19,005][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 15.661739349365234, 'accuracy': 0.5011764705882353, 'num_samples': 425, 'test_unique_accuracy': 0.46296296296296297, 'test_unique_num_samples': 432} +[2026-04-16 12:24:19,032][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.5011764705882353 is not better than 0.5741176470588235 of logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep76000, skipping checkpoint +[2026-04-16 12:24:41,215][trainer.accelerators.base_accelerator][INFO] - Training progress: step=93050/100000 (93.05%), epoch=2, lr=1e-05, speed=1.973 step/s, elapsed=13:05:52, eta=58:41 +[2026-04-16 12:25:03,357][trainer.accelerators.base_accelerator][INFO] - Training progress: step=93100/100000 (93.10%), epoch=2, lr=1e-05, speed=1.974 step/s, elapsed=13:06:14, eta=58:16 +[2026-04-16 12:25:25,407][trainer.accelerators.base_accelerator][INFO] - Training progress: step=93150/100000 (93.15%), epoch=2, lr=1e-05, speed=1.974 step/s, elapsed=13:06:36, eta=57:50 +[2026-04-16 12:25:47,544][trainer.accelerators.base_accelerator][INFO] - Training progress: step=93200/100000 (93.20%), epoch=2, lr=1e-05, speed=1.974 step/s, elapsed=13:06:58, eta=57:25 +[2026-04-16 12:26:10,040][trainer.accelerators.base_accelerator][INFO] - Training progress: step=93250/100000 (93.25%), epoch=2, lr=1e-05, speed=1.974 step/s, elapsed=13:07:21, eta=56:59 +[2026-04-16 12:26:32,124][trainer.accelerators.base_accelerator][INFO] - Training progress: step=93300/100000 (93.30%), epoch=2, lr=1e-05, speed=1.974 step/s, elapsed=13:07:43, eta=56:34 +[2026-04-16 12:26:54,288][trainer.accelerators.base_accelerator][INFO] - Training progress: step=93350/100000 (93.35%), epoch=2, lr=1e-05, speed=1.974 step/s, elapsed=13:08:05, eta=56:08 +[2026-04-16 12:27:16,412][trainer.accelerators.base_accelerator][INFO] - Training progress: step=93400/100000 (93.40%), epoch=2, lr=1e-05, speed=1.974 step/s, elapsed=13:08:27, eta=55:42 +[2026-04-16 12:27:38,540][trainer.accelerators.base_accelerator][INFO] - Training progress: step=93450/100000 (93.45%), epoch=2, lr=1e-05, speed=1.974 step/s, elapsed=13:08:49, eta=55:17 +[2026-04-16 12:28:00,656][trainer.accelerators.base_accelerator][INFO] - Training progress: step=93500/100000 (93.50%), epoch=2, lr=1e-05, speed=1.975 step/s, elapsed=13:09:11, eta=54:51 +[2026-04-16 12:28:22,742][trainer.accelerators.base_accelerator][INFO] - Training progress: step=93550/100000 (93.55%), epoch=2, lr=1e-05, speed=1.975 step/s, elapsed=13:09:33, eta=54:26 +[2026-04-16 12:28:44,805][trainer.accelerators.base_accelerator][INFO] - Training progress: step=93600/100000 (93.60%), epoch=2, lr=1e-05, speed=1.975 step/s, elapsed=13:09:56, eta=54:00 +[2026-04-16 12:29:06,928][trainer.accelerators.base_accelerator][INFO] - Training progress: step=93650/100000 (93.65%), epoch=2, lr=1e-05, speed=1.975 step/s, elapsed=13:10:18, eta=53:35 +[2026-04-16 12:29:28,993][trainer.accelerators.base_accelerator][INFO] - Training progress: step=93700/100000 (93.70%), epoch=2, lr=1e-05, speed=1.975 step/s, elapsed=13:10:40, eta=53:09 +[2026-04-16 12:29:51,339][trainer.accelerators.base_accelerator][INFO] - Training progress: step=93750/100000 (93.75%), epoch=2, lr=1e-05, speed=1.975 step/s, elapsed=13:11:02, eta=52:44 +[2026-04-16 12:30:13,459][trainer.accelerators.base_accelerator][INFO] - Training progress: step=93800/100000 (93.80%), epoch=2, lr=1e-05, speed=1.975 step/s, elapsed=13:11:24, eta=52:18 +[2026-04-16 12:30:35,510][trainer.accelerators.base_accelerator][INFO] - Training progress: step=93850/100000 (93.85%), epoch=2, lr=1e-05, speed=1.976 step/s, elapsed=13:11:46, eta=51:53 +[2026-04-16 12:30:57,632][trainer.accelerators.base_accelerator][INFO] - Training progress: step=93900/100000 (93.90%), epoch=2, lr=1e-05, speed=1.976 step/s, elapsed=13:12:08, eta=51:27 +[2026-04-16 12:31:19,749][trainer.accelerators.base_accelerator][INFO] - Training progress: step=93950/100000 (93.95%), epoch=2, lr=1e-05, speed=1.976 step/s, elapsed=13:12:31, eta=51:02 +[2026-04-16 12:31:41,858][trainer.accelerators.base_accelerator][INFO] - Training progress: step=94000/100000 (94.00%), epoch=2, lr=1e-05, speed=1.976 step/s, elapsed=13:12:53, eta=50:36 +[2026-04-16 12:31:41,896][__main__][INFO] - ========== EVAL START (periodic@gstep=94000) ========== +[2026-04-16 12:31:41,897][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-16 12:31:41,897][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 12:32:03,062][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 15.661739349365234, 'accuracy': 0.47294117647058825, 'num_samples': 425, 'test_unique_accuracy': 0.46296296296296297, 'test_unique_num_samples': 432} +[2026-04-16 12:32:03,063][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-16 12:32:03,063][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 12:32:18,252][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 15.661739349365234, 'accuracy': 0.47294117647058825, 'num_samples': 425, 'test_unique_accuracy': 0.5231481481481481, 'test_unique_num_samples': 432} +[2026-04-16 12:32:18,252][__main__][INFO] - ========== EVAL END (periodic@gstep=94000) ========== +[2026-04-16 12:32:18,252][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 15.702229499816895, 'accuracy': 0.47294117647058825, 'num_samples': 425, 'test_unique_accuracy': 0.5231481481481481, 'test_unique_num_samples': 432} +[2026-04-16 12:32:18,256][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.47294117647058825 is not better than 0.5741176470588235 of logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep76000, skipping checkpoint +[2026-04-16 12:32:40,297][trainer.accelerators.base_accelerator][INFO] - Training progress: step=94050/100000 (94.05%), epoch=2, lr=1e-05, speed=1.975 step/s, elapsed=13:13:51, eta=50:13 +[2026-04-16 12:33:02,412][trainer.accelerators.base_accelerator][INFO] - Training progress: step=94100/100000 (94.10%), epoch=2, lr=1e-05, speed=1.975 step/s, elapsed=13:14:13, eta=49:47 +[2026-04-16 12:33:24,545][trainer.accelerators.base_accelerator][INFO] - Training progress: step=94150/100000 (94.15%), epoch=2, lr=1e-05, speed=1.975 step/s, elapsed=13:14:35, eta=49:22 +[2026-04-16 12:33:47,016][trainer.accelerators.base_accelerator][INFO] - Training progress: step=94200/100000 (94.20%), epoch=2, lr=1e-05, speed=1.975 step/s, elapsed=13:14:58, eta=48:56 +[2026-04-16 12:34:09,055][trainer.accelerators.base_accelerator][INFO] - Training progress: step=94250/100000 (94.25%), epoch=2, lr=1e-05, speed=1.975 step/s, elapsed=13:15:20, eta=48:31 +[2026-04-16 12:34:31,183][trainer.accelerators.base_accelerator][INFO] - Training progress: step=94300/100000 (94.30%), epoch=2, lr=1e-05, speed=1.975 step/s, elapsed=13:15:42, eta=48:05 +[2026-04-16 12:34:53,279][trainer.accelerators.base_accelerator][INFO] - Training progress: step=94350/100000 (94.35%), epoch=2, lr=1e-05, speed=1.975 step/s, elapsed=13:16:04, eta=47:40 +[2026-04-16 12:35:15,398][trainer.accelerators.base_accelerator][INFO] - Training progress: step=94400/100000 (94.40%), epoch=2, lr=1e-05, speed=1.975 step/s, elapsed=13:16:26, eta=47:14 +[2026-04-16 12:35:37,407][trainer.accelerators.base_accelerator][INFO] - Training progress: step=94450/100000 (94.45%), epoch=2, lr=1e-05, speed=1.976 step/s, elapsed=13:16:48, eta=46:49 +[2026-04-16 12:35:59,473][trainer.accelerators.base_accelerator][INFO] - Training progress: step=94500/100000 (94.50%), epoch=2, lr=1e-05, speed=1.976 step/s, elapsed=13:17:10, eta=46:23 +[2026-04-16 12:36:21,533][trainer.accelerators.base_accelerator][INFO] - Training progress: step=94550/100000 (94.55%), epoch=2, lr=1e-05, speed=1.976 step/s, elapsed=13:17:32, eta=45:58 +[2026-04-16 12:36:43,601][trainer.accelerators.base_accelerator][INFO] - Training progress: step=94600/100000 (94.60%), epoch=2, lr=1e-05, speed=1.976 step/s, elapsed=13:17:54, eta=45:32 +[2026-04-16 12:37:05,728][trainer.accelerators.base_accelerator][INFO] - Training progress: step=94650/100000 (94.65%), epoch=2, lr=1e-05, speed=1.976 step/s, elapsed=13:18:16, eta=45:07 +[2026-04-16 12:37:27,867][trainer.accelerators.base_accelerator][INFO] - Training progress: step=94700/100000 (94.70%), epoch=2, lr=1e-05, speed=1.976 step/s, elapsed=13:18:39, eta=44:41 +[2026-04-16 12:37:50,059][trainer.accelerators.base_accelerator][INFO] - Training progress: step=94750/100000 (94.75%), epoch=2, lr=1e-05, speed=1.976 step/s, elapsed=13:19:01, eta=44:16 +[2026-04-16 12:38:12,183][trainer.accelerators.base_accelerator][INFO] - Training progress: step=94800/100000 (94.80%), epoch=2, lr=1e-05, speed=1.977 step/s, elapsed=13:19:23, eta=43:50 +[2026-04-16 12:38:34,600][trainer.accelerators.base_accelerator][INFO] - Training progress: step=94850/100000 (94.85%), epoch=2, lr=1e-05, speed=1.977 step/s, elapsed=13:19:45, eta=43:25 +[2026-04-16 12:38:56,744][trainer.accelerators.base_accelerator][INFO] - Training progress: step=94900/100000 (94.90%), epoch=2, lr=1e-05, speed=1.977 step/s, elapsed=13:20:07, eta=42:59 +[2026-04-16 12:39:18,962][trainer.accelerators.base_accelerator][INFO] - Training progress: step=94950/100000 (94.95%), epoch=2, lr=1e-05, speed=1.977 step/s, elapsed=13:20:30, eta=42:34 +[2026-04-16 12:39:41,180][trainer.accelerators.base_accelerator][INFO] - Training progress: step=95000/100000 (95.00%), epoch=2, lr=1e-05, speed=1.977 step/s, elapsed=13:20:52, eta=42:09 +[2026-04-16 12:39:41,221][__main__][INFO] - ========== EVAL START (periodic@gstep=95000) ========== +[2026-04-16 12:39:41,221][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-16 12:39:41,221][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 12:39:56,538][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 15.702229499816895, 'accuracy': 0.5105882352941177, 'num_samples': 425, 'test_unique_accuracy': 0.5231481481481481, 'test_unique_num_samples': 432} +[2026-04-16 12:39:56,539][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-16 12:39:56,539][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 12:40:11,698][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 15.702229499816895, 'accuracy': 0.5105882352941177, 'num_samples': 425, 'test_unique_accuracy': 0.4930555555555556, 'test_unique_num_samples': 432} +[2026-04-16 12:40:11,698][__main__][INFO] - ========== EVAL END (periodic@gstep=95000) ========== +[2026-04-16 12:40:11,699][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 15.747279167175293, 'accuracy': 0.5105882352941177, 'num_samples': 425, 'test_unique_accuracy': 0.4930555555555556, 'test_unique_num_samples': 432} +[2026-04-16 12:40:11,701][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.5105882352941177 is not better than 0.5741176470588235 of logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep76000, skipping checkpoint +[2026-04-16 12:40:33,798][trainer.accelerators.base_accelerator][INFO] - Training progress: step=95050/100000 (95.05%), epoch=2, lr=1e-05, speed=1.976 step/s, elapsed=13:21:45, eta=41:45 +[2026-04-16 12:40:59,808][trainer.accelerators.base_accelerator][INFO] - Training progress: step=95100/100000 (95.10%), epoch=2, lr=1e-05, speed=1.976 step/s, elapsed=13:22:11, eta=41:19 +[2026-04-16 12:41:44,950][trainer.accelerators.base_accelerator][INFO] - Training progress: step=95150/100000 (95.15%), epoch=2, lr=1e-05, speed=1.975 step/s, elapsed=13:22:56, eta=40:55 +[2026-04-16 12:42:38,754][trainer.accelerators.base_accelerator][INFO] - Training progress: step=95200/100000 (95.20%), epoch=2, lr=1e-05, speed=1.974 step/s, elapsed=13:23:50, eta=40:31 +[2026-04-16 12:43:00,904][trainer.accelerators.base_accelerator][INFO] - Training progress: step=95250/100000 (95.25%), epoch=2, lr=1e-05, speed=1.974 step/s, elapsed=13:24:12, eta=40:06 +[2026-04-16 12:43:23,088][trainer.accelerators.base_accelerator][INFO] - Training progress: step=95300/100000 (95.30%), epoch=2, lr=1e-05, speed=1.974 step/s, elapsed=13:24:34, eta=39:40 +[2026-04-16 12:43:45,116][trainer.accelerators.base_accelerator][INFO] - Training progress: step=95350/100000 (95.35%), epoch=2, lr=1e-05, speed=1.974 step/s, elapsed=13:24:56, eta=39:15 +[2026-04-16 12:44:07,217][trainer.accelerators.base_accelerator][INFO] - Training progress: step=95400/100000 (95.40%), epoch=2, lr=1e-05, speed=1.974 step/s, elapsed=13:25:18, eta=38:49 +[2026-04-16 12:44:29,408][trainer.accelerators.base_accelerator][INFO] - Training progress: step=95450/100000 (95.45%), epoch=2, lr=1e-05, speed=1.975 step/s, elapsed=13:25:40, eta=38:24 +[2026-04-16 12:45:05,448][trainer.accelerators.base_accelerator][INFO] - Training progress: step=95500/100000 (95.50%), epoch=2, lr=1e-05, speed=1.974 step/s, elapsed=13:26:16, eta=37:59 +[2026-04-16 12:45:28,557][trainer.accelerators.base_accelerator][INFO] - Training progress: step=95550/100000 (95.55%), epoch=2, lr=1e-05, speed=1.974 step/s, elapsed=13:26:39, eta=37:34 +[2026-04-16 12:45:50,744][trainer.accelerators.base_accelerator][INFO] - Training progress: step=95600/100000 (95.60%), epoch=2, lr=1e-05, speed=1.974 step/s, elapsed=13:27:01, eta=37:08 +[2026-04-16 12:46:12,846][trainer.accelerators.base_accelerator][INFO] - Training progress: step=95650/100000 (95.65%), epoch=2, lr=1e-05, speed=1.974 step/s, elapsed=13:27:24, eta=36:43 +[2026-04-16 12:46:34,967][trainer.accelerators.base_accelerator][INFO] - Training progress: step=95700/100000 (95.70%), epoch=2, lr=1e-05, speed=1.975 step/s, elapsed=13:27:46, eta=36:17 +[2026-04-16 12:46:57,033][trainer.accelerators.base_accelerator][INFO] - Training progress: step=95750/100000 (95.75%), epoch=2, lr=1e-05, speed=1.975 step/s, elapsed=13:28:08, eta=35:52 +[2026-04-16 12:47:19,821][trainer.accelerators.base_accelerator][INFO] - Training progress: step=95800/100000 (95.80%), epoch=2, lr=1e-05, speed=1.975 step/s, elapsed=13:28:31, eta=35:26 +[2026-04-16 12:47:41,893][trainer.accelerators.base_accelerator][INFO] - Training progress: step=95850/100000 (95.85%), epoch=2, lr=1e-05, speed=1.975 step/s, elapsed=13:28:53, eta=35:01 +[2026-04-16 12:48:03,976][trainer.accelerators.base_accelerator][INFO] - Training progress: step=95900/100000 (95.90%), epoch=2, lr=1e-05, speed=1.975 step/s, elapsed=13:29:15, eta=34:35 +[2026-04-16 12:48:26,257][trainer.accelerators.base_accelerator][INFO] - Training progress: step=95950/100000 (95.95%), epoch=2, lr=1e-05, speed=1.975 step/s, elapsed=13:29:37, eta=34:10 +[2026-04-16 12:48:48,465][trainer.accelerators.base_accelerator][INFO] - Training progress: step=96000/100000 (96.00%), epoch=2, lr=1e-05, speed=1.975 step/s, elapsed=13:29:59, eta=33:44 +[2026-04-16 12:48:48,504][__main__][INFO] - ========== EVAL START (periodic@gstep=96000) ========== +[2026-04-16 12:48:48,504][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-16 12:48:48,505][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 12:49:07,607][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 15.747279167175293, 'accuracy': 0.5364705882352941, 'num_samples': 425, 'test_unique_accuracy': 0.4930555555555556, 'test_unique_num_samples': 432} +[2026-04-16 12:49:07,607][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-16 12:49:07,608][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 12:49:22,849][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 15.747279167175293, 'accuracy': 0.5364705882352941, 'num_samples': 425, 'test_unique_accuracy': 0.5324074074074074, 'test_unique_num_samples': 432} +[2026-04-16 12:49:22,850][__main__][INFO] - ========== EVAL END (periodic@gstep=96000) ========== +[2026-04-16 12:49:22,863][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 15.788346290588379, 'accuracy': 0.5364705882352941, 'num_samples': 425, 'test_unique_accuracy': 0.5324074074074074, 'test_unique_num_samples': 432} +[2026-04-16 12:49:22,907][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.5364705882352941 is not better than 0.5741176470588235 of logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep76000, skipping checkpoint +[2026-04-16 12:49:45,096][trainer.accelerators.base_accelerator][INFO] - Training progress: step=96050/100000 (96.05%), epoch=2, lr=1e-05, speed=1.974 step/s, elapsed=13:30:56, eta=33:20 +[2026-04-16 12:50:07,539][trainer.accelerators.base_accelerator][INFO] - Training progress: step=96100/100000 (96.10%), epoch=2, lr=1e-05, speed=1.974 step/s, elapsed=13:31:18, eta=32:55 +[2026-04-16 12:50:29,653][trainer.accelerators.base_accelerator][INFO] - Training progress: step=96150/100000 (96.15%), epoch=2, lr=1e-05, speed=1.974 step/s, elapsed=13:31:40, eta=32:30 +[2026-04-16 12:50:51,752][trainer.accelerators.base_accelerator][INFO] - Training progress: step=96200/100000 (96.20%), epoch=2, lr=1e-05, speed=1.974 step/s, elapsed=13:32:03, eta=32:04 +[2026-04-16 12:51:13,903][trainer.accelerators.base_accelerator][INFO] - Training progress: step=96250/100000 (96.25%), epoch=2, lr=1e-05, speed=1.975 step/s, elapsed=13:32:25, eta=31:39 +[2026-04-16 12:51:44,433][trainer.accelerators.base_accelerator][INFO] - Training progress: step=96300/100000 (96.30%), epoch=2, lr=1e-05, speed=1.974 step/s, elapsed=13:32:55, eta=31:14 +[2026-04-16 12:52:06,922][trainer.accelerators.base_accelerator][INFO] - Training progress: step=96350/100000 (96.35%), epoch=2, lr=1e-05, speed=1.974 step/s, elapsed=13:33:18, eta=30:48 +[2026-04-16 12:52:28,996][trainer.accelerators.base_accelerator][INFO] - Training progress: step=96400/100000 (96.40%), epoch=2, lr=1e-05, speed=1.975 step/s, elapsed=13:33:40, eta=30:23 +[2026-04-16 12:52:51,064][trainer.accelerators.base_accelerator][INFO] - Training progress: step=96450/100000 (96.45%), epoch=2, lr=1e-05, speed=1.975 step/s, elapsed=13:34:02, eta=29:57 +[2026-04-16 12:53:13,149][trainer.accelerators.base_accelerator][INFO] - Training progress: step=96500/100000 (96.50%), epoch=2, lr=1e-05, speed=1.975 step/s, elapsed=13:34:24, eta=29:32 +[2026-04-16 12:53:35,138][trainer.accelerators.base_accelerator][INFO] - Training progress: step=96550/100000 (96.55%), epoch=2, lr=1e-05, speed=1.975 step/s, elapsed=13:34:46, eta=29:06 +[2026-04-16 12:53:57,376][trainer.accelerators.base_accelerator][INFO] - Training progress: step=96600/100000 (96.60%), epoch=2, lr=1e-05, speed=1.975 step/s, elapsed=13:35:08, eta=28:41 +[2026-04-16 12:54:19,462][trainer.accelerators.base_accelerator][INFO] - Training progress: step=96650/100000 (96.65%), epoch=2, lr=1e-05, speed=1.975 step/s, elapsed=13:35:30, eta=28:15 +[2026-04-16 12:54:41,524][trainer.accelerators.base_accelerator][INFO] - Training progress: step=96700/100000 (96.70%), epoch=2, lr=1e-05, speed=1.975 step/s, elapsed=13:35:52, eta=27:50 +[2026-04-16 12:55:03,543][trainer.accelerators.base_accelerator][INFO] - Training progress: step=96750/100000 (96.75%), epoch=2, lr=1e-05, speed=1.976 step/s, elapsed=13:36:14, eta=27:25 +[2026-04-16 12:55:25,630][trainer.accelerators.base_accelerator][INFO] - Training progress: step=96800/100000 (96.80%), epoch=2, lr=1e-05, speed=1.976 step/s, elapsed=13:36:36, eta=26:59 +[2026-04-16 12:55:48,011][trainer.accelerators.base_accelerator][INFO] - Training progress: step=96850/100000 (96.85%), epoch=2, lr=1e-05, speed=1.976 step/s, elapsed=13:36:59, eta=26:34 +[2026-04-16 12:56:10,052][trainer.accelerators.base_accelerator][INFO] - Training progress: step=96900/100000 (96.90%), epoch=2, lr=1e-05, speed=1.976 step/s, elapsed=13:37:21, eta=26:08 +[2026-04-16 12:56:32,121][trainer.accelerators.base_accelerator][INFO] - Training progress: step=96950/100000 (96.95%), epoch=2, lr=1e-05, speed=1.976 step/s, elapsed=13:37:43, eta=25:43 +[2026-04-16 12:56:54,145][trainer.accelerators.base_accelerator][INFO] - Training progress: step=97000/100000 (97.00%), epoch=2, lr=1e-05, speed=1.976 step/s, elapsed=13:38:05, eta=25:18 +[2026-04-16 12:56:54,184][__main__][INFO] - ========== EVAL START (periodic@gstep=97000) ========== +[2026-04-16 12:56:54,185][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-16 12:56:54,185][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 12:57:09,924][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 15.788346290588379, 'accuracy': 0.47058823529411764, 'num_samples': 425, 'test_unique_accuracy': 0.5324074074074074, 'test_unique_num_samples': 432} +[2026-04-16 12:57:09,925][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-16 12:57:09,925][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 12:57:25,117][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 15.788346290588379, 'accuracy': 0.47058823529411764, 'num_samples': 425, 'test_unique_accuracy': 0.47453703703703703, 'test_unique_num_samples': 432} +[2026-04-16 12:57:25,118][__main__][INFO] - ========== EVAL END (periodic@gstep=97000) ========== +[2026-04-16 12:57:25,118][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 15.833789825439453, 'accuracy': 0.47058823529411764, 'num_samples': 425, 'test_unique_accuracy': 0.47453703703703703, 'test_unique_num_samples': 432} +[2026-04-16 12:57:25,124][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.47058823529411764 is not better than 0.5741176470588235 of logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep76000, skipping checkpoint +[2026-04-16 12:57:47,200][trainer.accelerators.base_accelerator][INFO] - Training progress: step=97050/100000 (97.05%), epoch=2, lr=1e-05, speed=1.975 step/s, elapsed=13:38:58, eta=24:53 +[2026-04-16 12:58:09,298][trainer.accelerators.base_accelerator][INFO] - Training progress: step=97100/100000 (97.10%), epoch=2, lr=1e-05, speed=1.975 step/s, elapsed=13:39:20, eta=24:28 +[2026-04-16 12:58:31,437][trainer.accelerators.base_accelerator][INFO] - Training progress: step=97150/100000 (97.15%), epoch=2, lr=1e-05, speed=1.975 step/s, elapsed=13:39:42, eta=24:02 +[2026-04-16 12:58:53,538][trainer.accelerators.base_accelerator][INFO] - Training progress: step=97200/100000 (97.20%), epoch=2, lr=1e-05, speed=1.975 step/s, elapsed=13:40:04, eta=23:37 +[2026-04-16 12:59:16,014][trainer.accelerators.base_accelerator][INFO] - Training progress: step=97250/100000 (97.25%), epoch=2, lr=1e-05, speed=1.976 step/s, elapsed=13:40:27, eta=23:12 +[2026-04-16 12:59:38,168][trainer.accelerators.base_accelerator][INFO] - Training progress: step=97300/100000 (97.30%), epoch=2, lr=1e-05, speed=1.976 step/s, elapsed=13:40:49, eta=22:46 +[2026-04-16 13:00:00,334][trainer.accelerators.base_accelerator][INFO] - Training progress: step=97350/100000 (97.35%), epoch=2, lr=1e-05, speed=1.976 step/s, elapsed=13:41:11, eta=22:21 +[2026-04-16 13:00:22,498][trainer.accelerators.base_accelerator][INFO] - Training progress: step=97400/100000 (97.40%), epoch=2, lr=1e-05, speed=1.976 step/s, elapsed=13:41:33, eta=21:55 +[2026-04-16 13:00:44,533][trainer.accelerators.base_accelerator][INFO] - Training progress: step=97450/100000 (97.45%), epoch=2, lr=1e-05, speed=1.976 step/s, elapsed=13:41:55, eta=21:30 +[2026-04-16 13:01:06,713][trainer.accelerators.base_accelerator][INFO] - Training progress: step=97500/100000 (97.50%), epoch=2, lr=1e-05, speed=1.976 step/s, elapsed=13:42:17, eta=21:05 +[2026-04-16 13:01:28,806][trainer.accelerators.base_accelerator][INFO] - Training progress: step=97550/100000 (97.55%), epoch=2, lr=1e-05, speed=1.976 step/s, elapsed=13:42:40, eta=20:39 +[2026-04-16 13:01:50,995][trainer.accelerators.base_accelerator][INFO] - Training progress: step=97600/100000 (97.60%), epoch=2, lr=1e-05, speed=1.976 step/s, elapsed=13:43:02, eta=20:14 +[2026-04-16 13:02:13,137][trainer.accelerators.base_accelerator][INFO] - Training progress: step=97650/100000 (97.65%), epoch=2, lr=1e-05, speed=1.977 step/s, elapsed=13:43:24, eta=19:48 +[2026-04-16 13:02:35,214][trainer.accelerators.base_accelerator][INFO] - Training progress: step=97700/100000 (97.70%), epoch=2, lr=1e-05, speed=1.977 step/s, elapsed=13:43:46, eta=19:23 +[2026-04-16 13:02:57,367][trainer.accelerators.base_accelerator][INFO] - Training progress: step=97750/100000 (97.75%), epoch=2, lr=1e-05, speed=1.977 step/s, elapsed=13:44:08, eta=18:58 +[2026-04-16 13:03:19,518][trainer.accelerators.base_accelerator][INFO] - Training progress: step=97800/100000 (97.80%), epoch=2, lr=1e-05, speed=1.977 step/s, elapsed=13:44:30, eta=18:32 +[2026-04-16 13:03:41,916][trainer.accelerators.base_accelerator][INFO] - Training progress: step=97850/100000 (97.85%), epoch=2, lr=1e-05, speed=1.977 step/s, elapsed=13:44:53, eta=18:07 +[2026-04-16 13:04:04,003][trainer.accelerators.base_accelerator][INFO] - Training progress: step=97900/100000 (97.90%), epoch=2, lr=1e-05, speed=1.977 step/s, elapsed=13:45:15, eta=17:42 +[2026-04-16 13:04:26,069][trainer.accelerators.base_accelerator][INFO] - Training progress: step=97950/100000 (97.95%), epoch=2, lr=1e-05, speed=1.977 step/s, elapsed=13:45:37, eta=17:16 +[2026-04-16 13:04:48,175][trainer.accelerators.base_accelerator][INFO] - Training progress: step=98000/100000 (98.00%), epoch=2, lr=1e-05, speed=1.977 step/s, elapsed=13:45:59, eta=16:51 +[2026-04-16 13:04:48,214][__main__][INFO] - ========== EVAL START (periodic@gstep=98000) ========== +[2026-04-16 13:04:48,214][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-16 13:04:48,214][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 13:05:03,304][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 15.833789825439453, 'accuracy': 0.46352941176470586, 'num_samples': 425, 'test_unique_accuracy': 0.47453703703703703, 'test_unique_num_samples': 432} +[2026-04-16 13:05:03,304][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-16 13:05:03,304][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 13:05:18,454][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 15.833789825439453, 'accuracy': 0.46352941176470586, 'num_samples': 425, 'test_unique_accuracy': 0.4930555555555556, 'test_unique_num_samples': 432} +[2026-04-16 13:05:18,455][__main__][INFO] - ========== EVAL END (periodic@gstep=98000) ========== +[2026-04-16 13:05:18,455][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 15.874427795410156, 'accuracy': 0.46352941176470586, 'num_samples': 425, 'test_unique_accuracy': 0.4930555555555556, 'test_unique_num_samples': 432} +[2026-04-16 13:05:18,458][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.46352941176470586 is not better than 0.5741176470588235 of logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep76000, skipping checkpoint +[2026-04-16 13:05:40,315][trainer.accelerators.base_accelerator][INFO] - Training progress: step=98050/100000 (98.05%), epoch=2, lr=1e-05, speed=1.976 step/s, elapsed=13:46:51, eta=16:26 +[2026-04-16 13:06:02,485][trainer.accelerators.base_accelerator][INFO] - Training progress: step=98100/100000 (98.10%), epoch=2, lr=1e-05, speed=1.976 step/s, elapsed=13:47:13, eta=16:01 +[2026-04-16 13:06:24,554][trainer.accelerators.base_accelerator][INFO] - Training progress: step=98150/100000 (98.15%), epoch=2, lr=1e-05, speed=1.977 step/s, elapsed=13:47:35, eta=15:35 +[2026-04-16 13:06:46,941][trainer.accelerators.base_accelerator][INFO] - Training progress: step=98200/100000 (98.20%), epoch=2, lr=1e-05, speed=1.977 step/s, elapsed=13:47:58, eta=15:10 +[2026-04-16 13:07:09,116][trainer.accelerators.base_accelerator][INFO] - Training progress: step=98250/100000 (98.25%), epoch=2, lr=1e-05, speed=1.977 step/s, elapsed=13:48:20, eta=14:45 +[2026-04-16 13:07:31,267][trainer.accelerators.base_accelerator][INFO] - Training progress: step=98300/100000 (98.30%), epoch=2, lr=1e-05, speed=1.977 step/s, elapsed=13:48:42, eta=14:19 +[2026-04-16 13:07:53,382][trainer.accelerators.base_accelerator][INFO] - Training progress: step=98350/100000 (98.35%), epoch=2, lr=1e-05, speed=1.977 step/s, elapsed=13:49:04, eta=13:54 +[2026-04-16 13:08:15,560][trainer.accelerators.base_accelerator][INFO] - Training progress: step=98400/100000 (98.40%), epoch=2, lr=1e-05, speed=1.977 step/s, elapsed=13:49:26, eta=13:29 +[2026-04-16 13:08:38,008][trainer.accelerators.base_accelerator][INFO] - Training progress: step=98450/100000 (98.45%), epoch=2, lr=1e-05, speed=1.977 step/s, elapsed=13:49:49, eta=13:03 +[2026-04-16 13:09:00,153][trainer.accelerators.base_accelerator][INFO] - Training progress: step=98500/100000 (98.50%), epoch=2, lr=1e-05, speed=1.977 step/s, elapsed=13:50:11, eta=12:38 +[2026-04-16 13:09:22,349][trainer.accelerators.base_accelerator][INFO] - Training progress: step=98550/100000 (98.55%), epoch=2, lr=1e-05, speed=1.978 step/s, elapsed=13:50:33, eta=12:13 +[2026-04-16 13:09:50,306][trainer.accelerators.base_accelerator][INFO] - Training progress: step=98600/100000 (98.60%), epoch=2, lr=1e-05, speed=1.977 step/s, elapsed=13:51:01, eta=11:47 +[2026-04-16 13:10:13,303][trainer.accelerators.base_accelerator][INFO] - Training progress: step=98650/100000 (98.65%), epoch=2, lr=1e-05, speed=1.978 step/s, elapsed=13:51:24, eta=11:22 +[2026-04-16 13:10:38,772][trainer.accelerators.base_accelerator][INFO] - Training progress: step=98700/100000 (98.70%), epoch=2, lr=1e-05, speed=1.978 step/s, elapsed=13:51:50, eta=10:57 +[2026-04-16 13:11:02,247][trainer.accelerators.base_accelerator][INFO] - Training progress: step=98750/100000 (98.75%), epoch=2, lr=1e-05, speed=1.978 step/s, elapsed=13:52:13, eta=10:32 +[2026-04-16 13:11:25,474][trainer.accelerators.base_accelerator][INFO] - Training progress: step=98800/100000 (98.80%), epoch=2, lr=1e-05, speed=1.978 step/s, elapsed=13:52:36, eta=10:06 +[2026-04-16 13:11:48,606][trainer.accelerators.base_accelerator][INFO] - Training progress: step=98850/100000 (98.85%), epoch=2, lr=1e-05, speed=1.978 step/s, elapsed=13:52:59, eta=09:41 +[2026-04-16 13:12:11,328][trainer.accelerators.base_accelerator][INFO] - Training progress: step=98900/100000 (98.90%), epoch=2, lr=1e-05, speed=1.978 step/s, elapsed=13:53:22, eta=09:16 +[2026-04-16 13:12:33,783][trainer.accelerators.base_accelerator][INFO] - Training progress: step=98950/100000 (98.95%), epoch=2, lr=1e-05, speed=1.978 step/s, elapsed=13:53:45, eta=08:50 +[2026-04-16 13:12:58,267][trainer.accelerators.base_accelerator][INFO] - Training progress: step=99000/100000 (99.00%), epoch=2, lr=1e-05, speed=1.978 step/s, elapsed=13:54:09, eta=08:25 +[2026-04-16 13:12:58,301][__main__][INFO] - ========== EVAL START (periodic@gstep=99000) ========== +[2026-04-16 13:12:58,301][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-16 13:12:58,301][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 13:13:18,419][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 15.874427795410156, 'accuracy': 0.4682352941176471, 'num_samples': 425, 'test_unique_accuracy': 0.4930555555555556, 'test_unique_num_samples': 432} +[2026-04-16 13:13:18,420][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-16 13:13:18,421][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 13:13:34,903][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 15.874427795410156, 'accuracy': 0.4682352941176471, 'num_samples': 425, 'test_unique_accuracy': 0.5138888888888888, 'test_unique_num_samples': 432} +[2026-04-16 13:13:34,906][__main__][INFO] - ========== EVAL END (periodic@gstep=99000) ========== +[2026-04-16 13:13:34,907][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 15.919051170349121, 'accuracy': 0.4682352941176471, 'num_samples': 425, 'test_unique_accuracy': 0.5138888888888888, 'test_unique_num_samples': 432} +[2026-04-16 13:13:34,923][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.4682352941176471 is not better than 0.5741176470588235 of logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep76000, skipping checkpoint +[2026-04-16 13:13:57,470][trainer.accelerators.base_accelerator][INFO] - Training progress: step=99050/100000 (99.05%), epoch=2, lr=1e-05, speed=1.977 step/s, elapsed=13:55:08, eta=08:00 +[2026-04-16 13:14:20,503][trainer.accelerators.base_accelerator][INFO] - Training progress: step=99100/100000 (99.10%), epoch=2, lr=1e-05, speed=1.977 step/s, elapsed=13:55:31, eta=07:35 +[2026-04-16 13:14:43,432][trainer.accelerators.base_accelerator][INFO] - Training progress: step=99150/100000 (99.15%), epoch=2, lr=1e-05, speed=1.977 step/s, elapsed=13:55:54, eta=07:09 +[2026-04-16 13:15:06,635][trainer.accelerators.base_accelerator][INFO] - Training progress: step=99200/100000 (99.20%), epoch=2, lr=1e-05, speed=1.977 step/s, elapsed=13:56:17, eta=06:44 +[2026-04-16 13:15:30,171][trainer.accelerators.base_accelerator][INFO] - Training progress: step=99250/100000 (99.25%), epoch=2, lr=1e-05, speed=1.977 step/s, elapsed=13:56:41, eta=06:19 +[2026-04-16 13:15:53,343][trainer.accelerators.base_accelerator][INFO] - Training progress: step=99300/100000 (99.30%), epoch=2, lr=1e-05, speed=1.977 step/s, elapsed=13:57:04, eta=05:54 +[2026-04-16 13:16:16,226][trainer.accelerators.base_accelerator][INFO] - Training progress: step=99350/100000 (99.35%), epoch=2, lr=1e-05, speed=1.977 step/s, elapsed=13:57:27, eta=05:28 +[2026-04-16 13:16:40,228][trainer.accelerators.base_accelerator][INFO] - Training progress: step=99400/100000 (99.40%), epoch=2, lr=1e-05, speed=1.977 step/s, elapsed=13:57:51, eta=05:03 +[2026-04-16 13:17:03,517][trainer.accelerators.base_accelerator][INFO] - Training progress: step=99450/100000 (99.45%), epoch=2, lr=1e-05, speed=1.977 step/s, elapsed=13:58:14, eta=04:38 +[2026-04-16 13:17:28,134][trainer.accelerators.base_accelerator][INFO] - Training progress: step=99500/100000 (99.50%), epoch=2, lr=1e-05, speed=1.977 step/s, elapsed=13:58:39, eta=04:12 +[2026-04-16 13:17:51,506][trainer.accelerators.base_accelerator][INFO] - Training progress: step=99550/100000 (99.55%), epoch=2, lr=1e-05, speed=1.977 step/s, elapsed=13:59:02, eta=03:47 +[2026-04-16 13:18:14,362][trainer.accelerators.base_accelerator][INFO] - Training progress: step=99600/100000 (99.60%), epoch=2, lr=1e-05, speed=1.978 step/s, elapsed=13:59:25, eta=03:22 +[2026-04-16 13:18:37,284][trainer.accelerators.base_accelerator][INFO] - Training progress: step=99650/100000 (99.65%), epoch=2, lr=1e-05, speed=1.978 step/s, elapsed=13:59:48, eta=02:56 +[2026-04-16 13:18:59,680][trainer.accelerators.base_accelerator][INFO] - Training progress: step=99700/100000 (99.70%), epoch=2, lr=1e-05, speed=1.978 step/s, elapsed=14:00:10, eta=02:31 +[2026-04-16 13:19:22,349][trainer.accelerators.base_accelerator][INFO] - Training progress: step=99750/100000 (99.75%), epoch=2, lr=1e-05, speed=1.978 step/s, elapsed=14:00:33, eta=02:06 +[2026-04-16 13:19:45,354][trainer.accelerators.base_accelerator][INFO] - Training progress: step=99800/100000 (99.80%), epoch=2, lr=1e-05, speed=1.978 step/s, elapsed=14:00:56, eta=01:41 +[2026-04-16 13:20:08,038][trainer.accelerators.base_accelerator][INFO] - Training progress: step=99850/100000 (99.85%), epoch=2, lr=1e-05, speed=1.978 step/s, elapsed=14:01:19, eta=01:15 +[2026-04-16 13:20:31,428][trainer.accelerators.base_accelerator][INFO] - Training progress: step=99900/100000 (99.90%), epoch=2, lr=1e-05, speed=1.978 step/s, elapsed=14:01:42, eta=00:50 +[2026-04-16 13:20:55,227][trainer.accelerators.base_accelerator][INFO] - Training progress: step=99950/100000 (99.95%), epoch=2, lr=1e-05, speed=1.978 step/s, elapsed=14:02:06, eta=00:25 +[2026-04-16 13:21:18,326][trainer.accelerators.base_accelerator][INFO] - Training progress: step=100000/100000 (100.00%), epoch=2, lr=1e-05, speed=1.978 step/s, elapsed=14:02:29, eta=00:00 +[2026-04-16 13:21:18,333][__main__][INFO] - ========== EVAL START (final@gstep=100000) ========== +[2026-04-16 13:21:18,333][__main__][INFO] - *** Evaluating validation_unique *** +[2026-04-16 13:21:18,333][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 13:21:35,235][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 15.919051170349121, 'accuracy': 0.49411764705882355, 'num_samples': 425, 'test_unique_accuracy': 0.5138888888888888, 'test_unique_num_samples': 432} +[2026-04-16 13:21:35,237][__main__][INFO] - *** Evaluating test_unique *** +[2026-04-16 13:21:35,237][trainer.tasks.step_sana_task][INFO] - Running clip score... +[2026-04-16 13:21:51,265][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 15.919051170349121, 'accuracy': 0.49411764705882355, 'num_samples': 425, 'test_unique_accuracy': 0.4930555555555556, 'test_unique_num_samples': 432} +[2026-04-16 13:21:51,265][__main__][INFO] - ========== EVAL END (final@gstep=100000) ========== +[2026-04-16 13:21:51,266][trainer.accelerators.base_accelerator][INFO] - Metrics: {'logit_scale': 15.953969955444336, 'accuracy': 0.49411764705882355, 'num_samples': 425, 'test_unique_accuracy': 0.4930555555555556, 'test_unique_num_samples': 432} +[2026-04-16 13:21:51,270][trainer.accelerators.base_accelerator][INFO] - Metric accuracy=0.49411764705882355 is not better than 0.5741176470588235 of logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-gstep76000, skipping checkpoint +[2026-04-16 13:22:28,217][root][INFO] - gcc -pthread -B /g/data/rr81/aev/compiler_compat -DNDEBUG -fwrapv -O2 -Wall -fPIC -O2 -isystem /g/data/rr81/aev/include -fPIC -O2 -isystem /g/data/rr81/aev/include -fPIC -c /scratch/rr81/ma5430/tmp/tmpvxfiz37p/test.c -o /scratch/rr81/ma5430/tmp/tmpvxfiz37p/test.o +[2026-04-16 13:22:28,853][root][INFO] - gcc -pthread -B /g/data/rr81/aev/compiler_compat /scratch/rr81/ma5430/tmp/tmpvxfiz37p/test.o -laio -o /scratch/rr81/ma5430/tmp/tmpvxfiz37p/a.out +[2026-04-16 13:22:29,386][trainer.accelerators.base_accelerator][WARNING] - Falling back to direct model unwrap because DeepSpeed import failed: CUDA_HOME does not exist, unable to compile CUDA op(s) +[2026-04-16 13:22:29,390][trainer.accelerators.base_accelerator][INFO] - Saving final checkpoint to logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-final +[2026-04-16 13:22:31,721][root][INFO] - gcc -pthread -B /g/data/rr81/aev/compiler_compat -DNDEBUG -fwrapv -O2 -Wall -fPIC -O2 -isystem /g/data/rr81/aev/include -fPIC -O2 -isystem /g/data/rr81/aev/include -fPIC -c /scratch/rr81/ma5430/tmp/tmpjuc3no2_/test.c -o /scratch/rr81/ma5430/tmp/tmpjuc3no2_/test.o +[2026-04-16 13:22:31,946][root][INFO] - gcc -pthread -B /g/data/rr81/aev/compiler_compat /scratch/rr81/ma5430/tmp/tmpjuc3no2_/test.o -laio -o /scratch/rr81/ma5430/tmp/tmpjuc3no2_/a.out +[2026-04-16 13:22:40,050][trainer.accelerators.base_accelerator][INFO] - Saved checkpoint to logs/v8/reward_model/step_sana_sana_600m_512_variable-t_lr1e-5_step-8000_filter2_time951/checkpoint-final diff --git a/lrm/lrm_sana/trainer/datasets/__init__.py b/lrm/lrm_sana/trainer/datasets/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..fba1a2ae91cf1ecad0a45b4f5b0e64cc67996ac1 --- /dev/null +++ b/lrm/lrm_sana/trainer/datasets/__init__.py @@ -0,0 +1,6 @@ +from hydra.core.config_store import ConfigStore + +from trainer.datasets.step_sana_hf_dataset import StepSanaHFDatasetConfig + +cs = ConfigStore.instance() +cs.store(group="dataset", name="step_sana", node=StepSanaHFDatasetConfig) \ No newline at end of file diff --git a/lrm/lrm_sana/trainer/datasets/__pycache__/__init__.cpython-310.pyc b/lrm/lrm_sana/trainer/datasets/__pycache__/__init__.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..924c7d5d03bc263b04b5655ed6c8c6a34a9c7c8f Binary files /dev/null and b/lrm/lrm_sana/trainer/datasets/__pycache__/__init__.cpython-310.pyc differ diff --git a/lrm/lrm_sana/trainer/datasets/__pycache__/__init__.cpython-311.pyc b/lrm/lrm_sana/trainer/datasets/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..dc5505a3773f3a427f08401f56a6cbc790941d63 Binary files /dev/null and b/lrm/lrm_sana/trainer/datasets/__pycache__/__init__.cpython-311.pyc differ diff --git a/lrm/lrm_sana/trainer/datasets/__pycache__/base_dataset.cpython-310.pyc b/lrm/lrm_sana/trainer/datasets/__pycache__/base_dataset.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6fc99fc2df1a10f3e4d936d99919b2b23ec4181d Binary files /dev/null and b/lrm/lrm_sana/trainer/datasets/__pycache__/base_dataset.cpython-310.pyc differ diff --git a/lrm/lrm_sana/trainer/datasets/__pycache__/base_dataset.cpython-311.pyc b/lrm/lrm_sana/trainer/datasets/__pycache__/base_dataset.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..96a3d70af76102a7f51f2cb81e94c12c20e05fae Binary files /dev/null and b/lrm/lrm_sana/trainer/datasets/__pycache__/base_dataset.cpython-311.pyc differ diff --git a/lrm/lrm_sana/trainer/datasets/__pycache__/step_flux_hf_dataset.cpython-310.pyc b/lrm/lrm_sana/trainer/datasets/__pycache__/step_flux_hf_dataset.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..84277b32044fac41a6e1fb36bd29832a559a352c Binary files /dev/null and b/lrm/lrm_sana/trainer/datasets/__pycache__/step_flux_hf_dataset.cpython-310.pyc differ diff --git a/lrm/lrm_sana/trainer/datasets/__pycache__/step_flux_hf_dataset.cpython-311.pyc b/lrm/lrm_sana/trainer/datasets/__pycache__/step_flux_hf_dataset.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c5770e2446509ebc99ce9b416f47a9efc6877fb8 Binary files /dev/null and b/lrm/lrm_sana/trainer/datasets/__pycache__/step_flux_hf_dataset.cpython-311.pyc differ diff --git a/lrm/lrm_sana/trainer/datasets/__pycache__/step_sana_hf_dataset.cpython-311.pyc b/lrm/lrm_sana/trainer/datasets/__pycache__/step_sana_hf_dataset.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..43512ef8d42417a2a0d57d6b68dbeb81f1b2b824 Binary files /dev/null and b/lrm/lrm_sana/trainer/datasets/__pycache__/step_sana_hf_dataset.cpython-311.pyc differ diff --git a/lrm/lrm_sana/trainer/datasets/base_dataset.py b/lrm/lrm_sana/trainer/datasets/base_dataset.py new file mode 100644 index 0000000000000000000000000000000000000000..5cddbc8d8e48f43c774682b05ed88875def7771d --- /dev/null +++ b/lrm/lrm_sana/trainer/datasets/base_dataset.py @@ -0,0 +1,18 @@ +from dataclasses import dataclass + +import torch + + +@dataclass +class BaseDatasetConfig: + train_split_name: str = "train" + valid_split_name: str = "validation" + test_split_name: str = "test" + + batch_size: int = 4 + num_workers: int = 2 + drop_last: bool = True + + +class BaseDataset(torch.utils.data.Dataset): + pass diff --git a/lrm/lrm_sana/trainer/datasets/step_flux_hf_dataset.py b/lrm/lrm_sana/trainer/datasets/step_flux_hf_dataset.py new file mode 100644 index 0000000000000000000000000000000000000000..595a1ac818578d43d85eade60f1927faa38f1e30 --- /dev/null +++ b/lrm/lrm_sana/trainer/datasets/step_flux_hf_dataset.py @@ -0,0 +1,461 @@ +from dataclasses import dataclass, field +from io import BytesIO +from typing import Optional +import os +from glob import glob + +import torch +from PIL import Image +from accelerate.logging import get_logger +from datasets import load_from_disk, load_dataset, Dataset, concatenate_datasets +from hydra.utils import instantiate +from omegaconf import II +from transformers import CLIPTokenizer, T5TokenizerFast +from torchvision import transforms +import pandas as pd +from collections import Counter + +from trainer.datasets.base_dataset import BaseDataset, BaseDatasetConfig + +logger = get_logger(__name__) + + +def simple_collate(batch, column_name): + return torch.cat([item[column_name] for item in batch], dim=0) + + +@dataclass +class ProcessorConfig: + pretrained_model_name_or_path: str = II("model.pretrained_model_name_or_path") + max_sequence_length: int = II("model.max_sequence_length") + image_size: int = II("model.image_size") + # tokenizer_subfolder: str = "tokenizer" + random_crop: bool = False + no_hflip: bool = True + + + + +@dataclass +class StepFluxHFDatasetConfig(BaseDatasetConfig): + _target_: str = "trainer.datasets.step_flux_hf_dataset.StepFluxHFDataset" + dataset_name: str = "pickapic-anonymous/pickapic_v1" + dataset_config_name: Optional[str] = None # null + + from_disk: bool = False + train_split_name: str = "train" + valid_split_name: str = "validation_unique" + test_split_name: str = "test_unique" + cache_dir: Optional[str] = None + + caption_column_name: str = "caption" + input_ids_column_name: str = "input_ids" + input_ids_2_column_name: str = "input_ids_2" + image_0_column_name: str = "jpg_0" + image_1_column_name: str = "jpg_1" + label_0_column_name: str = "label_0" + label_1_column_name: str = "label_1" + are_different_column_name: str = "are_different" + has_label_column_name: str = "has_label" + + pixels_0_column_name: str = "pixel_values_0" + pixels_1_column_name: str = "pixel_values_1" + + timestep_column_name: str = "timestep" + constant_timestep: int = 1 + variable_timestep: bool = False + largest_timestep: int = 751 + + compare_between_timestep: bool = False + timestep_comparison_column_name: str = "timestep_comparison" + timestep_interval: int = 1 + + num_examples_per_prompt_column_name: str = "num_example_per_prompt" + + keep_only_different: bool = False + keep_only_with_label: bool = False + keep_only_with_label_in_non_train: bool = True + keep_only_with_pesudo_preference: bool = False + pseudo_preference_path: str = "" + filter_strategy: int = 1 + processor: ProcessorConfig = field(default_factory=ProcessorConfig) + + limit_examples_per_prompt: int = -1 + + only_on_best: bool = False + + +class StepFluxHFDataset(BaseDataset): + + def __init__(self, cfg: StepFluxHFDatasetConfig, split: str = "train"): + self.cfg = cfg + self.split = split + logger.info(f"Using step-aware datasets") + logger.info(f"Loading {self.split} dataset") + logger.info(f"Batch size is {self.cfg.batch_size}") + + self.dataset = self.load_hf_dataset(self.split) + logger.info(f"Loaded {len(self.dataset)} examples from {self.split} dataset") + + if self.cfg.keep_only_different: + self.dataset = self.dataset.filter(lambda x: x[self.cfg.are_different_column_name]) + + if self.cfg.keep_only_with_label: + logger.info(f"Keeping only examples with label") + self.dataset = self.dataset.filter(lambda x: x[self.cfg.has_label_column_name]) + logger.info(f"Kept {len(self.dataset)} examples from {self.split} dataset") + elif self.cfg.keep_only_with_label_in_non_train and self.split != self.cfg.train_split_name: + logger.info(f"Keeping only examples with label in {self.split} split") + self.dataset = self.dataset.filter(lambda x: x[self.cfg.has_label_column_name]) + logger.info(f"Kept {len(self.dataset)} examples from {self.split} dataset") + + if self.cfg.limit_examples_per_prompt > 0: + logger.info(f"Limiting examples per prompt to {self.cfg.limit_examples_per_prompt}") + df = self.dataset.to_pandas() + df = df.drop('__index_level_0__', axis=1) + logger.info(f"Loaded {len(df)} examples from {self.split} dataset") + df = df.groupby(self.cfg.caption_column_name).head(self.cfg.limit_examples_per_prompt) + logger.info(f"Kept {len(df)} examples from {self.split} dataset") + self.dataset = Dataset.from_pandas(df) + + if self.cfg.only_on_best and self.split == self.cfg.train_split_name: + logger.info(f"Keeping only best examples for training") + train_dataset = self.dataset.remove_columns([self.cfg.image_0_column_name, self.cfg.image_1_column_name]) + df = train_dataset.to_pandas() + df = df[df[self.cfg.has_label_column_name] == 1] + image_0_wins_df = df[df[self.cfg.label_0_column_name] == 1] + image_1_wins_df = df[df[self.cfg.label_0_column_name] == 0] + bad_image_0_to_good_image_1 = dict(zip(image_1_wins_df.image_0_uid, image_1_wins_df.image_1_uid)) + bad_image_1_to_good_image_0 = dict(zip(image_0_wins_df.image_1_uid, image_0_wins_df.image_0_uid)) + bad_images_uids2good_images_uids = bad_image_0_to_good_image_1 | bad_image_1_to_good_image_0 + image_0_uid2image_col_name = dict(zip(df.image_0_uid, [self.cfg.image_0_column_name] * len(df.image_0_uid))) + image_1_uid2image_col_name = dict(zip(df.image_1_uid, [self.cfg.image_1_column_name] * len(df.image_1_uid))) + uid2image_col_name = image_0_uid2image_col_name | image_1_uid2image_col_name + + bad_uids = set() + for bad_image, good_image in bad_images_uids2good_images_uids.items(): + cur_good = {bad_image} + while good_image in bad_images_uids2good_images_uids: + if good_image in cur_good: + bad_uids.add(bad_image) + break + cur_good.add(good_image) + good_image = bad_images_uids2good_images_uids[good_image] + bad_images_uids2good_images_uids[bad_image] = good_image + + df = df[~(df.image_0_uid.isin(bad_uids) | df.image_1_uid.isin(bad_uids))] + keep_ids = df.index.tolist() + self.dataset = self.dataset.select(keep_ids) + new_ids = list(range(len(df))) + uid2index = dict(zip(df.image_0_uid, new_ids)) | dict(zip(df.image_1_uid, new_ids)) + logger.info(f"Kept only {len(self.dataset)} best examples for training") + self.bad_images_uids2good_images_uids = bad_images_uids2good_images_uids + self.uid2index = uid2index + self.uid2image_col_name = uid2image_col_name + + pseudo_preference = None + pseudo_preference_matches_dataset = False + if self.split == self.cfg.train_split_name: + pseudo_path = (cfg.pseudo_preference_path or "").strip() + if pseudo_path and os.path.exists(pseudo_path): + try: + pseudo_preference = pd.read_csv(pseudo_path) + except pd.errors.ParserError as ex: + logger.warning( + f"Pseudo preference CSV has malformed rows, retrying with bad-line skipping: {ex}" + ) + pseudo_preference = pd.read_csv(pseudo_path, engine="python", on_bad_lines="skip") + if len(pseudo_preference) == len(self.dataset): + pseudo_preference_matches_dataset = True + self.dataset = self.dataset.add_column('different_flag', pseudo_preference['different_flag']) + else: + logger.warning( + "Skipping pseudo preference add_column because length mismatch: " + f"dataset={len(self.dataset)} pseudo_preference={len(pseudo_preference)} path={pseudo_path}" + ) + elif pseudo_path: + logger.warning(f"Pseudo preference path does not exist, skipping: {pseudo_path}") + + if self.cfg.compare_between_timestep and self.split == self.cfg.train_split_name: + logger.info(f"Adding timestep comparison column") + self.dataset = self.dataset.add_column(self.cfg.timestep_comparison_column_name, [False] * len(self.dataset)) + + if self.cfg.keep_only_with_pesudo_preference and self.split == self.cfg.train_split_name: + if pseudo_preference is None: + raise ValueError( + "keep_only_with_pesudo_preference=True requires a readable pseudo_preference_path for train split" + ) + if not pseudo_preference_matches_dataset: + logger.warning( + "Skipping keep_only_with_pesudo_preference because pseudo preference length does not " + f"match dataset length for split={self.split}: dataset={len(self.dataset)} " + f"pseudo_preference={len(pseudo_preference)}" + ) + else: + logger.info(f"Keeping only examples with pesudo preference, filter_strategy: {self.cfg.filter_strategy}") + if self.cfg.filter_strategy == 1: + filter_rule = ((pseudo_preference['different_flag']==1) & (pseudo_preference['aesthetic_gap']>0) & (pseudo_preference['clipscore_gap']>0) & (pseudo_preference['vqascore_gap']>0)) | \ + ((pseudo_preference['different_flag']==0) & (pseudo_preference['aesthetic_gap']<0.2) & (pseudo_preference['clipscore_gap']<0.03) & (pseudo_preference['vqascore_gap']<0.07)) + elif self.cfg.filter_strategy == 2: + filter_rule = ((pseudo_preference['different_flag']==1) & (pseudo_preference['aesthetic_gap']>-0.5) & (pseudo_preference['clipscore_gap']>0) & (pseudo_preference['vqascore_gap']>0)) | \ + ((pseudo_preference['different_flag']==0) & (pseudo_preference['aesthetic_gap']<0.2) & (pseudo_preference['clipscore_gap']<0.03) & (pseudo_preference['vqascore_gap']<0.07)) + elif self.cfg.filter_strategy == 3: + filter_rule = ((pseudo_preference['different_flag']==1) & (pseudo_preference['aesthetic_gap']>-1) & (pseudo_preference['clipscore_gap']>0) & (pseudo_preference['vqascore_gap']>0)) | \ + ((pseudo_preference['different_flag']==0) & (pseudo_preference['aesthetic_gap']<0.2) & (pseudo_preference['clipscore_gap']<0.03) & (pseudo_preference['vqascore_gap']<0.07)) + else: + raise ValueError(f"Unknown filter strategy: {self.cfg.filter_strategy}") + + logger.info(f"Loaded {len(self.dataset)} examples from {self.split} dataset") + # select from dataset by filter_rule index + true_indices = pseudo_preference[filter_rule].index.tolist() + self.dataset = self.dataset.select(true_indices, keep_in_memory=True) + + logger.info(f"Kept {len(self.dataset)} examples from {self.split} dataset") + + if self.cfg.compare_between_timestep and self.split == self.cfg.train_split_name: + if pseudo_preference is None: + raise ValueError( + "compare_between_timestep=True for train split requires pseudo_preference_path with different_flag" + ) + assert self.cfg.variable_timestep, "Only support variable timestep for now" + logger.info("Constructing timestep comparison dataset") + + original_dataset = self.load_hf_dataset(self.split) + original_dataset = original_dataset.add_column(self.cfg.timestep_comparison_column_name, [True] * len(original_dataset)) + if self.cfg.keep_only_with_pesudo_preference: + filter_rule = filter_rule & (pseudo_preference['different_flag']==1) + else: + filter_rule = (pseudo_preference['different_flag']==1) + true_indices = pseudo_preference[filter_rule].index.tolist() + comparison_dataset = original_dataset.select(true_indices) + + self.dataset = self.dataset.remove_columns('__index_level_0__') + comparison_dataset = comparison_dataset.remove_columns('__index_level_0__') + + self.dataset = concatenate_datasets([self.dataset, comparison_dataset]) + + logger.info(f"Loaded {len(self.dataset)} examples from {self.split} dataset") + + self.tokenizer = CLIPTokenizer.from_pretrained(cfg.processor.pretrained_model_name_or_path, subfolder='tokenizer') + self.tokenizer_2 = T5TokenizerFast.from_pretrained( + cfg.processor.pretrained_model_name_or_path, + subfolder='tokenizer_2', + ) + self.image_transform = transforms.Compose( + [ + transforms.Resize((cfg.processor.image_size, cfg.processor.image_size), interpolation=transforms.InterpolationMode.BILINEAR), + transforms.RandomCrop(cfg.processor.image_size) if cfg.processor.random_crop else transforms.CenterCrop(cfg.processor.image_size), + transforms.Lambda(lambda x: x) if cfg.processor.no_hflip else transforms.RandomHorizontalFlip(), + transforms.ToTensor(), + transforms.Normalize([0.5], [0.5]), + ] + ) + self.candidate_timesteps = torch.tensor(list(range(1, self.cfg.largest_timestep+1, 50)), dtype=torch.long) + + def load_hf_dataset(self, split: str) -> Dataset: + if self.cfg.from_disk: + dataset = load_from_disk(self.cfg.dataset_name)[split] + else: + offline_mode = os.getenv("HF_HUB_OFFLINE", "0").strip().lower() in {"1", "true", "yes", "on"} + if offline_mode: + cached_dataset = self._load_cached_dataset_from_hub(split) + if cached_dataset is not None: + return cached_dataset + dataset = load_dataset( + self.cfg.dataset_name, + # self.cfg.dataset_config_name, + cache_dir=self.cfg.cache_dir, + split=split + ) + return dataset + + def _load_cached_dataset_from_hub(self, split: str): + if "/" not in self.cfg.dataset_name: + return None + + hub_cache_dir = os.getenv("HF_HUB_CACHE") or os.getenv("HUGGINGFACE_HUB_CACHE") + if not hub_cache_dir: + return None + + org, name = self.cfg.dataset_name.split("/", 1) + repo_cache_dir = os.path.join(hub_cache_dir, f"datasets--{org}--{name}") + if not os.path.isdir(repo_cache_dir): + return None + + snapshot_dir = None + ref_main = os.path.join(repo_cache_dir, "refs", "main") + if os.path.isfile(ref_main): + revision = open(ref_main, "r", encoding="utf-8").read().strip() + candidate = os.path.join(repo_cache_dir, "snapshots", revision) + if os.path.isdir(candidate): + snapshot_dir = candidate + + if snapshot_dir is None: + snapshots = sorted(glob(os.path.join(repo_cache_dir, "snapshots", "*"))) + if snapshots: + snapshot_dir = snapshots[-1] + + if snapshot_dir is None: + return None + + data_dir = os.path.join(snapshot_dir, "data") + if not os.path.isdir(data_dir): + return None + + selected_split = split + parquet_files = sorted(glob(os.path.join(data_dir, f"{selected_split}-*.parquet"))) + if not parquet_files and split.startswith("validation"): + for alt_split in ("test_unique", "test"): + alt_files = sorted(glob(os.path.join(data_dir, f"{alt_split}-*.parquet"))) + if alt_files: + selected_split = alt_split + parquet_files = alt_files + logger.warning( + f"Offline cache missing split '{split}', falling back to '{selected_split}'" + ) + break + + if not parquet_files: + return None + + logger.info( + f"Loading cached offline split '{selected_split}' from {len(parquet_files)} parquet shards" + ) + return load_dataset("parquet", data_files=parquet_files, split="train") + + def tokenize(self, example): + caption = example[self.cfg.caption_column_name] + input_ids = self.tokenizer( + caption, + max_length=self.tokenizer.model_max_length, + padding="max_length", + truncation=True, + return_tensors="pt" + ).input_ids + input_ids_2 = self.tokenizer_2( + caption, + max_length=self.cfg.processor.max_sequence_length, + padding="max_length", + truncation=True, + return_tensors="pt" + ).input_ids + return input_ids, input_ids_2 + + def process_image(self, image): + if isinstance(image, dict): + image = image["bytes"] + if isinstance(image, bytes): + image = Image.open(BytesIO(image)) + image = image.convert("RGB") + pixel_values = self.image_transform(image).unsqueeze(0) + return pixel_values + + def __getitem__(self, idx): + example = self.dataset[idx] + + if self.cfg.only_on_best and self.split == self.cfg.train_split_name: + if example[self.cfg.label_0_column_name]: + bad_image_uid = example["image_1_uid"] + good_image_column_name = self.cfg.image_0_column_name + else: + bad_image_uid = example["image_0_uid"] + good_image_column_name = self.cfg.image_1_column_name + good_image_uid = self.bad_images_uids2good_images_uids[bad_image_uid] + good_image_index = self.uid2index[good_image_uid] + example[good_image_column_name] = self.dataset[good_image_index][self.uid2image_col_name[good_image_uid]] + + input_ids, input_ids_2 = self.tokenize(example) + + if self.split == self.cfg.train_split_name and self.cfg.compare_between_timestep and example[self.cfg.timestep_comparison_column_name]: + if example[self.cfg.label_0_column_name] == 1: + pixel_0_values = self.process_image(example[self.cfg.image_0_column_name]) + pixel_1_values = pixel_0_values.clone() + elif example[self.cfg.label_1_column_name] == 1: + pixel_0_values = self.process_image(example[self.cfg.image_1_column_name]) + pixel_1_values = pixel_0_values.clone() + else: + raise ValueError(f"No good image found for {idx} sample") + + index = torch.randint(0, len(self.candidate_timesteps), (1,)).item() + if index < self.cfg.timestep_interval: + next_index = index + self.cfg.timestep_interval + elif index >= len(self.candidate_timesteps) - self.cfg.timestep_interval: + next_index = index - self.cfg.timestep_interval + else: + if torch.rand(1).item() > 0.5: + next_index = index + self.cfg.timestep_interval + else: + next_index = index - self.cfg.timestep_interval + + if next_index > index: + label0 = torch.tensor([1]) + label1 = torch.tensor([0]) + else: + label0 = torch.tensor([0]) + label1 = torch.tensor([1]) + + item_timestep = self.candidate_timesteps[index].view(1,) + next_item_timestep = self.candidate_timesteps[next_index].view(1,) + item_timestep = torch.concat([item_timestep, next_item_timestep]) + item = { + self.cfg.input_ids_column_name: input_ids, + self.cfg.input_ids_2_column_name: input_ids_2, + self.cfg.pixels_0_column_name: pixel_0_values, + self.cfg.pixels_1_column_name: pixel_1_values, + self.cfg.label_0_column_name: label0, + self.cfg.label_1_column_name: label1, + self.cfg.num_examples_per_prompt_column_name: torch.tensor(example[self.cfg.num_examples_per_prompt_column_name])[None], + self.cfg.timestep_column_name: item_timestep + } + + else: + pixel_0_values = self.process_image(example[self.cfg.image_0_column_name]) + pixel_1_values = self.process_image(example[self.cfg.image_1_column_name]) + + if self.cfg.variable_timestep: + if self.split == self.cfg.train_split_name: + item_timestep = self.candidate_timesteps[torch.randint(0, len(self.candidate_timesteps), (1,)).item()].view(1,) + else: + item_timestep = torch.tensor([1], dtype=torch.long) + else: + item_timestep = torch.tensor([self.cfg.constant_timestep], dtype=torch.long) + item_timestep = torch.concat([item_timestep, item_timestep]) + item = { + self.cfg.input_ids_column_name: input_ids, + self.cfg.input_ids_2_column_name: input_ids_2, + self.cfg.pixels_0_column_name: pixel_0_values, + self.cfg.pixels_1_column_name: pixel_1_values, + self.cfg.label_0_column_name: torch.tensor(example[self.cfg.label_0_column_name])[None], + self.cfg.label_1_column_name: torch.tensor(example[self.cfg.label_1_column_name])[None], + self.cfg.num_examples_per_prompt_column_name: torch.tensor(example[self.cfg.num_examples_per_prompt_column_name])[None], + self.cfg.timestep_column_name: item_timestep + } + return item + + def collate_fn(self, batch): + input_ids = simple_collate(batch, self.cfg.input_ids_column_name) + input_ids_2 = simple_collate(batch, self.cfg.input_ids_2_column_name) + pixel_0_values = simple_collate(batch, self.cfg.pixels_0_column_name) + pixel_1_values = simple_collate(batch, self.cfg.pixels_1_column_name) + label_0 = simple_collate(batch, self.cfg.label_0_column_name) + label_1 = simple_collate(batch, self.cfg.label_1_column_name) + num_examples_per_prompt = simple_collate(batch, self.cfg.num_examples_per_prompt_column_name) + timestep = simple_collate(batch, self.cfg.timestep_column_name) + + pixel_0_values = pixel_0_values.to(memory_format=torch.contiguous_format).float() + pixel_1_values = pixel_1_values.to(memory_format=torch.contiguous_format).float() + + collated = { + self.cfg.input_ids_column_name: input_ids, + self.cfg.input_ids_2_column_name: input_ids_2, + self.cfg.pixels_0_column_name: pixel_0_values, + self.cfg.pixels_1_column_name: pixel_1_values, + self.cfg.label_0_column_name: label_0, + self.cfg.label_1_column_name: label_1, + self.cfg.num_examples_per_prompt_column_name: num_examples_per_prompt, + self.cfg.timestep_column_name: timestep, + } + return collated + + def __len__(self): + return len(self.dataset) \ No newline at end of file diff --git a/lrm/lrm_sana/trainer/datasets/step_sana_hf_dataset.py b/lrm/lrm_sana/trainer/datasets/step_sana_hf_dataset.py new file mode 100644 index 0000000000000000000000000000000000000000..3c4f92398315460e026fa867f58e0b4df25e4405 --- /dev/null +++ b/lrm/lrm_sana/trainer/datasets/step_sana_hf_dataset.py @@ -0,0 +1,489 @@ +from dataclasses import dataclass, field +from io import BytesIO +from typing import Optional +import os +from glob import glob + +import torch +from PIL import Image +from accelerate.logging import get_logger +from datasets import load_from_disk, load_dataset, Dataset, concatenate_datasets +from hydra.utils import instantiate +from omegaconf import II +from transformers import AutoTokenizer +from torchvision import transforms +import pandas as pd +from collections import Counter + +from trainer.datasets.base_dataset import BaseDataset, BaseDatasetConfig + +logger = get_logger(__name__) + + +def simple_collate(batch, column_name): + return torch.cat([item[column_name] for item in batch], dim=0) + + +@dataclass +class ProcessorConfig: + pretrained_model_name_or_path: str = II("model.pretrained_model_name_or_path") + max_sequence_length: int = II("model.max_sequence_length") + max_sequence_length_2: int = II("model.max_sequence_length_2") + image_size: int = II("model.image_size") + # tokenizer_subfolder: str = "tokenizer" + random_crop: bool = False + no_hflip: bool = True + + + + +@dataclass +class StepSanaHFDatasetConfig(BaseDatasetConfig): + _target_: str = "trainer.datasets.step_sana_hf_dataset.StepSanaHFDataset" + dataset_name: str = "pickapic-anonymous/pickapic_v1" + dataset_config_name: Optional[str] = None # null + + from_disk: bool = False + train_split_name: str = "train" + valid_split_name: str = "validation_unique" + test_split_name: str = "test_unique" + cache_dir: Optional[str] = None + + caption_column_name: str = "caption" + input_ids_column_name: str = "input_ids" + input_ids_2_column_name: str = "input_ids_2" + image_0_column_name: str = "jpg_0" + image_1_column_name: str = "jpg_1" + label_0_column_name: str = "label_0" + label_1_column_name: str = "label_1" + are_different_column_name: str = "are_different" + has_label_column_name: str = "has_label" + + pixels_0_column_name: str = "pixel_values_0" + pixels_1_column_name: str = "pixel_values_1" + + timestep_column_name: str = "timestep" + constant_timestep: int = 1 + variable_timestep: bool = False + largest_timestep: int = 751 + + compare_between_timestep: bool = False + timestep_comparison_column_name: str = "timestep_comparison" + timestep_interval: int = 1 + + num_examples_per_prompt_column_name: str = "num_example_per_prompt" + + keep_only_different: bool = False + keep_only_with_label: bool = False + keep_only_with_label_in_non_train: bool = True + keep_only_with_pesudo_preference: bool = False + pseudo_preference_path: str = "" + filter_strategy: int = 1 + processor: ProcessorConfig = field(default_factory=ProcessorConfig) + + limit_examples_per_prompt: int = -1 + + only_on_best: bool = False + + +class StepSanaHFDataset(BaseDataset): + + def __init__(self, cfg: StepSanaHFDatasetConfig, split: str = "train"): + self.cfg = cfg + self.split = split + logger.info(f"Using step-aware datasets") + logger.info(f"Loading {self.split} dataset") + logger.info(f"Batch size is {self.cfg.batch_size}") + + self.dataset = self.load_hf_dataset(self.split) + logger.info(f"Loaded {len(self.dataset)} examples from {self.split} dataset") + + if self.cfg.keep_only_different: + self.dataset = self.dataset.filter(lambda x: x[self.cfg.are_different_column_name]) + + if self.cfg.keep_only_with_label: + logger.info(f"Keeping only examples with label") + self.dataset = self.dataset.filter(lambda x: x[self.cfg.has_label_column_name]) + logger.info(f"Kept {len(self.dataset)} examples from {self.split} dataset") + elif self.cfg.keep_only_with_label_in_non_train and self.split != self.cfg.train_split_name: + logger.info(f"Keeping only examples with label in {self.split} split") + self.dataset = self.dataset.filter(lambda x: x[self.cfg.has_label_column_name]) + logger.info(f"Kept {len(self.dataset)} examples from {self.split} dataset") + + if self.cfg.limit_examples_per_prompt > 0: + logger.info(f"Limiting examples per prompt to {self.cfg.limit_examples_per_prompt}") + df = self.dataset.to_pandas() + df = df.drop('__index_level_0__', axis=1) + logger.info(f"Loaded {len(df)} examples from {self.split} dataset") + df = df.groupby(self.cfg.caption_column_name).head(self.cfg.limit_examples_per_prompt) + logger.info(f"Kept {len(df)} examples from {self.split} dataset") + self.dataset = Dataset.from_pandas(df) + + if self.cfg.only_on_best and self.split == self.cfg.train_split_name: + logger.info(f"Keeping only best examples for training") + train_dataset = self.dataset.remove_columns([self.cfg.image_0_column_name, self.cfg.image_1_column_name]) + df = train_dataset.to_pandas() + df = df[df[self.cfg.has_label_column_name] == 1] + image_0_wins_df = df[df[self.cfg.label_0_column_name] == 1] + image_1_wins_df = df[df[self.cfg.label_0_column_name] == 0] + bad_image_0_to_good_image_1 = dict(zip(image_1_wins_df.image_0_uid, image_1_wins_df.image_1_uid)) + bad_image_1_to_good_image_0 = dict(zip(image_0_wins_df.image_1_uid, image_0_wins_df.image_0_uid)) + bad_images_uids2good_images_uids = bad_image_0_to_good_image_1 | bad_image_1_to_good_image_0 + image_0_uid2image_col_name = dict(zip(df.image_0_uid, [self.cfg.image_0_column_name] * len(df.image_0_uid))) + image_1_uid2image_col_name = dict(zip(df.image_1_uid, [self.cfg.image_1_column_name] * len(df.image_1_uid))) + uid2image_col_name = image_0_uid2image_col_name | image_1_uid2image_col_name + + bad_uids = set() + for bad_image, good_image in bad_images_uids2good_images_uids.items(): + cur_good = {bad_image} + while good_image in bad_images_uids2good_images_uids: + if good_image in cur_good: + bad_uids.add(bad_image) + break + cur_good.add(good_image) + good_image = bad_images_uids2good_images_uids[good_image] + bad_images_uids2good_images_uids[bad_image] = good_image + + df = df[~(df.image_0_uid.isin(bad_uids) | df.image_1_uid.isin(bad_uids))] + keep_ids = df.index.tolist() + self.dataset = self.dataset.select(keep_ids) + new_ids = list(range(len(df))) + uid2index = dict(zip(df.image_0_uid, new_ids)) | dict(zip(df.image_1_uid, new_ids)) + logger.info(f"Kept only {len(self.dataset)} best examples for training") + self.bad_images_uids2good_images_uids = bad_images_uids2good_images_uids + self.uid2index = uid2index + self.uid2image_col_name = uid2image_col_name + + pseudo_preference = None + pseudo_preference_matches_dataset = False + if self.split == self.cfg.train_split_name: + pseudo_path = (cfg.pseudo_preference_path or "").strip() + if pseudo_path and os.path.exists(pseudo_path): + try: + pseudo_preference = pd.read_csv(pseudo_path) + except pd.errors.ParserError as ex: + logger.warning( + f"Pseudo preference CSV has malformed rows, retrying with bad-line skipping: {ex}" + ) + pseudo_preference = pd.read_csv(pseudo_path, engine="python", on_bad_lines="skip") + if len(pseudo_preference) == len(self.dataset): + pseudo_preference_matches_dataset = True + self.dataset = self.dataset.add_column('different_flag', pseudo_preference['different_flag']) + else: + logger.warning( + "Skipping pseudo preference add_column because length mismatch: " + f"dataset={len(self.dataset)} pseudo_preference={len(pseudo_preference)} path={pseudo_path}" + ) + elif pseudo_path: + logger.warning(f"Pseudo preference path does not exist, skipping: {pseudo_path}") + + if self.cfg.compare_between_timestep and self.split == self.cfg.train_split_name: + logger.info(f"Adding timestep comparison column") + self.dataset = self.dataset.add_column(self.cfg.timestep_comparison_column_name, [False] * len(self.dataset)) + + if self.cfg.keep_only_with_pesudo_preference and self.split == self.cfg.train_split_name: + if pseudo_preference is None: + raise ValueError( + "keep_only_with_pesudo_preference=True requires a readable pseudo_preference_path for train split" + ) + if not pseudo_preference_matches_dataset: + logger.warning( + "Skipping keep_only_with_pesudo_preference because pseudo preference length does not " + f"match dataset length for split={self.split}: dataset={len(self.dataset)} " + f"pseudo_preference={len(pseudo_preference)}" + ) + else: + logger.info(f"Keeping only examples with pesudo preference, filter_strategy: {self.cfg.filter_strategy}") + if self.cfg.filter_strategy == 1: + filter_rule = ((pseudo_preference['different_flag']==1) & (pseudo_preference['aesthetic_gap']>0) & (pseudo_preference['clipscore_gap']>0) & (pseudo_preference['vqascore_gap']>0)) | \ + ((pseudo_preference['different_flag']==0) & (pseudo_preference['aesthetic_gap']<0.2) & (pseudo_preference['clipscore_gap']<0.03) & (pseudo_preference['vqascore_gap']<0.07)) + elif self.cfg.filter_strategy == 2: + filter_rule = ((pseudo_preference['different_flag']==1) & (pseudo_preference['aesthetic_gap']>-0.5) & (pseudo_preference['clipscore_gap']>0) & (pseudo_preference['vqascore_gap']>0)) | \ + ((pseudo_preference['different_flag']==0) & (pseudo_preference['aesthetic_gap']<0.2) & (pseudo_preference['clipscore_gap']<0.03) & (pseudo_preference['vqascore_gap']<0.07)) + elif self.cfg.filter_strategy == 3: + filter_rule = ((pseudo_preference['different_flag']==1) & (pseudo_preference['aesthetic_gap']>-1) & (pseudo_preference['clipscore_gap']>0) & (pseudo_preference['vqascore_gap']>0)) | \ + ((pseudo_preference['different_flag']==0) & (pseudo_preference['aesthetic_gap']<0.2) & (pseudo_preference['clipscore_gap']<0.03) & (pseudo_preference['vqascore_gap']<0.07)) + else: + raise ValueError(f"Unknown filter strategy: {self.cfg.filter_strategy}") + + logger.info(f"Loaded {len(self.dataset)} examples from {self.split} dataset") + # select from dataset by filter_rule index + true_indices = pseudo_preference[filter_rule].index.tolist() + self.dataset = self.dataset.select(true_indices, keep_in_memory=True) + + logger.info(f"Kept {len(self.dataset)} examples from {self.split} dataset") + + if self.cfg.compare_between_timestep and self.split == self.cfg.train_split_name: + if pseudo_preference is None: + raise ValueError( + "compare_between_timestep=True for train split requires pseudo_preference_path with different_flag" + ) + assert self.cfg.variable_timestep, "Only support variable timestep for now" + logger.info("Constructing timestep comparison dataset") + + original_dataset = self.load_hf_dataset(self.split) + original_dataset = original_dataset.add_column(self.cfg.timestep_comparison_column_name, [True] * len(original_dataset)) + if self.cfg.keep_only_with_pesudo_preference: + filter_rule = filter_rule & (pseudo_preference['different_flag']==1) + else: + filter_rule = (pseudo_preference['different_flag']==1) + true_indices = pseudo_preference[filter_rule].index.tolist() + comparison_dataset = original_dataset.select(true_indices) + + self.dataset = self.dataset.remove_columns('__index_level_0__') + comparison_dataset = comparison_dataset.remove_columns('__index_level_0__') + + self.dataset = concatenate_datasets([self.dataset, comparison_dataset]) + + logger.info(f"Loaded {len(self.dataset)} examples from {self.split} dataset") + + self.tokenizer = AutoTokenizer.from_pretrained( + cfg.processor.pretrained_model_name_or_path, + subfolder="tokenizer", + ) + self.tokenizer_2 = None + try: + self.tokenizer_2 = AutoTokenizer.from_pretrained( + cfg.processor.pretrained_model_name_or_path, + subfolder="tokenizer_2", + ) + except Exception: + self.tokenizer_2 = None + + self.max_length = self._resolve_max_length(self.tokenizer, cfg.processor.max_sequence_length) + if self.tokenizer_2 is not None: + self.max_length_2 = self._resolve_max_length(self.tokenizer_2, cfg.processor.max_sequence_length_2) + else: + self.max_length_2 = self.max_length + self.image_transform = transforms.Compose( + [ + transforms.Resize((cfg.processor.image_size, cfg.processor.image_size), interpolation=transforms.InterpolationMode.BILINEAR), + transforms.RandomCrop(cfg.processor.image_size) if cfg.processor.random_crop else transforms.CenterCrop(cfg.processor.image_size), + transforms.Lambda(lambda x: x) if cfg.processor.no_hflip else transforms.RandomHorizontalFlip(), + transforms.ToTensor(), + transforms.Normalize([0.5], [0.5]), + ] + ) + self.candidate_timesteps = torch.tensor(list(range(1, self.cfg.largest_timestep+1, 50)), dtype=torch.long) + + @staticmethod + def _resolve_max_length(tokenizer, requested_max_length: int) -> int: + model_max_length = getattr(tokenizer, "model_max_length", None) + if model_max_length is None: + return requested_max_length + if model_max_length > 100000: + return requested_max_length + return min(requested_max_length, model_max_length) + + def load_hf_dataset(self, split: str) -> Dataset: + if self.cfg.from_disk: + dataset = load_from_disk(self.cfg.dataset_name)[split] + else: + offline_mode = os.getenv("HF_HUB_OFFLINE", "0").strip().lower() in {"1", "true", "yes", "on"} + if offline_mode: + cached_dataset = self._load_cached_dataset_from_hub(split) + if cached_dataset is not None: + return cached_dataset + dataset = load_dataset( + self.cfg.dataset_name, + # self.cfg.dataset_config_name, + cache_dir=self.cfg.cache_dir, + split=split + ) + return dataset + + def _load_cached_dataset_from_hub(self, split: str): + if "/" not in self.cfg.dataset_name: + return None + + hub_cache_dir = os.getenv("HF_HUB_CACHE") or os.getenv("HUGGINGFACE_HUB_CACHE") + if not hub_cache_dir: + return None + + org, name = self.cfg.dataset_name.split("/", 1) + repo_cache_dir = os.path.join(hub_cache_dir, f"datasets--{org}--{name}") + if not os.path.isdir(repo_cache_dir): + return None + + snapshot_dir = None + ref_main = os.path.join(repo_cache_dir, "refs", "main") + if os.path.isfile(ref_main): + revision = open(ref_main, "r", encoding="utf-8").read().strip() + candidate = os.path.join(repo_cache_dir, "snapshots", revision) + if os.path.isdir(candidate): + snapshot_dir = candidate + + if snapshot_dir is None: + snapshots = sorted(glob(os.path.join(repo_cache_dir, "snapshots", "*"))) + if snapshots: + snapshot_dir = snapshots[-1] + + if snapshot_dir is None: + return None + + data_dir = os.path.join(snapshot_dir, "data") + if not os.path.isdir(data_dir): + return None + + selected_split = split + parquet_files = sorted(glob(os.path.join(data_dir, f"{selected_split}-*.parquet"))) + if not parquet_files and split.startswith("validation"): + for alt_split in ("test_unique", "test"): + alt_files = sorted(glob(os.path.join(data_dir, f"{alt_split}-*.parquet"))) + if alt_files: + selected_split = alt_split + parquet_files = alt_files + logger.warning( + f"Offline cache missing split '{split}', falling back to '{selected_split}'" + ) + break + + if not parquet_files: + return None + + logger.info( + f"Loading cached offline split '{selected_split}' from {len(parquet_files)} parquet shards" + ) + return load_dataset("parquet", data_files=parquet_files, split="train") + + def tokenize(self, example): + caption = example[self.cfg.caption_column_name] + input_ids = self.tokenizer( + caption, + max_length=self.max_length, + padding="max_length", + truncation=True, + add_special_tokens=True, + return_tensors="pt" + ).input_ids + if self.tokenizer_2 is not None: + input_ids_2 = self.tokenizer_2( + caption, + max_length=self.max_length_2, + padding="max_length", + truncation=True, + add_special_tokens=True, + return_tensors="pt" + ).input_ids + else: + input_ids_2 = input_ids.clone() + return input_ids, input_ids_2 + + def process_image(self, image): + if isinstance(image, dict): + image = image["bytes"] + if isinstance(image, bytes): + image = Image.open(BytesIO(image)) + image = image.convert("RGB") + pixel_values = self.image_transform(image).unsqueeze(0) + return pixel_values + + def __getitem__(self, idx): + example = self.dataset[idx] + + if self.cfg.only_on_best and self.split == self.cfg.train_split_name: + if example[self.cfg.label_0_column_name]: + bad_image_uid = example["image_1_uid"] + good_image_column_name = self.cfg.image_0_column_name + else: + bad_image_uid = example["image_0_uid"] + good_image_column_name = self.cfg.image_1_column_name + good_image_uid = self.bad_images_uids2good_images_uids[bad_image_uid] + good_image_index = self.uid2index[good_image_uid] + example[good_image_column_name] = self.dataset[good_image_index][self.uid2image_col_name[good_image_uid]] + + input_ids, input_ids_2 = self.tokenize(example) + + if self.split == self.cfg.train_split_name and self.cfg.compare_between_timestep and example[self.cfg.timestep_comparison_column_name]: + if example[self.cfg.label_0_column_name] == 1: + pixel_0_values = self.process_image(example[self.cfg.image_0_column_name]) + pixel_1_values = pixel_0_values.clone() + elif example[self.cfg.label_1_column_name] == 1: + pixel_0_values = self.process_image(example[self.cfg.image_1_column_name]) + pixel_1_values = pixel_0_values.clone() + else: + raise ValueError(f"No good image found for {idx} sample") + + index = torch.randint(0, len(self.candidate_timesteps), (1,)).item() + if index < self.cfg.timestep_interval: + next_index = index + self.cfg.timestep_interval + elif index >= len(self.candidate_timesteps) - self.cfg.timestep_interval: + next_index = index - self.cfg.timestep_interval + else: + if torch.rand(1).item() > 0.5: + next_index = index + self.cfg.timestep_interval + else: + next_index = index - self.cfg.timestep_interval + + if next_index > index: + label0 = torch.tensor([1]) + label1 = torch.tensor([0]) + else: + label0 = torch.tensor([0]) + label1 = torch.tensor([1]) + + item_timestep = self.candidate_timesteps[index].view(1,) + next_item_timestep = self.candidate_timesteps[next_index].view(1,) + item_timestep = torch.concat([item_timestep, next_item_timestep]) + item = { + self.cfg.input_ids_column_name: input_ids, + self.cfg.input_ids_2_column_name: input_ids_2, + self.cfg.pixels_0_column_name: pixel_0_values, + self.cfg.pixels_1_column_name: pixel_1_values, + self.cfg.label_0_column_name: label0, + self.cfg.label_1_column_name: label1, + self.cfg.num_examples_per_prompt_column_name: torch.tensor(example[self.cfg.num_examples_per_prompt_column_name])[None], + self.cfg.timestep_column_name: item_timestep + } + + else: + pixel_0_values = self.process_image(example[self.cfg.image_0_column_name]) + pixel_1_values = self.process_image(example[self.cfg.image_1_column_name]) + + if self.cfg.variable_timestep: + if self.split == self.cfg.train_split_name: + item_timestep = self.candidate_timesteps[torch.randint(0, len(self.candidate_timesteps), (1,)).item()].view(1,) + else: + item_timestep = torch.tensor([1], dtype=torch.long) + else: + item_timestep = torch.tensor([self.cfg.constant_timestep], dtype=torch.long) + item_timestep = torch.concat([item_timestep, item_timestep]) + item = { + self.cfg.input_ids_column_name: input_ids, + self.cfg.input_ids_2_column_name: input_ids_2, + self.cfg.pixels_0_column_name: pixel_0_values, + self.cfg.pixels_1_column_name: pixel_1_values, + self.cfg.label_0_column_name: torch.tensor(example[self.cfg.label_0_column_name])[None], + self.cfg.label_1_column_name: torch.tensor(example[self.cfg.label_1_column_name])[None], + self.cfg.num_examples_per_prompt_column_name: torch.tensor(example[self.cfg.num_examples_per_prompt_column_name])[None], + self.cfg.timestep_column_name: item_timestep + } + return item + + def collate_fn(self, batch): + input_ids = simple_collate(batch, self.cfg.input_ids_column_name) + input_ids_2 = simple_collate(batch, self.cfg.input_ids_2_column_name) + pixel_0_values = simple_collate(batch, self.cfg.pixels_0_column_name) + pixel_1_values = simple_collate(batch, self.cfg.pixels_1_column_name) + label_0 = simple_collate(batch, self.cfg.label_0_column_name) + label_1 = simple_collate(batch, self.cfg.label_1_column_name) + num_examples_per_prompt = simple_collate(batch, self.cfg.num_examples_per_prompt_column_name) + timestep = simple_collate(batch, self.cfg.timestep_column_name) + + pixel_0_values = pixel_0_values.to(memory_format=torch.contiguous_format).float() + pixel_1_values = pixel_1_values.to(memory_format=torch.contiguous_format).float() + + collated = { + self.cfg.input_ids_column_name: input_ids, + self.cfg.input_ids_2_column_name: input_ids_2, + self.cfg.pixels_0_column_name: pixel_0_values, + self.cfg.pixels_1_column_name: pixel_1_values, + self.cfg.label_0_column_name: label_0, + self.cfg.label_1_column_name: label_1, + self.cfg.num_examples_per_prompt_column_name: num_examples_per_prompt, + self.cfg.timestep_column_name: timestep, + } + return collated + + def __len__(self): + return len(self.dataset) \ No newline at end of file diff --git a/lrm/lrm_sana/trainer/lr_schedulers/__pycache__/constant_with_warmup.cpython-310.pyc b/lrm/lrm_sana/trainer/lr_schedulers/__pycache__/constant_with_warmup.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..3574e1b0381b9b08c0fec7ae1b138bad0afd8ea5 Binary files /dev/null and b/lrm/lrm_sana/trainer/lr_schedulers/__pycache__/constant_with_warmup.cpython-310.pyc differ diff --git a/lrm/lrm_sana/trainer/lr_schedulers/__pycache__/constant_with_warmup.cpython-311.pyc b/lrm/lrm_sana/trainer/lr_schedulers/__pycache__/constant_with_warmup.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5f2258eda38ef3951cf86d286b3deb8aadcb19b6 Binary files /dev/null and b/lrm/lrm_sana/trainer/lr_schedulers/__pycache__/constant_with_warmup.cpython-311.pyc differ diff --git a/lrm/lrm_sana/trainer/lr_schedulers/__pycache__/dummy_lr_scheduler.cpython-311.pyc b/lrm/lrm_sana/trainer/lr_schedulers/__pycache__/dummy_lr_scheduler.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ee3f1a6ffefc93bc7c6d80a1a7afff903f6e4180 Binary files /dev/null and b/lrm/lrm_sana/trainer/lr_schedulers/__pycache__/dummy_lr_scheduler.cpython-311.pyc differ diff --git a/lrm/lrm_sana/trainer/models/__pycache__/flux_preference_model.cpython-310.pyc b/lrm/lrm_sana/trainer/models/__pycache__/flux_preference_model.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..91531a75eaeaef8479c8a0462edf260c4442107e Binary files /dev/null and b/lrm/lrm_sana/trainer/models/__pycache__/flux_preference_model.cpython-310.pyc differ diff --git a/lrm/lrm_sana/trainer/models/__pycache__/sana_preference_model.cpython-311.pyc b/lrm/lrm_sana/trainer/models/__pycache__/sana_preference_model.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..2ae68eae12f7631de56ba6e3db05a370693fc7b8 Binary files /dev/null and b/lrm/lrm_sana/trainer/models/__pycache__/sana_preference_model.cpython-311.pyc differ diff --git a/lrm/lrm_sana/trainer/models/__pycache__/unet_2d_condition_reward.cpython-310.pyc b/lrm/lrm_sana/trainer/models/__pycache__/unet_2d_condition_reward.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..cba8b25140672975a81190659ac0c5c3bbfcc8c7 Binary files /dev/null and b/lrm/lrm_sana/trainer/models/__pycache__/unet_2d_condition_reward.cpython-310.pyc differ diff --git a/lrm/lrm_sana/trainer/optimizers/__init__.py b/lrm/lrm_sana/trainer/optimizers/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..5bccdea3f2f8804ebbc15a40734ba279b0787a93 --- /dev/null +++ b/lrm/lrm_sana/trainer/optimizers/__init__.py @@ -0,0 +1,8 @@ +from hydra.core.config_store import ConfigStore + +from trainer.optimizers.adamw import AdamWOptimizerConfig +from trainer.optimizers.dummy_optimizer import DummyOptimizerConfig + +cs = ConfigStore.instance() +cs.store(group="optimizer", name="dummy", node=DummyOptimizerConfig) +cs.store(group="optimizer", name="adamw", node=AdamWOptimizerConfig) diff --git a/lrm/lrm_sana/trainer/optimizers/__pycache__/__init__.cpython-310.pyc b/lrm/lrm_sana/trainer/optimizers/__pycache__/__init__.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..67f4501b40d75c2903e8862aeb650d1173909391 Binary files /dev/null and b/lrm/lrm_sana/trainer/optimizers/__pycache__/__init__.cpython-310.pyc differ diff --git a/lrm/lrm_sana/trainer/optimizers/__pycache__/__init__.cpython-311.pyc b/lrm/lrm_sana/trainer/optimizers/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..44f299f3c99ae8325e477cace430c84c156039bf Binary files /dev/null and b/lrm/lrm_sana/trainer/optimizers/__pycache__/__init__.cpython-311.pyc differ diff --git a/lrm/lrm_sana/trainer/optimizers/__pycache__/adamw.cpython-310.pyc b/lrm/lrm_sana/trainer/optimizers/__pycache__/adamw.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6868f5afbdf4ad38512c98a028d503677d0ecef6 Binary files /dev/null and b/lrm/lrm_sana/trainer/optimizers/__pycache__/adamw.cpython-310.pyc differ diff --git a/lrm/lrm_sana/trainer/optimizers/__pycache__/adamw.cpython-311.pyc b/lrm/lrm_sana/trainer/optimizers/__pycache__/adamw.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..761ea78ad0ec4e5d5f8873e9a38e841a9273316b Binary files /dev/null and b/lrm/lrm_sana/trainer/optimizers/__pycache__/adamw.cpython-311.pyc differ diff --git a/lrm/lrm_sana/trainer/optimizers/__pycache__/dummy_optimizer.cpython-310.pyc b/lrm/lrm_sana/trainer/optimizers/__pycache__/dummy_optimizer.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e5925e73b8d98a678159aedbe2ff508c4d7f1b18 Binary files /dev/null and b/lrm/lrm_sana/trainer/optimizers/__pycache__/dummy_optimizer.cpython-310.pyc differ diff --git a/lrm/lrm_sana/trainer/optimizers/__pycache__/dummy_optimizer.cpython-311.pyc b/lrm/lrm_sana/trainer/optimizers/__pycache__/dummy_optimizer.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0f5812cb2d5538b44239a6d33b14074adb845388 Binary files /dev/null and b/lrm/lrm_sana/trainer/optimizers/__pycache__/dummy_optimizer.cpython-311.pyc differ diff --git a/lrm/lrm_sana/trainer/optimizers/adamw.py b/lrm/lrm_sana/trainer/optimizers/adamw.py new file mode 100644 index 0000000000000000000000000000000000000000..a8d8daf9fbf79c13951008e9c07d78ae44592de3 --- /dev/null +++ b/lrm/lrm_sana/trainer/optimizers/adamw.py @@ -0,0 +1,16 @@ +from dataclasses import dataclass + +import torch + + +class BaseAdamW(torch.optim.AdamW): + def __init__(self, model, **kwargs): + params = [p for p in model.parameters() if p.requires_grad] + super().__init__(params=params, **kwargs) + + +@dataclass +class AdamWOptimizerConfig: + _target_: str = "trainer.optimizers.adamw.BaseAdamW" + lr: float = 1e-6 + diff --git a/lrm/lrm_sana/trainer/optimizers/dummy_optimizer.py b/lrm/lrm_sana/trainer/optimizers/dummy_optimizer.py new file mode 100644 index 0000000000000000000000000000000000000000..1c6bf99782e46abd20b4cbe5e7251050d1a4a734 --- /dev/null +++ b/lrm/lrm_sana/trainer/optimizers/dummy_optimizer.py @@ -0,0 +1,21 @@ +from dataclasses import dataclass + +try: + from accelerate.utils import DummyOptim +except ImportError: + from accelerate.utils.deepspeed import DummyOptim + + +@dataclass +class DummyOptimizerConfig: + _target_: str = "trainer.optimizers.dummy_optimizer.BaseDummyOptim" + lr: float = 3e-6 + weight_decay: float = 0.3 + + +class BaseDummyOptim(DummyOptim): + def __init__(self, model, lr=0.001, weight_decay=0, **kwargs): + self.params = [p for p in model.parameters() if p.requires_grad] + self.lr = lr + self.weight_decay = weight_decay + self.kwargs = kwargs diff --git a/lrm/lrm_sana/trainer/scripts/__pycache__/train.cpython-310.pyc b/lrm/lrm_sana/trainer/scripts/__pycache__/train.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a6f9c35299f780477473ff65c1bf83b7b38452b0 Binary files /dev/null and b/lrm/lrm_sana/trainer/scripts/__pycache__/train.cpython-310.pyc differ diff --git a/lrm/lrm_sana/trainer/scripts/train.py b/lrm/lrm_sana/trainer/scripts/train.py new file mode 100644 index 0000000000000000000000000000000000000000..a41454deea33813017635651bedeba0d49618c10 --- /dev/null +++ b/lrm/lrm_sana/trainer/scripts/train.py @@ -0,0 +1,244 @@ +import json +import os +import sys +from typing import Any +from pathlib import Path + +import hydra +import torch +from hydra.utils import instantiate +from accelerate.logging import get_logger +from omegaconf import DictConfig, OmegaConf +from torch import nn +import time +from datasets import load_dataset, concatenate_datasets +from torch.utils.data import Dataset + +_PACKAGE_ROOT = Path(__file__).resolve().parents[2] +if str(_PACKAGE_ROOT) not in sys.path: + sys.path.insert(0, str(_PACKAGE_ROOT)) + +from trainer.accelerators.base_accelerator import BaseAccelerator +from trainer.configs.configs import TrainerConfig, instantiate_with_cfg + + +logger = get_logger(__name__) + +os.environ["TOKENIZERS_PARALLELISM"] = "false" + +if torch.cuda.is_available(): + # Prefer math attention for stability on large Flux training runs. + try: + torch.backends.cuda.enable_flash_sdp(False) + torch.backends.cuda.enable_mem_efficient_sdp(False) + torch.backends.cuda.enable_math_sdp(True) + print("[train.py] Disabled flash/mem-efficient SDP kernels; using math SDP backend.") + except Exception as ex: + print(f"[train.py] Could not configure SDP backend flags: {ex}") + + +def _unwrap_model(model: nn.Module) -> nn.Module: + return model.module if hasattr(model, "module") else model + + +def _get_logit_scale_metric(model: nn.Module) -> dict[str, float]: + model_ref = _unwrap_model(model) + logit_scale = getattr(model_ref, "logit_scale", None) + # In ZeRO-3, some ranks can hold empty shards for this scalar parameter. + if not isinstance(logit_scale, torch.Tensor) or logit_scale.numel() == 0: + return {} + return {"logit_scale": logit_scale.detach().float().exp().item()} + + +def load_dataloaders(cfg: DictConfig) -> Any: + dataloaders = {} + for split in [cfg.train_split_name, cfg.valid_split_name, cfg.test_split_name]: + dataset = instantiate_with_cfg(cfg, split=split) + should_shuffle = split == cfg.train_split_name + dataloaders[split] = torch.utils.data.DataLoader( + dataset, + shuffle=should_shuffle, + batch_size=cfg.batch_size, + collate_fn=dataset.collate_fn, + num_workers=cfg.num_workers + ) + return dataloaders + + +def load_optimizer(cfg: DictConfig, model: nn.Module): + try: + return instantiate(cfg, model=model) + except TypeError as ex: + # Some optimizer targets (e.g. torch.optim.AdamW) expect `params`, + # while custom wrappers in this repo expect `model`. + if "unexpected keyword argument 'model'" not in str(ex): + raise + model_ref = _unwrap_model(model) + params = [p for p in model_ref.parameters() if p.requires_grad] + return instantiate(cfg, params=params) + + +def load_scheduler(cfg: DictConfig, optimizer): + scheduler = instantiate_with_cfg(cfg, optimizer=optimizer) + return scheduler + + +def load_task(cfg: DictConfig, accelerator: BaseAccelerator): + task = instantiate_with_cfg(cfg, accelerator=accelerator) + return task + + +def verify_or_write_config(cfg: TrainerConfig): + os.makedirs(cfg.output_dir, exist_ok=True) + yaml_path = os.path.join(cfg.output_dir, "config.yaml") + if not os.path.exists(yaml_path): + OmegaConf.save(cfg, yaml_path, resolve=True) + with open(yaml_path) as f: + existing_config = f.read() + # if existing_config != OmegaConf.to_yaml(cfg, resolve=True): + # raise ValueError(f"Config was not saved correctly - {yaml_path}") + logger.info(f"Config can be found in {yaml_path}") + + +@hydra.main(version_base=None, config_path="../conf", config_name="config") +def main(cfg: TrainerConfig) -> None: + accelerator = instantiate_with_cfg(cfg.accelerator) + + if cfg.debug.activate and accelerator.is_main_process: + import pydevd_pycharm + pydevd_pycharm.settrace('localhost', port=cfg.debug.port, stdoutToServer=True, stderrToServer=True) + + if accelerator.is_main_process: + verify_or_write_config(cfg) + logger.info(f"Loading task") + task = load_task(cfg.task, accelerator) + logger.info(f"Loading model") + model = instantiate_with_cfg(cfg.model) + + use_data_parallel = os.environ.get("USE_DATA_PARALLEL", "0") == "1" + if use_data_parallel and torch.cuda.is_available() and torch.cuda.device_count() > 1: + logger.info(f"Using torch.nn.DataParallel with {torch.cuda.device_count()} GPUs") + model = nn.DataParallel(model) + + logger.info(f"Loading criterion") + criterion = instantiate_with_cfg(cfg.criterion) + logger.info(f"Loading optimizer") + optimizer = load_optimizer(cfg.optimizer, model) + logger.info(f"Loading lr scheduler") + lr_scheduler = load_scheduler(cfg.lr_scheduler, optimizer) + logger.info(f"Loading dataloaders") + split2dataloader = load_dataloaders(cfg.dataset) # train, val, test + + dataloaders = list(split2dataloader.values()) + + + model, optimizer, lr_scheduler, *dataloaders = accelerator.prepare(model, optimizer, lr_scheduler, *dataloaders) + + split2dataloader = dict(zip(split2dataloader.keys(), dataloaders)) + + accelerator.load_state_if_needed() + + accelerator.recalc_train_length_after_prepare(len(split2dataloader[cfg.dataset.train_split_name])) + + accelerator.init_training(cfg) + + def evaluate(trigger: str): + model.eval() + logger.info("========== EVAL START (%s) ==========" % trigger) + logger.info(f"*** Evaluating {cfg.dataset.valid_split_name} ***") + metrics = task.evaluate(model, criterion, split2dataloader[cfg.dataset.valid_split_name]) + accelerator.update_metrics(metrics) + + logger.info(f"*** Evaluating {cfg.dataset.test_split_name} ***") + metrics = task.evaluate(model, criterion, split2dataloader[cfg.dataset.test_split_name]) + metrics = {f"{cfg.dataset.test_split_name}_{k}": v for k, v in metrics.items()} + accelerator.update_metrics(metrics) + logger.info("========== EVAL END (%s) ==========" % trigger) + + + logger.info(f"task: {task.__class__.__name__}") + logger.info(f"model: {model.__class__.__name__}") + logger.info(f"num. model params: {int(sum(p.numel() for p in model.parameters()) // 1e6)}M") + logger.info( + f"num. model trainable params: {int(sum(p.numel() for p in model.parameters() if p.requires_grad) // 1e6)}M") + logger.info(f"criterion: {criterion.__class__.__name__}") + logger.info(f"num. train examples: {len(split2dataloader[cfg.dataset.train_split_name].dataset)}") + logger.info(f"num. valid examples: {len(split2dataloader[cfg.dataset.valid_split_name].dataset)}") + logger.info(f"num. test examples: {len(split2dataloader[cfg.dataset.test_split_name].dataset)}") + + metrics = _get_logit_scale_metric(model) + if metrics: + accelerator.update_metrics(metrics) + + logger.info( + "========== TRAIN LOOP START (eval_on_start=%s, validate_steps=%s, progress_log_interval=%s) ==========", + accelerator.cfg.eval_on_start, + accelerator.cfg.validate_steps, + getattr(accelerator.cfg, "progress_log_interval", "n/a"), + ) + + for epoch in range(accelerator.cfg.num_epochs): + train_loss, lr = 0.0, 0.0 + for step, batch in enumerate(split2dataloader[cfg.dataset.train_split_name]): + if accelerator.should_skip(epoch, step): + accelerator.update_progbar_step() + continue + + if accelerator.should_eval(): + trigger = "initial" if accelerator.global_step == 0 else f"periodic@gstep={accelerator.global_step}" + evaluate(trigger) + metrics = _get_logit_scale_metric(model) + if metrics: + accelerator.update_metrics(metrics) + + + if accelerator.should_save(): + accelerator.save_checkpoint() + + model.train() + + with accelerator.accumulate(model): + loss = task.train_step(model, criterion, batch) + avg_loss = accelerator.gather(loss).mean().item() + + accelerator.backward(loss) + + if accelerator.sync_gradients: + accelerator.clip_grad_norm_(model.parameters()) + + optimizer.step() + lr_scheduler.step() + optimizer.zero_grad() + + + train_loss += avg_loss / accelerator.cfg.gradient_accumulation_steps + + if accelerator.sync_gradients: + accelerator.update_global_step(train_loss) + train_loss = 0.0 + + if accelerator.global_step > 1: + lr = lr_scheduler.get_last_lr()[0] + + accelerator.update_step(avg_loss, lr) + + if accelerator.should_end(): + evaluate(f"final@gstep={accelerator.global_step}") + metrics = _get_logit_scale_metric(model) + if metrics: + accelerator.update_metrics(metrics) + accelerator.save_checkpoint() + break + + if accelerator.should_end(): + break + + accelerator.update_epoch() + + accelerator.wait_for_everyone() + accelerator.unwrap_and_save(model) + accelerator.end_training() + + +if __name__ == '__main__': + main() diff --git a/lrm/lrm_sana/trainer/utils/FID/__pycache__/__init__.cpython-310.pyc b/lrm/lrm_sana/trainer/utils/FID/__pycache__/__init__.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8dc3601f50c12a33d72bd01c9874ac3419dbf415 Binary files /dev/null and b/lrm/lrm_sana/trainer/utils/FID/__pycache__/__init__.cpython-310.pyc differ diff --git a/lrm/lrm_sana/trainer/utils/FID/__pycache__/fid_score.cpython-310.pyc b/lrm/lrm_sana/trainer/utils/FID/__pycache__/fid_score.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c17c081c6ba2492a8089c2cb58f7b65dfdc34958 Binary files /dev/null and b/lrm/lrm_sana/trainer/utils/FID/__pycache__/fid_score.cpython-310.pyc differ diff --git a/lrm/lrm_sana/trainer/utils/FID/__pycache__/img_data.cpython-310.pyc b/lrm/lrm_sana/trainer/utils/FID/__pycache__/img_data.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..fc067480a54d3a6c7356868e639cf5090e6cdc45 Binary files /dev/null and b/lrm/lrm_sana/trainer/utils/FID/__pycache__/img_data.cpython-310.pyc differ diff --git a/lrm/lrm_sana/trainer/utils/FID/fid_score.py b/lrm/lrm_sana/trainer/utils/FID/fid_score.py new file mode 100644 index 0000000000000000000000000000000000000000..da83e0d93dc4c1233ecc3161169fb8af488b0711 --- /dev/null +++ b/lrm/lrm_sana/trainer/utils/FID/fid_score.py @@ -0,0 +1,276 @@ +#!/usr/bin/env python3 +""" +Ported from https://github.com/MinfengZhu/DM-GAN/blob/master/eval/FID/fid_score.py + +Calculates the Frechet Inception Distance (FID) to evalulate GANs + +The FID metric calculates the distance between two distributions of images. +Typically, we have summary statistics (mean & covariance matrix) of one +of these distributions, while the 2nd distribution is given by a GAN. +When run as a stand-alone program, it compares the distribution of +images that are stored as PNG/JPEG at a specified location with a +distribution given by summary statistics (in pickle format). +The FID is calculated by assuming that X_1 and X_2 are the activations of +the pool_3 layer of the inception net for generated samples and real world +samples respectivly. +See --help to see further details. +Code apapted from https://github.com/bioinf-jku/TTUR to use PyTorch instead +of Tensorflow +Copyright 2018 Institute of Bioinformatics, JKU Linz +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 os +import pathlib +from argparse import ArgumentParser, ArgumentDefaultsHelpFormatter +from glob import glob + +import torch +import numpy as np +from PIL import Image +from datasets import load_from_disk, concatenate_datasets + +try: + from torchvision.transforms import InterpolationMode + BICUBIC = InterpolationMode.BICUBIC +except ImportError: + BICUBIC = Image.BICUBIC + +from imageio import imread +from scipy import linalg +from torch.autograd import Variable +from torch.nn.functional import adaptive_avg_pool2d +import torchvision.transforms as transforms +import torch.utils.data +from PIL import Image +from torch.utils import data +from trainer.utils.FID.inception import InceptionV3 +import trainer.utils.FID.img_data as img_data + +parser = ArgumentParser(formatter_class=ArgumentDefaultsHelpFormatter) +#parser.add_argument('path', type=str, nargs=2, +# help=('Path to the generated images or ' +# 'to .npz statistic files')) +parser.add_argument('--batch-size', type=int, default=64, + help='Batch size to use') +parser.add_argument('--dims', type=int, default=2048, + choices=list(InceptionV3.BLOCK_INDEX_BY_DIM), + help=('Dimensionality of Inception features to use. ' + 'By default, uses pool3 features')) +parser.add_argument('-c', '--gpu', default='', type=str, + help='GPU to use (leave blank for CPU only)') +parser.add_argument('--path1', type=str, default=64) +parser.add_argument('--path2', type=str, default=64) + +def get_activations(images, model, batch_size=64, dims=2048, cuda=False, verbose=True): + """Calculates the activations of the pool_3 layer for all images. + Params: + -- images : Numpy array of dimension (n_images, 3, hi, wi). The values + must lie between 0 and 1. + -- model : Instance of inception model + -- batch_size : the images numpy array is split into batches with + batch size batch_size. A reasonable batch size depends + on the hardware. + -- dims : Dimensionality of features returned by Inception + -- cuda : If set to True, use GPU + -- verbose : If set to True and parameter out_step is given, the number + of calculated batches is reported. + Returns: + -- A numpy array of dimension (num images, dims) that contains the + activations of the given tensor when feeding inception with the + query tensor. + """ + model.eval() + + #d0 = images.shape[0] + + d0 = images.__len__() * batch_size + if batch_size > d0: + print(('Warning: batch size is bigger than the data size. ' + 'Setting batch size to data size')) + batch_size = d0 + + n_batches = d0 // batch_size + n_used_imgs = n_batches * batch_size + + pred_arr = np.empty((n_used_imgs, dims)) + #for i in range(n_batches): + for i, batch in enumerate(images): + #batch = batch[0] + #if verbose: + #print('\rPropagating batch %d/%d' % (i + 1, n_batches), end='', flush=True) + #import ipdb + #ipdb.set_trace() + start = i * batch_size + end = start + batch_size + + #batch = torch.from_numpy(images[start:end]).type(torch.FloatTensor) + #batch = Variable(batch, volatile=True) + + if cuda: + batch = batch.cuda() + + pred = model(batch)[0] + + # If model output is not scalar, apply global spatial average pooling. + # This happens if you choose a dimensionality not equal 2048. + if pred.shape[2] != 1 or pred.shape[3] != 1: + pred = adaptive_avg_pool2d(pred, output_size=(1, 1)) + + pred_arr[start:end] = pred.cpu().data.numpy().reshape(batch_size, -1) + + if verbose: + print(' done') + + return pred_arr + + +def calculate_frechet_distance(mu1, sigma1, mu2, sigma2, eps=1e-6): + """Numpy implementation of the Frechet Distance. + The Frechet distance between two multivariate Gaussians X_1 ~ N(mu_1, C_1) + and X_2 ~ N(mu_2, C_2) is + d^2 = ||mu_1 - mu_2||^2 + Tr(C_1 + C_2 - 2*sqrt(C_1*C_2)). + Stable version by Dougal J. Sutherland. + Params: + -- mu1 : Numpy array containing the activations of a layer of the + inception net (like returned by the function 'get_predictions') + for generated samples. + -- mu2 : The sample mean over activations, precalculated on an + representive data set. + -- sigma1: The covariance matrix over activations for generated samples. + -- sigma2: The covariance matrix over activations, precalculated on an + representive data set. + Returns: + -- : The Frechet Distance. + """ + + mu1 = np.atleast_1d(mu1) + mu2 = np.atleast_1d(mu2) + + sigma1 = np.atleast_2d(sigma1) + sigma2 = np.atleast_2d(sigma2) + + assert mu1.shape == mu2.shape, \ + 'Training and test mean vectors have different lengths' + assert sigma1.shape == sigma2.shape, \ + 'Training and test covariances have different dimensions' + + diff = mu1 - mu2 + + # Product might be almost singular + covmean, _ = linalg.sqrtm(sigma1.dot(sigma2), disp=False) + if not np.isfinite(covmean).all(): + msg = ('fid calculation produces singular product; ' + 'adding %s to diagonal of cov estimates') % eps + print(msg) + offset = np.eye(sigma1.shape[0]) * eps + covmean = linalg.sqrtm((sigma1 + offset).dot(sigma2 + offset)) + + # Numerical error might give slight imaginary component + if np.iscomplexobj(covmean): + if not np.allclose(np.diagonal(covmean).imag, 0, atol=1e-3): + m = np.max(np.abs(covmean.imag)) + raise ValueError('Imaginary component {}'.format(m)) + covmean = covmean.real + + tr_covmean = np.trace(covmean) + + return (diff.dot(diff) + np.trace(sigma1) + + np.trace(sigma2) - 2 * tr_covmean) + + +def calculate_activation_statistics(images, model, batch_size=64, + dims=2048, cuda=False, verbose=True): + """Calculation of the statistics used by the FID. + Params: + -- images : Numpy array of dimension (n_images, 3, hi, wi). The values + must lie between 0 and 1. + -- model : Instance of inception model + -- batch_size : The images numpy array is split into batches with + batch size batch_size. A reasonable batch size + depends on the hardware. + -- dims : Dimensionality of features returned by Inception + -- cuda : If set to True, use GPU + -- verbose : If set to True and parameter out_step is given, the + number of calculated batches is reported. + Returns: + -- mu : The mean over samples of the activations of the pool_3 layer of + the inception model. + -- sigma : The covariance matrix of the activations of the pool_3 layer of + the inception model. + """ + act = get_activations(images, model, batch_size, dims, cuda, verbose) + mu = np.mean(act, axis=0) + sigma = np.cov(act, rowvar=False) + return mu, sigma + +def _compute_statistics_of_path(path, model, batch_size, dims, cuda): + if path.endswith('.npz'): + f = np.load(path) + m, s = f['mu'][:], f['sigma'][:] + f.close() + + else: + dataset_transforms = transforms.Compose([ + transforms.Resize(256, interpolation=BICUBIC), + transforms.CenterCrop(256), + transforms.Resize((299, 299)), + transforms.ToTensor(), + ]) + if path.endswith('*'): + dataset = concatenate_datasets([load_from_disk(ds_path) for ds_path in glob(path)]) + dataset = img_data.HFImgDataset(dataset, dataset_transforms) + else: + dataset = img_data.Dataset(path, dataset_transforms) + print(dataset.__len__()) + dataloader = torch.utils.data.DataLoader(dataset=dataset, batch_size=batch_size, shuffle=False, drop_last=True, num_workers=8) + m, s = calculate_activation_statistics(dataloader, model, batch_size, dims, cuda) + return m, s + +def calculate_fid_given_paths(paths, batch_size, cuda, dims): + """Calculates the FID of two paths""" + for p in paths: + if not os.path.exists(p) and "*" not in p: + raise RuntimeError('Invalid path: %s' % p) + + block_idx = InceptionV3.BLOCK_INDEX_BY_DIM[dims] + + model = InceptionV3([block_idx]) + if cuda: + model.cuda() + + m1, s1 = _compute_statistics_of_path(paths[0], model, batch_size, dims, cuda) + m2, s2 = _compute_statistics_of_path(paths[1], model, batch_size, dims, cuda) + fid_value = calculate_frechet_distance(m1, s1, m2, s2) + return fid_value + +@torch.no_grad() +def image2pred(model, batch): + model.eval() + pred = model(batch)[0] + + # If model output is not scalar, apply global spatial average pooling. + # This happens if you choose a dimensionality not equal 2048. + if pred.shape[2] != 1 or pred.shape[3] != 1: + pred = adaptive_avg_pool2d(pred, output_size=(1, 1)) + + pred = pred.data.view(batch.size(0), -1) + + return pred + +if __name__ == '__main__': + args = parser.parse_args() + os.environ['CUDA_VISIBLE_DEVICES'] = args.gpu + paths = ["",""] + paths[0] = args.path1 + paths[1] = args.path2 + print(paths) + fid_value = calculate_fid_given_paths(paths, args.batch_size,args.gpu,args.dims) + print('FID: ', fid_value) \ No newline at end of file diff --git a/lrm/lrm_sana/trainer/utils/FID/img_data.py b/lrm/lrm_sana/trainer/utils/FID/img_data.py new file mode 100644 index 0000000000000000000000000000000000000000..c250cd7615a5843346547710fa5ac04e7e04391b --- /dev/null +++ b/lrm/lrm_sana/trainer/utils/FID/img_data.py @@ -0,0 +1,68 @@ +import os +import torch +from torch.utils import data +import torchvision.transforms as transforms +from PIL import Image +from datasets import Dataset as HFDataset + + +class Dataset(data.Dataset): + 'Characterizes a dataset for PyTorch' + + def __init__(self, path, transform=None): + 'Initialization' + self.file_names = self.get_filenames(path) + self.transform = transform + + def __len__(self): + 'Denotes the total number of samples' + return len(self.file_names) + + def __getitem__(self, index): + 'Generates one sample of data' + img = Image.open(self.file_names[index]).convert('RGB') + # Convert image and label to torch tensors + if self.transform is not None: + img = self.transform(img) + return img + + def get_filenames(self, data_path): + images = [] + for path, subdirs, files in os.walk(data_path): + for name in files: + if name.rfind('jpg') != -1 or name.rfind('png') != -1: + filename = os.path.join(path, name) + if os.path.isfile(filename): + images.append(filename) + return images + + +class HFImgDataset: + def __init__(self, dataset, transform=None): + self.dataset = dataset + self.transform = transform + + def __len__(self): + return len(self.dataset) + + def __getitem__(self, item): + example = self.dataset[item] + if self.transform is not None: + example["image"] = self.transform(example["image"]) + return example["image"] + + +if __name__ == '__main__': + path = "/media/twilightsnow/workspace/gan/AttnGAN/output/birds_attn2_2018_06_24_14_52_20/Model/netG_avg_epoch_300" + batch_size = 16 + dataset = Dataset(path, transforms.Compose([ + transforms.Resize(299), + transforms.ToTensor(), + transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) + # transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)) + ])) + print(dataset.__len__()) + dataloader = torch.utils.data.DataLoader(dataset=dataset, batch_size=batch_size, shuffle=False, drop_last=True) + for i, batch in enumerate(dataloader): + print(batch) + break diff --git a/lrm/lrm_sana/trainer/utils/FID/inception.py b/lrm/lrm_sana/trainer/utils/FID/inception.py new file mode 100644 index 0000000000000000000000000000000000000000..00e1cfcca2cca06ca392ab62efb02dc7dfba5a60 --- /dev/null +++ b/lrm/lrm_sana/trainer/utils/FID/inception.py @@ -0,0 +1,138 @@ +import torch.nn as nn +import torch.nn.functional as F +from torchvision import models + + +class InceptionV3(nn.Module): + """Pretrained InceptionV3 network returning feature maps""" + + # Index of default block of inception to return, + # corresponds to output of final average pooling + DEFAULT_BLOCK_INDEX = 3 + + # Maps feature dimensionality to their output blocks indices + BLOCK_INDEX_BY_DIM = { + 64: 0, # First max pooling features + 192: 1, # Second max pooling featurs + 768: 2, # Pre-aux classifier features + 2048: 3 # Final average pooling features + } + + def __init__(self, + output_blocks=[DEFAULT_BLOCK_INDEX], + resize_input=True, + normalize_input=True, + requires_grad=False): + """Build pretrained InceptionV3 + Parameters + ---------- + output_blocks : list of int + Indices of blocks to return features of. Possible values are: + - 0: corresponds to output of first max pooling + - 1: corresponds to output of second max pooling + - 2: corresponds to output which is fed to aux classifier + - 3: corresponds to output of final average pooling + resize_input : bool + If true, bilinearly resizes input to width and height 299 before + feeding input to model. As the network without fully connected + layers is fully convolutional, it should be able to handle inputs + of arbitrary size, so resizing might not be strictly needed + normalize_input : bool + If true, normalizes the input to the statistics the pretrained + Inception network expects + requires_grad : bool + If true, parameters of the model require gradient. Possibly useful + for finetuning the network + """ + super(InceptionV3, self).__init__() + + self.resize_input = resize_input + self.normalize_input = normalize_input + self.output_blocks = sorted(output_blocks) + self.last_needed_block = max(output_blocks) + + assert self.last_needed_block <= 3, \ + 'Last possible output block index is 3' + + self.blocks = nn.ModuleList() + + inception = models.inception_v3(pretrained=True) + + # Block 0: input to maxpool1 + block0 = [ + inception.Conv2d_1a_3x3, + inception.Conv2d_2a_3x3, + inception.Conv2d_2b_3x3, + nn.MaxPool2d(kernel_size=3, stride=2) + ] + self.blocks.append(nn.Sequential(*block0)) + + # Block 1: maxpool1 to maxpool2 + if self.last_needed_block >= 1: + block1 = [ + inception.Conv2d_3b_1x1, + inception.Conv2d_4a_3x3, + nn.MaxPool2d(kernel_size=3, stride=2) + ] + self.blocks.append(nn.Sequential(*block1)) + + # Block 2: maxpool2 to aux classifier + if self.last_needed_block >= 2: + block2 = [ + inception.Mixed_5b, + inception.Mixed_5c, + inception.Mixed_5d, + inception.Mixed_6a, + inception.Mixed_6b, + inception.Mixed_6c, + inception.Mixed_6d, + inception.Mixed_6e, + ] + self.blocks.append(nn.Sequential(*block2)) + + # Block 3: aux classifier to final avgpool + if self.last_needed_block >= 3: + block3 = [ + inception.Mixed_7a, + inception.Mixed_7b, + inception.Mixed_7c, + nn.AdaptiveAvgPool2d(output_size=(1, 1)) + ] + self.blocks.append(nn.Sequential(*block3)) + + for param in self.parameters(): + param.requires_grad = requires_grad + + def forward(self, inp): + """Get Inception feature maps + Parameters + ---------- + inp : torch.autograd.Variable + Input tensor of shape Bx3xHxW. Values are expected to be in + range (0, 1) + Returns + ------- + List of torch.autograd.Variable, corresponding to the selected output + block, sorted ascending by index + """ + outp = [] + x = inp + + if self.resize_input: + x = F.upsample(x, size=(299, 299), mode='bilinear', align_corners=True) + + if self.normalize_input: + x = x.clone() + x[:, 0] = x[:, 0] * (0.229 / 0.5) + (0.485 - 0.5) / 0.5 + x[:, 1] = x[:, 1] * (0.224 / 0.5) + (0.456 - 0.5) / 0.5 + x[:, 2] = x[:, 2] * (0.225 / 0.5) + (0.406 - 0.5) / 0.5 + + for idx, block in enumerate(self.blocks): + x = block(x) + if idx in self.output_blocks: + outp.append(x) + + if idx == self.last_needed_block: + break + + return outp \ No newline at end of file diff --git a/lrm/lrm_sana/trainer/utils/__pycache__/data_utils.cpython-310.pyc b/lrm/lrm_sana/trainer/utils/__pycache__/data_utils.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c7c73d5dc5d5c2540e3c4fc841ba196771dffdc2 Binary files /dev/null and b/lrm/lrm_sana/trainer/utils/__pycache__/data_utils.cpython-310.pyc differ diff --git a/lrm/lrm_sana/trainer/utils/data_utils.py b/lrm/lrm_sana/trainer/utils/data_utils.py new file mode 100644 index 0000000000000000000000000000000000000000..8663a4cc739db7a941ba3ac63114ed5f1ea219cc --- /dev/null +++ b/lrm/lrm_sana/trainer/utils/data_utils.py @@ -0,0 +1,28 @@ +import logging +from glob import glob +from io import BytesIO +from PIL import Image +from tqdm import tqdm +from datasets import load_dataset, concatenate_datasets, Dataset, load_from_disk + +logger = logging.getLogger(__name__) + + +def parquet2dataset(parquet_path: str): + datasets = [] + for path in sorted(glob(f"{parquet_path}/*.parquet")): + datasets.append(load_dataset("parquet", data_files=path)["train"]) + dataset = concatenate_datasets(datasets) + return dataset + + +def bytes2image(bytes: bytes): + image = Image.open(BytesIO(bytes)) + image = image.convert("RGB") + return image + + +def dataset2images(dataset, pool, col): + image_bytes = dataset[col] + images = list(tqdm(pool.imap(bytes2image, image_bytes), total=len(image_bytes))) + return images