TL; DR
MNIST es el reconocimiento de imágenes Hello World. Después de aprenderlo de memoria, estas preguntas en su mente son fáciles de resolver.
Configuración de preguntas:
Su pregunta principal escrita es
// how to train, where to pass image and labels ?
dentro de su bloque de código. Para aquellos que encontré la respuesta perfecta de ejemplos de la sección de ejemplos de Tensorflow.js: ejemplo de MNIST. Mis enlaces a continuación tienen versiones de javascript y node.js puras y explicaciones de Wikipedia. Los examinaré en el nivel necesario para responder la pregunta principal en su mente y agregaré también perspectivas sobre cómo sus propias imágenes y etiquetas tienen algo que ver con el conjunto de imágenes MNIST y los ejemplos que lo usan.
Lo primero es lo primero:
Fragmentos de código.
dónde pasar las imágenes (muestra de Node.js)
async function loadImages(filename) {
const buffer = await fetchOnceAndSaveToDiskWithBuffer(filename);
const headerBytes = IMAGE_HEADER_BYTES;
const recordBytes = IMAGE_HEIGHT * IMAGE_WIDTH;
const headerValues = loadHeaderValues(buffer, headerBytes);
assert.equal(headerValues[0], IMAGE_HEADER_MAGIC_NUM);
assert.equal(headerValues[2], IMAGE_HEIGHT);
assert.equal(headerValues[3], IMAGE_WIDTH);
const images = [];
let index = headerBytes;
while (index < buffer.byteLength) {
const array = new Float32Array(recordBytes);
for (let i = 0; i < recordBytes; i++) {
// Normalize the pixel values into the 0-1 interval, from
// the original 0-255 interval.
array[i] = buffer.readUInt8(index++) / 255;
}
images.push(array);
}
assert.equal(images.length, headerValues[1]);
return images;
}
Notas:
El conjunto de datos MNIST es una imagen enorme, donde en un archivo hay varias imágenes como mosaicos en rompecabezas, todas y cada una con el mismo tamaño, una al lado de la otra, como cuadros en la tabla de coordinación x e y. Cada cuadro tiene una muestra y las correspondientes xey en la matriz de etiquetas tienen la etiqueta. A partir de este ejemplo, no es un gran problema convertirlo a varios formatos de archivo, por lo que en realidad solo se le da una imagen a la vez al ciclo while para manejar.
Etiquetas:
async function loadLabels(filename) {
const buffer = await fetchOnceAndSaveToDiskWithBuffer(filename);
const headerBytes = LABEL_HEADER_BYTES;
const recordBytes = LABEL_RECORD_BYTE;
const headerValues = loadHeaderValues(buffer, headerBytes);
assert.equal(headerValues[0], LABEL_HEADER_MAGIC_NUM);
const labels = [];
let index = headerBytes;
while (index < buffer.byteLength) {
const array = new Int32Array(recordBytes);
for (let i = 0; i < recordBytes; i++) {
array[i] = buffer.readUInt8(index++);
}
labels.push(array);
}
assert.equal(labels.length, headerValues[1]);
return labels;
}
Notas:
Aquí, las etiquetas también son datos de bytes en un archivo. En el mundo Javascript, y con el enfoque que tiene en su punto de partida, las etiquetas también podrían ser una matriz json.
entrenar al modelo:
await data.loadData();
const {images: trainImages, labels: trainLabels} = data.getTrainData();
model.summary();
let epochBeginTime;
let millisPerStep;
const validationSplit = 0.15;
const numTrainExamplesPerEpoch =
trainImages.shape[0] * (1 - validationSplit);
const numTrainBatchesPerEpoch =
Math.ceil(numTrainExamplesPerEpoch / batchSize);
await model.fit(trainImages, trainLabels, {
epochs,
batchSize,
validationSplit
});
Notas:
Aquí model.fit
está la línea de código real que hace la cosa: entrena el modelo.
Resultados de todo el asunto:
const {images: testImages, labels: testLabels} = data.getTestData();
const evalOutput = model.evaluate(testImages, testLabels);
console.log(
`\nEvaluation result:\n` +
` Loss = ${evalOutput[0].dataSync()[0].toFixed(3)}; `+
`Accuracy = ${evalOutput[1].dataSync()[0].toFixed(3)}`);
Nota:
En Data Science, también esta vez aquí, la parte más fascinante es saber qué tan bien el modelo sobrevive a la prueba de nuevos datos y sin etiquetas, ¿puede etiquetarlos o no? Para eso es la parte de evaluación que ahora nos imprime algunos números.
Pérdida y precisión: [4]
Cuanto menor sea la pérdida, mejor será un modelo (a menos que el modelo se haya ajustado demasiado a los datos de entrenamiento). La pérdida se calcula en el entrenamiento y la validación y su interacción es qué tan bien le está yendo al modelo en estos dos conjuntos. A diferencia de la precisión, la pérdida no es un porcentaje. Es un resumen de los errores cometidos para cada ejemplo en conjuntos de entrenamiento o validación.
..
La precisión de un modelo generalmente se determina después de que los parámetros del modelo se aprenden y arreglan y no se lleva a cabo el aprendizaje. Luego, las muestras de prueba se envían al modelo y se registra el número de errores (pérdida cero-uno) que comete el modelo, después de la comparación con los objetivos reales.
Más información:
En las páginas de github, en el archivo README.md, hay un enlace al tutorial, donde todo en el ejemplo de github se explica con mayor detalle.
[1] https://github.com/tensorflow/tfjs-examples/tree/master/mnist
[2] https://github.com/tensorflow/tfjs-examples/tree/master/mnist-node
[3] https://en.wikipedia.org/wiki/MNIST_database
[4] Cómo interpretar "pérdida" y "precisión" para un modelo de aprendizaje automático