Python Tensorflow – Función tf.keras.layers.Conv3D()

En este artículo, cubriremos la función Tensorflow tf.keras.layers.Conv3D().

TensorFlow es una biblioteca de aprendizaje automático gratuita y de código abierto. TensorFlow fue creado por los investigadores e ingenieros de Google Brain Team como parte del grupo de investigación de inteligencia artificial de Google con el objetivo de realizar investigaciones de aprendizaje automático y redes neuronales profundas, aunque la tecnología es lo suficientemente amplia como para usarse en varias disciplinas diferentes.

Diferencia entre Conv2D y Conv3D

Comencemos examinando primero qué es exactamente la convolución. En el procesamiento de imágenes, la convolución es la técnica de alterar una imagen aplicando un kernel a cada píxel y sus vecinos locales en toda la imagen. El núcleo es una array de valores cuyo tamaño y valores afectan el impacto de transformación del proceso de convolución. El tamaño de salida dependerá de lo siguiente: una cantidad de filtros, la extensión espacial del filtro, la zancada y la cantidad de relleno cero.

El filtro conv se arrastra horizontal y verticalmente (en x e y) sobre una imagen, lo que da como resultado un Conv2D , independientemente de si la imagen está en escala de grises (1 canal), color (3 canales) o cualquier otra cosa. La única diferencia es que el filtro Conv2D ahora requiere un número igual de canales en la tercera dimensión, mientras que la profundidad es la tercera dimensión en un proceso de convolución 3D , y el filtro de convolución también se mueve a lo largo de esa dimensión, por lo tanto, un filtro 2x2x2 se mueve en x, y y z a través del volumen. En ese escenario, la entrada tiene más de tres dimensiones.

La función tf.keras.layers.Conv3D() se usa para aplicar la operación de convolución 3D en los datos. Esta capa genera un tensor de salidas convolucionando la entrada de la capa con un núcleo de convolución.

Sintaxis: tf.keras.layers.Conv3D( 

filtros, kernel_size, strides=(1, 1, 1), padding=’valid’, data_format=Ninguno,

dilation_rate=(1, 1, 1), grupos=1, activación=Ninguno, use_bias=Verdadero,

kernel_initializer=’glorot_uniform’, bias_initializer=’ceros’, kernel_regularizer=Ninguno,

bias_regularizer=Ninguno, activity_regularizer=Ninguno, kernel_constraint=Ninguno,

bias_constraint=Ninguno, **kwargs)

Forma de entrada: un tensor de forma 5+D: batch_shape + (channels, conv_dim1, conv_dim2, conv_dim3)

Forma de salida: un tensor de forma 5+D: forma_lote + (filtros, nueva_conv_dim1, nueva_conv_dim2, nueva_conv_dim3)

Parámetros:

• filtros (Entero): La dimensionalidad del espacio de salida (es decir, el número de filtros de salida en la convolución).
• kernel_size (Integer | [Integer,Integer,Integer]): la profundidad, la altura y el ancho de la ventana de convolución 3D. 
• zancadas (Entero | [Entero,Entero,Entero]): Las zancadas convolucionales en cada dimensión.
• data_format: El formato de datos. Esto especifica el orden en el que se ordenan las dimensiones en las entradas. channel_last es el valor predeterminado.
• dilation_rate: en cada dimensión, la tasa de dilatación que se utilizará para la convolución dilatada. Debe ser un entero o una lista/tupla de tres enteros.
• grupos (entero): un número entero positivo que indica en cuántos grupos se divide la entrada a lo largo del eje del canal.
• activación: La función de activación de la capa.
• use_bias (booleano): si la capa tiene un vector de sesgo o no. Verdadero es el valor predeterminado.
• kernel_initializer: El inicializador de la array de pesos del kernel convolucional.
• bias_initializer: el inicializador del vector de polarización.
• kernel_regularizer: la función de regularización aplicada a la array de pesos del kernel.
• bias_regularizer: la función de regularizador aplicada al vector de sesgo.
• activity_regularizer: La función de regularizador aplicada a la activación.
• kernel_constraint: La restricción para los pesos del kernel convolucional.
• bias_constraint: La restricción para el vector de sesgo.

Devuelve: un tensor 5+D que representa la activación (conv3d (entradas, núcleo) + sesgo).

Ejemplo 1:

En este ejemplo, cuando use esta capa como la primera capa en un modelo, proporcione el argumento de palabra clave tensor_shape de números enteros, por ejemplo, tensor_shape=(4, 28, 28, 28, 1) para volúmenes de 28x28x28 con un solo canal, en data_format=” canales_último”. En Cov3D, pasó filter =8 , que es responsable de la dimensionalidad del espacio, mientras que kernel_size es responsable de la profundidad, la altura y el ancho de la ventana de convolución 3D. Después de eso, definimos devolver un modelo entrenado y predecir la etiqueta de un nuevo conjunto de datos. Este método acepta un argumento (p. ej., model. predict(X) ) y devuelve la etiqueta aprendida para cada objeto de la array.

import tensorflow as tf
  
tensor_shape = (4, 28, 28, 28, 1)
input_shape = tensor_shape[1:]
X = tf.random.normal(tensor_shape)
  
  
def model(input_shape):
    X_input = tf.keras.layers.Input(shape=input_shape)
    X_output = tf.keras.layers.Conv3D(
        filters=8, kernel_size=4, strides=2)(X_input)
    model = tf.keras.models.Model(inputs=X_input, outputs=X_output)
    return model
  
  
