Tensorflow.NET训练自己模型

Tensorflow.NET是基于Tensorflow封装的一个开源C#的库 接下来我们将试着使用他搭建自己的学习分类任务

1.下载安装下面的包直接在Nuget里面搜索安装即可

TensorFlow.Keras
SciSharp.TensorFlow.Redist
OpenCvSharp4
OpenCvSharp4.runtime.win

2、开始搭建可以直接赋值官网的代码根据自己的需要在调整网络 这里我们直接赋值官方实例

var layers = keras.layers;
var inputs = keras.Input(shape: (400, 300, 3), name: "img"); //这里注意一下H W 后面3 是图片通道数
// convolutional layer
var x = layers.Conv2D(32, 3, activation: "relu").Apply(inputs);
x = layers.Conv2D(64, 3, activation: "relu").Apply(x);
var block_1_output = layers.MaxPooling2D(3).Apply(x);
x = layers.Conv2D(64, 3, activation: "relu", padding: "same").Apply(block_1_output);
x = layers.Conv2D(64, 3, activation: "relu", padding: "same").Apply(x);
var block_2_output = layers.Add().Apply(new Tensors(x, block_1_output));
x = layers.Conv2D(64, 3, activation: "relu", padding: "same").Apply(block_2_output);
x = layers.Conv2D(64, 3, activation: "relu", padding: "same").Apply(x);
var block_3_output = layers.Add().Apply(new Tensors(x, block_2_output));
x = layers.Conv2D(64, 3, activation: "relu").Apply(block_3_output);
x = layers.GlobalAveragePooling2D().Apply(x);
x = layers.Dense(256, activation: "relu").Apply(x);
x = layers.Dropout(0.5f).Apply(x);
// output layer
var outputs = layers.Dense(2).Apply(x);//写自己的分类数量 有两个类别就写2 
// build keras model
var model = keras.Model(inputs, outputs, name: "toy_resnet");
model.summary();
// compile keras model in tensorflow static graph
model.compile(optimizer: keras.optimizers.RMSprop(1e-3f),loss: keras.losses.SparseCategoricalCrossentropy(from_logits: true),metrics: new[] { "acc" });
var ((x_train, y_train), (x_test, y_test)) = cifar10Data.load_data();// keras.datasets.cifar10.load_data();
x_train = x_train / 255.0f;// Train model
model.fit(x_train, y_train, batch_size: 10, epochs: 30, validation_split: 0.2f);// Save model
model.save("自己模型保存路径");

　　上面的 cifar10Data.load_data()是自己的路径 这里我封装了一个直接可以使用 使用时候注意 目录结构  

cifar10Data的代码如下

using OpenCvSharp;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Runtime.InteropServices;
using System.Threading.Tasks;
using Tensorflow;
using Tensorflow.Keras.Datasets;
using Tensorflow.NumPy;
using Tensorflow.Operations.Initializers;
using static Tensorflow.Binding;
using static Tensorflow.KerasApi;

public class Cifar10Data
{
    // 本地数据集根目录
    private readonly string _datasetRoot = "E:\\Modelinmg\\tf001";
    private readonly string _trainFolder;
    private readonly string _testFolder;

    // 图片尺寸：宽300，高400
    private const int ImgWidth = 300;
    private const int ImgHeight = 400;
    private const int Channel = 3;

    public Cifar10Data()
    {
        _trainFolder = Path.Combine(_datasetRoot, "train");//训练数据
        _testFolder = Path.Combine(_datasetRoot, "test");//测试数据
    }

    public DatasetPass load_data()
    {
        var (trainX, trainY) = LoadImageFolder(_trainFolder);
        var (testX, testY) = LoadImageFolder(_testFolder);

        return new DatasetPass
        {
            Train = (trainX, trainY),
            Test = (testX, testY)
        };
    }

