Машинное обучение на C#: TensorFlow.NET и нейросети

// Скажу честно, мне нравится, как это выглядит в C#
var model = tf.keras.Sequential();
model.Add(tf.keras.layers.Dense(64, activation: tf.keras.activations.ReLU));
model.Add(tf.keras.layers.Dense(10, activation: tf.keras.activations.Softmax));

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

Install-Package Keras.NET

Install-Package TensorFlow.NET -Version 0.40.0

using TensorFlow;
using static TensorFlow.Binding;
using NumSharp;

// Без статического импорта
var tensor = TensorFlow.Binding.tf.constant(new int[] { 1, 2, 3 });
 
// С статическим импортом — намного чище
var tensor = tf.constant(new int[] { 1, 2, 3 });

var hello = tf.constant("Привет, TensorFlow.NET!");
using (var session = new TFSession())
{
    var result = session.run(hello);
    Console.WriteLine(result.ToString());
}

using (var tensor = tf.constant(3.14f))
using (var anotherTensor = tf.constant(2.71f))
using (var result = tf.add(tensor, anotherTensor))
{
    Console.WriteLine(result.numpy());
}

// После тяжёлых вычислений
GC.Collect();
GC.WaitForPendingFinalizers();

Uninstall-Package SciSharp.TensorFlow.Redist
Install-Package SciSharp.TensorFlow.Redist-Windows-GPU

var gpus = tf.config.list_physical_devices("GPU");
foreach (var gpu in gpus)
{
    Console.WriteLine($"Найден GPU: {gpu}");
}

var model = tf.keras.Sequential();
model.Add(tf.keras.layers.InputLayer(inputShape: 784));
model.Add(tf.keras.layers.Dense(128, activation: tf.nn.relu));
model.Add(tf.keras.layers.Dense(10, activation: tf.nn.softmax));

// Загружаем данные MNIST
var (x_train, y_train, x_test, y_test) = tf.keras.datasets.mnist.load_data();
 
// Нормализуем пиксели к диапазону [0, 1]
x_train = x_train.reshape(x_train.shape[0], 784) / 255f;
x_test = x_test.reshape(x_test.shape[0], 784) / 255f;
 
// One-hot кодирование меток
y_train = tf.keras.utils.to_categorical(y_train, 10);
y_test = tf.keras.utils.to_categorical(y_test, 10);
 
// Создаём модель
var model = tf.keras.Sequential();
model.Add(tf.keras.layers.Dense(128, activation: tf.nn.relu, input_shape: new Shape(784)));
model.Add(tf.keras.layers.Dropout(0.2f)); // Дропаут против переобучения
model.Add(tf.keras.layers.Dense(10, activation: tf.nn.softmax));
 
// Компилируем модель
model.Compile(
    optimizer: tf.keras.optimizers.Adam(),
    loss: tf.keras.losses.CategoricalCrossentropy(),
    metrics: new[] { "accuracy" }
);
 
// Обучаем
model.Fit(x_train, y_train, batch_size: 128, epochs: 5, validation_data: (x_test, y_test));
 
// Оцениваем точность
var (loss, accuracy) = model.Evaluate(x_test, y_test);
Console.WriteLine($"Точность на тестовой выборке: {accuracy:P2}");

// Убираем пропуски в данных
var dataFrame = dataFrame.FillNa(0); // Заполняем пропуски нулями
 
// Кодируем категориальные признаки
var encoder = new OneHotEncoder();
var categoricalFeatures = encoder.Fit_transform(dataFrame["category"]);
 
// Масштабируем числовые признаки
var scaler = new StandardScaler();
var numericalFeatures = scaler.Fit_transform(dataFrame[new[] {"feature1", "feature2"}]);
 
// Объединяем признаки
var allFeatures = np.concatenate(numericalFeatures, categoricalFeatures, axis: 1);

// Отслеживаем метрики во время обучения
var history = model.Fit(x_train, y_train, 
    batch_size: 128, 
    epochs: 10, 
    validation_split: 0.2f, 
    verbose: 1); // verbose: 1 выводит прогресс-бар
 
