# 第一步：安裝核心庫
dotnet add package TensorFlow.NET --version 0.150.0
# 第二步：安裝 Keras 高層 API（可選，推薦）
dotnet add package TensorFlow.Keras
# 第三步：安裝運(yùn)行時(shí)支持包（根據(jù)你的平臺選擇其一）
# Windows/Linux CPU 版本
dotnet add package SciSharp.TensorFlow.Redist
# macOS CPU 版本
dotnet add package SciSharp.TensorFlow.Redist-OSX
# Windows GPU 版本（需要 CUDA 和 cuDNN）
dotnet add package SciSharp.TensorFlow.Redist-Windows-GPU
# Linux GPU 版本（需要 CUDA 和 cuDNN）
dotnet add package SciSharp.TensorFlow.Redist-Linux-GPU

MyTfProject/
├── MyTfProject.csproj
├── Program.cs
├── models/              # 存放預(yù)訓(xùn)練模型
│   └── inception/
│       └── tensorflow_inception_graph.pb
└── images/              # 測試圖片
    └── test.jpg

using static Tensorflow.Binding;
using static Tensorflow.KerasApi;
using Tensorflow;
using Tensorflow.NumPy;

// 禁用 Eager Execution，啟用 Graph 模式
tf.compat.v1.disable_eager_execution();
var graph = tf.Graph().as_default();
graph.Import("model.pb");
using var sess = tf.Session(graph);
var result = sess.run(outputTensor, feedDict);

// 啟用 Eager Execution
tf.enable_eager_execution();
var x = tf.constant(new float[] { 1, 2, 3 });
var y = tf.constant(new float[] { 4, 5, 6 });
var z = x + y;
print(z.numpy());  // 輸出: [5 7 9]

using System;
using System.IO;
using System.Collections.Generic;
using Tensorflow;
using Tensorflow.NumPy;
using static Tensorflow.Binding;
public class InferenceExample
{
    public void Run()
    {
        // 使用 Graph 模式
        tf.compat.v1.disable_eager_execution();
        // 1. 創(chuàng)建計(jì)算圖并導(dǎo)入 .pb 模型
        var graph = tf.Graph().as_default();
        graph.Import("models/inception/tensorflow_inception_graph.pb");
        // 2. 獲取輸入和輸出操作的引用
        var input_operation = graph.OperationByName("input");
        var output_operation = graph.OperationByName("output");
        // 3. 加載標(biāo)簽文件
        var labels = File.ReadAllLines("models/inception/imagenet_comp_graph_label_strings.txt");
        // 4. 讀取并預(yù)處理輸入圖片
        var inputTensor = ReadTensorFromImageFile("images/test.jpg");
        // 5. 創(chuàng)建 Session 并執(zhí)行推理
        using var sess = tf.Session(graph);
        var results = sess.run(
            output_operation.outputs[0],
            (input_operation.outputs[0], inputTensor)
        );
        // 6. 處理結(jié)果
        results = np.squeeze(results);
        int idx = np.argmax(results);
        Console.WriteLine($"識別結(jié)果: {labels[idx]} (置信度: {results[idx]:P2})");
    }
    /// <summary>
    /// 讀取圖片文件并預(yù)處理為模型所需的 Tensor
    /// </summary>
    private NDArray ReadTensorFromImageFile(string file_name,
        int input_height = 224,
        int input_width = 224,
        int input_mean = 117,
        int input_std = 1)
    {
        // 在臨時(shí) Graph 中構(gòu)建圖片預(yù)處理流程
        var g = tf.Graph().as_default();
        var file_reader = tf.io.read_file(file_name, "file_reader");
        var decodeJpeg = tf.image.decode_jpeg(file_reader, channels: 3, name: "DecodeJpeg");
        var cast = tf.cast(decodeJpeg, tf.float32);
        var dims_expander = tf.expand_dims(cast, 0);
        var resize = tf.constant(new int[] { input_height, input_width });
        var bilinear = tf.image.resize_bilinear(dims_expander, resize);
        var sub = tf.subtract(bilinear, new float[] { input_mean });
        var normalized = tf.divide(sub, new float[] { input_std });
        using var sess = tf.Session(g);
        return sess.run(normalized);
    }
}

