Función Tensorflow.js tf.train.rmsprop()

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.

La función tf.train.rmsprop() se usa para crear un tf.RMSPropOptimizer que usa el algoritmo decente de gradiente RMSProp. La implementación del optimizador RMSProp no es la versión centrada de RMSProp y utiliza un impulso simple. 

Sintaxis:

tf.train.rmsprop(learningRate, decay, momentum, epsilon, centered)

Parámetros:

• learningRate (número): Especifica la tasa de aprendizaje que utilizará el algoritmo de descenso de gradiente adadelta.
• decaimiento (número): Especifica la tasa de decaimiento de cada gradiente.
• impulso (número): especifica el impulso que utilizará el algoritmo de descenso de gradiente rmsprop.
• epsilon:  especifica un valor pequeño constante que se utiliza para evitar el denominador cero.
• centrado (booleano): especifica si los gradientes están normalizados por la varianza de gradiente estimada o no.

Valor devuelto: Devuelve un tf.RMSPropOptimizer

Ejemplo 1: Ajuste una función f=(a*x+y) usando el optimizador RMSProp, aprendiendo los coeficientes a y b.

// Importing tensorflow
import * as tf from "@tensorflow/tfjs"
 
const xs = tf.tensor1d([0, 1, 2]);
const ys = tf.tensor1d([1.1, 5.9, 16.8]);
 
// Choosing random coefficients.
const a = tf.scalar(Math.random()).variable();
const b = tf.scalar(Math.random()).variable();
 
// Defining function f = (a*x + b). We will use
// optimizer to fit f
const f = x => a.mul(x).add(b);
const loss = (pred, label) => pred.sub(label).square().mean();
 
// Define rate which will be used by rmsprop algorithm
const learningRate = 0.01;
 
// Create optimizer
const optimizer = tf.train.rmsprop(learningRate);
 
// 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()}}`);
const preds = f(xs).dataSync();
preds.forEach((pred, i) => {
   console.log(`x: ${i}, pred: ${pred}`);
});

Producción:

a:0.9164762496948242, b: 1.0887205600738525}
x: 0, pred: 1.0887205600738525
x: 1, pred: 2.0051968097686768
x: 2, pred: 2.921673059463501

Ejemplo 2:  Ajuste una ecuación cuadrática usando el optimizador RMSProp, aprendiendo los coeficientes a, b y c. Optimizer tendrá la siguiente configuración:

• tasa de aprendizaje = 0.01
• decaimiento = 0.1
• impulso = 1
• épsilon = 0,5
• centrado = verdadero

// 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.918823003768921, b: 3.333444833755493, c: 6.297145843505859
x: 0, pred: 6.297145843505859
x: 1, pred: 13.549413681030273
x: 2, pred: 28.639328002929688
x: 3, pred: 51.56688690185547

Referencia: https://js.tensorflow.org/api/1.0.0/#train.rmsprop