Машинное обучение на C#: обзор ML.NET и интеграция с Python

// Установка: dotnet add package Python.Runtime.NETStandard
using Python.Runtime;

public class PythonIntegration
{
    private IntPtr _pythonThread;
    
    public void InitializePython(string pythonPath)
    {
        // Установка пути к Python
        Runtime.PythonDLL = Path.Combine(pythonPath, "python39.dll");
        
        // Инициализация Python runtime
        PythonEngine.Initialize();
        
        // Получение GIL (Global Interpreter Lock)
        _pythonThread = PythonEngine.BeginAllowThreads();
    }
    
    public dynamic CallPythonScript(string scriptPath, params object[] args)
    {
        using (Py.GIL()) // Захват GIL для работы с Python
        {
            // Загрузка Python скрипта
            dynamic sys = Py.Import("sys");
            sys.path.append(Path.GetDirectoryName(scriptPath));
            
            string moduleName = Path.GetFileNameWithoutExtension(scriptPath);
            dynamic module = Py.Import(moduleName);
            
            // Вызов функции
            return module.main(args);
        }
    }
    
    public double[] UseNumPyForCalculations(double[] data)
    {
        using (Py.GIL())
        {
            dynamic np = Py.Import("numpy");
            
            // Конвертация C# массива в numpy array
            var pyArray = np.array(data);
            
            // Использование numpy функций
            var mean = np.mean(pyArray);
            var std = np.std(pyArray);
            var normalized = (pyArray - mean) / std;
            
            // Конвертация обратно в C# массив
            return normalized.As<double[]>();
        }
    }
    
    public void TrainScikitLearnModel(double[][] X, double[] y)
    {
        using (Py.GIL())
        {
            dynamic sklearn = Py.Import("sklearn");
            dynamic model = sklearn.ensemble.RandomForestClassifier(
                n_estimators: 100,
                random_state: 42);
            
            // Конвертация данных
            var pyX = ToPython(X);
            var pyY = ToPython(y);
            
            // Обучение модели
            model.fit(pyX, pyY);
            
            // Сохранение модели
            dynamic joblib = Py.Import("joblib");
            joblib.dump(model, "python_model.pkl");
            
            // Использование модели в C#
            var predictions = model.predict(pyX);
            var csharpPredictions = predictions.As<double[]>();
        }
    }
    
    private PyObject ToPython(double[][] array)
    {
        using (Py.GIL())
        {
            dynamic np = Py.Import("numpy");
            return np.array(array);
        }
    }
    
    private PyObject ToPython(double[] array)
    {
        using (Py.GIL())
        {
            dynamic np = Py.Import("numpy");
            return np.array(array);
        }
    }
    
    public void Shutdown()
    {
        PythonEngine.EndAllowThreads(_pythonThread);
        PythonEngine.Shutdown();
    }
}

// Пример использования
var pythonIntegration = new PythonIntegration();
pythonIntegration.InitializePython(@"C:\Python39");

// Вызов Python скрипта
var result = pythonIntegration.CallPythonScript(
    @"C:\scripts\data_processing.py",
    "input.csv",
    "output.csv");

// Использование numpy
var data = new double[] { 1.0, 2.0, 3.0, 4.0, 5.0 };
var normalized = pythonIntegration.UseNumPyForCalculations(data);

3.2. ML.NET + TensorFlow.NET: глубокое обучение на C#

3.2.1. Использование TensorFlow.NET

// Установка: dotnet add package TensorFlow.NET
//          dotnet add package SciSharp.TensorFlow.Redist
using Tensorflow;
using static Tensorflow.Binding;

public class TensorFlowModel
{
    public void CreateAndTrainModel()
    {
        // Инициализация TensorFlow
        tf.enable_eager_execution();
        
        // Загрузка данных MNIST
        var ((trainData, trainLabels), (testData, testLabels)) = 
            keras.datasets.mnist.load_data();
        
        // Препроцессинг
        trainData = trainData / 255.0f;
        testData = testData / 255.0f;
        
        // Создание модели
        var model = keras.Sequential(new List<ILayer>
        {
            keras.layers.Flatten(input_shape: (28, 28)),
            keras.layers.Dense(128, activation: "relu"),
            keras.layers.Dropout(0.2),
            keras.layers.Dense(10, activation: "softmax")
        });
        
        // Компиляция модели
        model.compile(
            optimizer: keras.optimizers.Adam(0.001),
            loss: keras.losses.SparseCategoricalCrossentropy(),
            metrics: new[] { "accuracy" });
        
        // Обучение
        model.fit(
            trainData, 
            trainLabels, 
            epochs: 5,
            validation_data: (testData, testLabels));
        
        // Сохранение модели
        model.save("mnist_model.h5");
        
        // Загрузка и использование модели
        var loadedModel = keras.models.load_model("mnist_model.h5");
        
        // Предсказание
        var predictions = loadedModel.predict(testData);
        var predictedClasses = predictions.argmax().numpy();
    }
    