// После обучения можем построить графики
var accuracyHistory = history.History["accuracy"];
var valAccuracyHistory = history.History["val_accuracy"];
 
// Тут можно использовать любую библиотеку для построения графиков
// Например, OxyPlot или ScottPlot
var plt = new ScottPlot.Plot(600, 400);
plt.AddScatter(Enumerable.Range(1, accuracyHistory.Count).Select(i => (double)i).ToArray(), 
    accuracyHistory.Select(a => (double)a).ToArray(), 
    label: "Точность на тренировочной выборке");
plt.AddScatter(Enumerable.Range(1, valAccuracyHistory.Count).Select(i => (double)i).ToArray(), 
    valAccuracyHistory.Select(a => (double)a).ToArray(), 
    label: "Точность на валидационной выборке");
plt.SaveFig("accuracy_history.png");

// Определяем число фолдов (частей) для кросс-валидации
int numFolds = 5;
var accuracies = new List<float>();
 
// Создаём разбиения данных
var indices = Enumerable.Range(0, x_train.shape[0]).ToArray();
var random = new Random(42); // Фиксируем сид для воспроизводимости
indices = indices.OrderBy(x => random.Next()).ToArray();
 
var foldSize = x_train.shape[0] / numFolds;
 
for (int fold = 0; fold < numFolds; fold++)
{
    Console.WriteLine($"Обрабатываем фолд {fold + 1}/{numFolds}");
    
    // Выделяем индексы для валидации в текущем фолде
    var valIndicesStart = fold * foldSize;
    var valIndicesEnd = (fold + 1) * foldSize;
    
    // Разделяем на обучающую и валидационную выборки
    var trainIndices = indices.Where((i, idx) => idx < valIndicesStart || idx >= valIndicesEnd).ToArray();
    var valIndices = indices.Where((i, idx) => idx >= valIndicesStart && idx < valIndicesEnd).ToArray();
    
    var x_fold_train = tf.gather(x_train, trainIndices);
    var y_fold_train = tf.gather(y_train, trainIndices);
    var x_fold_val = tf.gather(x_train, valIndices);
    var y_fold_val = tf.gather(y_train, valIndices);
    
    // Создаём новую модель для каждого фолда
    var model = tf.keras.Sequential();
    model.Add(tf.keras.layers.Dense(128, activation: tf.nn.relu, input_shape: new Shape(784)));
    model.Add(tf.keras.layers.Dropout(0.2f));
    model.Add(tf.keras.layers.Dense(10, activation: tf.nn.softmax));
    
    model.Compile(
        optimizer: tf.keras.optimizers.Adam(),
        loss: tf.keras.losses.CategoricalCrossentropy(),
        metrics: new[] { "accuracy" }
    );
    
    // Обучаем на текущем фолде
    model.Fit(x_fold_train, y_fold_train, batch_size: 128, epochs: 3, verbose: 0);
    
    // Оцениваем на валидационной выборке текущего фолда
    var (_, accuracy) = model.Evaluate(x_fold_val, y_fold_val);
    accuracies.Add(accuracy);
}
 
// Выводим среднюю точность по всем фолдам
Console.WriteLine($"Средняя точность по {numFolds} фолдам: {accuracies.Average():P2}");
Console.WriteLine($"Стандартное отклонение: {Math.Sqrt(accuracies.Select(a => Math.Pow(a - accuracies.Average(), 2)).Sum() / numFolds):P2}");

// Предположим, у нас есть бинарная классификация с сильным дисбалансом классов
 
// Способ 1: Взвешивание классов при обучении
var classWeights = new Dictionary<int, float>
{
    [0] = 1.0f,  // Мажоритарный класс (90% примеров)
    [1] = 9.0f   // Миноритарный класс (10% примеров) - вес в 9 раз больше
};
 
model.Fit(x_train, y_train, 
    batch_size: 128, 
    epochs: 10, 
    class_weight: classWeights);
 
