import org.superml.datasets.Datasets;
import org.superml.linear_model.LogisticRegression;
import org.superml.pipeline.Pipeline;
import org.superml.preprocessing.StandardScaler;
import org.superml.model_selection.ModelSelection;
import org.superml.visualization.VisualizationFactory;

// Load data and create pipeline
Datasets.Dataset dataset = Datasets.loadIris();
Pipeline pipeline = new Pipeline()
    .addStep("scaler", new StandardScaler())
    .addStep("classifier", new LogisticRegression());

// Train and evaluate
ModelSelection.TrainTestSplit split = ModelSelection.trainTestSplit(dataset.X, dataset.y, 0.2, 42);
pipeline.fit(split.XTrain, split.yTrain);
double[] predictions = pipeline.predict(split.XTest);

// Professional visualization (GUI + ASCII fallback)
VisualizationFactory.createDualModeConfusionMatrix(split.yTest, predictions, 
    new String[]{"Setosa", "Versicolor", "Virginica"}).display();

import org.superml.autotrainer.AutoTrainer;

// Automated algorithm selection and optimization
AutoTrainer.AutoMLResult result = AutoTrainer.autoML(dataset.X, dataset.y, "classification");
System.out.println("Best Algorithm: " + result.getBestAlgorithm());
System.out.println("Best Score: " + result.getBestScore());

import org.superml.datasets.KaggleTrainingManager;
import org.superml.datasets.KaggleIntegration.KaggleCredentials;

KaggleCredentials credentials = KaggleCredentials.fromDefaultLocation();
KaggleTrainingManager trainer = new KaggleTrainingManager(credentials);

// Configure training with model saving
KaggleTrainingManager.TrainingConfig config = new KaggleTrainingManager.TrainingConfig()
    .setSaveModels(true)
    .setModelsDirectory("kaggle_models")
    .setAlgorithms("logistic", "ridge")
    .setGridSearch(true);

List<KaggleTrainingManager.TrainingResult> results = trainer.trainOnDataset("titanic", "titanic", "survived", config);
System.out.println("Best model: " + results.get(0).algorithm);
System.out.println("Model saved to: " + results.get(0).modelFilePath);

import org.superml.persistence.ModelPersistence;
import org.superml.persistence.ModelManager;

// Train a model
LogisticRegression model = new LogisticRegression().setMaxIter(1000);
model.fit(X_train, y_train);

// Save with automatic performance evaluation and statistics
ModelPersistence.saveWithStats(model, "my_model", 
                               "Production iris classifier", 
                               X_test, y_test);

// Load model with type safety
LogisticRegression loadedModel = ModelPersistence.load("my_model", LogisticRegression.class);
double[] predictions = loadedModel.predict(X_test);

// The framework automatically captures:
// - Performance metrics (accuracy, precision, recall, F1)
// - Dataset statistics and hyperparameters
// - System information and timestamps

// Manage multiple models with automatic statistics
ModelManager manager = new ModelManager("models");
String savedPath = manager.saveModel(model, "iris");
List<String> allModels = manager.listModels();

import org.superml.datasets.Datasets;
import org.superml.linear_model.LogisticRegression;
import org.superml.tree.RandomForest;
import org.superml.tree.GradientBoosting;
import org.superml.metrics.Metrics;
import org.superml.model_selection.ModelSelection;
import org.superml.preprocessing.StandardScaler;

// Load dataset
Datasets.Dataset dataset = Datasets.loadIris();
ModelSelection.TrainTestSplit split = ModelSelection.trainTestSplit(dataset.X, dataset.y, 0.2, 42);

// Preprocessing
StandardScaler scaler = new StandardScaler();
double[][] XTrainScaled = scaler.fitTransform(split.XTrain);
double[][] XTestScaled = scaler.transform(split.XTest);

// Train multiple models
LogisticRegression lr = new LogisticRegression().setMaxIterations(1000);
RandomForest rf = new RandomForest().setNEstimators(100);
GradientBoosting gb = new GradientBoosting().setNEstimators(100).setLearningRate(0.1);

lr.fit(XTrainScaled, split.yTrain);
rf.fit(XTrainScaled, split.yTrain);
gb.fit(XTrainScaled, split.yTrain);

// Compare performance
double lrAccuracy = Metrics.accuracy(split.yTest, lr.predict(XTestScaled));
double rfAccuracy = Metrics.accuracy(split.yTest, rf.predict(XTestScaled));
double gbAccuracy = Metrics.accuracy(split.yTest, gb.predict(XTestScaled));

System.out.printf("Logistic Regression: %.3f\n", lrAccuracy);
System.out.printf("Random Forest: %.3f\n", rfAccuracy);
System.out.printf("Gradient Boosting: %.3f\n", gbAccuracy);

import org.superml.model_selection.CrossValidation;

// Basic cross-validation
LogisticRegression classifier = new LogisticRegression();
CrossValidation.CrossValidationResults results = 
    CrossValidation.crossValidate(classifier, X, y);