using System;
using System.IO;
using System.Linq;
using System.Drawing;
using Tensorflow;
using Tensorflow.NumPy;
using static Tensorflow.Binding;
public class ObjectDetectionExample
{
    public float MIN_SCORE = 0.5f;
    public void Run()
    {
        tf.compat.v1.disable_eager_execution();
        // 導(dǎo)入 MobileNet SSD 模型
        var graph = new Graph().as_default();
        graph.Import("ssd_mobilenet_v1_coco_2018_01_28/frozen_inference_graph.pb");
        // 獲取輸入輸出 Tensor 引用
        var imgTensor = graph.OperationByName("image_tensor");
        var tensorNum = graph.OperationByName("num_detections");
        var tensorBoxes = graph.OperationByName("detection_boxes");
        var tensorScores = graph.OperationByName("detection_scores");
        var tensorClasses = graph.OperationByName("detection_classes");
        // 讀取輸入圖片
        var imgArr = ReadTensorFromImageFile("images/input.jpg");
        // 執(zhí)行推理
        Tensor[] outTensors = new Tensor[] { tensorNum, tensorBoxes, tensorScores, tensorClasses };
        using var sess = tf.Session(graph);
        var results = sess.run(outTensors, new FeedItem(imgTensor, imgArr));
        // 解析結(jié)果
        var scores = results[2].ToArray<float>();
        var boxes = results[1].ToArray<float>();
        var ids = np.squeeze(results[3]).ToArray<float>();
        for (int i = 0; i < scores.Length; i++)
        {
            if (scores[i] > MIN_SCORE)
            {
                // 解析邊界框坐標(biāo)
                float top = boxes[i * 4] * imageHeight;
                float left = boxes[i * 4 + 1] * imageWidth;
                float bottom = boxes[i * 4 + 2] * imageHeight;
                float right = boxes[i * 4 + 3] * imageWidth;
                Console.WriteLine($"檢測到對象: 類別ID={ids[i]}, 置信度={scores[i]:P2}");
                Console.WriteLine($"  邊界框: ({left}, {top}) - ({right}, {bottom})");
            }
        }
    }
    private NDArray ReadTensorFromImageFile(string file_name)
    {
        var graph = tf.Graph().as_default();
        var file_reader = tf.io.read_file(file_name, "file_reader");
        var decodeJpeg = tf.image.decode_jpeg(file_reader, channels: 3, name: "DecodeJpeg");
        var casted = tf.cast(decodeJpeg, TF_DataType.TF_UINT8);
        var dims_expander = tf.expand_dims(casted, 0);
        using var sess = tf.Session(graph);
        return sess.run(dims_expander);
    }
}

using Tensorflow;
using static Tensorflow.Binding;
public void LoadSavedModel()
{
    // 使用 SavedModel 加載
    var sess = tf.Session();
    // 從指定目錄加載 SavedModel
    tf.saved_model.load(sess, tags: new[] { "serve" }, export_dir: "saved_model_dir");
    // 通過簽名運(yùn)行推理
    var inputTensor = ...; // 準(zhǔn)備輸入
    var result = sess.run(outputTensor, (inputPlaceholder, inputTensor));
}

// 假設(shè) singleImages 是多張圖片 Tensor 的列表
var batchTensor = tf.stack(singleImages.ToArray());  // 合并為 [batch, H, W, C]
var results = sess.run(outputTensor, (inputTensor, batchTensor));

public async Task<string> PredictAsync(byte[] imageData)
{
    return await Task.Run(() =>
    {
        var tensor = PreprocessImage(imageData);
        var result = sess.run(outputTensor, (inputTensor, tensor));
        return PostProcessResult(result);
    });
}

