Struct MLflowClient 

pub struct MLflowClient { /* private fields */ }

MLflow client for experiment tracking

Implementations

impl MLflowClient

pub fn new(config: MLflowConfig) -> Self

Create a new MLflow client

Arguments

• config - MLflow configuration

Example

use trustformers_debug::{MLflowClient, MLflowConfig};

let config = MLflowConfig::default();
let client = MLflowClient::new(config);

pub fn set_tracking_uri(&mut self, uri: impl Into<String>)

Set the tracking URI

Arguments

• uri - MLflow tracking server URI

pub async fn start_experiment( &mut self, name: impl Into<String>, ) -> Result<String>

Start a new experiment.

In TrackingMode::Http this looks the experiment up by name (GET experiments/get-by-name) and creates it (POST experiments/create) if it doesn’t exist yet – a real round trip to tracking_uri, which fails with a real transport/HTTP error if the server is unreachable or rejects the request. In TrackingMode::LocalOnly no request is made and a synthetic local-* id is generated instead, so callers can always tell the two apart.

Arguments

• name - Experiment name

Returns

Experiment ID

pub async fn start_run(&mut self, run_name: Option<&str>) -> Result<String>

Start a new run within the current experiment.

Real POST runs/create in TrackingMode::Http; a synthetic local-* id with no network access in TrackingMode::LocalOnly.

Arguments

• run_name - Optional run name

Returns

Run ID

pub async fn end_run(&mut self, status: RunStatus) -> Result<()>

End the current run: flushes any cached metrics/params/tags, then (in TrackingMode::Http) sets the run’s terminal status via a real POST runs/update call.

Arguments

• status - Final run status

pub fn log_param( &mut self, key: impl Into<String>, value: impl ToString, ) -> Result<()>

Log a parameter. Cached locally; delivered to the tracking server by MLflowClient::flush / MLflowClient::end_run (never on every call – a per-call network round trip for every logged value would be prohibitively slow for training loops that log every step).

Arguments

• key - Parameter name
• value - Parameter value

pub fn log_params(&mut self, params: HashMap<String, String>) -> Result<()>

Log multiple parameters at once

Arguments

• params - Map of parameter names to values

pub fn log_tag( &mut self, key: impl Into<String>, value: impl ToString, ) -> Result<()>

Log a tag. Cached locally, delivered the same way as parameters.

Arguments

• key - Tag name
• value - Tag value

pub fn log_tags(&mut self, tags: HashMap<String, String>) -> Result<()>

Log multiple tags at once

Arguments

• tags - Map of tag names to values

pub fn log_metric( &mut self, key: impl Into<String>, value: f64, step: i64, ) -> Result<()>

Log a metric at a specific step. Cached locally; see MLflowClient::log_param for why this does not hit the network directly.

Arguments

• key - Metric name
• value - Metric value
• step - Step number

pub fn log_metrics( &mut self, metrics: HashMap<String, f64>, step: i64, ) -> Result<()>

Log multiple metrics at once

Arguments

• metrics - Map of metric names to values
• step - Step number

pub fn log_tensor_stats( &mut self, prefix: &str, tensor: &Tensor, step: i64, ) -> Result<()>

Log tensor statistics as metrics

Arguments

• prefix - Metric name prefix
• tensor - Tensor to analyze
• step - Step number

pub fn log_array_stats( &mut self, prefix: &str, array: &Array1<f64>, step: i64, ) -> Result<()>

Log array statistics as metrics

Arguments

• prefix - Metric name prefix
• array - Array to analyze
• step - Step number

pub async fn flush(&self) -> Result<()>

Flush cached metrics, parameters and tags to the MLflow tracking server via a real POST runs/log-batch call (chunked to respect MLflow’s per-request limits of 1000 metrics / 100 params / 100 tags). A no-op in TrackingMode::LocalOnly – the caches themselves are the record in that mode – and a no-op when there is nothing cached or no active run.

pub fn log_artifact( &self, local_path: impl AsRef<Path>, artifact_path: Option<&str>, artifact_type: ArtifactType, ) -> Result<()>

Log an artifact (file) to the local artifact_dir cache.

Unlike Self::log_metric/Self::log_param/Self::log_tag, this method does not upload to the remote MLflow tracking server’s artifact store, even in TrackingMode::Http – MLflow’s artifact storage is backend-dependent (local disk, S3, GCS, Azure Blob, DBFS, …) and there is no single REST endpoint this client can target without knowing which backend the server is configured with. Uploading real artifact bytes to a remote MLflow server is intentionally out of scope for this client; only the experiment/run lifecycle and metrics/params/tags are delivered over HTTP. Callers that need artifacts on the actual tracking server must copy from artifact_dir themselves via whatever channel the server’s artifact backend expects.

Arguments

• local_path - Path to local file
• artifact_path - Optional path within the local artifact cache
• artifact_type - Type of artifact

pub fn log_model( &self, model_path: impl AsRef<Path>, model_name: Option<&str>, ) -> Result<()>

Log a model artifact

Arguments

• model_path - Path to model file
• model_name - Optional model name

pub fn log_plot( &self, plot_path: impl AsRef<Path>, plot_name: Option<&str>, ) -> Result<()>

Log a plot/visualization

Arguments

• plot_path - Path to plot file
• plot_name - Optional plot name

pub fn log_report(&self, content: &str, filename: &str) -> Result<()>

Log a text report

Arguments

• content - Report content
• filename - Report filename

pub fn get_run_info(&self) -> Option<RunInfo>

Get current run information. The start_time reflects when MLflowClient::start_run was actually called (real wall-clock ms since epoch), not a placeholder.

pub fn get_params(&self) -> HashMap<String, String>

Get all logged parameters

pub fn get_metrics(&self) -> HashMap<String, Vec<MetricPoint>>

Get all logged metrics

pub fn get_tags(&self) -> HashMap<String, String>

Get all logged tags

Trait Implementations

impl Debug for MLflowClient

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

Formats the value using the given formatter.