El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia

HOME

Introducción a TensorFlow.js

TensorFlow.js es una biblioteca de JavaScript para entrenar e implementar modelos de aprendizaje automático en el navegador y en Node.js. Esta herramienta permite a los desarrolladores aprovechar la potencia de TensorFlow directamente en aplicaciones web, lo que abre un abanico de posibilidades para la creación de aplicaciones interactivas y en tiempo real.

¿Por qué usar TensorFlow.js?

Interactividad en tiempo real: Permite la creación de aplicaciones que pueden interactuar con el usuario en tiempo real.
Despliegue sencillo: Los modelos pueden ser desplegados directamente en el navegador sin necesidad de servidores adicionales.
Accesibilidad: Facilita el acceso a modelos de aprendizaje automático a través de aplicaciones web.
Compatibilidad con Node.js: Permite el uso de TensorFlow en aplicaciones de servidor con Node.js.

Configuración de TensorFlow.js

Instalación en el Navegador

Para usar TensorFlow.js en el navegador, simplemente incluye la biblioteca en tu archivo HTML:

<!DOCTYPE html>
<html>
<head>
  <title>TensorFlow.js Example</title>
  <script src="https://cdn.jsdelivr.net/npm/@tensorflow/tfjs"></script>
</head>
<body>
  <h1>TensorFlow.js en el Navegador</h1>
  <script>
    // Aquí va tu código TensorFlow.js
  </script>
</body>
</html>

Instalación en Node.js

Para usar TensorFlow.js en un entorno Node.js, primero necesitas instalar el paquete:

npm install @tensorflow/tfjs-node

Luego, puedes requerir la biblioteca en tu archivo JavaScript:

const tf = require('@tensorflow/tfjs-node');

Conceptos Básicos de TensorFlow.js

Tensores

Los tensores son la estructura de datos fundamental en TensorFlow.js. Un tensor es una matriz multidimensional que puede contener datos de diferentes tipos (números, cadenas, etc.).

Creación de Tensores

// Crear un tensor de 1D (vector)
const tensor1d = tf.tensor1d([1, 2, 3, 4]);

// Crear un tensor de 2D (matriz)
const tensor2d = tf.tensor2d([[1, 2], [3, 4]]);

// Crear un tensor de 3D
const tensor3d = tf.tensor3d([[[1], [2]], [[3], [4]]]);

console.log(tensor1d.toString());
console.log(tensor2d.toString());
console.log(tensor3d.toString());

Operaciones con Tensores

TensorFlow.js proporciona una amplia gama de operaciones matemáticas que se pueden realizar en tensores.

Operaciones Básicas

const a = tf.tensor1d([1, 2, 3]);
const b = tf.tensor1d([4, 5, 6]);

// Suma
const sum = a.add(b);
sum.print(); // [5, 7, 9]

// Producto
const product = a.mul(b);
product.print(); // [4, 10, 18]

Variables

Las variables son tensores cuyo valor puede ser modificado. Son útiles para almacenar pesos y sesgos en modelos de aprendizaje automático.

const initialValue = tf.tensor1d([1, 2, 3]);
const variable = tf.variable(initialValue);

// Modificar el valor de la variable
variable.assign(tf.tensor1d([4, 5, 6]));
variable.print(); // [4, 5, 6]

Creación de un Modelo Simple

Definición del Modelo

En TensorFlow.js, los modelos se definen utilizando la API de Keras, que es una API de alto nivel para construir y entrenar modelos de aprendizaje profundo.

const model = tf.sequential();

// Añadir una capa densa
model.add(tf.layers.dense({units: 10, activation: 'relu', inputShape: [4]}));

// Añadir una capa de salida
model.add(tf.layers.dense({units: 3, activation: 'softmax'}));

model.summary();

Compilación del Modelo

Antes de entrenar el modelo, es necesario compilarlo especificando el optimizador, la función de pérdida y las métricas.

model.compile({
  optimizer: 'sgd',
  loss: 'categoricalCrossentropy',
  metrics: ['accuracy']
});

Entrenamiento del Modelo

Para entrenar el modelo, se utiliza el método fit, proporcionando los datos de entrada y las etiquetas.

const xs = tf.tensor2d([[1, 2, 3, 4], [4, 5, 6, 7], [7, 8, 9, 10]]);
const ys = tf.tensor2d([[1, 0, 0], [0, 1, 0], [0, 0, 1]]);

model.fit(xs, ys, {
  epochs: 10,
  callbacks: {
    onEpochEnd: (epoch, logs) => {
      console.log(`Epoch ${epoch}: loss = ${logs.loss}`);
    }
  }
});

