Program.cs

using MinimalTextClassifier.Core;
using Serilog;
using Serilog.Events;
using System.Diagnostics;

public static class Program
{
    public static void AddConsoleLogger()
    {
        var serilogLogger = new LoggerConfiguration()
            .Enrich.FromLogContext()
            .MinimumLevel.Verbose()
            .MinimumLevel.Override("Microsoft", LogEventLevel.Warning)
            .MinimumLevel.Override("System", LogEventLevel.Warning)
            .WriteTo.Console(
                restrictedToMinimumLevel: LogEventLevel.Debug,
                outputTemplate: "[{Timestamp:HH:mm:ss} {Level:u3}] {Message:lj}{NewLine}{Exception}")
            .WriteTo.File(
                path: "classifier_test.log",
                restrictedToMinimumLevel: LogEventLevel.Debug,
                rollingInterval: RollingInterval.Infinite,
                rollOnFileSizeLimit: true,
                fileSizeLimitBytes: 100 * 1024 * 1024, // 100 MB
                retainedFileCountLimit: 5)
            .CreateLogger();

        Log.Logger = serilogLogger;
        Log.Information("Serilog configured.");
    }

    public static async Task Main(string[] args)
    {
        AddConsoleLogger();

        Log.Information("Train model? Y/n");
        var answer = Console.ReadKey(false);
        if (char.ToLower(answer.KeyChar) == 'y')
        {
            // Step 1: Run the Python training script with real-time output streaming
            // (text classification fine-tuning, specifically binary classification)
            bool didComplete = await TuneModelPythonScript();
            if (!didComplete)
            {
                return;
            }
        }

        // Step 2: Load the fine-tuned model (generated by Python)
        string trainedModelPath = "deberta_v3_small_fine_tuned_int8.onnx";
        if (!File.Exists(trainedModelPath))
        {
            Log.Error("Trained model not found at {Path}", trainedModelPath);
            return;
        }

        var classifier = new MinimalTransformerClassifier(trainedModelPath);

        // Step 3 & 4: Test the classifier with the trained model
        // Step 3 & 4: Run batch tests on positive and negative examples
        const float cutoff = 0.5f;
        TestModel(classifier, cutoff);
    }

    private static void TestModel(MinimalTransformerClassifier classifier, float confidenceMax)
    {
        // Load positive examples
        string positivePath = "positive_examples.txt";
        if (!File.Exists(positivePath))
        {
            Log.Error("Positive examples file not found at {Path}", positivePath);
            return;
        }
        var positiveExamples = File.ReadAllLines(positivePath)
            .Select(line => line.Trim().Trim('"', '\''))
            .Where(line => !string.IsNullOrWhiteSpace(line))
            .ToList();

        // Load negative examples
        string negativePath = "negative_examples.txt";
        if (!File.Exists(negativePath))
        {
            Log.Error("Negative examples file not found at {Path}", negativePath);
            return;
        }
        var negativeExamples = File.ReadAllLines(negativePath)
            .Select(line => line.Trim().Trim('"', '\''))
            .Where(line => !string.IsNullOrWhiteSpace(line))
            .ToList();

        // Test positives (expect true)
        int positiveCorrect = 0;
        foreach (var example in positiveExamples)
        {
            var conf = classifier.ClassifyText(example);
            bool isWake = conf > confidenceMax;
            if (isWake)
                positiveCorrect++;
            Log.Debug("Positive example: '{Text}' -> IsWake: {IsWake}, Conf: {Conf:F3}", example, isWake, conf);
        }

        // Test negatives (expect false)
        int negativeCorrect = 0;
        foreach (var example in negativeExamples)
        {
            var conf = classifier.ClassifyText(example);
            bool isWake = conf > confidenceMax;
            if (!isWake)
                negativeCorrect++;
            Log.Debug("Negative example: '{Text}' -> IsWake: {IsWake}, Conf: {Conf:F3}", example, isWake, conf);
        }

        // Calculate and log percentages
        double positiveAccuracy = (double)positiveCorrect / positiveExamples.Count * 100;
        double negativeAccuracy = (double)negativeCorrect / negativeExamples.Count * 100;

        Log.Information("Test Results:");
        Log.Information("Positive examples accuracy: {Accuracy:F2}% ({Correct}/{Total})", positiveAccuracy, positiveCorrect, positiveExamples.Count);
        Log.Information("Negative examples accuracy: {Accuracy:F2}% ({Correct}/{Total})", negativeAccuracy, negativeCorrect, negativeExamples.Count);
    }

    private static async Task<bool> TuneModelPythonScript()
    {
        Log.Information("Starting Python training script...");
        var pythonProcess = new Process
        {
            StartInfo = new ProcessStartInfo
            {
                FileName = "python",
                Arguments = "train_model.py",  // Assumes script is in current dir
                RedirectStandardOutput = true,
                RedirectStandardError = true,
                UseShellExecute = false,
                CreateNoWindow = true
            },
            EnableRaisingEvents = true  // For OutputDataReceived
        };

        // Set up real-time output streaming
        pythonProcess.OutputDataReceived += (sender, e) =>
        {
            if (!string.IsNullOrEmpty(e.Data))
            {
                //Console.WriteLine(e.Data);  // Print to terminal
                Log.Information("->{data}", e.Data);
            }
        };

        pythonProcess.ErrorDataReceived += (sender, e) =>
        {
            if (!string.IsNullOrEmpty(e.Data))
            {
                //Console.Error.WriteLine(e.Data);  // Print errors to stderr/terminal
                Log.Information("->{data}", e.Data);
            }
        };

        pythonProcess.Start();
        pythonProcess.BeginOutputReadLine();
        pythonProcess.BeginErrorReadLine();

        await Task.Run(() => pythonProcess.WaitForExit());  // Wait async

        if (pythonProcess.ExitCode != 0)
        {
            Log.Error("Python training failed with exit code {Code}", pythonProcess.ExitCode);
            return false;
        }
        Log.Information("Python training completed successfully.");
        return true;
    }
}