Keras自定义损失函数在语义分割过程中忽略特定类的错误否定？

def weighted_categorical_crossentropy_ignore(weights): weights = K.variable(weights) def loss(y_true, y_pred): y_pred[tf.where(y_true == [1, 0, 0, 0, 0, 0])] = [1, 0, 0, 0, 0, 0] # Scale predictions so that the class probs of each sample sum to 1 y_pred /= K.sum(y_pred, axis=-1, keepdims=True) # Clip to prevent NaN's and Inf's y_pred = K.clip(y_pred, K.epsilon(), 1 - K.epsilon()) loss = y_true * K.log(y_pred) * weights loss = -K.sum(loss, -1) return loss return loss

import numpy as np from tensorflow.keras.utils import to_categorical # Generate the "images" at random true_flat = np.argmax(np.random.rand(1, 2, 2, 4), axis=3).astype('int') true = to_categorical(true_flat, num_classes=4).astype('int') pred_flat = np.argmax(np.random.rand(1, 2, 2, 4), axis=3).astype('int') pred = to_categorical(pred_flat, num_classes=4).astype('int') print('True:\n', true_flat) print('Pred:\n', pred_flat) # Create a mask representing an all "class 0" image class_zero_label = np.array([1, 0, 0, 0]) czl_all = class_zero_label * np.ones(true.shape).astype('int') # Mask both the truth and pred to locate class 0 pixels czl_true_locs = czl_all * true czl_pred_locs = czl_all * pred # Subtract to create "addition" matrix a = (czl_true_locs - czl_pred_locs) * czl_true_locs print('a:\n', a) # Do this m = ((a + 1) - (a * 2)) print('m - ', m.shape, ':\n', m) # Pull the front entry from 'm' and "expand" its value #x = (m[:, :, :, 0].flatten() * np.ones(pred.shape).astype('int')).T.reshape(pred.shape) m_front = m[:, :, :, 0] print('m_front - ', m_front.shape, ':\n', m_front) #m_flat = m_front.flatten() m_flat = m_front.reshape(m_front.shape[0], m_front.shape[1]*m_front.shape[2]) print('m_flat - ', m_flat.shape, ':\n', m_flat) m_expand = m_flat * np.ones(pred.shape).astype('int') print('m_expand - ', m_expand.shape, ':\n', m_expand) m_trans = m_expand.T m_fixT = m_trans.reshape(pred.shape) print('m_fixT - ', m_fixT.shape, ':\n', m_fixT) m = m_fixT print('m:\n', m.shape) # Perform the math as described pred = (pred * m) + a print('Pred:\n', np.argmax(pred, axis=3))

def weighted_categorical_crossentropy_ignore(weights): weights = K.variable(weights) def loss(y_true, y_pred): y_true_un = tf.unstack(y_true) y_pred_un = tf.unstack(y_pred) y_pred_new = [] for i in range(0, y_true.shape[0]): yt = y_true_un[i] yp = y_pred_un[i] # Pred: # [[[0 3] * [[[1 0] + [[[0 1] = [[[0 0] # [3 1]]] [[1 1]]] [[0 0]]] [[3 1]]] # If we multiple pred by a tensor which zeros out only incorrect class 0 labelleling # Then add class zero to those zero'd out locations # We can negate the effect of mis-classified class 0 pixels but still punish for # incorrectly predicted class 0 labels for other classes. # Create a mask respresenting an all "class 0" image class_zero_label = K.variable([1.0, 0.0, 0.0, 0.0, 0.0, 0.0]) czl_all = class_zero_label * K.ones(yt.shape) # Mask both true and pred to locate class 0 pixels czl_true = czl_all * yt czl_pred = czl_all * yp # Subtract to create "addition matrix" a = czl_true - czl_pred # Do this. m = ((a + 1) - (a * 2.)) # And this. x = K.flatten(m[:, :, 0]) x = x * K.ones(yp.shape) x = K.transpose(x) x = K.reshape(x, yp.shape) # Voila. ypnew = (yp * x) + a y_pred_new.append(ypnew) y_pred_new = tf.concat(y_pred_new, 0) # Continue calculating weighted categorical crossentropy # ------------------------------------------------------- # Scale predictions so that the class probs of each sample sum to 1 y_pred_new /= K.sum(y_pred_new, axis=-1, keepdims=True) # Clip to prevent NaN's and Inf's y_pred_new = K.clip(y_pred_new, K.epsilon(), 1 - K.epsilon()) loss = y_true * K.log(y_pred_new) * weights loss = -K.sum(loss, -1) return loss return loss

