Tensorflow.js tf.train.Optimizer clase .minimize() Método

Tensorflow.js es una biblioteca de código abierto desarrollada por Google para ejecutar modelos de aprendizaje automático y redes neuronales de aprendizaje profundo en el entorno del navegador o del Node.

El método .minimize() ejecuta la función dada f() e intenta minimizar la salida escalar de f() calculando los gradientes de y con respecto a la lista dada de variables entrenables indicadas por varList. Si no se proporciona una lista, calcula los gradientes con respecto a todas las variables entrenables.

Sintaxis:

Optimizer.minimize (f, returnCost?, varList?)

Parámetros:

• f (() => tf.Scalar): Especifica la función a ejecutar y cuya salida minimizar.
• returnCost (booleano): Especifica si devolver el valor del costo escalar producido al ejecutar f() o no.
• varList (tf.Variable[]): Especifica la lista de variables entrenables.

Valor devuelto: tf.Escalar | nulo

Ejemplo 1:

// Importing tensorflow
import tensorflow as tf
   
const xs = tf.tensor1d([0, 1, 2]);
const ys = tf.tensor1d([1.3, 2.5, 3.7]);
   
const x = tf.scalar(Math.random()).variable();
const y = tf.scalar(Math.random()).variable();
   
// Define a function f(x, y) = x + y.
const f = x => x.add(y);
const loss = (pred, label) =>
    pred.sub(label).square().mean();
   
const learningRate = 0.05;
   
// Create adagrad optimizer
const optimizer =
  tf.train.adagrad(learningRate);
   
// Train the model.
for (let i = 0; i < 5; i++) {
   optimizer.minimize(() => loss(f(xs), ys));
}
   
// Make predictions.
console.log(
`x: ${x.dataSync()}, y: ${y.dataSync()}`);
const preds = f(xs).dataSync();
preds.forEach((pred, i) => {
console.log(`x: ${i}, pred: ${pred}`);
});

Producción

x: 0.9395854473114014, y: 1.0498266220092773
x: 0, pred: 1.0498266220092773
x: 1, pred: 2.0498266220092773
x: 2, pred: 3.0498266220092773

Ejemplo 2:

// Importing tensorflow
import * as tf from "@tensorflow/tfjs"
   
const xs = tf.tensor1d([0, 1, 2, 3]);
const ys = tf.tensor1d([1.1, 5.9, 16.8, 33.9]);
   
// Choosing random coefficients
const a = tf.scalar(Math.random()).variable();
const b = tf.scalar(Math.random()).variable();
const c = tf.scalar(Math.random()).variable();
   
// Defining function f = (a*x^2 + b*x + c)
const f = x => a.mul(x.square()).add(b.mul(x)).add(c);
const loss = (pred, label) => pred.sub(label).square().mean();
   
// Setting configurations for our optimizer
const learningRate = 0.01;
const decay = 0.1;
const momentum = 1;
const epsilon = 0.5;
const centered = true;
   
// Create the optimizer
const optimizer = tf.train.rmsprop(learningRate,
        decay, momentum, epsilon, centered);
   
// Train the model.
for (let i = 0; i < 8; i++) {
   optimizer.minimize(() => loss(f(xs), ys));
}
   
// Make predictions.
console.log(`a: ${a.dataSync()},
    b: ${b.dataSync()}, c: ${c.dataSync()}`);
const preds = f(xs).dataSync();
preds.forEach((pred, i) => {
   console.log(`x: ${i}, pred: ${pred}`);
});

Producción

a: 3.6799352169036865, 
    b: 4.26292610168457, c: 4.544136047363281
x: 0, pred: 4.544136047363281
x: 1, pred: 12.486997604370117
x: 2, pred: 27.789730072021484
x: 3, pred: 50.45233154296875

Referencia: https://js.tensorflow.org/api/latest/#tf.train.Optimizer.minimize