El Projecte | Sobre nosaltres | Contribuir | Donacions | Llicència
HOME Els meus cursos Finalitzats
◄ Anterior
◄

TensorFlow.js

Següent ►
►

Introducció a TensorFlow.js

TensorFlow.js és una biblioteca de JavaScript per a l'entrenament i la implementació de models d'aprenentatge automàtic en el navegador i en Node.js. Aquesta biblioteca permet als desenvolupadors aprofitar la potència de TensorFlow directament en aplicacions web, oferint la capacitat de crear, entrenar i executar models de machine learning sense necessitat de backend.

Avantatges de TensorFlow.js

  • Execució en el navegador: Permet executar models d'aprenentatge automàtic directament en el navegador, aprofitant la GPU del dispositiu.
  • Interactivitat: Facilita la creació d'aplicacions interactives que poden respondre en temps real a les dades de l'usuari.
  • Portabilitat: Els models creats amb TensorFlow.js poden ser utilitzats tant en aplicacions web com en aplicacions de Node.js.
  • Integració amb altres biblioteques de JavaScript: Es pot integrar fàcilment amb altres biblioteques i frameworks de JavaScript com React, Angular, etc.

Instal·lació de TensorFlow.js

En el navegador

Per utilitzar TensorFlow.js en el navegador, només cal incloure la biblioteca en el teu fitxer HTML:

<!DOCTYPE html>
<html>
<head>
  <title>TensorFlow.js Example</title>
  <script src="https://cdn.jsdelivr.net/npm/@tensorflow/tfjs"></script>
</head>
<body>
  <script>
    // El teu codi de TensorFlow.js aquí
  </script>
</body>
</html>

En Node.js

Per utilitzar TensorFlow.js en un entorn Node.js, primer has d'instal·lar el paquet:

npm install @tensorflow/tfjs-node

Després, pots requerir la biblioteca en el teu fitxer JavaScript:

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

Conceptes bàsics de TensorFlow.js

Creació de tensors

Els tensors són la unitat bàsica de dades en TensorFlow.js. Pots crear tensors utilitzant la funció tf.tensor:

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

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

Operacions amb tensors

TensorFlow.js proporciona una àmplia gamma d'operacions matemàtiques que es poden realitzar amb tensors:

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

// Suma de tensors
const c = a.add(b);

// Multiplicació de tensors
const d = a.mul(b);

// Mostrar el resultat
c.print(); // [5, 7, 9]
d.print(); // [4, 10, 18]

Models i capes

TensorFlow.js permet crear models de xarxes neuronals utilitzant l'API de Keras. Aquí tens un exemple de com crear un model simple:

const model = tf.sequential();

// Afegir una capa d'entrada
model.add(tf.layers.dense({units: 32, inputShape: [784]}));

// Afegir una capa de sortida
model.add(tf.layers.dense({units: 10, activation: 'softmax'}));

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

Entrenament del model

Per entrenar el model, utilitza la funció model.fit:

const xs = tf.randomNormal([100, 784]);
const ys = tf.randomUniform([100, 10]);

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

Exemple pràctic: Classificació de dígits MNIST

Descripció del problema

El dataset MNIST és un conjunt de dades de dígits manuscrits que s'utilitza comunament per entrenar diversos sistemes de processament d'imatges. En aquest exemple, crearem un model simple per classificar aquests dígits utilitzant TensorFlow.js.

Carregant el dataset

TensorFlow.js proporciona una manera fàcil de carregar el dataset MNIST:

const mnist = require('mnist-data');

const data = mnist.training(0, 60000);
const testData = mnist.testing(0, 10000);

const xs = tf.tensor4d(data.images.values, [60000, 28, 28, 1]);
const ys = tf.tensor2d(data.labels.values, [60000, 10]);

const testXs = tf.tensor4d(testData.images.values, [10000, 28, 28, 1]);
const testYs = tf.tensor2d(testData.labels.values, [10000, 10]);

Creant el model

Crearem un model de xarxa neuronal convolucional (CNN) per a la classificació de dígits:

const model = tf.sequential();

model.add(tf.layers.conv2d({
  inputShape: [28, 28, 1],
  kernelSize: 3,
  filters: 32,
  activation: 'relu'
}));

model.add(tf.layers.maxPooling2d({poolSize: [2, 2]}));
model.add(tf.layers.flatten());
model.add(tf.layers.dense({units: 128, activation: 'relu'}));
model.add(tf.layers.dense({units: 10, activation: 'softmax'}));

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

Entrenant el model

Entrenarem el model utilitzant el dataset MNIST:

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

Avaluant el model

Després de l'entrenament, podem avaluar el model utilitzant el conjunt de dades de prova:

model.evaluate(testXs, testYs).print();

Exercicis pràctics

Exercici 1: Creació d'un tensor i operacions bàsiques

  1. Crea un tensor 2D de dimensions 3x3 amb valors aleatoris.
  2. Realitza una suma i una multiplicació element a element amb un altre tensor 2D de les mateixes dimensions.
  3. Mostra els resultats.

Solució

const tensorA = tf.randomNormal([3, 3]);
const tensorB = tf.randomNormal([3, 3]);

const sum = tensorA.add(tensorB);
const product = tensorA.mul(tensorB);

sum.print();
product.print();

Exercici 2: Creació i entrenament d'un model simple

  1. Crea un model seqüencial amb una capa d'entrada de 32 unitats i una capa de sortida de 10 unitats amb activació softmax.
  2. Compila el model amb l'optimitzador 'sgd' i la pèrdua 'categoricalCrossentropy'.
  3. Entrena el model amb dades aleatòries.

Solució

const model = tf.sequential();

model.add(tf.layers.dense({units: 32, inputShape: [784]}));
model.add(tf.layers.dense({units: 10, activation: 'softmax'}));

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

const xs = tf.randomNormal([100, 784]);
const ys = tf.randomUniform([100, 10]);

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

Conclusió

En aquesta secció, hem explorat TensorFlow.js, una poderosa biblioteca que permet portar l'aprenentatge automàtic al navegador i a Node.js. Hem après a crear tensors, realitzar operacions amb ells, construir models de xarxes neuronals i entrenar-los. A més, hem vist un exemple pràctic de classificació de dígits utilitzant el dataset MNIST. Amb aquests coneixements, estàs preparat per començar a desenvolupar aplicacions d'aprenentatge automàtic en JavaScript.

◄ Anterior
◄
Següent ►
►
El Projecte | Sobre nosaltres | Contribuir | Donacions | Llicència
© Copyright 2024. Tots els drets reservats