Ejemplo Práctico: Clasificación de Flores Iris

Descripción del Problema

El conjunto de datos de Iris es un clásico en el aprendizaje automático. Contiene 150 muestras de flores Iris, cada una con cuatro características (longitud y ancho del sépalo y del pétalo) y una de tres etiquetas de clase (Iris setosa, Iris versicolor, Iris virginica).

Implementación

Paso 1: Cargar los Datos

const iris = require('ml-dataset-iris');
const { getDataset } = require('ml-dataset-iris');

const { data, labels } = getDataset();
const xs = tf.tensor2d(data);
const ys = tf.oneHot(tf.tensor1d(labels, 'int32'), 3);

Paso 2: Definir y Compilar el Modelo

const model = tf.sequential();
model.add(tf.layers.dense({units: 10, activation: 'relu', inputShape: [4]}));
model.add(tf.layers.dense({units: 3, activation: 'softmax'}));

model.compile({
  optimizer: 'adam',
  loss: 'categoricalCrossentropy',
  metrics: ['accuracy']
});

Paso 3: Entrenar el Modelo

model.fit(xs, ys, {
  epochs: 50,
  callbacks: {
    onEpochEnd: (epoch, logs) => {
      console.log(`Epoch ${epoch}: loss = ${logs.loss}, accuracy = ${logs.acc}`);
    }
  }
});

Paso 4: Evaluar el Modelo

const result = model.evaluate(xs, ys);
result[0].print(); // Pérdida
result[1].print(); // Precisión

Ejercicios Prácticos

Ejercicio 1: Crear un Modelo de Regresión Lineal

Objetivo: Crear y entrenar un modelo de regresión lineal para predecir valores de salida basados en datos de entrada.

Instrucciones:

Define un modelo secuencial con una capa densa.
Compila el modelo utilizando el optimizador 'sgd' y la función de pérdida 'meanSquaredError'.
Entrena el modelo con datos de entrada y salida.

Solución:

const model = tf.sequential();
model.add(tf.layers.dense({units: 1, inputShape: [1]}));

model.compile({
  optimizer: 'sgd',
  loss: 'meanSquaredError'
});

const xs = tf.tensor2d([1, 2, 3, 4], [4, 1]);
const ys = tf.tensor2d([1, 3, 5, 7], [4, 1]);

model.fit(xs, ys, {
  epochs: 100,
  callbacks: {
    onEpochEnd: (epoch, logs) => {
      console.log(`Epoch ${epoch}: loss = ${logs.loss}`);
    }
  }
});

Ejercicio 2: Clasificación de Dígitos MNIST

Objetivo: Crear y entrenar un modelo para clasificar dígitos escritos a mano utilizando el conjunto de datos MNIST.

Instrucciones:

Carga el conjunto de datos MNIST.
Define un modelo secuencial con varias capas densas.
Compila y entrena el modelo.
Evalúa el modelo en el conjunto de datos de prueba.

Solución:

const mnist = require('mnist'); // Asegúrate de instalar el paquete mnist
const { set } = mnist;

const { training, test } = set(8000, 2000);

const trainXs = tf.tensor2d(training.map(item => item.input));
const trainYs = tf.tensor2d(training.map(item => item.output));

const testXs = tf.tensor2d(test.map(item => item.input));
const testYs = tf.tensor2d(test.map(item => item.output));

const model = tf.sequential();
model.add(tf.layers.dense({units: 128, activation: 'relu', inputShape: [784]}));
model.add(tf.layers.dense({units: 64, activation: 'relu'}));
model.add(tf.layers.dense({units: 10, activation: 'softmax'}));

model.compile({
  optimizer: 'adam',
  loss: 'categoricalCrossentropy',
  metrics: ['accuracy']
});

model.fit(trainXs, trainYs, {
  epochs: 10,
  validationData: [testXs, testYs],
  callbacks: {
    onEpochEnd: (epoch, logs) => {
      console.log(`Epoch ${epoch}: loss = ${logs.loss}, accuracy = ${logs.acc}`);
    }
  }
});

Conclusión

En esta sección, hemos explorado TensorFlow.js, una poderosa herramienta que permite llevar el aprendizaje automático al navegador y a Node.js. Hemos cubierto desde la configuración básica hasta la creación y entrenamiento de modelos simples. Además, hemos proporcionado ejercicios prácticos para reforzar los conceptos aprendidos. Con TensorFlow.js, puedes crear aplicaciones interactivas y en tiempo real que aprovechan la potencia del aprendizaje automático directamente en el navegador. ¡Sigue explorando y experimentando con TensorFlow.js para descubrir todo su potencial!

TensorFlow.js