web-dev-qa-db-ja.com

Kerasの複数のクラスで総損失はどのように計算されますか？

次のパラメータを持つネットワークがあるとしましょう：

  1. セマンティックセグメンテーションのための完全畳み込みネットワーク
  2. 損失=加重バイナリクロスエントロピー（ただし、損失関数である可能性はありますが、問題ではありません）
  3. 5つのクラス-入力は画像であり、グラウンドトゥルースはバイナリマスクです
  4. バッチサイズ= 16

これで、損失が次の方法で計算されることがわかりました。バイナリクロスエントロピーは、各クラスに関して画像の各ピクセルに適用されます。したがって、基本的に、各ピクセルには5つの損失値があります

このステップの後に何が起こりますか？

ネットワークをトレーニングすると、エポックの損失値が1つだけ出力されます。単一の値を生成するために発生する必要のある損失の累積には多くのレベルがあり、それがどのように発生するかは、ドキュメント/コードではまったく明確ではありません。

  1. 最初に結合されるもの 1）クラスの損失値（たとえば、5つの値（各クラスに1つ）がピクセルごとに結合されます）、次に画像内のすべてのピクセル、または（2）それぞれの画像内のすべてのピクセル個々のクラスでは、すべてのクラスの損失が組み合わされますか？
  2. これらの異なるピクセルの組み合わせはどの程度正確に発生していますか？どこで合計されていますか/どこで平均されていますか？
  3. ---（Kerasのbinary_crossentropyaxis=-1の平均。それで、これはクラスごとのすべてのピクセルの平均ですか、それともすべてのクラスの平均ですか、それとも両方ですか？

別の言い方をすると：異なるクラスの損失をどのように組み合わせて、画像の単一の損失値を生成しますか？

これはドキュメントではまったく説明されておらず、ネットワークのタイプに関係なく、kerasでマルチクラス予測を行う人々にとって非常に役立ちます。 keras code の開始へのリンクは次のとおりです。ここで最初に損失関数を渡します。

説明に最も近いのは

損失：文字列（目的関数の名前）または目的関数。損失を参照してください。モデルに複数の出力がある場合は、辞書または損失のリストを渡すことにより、出力ごとに異なる損失を使用できます。モデルによって最小化される損失値は、すべての個々の損失の合計になります。

keras から。つまり、これは、画像内の各クラスの損失が単純に合計されることを意味しますか？

誰かが試してみるためのサンプルコードはこちら。 Kaggle から借用し、マルチラベル予測用に変更した基本的な実装を次に示します。

# Build U-Net model
num_classes = 5
IMG_DIM = 256
IMG_CHAN = 3
weights = {0: 1, 1: 1, 2: 1, 3: 1, 4: 1000} #chose an extreme value just to check for any reaction
inputs = Input((IMG_DIM, IMG_DIM, IMG_CHAN))
s = Lambda(lambda x: x / 255) (inputs)

c1 = Conv2D(8, (3, 3), activation='relu', padding='same') (s)
c1 = Conv2D(8, (3, 3), activation='relu', padding='same') (c1)
p1 = MaxPooling2D((2, 2)) (c1)

c2 = Conv2D(16, (3, 3), activation='relu', padding='same') (p1)
c2 = Conv2D(16, (3, 3), activation='relu', padding='same') (c2)
p2 = MaxPooling2D((2, 2)) (c2)

c3 = Conv2D(32, (3, 3), activation='relu', padding='same') (p2)
c3 = Conv2D(32, (3, 3), activation='relu', padding='same') (c3)
p3 = MaxPooling2D((2, 2)) (c3)

c4 = Conv2D(64, (3, 3), activation='relu', padding='same') (p3)
c4 = Conv2D(64, (3, 3), activation='relu', padding='same') (c4)
p4 = MaxPooling2D(pool_size=(2, 2)) (c4)

c5 = Conv2D(128, (3, 3), activation='relu', padding='same') (p4)
c5 = Conv2D(128, (3, 3), activation='relu', padding='same') (c5)

u6 = Conv2DTranspose(64, (2, 2), strides=(2, 2), padding='same') (c5)
u6 = concatenate([u6, c4])
c6 = Conv2D(64, (3, 3), activation='relu', padding='same') (u6)
c6 = Conv2D(64, (3, 3), activation='relu', padding='same') (c6)

