def _grad_func(self, packed_coef_inter, X, y, activations, deltas,
coef_grads, intercept_grads):
loss, coef_grads, intercept_grads = \
self._backprop(X, y, activations, deltas,
coef_grads, intercept_grads)
grad = _pack(coef_grads, intercept_grads)
return grad
def _fit_evol(self, X, y, X_val, Y_val, activations, deltas, coef_grads,
intercept_grads, layer_units):
# Store meta information for the parameters
self._coef_indptr = []
self._intercept_indptr = []
start = 0
# Save sizes and indices of coefficients for faster unpacking
for i in range(self.n_layers_ - 1):
n_fan_in, n_fan_out = layer_units[i], layer_units[i + 1]
end = start + (n_fan_in * n_fan_out)
self._coef_indptr.append((start, end, (n_fan_in, n_fan_out)))
start = end
# Save sizes and indices of intercepts for faster unpacking
for i in range(self.n_layers_ - 1):
end = start + layer_units[i + 1]
self._intercept_indptr.append((start, end))
start = end
# Run evolution
packed_coef_inter = _pack(self.coefs_, self.intercepts_)
if self.verbose is True or self.verbose >= 1:
iprint = 1
else:
iprint = -1
bounds = list()
for i in range(len(packed_coef_inter)):
bounds.append(self.bound)
result = optimize.differential_evolution(func=self._loss_func,
bounds=bounds,
maxiter=self.max_iter,
disp=False,
polish=True,
init='latinhypercube',
popsize=self.popsize,
strategy=self.straegy,
seed=self.random_state,
args=(X, y, activations,
deltas, coef_grads,
intercept_grads),
callback=self._callback)
optimal_parameters = result.x
self.loss_ = result.fun
self._unpack(optimal_parameters)
def _fit_basinhopping(self, X, y, X_val, Y_val, activations, deltas,
coef_grads, intercept_grads, layer_units):
# Store meta information for the parameters
self._coef_indptr = []
self._intercept_indptr = []
start = 0
# Save sizes and indices of coefficients for faster unpacking
for i in range(self.n_layers_ - 1):
n_fan_in, n_fan_out = layer_units[i], layer_units[i + 1]
end = start + (n_fan_in * n_fan_out)
self._coef_indptr.append((start, end, (n_fan_in, n_fan_out)))
start = end
# Save sizes and indices of intercepts for faster unpacking
for i in range(self.n_layers_ - 1):
end = start + layer_units[i + 1]
self._intercept_indptr.append((start, end))
start = end
# Run Basinhopping
packed_coef_inter = _pack(self.coefs_, self.intercepts_)
minimizer_kwargs = {
'method': 'L-BFGS-B',
'args': (X, y, activations, deltas, coef_grads, intercept_grads)
}
result = optimize.basinhopping(x0=packed_coef_inter,
T=self.T,
stepsize=self.stepsize,
func=self._loss_func,
niter=self.max_iter,
callback=self._callback,
minimizer_kwargs=minimizer_kwargs)
optimal_parameters = result.x
self.loss = result.fun
self._unpack(optimal_parameters)
def _fit_bfgs(self, X, y, X_val, Y_val, activations, deltas, coef_grads,
intercept_grads, layer_units):
# Store meta information for the parameters
self._coef_indptr = []
self._intercept_indptr = []
start = 0
# Save sizes and indices of coefficients for faster unpacking
for i in range(self.n_layers_ - 1):
n_fan_in, n_fan_out = layer_units[i], layer_units[i + 1]
end = start + (n_fan_in * n_fan_out)
self._coef_indptr.append((start, end, (n_fan_in, n_fan_out)))
start = end
# Save sizes and indices of intercepts for faster unpacking
for i in range(self.n_layers_ - 1):
end = start + layer_units[i + 1]
self._intercept_indptr.append((start, end))
start = end
# Run BFGS
packed_coef_inter = _pack(self.coefs_, self.intercepts_)
if self.verbose is True or self.verbose >= 1:
iprint = 1
else:
iprint = -1
optimal_parameters, self.loss_, d, Bopt, func_calls, grad_calls, warnflag = \
optimize.fmin_bfgs(x0=packed_coef_inter,
f=self._loss_func,
fprime=self._grad_func,
maxiter=self.max_iter,
disp=False,
gtol=self.tol,
args=(X, y, activations, deltas, coef_grads, intercept_grads),
full_output=True,
callback=self._callback)
self._unpack(optimal_parameters)
def _fit_anneal(self, X, y, X_val, Y_val, activations, deltas, coef_grads,
intercept_grads, layer_units):
if scipy.__version__ == '0.14.0':
# Store meta information for the parameters
self._coef_indptr = []
self._intercept_indptr = []
start = 0
# Save sizes and indices of coefficients for faster unpacking
for i in range(self.n_layers_ - 1):
n_fan_in, n_fan_out = layer_units[i], layer_units[i + 1]
end = start + (n_fan_in * n_fan_out)
self._coef_indptr.append((start, end, (n_fan_in, n_fan_out)))
start = end
# Save sizes and indices of intercepts for faster unpacking
for i in range(self.n_layers_ - 1):
end = start + layer_units[i + 1]
self._intercept_indptr.append((start, end))
start = end
# Run Simulated Annealing
packed_coef_inter = _pack(self.coefs_, self.intercepts_)
result = optimize.anneal(x0=packed_coef_inter,
T0=self.T,
stepsize=self.stepsize,
func=self._loss_func,
maxiter=self.max_iter,
args=(X, y, activations, deltas,
coef_grads, intercept_grads))
optimal_parameters = result.x
self.loss = result.fun
self._unpack(optimal_parameters)
else:
raise ImportError('Anneal method require scipy version <= 0.14.0')
def _fit_cg(self, X, y, X_val, Y_val, activations, deltas, coef_grads,
intercept_grads, layer_units):
# Store meta information for the parameters
self._coef_indptr = []
self._intercept_indptr = []
start = 0
# Save sizes and indices of coefficients for faster unpacking
for i in range(self.n_layers_ - 1):
n_fan_in, n_fan_out = layer_units[i], layer_units[i + 1]
end = start + (n_fan_in * n_fan_out)
self._coef_indptr.append((start, end, (n_fan_in, n_fan_out)))
start = end
# Save sizes and indices of intercepts for faster unpacking
for i in range(self.n_layers_ - 1):
end = start + layer_units[i + 1]
self._intercept_indptr.append((start, end))
start = end
# Run CG
packed_coef_inter = _pack(self.coefs_, self.intercepts_)
optimal_parameters, self.loss_, func_calls, grad_calls, d = \
optimize.fmin_cg(x0=packed_coef_inter,
f=self._loss_func,
fprime=self._grad_func,
maxiter=self.max_iter,
disp=False,
epsilon=self.epsilon,
gtol=self.tol,
args=(X, y, activations, deltas, coef_grads, intercept_grads),
callback=self._callback,
full_output=True)
self._unpack(optimal_parameters)
