Python 具有C++； 我尝试使用 CNTK 的C++ API实现在线学习。在阅读单元测试的源代码和CNTKLibrary.h标题时，我只看到了培训模型的Trainer.TrainMinibatch方法。此方法可用于传递单个输入输出数据点吗？如果可能，最简单的方法是什么

我试图使用

CNTK:：Value:：CreateSequence

方法创建一个序列，然后我想在

TrainMinibatch

函数中使用该序列，但它没有按我预期的方式工作：

我尝试将此

python

代码移植到C++：

num_hidden_layers = 2
num_output_classes = 2
input_dim = 1
hidden_layers_dim = 400

input_var = C.input_variable(input_dim)
label_var = C.input_variable(num_output_classes)

def create_model(features):
    with C.layers.default_options(init = C.glorot_uniform(), activation=C.ops.relu):
        h = features
        for _ in range(num_hidden_layers):
            h = C.layers.Dense(hidden_layers_dim, activation=C.sigmoid)(h)
        r = C.layers.Dense(num_output_classes, activation=None)(h)
        return r

z = create_model(input_var)
loss = C.cross_entropy_with_softmax(z, label_var)
label_error = C.classification_error(z, label_var)

learning_rate = 0.2
lr_schedule = C.learning_rate_schedule(learning_rate, C.UnitType.minibatch)
learner = C.sgd(z.parameters, lr_schedule)
trainer = C.Trainer(z, (loss, label_error), [learner])

input_map = { label_var : None,  input_var : None}
training_progress_output_freq = 500

for i in range(0, 10000):
    input_map[input_var] = np.array([np.random.randint(0,2)], dtype=np.float32);
    if input_map[input_var] == 0:
        input_map[label_var] = np.array([1,0], dtype=np.float32)
    else:
         input_map[label_var] = np.array([0, 1], dtype=np.float32)
    trainer.train_minibatch(input_map)

我最后用这个C++代码：

const size_t inputDim = 1;// 28 * 28;
const size_t numOutputClasses = 2;// 10;
const size_t hiddenLayerDim = 400;
const size_t numHiddenLayers = 2;

//build the model
auto input = InputVariable({ inputDim }, DataType::Float, L"features");
FunctionPtr classifierOutput = input;
for (int i = 0; i < numHiddenLayers; i++)
{
    classifierOutput = FullyConnectedDNNLayer(classifierOutput, hiddenLayerDim, device, std::bind(Sigmoid, _1, L""));
}
classifierOutput = FullyConnectedLinearLayer(classifierOutput, 2, device);

auto labels = InputVariable({ numOutputClasses }, DataType::Float, L"labels");
auto trainingLoss = CrossEntropyWithSoftmax(classifierOutput, labels, L"lossFunction");
auto prediction = Minus(Constant::Scalar(1.0f, device), ClassificationError(classifierOutput, labels, L"classificationError"));

LearningRatePerMinibatchSchedule learningRatePerSample = 0.2;
auto trainer = CreateTrainer(classifierOutput, trainingLoss, prediction,
{ SGDLearner(classifierOutput->Parameters(), learningRatePerSample) }
);

std::cout << "Starting to train...\n";
size_t outputFrequencyInMinibatches = 500;
for (size_t i = 0; i < 10000; ++i)
{
    //input data
    std::vector<float> inputData(1);
    inputData[0] = ((float)rand()) / RAND_MAX;

    //output data
    std::vector<float> outputData(2);
    outputData[0] = inputData[0] > 0.5 ? 1.0 : 0.0;
    outputData[1] = 1.0 - outputData[0];

    ValuePtr inputSequence = CNTK::Value::CreateSequence(NDShape({ 1 }), inputData, device);
    ValuePtr outputSequence = CNTK::Value::CreateSequence(NDShape({ 2 }), outputData, device);

    std::unordered_map<Variable, ValuePtr> map = {{ input, inputSequence }, { labels, outputSequence }  };
    trainer->TrainMinibatch(map, device);
}

const size\u t inputDim=1；//28 * 28;
常量大小\u t numOutputClasses=2；//10;
常数大小\u t hiddenLayerDim=400；
常数大小\u t numHiddenLayers=2；
//建立模型
自动输入=InputVariable（{inputDim}，数据类型：：Float，L“features”）；
FunctionPtr ClassifierRoutPut=输入；
对于（int i=0；iParameters（），learningRatePerSample）}
);
标准：：cout 0.5？1.0 : 0.0;
outputData[1]=1.0—outputData[0]；
ValuePtr inputSequence=CNTK:：Value:：CreateSequence（NDShape（{1}），inputData，设备）；
ValuePtr outputSequence=CNTK:：Value:：CreateSequence（NDShape（{2}），outputData，设备）；
无序映射={{input，inputSequence}，{labels，outputSequence}；
培训师->列车小批量（地图、设备）；
}

---

< >我可以编译代码并让它运行，但是C++版本中的损失不收敛到0；在经过几百次迭代后的python版本中，损失或多或少是0…

python的输入数据似乎是0或1：

input_map[input_var] = np.array([np.random.randint(0,2)], dtype=np.float32);

<> >在C++代码中，它的浮动在0和1之间/<

//input data
std::vector<float> inputData(1);
inputData[0] = ((float)rand()) / RAND_MAX;

//输入数据
std：：矢量输入数据（1）；
inputData[0]=（（浮点）rand（））/rand_MAX；

请将它们更改为相同，并检查收敛速度是否不同