u7 = Conv2DTranspose(32, (2, 2), strides=(2, 2), padding='same') (c6)
u7 = concatenate([u7, c3])
c7 = Conv2D(32, (3, 3), activation='relu', padding='same') (u7)
c7 = Conv2D(32, (3, 3), activation='relu', padding='same') (c7)

u8 = Conv2DTranspose(16, (2, 2), strides=(2, 2), padding='same') (c7)
u8 = concatenate([u8, c2])
c8 = Conv2D(16, (3, 3), activation='relu', padding='same') (u8)
c8 = Conv2D(16, (3, 3), activation='relu', padding='same') (c8)

u9 = Conv2DTranspose(8, (2, 2), strides=(2, 2), padding='same') (c8)
u9 = concatenate([u9, c1], axis=3)
c9 = Conv2D(8, (3, 3), activation='relu', padding='same') (u9)
c9 = Conv2D(8, (3, 3), activation='relu', padding='same') (c9)

outputs = Conv2D(num_classes, (1, 1), activation='sigmoid') (c9)

model = Model(inputs=[inputs], outputs=[outputs])
model.compile(optimizer='adam', loss=weighted_loss(weights), metrics=[mean_iou])

def weighted_loss(weightsList):
    def lossFunc(true, pred):

        axis = -1 #if channels last 
        #axis=  1 #if channels first        
        classSelectors = K.argmax(true, axis=axis) 
        classSelectors = [K.equal(tf.cast(i, tf.int64), tf.cast(classSelectors, tf.int64)) for i in range(len(weightsList))]
        classSelectors = [K.cast(x, K.floatx()) for x in classSelectors]
        weights = [sel * w for sel,w in Zip(classSelectors, weightsList)] 

        weightMultiplier = weights[0]
        for i in range(1, len(weights)):
            weightMultiplier = weightMultiplier + weights[i]

        loss = BCE_loss(true, pred) - (1+dice_coef(true, pred))
        loss = loss * weightMultiplier
        return loss
    return lossFunc
model.summary()

実際のBCE-DICE損失関数はここにあります。

質問の動機：上記のコードに基づくと、20エポック後のネットワークの検証損失の合計は約1％です。ただし、最初の4つのクラスのユニオンスコアの平均交差はそれぞれ95％を超えていますが、最後のクラスでは23％です。 5番目のクラスがまったくうまくいっていないことを明確に示しています。ただし、この精度の低下は、損失にはまったく反映されていません。したがって、これは、サンプルの個々の損失が、5番目のクラスで見られる大きな損失を完全に打ち消す方法で組み合わされていることを意味します。そのため、サンプルごとの損失がバッチで組み合わされている場合でも、それは非常に低いです。この情報を調整する方法がわかりません。

pythontensorflowmachine-learningkerasdeep-learning
12
Jonathan

この回答の一部については 関連の回答 ですでに説明しましたが、ソースコードを詳細に調べて、具体的に回答を見つけましょう。

まず、フィードフォワードしましょう（！）: _weighted_loss_、_y_true_、_y_pred_を受け取る_sample_weight_関数への呼び出し がありますおよび入力としてのmask：

_weighted_loss = weighted_losses[i]
# ...
output_loss = weighted_loss(y_true, y_pred, sample_weight, mask)
_

_weighted_loss_は、実際には fitメソッドに渡されるすべての（拡張された）損失関数を含むリスト の要素です。

_weighted_losses = [
    weighted_masked_objective(fn) for fn in loss_functions]
_

私が言及した「拡張された」単語はここで重要です。これは、上記のように、実際の損失関数が _weighted_masked_objective_ という別の関数によってラップされているためです。この関数は次のように定義されています。