// Способ 2: Апсэмплинг миноритарного класса
var minorityIndices = Enumerable.Range(0, y_train.shape[0])
    .Where(i => y_train[i][1] > 0.5f)  // Индексы примеров миноритарного класса
    .ToArray();
 
// Дублируем примеры миноритарного класса для баланса
var augmentedIndices = Enumerable.Range(0, y_train.shape[0])
    .Concat(minorityIndices.SelectMany(_ => minorityIndices)) // Добавляем примеры миноритарного класса несколько раз
    .ToArray();
 
var x_train_balanced = tf.gather(x_train, augmentedIndices);
var y_train_balanced = tf.gather(y_train, augmentedIndices);
 
// Обучаемся на балансированных данных
model.Fit(x_train_balanced, y_train_balanced, batch_size: 128, epochs: 10);

// Создаём кастомную метрику F1-score
// К сожалению, стандартной реализации F1 в TensorFlow.NET пока нет, 
// приходится писать свою
 
class F1Score : IMetric 
{
    public string Name => "f1";
    
    public Tensor Call(Tensor y_true, Tensor y_pred)
    {
        // Переводим вероятности в предсказания классов
        var predicted_positives = tf.cast(tf.greater(y_pred, 0.5f), TF_DataType.TF_FLOAT);
        var true_positives = tf.cast(tf.logical_and(
            tf.cast(tf.equal(y_true, 1), tf.bool), 
            tf.cast(tf.equal(predicted_positives, 1), tf.bool)), 
        TF_DataType.TF_FLOAT);
        
        var precision = tf.reduce_sum(true_positives) / (tf.reduce_sum(predicted_positives) + tf.keras.backend.epsilon());
        var recall = tf.reduce_sum(true_positives) / (tf.reduce_sum(y_true) + tf.keras.backend.epsilon());
        
        return 2 * precision * recall / (precision + recall + tf.keras.backend.epsilon());
    }
}
 
// Используем кастомную метрику при компиляции модели
model.Compile(
    optimizer: tf.keras.optimizers.Adam(),
    loss: tf.keras.losses.BinaryCrossentropy(),
    metrics: new[] { new F1Score() }
);

// Параметры архитектуры
int[] hiddenLayers = new[] { 64, 128, 256 }; // Размер скрытых слоёв
float[] dropoutRates = new[] { 0.0f, 0.2f, 0.5f }; // Уровень дропаута
 
// Параметры обучения
float[] learningRates = new[] { 0.001f, 0.01f, 0.1f }; // Скорость обучения
int[] batchSizes = new[] { 32, 64, 128 }; // Размер мини-батча

var random = new Random(42);
var bestAccuracy = 0.0f;
var bestParams = new Dictionary<string, object>();
 
for (int i = 0; i < 20; i++) // Пробуем 20 случайных комбинаций
{
    // Выбираем случайные значения
    var hiddenSize = hiddenLayers[random.Next(hiddenLayers.Length)];
    var dropout = dropoutRates[random.Next(dropoutRates.Length)];
    var lr = learningRates[random.Next(learningRates.Length)];
    var batchSize = batchSizes[random.Next(batchSizes.Length)];
    
    var model = tf.keras.Sequential();
    model.Add(tf.keras.layers.Dense(hiddenSize, activation: tf.nn.relu, input_shape: new Shape(784)));
    model.Add(tf.keras.layers.Dropout(dropout));
    model.Add(tf.keras.layers.Dense(10, activation: tf.nn.softmax));
    
    model.Compile(
        optimizer: tf.keras.optimizers.Adam(lr),
        loss: tf.keras.losses.CategoricalCrossentropy(),
        metrics: new[] { "accuracy" }
    );
    
    model.Fit(x_train, y_train, batch_size: batchSize, epochs: 5, verbose: 0);
    
    var (_, accuracy) = model.Evaluate(x_test, y_test);
    Console.WriteLine($"Комбинация {i+1}: Слой={hiddenSize}, Дропаут={dropout}, " +
                       $"LR={lr}, Батч={batchSize}, Точность={accuracy:P2}");
    
    if (accuracy > bestAccuracy)
    {
        bestAccuracy = accuracy;
        bestParams["hiddenSize"] = hiddenSize;
        bestParams["dropout"] = dropout;
        bestParams["learningRate"] = lr;
        bestParams["batchSize"] = batchSize;
    }
}
 
