- NaN values are then filled with last known values.
'''
- def __init__(self, config_file = None, dict_features = None, features = None):
+ def __init__(self, config_file = None,
+ dict_features = None, dict_target = None):
'''
Constructor that defines all needed attributes and collects features.
'''
- self._config = ConfigParser()
- self._config.read(config_file)
+ self._config = config_file
self._start = datetime.strptime(self._config['DATETIME']['start'],
'%m/%d/%Y %H:%M:%S')
self._timestep = timedelta(hours =
self._config['DATETIME'].getfloat('hourStep'))
self._dict_features = dict_features
+ self._dict_target = dict_target
+
self._full_dict = None
self._dataframe = None
self._datetimes = []
- # If features are not provided to the constructor, then we collect
- # any existing feature in the dictionary
- if features != None:
- self._features = features
- else:
- self._features = set(chain.from_iterable([tuple(u.keys())
+
+ self._features = set(chain.from_iterable([tuple(u.keys())
for u in [*dict_features.values()]]))
+
feature_files = Path.cwd() / 'config' / 'features'
self._features = {feat : {'numerical': False} for feat in self._features}
for feature_file in listdir(feature_files):
if config.has_option(section, 'numerical'):
self._features[section]['numerical'] = config[section].getboolean('numerical')
+ self._numerical_columns = [k for k in self._features if self._features[k]['type'] == 1
+ or (self._features[k]['type'] == 3 and self._features[k]['numerical'])]
+
+ self._categorical_columns = [k for k in self._features if self._features[k]['type'] == 2
+ or (self._features[k]['type'] == 3 and not self._features[k]['numerical'])]
+
@property
'''
logger.info("Filling NaN numerical values in the feature dataframe")
# We interpolate (linearly or with splines) only numerical columns
- numerical_columns = [k for k in self._features if self._features[k]['type'] == 1
- or (self._features[k]['type'] == 3 and self._features[k]['numerical'])]
# The interpolation
if self._config['PREPROCESSING']['fill_method'] == 'propagate':
- self._dataframe[numerical_columns] =\
- self._dataframe[numerical_columns].fillna(method='ffill')
+ self._dataframe[self._numerical_columns] =\
+ self._dataframe[self._numerical_columns].fillna(method='ffill')
elif self._config['PREPROCESSING']['fill_method'] == 'linear':
- self._dataframe[numerical_columns] =\
- self._dataframe[numerical_columns].interpolate()
+ self._dataframe[self._numerical_columns] =\
+ self._dataframe[self._numerical_columns].interpolate()
elif self._config['PREPROCESSING']['fill_method'] == 'spline':
- self._dataframe[numerical_columns] =\
- self._dataframe[numerical_columns].interpolate(method='spline',
+ self._dataframe[self._numerical_columns] =\
+ self._dataframe[self._numerical_columns].interpolate(method='spline',
order=self._config['PREPROCESSING'].getint('order'))
# For the categorical columns, NaN values are filled by duplicating
# the last known value (forward fill method)
logger.info("Filling NaN categorical values in the feature dataframe")
- categorical_columns = [k for k in self._features if self._features[k]['type'] == 2
- or (self._features[k]['type'] == 3 and not self._features[k]['numerical'])]
- self._dataframe[categorical_columns] =\
- self._dataframe[categorical_columns].fillna(method='ffill')
+ self._dataframe[self._categorical_columns] =\
+ self._dataframe[self._categorical_columns].fillna(method='ffill')
# Uncomment this line to fill NaN values at the beginning of the
# dataframe. This may not be a good idea, especially for features
# Dropping rows that are not related to our datetime window (start/
# step / end)
- self._dataframe = self._dataframe.drop([k.to_pydatetime()
- for k in self._dataframe.T
- if k not in self._datetimes])
+ logger.info("Dropping rows that are not related to our datetime window")
+ self._dataframe['datetime'] =\
+ self._dataframe.apply(lambda x: datetime(int(x.year), int(x.month), int(x.dayInMonth), int(x.hour)), axis=1)
+ self._dataframe['row_ok'] =\
+ self._dataframe.apply(lambda x:x.datetime in self._datetimes, axis=1)
+ self._dataframe = self._dataframe[self._dataframe['row_ok']]
+ self._dataframe = self._dataframe.drop(['datetime', 'row_ok'], axis=1)
+ logger.info("Rows dropped")
+
+
+ def _add_history(self):
+ '''
+ Integrating previous nb of interventions as features
+ '''
+ logger.info("Integrating previous nb of interventions as features")
+ nb_lines = self._config['HISTORY_KNOWLEDGE'].getint('nb_lines')
+ for k in range(1,nb_lines+1):
+ name = 'history_'+str(nb_lines-k+1)
+ self._dataframe[name] = [np.NaN]*k + list(self._dict_target.values())[:-k]
+ self._numerical_columns.append(name)
+ self._dataframe = self._dataframe[nb_lines:]
+
def _standardize(self):
'''
logger.info("Standardizing numerical values in the feature dataframe")
# We operate only on numerical columns
- numerical_columns = [k for k in self._features if self._features[k]['type'] == 1
- or (self._features[k]['type'] == 3 and self._features[k]['numerical'])]
- self._dataframe[numerical_columns] = preprocessing.scale(self._dataframe[numerical_columns])
+ self._dataframe[self._numerical_columns] =\
+ preprocessing.scale(self._dataframe[self._numerical_columns])
+
def _one_hot_encoding(self):
Apply a one hot encoding for category features
'''
logger.info("One hot encoding for categorical feature")
- categorical_columns = [k for k in self._features if self._features[k]['type'] == 2
- or (self._features[k]['type'] == 3 and not self._features[k]['numerical'])]
- # On fait un codage disjonctif complet des variables qualitatives
+ # We store numerical columns
df_out = pd.DataFrame()
- for col in categorical_columns:
+ for col in self._numerical_columns:
+ df_out[col] = self._dataframe[col]
+ # The one hot encoding
+ for col in self._categorical_columns:
pd1 = pd.get_dummies(self._dataframe[col],prefix=col)
for col1 in pd1.columns:
df_out[col1] = pd1[col1]
self._dataframe = df_out
- print(self._dataframe.head())
-
@property
orient='index')
# Dealing with NaN values
self._fill_nan()
+ # Adding previous (historical) nb_interventions as features
+ self._add_history()
# Normalizing numerical values
self._standardize()
# Dealing with categorical features
