def __init__(self, channels, n_class, 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], name="x")
self.y = tf.placeholder("float", shape=[None, None, None, n_class], name="y")
self.keep_prob = tf.placeholder(tf.float32, name="dropout_probability") # dropout (keep probability)
# samarinm adjusted:
logits, self.variables, self.offset, self.convs_RELU = create_conv_net(self.x, self.keep_prob, channels, n_class, **kwargs)
# 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)
with tf.name_scope("cross_entropy"):
self.cross_entropy = cross_entropy(tf.reshape(self.y, [-1, n_class]),
tf.reshape(pixel_wise_softmax(logits), [-1, n_class]))
with tf.name_scope("results"):
self.predicter = pixel_wise_softmax(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):
"""
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
"""
with tf.name_scope("cost"):
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":
eps = 1e-5
prediction = pixel_wise_softmax(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 == "euclidean":
loss = 100.0 * tf.reduce_mean(
tf.square(tf.abs(flat_logits - flat_labels)))
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)
self.x = tf.placeholder("float", shape=[None, None, None, channels], name="x")
self.y = tf.placeholder("float", shape=[None, None, None, n_class], name="y")
self.keep_prob = tf.placeholder(tf.float32, name="dropout_probability") # 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)
with tf.name_scope("cross_entropy"):
self.cross_entropy = cross_entropy(tf.reshape(self.y, [-1, n_class]),
tf.reshape(pixel_wise_softmax(logits), [-1, n_class]))
with tf.name_scope("results"):
self.predicter = pixel_wise_softmax(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):
"""
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
"""
with tf.name_scope("cost"):
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":
eps = 1e-5
prediction = pixel_wise_softmax(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):
with tf.name_scope("cost"):
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":
eps = 1e-5
prediction = pixel_wise_softmax(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
label_weights: a pixel-wise weight map for heavy penalization of certain regions
regularizer: power of the L2 regularizers added to the loss function
"""
with tf.name_scope("cost"):
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)
print("@@@@@@@@ shape of weigt_map is {}".format(
weight_map.get_shape()))
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)
print("@@@@@@@@ shape of loss_map is {}".format(
loss_map.get_shape()))
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 == "my_cost":
class_weights = cost_kwargs.pop("class_weights", None)
weighted_labels = tf.reshape(self.w, [-1, 1])
weighted_labels = tf.reduce_sum(weighted_labels, axis=1)
print("@@@@@@@@ shape of weigted_labels is {}".format(
weighted_labels.get_shape()))
# weight_map = tf.multiply(flat_labels, weighted_labels)
# weight_map = tf.reduce_sum(weight_map, axis=1)
# loss_map = tf.nn.cross_entropy_with_logits(logits=flat_logits,
# targets=flat_labels)
loss_map = tf.nn.softmax_cross_entropy_with_logits_v2(
logits=flat_logits, labels=flat_labels)
print("@@@@@@@@ shape of loss_map is {}".format(
loss_map.get_shape()))
weighted_loss = tf.multiply(loss_map, weighted_labels)
loss = tf.reduce_mean(weighted_loss) #, axis=0) # FIXME: check
elif cost_name == "dice_coefficient":
eps = 1e-5
prediction = pixel_wise_softmax(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
