ML.NET и TensorFlow.NET: Умные приложения на C# с машинным обучением

var context = new MLContext(seed: 42); // фиксированное начальное значение для воспроизводимости

IDataView data = context.Data.LoadFromTextFile<HouseData>("prices.csv", separatorChar: ',', hasHeader: true);

// Использование AutoML для поиска лучшей модели классификации
ExperimentResult<MulticlassClassificationMetrics> result = context.Auto()
    .CreateMulticlassClassificationExperiment(experimentTime: TimeSpan.FromMinutes(10))
    .Execute(trainData, labelColumnName: "Category");

// Загрузка данных напрямую из базы через Entity Framework
using (var dbContext = new CustomerDbContext())
{
    var customers = dbContext.Customers.Where(c => c.Active).ToList();
    IDataView data = context.Data.LoadFromEnumerable(customers);
    // Дальнейшая обработка и обучение модели
}

var pipeline = context.Transforms.Text.FeaturizeText("Features", "ReviewText")
    .Append(context.Transforms.NormalizeMinMax("Features"))
    .Append(context.BinaryClassification.Trainers.LbfgsLogisticRegression());

var predictions = model.Transform(testData);
var metrics = context.BinaryClassification.Evaluate(predictions);
Console.WriteLine($"Accuracy: {metrics.Accuracy:P2}");
Console.WriteLine($"F1 Score: {metrics.F1Score:P2}");

context.Model.Save(model, data.Schema, "model.zip");
// Загрузка ранее сохраненной модели
var loadedModel = context.Model.Load("model.zip", out var modelInputSchema);

Install-Package TensorFlow.NET
Install-Package SciSharp.TensorFlow.Redist

// Создание простейшей нейронной сети с TensorFlow.NET
var tf = new TFGraph();
var session = new TFSession(tf);
 
// Создаём две переменные-заполнителя для входных данных
var x = tf.Placeholder(TFDataType.Float);
var y = tf.Placeholder(TFDataType.Float);
 
// Определяем операцию - умножение
var operation = tf.Mul(x, y);
 
// Запускаем вычисление и получаем результат
var result = session.Run(operation, 
                        new[] { x, y }, 
                        new object[] { 2f, 3f });
Console.WriteLine(result.GetValue()); // Выведет 6

// Загрузка предобученной модели MobileNet для классификации изображений
var model = SavedModel.Load("mobilenet_v2", tags: "serve");
 
// Подготовка изображения для модели
var tensor = ImageUtil.CreateTensorFromImageFile("cat.jpg", 
                                              224, 
                                              224, 
                                              TFDataType.UInt8);
 
// Получение предсказания
var predictions = model.Predict(tensor);
var topPredictions = predictions.GetTopPredictions(modelOutput, 5);
 
foreach (var p in topPredictions)
    Console.WriteLine($"{p.Label}: {p.Probability:P2}");

// Проверка доступности GPU
Console.WriteLine("Доступные устройства:");
foreach (var device in tf.list_physical_devices())
    Console.WriteLine($"{device.DeviceType}: {device.Name}");
 
// Явное указание использовать GPU
with(tf.device("/gpu:0"), delegate
{
    // Код, который будет выполняться на GPU
    var a = tf.constant(new float[,] { { 1, 2 }, { 3, 4 } });
    var b = tf.constant(new float[,] { { 5, 6 }, { 7, 8 } });
    var c = tf.matmul(a, b);
    Console.WriteLine(c);
});

var dataset = tf.data.Dataset.from_tensor_slices(trainData);
dataset = dataset.batch(32); // Размер мини-пакета
dataset = dataset.shuffle(bufferSize: 1000);
dataset = dataset.repeat(); // Бесконечное повторение для эпох
 
// Итерация по датасету
using var enumerator = dataset.make_one_shot_iterator();
var nextBatch = enumerator.get_next();
using var session = tf.Session();
while (true)
{
    try
    {
        var batch = session.run(nextBatch);
        // Обработка мини-пакета...
    }
    catch (TFOutOfRangeException)
    {
        break; // Конец датасета
    }
}