Console.WriteLine($"Лучшая конфигурация: {string.Join(", ", bestParams.Select(p => $"{p.Key}={p.Value}"))}");
Console.WriteLine($"Точность: {bestAccuracy:P2}");

// Сохраняем модель в формате SavedModel (универсальный формат TensorFlow)
model.Save("mnist_model");
 
// Сохраняем модель в формате HDF5 (удобен для переноса между разными языками)
model.Save("mnist_model.h5", saveFormat: "h5");
 
// Загружаем модель
var loadedModel = tf.keras.models.load_model("mnist_model");
// или
var loadedModelH5 = tf.keras.models.load_model("mnist_model.h5");

// Предполагаем, что у нас есть новое изображение цифры
float[] newImage = LoadAndPreprocessImage("seven.png"); // Реализацию этой функции опустим
 
// Преобразуем в нужный формат тензора
var input = tf.reshape(newImage, new Shape(1, 784));
 
// Делаем предсказание
var predictions = model.Predict(input);
 
// Получаем номер класса с максимальной вероятностью
var predictedClass = tf.argmax(predictions[0]);
Console.WriteLine($"Это похоже на цифру: {predictedClass.numpy()}");
 
// Выводим вероятности для всех классов
for (int i = 0; i < 10; i++)
{
    Console.WriteLine($"Вероятность {i}: {predictions[0][i]:P2}");
}

// Добавляем колбэк для мониторинга градиентов
model.Fit(x_train, y_train, callbacks: new[] 
{
    new TensorBoard(logDir: "./logs", histogramFreq: 1)
    // В логах TensorBoard можно будет увидеть распределение градиентов
});

model.Add(tf.keras.layers.Dense(128, 
                                activation: tf.nn.relu, 
                                kernelRegularizer: tf.keras.regularizers.l2(0.001f)));

// Создаём сверточную сеть для классификации изображений
var model = tf.keras.Sequential();
 
// Первая пара слоёв: свертка + пулинг
model.Add(tf.keras.layers.Conv2D(32, 
                             kernelSize: (3, 3),
                             activation: tf.keras.activations.ReLU,
                             inputShape: (32, 32, 3))); // 32x32 RGB-изображения
model.Add(tf.keras.layers.MaxPooling2D(poolSize: (2, 2)));
 
// Вторая пара: увеличиваем количество фильтров
model.Add(tf.keras.layers.Conv2D(64, 
                             kernelSize: (3, 3),
                             activation: tf.keras.activations.ReLU));
model.Add(tf.keras.layers.MaxPooling2D(poolSize: (2, 2)));
 
// Преобразуем карты признаков в плоский вектор
model.Add(tf.keras.layers.Flatten());
 
// Полносвязные слои для классификации
model.Add(tf.keras.layers.Dense(64, activation: tf.keras.activations.ReLU));
model.Add(tf.keras.layers.Dropout(0.5f));
model.Add(tf.keras.layers.Dense(10, activation: tf.keras.activations.Softmax));

// Простая RNN для анализа предложений
var model = tf.keras.Sequential();
 
// Слой эмбеддингов превращает индексы слов в векторы
model.Add(tf.keras.layers.Embedding(inputDim: vocabSize, 
                                outputDim: 128, 
                                inputLength: maxSequenceLength));
 
// Слой LSTM (улучшенная версия RNN, решающая проблему затухающих градиентов)
model.Add(tf.keras.layers.LSTM(units: 64, returnSequences: false));
 
// Классификатор на выходе
model.Add(tf.keras.layers.Dense(numClasses, activation: tf.keras.activations.Softmax));

// Двунаправленный LSTM для улучшенного понимания контекста
model.Add(tf.keras.layers.Bidirectional(
    tf.keras.layers.LSTM(units: 64, returnSequences: true),
    inputShape: new Shape(maxSequenceLength, featureSize)
));

