def __init__(self, **kwargs):
self._logging = watexlog().get_watex_logger(self.__class__.__name__)
for key in list(kwargs.keys()):
setattr(self, key, kwargs[key])
if hasattr(self, '_givenATTR'):
self._findFeaturePerSite_()
def reset_matplotlib():
interactive = matplotlib.rcParams['interactive']
backend = matplotlib.rcParams['backend']
matplotlib.rcdefaults() # reset the rcparams to default
matplotlib.rcParams['backend'] = backend
matplotlib.rcParams['interactive'] = interactive
logger = watexlog().get_watex_logger(__name__)
logger.info("Testing using matplotlib backend {}".format(
matplotlib.rcParams['backend']))
def __init__(self, df=None, data_fn = None , **kwargs):
self._logging =watexlog().get_watex_logger(self.__class__.__name__)
self._df =df
self._data_fn = data_fn
self.fig_num= kwargs.pop('fig_num', 1)
self.fig_size = kwargs.pop('fig_size', [12,6])
self.fig_dpi =kwargs.pop('fig_dpi', 300)
self.savefig = kwargs.pop('savefig', None)
self.fig_legend= kwargs.pop('fig_legend_kws', None)
self.fig_orientation =kwargs.pop('fig_orientation','landscape')
self.fig_title =kwargs.pop('title', None)
self.x_minorticks=kwargs.pop('xminorticks', 1)
self.y_minorticks =kwargs.pop('yminorticks', 1)
self.font_size =kwargs.pop('font_size',3.)
self.font_style=kwargs.pop('font_style', 'italic')
self.fs =kwargs.pop('fs', 2.)
self.mstyle =kwargs.pop('maker_style', 'o')
self.ms =kwargs.pop('ms', 3)
# self.mplfont =kwargs.pop('font','cursive')
self.markerfacecolor=kwargs.pop('markefacecolor', 'r')
self.markeredgecolor=kwargs.pop('markeredgecolor', 'gray')
self.lc = kwargs.pop('color', 'k')
self.font_weight =kwargs.pop('font_weight', 'bold')
self.ls= kwargs.pop('ls', '-')
self.lw =kwargs.pop('lw', 1.5)
self.alpha = kwargs.pop('alpha', 0.5)
self.stacked = kwargs.pop('stacked', False)
self.bins = kwargs.pop('bins', 10)
self.xlim =kwargs.pop('xlim', None )
self.ylim=kwargs.pop('y_lim', None)
self.sns_orient =kwargs.pop('orient', 'v')
self.sns_height =kwargs.pop ('sns_height', 4.)
self.sns_aspect =kwargs.pop ('sns_aspect', .7)
self.xlabel=kwargs.pop('xlabel', None)
self.ylabel=kwargs.pop('ylabel', None)
for key in kwargs.keys():
setattr(self, key, kwargs[key])
if self._data_fn is not None:
self.data_fn = self._data_fn
def __init__(self, data_fn =None , df=None , **kwargs)->None :
self._logging = watexlog().get_watex_logger(self.__class__.__name__)
self._data_fn = data_fn
self._df =df
self.categorial_features =kwargs.pop('categorial_features', None)
self.numerical_features =kwargs.pop('numerical_features', None)
self.target =kwargs.pop('target', 'flow')
self._drop_features = kwargs.pop('drop_features', ['lwi'])
self.random_state = kwargs.pop('random_state', 0)
self.default_estimator = kwargs.pop('default_estimator', 'svc')
self._df_cache =None
self._features = None
self.y = None
self.X = None
self.X_train =None
self.X_test = None
self.y_train =None
self.y_test =None
self._num_column_selector = make_column_selector(
dtype_include=np.number)
self._cat_colum_selector =make_column_selector(
dtype_exclude=np.number)
self._features_engineering =PolynomialFeatures(
10, include_bias=False)
self._selectors= SelectKBest(f_classif, k=4)
self._scalers =RobustScaler()
self._encodages =OneHotEncoder()
self._select_estimator_ =None
for key in kwargs.keys():
setattr(self, key, kwargs[key])
if self._data_fn is not None:
self.data_fn = self._data_fn
if self.df is not None :
self._read_and_encode_catFeatures()
def __init__(self,
listOferpfn=None,
listOfposMinMax=None,
erpObjs=None,
**kws):
self._logging = watexlog().get_watex_logger(self.__class__.__name__)
self.erpObjs = erpObjs
self.anomBoundariesObj = listOfposMinMax
self.dipoleLengthObjs = kws.pop('list_of_dipole_lengths', None)
self.export_data = kws.pop('export_erpFeatures', False)
self.export_fex = kws.pop('file_extension', 'csv')
self.listOferpfn = listOferpfn
self.id = None
for key in list(kws.keys()):
setattr(self, key, kws[key])
self._readErpObjs()
def __init__(self, df=None, data_fn=None, **kws):
self._logging = watexlog().get_watex_logger(self.__class__.__name__)
self.data_fn = data_fn
self._df = df
self._target = kws.pop('target', 'flow')
self._set_index = kws.pop('set_index', False)
self._flow_classes = kws.pop('flow_classes', None)
self._slmethod = kws.pop('slm', 'svm')
self._sanitize_df = kws.pop('sanitize_df', True)
self._drop_columns = kws.pop('drop_columns', ['east', 'north'])
self._fn = None
for key in list(kws.keys()):
setattr(self, key, kws[key])
if self.data_fn is not None or self._df is not None:
self._dropandFlow_classifier()
import warnings
from sklearn.tree import DecisionTreeClassifier
from sklearn.linear_model import SGDClassifier
from sklearn.neighbors import KNeighborsClassifier
from sklearn.svm import SVC
from watex.utils._watexlog import watexlog
_HAS_ENSEMBLE_ = False
try:
from sklearn.ensemble import RandomForestClassifier, AdaBoostClassifier
from sklearn.ensemble import VotingClassifier, BaggingClassifier, StackingClassifier
except:
warnings.warn('Trying importation of :mod:`sklearn.ensemble` failed. ')
watexlog().get_watex_logger(__name__).debug(
'Try to import :mod:`sklearn.ensemble` failed!')
else:
skl_ensemble__ = [
RandomForestClassifier, AdaBoostClassifier, VotingClassifier,
BaggingClassifier, StackingClassifier
]
_HAS_ENSEMBLE_ = True
from sklearn.model_selection import RandomizedSearchCV, GridSearchCV
from sklearn.model_selection import train_test_split
from sklearn.model_selection import GroupKFold
from sklearn.model_selection import learning_curve
from sklearn.metrics import confusion_matrix, f1_score, classification_report
from sklearn.feature_selection import SelectKBest, f_classif
from watex.analysis.features import sl_analysis
from watex.viewer.plot import hints
import watex.utils.exceptions as Wex
from watex.utils._watexlog import watexlog
_logger =watexlog().get_watex_logger(__name__)
d_estimators__={'dtc':DecisionTreeClassifier,
'svc':SVC,
'sgd':SGDClassifier,
'knn':KNeighborsClassifier
}
if _HAS_ENSEMBLE_ :
from watex.processing.__init__ import skl_ensemble__
for es_, esf_ in zip(['rdf', 'ada', 'vtc', 'bag','stc'], skl_ensemble__):
d_estimators__[es_]=esf_
class Preprocessing :
SUCCESS_IMPORT_CHART_STUDIO = True
else:
# updating chart_studio
try:
chart_studio_version = [
int(ss) for ss in chart_studio.__version__.split('.')
]
if chart_studio_version[0] == 1:
if chart_studio_version[1] < 1:
warnings.warn(
'Note: need chart_studio version 1.1.0 or higher to write '
' to plot some analyses figures propertly.', ImportWarning)
watexlog().get_watex_logger().warning(
'Note: need chart_studio version 1.14.0 to plot '
' component analysis figures or might not work properly.')
else:
msg = 'Plot chart is currently able to run.'
watexlog().get_watex_logger().info(''.join(
[msg, 'Chart_studio was successfully imported !']))
except:
watexlog().get_watex_logger().debug(
'Trouble occurs during searching of chart_studio version 1.14.0 to '
' to collect the updating version. Default version will be use for'
' chart plot.')
else:
def __init__(self, geofn=None, **kwargs) -> None:
self._logging = watexlog().get_watex_logger(self.__class__.__name__)
pass
