基于CNTK/C#实现Cifar【附源码】

最新推荐文章于 2022-12-04 14:54:08 发布
最新推荐文章于 2022-12-04 14:54:08 发布
阅读量746 收藏
点赞数 1
分类专栏： 深度学习-cntk 文章标签： c# cntk cifar 深度学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ctu_sue/article/details/127521765
版权

文章目录

前言

本文讲解基于CNTK+C#实现Cifar功能，并且如何构建ResNet网络结构

一、数据集的构建

首先这里提供一个1.tar.gz和一个py文件，这里主要是构建数据集，使用者只需要运行python文件就可以得到如下文件夹，此文件夹就是cifar的训练数据集
python实现代码如下：

from PIL import Image
import getopt, os, shutil, struct, sys,tarfile
import numpy as np
import pickle as cp
import xml.etree.cElementTree as et
import xml.dom.minidom

imgSize = 32
numFeature = imgSize * imgSize * 3

data_dir = './CIFAR-10/'
train_filename = data_dir + '/Train_cntk_text.txt'
test_filename = data_dir + '/Test_cntk_text.txt'
train_img_directory = data_dir + '/Train'
test_img_directory = data_dir + '/Test'

def readBatch(src):
    with open(src, 'rb') as f:
        if sys.version_info[0] < 3: 
            d = cp.load(f) 
        else:
            d = cp.load(f, encoding='latin1')
        data = d['data']
        feat = data
    res = np.hstack((feat, np.reshape(d['labels'], (len(d['labels']), 1))))
    return res.astype(np.int)

def saveTxt(filename, ndarray):
    with open(filename, 'w') as f:
        labels = list(map(' '.join, np.eye(10, dtype=np.uint).astype(str)))
        for row in ndarray:
            row_str = row.astype(str)
            label_str = labels[row[-1]]
            feature_str = ' '.join(row_str[:-1])
            f.write('|labels {} |features {}\n'.format(label_str, feature_str))

def saveMean(fname, data):
    root = et.Element('opencv_storage')
    et.SubElement(root, 'Channel').text = '3'
    et.SubElement(root, 'Row').text = str(imgSize)
    et.SubElement(root, 'Col').text = str(imgSize)
    meanImg = et.SubElement(root, 'MeanImg', type_id='opencv-matrix')
    et.SubElement(meanImg, 'rows').text = '1'
    et.SubElement(meanImg, 'cols').text = str(imgSize * imgSize * 3)
    et.SubElement(meanImg, 'dt').text = 'f'
    et.SubElement(meanImg, 'data').text = ' '.join(['%e' % n for n in np.reshape(data, (imgSize * imgSize * 3))])

    tree = et.ElementTree(root)
    tree.write(fname)
    x = xml.dom.minidom.parse(fname)
    with open(fname, 'w') as f:
        f.write(x.toprettyxml(indent = '  '))

def saveImage(fname, data, label, mapFile, regrFile, pad, **key_parms):
    # data in CIFAR-10 dataset is in CHW format.
    pixData = data.reshape((3, imgSize, imgSize))
    if ('mean' in key_parms):
        key_parms['mean'] += pixData

    if pad > 0:
        pixData = np.pad(pixData, ((0, 0), (pad, pad), (pad, pad)), mode='constant', constant_values=128) 

    img = Image.new('RGB', (imgSize + 2 * pad, imgSize + 2 * pad))
    pixels = img.load()
    for x in range(img.size[0]):
        for y in range(img.size[1]):
            pixels[x, y] = (pixData[0][y][x], pixData[1][y][x], pixData[2][y][x])
    img.save(fname)
    mapFile.write("%s\t%d\n" % (fname, label))

    channelMean = np.mean(pixData, axis=(1,2))
    regrFile.write("|regrLabels\t%f\t%f\t%f\n" % (channelMean[0]/255.0, channelMean[1]/255.0, channelMean[2]/255.0))

