def parabolic_crossentropy(nr_of_categories, delta=1, beta=1e10, dtype='float32'):
argmax = DifferentiableArgmax(nr_of_categories, beta, dtype=dtype)
offset = LazyInit(lambda: _K.constant(delta / 2, dtype=dtype))
f = LazyInit(lambda: _K.constant((nr_of_categories + delta) / nr_of_categories, dtype=dtype))
def loss_function(y_true, y_pred):
return ((argmax(y_pred) + offset()) - (argmax(y_true)) * f()) ** 2
return loss_function
def normal_penalized_crossentropy(nr_of_categories, alpha=10, beta=1e10, max_z=4, dtype='float32'):
max_cat_int = nr_of_categories - 1
_alpha = LazyInit(lambda: _K.constant(alpha, dtype=dtype))
_mue = LazyInit(lambda: _K.constant(max_cat_int / 2, dtype=dtype))
_sigma = LazyInit(lambda: _K.constant((max_cat_int - max_cat_int / 2) / abs(max_z), dtype=dtype))
_argmax = DifferentiableArgmax(nr_of_categories, beta, dtype=dtype)
_norm_dist = NormDistWeightedPenalizer(dtype)
def loss_function(y_true, y_pred):
# 1st we calculate the cross entropy
loss = categorical_crossentropy(y_true, y_pred)
# then we use the normal shaped probability distrubution to penalize the prediction
penalty = _norm_dist(_argmax(y_pred), _mue(), _sigma()) * _alpha()
return loss * penalty
return loss_function
def test_copy(self):
l = LazyInit(lambda: 12)
self.assertIsNone(l.value)
self.assertEqual(12, l())
self.assertIsNotNone(l.value)
l2 = deepcopy(l)
self.assertIsNone(l2.value)
self.assertEqual(12, l2())
def test_serialization(self):
l = LazyInit(lambda: 12)
self.assertIsNone(l.value)
self.assertEqual(12, l())
self.assertIsNotNone(l.value)
l2 = deserializeb(serializeb(l))
self.assertIsNone(l2.value)
self.assertEqual(12, l2())
def test_serialization(self):
"""given"""
lazy_val = LazyInit(lambda: K.constant(12))
val = lazy_val()
"""when"""
serialize(lazy_val, '/tmp/pandas_ml_common_test.dill')
lazy_val_2 = deserialize('/tmp/pandas_ml_common_test.dill', LazyInit)
"""then"""
self.assertEqual(12, K.eval(val))
self.assertEqual(12, K.eval(lazy_val_2()))
def _record_loss(self, epoch, fold, fold_epoch, train_data: XYWeight, test_data: List[XYWeight], verbose, callbacks, loss_history_key=None):
train_loss = self.calculate_loss(fold, train_data.x, train_data.y, train_data.weight)
self._history["train", loss_history_key or fold][(epoch, fold_epoch)] = train_loss
if len(test_data) > 0:
test_loss = np.array([self.calculate_loss(fold, x, y, w) for x, y, w in test_data if len(x) > 0]).mean()
else:
test_loss = np.NaN
self._history["test", loss_history_key or fold][(epoch, fold_epoch)] = test_loss
self.after_fold_epoch(epoch, fold, fold_epoch, train_loss, test_loss)
if verbose > 0:
print(f"epoch: {epoch}, train loss: {train_loss}, test loss: {test_loss}")
call_callable_dynamic_args(
callbacks,
epoch=epoch, fold=fold, fold_epoch=fold_epoch, loss=train_loss, val_loss=test_loss,
y_train=train_data.y, y_test=[td.y for td in test_data],
y_hat_train=LazyInit(lambda: self.predict(train_data.x)),
y_hat_test=[LazyInit(lambda: self.predict(td.x)) for td in test_data]
)
def __init__(self, dtype='float32'):
self.one = LazyInit(lambda: _K.constant(1, dtype=dtype))
self.two = LazyInit(lambda: _K.constant(2, dtype=dtype))
self.pi = LazyInit(lambda: _K.constant(3.1415, dtype=dtype))
self.e = LazyInit(lambda: _K.constant(2.7182, dtype=dtype))
def __init__(self, nr_of_categories, beta=1e10, dtype='float32'):
self.y_range = LazyInit(lambda: _K.arange(0, nr_of_categories, dtype=dtype))
self.beta = beta