def __init__(self, adaptee: Hypergrid):
HypergridAdapter.__init__(self,
name=adaptee.name,
random_state=adaptee.random_state)
self._adaptee: Hypergrid = adaptee
self._target: SimpleHypergrid = None
self._forward_name_mapping = dict()
self._backward_name_mapping = dict()
if HypergridAdapter.is_like_simple_hypergrid(self._adaptee):
# Need to flatten all the names
target_dimensions = []
for adaptee_dimension in self._adaptee.dimensions:
target_dimension_name = Dimension.flatten_dimension_name(
adaptee_dimension.name)
self._forward_name_mapping[
adaptee_dimension.name] = target_dimension_name
self._backward_name_mapping[
target_dimension_name] = adaptee_dimension.name
target_dimension = adaptee_dimension.copy()
target_dimension.name = target_dimension_name
target_dimensions.append(target_dimension)
self._target = SimpleHypergrid(name=self._adaptee.name,
dimensions=target_dimensions)
else:
raise TypeError(
f"Cannot build CompositeToSImpleHypergridAdapter for object of type {type(self._adaptee)}."
)
def __init__(self, adaptee: Hypergrid):
if not HypergridAdapter.is_like_simple_hypergrid(adaptee):
raise ValueError("Adaptee must implement a Hypergrid Interface.")
HypergridAdapter.__init__(self,
name=adaptee.name,
random_state=adaptee.random_state)
self._adaptee: Hypergrid = adaptee
self._target: Hypergrid = None
# Forward mapping:
# Key: adaptee dimension name
# Value: target dimension
#
self._adaptee_to_target_dimension_mappings = dict()
# Reverse mapping:
# Key: target dimension name
# Value: adaptee dimension
self._target_to_adaptee_dimension_mappings = dict()
if any(
isinstance(dimension, CategoricalDimension)
for dimension in self._adaptee.dimensions):
self._adaptee = CategoricalToDiscreteHypergridAdapter(
adaptee=self._adaptee)
# Now we need to build the target hypergrid and the mappings between adaptee and target.
self._build_simple_hypergrid_target()
def __init__(self, adaptee: Hypergrid):
if not HypergridAdapter.is_like_simple_hypergrid(adaptee):
raise ValueError("Adaptee must implement a Hypergrid Interface.")
HypergridAdapter.__init__(self,
name=adaptee.name,
random_state=adaptee.random_state)
self._adaptee: Hypergrid = adaptee
self._target: Hypergrid = None
# Forward mapping:
# Key: dimension name
# Value: a dictionary mapping adaptee values to target values
#
self._adaptee_to_target_dimension_mappings = dict()
# Reverse mapping:
# Key: dimension name
# Value: a dictionary mapping target values to adaptee values
self._target_to_adaptee_dimension_mappings = dict()
if self._adaptee.is_hierarchical():
self._adaptee = HierarchicalToFlatHypergridAdapter(
adaptee=self._adaptee)
# Now we need to build the target hypergrid and the mappings between adaptee and target.
self._build_simple_hypergrid_target()
def __init__(self,
adaptee: Hypergrid,
degree: int = 2,
include_bias: bool = True,
interaction_only: bool = False):
if not HypergridAdapter.is_like_simple_hypergrid(adaptee):
raise ValueError("Adaptee must implement a Hypergrid Interface.")
HypergridAdapter.__init__(self,
name=adaptee.name,
random_state=adaptee.random_state)
self._adaptee: Hypergrid = adaptee
self._polynomial_features_kwargs = {
'degree': degree,
'interaction_only': interaction_only,
'include_bias': include_bias,
'order': 'C'
}
self._target: Hypergrid = None
if self._adaptee.is_hierarchical():
self._adaptee = HierarchicalToFlatHypergridAdapter(
adaptee=self._adaptee)
# Record which adaptee dimensions are continuous
self._adaptee_contains_dimensions_to_transform = False
self._adaptee_dimension_names_to_transform = []
for adaptee_dimension in self._adaptee.dimensions:
if isinstance(adaptee_dimension, ContinuousDimension):
self._adaptee_dimension_names_to_transform.append(
adaptee_dimension.name)
self._num_dimensions_to_transform = len(
self._adaptee_dimension_names_to_transform)
self._adaptee_contains_dimensions_to_transform = self._num_dimensions_to_transform > 0
# see definition of _get_polynomial_feature_names() for usage
self._internal_feature_name_terminal_char = '_'
# Since sklearn PolynomialFeatures does not accept NaNs and these may appear in data frames from hierarchical hypergrids,
# the NaNs will be replaced with an imputed (finite) value. The following sets the value used.
self._nan_imputed_finite_value = 0
# instantiate sklearn's polynomial features instance
self._polynomial_features = PolynomialFeatures(
**self._polynomial_features_kwargs)
# because the exact number of additional dimensions that will be added depends on the parameters to sklearn's PF,
# *and* the sklearn PF instance above doesn't determine this information until after the .fit() method is called (requiring a dataframe),
# *and* the target hypergrid can not be constructed without knowing the resulting number of continuous dimensions,
# a trivial dataframe is constructed (all 1s) and .fit_transform() of _polynomial_features instance is called.
trivial_continuous_dim_x = np.ones(
(1, self._num_dimensions_to_transform))
trivial_polynomial_features_y = self._polynomial_features.fit_transform(
trivial_continuous_dim_x)
self._polynomial_features_powers = self._polynomial_features.powers_
self._num_polynomial_basis_dimensions_in_target = trivial_polynomial_features_y.shape[
1]
self._target_polynomial_feature_map = {
} # keys are target dimension names, values are index in features
self._build_simple_hypergrid_target()
def __init__(self,
adaptee: Hypergrid,
merge_all_categorical_dimensions: bool = False,
drop: str = None):
if not HypergridAdapter.is_like_simple_hypergrid(adaptee):
raise ValueError("Adaptee must implement a Hypergrid Interface.")
HypergridAdapter.__init__(self,
name=adaptee.name,
random_state=adaptee.random_state)
self._adaptee: Hypergrid = adaptee
self._merge_all_categorical_dimensions = merge_all_categorical_dimensions
self._one_hot_encoder_kwargs = {
'drop': drop,
'dtype': np.float64,
'sparse': False,
'handle_unknown': 'error'
}
self._all_one_hot_encoded_target_dimension_names = []
self._adaptee_to_target_data_dict: Dict[
str, CategoricalToOneHotEncodingAdapteeTargetMapping] = {}
self._adaptee_expected_dimension_name_ordering = []
self._concatenation_delim = '___'
self._merged_categorical_dimension_column_name = 'ohe_cross_product'
self.ohe_target_column_suffix = '__ohe'
self._target: Hypergrid = None
self.has_adaptee_been_flattened = False
# Since CategoricalDimension values may have different types within the same dimension,
# we pass the adaptee through the CategoricalToDiscrete adapter to move all value types to ints
# Because the OneHotEncoder needs to remember the dimension names (which change by the flattening in CategoricalToDiscrete),
# the flattening is performed here so the OneHotEncoder discovers the correct flattened column names
if self._adaptee.is_hierarchical():
self._adaptee = HierarchicalToFlatHypergridAdapter(
adaptee=self._adaptee)
self.has_adaptee_been_flattened = True
# Since the CategoricalToDiscrete adapter converts categorical dimensions to discrete dimensions, we remember the categorical dim names
self._adaptee_contains_categorical_dimensions = False
self._adaptee_dimension_names_to_transform = []
for adaptee_dimension in self._adaptee.dimensions:
if isinstance(adaptee_dimension, CategoricalDimension):
self._adaptee_dimension_names_to_transform.append(
adaptee_dimension.name)
self._adaptee_expected_dimension_name_ordering.append(
adaptee_dimension.name)
self._adaptee_contains_categorical_dimensions = len(
self._adaptee_dimension_names_to_transform) > 0
# since sklearn OneHotEncoder doesn't accept strings, convert any categorical dimensions to discrete
if any(
isinstance(dimension, CategoricalDimension) for dimension in
self._adaptee.dimensions) or self.has_adaptee_been_flattened:
self._adaptee = CategoricalToDiscreteHypergridAdapter(
adaptee=self._adaptee)
self._build_simple_hypergrid_target()
def __init__(self, adaptee: Hypergrid):
HypergridAdapter.__init__(self, name=adaptee.name, random_state=adaptee.random_state)
self._adaptee: Hypergrid = adaptee
self._target: Hypergrid = None
# Forward mapping:
# Key: dimension name
# Value: a dictionary mapping adaptee values to target values
#
self._adaptee_to_target_dimension_mappings = dict()
# Reverse mapping:
# Key: dimension name
# Value: a dictionary mapping target values to adaptee values
self._target_to_adaptee_dimension_mappings = dict()
# Now we need to build the target hypergrid and the mappings between adaptee and target.
if HypergridAdapter.is_like_simple_hypergrid(adaptee) and not adaptee.is_hierarchical():
self._build_simple_hypergrid_target()
else:
raise NotImplementedError("First apply the HierarchicalToFlatHypergridAdapter and chain it with this one.")