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.")