def saveTrainImages(filename, foldername):
    if not os.path.exists(foldername):
        os.makedirs(foldername)
    data = {}
    dataMean = np.zeros((3, imgSize, imgSize)) 
    with open(os.path.join(data_dir,'train_map.txt'), 'w') as mapFile:
        with open(os.path.join(data_dir,'train_regrLabels.txt'), 'w') as regrFile:
            for ifile in range(1, 6):
                with open(os.path.join('./cifar-10-batches-py', 'data_batch_' + str(ifile)), 'rb') as f:
                    if sys.version_info[0] < 3: 
                        data = cp.load(f)
                    else: 
                        data = cp.load(f, encoding='latin1')
                    for i in range(10000):
                        fname = os.path.join(os.path.abspath(foldername), ('%05d.png' % (i + (ifile - 1) * 10000)))
                        saveImage(fname, data['data'][i, :], data['labels'][i], mapFile, regrFile, 4, mean=dataMean)
    dataMean = dataMean / (50 * 1000)
    saveMean(os.path.join(data_dir,'CIFAR-10_mean.xml'), dataMean)

def saveTestImages(filename, foldername):
    if not os.path.exists(foldername):
      os.makedirs(foldername)
    with open(os.path.join(data_dir,'test_map.txt'), 'w') as mapFile:
        with open(os.path.join(data_dir,'test_regrLabels.txt'), 'w') as regrFile:
            with open(os.path.join('./cifar-10-batches-py', 'test_batch'), 'rb') as f:
                if sys.version_info[0] < 3: 
                    data = cp.load(f)
                else: 
                    data = cp.load(f, encoding='latin1')
                for i in range(10000):
                    fname = os.path.join(os.path.abspath(foldername), ('%05d.png' % i))
                    saveImage(fname, data['data'][i, :], data['labels'][i], mapFile, regrFile, 0)

# 解压压缩包
with tarfile.open(r'1.tar.gz') as tar:
    tar.extractall()
trn = np.empty((0, numFeature + 1), dtype=np.int)
for i in range(5):
    batchName = './cifar-10-batches-py/data_batch_{0}'.format(i + 1)
    trn = np.vstack((trn, readBatch(batchName)))
tst = readBatch('./cifar-10-batches-py/test_batch')

if not os.path.exists(data_dir):
    os.makedirs(data_dir)
os.makedirs(train_img_directory)
os.makedirs(test_img_directory)

saveTxt(os.path.join(data_dir,'Train_cntk_text.txt'), trn)
saveTxt(os.path.join(data_dir,'Test_cntk_text.txt'), tst)

saveTrainImages(os.path.join(data_dir,'Train_cntk_text.txt'), train_img_directory )
saveTestImages(os.path.join(data_dir,'Test_cntk_text.txt'), test_img_directory )

如图：
在这里插入图片描述
最后得到的目录结构如下：
在这里插入图片描述

二、CNTK/C#->Cifar代码构建

1.首先定义标准变量

//定义模型文件及训练次数
string modelFile = "./Cifar10Rest.model";
uint MaxEpochs = 120;

2.定义GPU环境

//定义GPU的配置
var device = DeviceDescriptor.GPUDevice(0);

3.载入数据集

//载入训练数据
var minibatchSource = CreateMinibatchSource(@".\CIFAR-10\train_map.txt", @".\CIFAR-10\CIFAR-10_mean.xml", imageDim, numClasses, MaxEpochs);
var imageStreamInfo = minibatchSource.StreamInfo("features");
var labelStreamInfo = minibatchSource.StreamInfo("labels");

4.创建模型

 //创建模型，先定义输入输出，然后定义模型，这里使用ResNet模型
var imageInput = CNTKLib.InputVariable(imageDim, imageStreamInfo.m_elementType, "Images");
var labelsVar = CNTKLib.InputVariable(new int[] { numClasses }, labelStreamInfo.m_elementType, "Labels");
var classifierOutput = ResNetClassifier(imageInput, numClasses, device, "classifierOutput");

模型结构具体实现代码

