Mam model, który ma zwracać współrzędne, a następnie musi zwracać pewność siebie. Moja strata funkcja musi wziąć pod uwagę współrzędne docelowe i dostępność docelową. Oto, jak wygląda moja funkcja strata:

def loss(targets, target_availabilities, preds, confidences):
    # my loss function goes here
    return loss

Funkcjonalne API Tensorflow pokazuje, jak przekazać 2 różne wyjścia za pomocą oddzielnych funkcji strat (lub tej samej funkcji straty, które zwracają 2 wartości straty, jeden dla każdej pary y_true i y_pred). Jak powinienem skompilować i dopasować mój model, aby uwzględnić cele, cel_aweństwa, prognozowania i powiadomienia poprzez tę funkcję pojedynczej straty?

0
FATEH ALIYEV 15 październik 2020, 16:53

1 odpowiedź

Najlepsza odpowiedź

Polecam korzystanie z niestandardowej pętli szkoleniowej, aby to wdrożyć. Pozwala na większą elastyczność. Dopóki zwracasz jedną wartość, możesz wykonać dowolny rodzaj obliczeń w funkcji straty. Powiedzmy, że chcesz to zrobić:

transformed_output = (y_pred * confidence) - availability

Możesz wdrożyć to w funkcji utraty niestandardowej (zakładając, że architektura netto neuronowa zwraca te trzy wartości):

def compute_loss(model, x, y, training):
  out, avail, conf = model(inputs=x, training=training)
  transformed_output = tf.add(tf.multiply(out, conf), avail)
  loss = loss_object(y_true=y, y_pred=transformed_output)
  return loss

Spowoduje to zwrócenie wartości, a Tensorflow spróbuje zminimalizować tę wartość bez względu na to, co jest.

Oto pełny przykład. Powiedzmy, że jest to "dostępność":

<tf.Tensor: shape=(1, 10), dtype=float32, 
numpy=array([[0., 0., 0., 0., 1., 0., 0., 0., 1., 1.]], dtype=float32)>

A to jest confidences:

<tf.Tensor: shape=(1, 10), dtype=float32, numpy=
array([[0.09586799, 0.03268242, 0.04225421, 0.4026084 , 0.5088273 ,
        0.38777208, 0.53815687, 0.41644037, 0.5709661 , 0.7587745 ]],
      dtype=float32)>

Trenujmy CNN, aby sklasyfikować MNistę zgodnie z tym specjalną funkcją straty.

import tensorflow as tf

(xtrain, ytrain), (xtest, ytest) = tf.keras.datasets.mnist.load_data()

unsqueeze = lambda x, y: (tf.expand_dims(
    tf.divide(
        tf.cast(x, tf.float32), 255), -1),
                          tf.one_hot(y, depth=10))

train = tf.data.Dataset.from_tensor_slices((xtrain, ytrain)).\
    shuffle(64).\
    batch(64).\
    map(unsqueeze).\
    prefetch(1)

test = tf.data.Dataset.from_tensor_slices((xtest, ytest)).\
    shuffle(64).\
    batch(64).\
    map(unsqueeze).\
    prefetch(1)

class CNN(tf.keras.Model):
    def __init__(self):
        super(CNN, self).__init__()
        self.conv1 = tf.keras.layers.Conv2D(filters=16, kernel_size=(3, 3),
                                            strides=(1, 1),
                                            input_shape=(28, 28, 1))
        self.maxp1 = tf.keras.layers.MaxPool2D(pool_size=(2, 2))
        self.conv2 = tf.keras.layers.Conv2D(filters=32, kernel_size=(3, 3),
                                            strides=(1, 1))
        self.maxp2 = tf.keras.layers.MaxPool2D(pool_size=(2, 2))
        self.flat1 = tf.keras.layers.Flatten()
        self.dens1 = tf.keras.layers.Dense(64, activation='relu')
        self.drop1 = tf.keras.layers.Dropout(5e-1)
        self.dens3 = tf.keras.layers.Dense(10)

    def call(self, x, training=None, **kwargs):
        x = self.conv1(x)
        x = self.maxp1(x)
        x = self.conv2(x)
        x = self.maxp2(x)
        x = self.flat1(x)
        x = self.dens1(x)
        x = self.drop1(x)
        x = self.dens3(x)
        availability = tf.cast(tf.random.uniform((len(x), 10), 0, 2,
                                                 dtype=tf.int32), tf.float32)
        confidences = tf.random.uniform((len(x), 10), 0, 1, dtype=tf.float32)
        return x, availability, confidences

model = CNN()

loss_object = tf.losses.CategoricalCrossentropy(from_logits=True)


def compute_loss(model, x, y, training):
  out, avail, conf = model(inputs=x, training=training)
  transformed_output = tf.add(tf.multiply(out, conf), avail)
  loss = loss_object(y_true=y, y_pred=transformed_output)
  return loss


def get_grad(model, x, y):
    with tf.GradientTape() as tape:
        loss = compute_loss(model, x, y, training=False)
    return loss, tape.gradient(loss, model.trainable_variables)


optimizer = tf.optimizers.Adam()

verbose = "Epoch {:2d} Loss: {:.3f} TLoss: {:.3f} Acc: {:.2%} TAcc: {:.2%}"


for epoch in range(1, 10 + 1):
    train_loss = tf.metrics.Mean()
    train_acc = tf.metrics.CategoricalAccuracy()
    test_loss = tf.metrics.Mean()
    test_acc = tf.metrics.CategoricalAccuracy()

    for x, y in train:
        loss_value, grads = get_grad(model, x, y)
        optimizer.apply_gradients(zip(grads, model.trainable_variables))
        train_loss.update_state(loss_value)
        train_acc.update_state(y, model(x, training=True))

    for x, y in test:
        loss_value, _ = get_grad(model, x, y)
        test_loss.update_state(loss_value)
        test_acc.update_state(y, model(x, training=False))


    print(verbose.format(epoch,
                         train_loss.result(),
                         test_loss.result(),
                         train_acc.result(),
                         test_acc.result()))
1
Nicolas Gervais 15 październik 2020, 15:22