-
Notifications
You must be signed in to change notification settings - Fork 284
/
tabular_feature_validator.py
518 lines (437 loc) · 20.7 KB
/
tabular_feature_validator.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
import functools
from typing import Dict, List, Optional, Tuple, cast
import numpy as np
import pandas as pd
from pandas.api.types import is_numeric_dtype
import scipy.sparse
import sklearn.utils
from sklearn import preprocessing
from sklearn.base import BaseEstimator
from sklearn.compose import ColumnTransformer
from sklearn.exceptions import NotFittedError
from sklearn.impute import SimpleImputer
from sklearn.pipeline import make_pipeline
from autoPyTorch.data.base_feature_validator import BaseFeatureValidator, SUPPORTED_FEAT_TYPES
def _create_column_transformer(
preprocessors: Dict[str, List[BaseEstimator]],
categorical_columns: List[str],
) -> ColumnTransformer:
"""
Given a dictionary of preprocessors, this function
creates a sklearn column transformer with appropriate
columns associated with their preprocessors.
Args:
preprocessors (Dict[str, List[BaseEstimator]]):
Dictionary containing list of numerical and categorical preprocessors.
categorical_columns (List[str]):
List of names of categorical columns
Returns:
ColumnTransformer
"""
categorical_pipeline = make_pipeline(*preprocessors['categorical'])
return ColumnTransformer([
('categorical_pipeline', categorical_pipeline, categorical_columns)],
remainder='passthrough'
)
def get_tabular_preprocessors() -> Dict[str, List[BaseEstimator]]:
"""
This function creates a Dictionary containing a list
of numerical and categorical preprocessors
Returns:
Dict[str, List[BaseEstimator]]
"""
preprocessors: Dict[str, List[BaseEstimator]] = dict()
# Categorical Preprocessors
onehot_encoder = preprocessing.OrdinalEncoder(handle_unknown='use_encoded_value',
unknown_value=-1)
categorical_imputer = SimpleImputer(strategy='constant', copy=False)
preprocessors['categorical'] = [categorical_imputer, onehot_encoder]
return preprocessors
class TabularFeatureValidator(BaseFeatureValidator):
"""
A subclass of `BaseFeatureValidator` made for tabular data.
It ensures that the dataset provided is of the expected format.
Subsequently, it preprocesses the data by fitting a column
transformer.
Attributes:
categories (List[List[str]]):
List for which an element at each index is a
list containing the categories for the respective
categorical column.
transformed_columns (List[str])
List of columns that were transformed.
column_transformer (Optional[BaseEstimator])
Hosts an imputer and an encoder object if the data
requires transformation (for example, if provided a
categorical column in a pandas DataFrame)
column_order (List[str]):
List of the features stored in the order that
was fitted.
numerical_columns (List[int]):
List of indices of numerical columns
categorical_columns (List[int]):
List of indices of categorical columns
"""
@staticmethod
def _comparator(cmp1: str, cmp2: str) -> int:
"""Order so that categorical columns come left and numerical columns come right
Args:
cmp1 (str): First variable to compare
cmp2 (str): Second variable to compare
Raises:
ValueError: if the values of the variables to compare
are not in 'categorical' or 'numerical'
Returns:
int: either [0, -1, 1]
"""
choices = ['categorical', 'numerical']
if cmp1 not in choices or cmp2 not in choices:
raise ValueError('The comparator for the column order only accepts {}, '
'but got {} and {}'.format(choices, cmp1, cmp2))
idx1, idx2 = choices.index(cmp1), choices.index(cmp2)
return idx1 - idx2
def _fit(
self,
X: SUPPORTED_FEAT_TYPES,
) -> BaseEstimator:
"""
In case input data is a pandas DataFrame, this utility encodes the user provided
features (from categorical for example) to a numerical value that further stages
will be able to use
Args:
X (SUPPORTED_FEAT_TYPES):
A set of features that are going to be validated (type and dimensionality
checks) and an encoder fitted in the case the data needs encoding
Returns:
self:
The fitted base estimator
"""
# The final output of a validator is a numpy array. But pandas
# gives us information about the column dtype
if isinstance(X, np.ndarray):
X = self.numpy_array_to_pandas(X)
if hasattr(X, "iloc") and not scipy.sparse.issparse(X):
X = cast(pd.DataFrame, X)
# Treat a column with all instances a NaN as numerical
# This will prevent doing encoding to a categorical column made completely
# out of nan values -- which will trigger a fail, as encoding is not supported
# with nan values.
# Columns that are completely made of NaN values are provided to the pipeline
# so that later stages decide how to handle them
if np.any(pd.isnull(X)):
for column in X.columns:
if X[column].isna().all():
X[column] = pd.to_numeric(X[column])
# Also note this change in self.dtypes
if len(self.dtypes) != 0:
self.dtypes[list(X.columns).index(column)] = X[column].dtype
if not X.select_dtypes(include='object').empty:
X = self.infer_objects(X)
self.transformed_columns, self.feat_type = self._get_columns_to_encode(X)
assert self.feat_type is not None
if len(self.transformed_columns) > 0:
preprocessors = get_tabular_preprocessors()
self.column_transformer = _create_column_transformer(
preprocessors=preprocessors,
categorical_columns=self.transformed_columns,
)
# Mypy redefinition
assert self.column_transformer is not None
self.column_transformer.fit(X)
# The column transformer reorders the feature types
# therefore, we need to change the order of columns as well
# This means categorical columns are shifted to the left
self.feat_type = sorted(
self.feat_type,
key=functools.cmp_to_key(self._comparator)
)
encoded_categories = self.column_transformer.\
named_transformers_['categorical_pipeline'].\
named_steps['ordinalencoder'].categories_
self.categories = [
# We fit an ordinal encoder, where all categorical
# columns are shifted to the left
list(range(len(cat)))
for cat in encoded_categories
]
for i, type_ in enumerate(self.feat_type):
if 'numerical' in type_:
self.numerical_columns.append(i)
else:
self.categorical_columns.append(i)
# Lastly, store the number of features
self.num_features = np.shape(X)[1]
return self
def transform(
self,
X: SUPPORTED_FEAT_TYPES,
) -> np.ndarray:
"""
Validates and fit a categorical encoder (if needed) to the features.
The supported data types are List, numpy arrays and pandas DataFrames.
Args:
X_train (SUPPORTED_FEAT_TYPES):
A set of features, whose categorical features are going to be
transformed
Return:
np.ndarray:
The transformed array
"""
if not self._is_fitted:
raise NotFittedError("Cannot call transform on a validator that is not fitted")
# If a list was provided, it will be converted to pandas
if isinstance(X, list):
X, _ = self.list_to_dataframe(X)
if isinstance(X, np.ndarray):
X = self.numpy_array_to_pandas(X)
if hasattr(X, "iloc") and not scipy.sparse.issparse(X):
if np.any(pd.isnull(X)):
for column in X.columns:
if X[column].isna().all():
X[column] = pd.to_numeric(X[column])
# Also remove the object dtype for new data
if not X.select_dtypes(include='object').empty:
X = self.infer_objects(X)
# Check the data here so we catch problems on new test data
self._check_data(X)
# Pandas related transformations
if hasattr(X, "iloc") and self.column_transformer is not None:
if np.any(pd.isnull(X)):
# After above check it means that if there is a NaN
# the whole column must be NaN
# Make sure it is numerical and let the pipeline handle it
for column in X.columns:
if X[column].isna().all():
X[column] = pd.to_numeric(X[column])
X = self.column_transformer.transform(X)
# Sparse related transformations
# Not all sparse format support index sorting
if scipy.sparse.issparse(X) and hasattr(X, 'sort_indices'):
X.sort_indices()
try:
X = sklearn.utils.check_array(
X,
force_all_finite=False,
accept_sparse='csr'
)
except Exception as e:
self.logger.exception(f"Conversion failed for input {X.dtypes} {X}"
"This means AutoPyTorch was not able to properly "
"Extract the dtypes of the provided input features. "
"Please try to manually cast it to a supported "
"numerical or categorical values.")
raise e
return X
def _check_data(
self,
X: SUPPORTED_FEAT_TYPES,
) -> None:
"""
Feature dimensionality and data type checks
Args:
X (SUPPORTED_FEAT_TYPES):
A set of features that are going to be validated (type and dimensionality
checks) and an encoder fitted in the case the data needs encoding
"""
if not isinstance(X, (np.ndarray, pd.DataFrame)) and not scipy.sparse.issparse(X):
raise ValueError("AutoPyTorch only supports Numpy arrays, Pandas DataFrames,"
" scipy sparse and Python Lists, yet, the provided input is"
" of type {}".format(type(X))
)
if self.data_type is None:
self.data_type = type(X)
if self.data_type != type(X):
self.logger.warning("AutoPyTorch previously received features of type %s "
"yet the current features have type %s. Changing the dtype "
"of inputs to an estimator might cause problems" % (
str(self.data_type),
str(type(X)),
),
)
# Do not support category/string numpy data. Only numbers
if hasattr(X, "dtype"):
if not np.issubdtype(X.dtype.type, np.number): # type: ignore[union-attr]
raise ValueError(
"When providing a numpy array to AutoPyTorch, the only valid "
"dtypes are numerical ones. The provided data type {} is not supported."
"".format(
X.dtype.type, # type: ignore[union-attr]
)
)
# Then for Pandas, we do not support Nan in categorical columns
if hasattr(X, "iloc"):
# If entered here, we have a pandas dataframe
X = cast(pd.DataFrame, X)
# Handle objects if possible
if not X.select_dtypes(include='object').empty:
X = self.infer_objects(X)
# Define the column to be encoded here as the feature validator is fitted once
# per estimator
self.transformed_columns, self.feat_type = self._get_columns_to_encode(X)
column_order = [column for column in X.columns]
if len(self.column_order) > 0:
if self.column_order != column_order:
raise ValueError("Changing the column order of the features after fit() is "
"not supported. Fit() method was called with "
"{} whereas the new features have {} as type".format(self.column_order,
column_order,)
)
else:
self.column_order = column_order
dtypes = [dtype.name for dtype in X.dtypes]
if len(self.dtypes) > 0:
if self.dtypes != dtypes:
raise ValueError("Changing the dtype of the features after fit() is "
"not supported. Fit() method was called with "
"{} whereas the new features have {} as type".format(self.dtypes,
dtypes,
)
)
else:
self.dtypes = dtypes
def _get_columns_to_encode(
self,
X: pd.DataFrame,
) -> Tuple[List[str], List[str]]:
"""
Return the columns to be encoded from a pandas dataframe
Args:
X (pd.DataFrame)
A set of features that are going to be validated (type and dimensionality
checks) and an encoder fitted in the case the data needs encoding
Returns:
transformed_columns (List[str]):
Columns to encode, if any
feat_type:
Type of each column numerical/categorical
"""
if len(self.transformed_columns) > 0 and self.feat_type is not None:
return self.transformed_columns, self.feat_type
# Register if a column needs encoding
transformed_columns = []
# Also, register the feature types for the estimator
feat_type = []
# Make sure each column is a valid type
for i, column in enumerate(X.columns):
if X[column].dtype.name in ['category', 'bool']:
transformed_columns.append(column)
feat_type.append('categorical')
# Move away from np.issubdtype as it causes
# TypeError: data type not understood in certain pandas types
elif not is_numeric_dtype(X[column]):
if X[column].dtype.name == 'object':
raise ValueError(
"Input Column {} has invalid type object. "
"Cast it to a valid dtype before using it in AutoPyTorch. "
"Valid types are numerical, categorical or boolean. "
"You can cast it to a valid dtype using "
"pandas.Series.astype ."
"If working with string objects, the following "
"tutorial illustrates how to work with text data: "
"https://scikit-learn.org/stable/tutorial/text_analytics/working_with_text_data.html".format(
# noqa: E501
column,
)
)
elif pd.core.dtypes.common.is_datetime_or_timedelta_dtype(
X[column].dtype
):
raise ValueError(
"AutoPyTorch does not support time and/or date datatype as given "
"in column {}. Please convert the time information to a numerical value "
"first. One example on how to do this can be found on "
"https://stats.stackexchange.com/questions/311494/".format(
column,
)
)
else:
raise ValueError(
"Input Column {} has unsupported dtype {}. "
"Supported column types are categorical/bool/numerical dtypes. "
"Make sure your data is formatted in a correct way, "
"before feeding it to AutoPyTorch.".format(
column,
X[column].dtype.name,
)
)
else:
feat_type.append('numerical')
return transformed_columns, feat_type
def list_to_dataframe(
self,
X_train: SUPPORTED_FEAT_TYPES,
X_test: Optional[SUPPORTED_FEAT_TYPES] = None,
) -> Tuple[pd.DataFrame, Optional[pd.DataFrame]]:
"""
Converts a list to a pandas DataFrame. In this process, column types are inferred.
If test data is provided, we proactively match it to train data
Args:
X_train (SUPPORTED_FEAT_TYPES):
A set of features that are going to be validated (type and dimensionality
checks) and a encoder fitted in the case the data needs encoding
X_test (Optional[SUPPORTED_FEAT_TYPES]):
A hold out set of data used for checking
Returns:
pd.DataFrame:
transformed train data from list to pandas DataFrame
pd.DataFrame:
transformed test data from list to pandas DataFrame
"""
# If a list was provided, it will be converted to pandas
X_train = pd.DataFrame(data=X_train).infer_objects()
self.logger.warning("The provided feature types to AutoPyTorch are of type list."
"Features have been interpreted as: {}".format([(col, t) for col, t in
zip(X_train.columns, X_train.dtypes)]))
if X_test is not None:
if not isinstance(X_test, list):
self.logger.warning("Train features are a list while the provided test data"
"is {}. X_test will be casted as DataFrame.".format(type(X_test))
)
X_test = pd.DataFrame(data=X_test).infer_objects()
return X_train, X_test
def numpy_array_to_pandas(
self,
X: np.ndarray,
) -> pd.DataFrame:
"""
Converts a numpy array to pandas for type inference
Args:
X (np.ndarray):
data to be interpreted.
Returns:
pd.DataFrame
"""
return pd.DataFrame(X).infer_objects().convert_dtypes()
def infer_objects(self, X: pd.DataFrame) -> pd.DataFrame:
"""
In case the input contains object columns, their type is inferred if possible
This has to be done once, so the test and train data are treated equally
Args:
X (pd.DataFrame):
data to be interpreted.
Returns:
pd.DataFrame
"""
if hasattr(self, 'object_dtype_mapping'):
# Mypy does not process the has attr. This dict is defined below
for key, dtype in self.object_dtype_mapping.items(): # type: ignore[has-type]
if 'int' in dtype.name:
# In the case train data was interpreted as int
# and test data was interpreted as float, because of 0.0
# for example, honor training data
X[key] = X[key].applymap(np.int64)
else:
try:
X[key] = X[key].astype(dtype.name)
except Exception as e:
# Try inference if possible
self.logger.warning(f"Tried to cast column {key} to {dtype} caused {e}")
pass
else:
X = X.infer_objects()
for column in X.columns:
if not is_numeric_dtype(X[column]):
X[column] = X[column].astype('category')
self.object_dtype_mapping = {column: X[column].dtype for column in X.columns}
self.logger.debug(f"Infer Objects: {self.object_dtype_mapping}")
return X