def __init__(self,
channels=3,
n_class=2,
cost="cross_entropy",
cost_kwargs={},
**kwargs):
tf.reset_default_graph()
self.n_class = n_class
self.summaries = kwargs.get("summaries", True)
self.x = tf.placeholder("float", shape=[None, None, None, channels])
self.y = tf.placeholder("float", shape=[None, None, None, n_class])
self.keep_prob = tf.placeholder(
tf.float32) #dropout (keep probability)
#import pdb;pdb.set_trace()
logits, self.variables, self.offset = create_conv_net(
self.x, self.keep_prob, channels, n_class, **kwargs)
self.cost = self._get_cost(logits, cost, cost_kwargs)
self.gradients_node = tf.gradients(self.cost, self.variables)
self.cross_entropy = tf.reduce_mean(
cross_entropy(
tf.reshape(self.y, [-1, n_class]),
tf.reshape(pixel_wise_softmax_2(logits), [-1, n_class])))
self.predicter = pixel_wise_softmax_2(logits)
self.correct_pred = tf.equal(tf.argmax(self.predicter, 3),
tf.argmax(self.y, 3))
self.accuracy = tf.reduce_mean(tf.cast(self.correct_pred, tf.float32))
def __init__(self, nx=None, ny=None, channels=3, n_class=2, add_regularizers=True, class_weights=None, **kwargs):
tf.reset_default_graph()
self.n_class = n_class
self.summaries = kwargs.get("summaries", True)
self.x = tf.placeholder("float", shape=[None, nx, ny, channels])
self.y = tf.placeholder("float", shape=[None, None, None, n_class])
self.keep_prob = tf.placeholder(tf.float32) #dropout (keep probability)
logits, self.variables, self.offset = create_conv_net(self.x, self.keep_prob, channels, n_class, **kwargs)
if class_weights is not None:
class_weights = tf.constant(np.array(class_weights, dtype=np.float32))
weighted_logits = tf.mul(tf.reshape(logits, [-1, n_class]), class_weights)
loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(weighted_logits, tf.reshape(self.y, [-1, n_class])))
else:
loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(tf.reshape(logits, [-1, n_class]),
tf.reshape(self.y, [-1, n_class])))
self.gradients_node = tf.gradients(loss, self.variables)
self.cross_entropy = tf.reduce_mean(cross_entropy(tf.reshape(self.y, [-1, n_class]),
tf.reshape(pixel_wise_softmax_2(logits), [-1, n_class]),
))
self.cost = loss
if add_regularizers:
reg_constant = 0.001 # Choose an appropriate one.
regularizers = sum([tf.nn.l2_loss(variable) for variable in self.variables])
self.cost += (reg_constant * regularizers)
self.predicter = pixel_wise_softmax_2(logits)
self.correct_pred = tf.equal(tf.argmax(self.predicter, 3), tf.argmax(self.y, 3))
self.accuracy = tf.reduce_mean(tf.cast(self.correct_pred, tf.float32))
def __init__(self, channels=3, n_class=2, height=None, width=None, cost="cross_entropy", cost_kwargs={}, **kwargs):
tf.reset_default_graph()
self.n_class = n_class
self.summaries = kwargs.get("summaries", True)
self.x = tf.placeholder("float", shape=[None, height, width, channels], name='images')
self.keep_prob = tf.placeholder(tf.float32, shape=(), name='keep_prob') #dropout (keep probability)
logits, self.variables, self.offset = create_conv_net(self.x, self.keep_prob, channels, n_class, nx=height, ny=width, **kwargs)
pred_shape = logits.get_shape().as_list()
self.y = tf.placeholder("float", shape=[None, pred_shape[1], pred_shape[2], n_class], name='labels')
self.cost = self._get_cost(logits, cost, cost_kwargs)
self.gradients_node = tf.gradients(self.cost, self.variables)
self.predicter = pixel_wise_softmax_2(logits)
self.cross_entropy = tf.reduce_mean(cross_entropy(tf.reshape(self.y, [-1, n_class]),
tf.reshape(pixel_wise_softmax_2(logits), [-1, n_class])))
self.correct_pred = tf.equal(tf.argmax(self.predicter, 3), tf.argmax(self.y, 3))
self.accuracy = tf.reduce_mean(tf.cast(self.correct_pred, tf.float32))
def __init__(self,
channels=3,
n_class=2,
cost="cross_entropy",
cost_kwargs={},
**kwargs):
tf.reset_default_graph()
self.n_class = n_class
self.summaries = kwargs.get("summaries", True)
self.x = tf.placeholder("float", shape=[None, None, None, channels])
self.y = tf.placeholder("float", shape=[None, None, None, n_class])
self.keep_prob = tf.placeholder(
tf.float32) #dropout (keep probability)
logits, self.variables, self.offset = create_conv_net(
self.x, self.keep_prob, channels, n_class, **kwargs)
self.cost = self._get_cost(logits, cost, cost_kwargs)
self.gradients_node = tf.gradients(self.cost, self.variables)
self.cross_entropy = tf.reduce_mean(
cross_entropy(
tf.reshape(self.y, [-1, n_class]),
tf.reshape(pixel_wise_softmax_2(logits), [-1, n_class])))
self.predicter = pixel_wise_softmax_2(logits)
self.correct_pred = tf.equal(tf.argmax(self.predicter, 3),
tf.argmax(self.y, 3))
self.accuracy = tf.reduce_mean(tf.cast(self.correct_pred, tf.float32))
#showing images in tensorboard
self.sum_img_y = tf.reshape(
self.y[0, :, :, 0],
shape=[1, tf.shape(self.y)[1],
tf.shape(self.y)[2], 1])
self.sum_img_y2 = tf.reshape(
self.y[0, :, :, 1],
shape=[1, tf.shape(self.y)[1],
tf.shape(self.y)[2], 1])
self.sum_img_pred = tf.reshape(
self.predicter[0, :, :, 0],
shape=[1, tf.shape(self.y)[1],
tf.shape(self.y)[2], 1])
self.sum_img_pred2 = tf.reshape(
self.predicter[0, :, :, 1],
shape=[1, tf.shape(self.y)[1],
tf.shape(self.y)[2], 1])
eps = 1e-5
intersection = tf.reduce_sum(self.predicter[:, :, :, 1] *
self.y[:, :, :, 1])
union = eps + tf.reduce_sum(
self.predicter[:, :, :, 1]) + tf.reduce_sum(self.y[:, :, :, 1])
self.dice_score = (2 * intersection / (union))
def __init__(self,
channels=3,
n_class=2,
cost="cross_entropy",
cost_kwargs={},
**kwargs):
tf.reset_default_graph()
self.n_class = n_class
self.summaries = kwargs.get("summaries", True)
with tf.name_scope('inputs'):
self.x = tf.placeholder("float",
shape=[None, None, None, channels],
name='image')
self.y = tf.placeholder("float",
shape=[None, None, None, n_class],
name='label')
tf.summary.histogram('image', self.x)
tf.summary.histogram('label', self.y)
tf.summary.image('image_sum', get_image_summary(self.x))
tf.summary.image('label_sum', get_image_summary(self.y, idx=1))
self.keep_prob = tf.placeholder(
tf.float32, name='drop') #dropout (keep probability)
self.trainphase = tf.placeholder(tf.bool, name='trainphase')
logits, self.variables, self.offset = create_conv_net(
self.x, self.keep_prob, self.trainphase, channels, n_class,
**kwargs)
self.cost = self._get_cost(logits, cost, cost_kwargs)
self.gradients_node = tf.gradients(self.cost, self.variables)
with tf.name_scope('CrossEntropyforScale'):
self.cross_entropy = tf.reduce_mean(
cross_entropy(
tf.reshape(self.y, [-1, n_class]),
tf.reshape(pixel_wise_softmax_2(logits), [-1, n_class])))
with tf.name_scope('Predict'):
self.predicter = pixel_wise_softmax_2(logits)
tf.summary.image('predict1',
get_image_summary(self.predicter, idx=0))
tf.summary.image('predict2',
get_image_summary(self.predicter, idx=1))
with tf.name_scope('Accuracy'):
self.correct_pred = tf.equal(tf.argmax(self.predicter, 3),
tf.argmax(self.y, 3))
self.accuracy = tf.reduce_mean(
tf.cast(self.correct_pred, tf.float32))
def _get_cost(self, logits, cost_name, cost_kwargs):
"""
Constructs the cost function, either cross_entropy, weighted cross_entropy or dice_coefficient.
Optional arguments are:
class_weights: weights for the different classes in case of multi-class imbalance
regularizer: power of the L2 regularizers added to the loss function
"""
flat_logits = tf.reshape(logits, [-1, self.n_class])
flat_labels = tf.reshape(self.y, [-1, self.n_class])
if cost_name == "cross_entropy":
class_weights = cost_kwargs.pop("class_weights", None)
if class_weights is not None:
class_weights = tf.constant(np.array(class_weights, dtype=np.float32))
weight_map = tf.mul(flat_labels, class_weights)
weight_map = tf.reduce_sum(weight_map, axis=1)
loss_map = tf.nn.softmax_cross_entropy_with_logits(flat_logits, flat_labels)
weighted_loss = tf.mul(loss_map, weight_map)
loss = tf.reduce_mean(weighted_loss)
else:
loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(flat_logits,
flat_labels))
elif cost_name == "dice_coefficient":
predictions = pixel_wise_softmax_2(logits)
flat_predictions = tf.reshape(predos, [-1, self.n_class])
intersection = tf.reduce_sum(tf.mul(flat_predictions, flat_labels))
union = tf.reduce_sum(tf.mul(flat_predictions, flat_predictions)) + tf.reduce_sum(
tf.mul(flat_labels, flat_labels))
loss = 1 - (2 * intersection / union)
def _get_cost(self, logits, cost_name, cost_kwargs):
"""
Constructs the cost function, either cross_entropy, weighted cross_entropy or dice_coefficient.
Optional arguments are:
class_weights: weights for the different classes in case of multi-class imbalance
regularizer: power of the L2 regularizers added to the loss function
"""
flat_logits = tf.reshape(logits, [-1, self.n_class])
flat_labels = tf.reshape(self.y, [-1, self.n_class])
if cost_name == "cross_entropy":
fore_weights = cost_kwargs.pop("fore_weights", None)
back_weights = cost_kwargs.pop("back_weights", None)
if fore_weights is not None:
# By XY
logits_softmax = tf.nn.softmax(flat_logits)
weight_fore = tf.constant(np.array(fore_weights, dtype=np.float32))
weight_back = tf.constant(np.array(back_weights, dtype=np.float32))
weight_map_fore = tf.multiply(flat_labels, weight_fore)
weight_map_back = tf.multiply(flat_labels, weight_back)
# Weighted loss - use this loss at the first-step training
weight_loss = -weight_map_fore[..., 0] * tf.log(logits_softmax[..., 0])
for i_map in range(1, self.n_class):
weight_loss = weight_loss-weight_map_back[..., i_map]*tf.log(logits_softmax[..., i_map])
loss = tf.reduce_mean(weight_loss)
# # Focal loss - use this loss at the second-step training
# focal_map = tf.ones(tf.shape(logits_softmax), tf.float32) - logits_softmax
# focal_map_2 = tf.multiply(focal_map, focal_map)
# focal_loss = -weight_map_fore[..., 0]*focal_map_2[..., 0]*tf.log(logits_softmax[..., 0])# weighted background
# for i_map in range(1, self.n_class):
# focal_loss = focal_loss-weight_map_back[..., i_map]*focal_map_2[..., i_map]*tf.log(logits_softmax[..., i_map])
# loss = tf.reduce_mean(focal_loss)
# By XY
else:
loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=flat_logits,
labels=flat_labels))
elif cost_name == "dice_coefficient":
eps = 1e-5
prediction = pixel_wise_softmax_2(logits)
intersection = tf.reduce_sum(prediction * self.y)
union = eps + tf.reduce_sum(prediction) + tf.reduce_sum(self.y)
loss = -(2 * intersection/ (union))
else:
raise ValueError("Unknown cost function: "%cost_name)
regularizer = cost_kwargs.pop("regularizer", None)
if regularizer is not None:
regularizers = sum([tf.nn.l2_loss(variable) for variable in self.variables])
loss += (regularizer * regularizers)
return loss
def _get_cost(self, logits, cost_name, cost_kwargs):
"""
Constructs the cost function, either cross_entropy, weighted cross_entropy or dice_coefficient.
Optional arguments are:
class_weights: weights for the different classes in case of multi-class imbalance
regularizer: power of the L2 regularizers added to the loss function
"""
flat_logits = tf.reshape(logits, [-1, self.n_class])
flat_labels = tf.reshape(self.y, [-1, self.n_class])
if cost_name == "cross_entropy":
class_weights = cost_kwargs.pop("class_weights", None)
if class_weights is not None:
class_weights = tf.constant(
np.array(class_weights, dtype=np.float32))
weight_map = tf.multiply(flat_labels, class_weights)
weight_map = tf.reduce_sum(weight_map, axis=1)
loss_map = tf.nn.softmax_cross_entropy_with_logits(
logits=flat_logits, labels=flat_labels)
weighted_loss = tf.multiply(loss_map, weight_map)
#weight each pixel by value specified in weight map (added 1/10/2018)
loss = tf.reduce_mean(
tf.multiply(weighted_loss, tf.reshape(self.w, [-1])))
else:
#weight each pixel by value specified in weight map (added 1/10/2018)
weight_map = tf.reshape(self.w, [-1])
loss_map = tf.nn.softmax_cross_entropy_with_logits(
logits=flat_logits, labels=flat_labels)
weighted_loss = tf.multiply(loss_map, weight_map)
loss = tf.reduce_mean(weighted_loss)
elif cost_name == "dice_coefficient":
eps = 1e-5
prediction = pixel_wise_softmax_2(logits)
intersection = tf.reduce_sum(prediction * self.y)
union = eps + tf.reduce_sum(prediction) + tf.reduce_sum(self.y)
loss = -(2 * intersection / (union))
else:
raise ValueError("Unknown cost function: " % cost_name)
regularizer = cost_kwargs.pop("regularizer", None)
if regularizer is not None:
regularizers = sum(
[tf.nn.l2_loss(variable) for variable in self.variables])
loss += (regularizer * regularizers)
return loss
def _get_cost(self, logits, cost_name, cost_kwargs):
"""
Constructs the cost function, either cross_entropy, weighted cross_entropy,
dice_coefficient, or iou (intersection over union).
Optional arguments are:
class_weights: weights for the different classes in case of multi-class imbalance
regularizer: power of the L2 regularizers added to the loss function
"""
flat_logits = tf.reshape(logits, [-1, self.n_class])
flat_labels = tf.reshape(self.y, [-1, self.n_class])
if cost_name == "cross_entropy":
class_weights = cost_kwargs.pop("class_weights", None)
if class_weights is not None:
class_weights = tf.constant(
np.array(class_weights, dtype=np.float32))
weight_map = tf.multiply(flat_labels, class_weights)
weight_map = tf.reduce_sum(weight_map, axis=1)
loss_map = tf.nn.softmax_cross_entropy_with_logits_v2(
logits=flat_logits, labels=flat_labels)
weighted_loss = tf.multiply(loss_map, weight_map)
loss = tf.reduce_mean(weighted_loss)
else:
loss = tf.reduce_mean(
tf.nn.softmax_cross_entropy_with_logits_v2(
logits=flat_logits, labels=flat_labels))
elif cost_name == "dice_coefficient" or cost_name == "iou":
eps = 1e-5
prediction = pixel_wise_softmax_2(logits)
A_intersect_B = tf.reduce_sum(prediction * self.y, axis=[0, 1, 2])
A_plus_B = tf.reduce_sum(
prediction, axis=[0, 1, 2]) + tf.reduce_sum(self.y,
axis=[0, 1, 2])
if cost_name == "dice_coefficient":
denominator = A_plus_B
else: # intersection over union
A_union_B = A_plus_B - A_intersect_B
denominator = A_union_B
loss = tf.reduce_sum(-(2 * A_intersect_B / (eps + denominator)))
else:
raise ValueError("Unknown cost function: " % cost_name)
regularizer = cost_kwargs.pop("regularizer", None)
if regularizer is not None:
regularizers = sum(
[tf.nn.l2_loss(variable) for variable in self.variables])
loss += (regularizer * regularizers)
return loss
def __init__(self,
channels=3,
n_class=2,
cost="cross_entropy",
cost_kwargs={},
**kwargs):
tf.reset_default_graph()
self.n_class = n_class
self.summaries = kwargs.get("summaries", True)
with tf.name_scope('inputs') as scope:
self.x = tf.placeholder("float",
shape=[None, None, None, channels])
self.y = tf.placeholder("float", shape=[None, None, None, n_class])
self.keep_prob = tf.placeholder(
tf.float32) #dropout (keep probability)
with tf.name_scope('CONVNET') as scope:
logits, self.variables, self.offset = create_conv_net(
self.x, self.keep_prob, channels, n_class, **kwargs)
with tf.name_scope('COST') as scope:
self.cost = self._get_cost(logits, cost, cost_kwargs)
with tf.name_scope('GRADIENT') as scope:
self.gradients_node = tf.gradients(self.cost, self.variables)
with tf.name_scope('CROSSENTROPY') as scope:
self.cross_entropy = tf.reduce_mean(
cross_entropy(
tf.reshape(self.y, [-1, n_class]),
tf.reshape(pixel_wise_softmax_2(logits), [-1, n_class])))
with tf.name_scope('PREDICTER') as scope:
self.predicter = pixel_wise_softmax_2(logits)
self.correct_pred = tf.equal(tf.argmax(self.predicter, 3),
tf.argmax(self.y, 3))
self.accuracy = tf.reduce_mean(
tf.cast(self.correct_pred, tf.float32))
def _get_cost(self, logits, cost_name, cost_kwargs):
flat_logits = tf.reshape(logits, [-1, self.n_class])
flat_labels = tf.reshape(self.y, [-1, self.n_class])
if cost_name == "cross_entropy":
class_weights = cost_kwargs.pop("class_weights", None)
if class_weights is not None:
class_weights = tf.constant(
np.array(class_weights, dtype=np.float32))
weight_map = tf.multiply(flat_labels, class_weights)
weight_map = tf.reduce_sum(weight_map, axis=1)
loss_map = tf.nn.softmax_cross_entropy_with_logits(
flat_logits, flat_labels)
weighted_loss = tf.multiply(loss_map, weight_map)
loss = tf.reduce_mean(weighted_loss)
else:
loss = tf.reduce_mean(
tf.nn.softmax_cross_entropy_with_logits(
logits=flat_logits, labels=flat_labels))
elif cost_name == "dice_coefficient":
eps = 1e-5
prediction = pixel_wise_softmax_2(logits)
intersection = tf.reduce_sum(prediction * self.y)
union = eps + tf.reduce_sum(prediction) + tf.reduce_sum(self.y)
loss = -(2 * intersection / (union))
else:
raise ValueError("Unknown cost function: " % cost_name)
regularizer = cost_kwargs.pop("regularizer", None)
if regularizer is not None:
regularizers = sum(
[tf.nn.l2_loss(variable) for variable in self.variables])
loss += (regularizer * regularizers)
return loss
def _get_cost(self, logits, cost_name, cost_kwargs):
"""
Constructs the cost function, either cross_entropy, weighted cross_entropy or dice_coefficient.
Optional arguments are:
class_weights: weights for the different classes in case of multi-class imbalance
regularizer: power of the L2 regularizers added to the loss function
"""
flat_logits = tf.reshape(logits, [-1, self.n_class])
flat_labels = tf.reshape(self.y, [-1, self.n_class])
if cost_name == "cross_entropy":
class_weights = cost_kwargs.pop("class_weights", None)
if class_weights is not None:
class_weights = tf.constant(
np.array(class_weights, dtype=np.float32))
weight_map = tf.multiply(flat_labels, class_weights)
weight_map = tf.reduce_sum(weight_map, axis=1)
loss_map = tf.nn.softmax_cross_entropy_with_logits(
logits=flat_logits, labels=flat_labels)
weighted_loss = tf.multiply(loss_map, weight_map)
loss = tf.reduce_mean(weighted_loss)
else:
loss = tf.reduce_mean(
tf.nn.softmax_cross_entropy_with_logits(
logits=flat_logits, labels=flat_labels))
# loss_map = tf.nn.softmax_cross_entropy_with_logits(logits=flat_logits,
# labels=flat_labels)
# weight = (1000000.0-tf.reduce_sum(loss_map[..., 1]))/tf.reduce_sum(loss_map[..., 1])
# loss = (tf.reduce_sum(loss_map[..., 0])+tf.reduce_sum(loss_map[..., 1]*weight))/1000000.0
# elif cost_name == "sigmoid_cross_entropy"
elif cost_name == "dice_coefficient":
eps = 1e-5
prediction = pixel_wise_softmax_2(logits)
intersection = tf.reduce_sum(prediction * self.y)
union = eps + tf.reduce_sum(prediction) + tf.reduce_sum(self.y)
loss = -(2 * intersection / (union))
elif cost_name == 'IoU':
eps = 1e-5
logits = pixel_wise_softmax_2(logits)
inter_ground = tf.reduce_sum(logits[..., 0] * self.y[..., 0])
inter_pred = tf.reduce_sum(logits[..., 1] * self.y[..., 1])
ground_loss = -tf.div(
inter_ground,
tf.reduce_sum(logits[..., 0]) + tf.reduce_sum(self.y[..., 0]) -
inter_ground + eps)
pred_loss = -tf.div(
inter_pred,
tf.reduce_sum(logits[..., 1]) + tf.reduce_sum(self.y[..., 1]) -
inter_pred + eps)
loss = 1 + pred_loss
# loss = tf.cond(sum_labels_map > 0, lambda: 1.0 - tf.div(inter,union + eps), lambda: 0.0)
else:
raise ValueError("Unknown cost function: " % cost_name)
regularizer = cost_kwargs.pop("regularizer", None)
if regularizer is not None:
regularizers = sum([
tf.nn.l2_loss(variable)
for variable in self.generator_variables
])
loss += (regularizer * regularizers)
return loss, logits
def __init__(self,
channels=3,
n_class=2,
cost="cross_entropy",
adversarial=True,
border_addition=0,
patch_size=1000,
summaries=True,
cost_kwargs={},
unet_kwargs={},
resnet_kwargs={}):
tf.reset_default_graph()
self.n_class = n_class
self.summaries = summaries
self.x = tf.placeholder("float", shape=[None, None, None, channels])
self.y = tf.placeholder("float", shape=[None, None, None, n_class])
self.keep_prob = tf.placeholder(
tf.float32) #dropout (keep probability)
self.is_training = tf.placeholder(tf.bool)
generator_logits, self.generator_variables, self.offset = create_conv_net(
self.x, self.keep_prob, channels, n_class, unet_kwargs)
self.border_addition = border_addition
if border_addition != 0:
generator_logits = generator_logits[:, border_addition:
-border_addition,
border_addition:
-border_addition, ...]
self.predicter = pixel_wise_softmax_2(generator_logits)
self.bce_loss, self.pred = self._get_cost(generator_logits, cost,
cost_kwargs)
self.cross_entropy = tf.reduce_mean(
cross_entropy(
tf.reshape(self.y, [-1, n_class]),
tf.reshape(pixel_wise_softmax_2(generator_logits),
[-1, n_class])))
self.argmax = tf.argmax(self.predicter, 3)
self.correct_pred = tf.equal(self.argmax, tf.argmax(self.y, 3))
self.accuracy = tf.reduce_mean(tf.cast(self.correct_pred, tf.float32))
self.tp = tf.reduce_sum(
tf.cast(tf.argmax(self.predicter, 3), tf.float32) * self.y[..., 1])
self.fp = tf.reduce_sum(
tf.cast(tf.argmax(self.predicter, 3), tf.float32)) - self.tp
self.fn = tf.reduce_sum(self.y[..., 1]) - self.tp
self.precision = self.tp / (self.tp + self.fp)
self.recall = self.tp / (self.tp + self.fn)
self.f1 = 2 * self.recall * self.precision / (self.recall +
self.precision)
# smooth_labels = smooth(self.y, 2, 0.1)*np.random.normal(0.95, 0.5)
# print(smooth_labels.shape)
# smooth_labels = tf.reshape(self.y[:,:,:,1]*np.random.normal(0.85, 0.15), (1, patch_size, patch_size, 1))
# smooth_labels[...,0] = 1.0 - smooth_labels[...,1]
# smooth_labels = tf.reshape(smooth_labels, (1, patch_size, patch_size, n_class))
# smooth_labels = tf.concat([1.0 -smooth_labels, smooth_labels], axis=3)
#prediction = tf.cast(tf.stack([1 - self.argmax, self.argmax], axis=3), tf.float32)
# image_patches = tf.extract_image_patches(
# image, PATCH_SIZE, PATCH_SIZE, [1, 1, 1, 1], 'VALID')
self.generator_cost = self.bce_loss
def _get_cost(self, logits, cost_name, cost_kwargs):
"""
Constructs the cost function, either cross_entropy, weighted cross_entropy or dice_coefficient.
Optional arguments are:
class_weights: weights for the different classes in case of multi-class imbalance
regularizer: power of the L2 regularizers added to the loss function
"""
class_weights = cost_kwargs.pop("class_weights", None)
flat_logits = tf.reshape(logits, [-1, self.n_class])
flat_labels = tf.reshape(self.y, [-1, self.n_class])
if cost_name == "cross_entropy":
if class_weights is None:
loss = tf.reduce_mean(
tf.nn.softmax_cross_entropy_with_logits(
logits=flat_logits, labels=flat_labels))
else:
class_weights = tf.constant(
np.array(class_weights, dtype=np.float32))
weight_map = tf.multiply(flat_labels, class_weights)
weight_map = tf.reduce_sum(weight_map, axis=1)
loss_map = tf.nn.softmax_cross_entropy_with_logits(
logits=flat_logits, labels=flat_labels)
weighted_loss = tf.multiply(loss_map, weight_map)
loss = tf.reduce_mean(weighted_loss)
elif cost_name == "dice_coefficient":
# eps = 1e-5
eps = tf.constant(value=(2**-14))
prediction = pixel_wise_softmax_2(logits)
# prediction[tf.is_nan(prediction)] = 0
prediction = tf.where(tf.is_nan(prediction),
tf.zeros_like(prediction), prediction)
if class_weights is None:
intersection = tf.reduce_sum(prediction * self.y)
else:
class_weights = tf.constant(
np.array(class_weights, dtype=np.float32))
intersection = tf.reduce_sum(prediction * self.y *
class_weights)
union = eps + tf.reduce_sum(prediction) + tf.reduce_sum(self.y)
loss = -(2 * intersection / union)
loss = tf.where(tf.is_nan(loss), tf.zeros_like(loss),
loss) # Note: loss is only a scalar value
else:
raise ValueError("Unknown cost function: " % cost_name)
# regularizer_l1 = cost_kwargs.pop("regularizer_l1", None)
# if regularizer_l1 is not None:
# regularizers = sum([tf.nn.l1_loss(variable) for variable in self.variables])
# loss += (regularizer_l1 * regularizers)
regularizer_l2 = cost_kwargs.pop("regularizer", None)
if regularizer_l2 is not None:
regularizers = sum(
[tf.nn.l2_loss(variable) for variable in self.variables])
loss += (regularizer_l2 * regularizers)
return loss