// Создание последовательной модели с использованием Keras API
var model = new Sequential();
model.Add(new Dense(128, activation: "relu", input_shape: new Shape(784)));
model.Add(new Dropout(0.2f));
model.Add(new Dense(10, activation: "softmax"));
 
// Компиляция модели
model.Compile(
    optimizer: "adam",
    loss: "sparse_categorical_crossentropy",
    metrics: new[] { "accuracy" }
);
 
// Обучение модели
model.Fit(
    x_train, y_train,
    batch_size: 32,
    epochs: 5,
    validation_data: (x_test, y_test)
);

// Загрузка предобученной модели без выходного слоя
var baseModel = tf.keras.applications.MobileNetV2(
    include_top: false, 
    input_shape: new Shape(224, 224, 3),
    weights: "imagenet"
);
 
// Заморозка весов базовой модели
baseModel.trainable = false;
 
// Добавление своих слоёв
var model = new Sequential();
model.Add(baseModel);
model.Add(new GlobalAveragePooling2D());
model.Add(new Dense(1024, activation: "relu"));
model.Add(new Dense(numClasses, activation: "softmax"));
 
// Компиляция и обучение
model.Compile(optimizer: "adam", loss: "categorical_crossentropy", metrics: new[] { "accuracy" });

// Создание сверточной нейронной сети для классификации изображений
var model = new Sequential(new Layer[]
{
    new InputLayer(inputShape: new Shape(28, 28, 1)),
    new Conv2D(32, kernelSize: (3, 3), activation: "relu"),
    new MaxPooling2D(poolSize: (2, 2)),
    new Conv2D(64, kernelSize: (3, 3), activation: "relu"),
    new MaxPooling2D(poolSize: (2, 2)),
    new Flatten(),
    new Dense(128, activation: "relu"),
    new Dense(10, activation: "softmax")
});

// Определяем структуру данных
public class SentimentData
{
    [LoadColumn(0)] public string Text { get; set; }
    [LoadColumn(1), ColumnName("Label")] public bool Sentiment { get; set; }
}
 
public class SentimentPrediction
{
    [ColumnName("PredictedLabel")] public bool Prediction { get; set; }
    public float Probability { get; set; }
    public float Score { get; set; }
}
 
// Создаем конвейер обработки и обучения
var pipeline = context.Transforms.Text
    .FeaturizeText("Features", nameof(SentimentData.Text))
    .Append(context.BinaryClassification.Trainers
        .SdcaLogisticRegression(labelColumnName: "Label", featureColumnName: "Features"));
 
// Обучаем модель
var model = pipeline.Fit(trainData);
 
// Используем модель для предсказаний
var predictionEngine = context.Model
    .CreatePredictionEngine<SentimentData, SentimentPrediction>(model);
var prediction = predictionEngine.Predict(new SentimentData { Text = "Этот продукт просто великолепен!" });
Console.WriteLine($"Положительный отзыв: {prediction.Prediction} с вероятностью: {prediction.Probability:P2}");

var customMapping = context.Transforms.CustomMapping<InputData, ProcessedData>(
    (input, output) => {
        output.HasFinancialTerms = ContainsFinancialTerms(input.Text);
        output.StructureScore = AnalyzeStructure(input.Text);
        // Другие преобразования...
    },
    "CustomFeatureExtractor");
 
var enhancedPipeline = pipeline.Append(customMapping);

// Загрузка предобученной модели
var modelPath = "inception_v3";
var model = tf.keras.models.load_model(modelPath);
 
// Подготовка изображения
var imageTensor = ImageUtil.ReadTensorFromImageFile(
    "dog.jpg",
    height: 299,
    width: 299,
    mean: 0,
    scale: 1.0f / 255f);
 
// Получение предсказания
var prediction = model.predict(imageTensor);
var result = prediction.numpy();

// Детекция объектов с YOLO
var yoloModel = tf.keras.models.load_model("yolov4");
var detections = yoloModel.predict(preprocessedImage);
var boxes = ProcessYoloOutput(detections); // Извлечение координат рамок
 