using System.Collections.Generic;
using Tensorflow;
using Tensorflow.Keras.Engine;
using static Tensorflow.Binding;
using static Tensorflow.KerasApi;
public class KerasSequentialExample
{
    Model model;
    int batch_size = 32;
    int epochs = 10;
    public void Run()
    {
        // 啟用 Eager 模式
        tf.enable_eager_execution();
        BuildModel();
        Train();
    }
    public void BuildModel()
    {
        int num_classes = 5;  // 5 種花卉分類
        var layers = keras.layers;
        // 使用 Sequential API 構(gòu)建模型
        var myLayers = new List<ILayer>
        {
            // 歸一化層：將像素值從 [0, 255] 縮放到 [0, 1]
            layers.Rescaling(1.0f / 255, input_shape: (64, 64, 3)),
            // 卷積層 + 池化層
            layers.Conv2D(16, 3, padding: "same", activation: keras.activations.Relu),
            layers.MaxPooling2D(),
            // 展平層
            layers.Flatten(),
            // 全連接層
            layers.Dense(128, activation: keras.activations.Relu),
            // 輸出層（logits，未經(jīng) softmax）
            layers.Dense(num_classes)
        };
        model = keras.Sequential(myLayers);
        // 編譯模型
        model.compile(
            optimizer: keras.optimizers.Adam(),
            loss: keras.losses.SparseCategoricalCrossentropy(from_logits: true),
            metrics: new[] { "accuracy" }
        );
        // 打印模型摘要
        model.summary();
    }
    public void Train()
    {
        // 訓(xùn)練模型（需先準(zhǔn)備 train_ds 和 val_ds 數(shù)據(jù)集）
        model.fit(train_ds, validation_data: val_ds, epochs: epochs);
    }
}

using Tensorflow.Keras.Engine;
using Tensorflow.NumPy;
using static Tensorflow.Binding;
using static Tensorflow.KerasApi;
public class KerasFunctionalExample
{
    IModel model;
    NDArray x_train, y_train, x_test, y_test;
    public void Run()
    {
        tf.enable_eager_execution();
        PrepareData();
        BuildModel();
        Train();
    }
    public void PrepareData()
    {
        // 加載 MNIST 數(shù)據(jù)集
        (x_train, y_train, x_test, y_test) = keras.datasets.mnist.load_data();
        x_train = x_train.reshape((60000, 784)) / 255f;
        x_test = x_test.reshape((10000, 784)) / 255f;
    }
    public void BuildModel()
    {
        var layers = keras.layers;
        // 定義輸入
        var inputs = keras.Input(shape: 784);
        // 第一全連接層
        var outputs = layers.Dense(64, activation: keras.activations.Relu).Apply(inputs);
        // 第二全連接層
        outputs = layers.Dense(64, activation: keras.activations.Relu).Apply(outputs);
        // 輸出層
        outputs = layers.Dense(10).Apply(outputs);
        // 構(gòu)建模型
        model = keras.Model(inputs, outputs, name: "mnist_model");
        model.summary();
        // 編譯模型
        model.compile(
            loss: keras.losses.SparseCategoricalCrossentropy(from_logits: true),
            optimizer: keras.optimizers.RMSprop(),
            metrics: new[] { "accuracy" }
        );
    }
    public void Train()
    {
        model.fit(x_train, y_train, batch_size: 64, epochs: 2, validation_split: 0.2f);
        model.evaluate(x_test, y_test, verbose: 2);
        // 保存模型
        model.save("mnist_model");
        // 重新加載模型
        // model = keras.models.load_model("mnist_model");
    }
}

