Binom.AutoML.IPCClient 1.0.1

Binom.AutoML IPC Client Library Documentation

1. Introduction

The Binom.AutoML.IPCClient library provides a high-level interface for interacting with the Binom.AutoML application via IPC (Inter-Process Communication). It encapsulates the complexity of IPC communication and provides a fluent API for experiment configuration.

2. Getting Started

2.1 Installation

Add a reference to the Binom.AutoML.IPCClient assembly in your project.

2.2 Initialization

using Binom.AutoML.IPCClient;
using Binom.AutoML.Interfaces;

var client = new BinomAutoMLIPCClient("InstanceName", new ConsoleClientLogger());

3. Connection Management

3.1 Establishing Connection

await client.ConnectAsync();

3.2 Connection Status

var status = client.GetCurrentConnectionStatus();
client.ConnectionStatusChanged += (newStatus) => 
    Console.WriteLine($"Connection status changed to: {newStatus}");

3.3 Disconnecting

await client.DisconnectAsync();

4. Experiment Management with Fluent API

4.1 Creating Experiments

The ExperimentLayoutBuilder provides a fluent interface for configuring experiments:

var experimentInfo = await client.NewExperiment()
    .SetExperimentName("MyExperiment")
    .SetOwnerID("User123")
    .ForRegressionTask()
    .SetMaxExperimentTimeInSeconds(3600)
    .SetOptimizationMetric("RSquared")
    .SetMaxModelsToExplore(10)
    .SetTrainTestSplitFraction(0.8m)
    .EnableDataShuffling()
    .SetInitialDataSourcePath("data.csv")
    .SendToServerAsync();

4.2 Fluent API Methods

• SetExperimentName(string name)
• SetOwnerID(string ownerId)
• ForRegressionTask()
• ForBinaryClassificationTask()
• ForMulticlassClassificationTask()
• SetMaxExperimentTimeInSeconds(uint seconds)
• SetOptimizationMetric(RegressionMetricType|BinaryClassificationMetricType|MulticlassClassificationMetricType metric) - Sets the optimization metric for the experiment. The available metrics depend on the experiment type:
  • Regression: RSquared, MeanAbsoluteError, MeanSquaredError, RootMeanSquaredError
  • Binary Classification: Accuracy, AreaUnderRocCurve, AreaUnderPrecisionRecallCurve, F1Score, PositivePrecision, PositiveRecall
  • Multiclass Classification: MacroAccuracy, MicroAccuracy, LogLoss, LogLossReduction, TopKAccuracy
• WithAllowedTrainers(params TrainerDto[] trainers) - Specifies allowed trainers for the experiment. The available trainers depend on the experiment type:
  • Regression: FastForest, FastTree, FastTreeTweedie, LightGbm, LbfgsPoissonRegression, StochasticDualCoordinateAscent
  • Binary Classification: FastForest, FastTree, LightGbm, LbfgsLogisticRegression, SdcaLogisticRegression
  • Multiclass Classification: FastForestOva, FastTreeOva, LightGbm, LbfgsMaximumEntropy, LbfgsLogisticRegressionOva, SdcaMaximumEntropy
• SetMaxModelsToExplore(int count)
• SetTrainTestSplitFraction(decimal fraction)
• EnableDataShuffling(bool shuffle = true)
• EnableCrossValidation(bool useCrossValidation = true)
• SetCrossValidationFolds(int folds)
• SetInitialDataSourcePath(string? path)
• SetBalancingStrategy(DataBalancingStrategyDto strategy)

5. Working with Experiments

5.1 Getting Experiment Information

var experiment = await client.GetExperimentAsync(experimentId);
var allExperiments = await client.GetAllExperimentsAsync();

5.2 Updating Experiment Settings

await client.UpdateExperimentSettingsAsync(experimentId, newSettings);

5.3 Deleting Experiments

await client.DeleteExperimentAsync(experimentId);

6. Data Management

6.1 Importing Data

await client.ImportDataFromFileAsync(experimentId, "data.csv");

6.2 Exporting Data