private static Function ConvBatchNormalizationLayer(Variable input, int outFeatureMapCount, int kernelWidth, int kernelHeight, int hStride, int vStride, double wScale, double bValue, double scValue, int bnTimeConst, bool spatial, DeviceDescriptor device)
{
    int numInputChannels = input.Shape[input.Shape.Rank - 1];

    var convParams = new Parameter(new int[] { kernelWidth, kernelHeight, numInputChannels, outFeatureMapCount },
        DataType.Float, CNTKLib.GlorotUniformInitializer(wScale, -1, 2), device);
    var convFunction = CNTKLib.Convolution(convParams, input, new int[] { hStride, vStride, numInputChannels });

    var biasParams = new Parameter(new int[] { NDShape.InferredDimension }, (float)bValue, device, "");
    var scaleParams = new Parameter(new int[] { NDShape.InferredDimension }, (float)scValue, device, "");
    var runningMean = new Constant(new int[] { NDShape.InferredDimension }, 0.0f, device);
    var runningInvStd = new Constant(new int[] { NDShape.InferredDimension }, 0.0f, device);
    var runningCount = Constant.Scalar(0.0f, device);
    return CNTKLib.BatchNormalization(convFunction, scaleParams, biasParams, runningMean, runningInvStd, runningCount,
        spatial, (double)bnTimeConst, 0.0, 1e-5 /* epsilon */);
}
private static Function ConvBatchNormalizationReLULayer(Variable input, int outFeatureMapCount, int kernelWidth, int kernelHeight, int hStride, int vStride, double wScale, double bValue, double scValue, int bnTimeConst, bool spatial, DeviceDescriptor device)
{
    var convBNFunction = ConvBatchNormalizationLayer(input, outFeatureMapCount, kernelWidth, kernelHeight, hStride, vStride, wScale, bValue, scValue, bnTimeConst, spatial, device);
    return CNTKLib.ReLU(convBNFunction);
}
private static Function ResNetNode(Variable input, int outFeatureMapCount, int kernelWidth, int kernelHeight, double wScale, double bValue,double scValue, int bnTimeConst, bool spatial, DeviceDescriptor device)
{
    var c1 = ConvBatchNormalizationReLULayer(input, outFeatureMapCount, kernelWidth, kernelHeight, 1, 1, wScale, bValue, scValue, bnTimeConst, spatial, device);
    var c2 = ConvBatchNormalizationLayer(c1, outFeatureMapCount, kernelWidth, kernelHeight, 1, 1, wScale, bValue, scValue, bnTimeConst, spatial, device);
    var p = CNTKLib.Plus(c2, input);
    return CNTKLib.ReLU(p);
}
private static Function ProjectLayer(Variable wProj, Variable input, int hStride, int vStride, double bValue, double scValue, int bnTimeConst, DeviceDescriptor device)
{
    int outFeatureMapCount = wProj.Shape[0];
    var b = new Parameter(new int[] { outFeatureMapCount }, (float)bValue, device, "");
    var sc = new Parameter(new int[] { outFeatureMapCount }, (float)scValue, device, "");
    var m = new Constant(new int[] { outFeatureMapCount }, 0.0f, device);
    var v = new Constant(new int[] { outFeatureMapCount }, 0.0f, device);

    var n = Constant.Scalar(0.0f, device);

    int numInputChannels = input.Shape[input.Shape.Rank - 1];

    var c = CNTKLib.Convolution(wProj, input, new int[] { hStride, vStride, numInputChannels }, new bool[] { true }, new bool[] { false });
    return CNTKLib.BatchNormalization(c, sc, b, m, v, n, true /*spatial*/, (double)bnTimeConst, 0, 1e-5, false);
}
private static Function ResNetNodeInc(Variable input, int outFeatureMapCount, int kernelWidth, int kernelHeight, double wScale, double bValue, double scValue, int bnTimeConst, bool spatial, Variable wProj, DeviceDescriptor device)
{
    var c1 = ConvBatchNormalizationReLULayer(input, outFeatureMapCount, kernelWidth, kernelHeight, 2, 2, wScale, bValue, scValue, bnTimeConst, spatial, device);
    var c2 = ConvBatchNormalizationLayer(c1, outFeatureMapCount, kernelWidth, kernelHeight, 1, 1, wScale, bValue, scValue, bnTimeConst, spatial, device);

    var cProj = ProjectLayer(wProj, input, 2, 2, bValue, scValue, bnTimeConst, device);

    var p = CNTKLib.Plus(c2, cProj);
    return CNTKLib.ReLU(p);
}
private static Constant GetProjectionMap(int outputDim, int inputDim, DeviceDescriptor device)
{
    if (inputDim > outputDim)
        throw new Exception("Can only project from lower to higher dimensionality");

    float[] projectionMapValues = new float[inputDim * outputDim];
    for (int i = 0; i < inputDim * outputDim; i++)
        projectionMapValues[i] = 0;
    for (int i = 0; i < inputDim; ++i)
        projectionMapValues[(i * (int)inputDim) + i] = 1.0f;

    var projectionMap = new NDArrayView(DataType.Float, new int[] { 1, 1, inputDim, outputDim }, device);
    projectionMap.CopyFrom(new NDArrayView(new int[] { 1, 1, inputDim, outputDim }, projectionMapValues, (uint)projectionMapValues.Count(), device));

    return new Constant(projectionMap);
}
private static Function ResNetClassifier(Variable input, int numOutputClasses, DeviceDescriptor device, string outputName)
{
    //模型构建
    double convWScale = 7.07;
    double convBValue = 0;

    double fc1WScale = 0.4;
    double fc1BValue = 0;

    double scValue = 1;
    int bnTimeConst = 4096;

    int kernelWidth = 3;
    int kernelHeight = 3;

    double conv1WScale = 0.26;
    int cMap1 = 16;
    //卷积+标准化+激活函数
    var conv1 = ConvBatchNormalizationReLULayer(input, cMap1, kernelWidth, kernelHeight, 1, 1, conv1WScale, convBValue, scValue, bnTimeConst, true /*spatial*/, device);

    //ResNet实现的块
    var rn1_1 = ResNetNode(conv1, cMap1, kernelWidth, kernelHeight, convWScale, convBValue, scValue, bnTimeConst, false /*spatial*/, device);
    var rn1_2 = ResNetNode(rn1_1, cMap1, kernelWidth, kernelHeight, convWScale, convBValue, scValue, bnTimeConst, true /*spatial*/, device);
    var rn1_3 = ResNetNode(rn1_2, cMap1, kernelWidth, kernelHeight, convWScale, convBValue, scValue, bnTimeConst, false /*spatial*/, device);

    int cMap2 = 32;
    var rn2_1_wProj = GetProjectionMap(cMap2, cMap1, device);
    var rn2_1 = ResNetNodeInc(rn1_3, cMap2, kernelWidth, kernelHeight, convWScale, convBValue, scValue, bnTimeConst, true /*spatial*/, rn2_1_wProj, device);
    var rn2_2 = ResNetNode(rn2_1, cMap2, kernelWidth, kernelHeight, convWScale, convBValue, scValue, bnTimeConst, false /*spatial*/, device);
    var rn2_3 = ResNetNode(rn2_2, cMap2, kernelWidth, kernelHeight, convWScale, convBValue, scValue, bnTimeConst, true /*spatial*/, device);

    int cMap3 = 64;
    var rn3_1_wProj = GetProjectionMap(cMap3, cMap2, device);
    var rn3_1 = ResNetNodeInc(rn2_3, cMap3, kernelWidth, kernelHeight, convWScale, convBValue, scValue, bnTimeConst, true /*spatial*/, rn3_1_wProj, device);
    var rn3_2 = ResNetNode(rn3_1, cMap3, kernelWidth, kernelHeight, convWScale, convBValue, scValue, bnTimeConst, false /*spatial*/, device);
    var rn3_3 = ResNetNode(rn3_2, cMap3, kernelWidth, kernelHeight, convWScale, convBValue, scValue, bnTimeConst, false /*spatial*/, device);

    // 全局平均池化
    int poolW = 8;
    int poolH = 8;
    int poolhStride = 1;
    int poolvStride = 1;
    var pool = CNTKLib.Pooling(rn3_3, PoolingType.Average,
        new int[] { poolW, poolH, 1 }, new int[] { poolhStride, poolvStride, 1 });

    // 输出层
    var outTimesParams = new Parameter(new int[] { numOutputClasses, 1, 1, cMap3 }, DataType.Float,
        CNTKLib.GlorotUniformInitializer(fc1WScale, 1, 0), device);
    var outBiasParams = new Parameter(new int[] { numOutputClasses }, (float)fc1BValue, device, "");

    return CNTKLib.Plus(CNTKLib.Times(outTimesParams, pool), outBiasParams, outputName);
}

