How to use the neuraxle.base.MetaStepMixin function in neuraxle

To help you get started, we’ve selected a few neuraxle examples, based on popular ways it is used in public projects.

Secure your code as it's written. Use Snyk Code to scan source code in minutes - no build needed - and fix issues immediately.

github Neuraxio / Neuraxle / neuraxle / metaopt / sklearn.py View on Github external
Unless required by applicable law or agreed to in writing, software
    distributed under the License is distributed on an "AS IS" BASIS,
    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    See the License for the specific language governing permissions and
    limitations under the License.

..
    Thanks to Umaneo Technologies Inc. for their contributions to this Machine Learning
    project, visit https://www.umaneo.com/ for more information on Umaneo Technologies Inc.

"""

from neuraxle.base import MetaStepMixin, BaseStep


class MetaSKLearnWrapper(MetaStepMixin, BaseStep):

    def __init__(self, wrapped):
        """
        Wrap a scikit-learn MetaEstimatorMixin for usage in Neuraxle. 
        This class is similar to the SKLearnWrapper class of Neuraxle that can wrap a scikit-learn BaseEstimator. 
        
        :param wrapped: a scikit-learn object of type "MetaEstimatorMixin". 
        """
        MetaStepMixin.__init__(self)
        BaseStep.__init__(self)
        self.wrapped_sklearn_metaestimator = wrapped  # TODO: use self.set_step of the MetaStepMixin instead?
        # sklearn.model_selection.RandomizedSearchCV

    def fit(self, data_inputs, expected_outputs=None) -> 'BaseStep':
        self.wrapped_sklearn_metaestimator = self.wrapped_sklearn_metaestimator.fit(data_inputs, expected_outputs)
        return self
github Neuraxio / Neuraxle / neuraxle / steps / column_transformer.py View on Github external
np.expand_dims(np.array(data_inputs)[:, i], axis=-1)
                for i in self.column_selection
            ]
            return np.concatenate(columns, axis=-1)

        if self.column_selection is None:
            return data_inputs

        raise ValueError(
            'column selection type not supported : {0}\nSupported types'.format(
                self.column_selection,
                repr(ColumnSelectionType)
            ))


class ColumnsSelectorND(MetaStepMixin, BaseStep):
    """
    ColumnSelectorND wraps a ColumnSelector2D by as many ForEachDataInput step
    as needed to select the last dimension.
    """

    def __init__(self, columns_selection, n_dimension=3):
        BaseStep.__init__(self)

        col_selector = ColumnSelector2D(columns_selection=columns_selection)
        for _ in range(min(0, n_dimension - 2)):
            col_selector = ForEachDataInput(col_selector)

        MetaStepMixin.__init__(self, col_selector)
        self.n_dimension = n_dimension

    def fit(self, data_inputs, expected_outputs=None) -> 'BaseStep':
github Neuraxio / Neuraxle / neuraxle / metaopt / random.py View on Github external
def __init__(self, scoring_function=r2_score, joiner=NumpyConcatenateOuterBatch()):
        MetaStepMixin.__init__(self)
        BaseStep.__init__(self)
        self.scoring_function = scoring_function
        self.joiner = joiner
github Neuraxio / Neuraxle / neuraxle / steps / flow.py View on Github external
def __init__(self, wrapped: BaseStep):
        ForceHandleMixin.__init__(self)
        MetaStepMixin.__init__(self, wrapped=wrapped)
        BaseStep.__init__(self)
github Neuraxio / Neuraxle / neuraxle / steps / flow.py View on Github external
from neuraxle.base import MetaStepMixin, BaseStep, ExecutionContext, DataContainer, NonTransformableMixin, \
    ExecutionMode, NonFittableMixin, ForceHandleMixin


class TransformOnlyWrapper(
    NonTransformableMixin,
    NonFittableMixin,
    MetaStepMixin,
    BaseStep
):
    """
    A wrapper step that makes its wrapped step only executes in the transform execution mode.

    .. seealso:: :class:`ExecutionMode`,
        :class:`neuraxle.base.DataContainer`,
        :class:`neuraxle.base.NonTransformableMixin`,
        :class:`neuraxle.base.NonFittableMixin`,
        :class:`neuraxle.base.MetaStepMixin`,
        :class:`neuraxle.base.BaseStep`
    """

    def __init__(self, wrapped: BaseStep):
        NonTransformableMixin.__init__(self)
        NonFittableMixin.__init__(self)
github Neuraxio / Neuraxle / neuraxle / metaopt / random.py View on Github external
def __init__(
            self,
            wrapped = None,
            n_iter: int = 10,
            higher_score_is_better: bool = True,
            validation_technique: BaseCrossValidation = KFoldCrossValidation(),
            refit=True,
    ):
        if wrapped is not None:
            MetaStepMixin.__init__(self, wrapped)
        BaseStep.__init__(self)
        self.n_iter = n_iter
        self.higher_score_is_better = higher_score_is_better
        self.validation_technique: BaseCrossValidation = validation_technique
        self.refit = refit
github Neuraxio / Neuraxle / neuraxle / steps / loop.py View on Github external
def set_hyperparams(self, hyperparams: HyperparameterSamples) -> BaseStep:
        MetaStepMixin.set_hyperparams(self, hyperparams)
        self.steps = [s.set_hyperparams(self.wrapped.get_hyperparams()) for s in self.steps]
        return self
github Neuraxio / Neuraxle / neuraxle / steps / data.py View on Github external
:param data_inputs: (data inputs, expected outputs) tuple to shuffle
        :return:
        """
        if self.increment_seed_after_each_fit:
            self.seed += 1

        di, eo = data_inputs
        data = list(zip(di, eo))
        random.Random(self.seed).shuffle(data)

        data_inputs_shuffled, expected_outputs_shuffled = list(zip(*data))

        return list(data_inputs_shuffled), list(expected_outputs_shuffled)


class EpochRepeater(MetaStepMixin, BaseStep):
    """
    Repeat wrapped step fit, or transform for the number of epochs passed in the constructor.

    .. code-block:: python

        p = Pipeline([
            TrainOnlyWrapper(DataShuffler(seed=42, increment_seed_after_each_fit=True, increment_seed_after_each_fit=False)),
            EpochRepeater(ForecastingPipeline(), epochs=EPOCHS, repeat_in_test_mode=False)
        ])

    .. seealso::
        :class:`DataShuffler`,
        :class:`MetaStepMixin`,
        :class:`TrainOnlyWrapper`,
        :class:`TestOnlyWrapper`,
        :class:`BaseStep`
github Neuraxio / Neuraxle / neuraxle / steps / column_transformer.py View on Github external
def __init__(self, columns_selection, n_dimension=3):
        BaseStep.__init__(self)

        col_selector = ColumnSelector2D(columns_selection=columns_selection)
        for _ in range(min(0, n_dimension - 2)):
            col_selector = ForEachDataInput(col_selector)

        MetaStepMixin.__init__(self, col_selector)
        self.n_dimension = n_dimension