    private (NDArray imageNd, NDArray labelNd) LoadImageFolder(string folderPath)
    {
        if (!Directory.Exists(folderPath))
            throw new DirectoryNotFoundException($"数据集文件夹不存在：{folderPath}");

        var classDirs = Directory.GetDirectories(folderPath).OrderBy(p => p).ToList();
        Dictionary<string, int> classLabelMap = new Dictionary<string, int>();
        for (int i = 0; i < classDirs.Count; i++)
        {
            string className = Path.GetFileName(classDirs[i]);
            classLabelMap[className] = i;
        }
        //var shuffledList= classLabelMap.ToList();
        // Random rng = new Random();
        // shuffledList = shuffledList.OrderBy(x => rng.Next()).ToList();
        // // 如果需要重新放回字典（但字典本身仍然无序）
        // classLabelMap = new Dictionary<string, int>(shuffledList);
        List<string> imageMatList = new List<string>();
        List<int> labelList = new List<int>();

        foreach (var classDir in classDirs)
        {
            string className = Path.GetFileName(classDir);
            int label = classLabelMap[className];
            var imgPaths = Directory.GetFiles(classDir, "*.*")
                .Where(p => p.EndsWith(".jpg") || p.EndsWith(".jpeg") || p.EndsWith(".png"));

            foreach (var imgPath in imgPaths)
            {
                imageMatList.Add(imgPath);
                labelList.Add(label);
            }
        }

        var pairList = imageMatList.Zip(labelList, (path, label) => new { Img = path, Label = label }).ToList();
        Random random = new Random(42);
        pairList = pairList.OrderBy(_ => random.Next()).ToList();
        imageMatList.Clear();
        labelList.Clear();
        foreach (var item in pairList)
        {
            imageMatList.Add(item.Img);
            labelList.Add(item.Label);
        }

        int sampleCount = imageMatList.Count;//数据总量
        if (sampleCount == 0)
            throw new Exception($"文件夹 {folderPath} 未找到任何有效图片");

        // ========== 核心修复：直接创建NDArray，删除全局超大byte[] ==========
        long[] imgShape = { sampleCount, ImgWidth, ImgHeight, Channel };
        //NDArray imageND = np.zeros(imgShape, np.float32);
        NDArray imageNd = np.zeros(imgShape, np.uint8);

        Mat bgrImg = new Mat();
        Mat rgbImg = new Mat();
        //Mat[] channels = null;
        int idx = 0;
        //byte[] bytes = new byte[ImgHeight * ImgWidth * Channel* sampleCount];
        int singleByte = ImgHeight * ImgWidth * 3;
        foreach (var item in imageMatList)
        {
            bgrImg = Cv2.ImRead(item, ImreadModes.Color);
            if (bgrImg.Empty())
            {
                Console.WriteLine($"跳过损坏/无法读取图片：{item}");
                bgrImg.Dispose();
                continue;
            }
            if (bgrImg.Channels() != Channel)
            {
                Console.WriteLine($"跳过非3通道图片：{item}");
                bgrImg.Dispose();
                continue;
            }
            if (bgrImg.Rows != ImgHeight || bgrImg.Cols != ImgWidth)
            {
                bgrImg.Dispose();
                throw new Exception($"图片尺寸不匹配 {item}，预期高{ImgHeight}×宽{ImgWidth}");
            }
            Cv2.CvtColor(bgrImg, rgbImg, ColorConversionCodes.BGR2RGB);
            // 单张图片总字节 H*W*3 
            byte[] pixelData = new byte[singleByte];
            // 直接拷贝整张RGB图像内存，天然NHWC排布
            Marshal.Copy(rgbImg.Data, pixelData, 0, singleByte);
            // 一维数组直接重塑 (H,W,3)，无任何通道转换
            imageNd[idx] = np.array(pixelData).reshape((ImgHeight, ImgWidth, 3));
            idx++;
            //rgbImg.SetTo(0);
        }
        bgrImg.Dispose();
        rgbImg.Dispose();
        // 归一化转float32
        // imageNd = imageNd.astype(np.float32);
        //imageNd = imageNd / 255.0f;

        NDArray labelNd = np.array(labelList.ToArray()).astype(np.int32);
        return (imageNd, labelNd);
    }

    public NDArray oneImg(string imgpath)
    {

        Mat bgrImg = new Mat();
        Mat rgbImg = new Mat();
        bgrImg = Cv2.ImRead(imgpath, ImreadModes.Color);
        if (bgrImg.Empty())
        {
            bgrImg.Dispose();
            throw new Exception($"跳过损坏/无法读取图片：{imgpath}");
        }
        if (bgrImg.Channels() != Channel)
        {
            bgrImg.Dispose();
            throw new Exception("$\"跳过非3通道图片：{imgpath}\"");
        }        
        Cv2.CvtColor(bgrImg, rgbImg, ColorConversionCodes.BGR2RGB);
        int singleByte = rgbImg.Width * rgbImg.Height * 3;
        // 单张图片总字节 H*W*3 
        byte[] pixelData = new byte[singleByte];
        // 直接拷贝整张RGB图像内存，天然NHWC排布
        Marshal.Copy(rgbImg.Data, pixelData, 0, singleByte);
        // 一维数组直接重塑 (H,W,3)，无任何通道转换
        int[] shape = new int[] { 1, rgbImg.Height, rgbImg.Width, 3 };
        return np.array(pixelData).reshape(shape);

    }
    //模型预测
    public int Modelpredict(string Modelpath, string imgpath)
    {
        NDArray nD=  oneImg(imgpath);
        //NDArray input_batch = np.expand_dims(nD, axis: 0);
        var modeltest = keras.models.load_model(Modelpath);
        nD = nD / 255.0f;
        var logits = modeltest.predict(nD);
        NDArray prob = tf.nn.softmax(logits).numpy();
        //5.找出概率最大下标，就是预测类别
        int predictClass = np.argmax(prob[0]);
        
        return predictClass;
    }
}