5.训练指标

//训练及验证指标，loss及acc
var trainingLoss = CNTKLib.CrossEntropyWithSoftmax(classifierOutput, labelsVar, "lossFunction");
var prediction = CNTKLib.ClassificationError(classifierOutput, labelsVar, 5, "predictionError");   //top5

6.学习率设置

var learningRatePerSample = new TrainingParameterScheduleDouble(0.0078125, 1);

7.训练器

var trainer = Trainer.CreateTrainer(classifierOutput, trainingLoss, prediction,
                new List<Learner> { Learner.SGDLearner(classifierOutput.Parameters(), learningRatePerSample) });

8.开始训练

while (true)
{
    //获取每次批次的数据
    var minibatchData = minibatchSource.GetNextMinibatch(minibatchSize, device);

    if (minibatchData.empty())
    {
        break;
    }

    //训练批次
    trainer.TrainMinibatch(new Dictionary<Variable, MinibatchData>()
            { { imageInput, minibatchData[imageStreamInfo] }, { labelsVar, minibatchData[labelStreamInfo] } }, device);

    //输出训练结果
    PrintTrainingProgress(trainer, miniBatchCount++, outputFrequencyInMinibatches);
}

9.验证集合

public static float ValidateModelWithMinibatchSource(string modelFile, MinibatchSource testMinibatchSource, int[] imageDim, int numClasses, string featureInputName, string labelInputName, string outputName, DeviceDescriptor device, int maxCount = 1000)
{
    Function model = Function.Load(modelFile, device);
    var imageInput = model.Arguments[0];
    var labelOutput = model.Outputs.Single(o => o.Name == outputName);

    var featureStreamInfo = testMinibatchSource.StreamInfo(featureInputName);
    var labelStreamInfo = testMinibatchSource.StreamInfo(labelInputName);

    int batchSize = 50;
    int miscountTotal = 0, totalCount = 0;
    while (true)
    {
        var minibatchData = testMinibatchSource.GetNextMinibatch((uint)batchSize, device);
        if (minibatchData == null || minibatchData.Count == 0)
            break;
        totalCount += (int)minibatchData[featureStreamInfo].numberOfSamples;

        var labelData = minibatchData[labelStreamInfo].data.GetDenseData<float>(labelOutput);
        var expectedLabels = labelData.Select(l => l.IndexOf(l.Max())).ToList();

        var inputDataMap = new Dictionary<Variable, Value>() {
            { imageInput, minibatchData[featureStreamInfo].data }
        };

        var outputDataMap = new Dictionary<Variable, Value>() {
            { labelOutput, null }
        };

        model.Evaluate(inputDataMap, outputDataMap, device);
        var outputData = outputDataMap[labelOutput].GetDenseData<float>(labelOutput);
        var actualLabels = outputData.Select(l => l.IndexOf(l.Max())).ToList();

        int misMatches = actualLabels.Zip(expectedLabels, (a, b) => a.Equals(b) ? 0 : 1).Sum();

        miscountTotal += misMatches;
        Console.WriteLine($"Validating Model: Total Samples = {totalCount}, Misclassify Count = {miscountTotal}");

        if (totalCount > maxCount)
            break;
    }

    float errorRate = 1.0F * miscountTotal / totalCount;
    Console.WriteLine($"Model Validation Error = {errorRate}");
    return errorRate;
}