def weighted_categorical_crossentropy_ignore(weights): weights = K.variable(weights) def loss(y_true, y_pred): yp = y_pred.numpy() yt = y_true.numpy() yp[np.nonzero(np.all(yt == [1, 0, 0, 0, 0, 0], axis=3))] = [1, 0, 0, 0, 0, 0] # Continue calculating weighted categorical crossentropy # ------------------------------------------------------- # Scale predictions so that the class probs of each sample sum to 1 yp /= K.sum(yp, axis=-1, keepdims=True) # Clip to prevent NaN's and Inf's yp = K.clip(yp, K.epsilon(), 1 - K.epsilon()) loss = y_true * K.log(yp) * weights loss = -K.sum(loss, -1) return loss return loss

def weighted_categorical_crossentropy_ignore(weights): weights = K.variable(weights) def loss(y_true, y_pred): # yp = y_pred.numpy().copy() # yt = y_true.numpy().copy() # yp[np.nonzero(np.all(yt == [1, 0, 0, 0, 0, 0], axis=3))] = [1, 0, 0, 0, 0, 0] yp = K.variable(y_pred) yt = K.variable(y_true) #np.all x = K.all(yt == [1, 0, 0, 0, 0, 0], axis=3) #np.nonzero ne = tf.not_equal(x, tf.constant(False)) y = tf.where(ne) # Perform the desired operation yp[y] = [1, 0, 0, 0, 0, 0] # Continue calculating weighted categorical crossentropy # ------------------------------------------------------- # Scale predictions so that the class probs of each sample sum to 1 #yp /= K.sum(yp, axis=-1, keepdims=True) # Cannot use \= on tf.var, must use var = var / yp = yp / K.sum(yp, axis=-1, keepdims=True) # Clip to prevent NaN's and Inf's yp = K.clip(yp, K.epsilon(), 1 - K.epsilon()) loss = y_true * K.log(yp) * weights loss = -K.sum(loss, -1) return loss return loss

def weighted_categorical_crossentropy_ignore(weights): weights = K.variable(weights) def loss(y_true, y_pred): print('y_true.shape: ', y_true.shape) print('y_pred.shape: ', y_pred.shape) # Generate modified y_pred where all truly class0 pixels are correct y_true_class0_indicies = tf.where(tf.math.equal(y_true, [1., 0., 0., 0., 0., 0.])) y_pred_updates = tf.repeat([ [1.0, 0.0, 0.0, 0.0, 0.0, 0.0]], repeats=y_true_class0_indicies.shape[0], axis=0) yp = tf.tensor_scatter_nd_update(y_pred, y_true_class0_indicies, y_pred_updates) # Continue calculating weighted categorical crossentropy # ------------------------------------------------------- # Scale predictions so that the class probs of each sample sum to 1 yp /= K.sum(yp, axis=-1, keepdims=True) # Clip to prevent NaN's and Inf's yp = K.clip(yp, K.epsilon(), 1 - K.epsilon()) loss = y_true * K.log(yp) * weights loss = -K.sum(loss, -1) return loss return loss

conv2d_18 (Conv2D) (None, 128, 128, 6) 1542 dropout_5[0][0] __________________________________________________________________________________________________ activation_9 (Activation) (None, 128, 128, 6) 0 conv2d_18[0][0] ================================================================================================== Total params: 535,551,494 Trainable params: 535,529,478 Non-trainable params: 22,016 __________________________________________________________________________________________________

