Función Tensorflow.js tf.conv2d()

Tensorflow.js es una biblioteca de JavaScript desarrollada por Google para ejecutar y entrenar modelos de aprendizaje automático en el navegador o en Node.js. 

La función tf.conv2d() se usa para calcular convoluciones 2d sobre la entrada dada. En una red neuronal profunda, usamos esta capa de convolución que crea un núcleo de convolución que, cuando se aplica a las capas de entrada, produce un tensor de salidas. 

Sintaxis:

tf.conv2d (x, filter, strides, pad, dataFormat?, 
        dilations?, dimRoundingMode?) 

Parámetros:

• x: Se da un tensor de rango 3 y rango 4 con forma [batch, height, width, inChannels]. Puede ser un tensor 3D, un tensor 4D o una array tipada.
• filtro: el filtro es de rango 4 con parámetros de forma [filterHeight, filterWidth, inDepth, outDepth] se pasa. Debe ser un tensor 4D, una array anidada o una array tipada.
• zancadas ([número, número]|número) : zancadas de la circunvolución : [strideHeight, strideWidth].
• pad: El tipo de algoritmo de relleno.
  • Igual: Independientemente del tamaño del filtro, la salida será del mismo tamaño que la entrada.
  • válido: la salida será más pequeña que la entrada si el filtro es mayor que 1×1.
  • También puede ser un número o conv_util.ExplicitPadding.
• dataFormat: de dos strings puede ser: «NHWC», «NCHW». Con el formato predeterminado “NHWC”, los datos se almacenan en el orden de: [lote, altura, ancho, canales]. Es necesario especificar el formato de los datos de entrada y salida. Esto es opcional.
• dilataciones: la tasa de dilatación son dos tuplas de números enteros que verifican la tasa de la convolución. [dilationHeight, dilatationWidth] se pasa como parámetros. Esto es opcional.
• dimRoundingMode: el formato de string será ‘techo’, ‘redondo’ o ‘piso’. Esto es opcional.

Ejemplo 1: aquí tomamos una entrada de tensor de 4 dimensiones y otro kernel 4d y luego aplicamos convolución que da como resultado el tensor de salida. Las formas también se imprimen junto con el tensor de salida.

// Importing the tensorflow.js library
import * as tf from "@tensorflow/tfjs"
  
// Input tensor
const x = tf.tensor4d([[
  [[2], [1], [2], [0], [1]],
  [[1], [3], [2], [2], [3]],
  [[1], [1], [3], [3], [0]],
  [[2], [2], [0], [1], [1]],
  [[0], [0], [3], [1], [2]], ]]);
console.log('Shape of the input:',x.shape);
  
// Kernel has been set
const kernel = tf.tensor4d([
     [ [[2, 0.1]], [[3, 0.2]] ],
     [ [[0, 0.3]], [[1, 0.4]] ],
]);
  
console.log('Shape of the kernel:',kernel.shape);
  
// Output tensor after convolution
let out = tf.conv2d(x, kernel, 
    strides = [1, 1, 1, 1], 'same');
  
out.print();
console.log('Shape of the output:',out.shape)

Producción:

Shape of the input: 1,5,5,1
Shape of the kernel: 2,2,1,2
Tensor
    [[[[10, 1.9000001],
       [10, 2.2      ],
       [6 , 1.6      ],
       [6 , 2        ],
       [2 , 1        ]],

      [[12, 1.4      ],
       [15, 2.2      ],
       [13, 2.7      ],
       [13, 1.7      ],
       [6 , 0.3      ]],

      [[7 , 1.7      ],
       [11, 1.3      ],
       [16, 1.3000001],
       [7 , 1        ],
       [0 , 0.3      ]],

      [[10, 0.6      ],
       [7 , 1.4      ],
       [4 , 1.5      ],
       [7 , 1.4000001],
       [2 , 0.7      ]],

      [[0 , 0        ],
       [9 , 0.6      ],
       [9 , 0.5      ],
       [8 , 0.5      ],
       [4 , 0.2      ]]]]
Shape of the output: 1,5,5,2

Ejemplo 2: Las convoluciones juegan un papel importante en el diseño de la arquitectura del modelo de aprendizaje profundo. En este ejemplo, creamos una función y dentro definimos un modelo secuencial. Después de esto, agregamos capas de modelo usando tf.layers.conv2d() con forma de entrada, filtro, kernel, relleno como sus parámetros. Luego, después de maxpooling, flattening y compilación posteriores, devolvemos el modelo.

// Define the model architecture
function buildModel() {
    const model = tf.sequential();
  
    // Add the model layers starting
    // with convolution layers
    model.add(tf.layers.conv2d({
        inputShape: [28, 28, 1],
        filters: 8,
        kernelSize: 5,
        padding: 'same',
        activation: 'relu'
    }));
  
    model.add(tf.layers.maxPooling2d({
        poolSize: 2,
        strides: 2
    }));
  
    // Again we set  another convolution layer
    model.add(tf.layers.conv2d({
        filters: 16,
        kernelSize: 5,
        padding: 'same',
        activation: 'relu'
    }));
      
    model.add(tf.layers.maxPooling2d({
        poolSize: 3,
        strides: 3
    }));
  
    const numofClasses = 10;
    model.add(tf.layers.flatten());
    model.add(tf.layers.dense({
        units: numofClasses,
        activation: 'softmax'
    }));
  
    // Compile the model
    model.compile({
        optimizer: 'adam',
        loss: 'categoricalCrossentropy',
        metrics: ['accuracy']
    });
  
    return model;
}
const jsmodel = buildModel()
jsmodel.summary()

Producción:

_________________________________________________________________
Layer (type)                 Output shape              Param #   
=================================================================
conv2d_Conv2D1 (Conv2D)      [null,28,28,8]            208       
_________________________________________________________________
max_pooling2d_MaxPooling2D1  [null,14,14,8]            0         
_________________________________________________________________
conv2d_Conv2D2 (Conv2D)      [null,14,14,16]           3216      
_________________________________________________________________
max_pooling2d_MaxPooling2D2  [null,4,4,16]             0         
_________________________________________________________________
flatten_Flatten1 (Flatten)   [null,256]                0         
_________________________________________________________________
dense_Dense1 (Dense)         [null,10]                 2570      
=================================================================
Total params: 5994
Trainable params: 5994
Non-trainable params: 0
_________________________________________________________________

Referencia: https://js.tensorflow.org/api/3.6.0/#layers.conv2d