X,y = make_moons(n_samples=100, noise=0.25, random_state=3)
X_train, X_test, y_train, y_test = train_test_split(X, y, stratify=y, random_state=42)
mlp = MLPClassifier(solver='lbfgs', random_state=0, hidden_layer_sizes=[10,10]).fit(X_train, y_train)
plt.figure("[10,10]")
dsets.plot_2d_separator(mlp, X_train, fill=True, alpha=.3)
dsets.discrete_scatter(X_train[:,0], X_train[:,1], y_train)
plt.xlabel("Feature 0")
plt.ylabel("Feature 1")
print("hidden_layer_sizes : [10] : 1 hidden avec 10 nœuds \n \t \t [10,10] : 2 hidden 10 nœuds chacune")
mlp = MLPClassifier(solver='lbfgs', random_state=0, hidden_layer_sizes=[10,10,10]).fit(X_train, y_train)
plt.figure("{}".format(mlp.__getattribute__("hidden_layer_sizes" )))
dsets.plot_2d_separator(mlp, X_train, fill=True, alpha=.3)
dsets.discrete_scatter(X_train[:,0], X_train[:,1], y_train)
plt.xlabel("Feature 0")
plt.ylabel("Feature 1")
mlp = MLPClassifier(solver='lbfgs', activation='tanh',random_state=0, hidden_layer_sizes=[10,10,10]).fit(X_train, y_train)
plt.figure("{}, {}".format(mlp.__getattribute__("hidden_layer_sizes"), mlp.__getattribute__("activation")))
dsets.plot_2d_separator(mlp, X_train, fill=True, alpha=.3)
dsets.discrete_scatter(X_train[:,0], X_train[:,1], y_train)
plt.xlabel("Feature 0")
plt.ylabel("Feature 1")
fig, axes = plt.subplots(2,4,figsize=(20,8))
#Accuracy on the test set: 0.881
#### On doit rescaler les données pour satisfaire les exigeances du MLP (moyenne à 0 et std à 1) et améliorer les capacités du MLP
X_train_scaled = (X_train-X_train.mean(axis=0))/X_train.std(axis=0)
#### On utilise de même X_train.mean pour rescaler les données
X_test_scaled = (X_test-X_train.mean(axis=0))/X_train.std(axis=0)
mlp = MLPClassifier(random_state=42, max_iter=1000).fit(X_train_scaled, y_train)
print("\nAccuracy on the Scaled training set: {:.3f}".format(mlp.score(X_train_scaled,y_train)))
print("Accuracy on the Scaled test set: {:.3f}".format(mlp.score(X_test_scaled, y_test)))
print("\nOn passe alpha de {:.4f}, à {:.4f}".format(mlp.__getattribute__("alpha"), 1))
mlp = MLPClassifier(random_state=42, max_iter=1000, alpha=1).fit(X_train_scaled, y_train)
print("Accuracy on the Scaled training set: {:.3f}".format(mlp.score(X_train_scaled,y_train)))
print("Accuracy on the Scaled test set: {:.3f}".format(mlp.score(X_test_scaled, y_test)))
fig, axes = plt.subplots(2,1, figsize=(15,8))
for ax, alpha in zip(axes, [1, 10]) :
mlp = MLPClassifier(random_state=42, max_iter=1000,alpha=alpha).fit(X_train_scaled, y_train)
ax.set_title("alpha = {:.4f}".format(alpha), loc=u'right')
ax.imshow(mlp.coefs_[0], cmap='viridis', interpolation='none')
ax.set_xlabel("Columns in weights Matrix")
ax.set_ylabel("Input features")
plt.sca(axes[0])
plt.yticks(xrange(X.shape[1]), cancer.feature_names)
class _MLPClassifier(BaseEstimator):
def __init__(self, runner, **kwargs):
self.runner = runner
self.mlp = MLPClassifier(**kwargs)
self.state_callback = self.runner._save_state
self.user_info = [(k, v) for k, v in kwargs.items()]
for k, v in kwargs.items():
self.runner._log_current_argument(k, v)
# need to intercept the classifier so we can track statistics.
if runner.generate_curves:
if hasattr(self.mlp, '_update_no_improvement_count'):
self._mlp_update_no_improvement_count = self.mlp._update_no_improvement_count
self.mlp._update_no_improvement_count = self._update_no_improvement_count_intercept
if hasattr(self.mlp, '_loss_grad_lbfgs'):
self._mlp_loss_grad_lbfgs = self.mlp._loss_grad_lbfgs
self.mlp._loss_grad_lbfgs = self._loss_grad_lbfgs_intercept
def __getattr__(self, item):
return self.mlp.__getattribute__(item)
def get_params(self, deep=True):
out = super().get_params()
out.update(self.mlp.get_params())
return out
def fit(self, x_train, y_train=None):
self.runner._start_run_timing()
# make initial callback
self._invoke_runner_callback()
return self.mlp.fit(x_train, y_train)
def predict(self, x_test):
return self.mlp.predict(x_test)
def _update_no_improvement_count_intercept(self, early_stopping, x_val,
y_val):
self._invoke_runner_callback()
return self._mlp_update_no_improvement_count(
early_stopping, x_val, y_val)
def _loss_grad_lbfgs_intercept(self, packed_coef_inter, x, y,
activations, deltas, coef_grads,
intercept_grads):
self._invoke_runner_callback()
return self._mlp_loss_grad_lbfgs(packed_coef_inter, x, y,
activations, deltas, coef_grads,
intercept_grads)
def _invoke_runner_callback(self):
iterations = self.mlp.n_iter_ if hasattr(self.mlp,
'n_iter_') else 0
no_improvement_count = self.mlp._no_improvement_count if hasattr(
self.mlp, '_no_improvement_count') else 0
done = (self.mlp.early_stopping and
(no_improvement_count > self.mlp.n_iter_no_change)
or iterations == self.mlp.max_iter)
state = self.mlp.coefs_ if hasattr(self.mlp, 'coefs_') else []
fitness = self.mlp.loss_ if hasattr(self.mlp, 'loss_') else 0
curve = self.mlp.loss_curve_ if hasattr(self.mlp,
'loss_curve_') else [0]
return self.state_callback(iteration=iterations,
state=state,
fitness=fitness,
user_data=self.user_info,
attempt=no_improvement_count,
done=done,
curve=curve)