1条回答

网友
1楼 · 发布于 2024-10-02 00:38:30

如果我正确理解了您的问题，您正在寻找以下内容：
import tensorflow as tf # batch of true labels y_true = tf.constant([5, 0, 1, 3, 4, 0, 2, 0], dtype=tf.int64) # batch of class probabilities y_pred = tf.constant( [ [0.34670502, 0.04551039, 0.14020428, 0.14341979, 0.21430719, 0.10985339], [0.25681055, 0.14013883, 0.19890164, 0.11124421, 0.14526634, 0.14763844], [0.09199252, 0.21889475, 0.1170236 , 0.1929019 , 0.20311192, 0.17607528], [0.3246354 , 0.23257554, 0.15549366, 0.17282239, 0.00000001, 0.11447308], [0.16502093, 0.13163856, 0.14371352, 0.19880624, 0.23360236, 0.12721846], [0.27362782, 0.21408406, 0.10917682, 0.13135742, 0.10814326, 0.16361059], [0.20697299, 0.23721898, 0.06455399, 0.11071447, 0.18990229, 0.19063729], [0.10320242, 0.22173141, 0.2547973 , 0.2314068 , 0.07063974, 0.11822232] ], dtype=tf.float32) # find the indices in the batch where the true label is the class 0 indices = tf.where(tf.math.equal(y_true, 0)) # create a tensor with the number of updates you want to replace in `y_pred` updates = tf.repeat( [[1.0, 0.0, 0.0, 0.0, 0.0, 0.0]], repeats=indices.shape[0], axis=0) # insert the updates into `y_pred` at the specified indices modified_y_pred = tf.tensor_scatter_nd_update(y_pred, indices, updates) print(modified_y_pred) # tf.Tensor( # [[0.34670502, 0.04551039, 0.14020428, 0.14341979, 0.21430719, 0.10985339], # [1.00000000, 0.00000000, 0.00000000, 0.00000000, 0.00000000, 0.00000000], # [0.09199252, 0.21889475, 0.1170236 , 0.1929019 , 0.20311192, 0.17607528], # [0.3246354 , 0.23257554, 0.15549366, 0.17282239, 0.00000001, 0.11447308], # [0.16502093, 0.13163856, 0.14371352, 0.19880624, 0.23360236, 0.12721846], # [1.00000000, 0.00000000, 0.00000000, 0.00000000, 0.00000000, 0.00000000], # [0.20697299, 0.23721898, 0.06455399, 0.11071447, 0.18990229, 0.19063729], # [1.00000000, 0.00000000, 0.00000000, 0.00000000, 0.00000000, 0.00000000]], # shape=(8, 6), dtype=tf.float32)
这个最后的张量modified_y_pred可以用于微分
编辑：
使用面具可能更容易做到这一点
例如：
# these arent normalized to 1 but you get the point probs = tf.random.normal([2, 4, 4, 6]) # raw labels per pixel labels = tf.random.uniform( shape=[2, 4, 4], minval=0, maxval=6, dtype=tf.int64) # your labels are already one-hot encoded labels = tf.one_hot(labels, 6) # boolean mask where classes are `0` # converting back to int labels with argmax for purposes of # using `tf.math.equal`. Matching on `[1, 0, 0, 0, 0, 0]` is # potentially buggy; matching on an integer is a lot more # explicit. mask = tf.math.equal(tf.math.argmax(labels, -1), 0)[..., None] # flip the mask to zero out the pixels across channels where # labels are zero probs *= tf.cast(tf.math.logical_not(mask), tf.float32) # multiply the mask by the one-hot labels, and add back # to the already masked probabilities. probs += labels * tf.cast(mask, tf.float32)

相关问题更多 >

编程相关推荐

热门问题

热门文章