    public void TransferLearningWithTensorFlow()
    {
        // Загрузка предобученной модели
        var baseModel = keras.applications.MobileNetV2(
            input_shape: (224, 224, 3),
            include_top: false,
            weights: "imagenet");
        
        // Заморозка базовой модели
        baseModel.trainable = false;
        
        // Добавление новых слоев
        var model = keras.Sequential(new List<ILayer>
        {
            baseModel,
            keras.layers.GlobalAveragePooling2D(),
            keras.layers.Dense(256, activation: "relu"),
            keras.layers.Dropout(0.5),
            keras.layers.Dense(10, activation: "softmax")
        });
        
        model.compile(
            optimizer: keras.optimizers.Adam(0.0001),
            loss: keras.losses.CategoricalCrossentropy(),
            metrics: new[] { "accuracy" });
        
        // Генератор данных для аугментации
        var dataGenerator = keras.preprocessing.image.ImageDataGenerator(
            rescale: 1.0f / 255,
            rotation_range: 20,
            width_shift_range: 0.2,
            height_shift_range: 0.2,
            horizontal_flip: true);
    }
}

3.3. Гибридный пайплайн: Python для обучения, C# для инференса

3.3.1. Обучение в Python, использование в C#

# train_model.py - обучение модели в Python
import pandas as pd
import numpy as np
from sklearn.ensemble import RandomForestRegressor
from sklearn.model_selection import train_test_split
import joblib
import json

# Загрузка и подготовка данных
data = pd.read_csv('housing_data.csv')
X = data[['Size', 'Bedrooms', 'YearBuilt']]
y = data['Price']

X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42)

# Обучение модели
model = RandomForestRegressor(n_estimators=100, random_state=42)
model.fit(X_train, y_train)

# Сохранение модели
joblib.dump(model, 'model.pkl')

# Сохранение метаданных
metadata = {
    'features': X.columns.tolist(),
    'feature_types': {
        'Size': 'float',
        'Bedrooms': 'float', 
        'YearBuilt': 'float'
    },
    'target': 'Price',
    'model_type': 'RandomForestRegressor',
    'performance': {
        'train_score': model.score(X_train, y_train),
        'test_score': model.score(X_test, y_test)
    }
}

with open('model_metadata.json', 'w') as f:
    json.dump(metadata, f, indent=2)

print("Model trained and saved successfully")

3.3.2. Загрузка и использование Python-модели в C#

public class PythonTrainedModel
{
    private dynamic _pythonModel;
    private dynamic _scaler;
    private Dictionary<string, string> _metadata;
    
    public void LoadPythonModel(string modelPath, string metadataPath)
    {
        using (Py.GIL())
        {
            // Загрузка joblib
            dynamic joblib = Py.Import("joblib");
            
            // Загрузка модели и скейлера
            _pythonModel = joblib.load(Path.Combine(modelPath, "model.pkl"));
            _scaler = joblib.load(Path.Combine(modelPath, "scaler.pkl"));
            
            // Загрузка метаданных
            string metadataJson = File.ReadAllText(metadataPath);
            _metadata = JsonSerializer.Deserialize<Dictionary<string, string>>(metadataJson);
        }
    }
    
    public double Predict(double[] features)
    {
        using (Py.GIL())
        {
            // Конвертация features в Python объект
            dynamic np = Py.Import("numpy");
            var pyFeatures = np.array(features).reshape(1, -1);
            
            // Масштабирование признаков
            var scaledFeatures = _scaler.transform(pyFeatures);
            
            // Предсказание
            var prediction = _pythonModel.predict(scaledFeatures);
            
            // Конвертация в C# тип
            return prediction[0].As<double>();
        }
    }
    
    public double[] PredictBatch(double[][] featuresBatch)
    {
        using (Py.GIL())
        {
            dynamic np = Py.Import("numpy");
            var pyBatch = np.array(featuresBatch);
            
            var scaledBatch = _scaler.transform(pyBatch);
            var predictions = _pythonModel.predict(scaledBatch);
            
            return predictions.As<double[]>();
        }
    }
    
    public ModelMetrics GetMetrics()
    {
        using (Py.GIL())
        {
            if (_pythonModel != null)
            {
                // Получение feature importance
                var importances = _pythonModel.feature_importances_;
                var featureNames = _metadata["features"].Split(',');
                
                var importanceDict = new Dictionary<string, double>();
                for (int i = 0; i < featureNames.Length; i++)
                {
                    importanceDict[featureNames[i]] = importances[i].As<double>();
                }
                
                return new ModelMetrics
                {
                    FeatureImportance = importanceDict,
                    ModelType = _metadata["model_type"],
                    TrainingDate = DateTime.Parse(_metadata["training_date"])
                };
            }
            
            return null;
        }
    }
}