_def weighted_masked_objective(fn):
    """Adds support for masking and sample-weighting to an objective function.
    It transforms an objective function `fn(y_true, y_pred)`
    into a sample-weighted, cost-masked objective function
    `fn(y_true, y_pred, weights, mask)`.
    # Arguments
        fn: The objective function to wrap,
            with signature `fn(y_true, y_pred)`.
    # Returns
        A function with signature `fn(y_true, y_pred, weights, mask)`.
    """
    if fn is None:
        return None

    def weighted(y_true, y_pred, weights, mask=None):
        """Wrapper function.
        # Arguments
            y_true: `y_true` argument of `fn`.
            y_pred: `y_pred` argument of `fn`.
            weights: Weights tensor.
            mask: Mask tensor.
        # Returns
            Scalar tensor.
        """
        # score_array has ndim >= 2
        score_array = fn(y_true, y_pred)
        if mask is not None:
            # Cast the mask to floatX to avoid float64 upcasting in Theano
            mask = K.cast(mask, K.floatx())
            # mask should have the same shape as score_array
            score_array *= mask
            #  the loss per batch should be proportional
            #  to the number of unmasked samples.
            score_array /= K.mean(mask)

        # apply sample weighting
        if weights is not None:
            # reduce score_array to same ndim as weight array
            ndim = K.ndim(score_array)
            weight_ndim = K.ndim(weights)
            score_array = K.mean(score_array,
                                 axis=list(range(weight_ndim, ndim)))
            score_array *= weights
            score_array /= K.mean(K.cast(K.not_equal(weights, 0), K.floatx()))
        return K.mean(score_array)
return weighted
_

したがって、ネストされた関数weightedがあり、実際にはscore_array = fn(y_true, y_pred)行に実際の損失関数fnを呼び出します。さて、具体的には、提供されたOPの例の場合、fn（つまり、損失関数）は_binary_crossentropy_です。したがって、Kerasの binary_crossentropy() の定義を確認する必要があります。

_def binary_crossentropy(y_true, y_pred):
    return K.mean(K.binary_crossentropy(y_true, y_pred), axis=-1)
_

次に、バックエンド関数K.binary_crossentropy()を呼び出します。 Tensorflowをバックエンドとして使用する場合、 K.binary_crossentropy() の定義は次のとおりです。

_def binary_crossentropy(target, output, from_logits=False):
    """Binary crossentropy between an output tensor and a target tensor.
    # Arguments
        target: A tensor with the same shape as `output`.
        output: A tensor.
        from_logits: Whether `output` is expected to be a logits tensor.
            By default, we consider that `output`
            encodes a probability distribution.
    # Returns
        A tensor.
    """
    # Note: tf.nn.sigmoid_cross_entropy_with_logits
    # expects logits, Keras expects probabilities.
    if not from_logits:
        # transform back to logits
        _epsilon = _to_tensor(epsilon(), output.dtype.base_dtype)
        output = tf.clip_by_value(output, _epsilon, 1 - _epsilon)
        output = tf.log(output / (1 - output))

    return tf.nn.sigmoid_cross_entropy_with_logits(labels=target,
                                                   logits=output)
_

_tf.nn.sigmoid_cross_entropy_with_logits_ は以下を返します。

logitsと同じ形状のテンソルで、コンポーネントごとのロジスティック損失があります。

さて、逆伝播（！）しましょう：上記の注意を考慮すると、_K.binray_crossentropy_の出力形状は_y_pred_（または_y_true_）と同じになります。 OPが述べたように、_y_true_は_(batch_size, img_dim, img_dim, num_classes)_の形をしています。したがって、K.mean(..., axis=-1)は形状_(batch_size, img_dim, img_dim, num_classes)_のテンソルに適用され、形状_(batch_size, img_dim, img_dim)_の出力テンソルになります。したがって、すべてのクラスの損失値は、画像内のピクセルごとに平均化されます。したがって、上記のweighted関数の_score_array_の形状は_(batch_size, img_dim, img_dim)_になります。もう1つのステップがあります。weighted関数のreturnステートメントは、再び平均を取ります。つまり、return K.mean(score_array)です。では、どのように平均を計算するのでしょうか？ mean バックエンド関数の定義を見ると、axis引数がNoneであることがわかります。デフォルト：

