Struct RunBuilder 

pub struct RunBuilder { /* private fields */ }

Configure and start a Run.

All fields have defaults. The simplest usage is:

let mut run = Run::builder().start()?;

Implementations

impl RunBuilder

pub fn run_id(self, id: RunId) -> Self

pub fn name(self, name: impl Into<String>) -> Self

pub fn project(self, name: impl Into<String>) -> Self

pub fn experiment(self, name: impl Into<String>) -> Self

pub fn user(self, id: UserId) -> Self

pub fn tags(self, tags: Vec<String>) -> Self

pub fn tag(self, tag: impl Into<String>) -> Self

pub fn wal_dir(self, dir: impl Into<PathBuf>) -> Self

pub fn wal(self, wal: WalKind) -> Self

pub fn max_points_per_batch(self, n: usize) -> Self

Examples found in repository

examples/rust_api.rs (line 4)

fn main() {
    let mut run = photon::Run::builder()
        .endpoint("[::1]:50051")
        .max_points_per_batch(50)
        .start()
        .expect("failed to start run");

    println!("Run: {}", run.id());

    // Simulate a training loop
    for step in 0..200 {
        let loss = 1.0 / (1.0 + step as f64 * 0.05);
        let accuracy = 1.0 - loss;

        run.log("train/loss", loss, step).unwrap();
        run.log("train/accuracy", accuracy, step).unwrap();

        if step % 10 == 0 {
            let lr = 0.001 * 0.95_f64.powi(step as i32 / 10);
            run.log("train/lr", lr, step).unwrap();
        }
    }

    println!("Logged: {} points", run.points_logged());

    let stats = run.finish().expect("finish failed");

    println!("\n--- Results ---");
    println!("Points:       {}", stats.points);
    println!("Dropped:      {}", stats.points_dropped);
    println!("Batches:      {}", stats.batches);
    println!("Bytes (raw):  {}", stats.bytes_uncompressed);
    println!("Bytes (wire): {}", stats.bytes_compressed);
    println!("Sent:         {}", stats.batches_sent);
    println!("Acked:        {}", stats.batches_acked);

    assert!(stats.batches > 0);
    assert_eq!(stats.points, 420);
    assert_eq!(stats.points_dropped, 0);

    println!("\nAll checks passed!");
}

pub fn batch_interval(self, interval: Duration) -> Self

pub fn channel_capacity(self, cap: usize) -> Self

pub fn codec(self, codec: CodecKind) -> Self

pub fn compressor(self, compressor: CompressorKind) -> Self

pub fn transport(self, transport: TransportKind) -> Self

pub fn endpoint(self, url: impl Into<String>) -> Self

Examples found in repository

examples/rust_api.rs (line 3)

fn main() {
    let mut run = photon::Run::builder()
        .endpoint("[::1]:50051")
        .max_points_per_batch(50)
        .start()
        .expect("failed to start run");

    println!("Run: {}", run.id());

    // Simulate a training loop
    for step in 0..200 {
        let loss = 1.0 / (1.0 + step as f64 * 0.05);
        let accuracy = 1.0 - loss;

        run.log("train/loss", loss, step).unwrap();
        run.log("train/accuracy", accuracy, step).unwrap();

        if step % 10 == 0 {
            let lr = 0.001 * 0.95_f64.powi(step as i32 / 10);
            run.log("train/lr", lr, step).unwrap();
        }
    }

    println!("Logged: {} points", run.points_logged());

    let stats = run.finish().expect("finish failed");

    println!("\n--- Results ---");
    println!("Points:       {}", stats.points);
    println!("Dropped:      {}", stats.points_dropped);
    println!("Batches:      {}", stats.batches);
    println!("Bytes (raw):  {}", stats.bytes_uncompressed);
    println!("Bytes (wire): {}", stats.bytes_compressed);
    println!("Sent:         {}", stats.batches_sent);
    println!("Acked:        {}", stats.batches_acked);

    assert!(stats.batches > 0);
    assert_eq!(stats.points, 420);
    assert_eq!(stats.points_dropped, 0);

    println!("\nAll checks passed!");
}

pub fn start(self) -> Result<Run, StartError>

Examples found in repository

examples/rust_api.rs (line 5)

fn main() {
    let mut run = photon::Run::builder()
        .endpoint("[::1]:50051")
        .max_points_per_batch(50)
        .start()
        .expect("failed to start run");

    println!("Run: {}", run.id());

    // Simulate a training loop
    for step in 0..200 {
        let loss = 1.0 / (1.0 + step as f64 * 0.05);
        let accuracy = 1.0 - loss;

        run.log("train/loss", loss, step).unwrap();
        run.log("train/accuracy", accuracy, step).unwrap();

        if step % 10 == 0 {
            let lr = 0.001 * 0.95_f64.powi(step as i32 / 10);
            run.log("train/lr", lr, step).unwrap();
        }
    }

    println!("Logged: {} points", run.points_logged());

    let stats = run.finish().expect("finish failed");

    println!("\n--- Results ---");
    println!("Points:       {}", stats.points);
    println!("Dropped:      {}", stats.points_dropped);
    println!("Batches:      {}", stats.batches);
    println!("Bytes (raw):  {}", stats.bytes_uncompressed);
    println!("Bytes (wire): {}", stats.bytes_compressed);
    println!("Sent:         {}", stats.batches_sent);
    println!("Acked:        {}", stats.batches_acked);

    assert!(stats.batches > 0);
    assert_eq!(stats.points, 420);
    assert_eq!(stats.points_dropped, 0);

    println!("\nAll checks passed!");
}

Trait Implementations

impl Default for RunBuilder

fn default() -> Self

Returns the “default value” for a type.