// Для каждой рамки вырезаем часть изображения и классифицируем
foreach (var box in boxes)
{
    var croppedImage = CropImage(originalImage, box);
    var productImage = PreprocessForClassifier(croppedImage);
    var productClass = classifierModel.predict(productImage);
    Console.WriteLine($"Обнаружен товар: {GetProductName(productClass)} на полке {box.ShelfId}");
}

// Структура данных для рекомендаций
public class ProductRating
{
    [LoadColumn(0)] public float UserId { get; set; }
    [LoadColumn(1)] public float ProductId { get; set; }
    [LoadColumn(2)] public float Rating { get; set; }
}
 
public class ProductPrediction
{
    public float Score { get; set; }
}
 
// Создание и обучение модели
var options = new MatrixFactorizationTrainer.Options
{
    MatrixColumnIndexColumnName = nameof(ProductRating.UserId),
    MatrixRowIndexColumnName = nameof(ProductRating.ProductId),
    LabelColumnName = nameof(ProductRating.Rating),
    NumberOfIterations = 20,
    ApproximationRank = 100
};
 
var pipeline = context.Recommendation().Trainers.MatrixFactorization(options);
var model = pipeline.Fit(trainData);
 
// Получение рекомендаций для пользователя
var predictionEngine = context.Model
    .CreatePredictionEngine<ProductRating, ProductPrediction>(model);
 
// Предсказание рейтинга для товара, который пользователь еще не оценивал
var prediction = predictionEngine.Predict(
    new ProductRating { UserId = 42, ProductId = 123 });
Console.WriteLine($"Предполагаемый рейтинг: {prediction.Score}");

// Создание прогноза временного ряда
var forecastingPipeline = context.Forecasting.ForecastBySsa(
    outputColumnName: nameof(SalesForecast.Forecast),
    inputColumnName: nameof(SalesData.Sales),
    windowSize: 7,      // Размер скользящего окна
    seriesLength: 30,   // Длина ряда для анализа
    trainSize: 365,     // Количество точек для обучения
    horizon: 7);        // Горизонт прогнозирования (неделя вперед)
 
// Обучение модели
var model = forecastingPipeline.Fit(salesData);
 
// Прогнозирование
var forecasts = model.Transform(testData);

// Создаем признаки из временного ряда
var timeSeriesTransforms = context.Transforms.DetectSeasonality(
    outputColumnName: "SeasonalityFeatures",
    inputColumnName: nameof(SalesData.Sales),
    windowSize: 30)
.Append(context.Transforms.DetectAnomalies(
    outputColumnName: "AnomalyScores",
    inputColumnName: nameof(SalesData.Sales)));
 
// Добавляем внешние факторы
var combinedData = salesData.Join(
    marketingData,
    s => s.Date,
    m => m.Date,
    (s, m) => new { s.Sales, s.Date, m.MarketingBudget, m.Holidays });
 
// Обучаем комбинированную модель
var regressionPipeline = context.Transforms.Concatenate(
    "Features",
    "SeasonalityFeatures", "AnomalyScores", 
    nameof(combinedData.MarketingBudget), nameof(combinedData.Holidays))
.Append(context.Regression.Trainers.FastTree());

var tokenizationPipeline = context.Transforms.Text.TokenizeIntoWords(
    "Tokens", 
    nameof(TextData.Text))
.Append(context.Transforms.Text.RemoveDefaultStopWords(
    "TokensWithoutStopWords",
    "Tokens",
    language: StopWordsRemovingEstimator.Language.Russian))
.Append(context.Transforms.Text.ProduceNgrams(
    "Ngrams",
    "TokensWithoutStopWords"));

// Создание модели Word2Vec
var corpus = new[] { "я люблю машинное обучение", "нейронные сети это круто" };
var tokens = corpus.Select(s => s.Split(' ')).ToArray();
 
var model = new Word2Vec(tokens, 
    embeddingSize: 100, 
    windowSize: 5, 
    minCount: 1);
model.Train(epochs: 1000);
 
var vector = model.GetWordVector("обучение");