// Загружаем предобученную MobileNetV2
var baseModel = tf.keras.applications.MobileNetV2(
    inputShape: new Shape(224, 224, 3),
    include_top: false,
    weights: "imagenet"
);
 
// Замораживаем веса базовой модели
baseModel.trainable = false;
 
// Добавляем свои слои для классификации
var model = tf.keras.Sequential();
model.Add(baseModel);
model.Add(tf.keras.layers.GlobalAveragePooling2D());
model.Add(tf.keras.layers.Dense(1024, activation: tf.keras.activations.ReLU));
model.Add(tf.keras.layers.Dense(myClassCount, activation: tf.keras.activations.Softmax));

// Определяем генератор
var generator = tf.keras.Sequential();
generator.Add(tf.keras.layers.Dense(7 * 7 * 256, use_bias: false, input_shape: (100)));
generator.Add(tf.keras.layers.BatchNormalization());
generator.Add(tf.keras.layers.LeakyReLU());
generator.Add(tf.keras.layers.Reshape((7, 7, 256)));
// Добавляем несколько слоёв Conv2DTranspose для "разворачивания" изображения
generator.Add(tf.keras.layers.Conv2DTranspose(128, (5, 5), strides: (1, 1), padding: "same", use_bias: false));
generator.Add(tf.keras.layers.BatchNormalization());
generator.Add(tf.keras.layers.LeakyReLU());
// Финальный слой для создания изображения
generator.Add(tf.keras.layers.Conv2DTranspose(1, (5, 5), strides: (2, 2), padding: "same", use_bias: false, activation: "tanh"));
 
// Определяем дискриминатор
var discriminator = tf.keras.Sequential();
discriminator.Add(tf.keras.layers.Conv2D(64, (5, 5), strides: (2, 2), padding: "same", input_shape: (28, 28, 1)));
discriminator.Add(tf.keras.layers.LeakyReLU());
discriminator.Add(tf.keras.layers.Dropout(0.3f));
// Дополнительные сверточные слои
discriminator.Add(tf.keras.layers.Conv2D(128, (5, 5), strides: (2, 2), padding: "same"));
discriminator.Add(tf.keras.layers.LeakyReLU());
discriminator.Add(tf.keras.layers.Dropout(0.3f));
// Выходной слой для бинарной классификации: настоящее/поддельное
discriminator.Add(tf.keras.layers.Flatten());
discriminator.Add(tf.keras.layers.Dense(1));

// Создаём автоэнкодер для обнаружения аномалий
var input = tf.keras.Input(shape: (784)); // Вход для MNIST
 
// Энкодер (сжимающая часть)
var encoded = tf.keras.layers.Dense(128, activation: "relu").Apply(input);
encoded = tf.keras.layers.Dense(64, activation: "relu").Apply(encoded);
encoded = tf.keras.layers.Dense(32, activation: "relu").Apply(encoded);
 
// Латентное представление (код)
var latent = tf.keras.layers.Dense(16, activation: "relu").Apply(encoded);
 
// Декодер (восстанавливающая часть)
var decoded = tf.keras.layers.Dense(32, activation: "relu").Apply(latent);
decoded = tf.keras.layers.Dense(64, activation: "relu").Apply(decoded);
decoded = tf.keras.layers.Dense(128, activation: "relu").Apply(decoded);
var output = tf.keras.layers.Dense(784, activation: "sigmoid").Apply(decoded);
 
// Создаём модель автоэнкодера
var autoencoder = tf.keras.Model(input, output);
 
// Компилируем модель с метрикой MSE — она будет показывать ошибку реконструкции
autoencoder.Compile(optimizer: "adam", loss: "mse", metrics: new[] { "mse" });
 
// Обучаем только на нормальных данных
autoencoder.Fit(normalData, normalData, epochs: 50, batch_size: 128, validation_split: 0.2f);
 
// Теперь можем использовать для обнаружения аномалий
var testReconstruction = autoencoder.Predict(testData);
var mse = new List<float>();
 