三、训练展示

在这里插入图片描述
在这里插入图片描述

源码

源码下载

爱学习的广东仔
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
基于CNTK/C# 实现Cifar的实现，网络模型为ResNet
10-25
标题中的“基于CNTK/C# 实现Cifar的实现，网络模型为ResNet”表明了这是一个使用微软认知工具包（CNTK）和C#编程语言，实现针对Cifar数据集的深度学习项目，且网络结构采用了残差网络（ResNet）。Cifar是一个广泛...
基于CNTK/C#实现自定义数据集的图像分类
10-30
总的来说，基于CNTK和C#实现自定义数据集的图像分类是一个涉及数据处理、模型构建、训练和评估的完整流程。这个过程中需要掌握C#编程、深度学习基础知识以及CNTK的API使用。通过实践，不仅可以提升编程技能，也能...
基于CNTK/C#实现图像分类【附部分源码及模型】
ctu_sue的博客
10-30 1084
本文基于CNTK实现分类，并以之前的不同，本次使用C#实现，不适用python，python版的CNTK比较简单，而且python版的cntk个人感觉没什么必要，毕竟是微软的框架因此本人强迫症犯了，所以使用C#实现CNTK环境版本：cntk 2.7cuda 10.1
基于CNTK/C#实现MNIST【附源码】
ctu_sue的博客
10-25 377
本文实现基于CNTK实现MNIST，并对其实现CNN以及MLP方法进行测试。
c# cntk 模型复制_CNTK-分类模型
cunzai1985的博客
09-22 251
c# cntk 模型复制 CNTK-分类模型 (CNTK - Classification Model) Advertisements 广告 Previous Page 上一页 Next Page 下一页 This chapter will help you to understand how to measure performance of classifi...
深度学习框架【CNTK】的安装
ctu_sue的博客
10-25 2001
鉴于之前介绍的深度学习框架都是基于python写的，本次学习CNTK的时候决定使用C#来尝试，而且CNTK因各种原因，暂时无法在高于3.6版本进行安装，因此决定尝试使用C#来做CNTK的开发。
通过C#/.NET API使用CNTK
dotNET跨平台
10-17 1681
CNTK v2.2.0提供C#API来建立、训练和评估CNTK模型。 本节概要介绍了CNTK C#API。 在CNTK github respository中可以找到C#训练示例。 使用C＃/ .NET管理API构建深层神经网络 CNTK C#API 通过CNTKLib命名空间提供基本操作。 CNTK操作需要一个或两个具有必要参数的输入变量，并产生一个CNTK函数。 CNTK函数将输入
基于C#/CNTK实现的MNIST
10-25
总的来说，这个“基于C#/CNTK实现的MNIST”项目提供了一个在C#环境中使用深度学习解决实际问题的实例。通过这个项目，开发者不仅可以学习到C#与CNTK的结合使用，还能深入了解CNN的工作原理以及如何处理图像识别任务...
modbus tcp/rtu 基于C#的源码实现(老外的源码)
11-15
2. **数据编码与解码**：根据ModBus协议，你需要实现将C#对象转换为二进制流（用于发送）和从二进制流解析数据（用于接收）的方法。 3. **错误处理**：确保正确处理异常，如超时、连接中断、无效响应等。 4. **...
打造最漂亮的串口通讯调试助手 基于C# WPF .net4开发 附源码带详细注释
06-27
WPF界面全部用XAML语言手打，基本都是Grid布局，VS很强大，编程很舒服便捷，源码有很详细的注释。 * 学C#和WPF编的第一个软件，整个编程过程，通过百度不断学习 * 作者是做硬件的，只为学习做简单的上位机程序，...
CNTK(微软深度学习工具包) v2.0正式版
01-22
CNTK2.0由微软正式发布，全名Cognitive Toolkit/CNTK，是一个可帮助公司加速图像和语音处理的深度学习工具。CNTK最早是由微软一些想要更快更高效地做自己的研究的计算机科学家开发的，但事故它很快就超越了语音领域并演变成了一个产品。已经在微软的产品上得到了广泛的应用，并且也被全世界需要大规模应用深度学习的公司或对最近的算法和技术感兴趣的学习所使用。 伴随着新版本CNTK2.0发布，该工具包的最新版本已经通过一个开源证书发布在了GitHub上，用户可以使用包括 Python（版本2.7、3.4 和3.5）、C++以及C#/.NET管理的认知工具包软件库获得额外的绑定。其他新特性包括Python示例和教程、Layers library的诸多改进、自动安装、Docker Hub中包括Docker 图像等等，部署了数百个新特性、性能提升和修复。
使用CNTK和C＃进行线性回归
04-14
使用CNTK和C＃进行线性回归
微软的深度学习框架cntk ，我目前见过 安装方式最简单的一个框架，2.0之后开始支持C# 咯...
04-07 191
wiki：https://github.com/Microsoft/CNTK/wiki 嗨，你也是我这种手残党么？之前试着安装着mxnet和tensorflow，但是因为时间比较短所以往往来不及安装完就失去兴趣，今天看到微软的cntk可以用了，一次性安装好了，并且测试通过 本人环境: Windows 7 X64 8G内存 下载链接 官方安装说明：https://gith...
CNTK在C#中的使用入门
11-03 461
关于如何用C#调用CNTK ，网上有寥寥无几的帖子，切都是老版本的。还有人很不爽的说大微软的人工智能包居然支持Python,而无C#?岂有此理？！ 想想也没什么，微软有时候也很无厘头。Python的慢是专业IT所不能忍受的，好在只是粘合剂的作用，CNTK纯纯C++作品，速度杠杠的，据说甩ten...
ResNet网络复现
qq_38109282的博客
04-20 2578
ResNet 本篇实现的是基于2015年何凯明推出的ResNet，2016年的改进后续试着实现，比较下效果。 学习流程 阅读ResNet论文原文 搜集学习资源：视频讲解-博客资源 熟悉ResNet网络结构 代码复现，清楚网络结构中层与层之间的操作 ResNet论文 原论文：2015-Deep Residual Learning for Image Recognition 2016-Identity Mappings in Deep Residual Networks 论文翻译：ResNet论文翻译——中
在C#中调用OpenVINO™ 模型 | 开发者实战
最新发布
hllyzms的博客
12-04 829
1.1 项目概述1.1.1 项目介绍C#调用OpenVINO™ 工具套件部署Al模型项目开发项目，简称OpenVinoSharp，这是一个示例项目，该项目实现在C#编程语言下调用Intel推出的 OpenVINO™ 工具套件，进行深度学习等Al项目在C#框架下的部署。该项目由C++语言编写OpenVINO™ dll库，并在C#语言下实现调用。项目可以实现在C#编程语言下调用Intel推出的 OpenVINO™ 工具套件，进行深度学习等Al项目在C#框架下的部署，目前可以支持的Al模型格式：■ Paddl
C# .NET ML.NET 机器学习 图像分类
LiuV
05-20 1996
C# .NET ML.NET 机器学习 图像分类 一、 准备工作 先下载好“resnet_v2_50_299.meta”这个文件，放入“C:\Users\jk\AppData\Local\Temp\MLNET\”这个文件夹，目录不存在自己新建下。“jk”是WINDOWS登录名，注意换成你自己的。 下载地址：https://download.csdn.net/download/runliuv/15724931 新建一个“z机器学习样本1”目录，再建立“猫”和“狗”2个子目录。在网上下载“猫”和“狗”的图
基于CNTK/C#实现逻辑回归【附源码】
ctu_sue的博客
11-01 579
本文基于CNTK实现逻辑回归二分类，并以之前的不同，本次使用C#实现，不适用python，python版的CNTK比较简单，而且python版的cntk个人感觉没什么必要，毕竟是微软的框架因此本人强迫症犯了，所以使用C#实现CNTK环境版本：cntk 2.7cuda 10.1。
CNTK入门新人必看【很多人不懂的基础问题】
赫的BLOG
02-10 7779
CNTK是用C++写的深层神经网络工具集，就目前的趋势来看，google类库虽然人气众多，但是不重视抢占windows市场，估计以后windows平台下面，还是微软的cntk做老大的地位。 CNTK虽然支持C++,c#的调用，但是仍然离不开Python和BrainScript，参考CNTK当前支持的模型列表    要首先用Python和BrainScript生成模型，处理下输入流，然后用C++
C#的串口通信源程序.doc
11-17
本资源是一份C#编写的串口通信源程序，用于实现单片机上位机和下位机之间的简单通信。该程序是基于Windows Forms设计的，主要用于控制和监控串口通信过程。以下是关键知识点的详细解读： 1. **环境与依赖**: - 该...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

爱学习的广东仔

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值