C# 深度学习框架 TorchSharp 原生训练模型和图像识别

TorchSharp
TorchSharp-cuda-windows
TorchVision
Maomi.Torch

using Maomi.Torch;

Device defaultDevice = MM.GetOpTimalDevice();
torch.set_default_device(defaultDevice);

Console.WriteLine("当前正在使用 {defaultDevice}");

using TorchSharp;
using static TorchSharp.torch;
using datasets = TorchSharp.torchvision.datasets;
using transforms = TorchSharp.torchvision.transforms;

// 指定训练数据集
var training_data = datasets.FashionMNIST(
    root:"data",// 数据集在那个目录下
    train:true,// 加载该数据集，用于训练
    download:true,// 如果数据集不存在，是否下载
    target_transform: transforms.ConvertImageDtype(ScalarType.Float32)// 指定特征和标签转换，将标签转换为Float32
);

// 指定测试数据集
var test_data = datasets.FashionMNIST(
    root:"data",// 数据集在那个目录下
    train:false,// 加载该数据集，用于训练
    download:true,// 如果数据集不存在，是否下载
    target_transform: transforms.ConvertImageDtype(ScalarType.Float32)// 指定特征和标签转换，将标签转换为Float32
    );

│   t10k-images-idx3-ubyte.gz
│   t10k-labels-idx1-ubyte.gz
│   train-images-idx3-ubyte.gz
│   train-labels-idx1-ubyte.gz
│
└───test_data
        t10k-images-idx3-ubyte
        t10k-labels-idx1-ubyte
        train-images-idx3-ubyte
        train-labels-idx1-ubyte

for (int i = 0; i < training_data.Count; i++)
{
    var dic = training_data.GetTensor(i);
    var img = dic["data"];
    var label = dic["label"];
    label.print();
}

for (int i =0; i < training_data.Count; i++)
{
var dic = training_data.GetTensor(i);
var img = dic["data"];
var label = dic["label"];

if(i >2)
{
break;
}

    img.ShowImage();
}

img.SavePng("data/{i}.png");

// 分批加载图像，打乱顺序
var train_loader = torch.utils.data.DataLoader(training_data, batchSize: 64, shuffle: true, device: defaultDevice);

// 分批加载图像，不打乱顺序
var test_loader = torch.utils.data.DataLoader(test_data, batchSize: 64, shuffle: false, device: defaultDevice);

using TorchSharp.Modules;
usingstaticTorchSharp.torch;
using nn =TorchSharp.torch.nn;

publicclassNeuralNetwork:nn.Module<Tensor,Tensor>
{
// 传递给基类的参数是模型的名称
publicNeuralNetwork():base(nameof(NeuralNetwork))
{
        flatten = nn.Flatten();
        linear_relu_stack = nn.Sequential(
            nn.Linear(28*28,512),
            nn.ReLU(),
            nn.Linear(512,512),
            nn.ReLU(),
            nn.Linear(512,10));

// C# 版本需要调用这个函数，将模型的组件注册到模型中
RegisterComponents();
}

Flatten flatten;
Sequential linear_relu_stack;

publicoverrideTensorforward(Tensor input)
{
// 将输入一层层处理并传递给下一层
var x = flatten.call(input);
var logits = linear_relu_stack.call(x);
return logits;
}
}

var model = new NeuralNetwork();
model.to(defaultDevice);

// 定义损失函数、优化器和学习率
var loss_fn = nn.CrossEntropyLoss();
var optimizer = torch.optim.SGD(model.parameters(), learningRate : 1e-3);

static voidTrain(DataLoader dataloader,NeuralNetwork model,CrossEntropyLoss loss_fn, SGD optimizer)
{
var size = dataloader.dataset.Count;
    model.train();

int batch =0;
foreach(var item in dataloader)
{
var x = item["data"];
var y = item["label"];

// 第一步
// 训练当前图片
var pred = model.call(x);

// 通过损失函数得出与真实结果的误差
var loss = loss_fn.call(pred, y);

// 第二步，反向传播
        loss.backward();

// 计算梯度并优化参数
        optimizer.step();

// 清空优化器当前的梯度
        optimizer.zero_grad();

// 每 100 次打印损失值和当前训练的图片数量
if(batch %100==0)
{
            loss = loss.item<float>();

// Pytorch 框架会在 x.shape[0] 存储当前批的位置
var current =(batch +1)* x.shape[0];

Console.WriteLine("loss: {loss.item<float>(),7}  [{current,5}/{size,5}]");
}

        batch++;
}
}

static voidTest(DataLoader dataloader,NeuralNetwork model,CrossEntropyLoss loss_fn)
{
var size =(int)dataloader.dataset.Count;
var num_batches =(int)dataloader.Count;

// 将模型设置为评估模式
    model.eval();

var test_loss =0F;
var correct =0F;

using(var n = torch.no_grad())
{
foreach(var item in dataloader)
{
var x = item["data"];
var y = item["label"];

// 使用已训练的参数预测测试数据
var pred = model.call(x);

// 计算损失值
            test_loss += loss_fn.call(pred, y).item<float>();
            correct +=(pred.argmax(1)== y).type(ScalarType.Float32).sum().item<float>();
}
}

    test_loss /= num_batches;
    correct /= size;
Console.WriteLine("Test Error: \n Accuracy: {(100 * correct):F1}%, Avg loss: {test_loss:F8} \n");
}

// 训练的轮数
var epochs =5;

foreach(var epoch inEnumerable.Range(0, epochs))
{
Console.WriteLine("Epoch {epoch + 1}\n-------------------------------");
Train(train_loader, model, loss_fn, optimizer);
Test(train_loader, model, loss_fn);
}

Console.WriteLine("Done!");

model.save("model.dat");
Console.WriteLine("Saved PyTorch Model State to model.dat");

model.load("model.dat");

var classes =newstring[]{
"T-shirt/top",
"Trouser",
"Pullover",
"Dress",
"Coat",
"Sandal",
"Shirt",
"Sneaker",
"Bag",
"Ankle boot",
};

// 设置为评估模式
model.eval();

// 加载测试数据中的第一个图片以及其标签
var x = test_data.GetTensor(0)["data"];
var y = test_data.GetTensor(0)["label"];

using(torch.no_grad())
{
    x = x.to(defaultDevice);
var pred = model.call(x);
var predicted = classes[pred[0].argmax(0).ToInt32()];
var actual = classes[y.ToInt32()];
Console.WriteLine("Predicted: \"{predicted}\", Actual: \"{actual}\"");
}

var img = MM.LoadImage("0.png");
using(torch.no_grad())
{
    img = img.to(defaultDevice);
var pred = model.call(img);

// 转换为归一化的概率
var array = torch.nn.functional.softmax(pred, dim:0);
var max = array.ToFloat32Array().Max();
var predicted = classes[pred[0].argmax(0).ToInt32()];

Console.WriteLine("识别结果 {predicted}，概率 {max * 100}%");
}