Description et implémentation de Maxout (Python)

en premier

Cet article décrit ce qui suit et implémente la fonction Maxout dans le code Python.

1. Qu'est-ce que la fonction Maxout?
2. Code de fonction et utilisation de Maxout

Dans cet article, la fonction Maxout est implémentée afin qu'elle puisse être utilisée comme couche de Keras. Le code et la description sont à la fin.

Qu'est-ce que la fonction Maxout?

La fonction Maxout est utilisée comme fonction d'activation de couche dans les modèles Deep Learning tels que CNN et DNN. Le principal avantage de l'utilisation de la fonction Maxout comme fonction d'activation est que vous pouvez passer des données à la couche suivante sans changer la taille des données fournies par la couche précédente.

Pour expliquer cela, en général, les CNN et les DNN utilisent souvent une couche de regroupement pour réduire la taille des données, tandis que la fonction Maxout réduit le nombre de dimensions correspondant au nombre de canaux au lieu de réduire la taille. Je fais. Cela rend inutile l'utilisation de la couche de regroupement et est utilisé lorsque vous souhaitez conserver autant que possible la taille des données de la couche. (En fait, il est utilisé dans la couche CNN et est souvent utilisé en combinaison avec la couche Pooling)

La fonction Maxout peut être exprimée comme suit lorsqu'elle est écrite dans une formule mathématique.

Ce que fait réellement la fonction Maxout est de prendre le Max des pixels situés au même emplacement dans chaque dimension (canal, carte des caractéristiques) et de l'utiliser comme pixel des données de sortie. L'image ci-dessous ressemble à la figure ci-dessous.

Reference https://www.google.com/url?sa=i&url=https%3A%2F%2Flink.springer.com%2Farticle%2F10.1186%2Fs40537-019-0233-0&psig=AOvVaw2-jjWv_TTq3t2bz_Py6_S0&ust=1592137921627000&source=images&cd=vfe&ved=0CA0QjhxqFwoTCOiAvJDm_ukCFQAAAAAdAAAAABAD

Lors de son implémentation en tant que code, il est possible de spécifier le nombre de dimensions après la sortie. Par exemple, laissez le nombre de dimensions de sortie être 2 et le nombre de dimensions d'entrée être N. Dans ce cas, les données d'entrée sont divisées en deux blocs dimensionnels n / 2, et Maxout est effectué pour chacun.

Implémentation en tant que couche Keras

Mettez en œuvre comme suit. Il a été confirmé qu'il fonctionnait à la fois avec Tensorflow 2 et 1.

Maxout.py

import tensorflow as tf
from typeguard import typechecked
import keras

class Maxout(keras.layers.Layer):
    #num_Spécifiez le nombre de dimensions après la sortie avec l'unité
    #Spécifiez l'axe que vous voulez prendre Max avec axe (généralement la valeur par défaut. Pour Canal d'abord, spécifiez 1)
    @typechecked
    def __init__(self, num_units: int, axis: int = -1, **kwargs):
        super().__init__(**kwargs)
        self.num_units = num_units
        self.axis = axis

    def call(self, inputs):
        inputs = tf.convert_to_tensor(inputs)
        shape = inputs.get_shape().as_list()
        # Dealing with batches with arbitrary sizes
        for i in range(len(shape)):
            if shape[i] is None:
                shape[i] = tf.shape(inputs)[i]

        num_channels = shape[self.axis]
        if not isinstance(num_channels, tf.Tensor) and num_channels % self.num_units:
            raise ValueError(
                "number of features({}) is not "
                "a multiple of num_units({})".format(num_channels, self.num_units)
            )

        if self.axis < 0:
            axis = self.axis + len(shape)
        else:
            axis = self.axis
        assert axis >= 0, "Find invalid axis: {}".format(self.axis)

        expand_shape = shape[:]
        expand_shape[axis] = self.num_units
        k = num_channels // self.num_units
        expand_shape.insert(axis, k)

        outputs = tf.math.reduce_max(
            tf.reshape(inputs, expand_shape), axis, keepdims=False
        )
        return outputs

    def compute_output_shape(self, input_shape):
        input_shape = tf.TensorShape(input_shape).as_list()
        input_shape[self.axis] = self.num_units
        return tf.TensorShape(input_shape)

    def get_config(self):
        config = {"num_units": self.num_units, "axis": self.axis}
        base_config = super().get_config()
        return {**base_config, **config}

Un exemple d'utilisation est présenté ci-dessous. Si vous l'appelez ainsi, cela fonctionnera.

example.py

from Maxout import Maxout

conv2d = Conv2D(64, kernel_size, strides, padding)(input)
maxout = Maxout(n_units)(conv2d)

en conclusion

Cette fois, j'ai expliqué la fonction Maxout. Maxout est souvent utilisé comme fonction d'activation pour LCNN, etc. dans des études récentes. J'espère que vous avez trouvé cet article utile.

Reference Maxout Networks (https://arxiv.org/pdf/1302.4389.pdf) A Light CNN for Deep Face Representation with Noisy Labels (https://arxiv.org/pdf/1511.02683.pdf)