def fit(self, inputs, targets, verbose = False):
fit_stats = {"train_loss": [], "train_acc": [], "valid_loss": [], "valid_acc": []}
self.weights = self.init_method.initialize_weights((inputs.shape[1], targets.shape[1]))
self.bias = np.zeros((1, targets.shape[1]))
for i in range(self.epochs):
linear_predictions = inputs.dot(self.weights) + self.bias
predictions = self.activate.forward(linear_predictions)
loss = self.loss.forward(predictions, targets) + self.regularization.regulate(self.weights)
acc = self.loss.accuracy(predictions, targets)
fit_stats["train_loss"].append(np.mean(loss))
fit_stats["train_acc"].append(np.mean(acc))
grad = self.loss.backward(predictions, targets) * self.activate.backward(linear_predictions)
d_weights = inputs.T.dot(grad) + self.regularization.derivative(self.weights)
d_bias = np.sum(grad, axis = 0, keepdims = True) + self.regularization.derivative(self.bias)
self.weights = optimize(self.optimizer).update(self.weights, d_weights, i, 1, 1)
self.bias = optimize(self.optimizer).update(self.bias, d_bias, i, 1, 1)
if verbose:
print('TRAINING: Epoch-{} loss: {:2.4f} acc: {:2.4f}'.format(i+1, loss, acc))
else:
computebar(self.epochs, i)
return fit_stats
def run(self,
f,
df,
params=1,
epochs=10,
tol=1e-4,
scale_factor=5,
verbose=False):
self.inputs = init(self.init_method).initialize_weights(
(params, 1)) * scale_factor
self.f0 = f(self.inputs) # initial function value (fsolve)
self.epochs = epochs
self.fsolve = np.zeros((self.epochs, 1))
self.weights = np.zeros((self.epochs, 1, params))
for i in np.arange(self.epochs):
self.inputs = optimize(self.optimizer).update(
self.inputs, df(self.inputs))
self.weights[i, :, :] = self.inputs.T
f_solution = f(self.inputs)
self.fsolve[i, :] = f_solution
if verbose:
if i % 5 == 0:
print('Epoch-{} weights: {:.20}'.format(
i + 1, self.npstring(self.inputs.T)))
print('Epoch-{} eps: {:.20}'.format(
i + 1, self.npstring(self.f0 - f_solution)))
def __init__(self,
epochs,
loss = 'binary_crossentropy',
init_method = 'he_normal',
optimizer = {},
penalty = 'lasso',
penalty_weight = 0,
l1_ratio = 0.5):
self.epochs = epochs
self.loss = objective(loss)
self.init_method = init(init_method)
self.optimizer = optimize(optimizer)
self.activate = activation('sigmoid')
self.regularization = regularize(penalty, penalty_weight, l1_ratio = l1_ratio)
def __init__(self,
epochs,
loss='mean_squared_error',
init_method='he_uniform',
optimizer={},
penalty='ridge',
penalty_weight=0.5,
l1_ratio=0.5):
self.epochs = epochs
self.loss = objective(loss)
self.init_method = init(init_method)
self.optimizer = optimize(optimizer)
self.regularization = regularize(penalty,
penalty_weight,
l1_ratio=l1_ratio)