def entropy(y_true, y_pred):
"""
Standard entropy over class probabilities.
It sums y_pred * K.log(y_pred + epsilon) over class probabilities, and then takes average over samples
"""
return K.mean(-K.sum(y_pred * K.log(y_pred + K.epsilon()), axis=-1),
axis=-1)
def nll(y_true, y_pred):
#if variance_logits:
# variance_tensor = K.exp(variance_tensor)
return 0.5 * K.mean(
K.log(variance_tensor + epsilon) + K.square(y_true - y_pred) /
(variance_tensor + epsilon))
def call(self, inputs):
assert len(
inputs
) == 2, "This layer requires exactly two inputs (mean and variance logits)"
logit_mean, logit_var = inputs
logit_std = self.preprocess_variance_input(logit_var)
logit_shape = (K.shape(logit_mean)[0], self.num_samples,
K.shape(logit_mean)[-1])
logit_mean = K.expand_dims(logit_mean, axis=1)
logit_mean = K.repeat_elements(logit_mean, self.num_samples, axis=1)
logit_std = K.expand_dims(logit_std, axis=1)
logit_std = K.repeat_elements(logit_std, self.num_samples, axis=1)
logit_samples = K.random_normal(logit_shape,
mean=logit_mean,
stddev=logit_std)
# Apply max normalization for numerical stability
logit_samples = logit_samples - K.max(
logit_samples, axis=-1, keepdims=True)
# Apply temperature scaling to logits
logit_samples = logit_samples / self.temperature
prob_samples = K.softmax(logit_samples, axis=-1)
probs = K.mean(prob_samples, axis=1)
# This is required due to approximation error, without it probabilities can sum to 1.01 or 0.99
probs = probs / K.sum(probs, axis=-1, keepdims=True)
return probs
def beta_nll(y_true, y_pred):
#if variance_logits:
# variance_tensor = K.exp(variance_tensor)
beta_sigma_sq = K.stop_gradient(K.pow(variance_tensor, beta))
return 0.5 * K.mean(
beta_sigma_sq *
(K.log(variance_tensor + epsilon) + K.square(y_true - y_pred) /
(variance_tensor + epsilon)))
def negative_log_likelihood(y_true, y_pred):
"""
Negative log-likelihood or negative log-probability loss/metric.
Reference: Evaluating Predictive Uncertainty Challenge, Quiñonero-Candela et al, 2006.
It sums over classes: log(y_pred) for true class and log(1.0 - pred) for not true class, and then takes average across samples.
"""
y_pred = K.clip(y_pred, K.epsilon(), 1.0 - K.epsilon())
return -K.mean(K.sum(y_true * K.log(y_pred) +
(1.0 - y_true) * K.log(1.0 - y_pred),
axis=-1),
axis=-1)
def brier_score(y_true, y_pred):
"""
Mean squared error on the probabilities.
"""
return K.mean(K.square(y_true - y_pred))
def pinball(y_true, y_pred):
err = y_true - y_pred
return K.mean(K.maximum(tau * err, (tau - 1.0) * err), axis=-1)
def nll(y_true, y_pred):
return K.mean(
K.log(2.0 * spread_tensor + epsilon) + K.abs(y_true - y_pred) /
(spread_tensor + epsilon))
def kl_loss(self, w, mu, sigma):
return self.kl_weight * K.mean(
gaussian.log_probability(w, mu, sigma) -
self.prior * self.log_prior_prob(w))
def kl_loss(self, parameter, distribution):
return self.kl_weight * K.mean(distribution.log_probability(parameter))
def rbf(self, z):
z = z - self.centroids
z = K.mean(K.square(z), axis=1) / (2.0 * self.length_scale**2)
z = K.exp(-z)
return z