Personnaliser le modèle / la couche / la métrique avec TensorFlow

introduction

Lors de l'implémentation d'un modèle par vous-même dans TensorFlow, il est pratique d'hériter des classes déjà préparées, mais cela a pris du temps à comprendre, alors ne l'oubliez pas.

Environnement confirmé

Personnalisation du modèle

Créé en référence à [Official Tutorial](https://www.tensorflow.org/tutorials/customization/custom_layers?hl=ja#model: combinaison de couches). Après avoir traversé les deux couches convolutives, ajoutez les valeurs d'entrée pour créer un bloc résiduel dont la taille de sortie est la moitié de celle de l'entrée.

from tf.keras.layers import Conv2D, BatchNormalization, Add, Activation

class ResidualBlock(tf.keras.Model):
    
    def __init__(self, filters, kernel_size=2, block_name=''):

        #la magie
        super(ResidualBlock, self).__init__()

        #Ajuster la taille à la sortie pour ajouter des valeurs d'entrée
        self.conv0 = Conv2D(filters, 1, strides=2, padding='same', name=block_name+'_conv0')
        self.bn0 = BatchNormalization(name=block_name+'_bn0')

        #Couche pliante (taille de la première moitié de la couche)
        self.conv1 = Conv2D(filters, kernel_size, strides=2, padding='same', activation='relu', name=block_name+'_conv1')
        self.bn1 = BatchNormalization(name=block_name+'_bn1')
        self.conv2 = Conv2D(filters, kernel_size, padding='same', activation='relu', name=block_name+'_conv2')
        self.bn2 = BatchNormalization(name=block_name+'_bn2')
        
        #Ajouter une entrée et une sortie
        self.add = Add(name=block_name+'_add')
        self.out = Activation('relu', name=block_name+'_out')
        
    def call(self, x):
        
        shortcut = self.conv0(x)
        shortcut = self.bn0(shortcut)
        
        x = self.conv1(x)
        x = self.bn1(x)
        x = self.conv2(x)
        x = self.bn2(x)
       
        x = self.add([shortcut,x])
        x = self.out(x)
        
        return x

Créez les calques nécessaires avec init '' 'et implémentez le flux de calcul avec `` appel' '

Personnalisation des couches

Les modèles personnalisés et les modèles préparés avec tf.keras.applications '' peuvent être combinés à l'aide de tf.keras.models.Sequential '' pour créer de nouveaux modèles. Il y a des moments où vous souhaitez accéder aux couches à l'intérieur du modèle lors de la création d'une carte thermique, mais il semble que vous ne pouvez pas le faire tant que vous la vérifiez vous-même. Par conséquent, créez une couche unique qui renvoie la sortie du modèle telle quelle.

class IdentityLayer(tf.keras.layers.Layer):
    def __init__(self):
        super(IdentityLayer, self).__init__()
    def call(self, x):
        return x

Presque la même chose que la personnalisation d'un modèle.

Personnaliser les métriques

Créé avec référence à API officielle. Créez de vrais positifs pour l'entrée et la sortie catégoriques.

class TP_metric(tf.keras.metrics.Metric):

    def __init__(self, name='TP', **kwargs):
        
        #la magie
        super(TP_metric, self).__init__(name=name, **kwargs)
        #Définition des variables internes
        self.value = self.add_weight(name='tp', initializer='zeros')

    def update_state(self, y_true, y_pred, sample_weight=None):

        # one_Convertir le vecteur chaud en un tableau d'étiquettes
        y_true = tf.argmax(y_true, axis=-1)
        y_true = tf.cast(y_true, K.floatx())
        y_pred = tf.argmax(y_pred, axis=-1)
        y_pred = tf.cast(y_pred, K.floatx())
        
        #Si la valeur vraie et la valeur prédite sont toutes deux 1, TP augmente de 1.
        tmp = tf.equal(tf.add(y_true, y_pred), 2)
        tmp = tf.cast(tmp, K.floatx())

        #Mettre à jour les variables internes
        self.value.assign_add(tf.reduce_sum(tmp))

    def result(self):
        return self.value

C'est assez bruyant (même si c'est Python), alors essayez de lancer fréquemment. Au début, j'ai essayé de le rendre compatible avec Sparse Categorical, mais pour une raison quelconque, la forme de y_true``` était la même que y_pred```. Au lieu de cela, ajustez le jeu de données d'étiquette.

def one_hot(x):
    return tf.one_hot(x,Nombre de catégories)

label_ds = tf.data.Dataset.from_tensor_slices(tf.cast(label_list, tf.int32))
label_ds = label_ds.map(one_hot)

prime

En utilisant à la fois tf 1.x et tf 2.x, j'avais l'impression de comprendre un peu eager_execution.

Recommended Posts

Personnaliser le modèle / la couche / la métrique avec TensorFlow
Essayez TensorFlow RNN avec un modèle de base
Zundokokiyoshi avec TensorFlow
Casser des blocs avec Tensorflow
Chargez le fichier de modèle TensorFlow .pb avec readNetFromTensorflow ().
Lecture de données avec TensorFlow
Prévisions de courses de bateaux avec TensorFlow
Montage du modèle avec lmfit
Régression avec un modèle linéaire
Découvrez Wasserstein GAN avec le modèle Keras et l'optimisation TensorFlow
Essayez la régression avec TensorFlow
Reconnaissance d'image en temps réel sur les appareils mobiles à l'aide du modèle d'apprentissage TensorFlow
Traduire Premiers pas avec TensorFlow
Modèle de prédiction de langage par TensorFlow
Utiliser TensorFlow avec Intellij IDEA
Fonction sinueuse approximative avec TensorFlow
Modèle de transformation de séquence de didacticiel TensorFlow (traduction)
Prévision du cours de l'action avec tensorflow
Calibrer le modèle avec PyCaret
TensorFlow Couche NIN de lasagnes portées
Essayez TensorFlow MNIST avec RNN
Défi la classification des images par TensorFlow2 + Keras 4 ~ Prédisons avec un modèle entraîné ~
Création d'un modèle séquentiel Tensorflow avec une image originale ajoutée à MNIST