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.
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' '
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.
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)
En utilisant à la fois tf 1.x et tf 2.x, j'avais l'impression de comprendre un peu eager_execution.
Recommended Posts