_def mean(x, axis=None, keepdims=False):
    """Mean of a tensor, alongside the specified axis.
    # Arguments
        x: A tensor or variable.
        axis: A list of integer. Axes to compute the mean.
        keepdims: A boolean, whether to keep the dimensions or not.
            If `keepdims` is `False`, the rank of the tensor is reduced
            by 1 for each entry in `axis`. If `keepdims` is `True`,
            the reduced dimensions are retained with length 1.
    # Returns
        A tensor with the mean of elements of `x`.
    """
    if x.dtype.base_dtype == tf.bool:
        x = tf.cast(x, floatx())
return tf.reduce_mean(x, axis, keepdims)
_

そして、 tf.reduce_mean() を呼び出します。これは、_axis=None_引数を指定して、入力テンソルのすべての軸の平均を取り、単一の値を返します。したがって、形状_(batch_size, img_dim, img_dim)_のテンソル全体の平均が計算されます。これは、バッチ内のすべてのラベルとそのすべてのピクセルの平均を取ることを意味し、損失値を表す単一のスカラー値として返されます。 。次に、この損失値はKerasによって報告され、最適化に使用されます。

ボーナス：モデルに複数の出力層があり、したがって複数の損失関数が使用されている場合はどうなりますか？

この回答で言及した最初のコードを覚えておいてください。

_weighted_loss = weighted_losses[i]
# ...
output_loss = weighted_loss(y_true, y_pred, sample_weight, mask)
_

ご覧のとおり、配列のインデックス作成に使用されるi変数があります。あなたは正しく推測したかもしれません：それは実際には指定された損失関数を使用して各出力層の損失値を計算し、次にこれらすべての損失値の（加重）合計を 計算するループの一部です総損失 ：

_# Compute total loss.
total_loss = None
with K.name_scope('loss'):
    for i in range(len(self.outputs)):
        if i in skip_target_indices:
            continue
        y_true = self.targets[i]
        y_pred = self.outputs[i]
        weighted_loss = weighted_losses[i]
        sample_weight = sample_weights[i]
        mask = masks[i]
        loss_weight = loss_weights_list[i]
        with K.name_scope(self.output_names[i] + '_loss'):
            output_loss = weighted_loss(y_true, y_pred,
                                        sample_weight, mask)
        if len(self.outputs) > 1:
            self.metrics_tensors.append(output_loss)
            self.metrics_names.append(self.output_names[i] + '_loss')
        if total_loss is None:
            total_loss = loss_weight * output_loss
        else:
            total_loss += loss_weight * output_loss
    if total_loss is None:
        if not self.losses:
            raise ValueError('The model cannot be compiled '
                                'because it has no loss to optimize.')
        else:
            total_loss = 0.

    # Add regularization penalties
    # and other layer-specific losses.
    for loss_tensor in self.losses:
        total_loss += loss_tensor  
_
2
today
1) What gets combined first - (1) the loss values of the class(for instance 10 values(one for each class) get combined per pixel) and

次に、画像内のすべてのピクセル、または（2）個々のクラスごとの画像内のすべてのピクセル、次にすべてのクラス損失が結合されますか？ 2）これらの異なるピクセルの組み合わせはどの程度正確に発生していますか？どこで合計されていますか/どこで平均されていますか？

（1）に対する私の答え：画像のバッチをトレーニングする場合、ピクセル値で構成される配列は、非線形関数、損失を計算し、最適化（重みを更新）することによってトレーニングされます。 損失はピクセル値ごとに計算されるのではなく、画像ごとに計算されます。

ピクセル値（X_train）、重み、およびバイアス（b）は、予測されたy値を計算するためにシグモイド（非線形性の最も単純な例）で使用されます。これは、y_train（一度に1つのバッチ）とともに損失を計算するために使用されます。損失は、SGD、運動量、アダムなどの最適化方法の1つを使用して最適化され、重みとバイアスが更新されます。

（2）に対する私の答え：非線形操作中に、ピクセル値（X_train）が（ドット積を介して）重みと結合され、バイアスに追加されて、予測されたターゲット値が形成されます。

バッチでは、異なるクラスに属するトレーニング例が存在する場合があります。対応する目標値（各クラス）が対応する予測値と比較され、損失が計算されます。したがって、これらはすべての損失を合計することはまったく問題ありません。

正しいクラスの対応するターゲットと比較する限り、それらが1つのクラスに属しているか複数のクラスに属しているかは実際には問題ではありません。意味がありますか？

0
BlueKryptonite