System.out.println("Accuracy: " + results.getMeanScore("accuracy") + 
                   " ± " + results.getStdScore("accuracy"));

// Custom cross-validation configuration
CrossValidation.CrossValidationConfig config = 
    new CrossValidation.CrossValidationConfig()
        .setFolds(10)
        .setShuffle(true)
        .setRandomSeed(42L)
        .setMetrics("accuracy", "precision", "recall", "f1");

CrossValidation.CrossValidationResults detailedResults = 
    CrossValidation.crossValidate(classifier, X, y, config);

// Regression cross-validation
Ridge regressor = new Ridge();
CrossValidation.CrossValidationResults regressionResults = 
    CrossValidation.crossValidateRegression(regressor, X, y, 
        new CrossValidation.CrossValidationConfig());

import org.superml.model_selection.HyperparameterTuning;

// Grid Search for Classification
HyperparameterTuning.TuningResults gridResults = HyperparameterTuning.gridSearch(
    new LogisticRegression(),
    X, y,
    HyperparameterTuning.ParameterSpec.discrete("learningRate", 0.01, 0.1, 0.5),
    HyperparameterTuning.ParameterSpec.discrete("maxIter", 500, 1000, 1500)
);

System.out.println("Best parameters: " + gridResults.getBestParameters());
System.out.println("Best score: " + gridResults.getBestScore());

// Grid Search for Regression
HyperparameterTuning.TuningResults regressionGrid = 
    HyperparameterTuning.gridSearchRegressor(
        new Ridge(),
        X, y,
        HyperparameterTuning.ParameterSpec.discrete("alpha", 0.1, 1.0, 10.0),
        HyperparameterTuning.ParameterSpec.continuous("tolerance", 1e-6, 1e-3, 5)
    );

// Random Search with Custom Configuration
HyperparameterTuning.TuningConfig advancedConfig = 
    new HyperparameterTuning.TuningConfig()
        .setScoringMetric("f1")
        .setCvFolds(5)
        .setParallel(true)
        .setVerbose(true)
        .setRandomSeed(123L);

HyperparameterTuning.TuningResults randomResults = 
    HyperparameterTuning.RandomSearch.search(
        new LogisticRegression(),
        X, y,
        Arrays.asList(
            HyperparameterTuning.ParameterSpec.discrete("learningRate", 0.001, 0.01, 0.1, 0.5),
            HyperparameterTuning.ParameterSpec.integer("maxIter", 100, 2000)
        ),
        advancedConfig
    );

// Parameter Specifications
// Discrete values
HyperparameterTuning.ParameterSpec.discrete("param", "A", "B", "C");

// Continuous range with specified steps
HyperparameterTuning.ParameterSpec.continuous("learning_rate", 0.001, 0.1, 10);

// Integer range
HyperparameterTuning.ParameterSpec.integer("max_depth", 1, 20);

import org.superml.persistence.ModelPersistence;
import org.superml.persistence.ModelManager;

// Train and save a pipeline
Pipeline pipeline = new Pipeline()
    .addStep("scaler", new StandardScaler())
    .addStep("classifier", new LogisticRegression());

pipeline.fit(X_train, y_train);

// Save with rich metadata
Map<String, Object> metadata = Map.of(
    "accuracy", Metrics.accuracy(y_test, pipeline.predict(X_test)),
    "features", X_train[0].length,
    "samples", X_train.length,
    "created_by", "SuperML_Demo"
);

ModelPersistence.save(pipeline, "production_model", "Main classification pipeline", metadata);

// Later, load and use the model
Pipeline loadedPipeline = ModelPersistence.load("production_model", Pipeline.class);
double[] predictions = loadedPipeline.predict(X_new);

// Model management
ModelManager manager = new ModelManager("models");
List<ModelManager.ModelInfo> models = manager.getModelsInfo();
for (ModelManager.ModelInfo info : models) {
    System.out.println(info); // Shows class, size, save time, etc.
}

import org.superml.inference.InferenceEngine;
import org.superml.inference.BatchInferenceProcessor;

// Create inference engine and load model
InferenceEngine engine = new InferenceEngine();
engine.loadModel("classifier", "models/trained_model.superml");

// Single prediction
double prediction = engine.predict("classifier", features);

// Batch prediction with monitoring
double[] batchPredictions = engine.predict("classifier", batchFeatures);

// Asynchronous inference
CompletableFuture<Double> future = engine.predictAsync("classifier", features);

// Performance metrics
InferenceMetrics metrics = engine.getMetrics("classifier");
System.out.println("Throughput: " + metrics.getThroughputSamplesPerSecond() + " samples/sec");

// Batch processing for large datasets
BatchInferenceProcessor processor = new BatchInferenceProcessor(engine);
BatchResult result = processor.processCSV("input.csv", "output.csv", "classifier");