Node.js 神经网络刚刚获胜'；我不能正确地训练

我想创建一个能够从MINST数据库猜出数字的神经网络。我正在使用npmjs.org上的库（npm安装——save mnist）

我只是无法让我的神经网络学习数字，我还尝试了一个基本的异或问题，仍然不起作用。。没人知道为什么吗

import * as tf from '@tensorflow/tfjs-node';
import * as mnist from 'mnist';

const ACTIVATION = "sigmoid"

const input = tf.input({
  shape: [784],
});

const denseLayer1 = tf.layers.dense({
  units: 30,
  activation: ACTIVATION
});

const denseLayer2 = tf.layers.dense({
  units: 30,
  activation: ACTIVATION
});

const output = tf.layers.dense({
  units: 10,
  activation: ACTIVATION
});

const model = tf.model({
  inputs: input,
  outputs: output.apply(denseLayer2.apply(denseLayer1.apply(input)))
});

model.compile({
  optimizer: tf.train.sgd(0.1),
  loss: tf.losses.meanSquaredError
});


let coolSet = mnist.set(100, 300);
let inputs = [];
let outputs = [];
coolSet.training.forEach((oneTraining, index) => {
  inputs.push(oneTraining.input);
  outputs.push(oneTraining.output)
});
outputs = tf.tensor2d(outputs);
inputs = tf.tensor2d(inputs);

let testInputs = [];
let testOutputs = [];
coolSet.test.forEach(oneTest => {
  testInputs.push(oneTest.input);
  testOutputs.push(oneTest.output)
});

train().then(() => {
  testInputs.forEach((x, index) => {
    const predictedOutput = model.predict(tf.tensor2d([x]));
    console.log(`Excpected Output: ${testOutputs[index]}
  Output: ${predictedOutput.toString()}`)
  });
});

async function train() {
  for (let i = 0; i < 100; i++) {
    const config = {
      shuffle: true,
      epochs: 10
    };
    const response = await model.fit(inputs, outputs, config);
    console.log(response.history.loss[0]);
  }
}

---

答案很简单：多训练！我原以为10个时代和100次迭代就足够了，但我试了1000次，知道了，现在它可以工作了

对于这个神经网络，有几件事需要注意

要解决的问题是分类问题。这意味着给定一个输入，输出是在不同标签中选择一个类别。输出是一个概率（范围从0到1）。输出的总和应为1。通常，在分类问题中，最后一层是

softmax

激活，它接受一个输入层并输出一个分数，表示每个可能类别的概率

至于损失，最好的选择是

二进制交叉熵

或

分类交叉熵

。人们并没有真正计算预测和预期输出之间的欧几里德距离。与回归问题相比，它在这里的意义更小

const ACTIVATION=“sigmoid”
常量输入=tf.input({
形状：[784]，
});
const denseLayer1=tf.layers.dense({
单位:30,，
激活：激活
});
const denseLayer2=tf.layers.dense({
单位:30,，
激活：激活
});
常量输出=tf.layers.density({
单位:10,，
激活：“softmax”
});
const model=tf.model({
输入：输入，
输出：output.apply（denseLayer2.apply（denseLayer1.apply（输入）））
});
model.compile({
优化器：“亚当”，
损失：“分类交叉熵”
});
让coolSet=mnist.set（100300）；
让输入=[]；
让输出=[]；
coolSet.training.forEach（（一次训练，索引）=>{
输入。推送（oneTraining.input）；
outputs.push（oneTraining.output）
});
输出=tf张量（输出）；
输入=tf.张量（输入[100784]）；
设testInputs=[]；
设testOutputs=[]；
coolSet.test.forEach（oneTest=>{
测试输入推送（一次测试输入）；
testOutputs.push（oneTest.output）
});
训练（），然后（（）=>{
testInputs.slice（0,10）.forEach（（x，索引）=>{
const predictedOutput=model.predict（tf.tensor（[x]）；
log（`Excpected Output:${testOutputs[index]}
输出：${predictedOutput.equal（predictedOutput.max（1））.toString（）}`）
});
});
异步函数列（）{
常量配置={
洗牌：没错，
纪元：1000，
回调：{
onEpochEnd:async（u，l）=>{console.log（l.loss）}
}
};
const response=wait model.fit（输入、输出、配置）；
}

我的答案也有效，但我是神经网络的新手，所以我认为你的答案也正确！另外：您知道在哪里学习用于什么的函数吗？：）我给出了一些关于如何为一般分类问题构建层的建议。

Excpected Output: 0,0,1,0,0,0,0,0,0,0
  Output: Tensor
     [[0.0957722, 0.1015996, 0.0940665, 0.0999646, 0.1097334, 0.0965195, 0.1045253, 0.0923973, 0.1008056, 0.1046157],]

15ms 150us/step - loss=0.0889 
Epoch 10 / 10