Una introducción a Tensorflow.js - Machine Learning en la web

El Machine Learning ha sido una palabra muy pronunciado estos últimos años. Y es que gracias a la Inteligencia Artificial, las grandes compañias lo utilizan para mejor la experiencia del usuario. El lenguaje de progrmaación Python es un lenguaje con el cual se pueden realizar procesos de Machine Learning de manera muy fácil. Esto porque existen demasiados paquetes y librerias, como lo son: Keras, Scikit-Learn, OpenCv, Caffe, Tensorflow, y muchos más.

Hace poco tiempo Google, lanaza la libreria Tensorflow.js la cual nos permite crwar procesos de Aprendizaje Automatico en nuestras paginas webs.

En este articulo me dedicare a explicarles los conceptos básicos de Tensorflow.js y realizaremos nuestro primer programa de Inteligencia Artificial.

Sí quieres probar los ejemplos, puedes hacer online desde: https://codepen.io.

¿Que es Tensorflow.js?

TensorFlow.js es una biblioteca JavaScript de código abierto acelerada por JavaScript para inteligencia artificial. Ofrece bloques de aprendizaje de máquinas de alto rendimiento al alcance de su mano, lo que le permite entrenar redes neuronales en un navegador o ejecutar modelos pre-entrenados en modo de inferencia.

TensorFlow.js proporciona bloques de construcción de bajo nivel para el aprendizaje automático, así como una API inspirada en Keras de alto nivel para la construcción de redes neuronales. Echemos un vistazo a algunos de los componentes principales de la biblioteca.

Liberia

Podremos obtener acceso a la librería simplemente con el CDN:

<script src="https://cdn.jsdelivr.net/npm/@tensorflow/tfjs@0.11.7"> </script>

Tensores

La unidad central de datos en TensorFlow.js es el tensor: un conjunto de valores numéricos formados en una matriz de una o más dimensiones. Una instancia Tensor tiene un shape atributo que define la forma de la matriz (es decir, cuántos valores hay en cada dimensión de la matriz).

El Tensor constructor primario es la función tf.tensor:

// Tensor 2x3 const shape = [2, 3]; // 2 filas, 3 columnas const a = tf.tensor([1.0, 2.0, 3.0, 10.0, 20.0, 30.0], shape); a.print(); // Mostramos los valores de los tensores en la consola // Salida: [[1 , 2 , 3 ], // [10, 20, 30]] const b = tf.tensor([[1.0, 2.0, 3.0], [10.0, 20.0, 30.0]]); b.print(); // Salida: [[1 , 2 , 3 ], // [10, 20, 30]]

Sin embargo, para la construcción de los tensores de bajo rango, se recomienda utilizar las siguientes funciones para mejorar la legibilidad del código: tf.scalar, tf.tensor1d, tf.tensor2d, tf.tensor3dy tf.tensor4d.

El siguiente ejemplo crea un tensor idéntico al anterior utilizando tf.tensor2d:

const c = tf.tensor2d([[1.0, 2.0, 3.0], [10.0, 20.0, 30.0]]);
c.print();
// Salida: [[1 , 2 , 3 ],
//          [10, 20, 30]]

TensorFlow.js también proporciona funciones de conveniencia para crear tensores con todos los valores establecidos en 0 ( tf.zeros) o todos los valores establecidos en 1 ( tf.ones):

// Tensor 3x5 con todos los valores establecidos en 0
const zeros = tf.zeros([3, 5]);
// Salida: [[0, 0, 0, 0, 0],
//          [0, 0, 0, 0, 0],
//          [0, 0, 0, 0, 0]]

En TensorFlow.js, los tensores son inmutables; una vez creado, no puede cambiar sus valores. En su lugar, realiza operaciones sobre ellos que generan nuevos tensores.

Variables

Variable se inicializan con un tensor de valores. A diferencia de Tensor, sin embargo, sus valores son mutables. Puede asignar un nuevo tensor a una variable existente usando el assignmétodo:

const initialValues = tf.zeros([5]);
const biases = tf.variable(initialValues);
biases.print(); // Salida: [0, 0, 0, 0, 0]

const updatedValues = tf.tensor1d([0, 1, 0, 1, 0]);
biases.assign(updatedValues); // update values of biases
biases.print(); // output: [0, 1, 0, 1, 0]

Las variables se usan principalmente para almacenar y luego actualizar valores durante el entrenamiento modelo.

Operaciones (Ops)

Si bien los tensores le permiten almacenar datos, las operaciones (ops) le permiten manipular esos datos. TensorFlow.js proporciona una amplia variedad de operaciones adecuadas para el aprendizaje lineal y de álgebra lineal que se pueden realizar en tensores. Debido a que los tensores son inmutables, estas operaciones no cambian sus valores; en cambio, las operaciones devuelven nuevos tensores.

Las operaciones disponibles incluyen operaciones unarias tales como square:

const d = tf.tensor2d([[1.0, 2.0], [3.0, 4.0]]);
const d_squared = d.square();
d_squared.print();
// Salida: [[1, 4 ],
//          [9, 16]]

Y operaciones binarias tales como add, suby mul:

const e = tf.tensor2d([[1.0, 2.0], [3.0, 4.0]]);
const f = tf.tensor2d([[5.0, 6.0], [7.0, 8.0]]);

const e_plus_f = e.add(f);
e_plus_f.print();
// Salida: [[6 , 8 ],
//          [10, 12]]

TensorFlow.js tiene una API encadenable; puedes llamar a operaciones sobre el resultado de las operaciones:

const sq_sum = e.add(f).square();
sq_sum.print();
// Output: [[36 , 64 ],
//          [100, 144]]

// All operations are also exposed as functions in the main namespace,
// so you could also do the following:
const sq_sum = tf.square(tf.add(e, f));

Modelos y capas

Conceptualmente, un modelo es una función que, dado algún aporte, producirá algún resultado deseado.

En TensorFlow.js hay dos formas de crear modelos. Puede usar ops directamente para representar el trabajo que hace el modelo. Por ejemplo:

// Definimos la función
function predict(input) {
  // y = a * x ^ 2 + b * x + c
  return tf.tidy(() => {
    const x = tf.scalar(input);

    const ax2 = a.mul(x.square());
    const bx = b.mul(x);
    const y = ax2.add(bx).add(c);

    return y;
  });
}

// Definimos la constante: y = 2x^2 + 4x + 8
const a = tf.scalar(2);
const b = tf.scalar(4);
const c = tf.scalar(8);

// Predecir la salida de la entrada 2 2
const result = predict(2);
result.print() // Salida: 24

También puede usar la API de alto nivel tf.modelpara construir un modelo a partir de capas , que son una abstracción popular en aprendizaje profundo. El siguiente código construye un tf.sequentialmodelo:

const model = tf.sequential();
model.add(
  tf.layers.simpleRNN({
    units: 20,
    recurrentInitializer: 'GlorotNormal',
    inputShape: [80, 4]
  })
);

const optimizer = tf.train.sgd(LEARNING_RATE);
model.compile({optimizer, loss: 'categoricalCrossentropy'});
model.fit({x: data, y: labels});

Hay muchos tipos diferentes de capas disponibles en TensorFlow.js. Algunos ejemplos incluyen tf.layers.simpleRNN, tf.layers.gruy tf.layers.lstm.

Estoy planeando realizar una serie de tutoriales con respecto a Tensorflow.js mostrando desde lo más básico a un nivel intermedio. ¿Que te parecería? Dame tu opinión: https://m.me/codigocomentado.

Código Comentado

Buscar este blog