// 從目錄結(jié)構(gòu)自動(dòng)加載圖片數(shù)據(jù)集
// 目錄結(jié)構(gòu)要求：
// data_dir/
//   class_a/
//     img1.jpg, img2.jpg, ...
//   class_b/
//     img1.jpg, img2.jpg, ...
var train_ds = keras.preprocessing.image_dataset_from_directory(
    data_dir,
    validation_split: 0.2f,
    subset: "training",
    seed: 123,
    image_size: (64, 64),
    batch_size: 32
);
var val_ds = keras.preprocessing.image_dataset_from_directory(
    data_dir,
    validation_split: 0.2f,
    subset: "validation",
    seed: 123,
    image_size: (64, 64),
    batch_size: 32
);
// 數(shù)據(jù)增強(qiáng)：打亂順序 + 預(yù)取優(yōu)化
train_ds = train_ds.shuffle(1000).prefetch(buffer_size: -1);
val_ds = val_ds.prefetch(buffer_size: -1);

using SciSharp.Models;
using SciSharp.Models.ImageClassification;
using System;
using System.IO;
using Tensorflow.Keras.Utils;
using static Tensorflow.Binding;
public class TransferLearningExample
{
    float accuracy;
    public void Run()
    {
        PrepareData();
        Train();
        Test();
        Predict();
        Console.WriteLine($"測試準(zhǔn)確率: {accuracy:P2}");
    }
    /// <summary>
    /// 準(zhǔn)備數(shù)據(jù)：下載花卉數(shù)據(jù)集
    /// </summary>
    public void PrepareData()
    {
        string fileName = "flower_photos.tgz";
        string dataDir = "image_classification_v1";
        string url = $"http://download.tensorflow.org/example_images/{fileName}";
        Web.Download(url, dataDir, fileName);
        Compress.ExtractTGZ(Path.Join(dataDir, fileName), dataDir);
    }
    /// <summary>
    /// 使用 ModelWizard 訓(xùn)練遷移學(xué)習(xí)模型
    /// 底層使用 InceptionV3 作為預(yù)訓(xùn)練基座
    /// </summary>
    public void Train()
    {
        var wizard = new ModelWizard();
        var task = wizard.AddImageClassificationTask<TransferLearning>(new TaskOptions
        {
            DataDir = @"image_classification_v1\flower_photos",
        });
        task.Train(new TrainingOptions
        {
            TrainingSteps = 100
        });
    }
    /// <summary>
    /// 測試模型準(zhǔn)確率
    /// </summary>
    public void Test()
    {
        var wizard = new ModelWizard();
        var task = wizard.AddImageClassificationTask<TransferLearning>(new TaskOptions
        {
            DataDir = @"image_classification_v1\flower_photos",
            ModelPath = @"image_classification_v1\saved_model.pb"
        });
        var result = task.Test(new TestingOptions { });
        accuracy = result.Accuracy;
    }
    /// <summary>
    /// 使用訓(xùn)練好的模型進(jìn)行預(yù)測
    /// </summary>
    public void Predict()
    {
        var wizard = new ModelWizard();
        var task = wizard.AddImageClassificationTask<TransferLearning>(new TaskOptions
        {
            ModelPath = @"image_classification_v1\saved_model.pb"
        });
        var imgPath = Path.Join("image_classification_v1", "flower_photos", 
            "daisy", "5547758_eea9edfd54_n.jpg");
        var input = ImageUtil.ReadImageFromFile(imgPath);
        var result = task.Predict(input);
        Console.WriteLine($"預(yù)測結(jié)果: {result.Label}");
    }
}

