class Layer(object):
"""
A collection of models that may be chained to other layers in order to
build a full deep forest model.
"""
def __init__(self, layer, *models):
self.parent_layer = layer
self.models = Models(check_models(models))
def fit(self, X, y):
self.parent_layer.fit(X, y)
full_X = self._add_parent_predictions(X)
self.models.fit(full_X, y)
return self
def _add_parent_predictions(self, X):
predictions = self.parent_layer.predict_proba(X)
if len(predictions.shape) != 2:
predictions = np.reshape(predictions, (len(X), -1))
new_X = np.concatenate([X, predictions], axis=1)
return new_X
def predict_proba(self, X):
full_X = self._add_parent_predictions(X)
return self.models.predict_proba(full_X)
def test_Models_fit_method_should_return_self(self):
# Given
models = Models(create_models(n=3, predicted_value=self.y_test))
# When
new_models = models.fit(self.X_train, self.y_train)
# Check
assert models is new_models
def test_Models_fit_method_should_fit_all_internal_models(self):
# Given
models = Models(create_models(n=3, predicted_value=self.y_test))
# When
models.fit(self.X_train, self.y_train)
# Check
for model in models._models:
model.fit.assert_called_once_with(self.X_train, self.y_train)
def test_Models_predict_method_should_call_predict_on_all_models(self):
# Given
models = Models(create_models(n=3, predicted_value=self.y_test))
# When
models.predict(self.X_test)
# Check
for model in models._models:
model.predict_proba.assert_called_once_with(self.X_test)
def test_Models_predict_proba_should_return_properly_formatted_array(self):
# Given
nb_models = 3
models = Models(create_models(n=nb_models,
predicted_value=self.y_test))
# When
prediction = models.predict_proba(self.X_test)
# Check
assert prediction.shape == (len(self.y_test), 2, nb_models)
class InputLayer(object):
"""
A layer that is not built upon another layer.
"""
def __init__(self, *models):
self.models = Models(check_models(models))
def fit(self, X, y):
self.models.fit(X, y)
return self
def predict_proba(self, X):
return self.models.predict_proba(X)
def test_indexing_should_return_models(self):
# Given
nb_models = 3
models = Models(create_models(n=nb_models,
predicted_value=self.y_test))
# When
model = models[0]
# Check
assert isinstance(model, MagicMock)
class Scan(object):
def __init__(self, models, n_patch, patch_size=(2, 2)):
self.models = Models(models)
self.n_patch = n_patch
self.patch_size = patch_size
def fit(self, X, y):
transformed_X, transformed_y = self._scan(X, y)
self.models.fit(transformed_X, transformed_y)
def transform(self, X):
transformed_X = self._scan(X)
models_predictions = self.models.predict_proba(transformed_X)
return models_predictions.reshape(len(X), -1)
def fit_transform(self, X, y):
transformed_X, transformed_y = self._scan(X, y)
self.models.fit(transformed_X, transformed_y)
models_predictions = self.models.predict_proba(transformed_X)
return models_predictions.reshape(len(X), -1)
def _scan(self, X, y=None):
arrays, n_patches = zip(*(self._patch(x) for x in X))
new_X = np.vstack(arrays)
if y is not None:
new_y = np.repeat(y, n_patches, axis=0)
return new_X, new_y
else:
return new_X
def _patch(self, X):
patches = extract_patches_2d(X,
self.patch_size,
max_patches=self.n_patch)
lines = (np.hstack(np.hstack(x)) for x in patches)
array = np.vstack(x for x in lines)
return array, len(patches)
def __init__(self, models, n_patch, patch_size=(2, 2)):
self.models = Models(models)
self.n_patch = n_patch
self.patch_size = patch_size
def __init__(self, *models):
self.models = Models(check_models(models))
def __init__(self, layer, *models):
self.parent_layer = layer
self.models = Models(check_models(models))