Struct TrainingSnapshot 

pub struct TrainingSnapshot {

    pub timestamp_ms: u64,
    pub epoch: usize,
    pub total_epochs: usize,
    pub step: usize,
    pub steps_per_epoch: usize,
    pub loss: f32,
    pub loss_history: Vec<f32>,
    pub learning_rate: f32,
    pub lr_history: Vec<f32>,
    pub gradient_norm: f32,
    pub accuracy: f32,
    pub tokens_per_second: f32,
    pub samples_per_second: f32,
    pub start_timestamp_ms: u64,
    pub gpu: Option<GpuTelemetry>,
    pub sample: Option<SamplePeek>,
    pub status: TrainingStatus,
    pub experiment_id: String,
    pub model_name: String,
    pub model_path: String,
    pub optimizer_name: String,
    pub batch_size: usize,
    pub checkpoint_path: String,
    pub executable_path: String,
}

Complete training state snapshot

Fields

timestamp_ms: u64

Unix timestamp in milliseconds

epoch: usize

Current epoch (1-indexed)

total_epochs: usize

Total epochs

step: usize

Current step within epoch

steps_per_epoch: usize

Total steps per epoch

loss: f32

Current loss value

loss_history: Vec<f32>

Loss history (last N values for sparkline)

learning_rate: f32

Current learning rate

lr_history: Vec<f32>

Learning rate history (per-step, for epoch summaries)

gradient_norm: f32

Gradient norm

accuracy: f32

Training accuracy (0.0 to 1.0)

tokens_per_second: f32

Throughput in tokens per second

samples_per_second: f32

Throughput in samples per second

start_timestamp_ms: u64

Training start timestamp (ms)

gpu: Option<GpuTelemetry>

GPU telemetry (optional)

sample: Option<SamplePeek>

Sample peek (optional)

status: TrainingStatus

Training status

experiment_id: String

Experiment name/ID

model_name: String

Model name

model_path: String

Model path (e.g., path to .safetensors or .gguf)

optimizer_name: String

Optimizer name (e.g., “AdamW”, “SGD”)

batch_size: usize

Batch size

checkpoint_path: String

Checkpoint path (where checkpoints are saved)

executable_path: String

Executable path (path to training binary)

Implementations

impl TrainingSnapshot

pub fn elapsed(&self) -> Duration

Calculate elapsed time since training start Uses the snapshot’s timestamp_ms for deterministic/reproducible output (ENT-140)

pub fn estimated_remaining(&self) -> Option<Duration>

Calculate estimated remaining time

pub fn global_step(&self) -> usize

Global step (epoch * steps_per_epoch + step)

pub fn progress_percent(&self) -> f32

Progress percentage (0-100)

pub fn loss_trend(&self) -> LossTrend

Compute loss trend from recent history

Returns:

• LossTrend::Decreasing if loss is going down (good)
• LossTrend::Stable if loss is plateauing
• LossTrend::Increasing if loss is going up (bad)
• LossTrend::Unknown if not enough data

Trait Implementations

impl Clone for TrainingSnapshot

fn clone(&self) -> TrainingSnapshot

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for TrainingSnapshot

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for TrainingSnapshot

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for TrainingSnapshot

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<&TrainingSnapshot> for HeadlessOutput

fn from(snapshot: &TrainingSnapshot) -> Self

Converts to this type from the input type.

impl Serialize for TrainingSnapshot

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.