// Вычисляем ошибку реконструкции для каждого примера
for (int i = 0; i < testData.shape[0]; i++)
{
    var originalImage = testData[i];
    var reconstructedImage = testReconstruction[i];
    mse.Add(MeanSquaredError(originalImage.numpy(), reconstructedImage.numpy()));
}
 
// Примеры с высокой ошибкой — потенциальные аномалии
var threshold = CalculateThreshold(mse.ToArray());
var anomalies = mse.Select((error, index) => new { Error = error, Index = index })
                  .Where(x => x.Error > threshold)
                  .Select(x => x.Index)
                  .ToArray();

// Предполагаем, что модель уже обучена
var model = LoadModel("cnn_model");
 
// Функция для извлечения активаций конкретного слоя
Tensor GetLayerActivation(Tensor inputImage, int layerIndex)
{
    // Создаем усеченную модель, возвращающую выход указанного слоя
    var layer = model.Layers[layerIndex];
    var truncatedModel = tf.keras.Model(model.Input, layer.Output);
    
    // Получаем активации
    return truncatedModel.Predict(inputImage);
}
 
// Получаем активации третьего сверточного слоя для тестового изображения
var image = LoadAndPreprocessImage("test_image.jpg");
var activations = GetLayerActivation(image, 2); // Индекс сверточного слоя
 
// Теперь можем визуализировать эти активации
// Например, сохраняя их как изображения через ScottPlot или другую библиотеку

// Функция для создания CAM (Class Activation Map)
Tensor GenerateClassActivationMap(Tensor inputImage, int targetClass)
{
    // Получаем выходы последнего сверточного слоя
    var lastConvLayer = model.Layers
        .Where(l => l.GetType().Name.Contains("Conv2D"))
        .Last();
    
    var convOutputModel = tf.keras.Model(model.Input, lastConvLayer.Output);
    var convOutputs = convOutputModel.Predict(inputImage);
    
    // Получаем веса для целевого класса
    var classifierLayer = model.Layers.Last();
    var targetClassWeights = classifierLayer.get_weights()[0][:,targetClass];
    
    // Умножаем карты признаков на веса и суммируем для получения CAM
    var cam = tf.reduce_sum(
        tf.multiply(convOutputs, targetClassWeights),
        axis: -1
    );
    
    return cam;
}

// L1-регуляризация (лассо) — штрафует абсолютные значения весов
// Хороша для получения разреженных весов (много нулей)
model.Add(tf.keras.layers.Dense(128, 
                           activation: tf.nn.relu, 
                           kernelRegularizer: tf.keras.regularizers.l1(0.001f)));
 
// L2-регуляризация (гребневая) — штрафует квадраты весов
// Предпочтительна для большинства задач
model.Add(tf.keras.layers.Dense(128, 
                           activation: tf.nn.relu, 
                           kernelRegularizer: tf.keras.regularizers.l2(0.001f)));
 
// Комбинированная L1 и L2 (ElasticNet)
model.Add(tf.keras.layers.Dense(128, 
                           activation: tf.nn.relu, 
                           kernelRegularizer: tf.keras.regularizers.l1_l2(l1: 0.001f, l2: 0.001f)));

// Колбэк для ранней остановки
var earlyStoppingCallback = tf.keras.callbacks.EarlyStopping(
    monitor: "val_loss",
    patience: 5,  // Ждём 5 эпох без улучшения, затем останавливаемся
    restoreBestWeights: true  // Возвращаем веса с лучшей валидационной ошибкой
);
 
// Используем при обучении
model.Fit(x_train, y_train, 
      batch_size: 32, 
      epochs: 100,  // Максимальное число эпох
      validationData: (x_val, y_val),
      callbacks: new[] { earlyStoppingCallback });

// Обучаем несколько моделей с разной инициализацией
var models = new List<IModel>();
for (int i = 0; i < 5; i++) 
{
    var model = tf.keras.Sequential();
    // Конфигурируем модель...
    model.Compile(/* параметры */);
    model.Fit(x_train, y_train, /* параметры */);
    models.Add(model);
}
 
