def get_main_loss(main_loss_str):
"""
Get the main loss function using a string.
The search is structured in 3 steps:
1. Search for the loss in the custom losses
2. Search for the loss in the standard keras losses
3. Fall back to categorical crossentropy if the loss does not exist
Arguments
----
main_loss_str: String
Name of the loss function you are looking
for.
"""
if type(main_loss_str) is list:
main_loss_str = main_loss_str[0]
custom_loss_dict = get_custom_loss_dict()
loss = custom_loss_dict.get(main_loss_str, 'not_custom')
if loss == 'not_custom':
try:
loss = losses.get(main_loss_str)
except ValueError:
print("We could not find your custom loss: " + str(main_loss_str))
print("Fall back to categorical crossentropy")
loss = losses.get('categorical_crossentropy')
return loss
def test_regression():
(x_train, y_train), (x_test, y_test) = boston_housing.load_data()
supervision_metric = 'mae'
ivis_boston = Ivis(k=15,
batch_size=16,
epochs=2,
supervision_metric=supervision_metric)
ivis_boston.fit(x_train, y_train)
embeddings = ivis_boston.transform(x_train)
y_pred = ivis_boston.score_samples(x_train)
loss_name = ivis_boston.model_.loss['supervised'].__name__
assert losses.get(loss_name).__name__ == losses.get(
supervision_metric).__name__
assert ivis_boston.model_.layers[-1].activation.__name__ == 'linear'
assert ivis_boston.model_.layers[-1].output_shape[-1] == 1
def compile_model(self,
optimizer,
optimizer_kwargs,
loss,
metrics,
target_tensors=None,
**kwargs):
# Initialize optimizer
optimizer = optimizers.__dict__[optimizer]
optimizer = optimizer(**optimizer_kwargs)
# Make sure sparse metrics and loss are specified sparse
metrics = ensure_list_or_tuple(metrics)
loss = ensure_list_or_tuple(loss)
for i, m in enumerate(metrics + loss):
if "sparse" not in m:
raise_non_sparse_metric_or_loss_error()
# Initialize loss(es)
loss_list = []
for l in loss:
if l in losses.__dict__:
loss_list.append(losses.get(l))
else:
import inspect
l = loss_functions.__dict__[l]
if inspect.isclass(l):
loss_list.append(l(logger=self.logger, **kwargs))
else:
loss_list.append(l)
loss = loss_list
# Find metrics both from standard keras.metrics module and own custom
init_metrics = []
for m in metrics:
if m in TF_metrics.__dict__:
init_metrics.append(TF_metrics.get(m))
else:
import inspect
metric = custom_metrics.__dict__[m]
if inspect.isclass(metric):
metric = metric(logger=self.logger, **kwargs)
init_metrics.append(metric)
# Compile the model
self.model.compile(optimizer=optimizer,
loss=loss,
metrics=init_metrics,
target_tensors=target_tensors)
self.logger("Optimizer: %s" % optimizer)
self.logger("Loss funcs: %s" % loss)
self.logger("Metrics: %s" % init_metrics)
if target_tensors is not None:
self.target_tensor = True
return self
def compile_model(self,
optimizer,
optimizer_kwargs,
loss,
metrics,
sparse=False,
mem_logging=False,
**kwargs):
# Initialize optimizer
optimizer = optimizers.__dict__[optimizer]
optimizer = optimizer(**optimizer_kwargs)
# Initialize loss
if loss in losses.__dict__:
loss = losses.get(loss)
else:
import inspect
loss = loss_functions.__dict__[loss]
if inspect.isclass(loss):
loss = loss(logger=self.logger, **kwargs)
if sparse:
# Make sure sparse metrics are specified
for i, m in enumerate(metrics):
if "sparse" not in m:
new = "sparse_" + m
self.logger("Note: changing %s --> "
"%s (sparse=True passed)" % (m, new))
metrics[i] = new
# Find metrics both from standard keras.metrics module and own custom
init_metrics = []
for m in metrics:
if m in TF_metrics.__dict__:
init_metrics.append(TF_metrics.get(m))
else:
import inspect
metric = custom_metrics.__dict__[m]
if inspect.isclass(metric):
metric = metric(logger=self.logger, **kwargs)
init_metrics.append(metric)
# Compile the model
self.model.compile(optimizer=optimizer,
loss=loss,
metrics=init_metrics)
self.logger("Optimizer: %s" % optimizer)
self.logger("Loss: %s" % loss)
self.logger("Targets: %s" % ("Integer" if sparse else "One-Hot"))
self.logger("Metrics: %s" % init_metrics)
return self
def get_model(input_shape=(256, 256, 3)):
inputs = layers.Input(shape=input_shape) # 256
decoder0 = u_net_block(inputs)
outputs = layers.Conv2D(1, (1, 1), activation='sigmoid')(decoder0)
model = models.Model(inputs=[inputs], outputs=[outputs])
model.compile(
optimizer=optimizers.get(OPTIMIZER),
loss=losses.get(LOSS),
metrics=[metrics.get(metric) for metric in METRICS])
return model
def test_svm_score_samples():
iris = datasets.load_iris()
x = iris.data
y = iris.target
supervision_metric = 'categorical_hinge'
ivis_iris = Ivis(k=15,
batch_size=16,
epochs=2,
supervision_metric=supervision_metric)
# Correctly formatted one-hot labels train successfully
y = to_categorical(y)
embeddings = ivis_iris.fit_transform(x, y)
y_pred = ivis_iris.score_samples(x)
loss_name = ivis_iris.model_.loss['supervised'].__name__
assert losses.get(loss_name).__name__ == losses.get(
supervision_metric).__name__
assert ivis_iris.model_.layers[-1].activation.__name__ == 'linear'
assert ivis_iris.model_.layers[-1].kernel_regularizer is not None
assert ivis_iris.model_.layers[-1].output_shape[-1] == y.shape[-1]
def get(identifier: Union[Callable, str]) -> Callable:
"""Returns loss function
Arguments:
identifier: Function or string
Returns:
Function corresponding to the input string or input function.
"""
if identifier is None:
return None
elif callable(identifier):
return identifier
elif identifier in LOSSES.keys():
return LOSSES.get(identifier)
else:
return losses.get(identifier)
def test_score_samples():
iris = datasets.load_iris()
x = iris.data
y = iris.target
supervision_metric = 'sparse_categorical_crossentropy'
ivis_iris = Ivis(k=15,
batch_size=16,
epochs=2,
supervision_metric=supervision_metric)
embeddings = ivis_iris.fit_transform(x, y)
y_pred = ivis_iris.score_samples(x)
# Softmax probabilities add to one, correct shape
assert np.sum(y_pred, axis=-1) == pytest.approx(1, 0.01)
assert y_pred.shape[0] == x.shape[0]
assert y_pred.shape[1] == len(np.unique(y))
# Check that loss function and activation are correct
loss_name = ivis_iris.model_.loss['supervised'].__name__
assert losses.get(loss_name).__name__ == losses.get(
supervision_metric).__name__
assert ivis_iris.model_.layers[-1].activation.__name__ == 'softmax'
def get_siamese_model(input_shape=(256, 256, 3)):
inputs = layers.Input(shape=input_shape) # 256
block0 = u_net_block(inputs)
block1 = u_net_block(inputs)
decoder_siamese = layers.concatenate([block0, block1], axis=-1)
outputs = layers.Conv2D(1, (1, 1), activation='sigmoid')(decoder_siamese)
model = models.Model(inputs=[inputs], outputs=[outputs])
model.compile(
optimizer=optimizers.get(OPTIMIZER),
loss=losses.get(LOSS),
metrics=[metrics.get(metric) for metric in METRICS])
return model
def contractive_loss(y_pred, y_true):
# Get the base_loss.
if isinstance(self.loss, str):
base_loss = losses.get(self.loss)(y_pred, y_true)
else:
base_loss = self.loss(y_pred, y_true)
# Get the contractive loss.
encoder_output = self.encoder.layers[-1]
weigths = K.variable(value=encoder_output.get_weights()[0])
weigths = K.transpose(weigths) # N_hidden x N
h = encoder_output.output
dh = h * (1 - h)
contractive = lam * K.sum(dh**2 * K.sum(weigths**2, axis=1), axis=1)
return base_loss + contractive
def vae_loss(loss_inputs, loss_outputs):
# Flatten all to accept different dimensions.
loss_inputs = K.flatten(loss_inputs)
loss_outputs = K.flatten(loss_outputs)
# Reconstruction loss.
if isinstance(self.loss, str):
r_loss = losses.get(self.loss)(loss_inputs, loss_outputs)
else:
r_loss = self.loss(loss_inputs, loss_outputs)
r_loss *= inputs_dim
# kl loss.
kl_loss = 1 + z_log_var - K.square(z_mean) - K.exp(z_log_var)
kl_loss = K.sum(kl_loss, axis=-1)
kl_loss *= -0.5
# VAE loss.
vae_loss = K.mean(r_loss + kl_loss)
vae_loss /= inputs_dim
return vae_loss
def __init__(self, loss, fast=False, **kwargs):
self.supports_masking = True
self.loss = losses.get(loss)
self.fast = fast
super(GradientNormLayer, self).__init__(**kwargs)
def __init__(self, loss, **kwargs):
self.supports_masking = True
self.loss = losses.get(loss)
super(LossLayer, self).__init__(**kwargs)
def get_loss_class_function_or_string(
loss: str) -> Union[losses_mod.Loss, Callable]:
got = losses_mod.get(loss)
if type(got) == FunctionType:
return got
return type(got) # a class, e.g. if loss="BinaryCrossentropy"