// LSTM модель для классификации текста
var model = new Sequential();
model.Add(new Embedding(inputDim: vocabSize, outputDim: 128, inputLength: maxSequenceLength));
model.Add(new Bidirectional(new LSTM(64, returnSequences: true)));
model.Add(new GlobalMaxPooling1D());
model.Add(new Dense(32, activation: "relu"));
model.Add(new Dense(numClasses, activation: "softmax"));
 
model.Compile(optimizer: "adam", loss: "categorical_crossentropy", metrics: new[] { "accuracy" });

// Загрузка предобученной BERT модели
var tokenizer = new BertTokenizer("vocab.txt");
var bertModel = TFBertModel.FromPretrained("bert-base-multilingual-cased");
 
// Подготовка текста
var encodedInput = tokenizer.Encode(
    "Машинное обучение - это интересно.",
    maxLength: 128,
    truncation: true,
    padding: PaddingStrategy.MaxLength);
 
// Получение эмбеддингов
var output = bertModel.Call(encodedInput);

public interface IModelStrategy
{
    ITransformer Train(MLContext context, IDataView trainingData);
    void Evaluate(MLContext context, ITransformer model, IDataView testData);
}
 
public class LogisticRegressionStrategy : IModelStrategy
{
    public ITransformer Train(MLContext context, IDataView trainingData)
    {
        var pipeline = context.Transforms.Text.FeaturizeText("Features", "Text")
            .Append(context.BinaryClassification.Trainers.LbfgsLogisticRegression());
        return pipeline.Fit(trainingData);
    }
    
    public void Evaluate(MLContext context, ITransformer model, IDataView testData)
    {
        // Логика оценки модели...
    }
}

public abstract class ModelTrainerBase
{
    protected readonly MLContext _context;
    
    protected ModelTrainerBase(MLContext context)
    {
        _context = context;
    }
    
    public ITransformer TrainModel(IDataView trainingData)
    {
        PreprocessData(trainingData);
        var pipeline = BuildPipeline();
        var model = pipeline.Fit(trainingData);
        EvaluateModel(model, trainingData);
        return model;
    }
    
    protected abstract IEstimator<ITransformer> BuildPipeline();
    protected virtual void PreprocessData(IDataView data) { }
    protected virtual void EvaluateModel(ITransformer model, IDataView data) { }
}

public interface IModelFactory
{
    ITransformer CreateModel(string modelType, MLContext context, IDataView data);
}
 
public class MLNetModelFactory : IModelFactory
{
    public ITransformer CreateModel(string modelType, MLContext context, IDataView data)
    {
        switch (modelType)
        {
            case "LogisticRegression":
                var logisticPipeline = context.Transforms.Text.FeaturizeText("Features", "Text")
                    .Append(context.BinaryClassification.Trainers.LbfgsLogisticRegression());
                return logisticPipeline.Fit(data);
            
            case "FastTree":
                var fastTreePipeline = context.Transforms.Text.FeaturizeText("Features", "Text")
                    .Append(context.BinaryClassification.Trainers.FastTree());
                return fastTreePipeline.Fit(data);
            
            default:
                throw new ArgumentException($"Unsupported model type: {modelType}");
        }
    }
}

public void ConfigureServices(IServiceCollection services)
{
    // MLContext должен быть синглтоном для всего приложения
    services.AddSingleton<MLContext>(new MLContext(seed: 42));
    
    // Сервисы для работы с моделями
    services.AddScoped<IModelTrainer, SentimentModelTrainer>();
    services.AddScoped<IModelEvaluator, ModelEvaluator>();
    
    // Репозиторий моделей - управляет загрузкой/сохранением
    services.AddSingleton<IModelRepository, FileSystemModelRepository>();
    
    // Предсказатель - создает PredictionEngine для каждого запроса
    services.AddTransient<IPredictionService, PredictionService>();
}

public class PredictionEnginePool<TData, TPrediction> where TData : class where TPrediction : class, new()
{
    private readonly ObjectPool<PredictionEngine<TData, TPrediction>> _pool;
    private readonly ITransformer _model;
    private readonly MLContext _mlContext;
 