// Для предсказания усредняем результаты всех моделей
Tensor MakeEnsemblePrediction(Tensor input)
{
    var predictions = models.Select(m => m.Predict(input)).ToArray();
    return tf.reduce_mean(tf.stack(predictions), axis: 0);
}

// Предсказания нескольких моделей для классификации
int PredictClass(Tensor input)
{
    // Получаем предсказанные классы от каждой модели
    var predictedClasses = models.Select(m => {
        var pred = m.Predict(input);
        return tf.argmax(pred[0]).numpy();
    }).ToArray();
    
    // Находим класс с наибольшим числом "голосов"
    return predictedClasses
        .GroupBy(c => c)
        .OrderByDescending(g => g.Count())
        .First()
        .Key;
}

// Простой пример квантизации модели в TensorFlow.NET
var model = tf.keras.models.load_model("my_model");
 
// Определяем датасет для калибровки квантизации
var calibrationDataset = tf.data.Dataset.from_tensor_slices(x_cal)
                          .batch(32);
 
// Конвертируем модель в квантизованную версию
var converter = tf.lite.TFLiteConverter.from_keras_model(model);
converter.optimizations = new[] { tf.lite.Optimize.DEFAULT };
converter.representative_dataset = calibrationDataset;
converter.target_spec.supported_ops = new[] { tf.lite.OpsSet.TFLITE_BUILTINS_INT8 };
converter.inference_input_type = tf.int8;
converter.inference_output_type = tf.int8;
 
var quantizedModelContent = converter.convert();
File.WriteAllBytes("quantized_model.tflite", quantizedModelContent);

// Прунинг модели в TensorFlow.NET
var pruningSchedule = new tf.keras.optimizers.schedules.PolynomialDecay(
    initialLearningRate: 0.0, 
    decaySteps: 1000,
    endLearningRate: 0.5f 
);
 
var pruningParams = new Dictionary<string, object>
{
    ["pruning_schedule"] = pruningSchedule,
    ["block_size"] = new[] { 1, 1 },
    ["block_pooling_type"] = "AVG"
};
 
// Создаём прунинг-колбэк
var callbacks = new[]
{
    tf.keras.callbacks.PruningSummaries(log_dir: "./logs")
};
 
// Применяем прунинг к модели
var prunedModel = tf.keras.prune.prune_low_magnitude(model, **pruningParams);
 
// Продолжаем обучение с прунингом
prunedModel.Fit(x_train, y_train, 
          callbacks: callbacks, 
          validation_data: (x_val, y_val));
 
// После обучения убираем маски прунинга для финальной модели
var finalModel = tf.keras.prune.strip_pruning(prunedModel);

// Оптимизация графа перед экспортом
var config = new ConfigProto
{
    graph_options = new GraphOptions
    {
        optimizer_options = new OptimizerOptions
        {
            global_jit_level = OptimizerOptions.Types.GlobalJitLevel.ON_2,
            do_constant_folding = true,
            do_function_inlining = true
        }
    }
};
 
using (var session = tf.Session(config: config))
{
    // Выполняем операции в оптимизированной сессии
}

// Экспорт модели TensorFlow.NET в ONNX
var model = tf.keras.models.load_model("my_model");
 
// Определяем вход для модели
var spec = new tf.TensorSpec.from_tensor(tf.ones(new int[] { 1, 224, 224, 3 }));
 
// Конвертируем модель в ONNX
var onnx_model = tf.onnx.export(model, spec);
File.WriteAllBytes("model.onnx", onnx_model);

// Загрузка ONNX-модели в ML.NET
var mlContext = new MLContext();
var pipeline = mlContext.Transforms
    .ApplyOnnxModel("model.onnx");
 
// Создаём прогнозную функцию
var predictionFunction = pipeline.Fit(mlContext.Data.LoadFromEnumerable(new[] { new ModelInput() }))
    .CreatePredictionEngine<ModelInput, ModelOutput>(mlContext);
 
// Используем для прогнозирования
var prediction = predictionFunction.Predict(new ModelInput { ... });