Python 为什么我的裸骨C/C++；模型的性能不如TensorFlow模型？

我在TensorFlow中实现了一个回归模型（接收3个输入并在输出中添加它们），如下所示：

hidden = tf.keras.layers.Dense(units=8,
                               input_shape=[3])

output = tf.keras.layers.Dense(units=1)

model = tf.keras.Sequential([hidden, output])

model.compile(loss='mean_squared_error')

history = model.fit(xtrain,ytrain,
                    epochs=500,
                    shuffle= True,
                    verbose=False)

print("Finished training the model")

它只需8个训练集的数据和500个历元（默认情况下使用线性激活，无需标准化），就可以出色地执行

当我尝试在一个C/C++低级模型（只有标准的C/C++库）上做同样的事情时，所有的东西都一样（显然），我得到了所有权重和输出的

NAN

/// Forward pass
            for (int j=0; j<numHiddenNodes; j++)
            {
                double activation=hiddenLayerBias[j];
                //std::cout<<"Training Set :"<<x<<"\n";
                 for (int k=0; k<numInputs; k++) {
                    activation+=training_inputs[x][k]*hiddenWeights[k][j];
                }
                hiddenLayer[j] = lin(activation);
            }

            for (int j=0; j<numOutputs; j++) {
                double activation=outputLayerBias[j];
                for (int k=0; k<numHiddenNodes; k++)
                {
                    activation+=hiddenLayer[k]*outputWeights[k][j];
                }
                outputLayer[j] = lin(activation);
            }

            //std::cout << "Input:" << training_inputs[x][0] << " " << "    Output:" << outputLayer[0] << "    Expected Output: " << training_outputs[x][0] << "\n";
            MSE += (1/numOutputs)*pow( training_outputs[x][0] - outputLayer[0], 2);

           /// Backprop
           ///   For V
            double deltaOutput[numOutputs];
            for (int j=0; j<numOutputs; j++) {
                double errorOutput = (training_outputs[i][j]-outputLayer[j]);
                deltaOutput[j] = errorOutput*dlin(outputLayer[j]);
            }

            ///   For W
            double deltaHidden[numHiddenNodes];
            for (int j=0; j<numHiddenNodes; j++) {
                double errorHidden = 0.0f;
                for(int k=0; k<numOutputs; k++) {
                    errorHidden+=deltaOutput[k]*outputWeights[j][k];
                }
                deltaHidden[j] = errorHidden*dlin(hiddenLayer[j]);
            }

            ///Updation
            ///   For V and b
            for (int j=0; j<numOutputs; j++) {
                //b
                outputLayerBias[j] += deltaOutput[j]*lr;
                for (int k=0; k<numHiddenNodes; k++)
                {
                    outputWeights[k][j]+= hiddenLayer[k]*deltaOutput[j]*lr;
                }

///向前传球
对于（int j=0；jn）当第一个NaN出现时，您必须进行调试（因为它将快速传播到所有地方）.我会假设你在某个地方被零除，得到无穷大，然后是NaN，但这不能仅从这个问题中的信息来理解。很难找到导致这种情况的元素。只有一个地方发生减法，0个地方发生除法。如果减法的话，我加上了0.001ion给出了一个0。但仍然得到NaN。这正是你应该拿出调试器并找到根本原因的原因。仅仅因为它是机器学习并不意味着它足以摆弄输入和代码，直到它“工作”。我建议在之后（或之后）检查NaN每个循环和使用中的一个选项使调试器在第一次出现时中断。然后检查数组的内容并从那里向后工作。