Tensorflow.js tf.layers.conv1d() Función

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 Tensorflow.js tf.layers.conv1d() se usa para crear una capa de convolución. Se utiliza para aplicar convolución 1d a los datos de entrada. La capa convolucional se usa para hacer un filtro que se usa para filtrar los datos de entrada en la salida deseada.

Sintaxis:

tf.layers.conv1d(args);

Parámetros: Esta función acepta los siguientes parámetros:

• args: este es un tipo de objeto que contiene los siguientes valores:
  • filtros: Es el número que define la dimensión del tensor de salida. Es el número de filtros en la convolución.
  • kernelSize: define la ventana de convolución para las capas de convolución, lo que significa que el subconjunto de datos de entrada se toma a la vez.
  • zancadas: Define la unidad a mover en los datos de entrada por la capa de convolución en cada dimensión.
  • relleno: define el relleno de la capa de convolución, lo que significa que equivale a datos agregados a los datos de entrada durante el procesamiento. Su valor puede ser ‘válido’, ‘mismo’ y ‘causal’.
  • dataFormat: define el formato de datos de los datos de entrada, ya que los datos están en ‘channelsFirst’ o en ‘channelsLast’.
  • dilationRate: Se utiliza para dilatar la convolución en cada dimensión. Se utiliza para definir el espacio entre los valores en kernel.
  • activación: Define la función de activación a utilizar para los datos de entrada.
  • useBias: se utiliza para tomar decisiones sobre el uso o no del vector de sesgo.
  • kernelInitializer: Es el peso inicial para el kernel en la capa de convolución. Define la forma de establecer los pesos aleatorios iniciales de las capas de convolución.
  • biasInitializer: Es el peso inicial para el vector de polarización de la capa de convolución.
  • kernelConstraint: es la restricción para el peso del núcleo de la capa de convolución que se utiliza para aumentar la eficiencia.
  • biasConstraint: Es la restricción para que el vector de polarización de la capa de convolución aumente la eficiencia.
  • kernelRegularizer: Es la función regularizadora que se aplica a la array del peso del kernel para regularizarlo.
  • biasRegularizer: Es la función regularizadora que se aplica al vector bias para regularizarlo.
  • activityRegularizer: es la función que se aplica a la activación con fines de regularización.
  • inputShape: declaró que esta capa acepta la capa de entrada de esta forma. solo se usa para la capa de entrada.
  • batchInputShape: define el tamaño del lote de la capa de entrada. Se utiliza para la capa de entrada.
  • batchSize: se utiliza como complemento de batchInputShape en el proceso de creación de la capa de entrada.
  • dtype: define el tipo de datos para esta capa. ‘float32’ es el valor predeterminado para la capa.
  • entrenable: Se utiliza para hacer capa entrenable de función o no.
  • pesos: Es el valor del peso inicial de esta capa.
  • inputDtype: Se utiliza para decidir el tipo de datos de la capa de entrada.

Devoluciones: Conv1D

Ejemplo 1: en este ejemplo, crearemos un modelo secuencial y le agregaremos la capa de convolución 1d con filter, kernelSize, inputShape y activación. Por fin compilamos nuestro modelo con capas y vemos el resumen del mismo. 

import * as tf from "@tensorflow/tfjs"
 
  // Creating model
  const geek_Model  =  tf.sequential();
 
  // Adding inputLayer layer
  const geek_config = {inputShape: [7,4]};
  const geek_layer1 = tf.layers.inputLayer(geek_config);
  geek_Model.add(geek_layer1);
 
  // Adding convolution layer
  const geek_config2 = {
    filters:10,kernelSize:7                        
   ,inputShape:[28,1],
    activation: 'relu'};
  const geek_layer2 = tf.layers.conv1d(geek_config2);
   //console.log(y.shape);
   geek_Model.add(geek_layer2);
 
  // Adding dense layer
  const geek_config3 = {
    units:7,
    activation: 'softmax'
  };
  const geek_layer3 = tf.layers.dense(geek_config3);
  geek_Model.add(geek_layer3)
 
  // Compiling our model
  const geek_config4 = {
    optimizer: 'sgd',
    loss: 'meanSquaredError'
  };
  geek_Model.compile(geek_config4);
 
  // Printing our summary
  geek_Model.summary()

Producción:

_________________________________________________________________
Layer (type)                 Output shape              Param #   
=================================================================
input1 (InputLayer)          [null,7,4]                0         
_________________________________________________________________
conv1d_Conv1D1 (Conv1D)      [null,1,10]               290       
_________________________________________________________________
dense_Dense1 (Dense)         [null,1,7]                77        
=================================================================
Total params: 367
Trainable params: 367
Non-trainable params: 0
_________________________________________________________________

Ejemplo 2: En este ejemplo, veremos cómo la capa de convolución filtra los datos de entrada según la configuración. Aquí hacemos una capa de convolución con inputShape, filter, kernelSize, activación y compilamos el modelo con ella. Con la capa de convolución filtrada, usamos la función de predicción para los datos de entrada.

import * as tf from "@tensorflow/tfjs"
 
// Input Layer for model
const geek_config = {shape:[3,4]};
const geek_InputL = tf.input(geek_config);
console.log(`Input layer shape : ${geek_InputL.shape}`);
 
// Convolution For the model 
const geek_config2 = {
  filters:2,kernelSize:2                        
 ,inputShape:[3,4],
  activation: 'sigmoid'};
const geek_convLayer = tf.layers.conv1d(geek_config2).apply(geek_InputL);
console.log(`Convolution layer shape : ${geek_convLayer.shape}`);
 
// Adding layer to the model
const geek_config3 = {inputs:geek_InputL, outputs:geek_convLayer};
const model = tf.model(geek_config3);
// Compiling the model
const geek_config4 = {optimizer:'sgd',loss:'meanSquaredError'};
model.compile(geek_config4);
 
// Predicting the value for the input
const geek_Test = tf.randomUniform([3,3,4]);
model.predict(geek_Test).print();

Producción: 

Input layer shape : ,3,4
Convolution layer shape : ,2,2
Tensor
    [[[0.5468831, 0.4990641],
      [0.3059803, 0.4743758]],

     [[0.4450175, 0.4848864],
      [0.3678558, 0.4276305]],

     [[0.4802476, 0.5687023],
      [0.4083693, 0.4854257]]]

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