// Сервис для управления гибридным пайплайном
public class HybridMLService
{
    private readonly PythonIntegration _python;
    private readonly MLContext _mlContext;
    private PythonTrainedModel _pythonModel;
    private ITransformer _mlNetModel;
    
    public HybridMLService()
    {
        _python = new PythonIntegration();
        _python.InitializePython(@"C:\Python39");
        _mlContext = new MLContext();
    }
    
    public async Task TrainHybridModel(string dataPath)
    {
        // Шаг 1: Предобработка данных в Python
        Console.WriteLine("Preprocessing data with pandas...");
        await Task.Run(() => _python.CallPythonScript(
            @"scripts\preprocess.py",
            dataPath,
            "processed_data.csv"));
        
        // Шаг 2: Обучение сложной модели в Python
        Console.WriteLine("Training model with scikit-learn...");
        await Task.Run(() => _python.CallPythonScript(
            @"scripts\train_model.py",
            "processed_data.csv",
            "python_model.pkl"));
        
        // Шаг 3: Загрузка Python модели в C#
        _pythonModel = new PythonTrainedModel();
        _pythonModel.LoadPythonModel("python_model.pkl", "model_metadata.json");
        
        // Шаг 4: Создание упрощенной модели в ML.NET для продакшена
        Console.WriteLine("Creating production model with ML.NET...");
        await CreateSimplifiedMlNetModel("processed_data.csv");
        
        // Шаг 5: Сравнение производительности
        await CompareModelPerformance("test_data.csv");
    }
    
    private async Task CreateSimplifiedMlNetModel(string processedDataPath)
    {
        await Task.Run(() =>
        {
            var data = _mlContext.Data.LoadFromTextFile<HousingData>(
                processedDataPath, hasHeader: true);
            
            var pipeline = _mlContext.Transforms
                .Concatenate("Features", "Size", "Bedrooms", "YearBuilt")
                .Append(_mlContext.Regression.Trainers.FastTree(
                    labelColumnName: "Price",
                    featureColumnName: "Features"));
            
            _mlNetModel = pipeline.Fit(data);
            
            _mlContext.Model.Save(_mlNetModel, data.Schema, "mlnet_model.zip");
        });
    }
    
    private async Task CompareModelPerformance(string testDataPath)
    {
        var testData = File.ReadAllLines(testDataPath)
            .Skip(1)
            .Select(line => line.Split(','))
            .Select(parts => new HousingData
            {
                Size = float.Parse(parts[0]),
                Bedrooms = float.Parse(parts[1]),
                YearBuilt = float.Parse(parts[2]),
                Price = float.Parse(parts[3])
            })
            .ToList();
        
        var pythonPredictions = new List<double>();
        var mlnetPredictions = new List<double>();
        var actualPrices = new List<double>();
        
        foreach (var item in testData)
        {
            // Python модель
            var pythonPred = await Task.Run(() => _pythonModel.Predict(
                new[] { item.Size, item.Bedrooms, item.YearBuilt }));
            pythonPredictions.Add(pythonPred);
            
            // ML.NET модель
            var mlnetPred = PredictWithMlNet(item);
            mlnetPredictions.Add(mlnetPred);
            
            actualPrices.Add(item.Price);
        }
        
        // Расчет метрик
        var pythonMetrics = CalculateMetrics(actualPrices, pythonPredictions);
        var mlnetMetrics = CalculateMetrics(actualPrices, mlnetPredictions);
        
        Console.WriteLine("Performance Comparison:");
        Console.WriteLine($"Python Model - RMSE: {pythonMetrics.RMSE:F2}, " +
                         $"R²: {pythonMetrics.RSquared:F4}");
        Console.WriteLine($"ML.NET Model - RMSE: {mlnetMetrics.RMSE:F2}, " +
                         $"R²: {mlnetMetrics.RSquared:F4}");
        Console.WriteLine($"Inference Time - Python: {pythonMetrics.InferenceTimeMs}ms, " +
                         $"ML.NET: {mlnetMetrics.InferenceTimeMs}ms");
    }
    
    private double PredictWithMlNet(HousingData data)
    {
        var predictionEngine = _mlContext.Model
            .CreatePredictionEngine<HousingData, PricePrediction>(_mlNetModel);
        
        return predictionEngine.Predict(data).PredictedPrice;
    }
}

Продакшн-развертывание и мониторинг

4.1. Docker-контейнеризация ML-моделей

4.1.1. Dockerfile для ML.NET приложения