    public PredictionEnginePool(MLContext mlContext, ITransformer model)
    {
        _mlContext = mlContext;
        _model = model;
        _pool = new DefaultObjectPool<PredictionEngine<TData, TPrediction>>(
            new PredictionEnginePoolPolicy<TData, TPrediction>(mlContext, model));
    }
 
    public TPrediction Predict(TData data)
    {
        var engine = _pool.Get();
        try
        {
            return engine.Predict(data);
        }
        finally
        {
            _pool.Return(engine);
        }
    }
}

public class HotSwappableModel<TData, TPrediction> where TData : class where TPrediction : class, new()
{
    private PredictionEnginePool<TData, TPrediction> _activePool;
    private readonly object _swapLock = new object();
    private readonly MLContext _mlContext;
 
    public HotSwappableModel(MLContext mlContext, ITransformer initialModel)
    {
        _mlContext = mlContext;
        _activePool = new PredictionEnginePool<TData, TPrediction>(mlContext, initialModel);
    }
 
    public void SwapModel(ITransformer newModel)
    {
        var newPool = new PredictionEnginePool<TData, TPrediction>(_mlContext, newModel);
        
        lock (_swapLock)
        {
            var oldPool = _activePool;
            _activePool = newPool;
            // Старый пул можно утилизировать позже
        }
    }
 
    public TPrediction Predict(TData data)
    {
        return _activePool.Predict(data);
    }
}

public class DataCollector
{
    private readonly CorporateDbContext _dbContext;
    private readonly MLContext _mlContext;
 
    public DataCollector(CorporateDbContext dbContext, MLContext mlContext)
    {
        _dbContext = dbContext;
        _mlContext = mlContext;
    }
 
    public IDataView CollectTrainingData()
    {
        var trainingData = _dbContext.Transactions
            .Where(t => t.Date > DateTime.Now.AddMonths(-3))
            .Select(t => new TransactionData
            {
                Amount = t.Amount,
                MerchantType = t.MerchantType,
                IsWeekend = t.Date.DayOfWeek == DayOfWeek.Saturday || t.Date.DayOfWeek == DayOfWeek.Sunday,
                IsOverlimit = t.IsFraudulent
            })
            .ToList();
 
        return _mlContext.Data.LoadFromEnumerable(trainingData);
    }
}

public class PredictionPublisher
{
    private readonly IEventBus _eventBus;
    
    public async Task PublishPrediction<TData, TPrediction>(TData inputData, TPrediction prediction, string modelId)
    {
        var predictionEvent = new PredictionCompletedEvent
        {
            ModelId = modelId,
            Timestamp = DateTime.UtcNow,
            InputData = JsonSerializer.Serialize(inputData),
            Prediction = JsonSerializer.Serialize(prediction)
        };
        
        await _eventBus.PublishAsync(predictionEvent);
    }
}

// Конфигурация для AOT-компиляции в .csproj
<PropertyGroup>
  <PublishAot>true</PublishAot>
  <OptimizationPreference>Speed</OptimizationPreference>
</PropertyGroup>

// Векторизированное умножение матриц с помощью нового API
var a = new Tensor<float>(new[] { 2, 3 }); // матрица 2x3
var b = new Tensor<float>(new[] { 3, 2 }); // матрица 3x2
var c = Tensor.MatMul(a, b); // результат 2x2

[Benchmark]
public float[] PredictWithJit()
{
    return _jitModel.Predict(_sampleData);
}
 
[Benchmark]
public float[] PredictWithAot()
{
    return _aotModel.Predict(_sampleData);
}

// Векторизированная операция умножения весов
private float[] ApplyWeights(float[] input, float[] weights)
{
    var result = new float[input.Length];
    for (int i = 0; i < input.Length; i += Vector<float>.Count)
    {
        var vi = new Vector<float>(input, i);
        var vw = new Vector<float>(weights, i);
        var vr = vi * vw;
        vr.CopyTo(result, i);
    }
    return result;
}