def handle_inverse_transform(self, data_container: DataContainer, context: ExecutionContext) -> DataContainer:
"""
Handle inverse transform by passing expected outputs to the wrapped step inverse transform method.
Update the expected outputs with the outputs.
:param context: execution context
:param data_container:
:return: data container
:rtype: DataContainer
"""
new_expected_outputs_data_container = self.wrapped.handle_inverse_transform(
DataContainer(
current_ids=data_container.current_ids,
data_inputs=data_container.expected_outputs,
expected_outputs=None
),
context.push(self.wrapped)
)
data_container.set_expected_outputs(new_expected_outputs_data_container.data_inputs)
current_ids = self.hash(data_container)
data_container.set_current_ids(current_ids)
return data_container
def _fit_data_container(self, data_container: DataContainer, context: ExecutionContext) -> 'BaseStep':
"""
Handle transform by fitting the step,
and updating the data inputs, and expected outputs inside the data container.
:param context: execution context
:param data_container:
:return:
"""
new_self = self.fit((data_container.data_inputs, data_container.expected_outputs), None)
data_container.set_data_inputs((data_container.data_inputs, data_container.expected_outputs))
data_container.set_expected_outputs(expected_outputs=None)
return new_self
def handle_transform(self, data_container: DataContainer,
context: ExecutionContext) -> DataContainer:
new_expected_outputs_data_container = self.wrapped.handle_transform(
DataContainer(current_ids=data_container.current_ids,
data_inputs=data_container.expected_outputs,
expected_outputs=None), context.push(self.wrapped))
data_container.set_expected_outputs(
new_expected_outputs_data_container.data_inputs)
current_ids = self.hash(data_container)
data_container.set_current_ids(current_ids)
return data_container
def _transform_data_container(self, data_container: DataContainer, context: ExecutionContext) -> DataContainer:
"""
Handle inverse transform by updating the data inputs, and expected outputs inside the data container.
:param context: execution context
:param data_container:
:return:
"""
di_eo = (data_container.data_inputs, data_container.expected_outputs)
new_data_inputs, new_expected_outputs = self.transform(di_eo)
data_container.set_data_inputs(new_data_inputs)
data_container.set_expected_outputs(new_expected_outputs)
return data_container
def _did_process(self, data_container: DataContainer, context: ExecutionContext) -> DataContainer:
di, eo = data_container.data_inputs
if len(di) != len(eo):
raise AssertionError(
'{}: Found different len for data inputs, and expected outputs. Please return the same the same amount of data inputs, and expected outputs, or otherwise create your own handler methods to do more funky things.'.format(
self.name))
data_container.set_data_inputs(data_inputs=di)
data_container.set_expected_outputs(expected_outputs=eo)
data_container = super()._did_process(data_container, context)
if len(data_container.current_ids) != len(data_container.data_inputs):
raise AssertionError(
'{}: Caching broken because there is a different len of current ids, and data inputs. Please use InputAndOutputTransformerWrapper if you plan to change the len of the data inputs.'.format(
self.name))
return data_container
def _fit_transform_data_container(self, data_container: DataContainer, context: ExecutionContext) -> (
BaseStep, DataContainer):
"""
Handle fit transform by passing expected outputs to the wrapped step fit method.
Update the expected outputs with the outputs.
:param context: execution context
:type context: ExecutionContext
:param data_container: data container to fit on
:return: self, data container
:rtype: (BaseStep, DataContainer)
"""
self.wrapped, new_expected_outputs_data_container = self.wrapped.handle_fit_transform(
DataContainer(data_inputs=data_container.expected_outputs, current_ids=data_container.current_ids,
expected_outputs=None),
context
)
data_container.set_expected_outputs(new_expected_outputs_data_container.data_inputs)
return self, data_container
def handle_fit_transform(
self, data_container: DataContainer,
context: ExecutionContext) -> ('BaseStep', DataContainer):
"""
Handle transform by fitting the step,
and updating the data inputs, and expected outputs inside the data container.
:param context: execution context
:param data_container:
:return:
"""
new_self, (new_data_inputs, new_expected_outputs) = \
self.fit_transform((data_container.data_inputs, data_container.expected_outputs), None)
data_container.set_data_inputs(new_data_inputs)
data_container.set_expected_outputs(new_expected_outputs)
current_ids = self.hash(data_container)
data_container.set_current_ids(current_ids)
return new_self, data_container
def _fit_data_container(
self, data_container: DataContainer,
context: ExecutionContext) -> (BaseStep, DataContainer):
"""
Handle fit by passing the data inputs, and the expected outputs to the wrapped step fit method.
:param context: execution context
:type context: ExecutionContext
:param data_container: data container to fit on
:return: self, data container
:rtype: (BaseStep, DataContainer)
"""
self.wrapped = self.wrapped.handle_fit(
DataContainer(data_inputs=(copy.copy(data_container.data_inputs),
copy.copy(
data_container.expected_outputs)),
current_ids=data_container.current_ids,
expected_outputs=None), context)
data_container.set_data_inputs(
(data_container.data_inputs, data_container.expected_outputs))
data_container.set_expected_outputs(expected_outputs=None)
return self