using System.Collections.Generic;
using Tensorflow;
using Tensorflow.Keras.Engine;
using static Tensorflow.Binding;
using static Tensorflow.KerasApi;
public class ManualTransferLearning
{
    Model model;
    IModel base_model;  // 類級別字段，供 BuildTransferLearningModel 和 FineTune 共用
    public void BuildTransferLearningModel(int num_classes = 5)
    {
        tf.enable_eager_execution();
        var layers = keras.layers;
        // 1. 加載預(yù)訓(xùn)練的 MobileNetV2 模型（不含頂層）
        base_model = keras.applications.MobileNetV2(
            input_shape: (224, 224, 3),
            include_top: false,
            weights: "imagenet"
        );
        // 2. 凍結(jié)預(yù)訓(xùn)練層
        base_model.trainable = false;
        // 3. 構(gòu)建新模型
        var inputs = keras.Input(shape: (224, 224, 3));
        // 數(shù)據(jù)預(yù)處理
        var x = layers.Rescaling(1.0f / 127.5f, input_shape: (224, 224, 3)).Apply(inputs);
        x = layers.Rescaling(-1, offset: 1).Apply(x);  // 歸一化到 [-1, 1]
        // 通過預(yù)訓(xùn)練基座提取特征
        x = base_model.Apply(x);
        // 全局平均池化
        x = layers.GlobalAveragePooling2D().Apply(x);
        // Dropout 防止過擬合
        x = layers.Dropout(0.2f).Apply(x);
        // 輸出層
        var outputs = layers.Dense(num_classes).Apply(x);
        model = keras.Model(inputs, outputs, name: "transfer_learning_model");
        model.compile(
            optimizer: keras.optimizers.Adam(),
            loss: keras.losses.SparseCategoricalCrossentropy(from_logits: true),
            metrics: new[] { "accuracy" }
        );
        model.summary();
    }
    /// <summary>
    /// 微調(diào)：解凍部分頂層繼續(xù)訓(xùn)練
    /// 注意：base_model 是類級別字段，在 BuildTransferLearningModel 中初始化
    /// </summary>
    public void FineTune()
    {
        // 解凍最后 20 層
        base_model.trainable = true;
        foreach (var layer in base_model.layers.TakeLast(20))
        {
            layer.trainable = true;
        }
        // 重新編譯模型（微調(diào)需要更小的學(xué)習(xí)率）
        model.compile(
            optimizer: keras.optimizers.Adam(1e-5f),
            loss: keras.losses.SparseCategoricalCrossentropy(from_logits: true),
            metrics: new[] { "accuracy" }
        );
        // 繼續(xù)訓(xùn)練
        model.fit(train_ds, validation_data: val_ds, epochs: 10);
    }
}

// 保存模型（包含結(jié)構(gòu)和權(quán)重）
model.save("my_model");
// 重新加載模型
var loadedModel = keras.models.load_model("my_model");

// Keras 模型默認(rèn)以 SavedModel 格式保存
// 目錄結(jié)構(gòu)：
// my_model/
//   saved_model.pb
//   variables/
//     variables.data-00000-of-00001
//     variables.index
//   assets/

// 線程安全的推理服務(wù)示例
public class InferenceService : IDisposable
{
    private readonly Session _session;
    private readonly Tensor _inputTensor;
    private readonly Tensor _outputTensor;
    private readonly object _lock = new object();
    public InferenceService(string modelPath)
    {
        tf.compat.v1.disable_eager_execution();
        var graph = tf.Graph().as_default();
        graph.Import(modelPath);
        _session = tf.Session(graph);
        _inputTensor = graph.OperationByName("input");
        _outputTensor = graph.OperationByName("output");
    }
    public NDArray Predict(NDArray input)
    {
        lock (_lock)
        {
            return _session.run(_outputTensor, (_inputTensor, input));
        }
    }
    public void Dispose()
    {
        _session?.close();
    }
}

FROM mcr.microsoft.com/dotnet/aspnet:8.0 AS base
WORKDIR /app
EXPOSE 80
# 安裝 TensorFlow 運(yùn)行時(shí)依賴
RUN apt-get update && apt-get install -y \
    libgomp1 \
    && rm -rf /var/lib/apt/lists/*
FROM mcr.microsoft.com/dotnet/sdk:8.0 AS build
WORKDIR /src
COPY ["MyApp.csproj", "."]
RUN dotnet restore
COPY . .
RUN dotnet publish -c Release -o /app/publish
FROM base AS final
WORKDIR /app
COPY --from=build /app/publish .
COPY models/ ./models/
ENTRYPOINT ["dotnet", "MyApp.dll"]

// 正確做法：使用 using 語句
using var sess = tf.Session(graph);
var result = sess.run(outputTensor, (inputTensor, input));
// sess 會(huì)在作用域結(jié)束時(shí)自動(dòng)釋放