var exportedPath = await client.ExportDataToFileAsync(experimentId, "output");

6.3 Incremental Data Collection

await client.AddDataPointAsync(experimentId, new IncrementalDataPointDto {
    Label = "1",
    Features = object[] { 1.1, 1.2 }
});
await client.FinalizeDataCollectionAsync(experimentId);

7. Training and Models

7.1 Starting Training

await client.StartTrainingAsync(experimentId);

7.2 Monitoring Training

var status = await client.GetTrainingStatusAsync(experimentId);
var results = await client.GetTrainingResultsAsync(experimentId);
var logs = await client.GetTrainingLogsAsync(experimentId);

7.3 Canceling Training

await client.CancelTrainingAsync(experimentId);

7.4 Getting Best Model

var bestModel = await client.GetBestModelAsync(experimentId);

8. Error Handling

8.1 Exception Types

• ExperimentConfigurationException: Invalid experiment configuration
• BinomClientConnectionException: Connection-related errors
• BinomServerOperationException: Server-side operation failures

8.2 Example

try {
    await client.StartTrainingAsync(experimentId);
}
catch (BinomClientConnectionException ex) {
    Console.WriteLine($"Connection error: {ex.Message}");
}
catch (BinomServerOperationException ex) {
    Console.WriteLine($"Server error: {ex.Message}");
}

9. Events

9.1 Available Events

• ConnectionStatusChanged
• ExperimentCreated
• ExperimentUpdated
• ExperimentDeleted
• DataLoadingProgress
• DataLoaded
• TrainingStarted
• TrainingProgress
• TrainingCompleted
• TrainingCancelled
• TrainingLogReceived

9.2 Example

client.TrainingProgress += (sender, progress) => 
    Console.WriteLine($"Training progress: {progress.OptimizationMetricValue}");

10. Complete Example

using Binom.AutoML.IPCClient;
using Binom.AutoML.Interfaces;
using Binom.AutoML.Interfaces.Dtos;

class Program {
    static async Task Main(string[] args) {
        var client = new BinomAutoMLIPCClient("InstanceName", new ConsoleClientLogger());
        
        try {
            await client.ConnectAsync();
            
            // Create experiment
            var experiment = await client.NewExperiment()
                .SetExperimentName("SalesPrediction")
                .SetOwnerID("AnalyticsTeam")
                .ForRegressionTask()
                .SetMaxExperimentTimeInSeconds(1800)
                .SetOptimizationMetric(RegressionMetricType.RSquared)
                .WithAllowedTrainers(RegressionTrainerDto.LightGbm, RegressionTrainerDto.FastTree)
                .SetMaxModelsToExplore(15)
                .SetTrainTestSplitFraction(0.75m)
                .EnableDataShuffling()
                .SetInitialDataSourcePath("sales_data.csv")
                .SendToServerAsync();

            // Start training
            await client.StartTrainingAsync(experiment.ExperimentId);
            
            // Monitor training
            client.TrainingProgress += (s, e) => 
                Console.WriteLine($"Trial {e.TrialNumber}: {e.OptimizationMetricValue}");
                
            var results = await client.GetTrainingResultsAsync(experiment.ExperimentId);
            Console.WriteLine($"Best model: {results.BestModel.TrainerName}");
        }
        catch (Exception ex) {
            Console.WriteLine($"Error: {ex.Message}");
        }
        finally {
            await client.DisconnectAsync();
        }
    }
}

class ConsoleClientLogger : IClientLogger {
    public void LogDebug(string message, params object[] args) => 
        Console.WriteLine($"[DEBUG] {string.Format(message, args)}");
    public void LogInformation(string message, params object[] args) => 
        Console.WriteLine($"[INFO] {string.Format(message, args)}");
    public void LogWarning(string message, params object[] args) => 
        Console.WriteLine($"[WARN] {string.Format(message, args)}");
    public void LogError(Exception ex, string message, params object[] args) => 
        Console.WriteLine($"[ERROR] {string.Format(message, args)}\n{ex}");
}