Struct TrainingState 

pub struct TrainingState {

    pub step: usize,
    pub total_steps: usize,
    pub best_loss: Option<f32>,
    pub lr: f32,
    pub epoch: usize,
    pub batch_size: usize,
    pub grad_accum_steps: usize,
    pub sequence_length: usize,
    pub fp16: bool,
    pub train_modules: String,
    pub task: String,
    pub model_path: String,
    pub dataset_path: String,
    pub seed: u64,
}

Progress and settings of a training run (also read by ferrotensor-monitor from training_state.json).

Fields

step: usize

Optimizer steps completed.

total_steps: usize

Planned optimizer steps.

best_loss: Option<f32>

Lowest logged training loss so far.

lr: f32

Peak learning rate.

epoch: usize

Epochs completed.

batch_size: usize

Sequences per batch.

grad_accum_steps: usize

Batches per optimizer step.

sequence_length: usize

Maximum tokens per example.

fp16: bool

Whether loss scaling was enabled.

train_modules: String

What was trained (lora, all, attn, …).

task: String

Objective (sft or pretrain).

model_path: String

Model directory.

dataset_path: String

Training data file.

seed: u64

Data-order seed of the run, so a resume replays the same order.

Implementations

impl TrainingState

pub fn new(total_steps: usize) -> Self

A fresh state for a run of total_steps steps.

pub fn save<P: AsRef<Path>>(&self, path: P) -> Result<(), Box<dyn Error>>

Write as pretty JSON.

pub fn load<P: AsRef<Path>>(path: P) -> Result<Self, Box<dyn Error>>

Read a state written by save.

pub fn validate_resume( &self, train_modules: &str, task: &str, sequence_length: usize, model_path: &str, ) -> Result<(), String>

Validate that a resume is compatible with the current run configuration.

Trait Implementations

impl Clone for TrainingState

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TrainingState

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for TrainingState

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for TrainingState

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

where __S: Serializer,

Serialize this value into the given Serde serializer.