model = model(input_shape)
  
Y = model.predict(X, steps=4)
print(Y.shape)

Producción:

(4, 13, 13, 13, 8)

Ejemplo 2:

En este ejemplo, cuando use esta capa como la primera capa en un modelo, proporcione el argumento de palabra clave tensor_shape de números enteros, por ejemplo, tensor_shape=(1, 4, 4, 4, 1) para volúmenes 4x4x4 con un solo canal, en data_format=” canales_último”. En Cov3D, pasó filter =3 , que es responsable de la dimensionalidad del espacio, mientras que kernel_size es responsable de la profundidad, la altura y el ancho de la ventana de convolución 3D. Después de eso, definimos devolver un modelo entrenado y predecir la etiqueta de un nuevo conjunto de datos. Este método acepta un argumento (p. ej., model. predict(X) ) y devuelve la etiqueta aprendida para cada objeto de la array.

import tensorflow as tf
  
tensor_shape = (1, 4, 4, 4, 1)
input_shape = tensor_shape[1:]
X = tf.random.normal(tensor_shape)
  
  
def model(input_shape):
    X_input = tf.keras.layers.Input(shape=input_shape)
    X_output = tf.keras.layers.Conv3D(
        filters=3, kernel_size=3, strides=1)(X_input)
    model = tf.keras.models.Model(inputs=X_input, outputs=X_output)
    return model
  
  
model = model(input_shape)
  
Y = model.predict(X, steps=1)
print(Y)

Producción:

[[[[[-1.2114613   0.576858    0.29229757]
    [ 0.83879304 -0.20926164  0.8637264 ]]

   [[ 0.03376093  0.1571547   0.13753639]
    [-0.2992745   0.73341274  0.46030152]]]


  [[[ 0.61261517 -0.1008687  -0.64397895]
    [-0.5964341  -0.9971596  -0.18633988]]

   [[ 1.5544158   0.27557844 -1.2441761 ]
    [-0.21357535  0.51095605 -1.8175783 ]]]]]

CNN en conjunto de datos 3D MNIST

Usemos el conocimiento anterior para crear una red neuronal convolucional. Para este propósito, hemos utilizado el conjunto de datos 3D MNIST . 

Paso 1: Comencemos importando todas las bibliotecas deseadas y el conjunto de datos. Después de eso imprimiremos la forma de una de las arrays, notaremos que la información está condensada en este momento.

# Importing libraries
# Importing libraries
import h5py
import numpy as np
import tensorflow as tf
  
with h5py.File("full_dataset_vectors.h5", "r") as hf:
    # Importing MNIST 3D dataset
    X_train = hf["X_train"][:]
    Y_train = hf["y_train"][:]
    X_test = hf["X_test"][:]
    Y_test = hf["y_test"][:]
  
print(X_train.shape)

Producción:

(10000, 4096)

Paso 2: remodelar el conjunto de datos

# Reshaping dataset
X_train = X_train.reshape(X_train.shape[0], 1, 16, 16, 16)
X_test = X_test.reshape(X_test.shape[0], 1, 16, 16, 16)
  
print(X_train.shape)
print(Y_train.shape)
print(X_test.shape)
print(Y_test.shape)

Producción:

(10000, 1, 16, 16, 16)
(10000,)
(2000, 1, 16, 16, 16)
(2000,)

Paso 3: ahora, antes de enviar el conjunto de datos al modelo, realizaremos algunos pasos de preprocesamiento de datos, como la normalización y la codificación one-hot.

def data_preprocessing():
    global X_train, X_test, Y_train, Y_test
    X_train = X_train/255.0
    X_test = X_test/255.0
    Y_train = tf.keras.utils.to_categorical(Y_train)
    Y_test = tf.keras.utils.to_categorical(Y_test)
    num_classes = Y_train.shape[1]
    return num_classes
  
  
num_classes = data_preprocessing()

Paso 4: Ahora, finalmente crearemos el modelo y lo ajustaremos al conjunto de datos de entrenamiento. He usado un modelo muy básico aquí para la demostración que consiste en una capa Conv3D, MaxPool3D seguida de dos capas densas.

def model(input_shape, num_classes):
    X_input = tf.keras.Input(input_shape)
    X = tf.keras.layers.Conv3D(filters=32, kernel_size=(
        2, 2, 2), activation='relu', data_format='channels_first')(X_input)
    X = tf.keras.layers.MaxPool3D(data_format='channels_first')(X)
    X = tf.keras.layers.Dropout(rate=0.25)(X)
    X = tf.keras.layers.Flatten()(X)
    X = tf.keras.layers.Dense(128, activation='softmax')(X)
    X = tf.keras.layers.Dropout(rate=0.5)(X)
    X_output = tf.keras.layers.Dense(num_classes, activation='softmax')(X)
    model = tf.keras.models.Model(inputs=X_input, outputs=X_output)
    return model
  
  
model = model(X_train.shape[1:], num_classes)
model.compile(optimizer=tf.keras.optimizers.Adam(),
              loss='categorical_crossentropy', metrics='accuracy')
  
print(model.summary())

Producción: