diff --git a/multiview_platform/MonoMultiViewClassifiers/Monoview/Additions/SVCClassifier.py b/multiview_platform/MonoMultiViewClassifiers/Monoview/Additions/SVCClassifier.py new file mode 100644 index 0000000000000000000000000000000000000000..412d82ce02b251d78b60cad8c5a9a5703516fd73 --- /dev/null +++ b/multiview_platform/MonoMultiViewClassifiers/Monoview/Additions/SVCClassifier.py @@ -0,0 +1,24 @@ +from sklearn.svm import SVC + + +class SVCClassifier(SVC): + + def __init__(self, random_state=None, kernel='rbf', C=1.0, degree=3, **kwargs): + super(SVCClassifier, self).__init__( + C=C, + kernel=kernel, + degree=degree, + probability=True, + max_iter=1000, + random_state=random_state + ) + self.classed_params = None + self.weird_strings = {} + + def canProbas(self): + """Used to know if the classifier can return label probabilities""" + return True + + def getInterpret(self, directory): + interpretString = "" + return interpretString \ No newline at end of file diff --git a/multiview_platform/MonoMultiViewClassifiers/MonoviewClassifiers/Adaboost.py b/multiview_platform/MonoMultiViewClassifiers/MonoviewClassifiers/Adaboost.py index 6e47cd74f402f18bd812720ea5c62f95efef1c85..b8bb3703ef55d1b4d21ec2e1985c897757023b9e 100644 --- a/multiview_platform/MonoMultiViewClassifiers/MonoviewClassifiers/Adaboost.py +++ b/multiview_platform/MonoMultiViewClassifiers/MonoviewClassifiers/Adaboost.py @@ -46,65 +46,3 @@ def paramsToSet(nIter, random_state): paramsSet.append({"n_estimators": random_state.randint(1, 500), "base_estimator": None}) return paramsSet -# def canProbas(): -# return True -# -# -# def fit(DATASET, CLASS_LABELS, randomState, NB_CORES=1, **kwargs): -# """Used to fit the monoview classifier with the args stored in kwargs""" -# classifier = AdaBoostClassifier(n_estimators=kwargs['n_estimators'], -# base_estimator=kwargs['base_estimator'], -# random_state=randomState) -# classifier.fit(DATASET, CLASS_LABELS) -# return classifier -# -# -# def paramsToSet(nIter, randomState): -# """Used for weighted linear early fusion to generate random search sets""" -# paramsSet = [] -# for _ in range(nIter): -# paramsSet.append({"n_estimators": randomState.randint(1, 15), -# "base_estimator": DecisionTreeClassifier()}) -# return paramsSet -# -# -# def getKWARGS(args): -# """Used to format kwargs for the parsed args""" -# kwargsDict = {} -# kwargsDict['n_estimators'] = args.Ada_n_est -# kwargsDict['base_estimator'] = DecisionTreeClassifier() #args.Ada_b_est -# return kwargsDict -# -# -# def genPipeline(): -# return Pipeline([('classifier', AdaBoostClassifier())]) -# -# -# def genParamsDict(randomState): -# return {"classifier__n_estimators": np.arange(150)+1, -# "classifier__base_estimator": [DecisionTreeClassifier()]} -# -# -# def genBestParams(detector): -# return {"n_estimators": detector.best_params_["classifier__n_estimators"], -# "base_estimator": detector.best_params_["classifier__base_estimator"]} -# -# -# def genParamsFromDetector(detector): -# nIter = len(detector.cv_results_['param_classifier__n_estimators']) -# return [("baseEstimators", np.array(["DecisionTree" for _ in range(nIter)])), -# ("nEstimators", np.array(detector.cv_results_['param_classifier__n_estimators']))] -# -# -# def getConfig(config): -# if type(config) is not dict: # Used in late fusion when config is a classifier -# return "\n\t\t- Adaboost with num_esimators : " + str(config.n_estimators) + ", base_estimators : " + str( -# config.base_estimator) -# else: -# return "\n\t\t- Adaboost with n_estimators : " + str(config["n_estimators"]) + ", base_estimator : " + str( -# config["base_estimator"]) -# -# -# def getInterpret(classifier, directory): -# interpretString = getFeatureImportance(classifier, directory) -# return interpretString \ No newline at end of file diff --git a/multiview_platform/MonoMultiViewClassifiers/MonoviewClassifiers/DecisionTree.py b/multiview_platform/MonoMultiViewClassifiers/MonoviewClassifiers/DecisionTree.py index ac4f9bd5750b04b77dd50c6050fce8868ee92ed3..7373f6d0f3433791aaed811ef5ab1964225c0bbb 100644 --- a/multiview_platform/MonoMultiViewClassifiers/MonoviewClassifiers/DecisionTree.py +++ b/multiview_platform/MonoMultiViewClassifiers/MonoviewClassifiers/DecisionTree.py @@ -1,28 +1,45 @@ -from sklearn import tree -from sklearn.pipeline import Pipeline # Pipelining in classification -from sklearn.model_selection import RandomizedSearchCV -from scipy.stats import randint -import numpy as np -# import graphviz -# import cPickle +from sklearn.tree import DecisionTreeClassifier -from .. import Metrics -from ..utils.HyperParameterSearch import genHeatMaps +from ..Monoview.MonoviewUtils import CustomRandint, BaseMonoviewClassifier # Author-Info __author__ = "Baptiste Bauvin" __status__ = "Prototype" # Production, Development, Prototype -def canProbas(): - return True - - -def fit(DATASET, CLASS_LABELS, randomState, NB_CORES=1, **kwargs): - classifier = tree.DecisionTreeClassifier(max_depth=kwargs['max_depth'], criterion=kwargs['criterion'], - splitter=kwargs['splitter'], random_state=randomState) - classifier.fit(DATASET, CLASS_LABELS) - return classifier +class DecisionTree(DecisionTreeClassifier, BaseMonoviewClassifier): + + def __init__(self, random_state=None, max_depth=None, + criterion='gini', splitter='best', **kwargs): + super(DecisionTree, self).__init__( + max_depth=max_depth, + criterion=criterion, + splitter=splitter, + random_state=random_state + ) + self.param_names = ["max_depth", "criterion", "splitter",] + self.classed_params = None + self.distribs = [CustomRandint(low=1, high=300), + ["gini", "entropy"], + ["best", "random"], ] + self.weird_strings = {} + + def canProbas(self): + """Used to know if the classifier can return label probabilities""" + return True + + def getInterpret(self, directory): + interpretString = "" + interpretString += self.getFeatureImportance(directory) + return interpretString + + +def formatCmdArgs(args): + """Used to format kwargs for the parsed args""" + kwargsDict = {"max_depth": args.DT_depth, + "criterion": args.DT_criterion, + "splitter": args.DT_splitter} + return kwargsDict def paramsToSet(nIter, randomState): @@ -31,47 +48,4 @@ def paramsToSet(nIter, randomState): paramsSet.append({"max_depth": randomState.randint(1, 300), "criterion": randomState.choice(["gini", "entropy"]), "splitter": randomState.choice(["best", "random"])}) - return paramsSet - - -def getKWARGS(args): - kwargsDict = {"max_depth": args.DT_depth, "criterion": args.DT_criterion, "splitter": args.DT_splitter} - return kwargsDict - - -def genPipeline(): - return Pipeline([('classifier', tree.DecisionTreeClassifier())]) - - -def genParamsDict(randomState): - return {"classifier__max_depth": np.arange(1, 300), - "classifier__criterion": ["gini", "entropy"], - "classifier__splitter": ["best", "random"]} - - -def genBestParams(detector): - return {"max_depth": detector.best_params_["classifier__max_depth"], - "criterion": detector.best_params_["classifier__criterion"], - "splitter": detector.best_params_["classifier__splitter"]} - - -def genParamsFromDetector(detector): - return [("maxDepth", np.array(detector.cv_results_['param_classifier__max_depth'])), - ("criterion", np.array(detector.cv_results_['param_classifier__criterion'])), - ("splitter", np.array(detector.cv_results_['param_classifier__splitter']))] - - -def getConfig(config): - if type(config) is not dict: - return "\n\t\t- Decision Tree with max_depth : " + str( - config.max_depth) + ", criterion : " + config.criterion + ", splitter : " + config.splitter - else: - return "\n\t\t- Decision Tree with max_depth : " + str(config["max_depth"]) + ", criterion : " + config[ - "criterion"] + ", splitter : " + config["splitter"] - -def getInterpret(classifier, directory): - dot_data = tree.export_graphviz(classifier, out_file=None) - # graph = graphviz.Source(dot_data) - # graph.render(directory+"-tree.pdf") - interpretString = getFeatureImportance(classifier, directory) - return interpretString \ No newline at end of file + return paramsSet \ No newline at end of file diff --git a/multiview_platform/MonoMultiViewClassifiers/MonoviewClassifiers/KNN.py b/multiview_platform/MonoMultiViewClassifiers/MonoviewClassifiers/KNN.py index d242580e28ea6b5c71963e9542571f391a9d6b0c..56378b3ab4b08b6cd4765d03294e3b85033239a9 100644 --- a/multiview_platform/MonoMultiViewClassifiers/MonoviewClassifiers/KNN.py +++ b/multiview_platform/MonoMultiViewClassifiers/MonoviewClassifiers/KNN.py @@ -1,82 +1,52 @@ from sklearn.neighbors import KNeighborsClassifier -from sklearn.pipeline import Pipeline # Pipelining in classification -from sklearn.model_selection import RandomizedSearchCV -from scipy.stats import randint -import numpy as np -from .. import Metrics -from ..utils.HyperParameterSearch import genHeatMaps +from ..Monoview.MonoviewUtils import CustomRandint, BaseMonoviewClassifier # Author-Info __author__ = "Baptiste Bauvin" __status__ = "Prototype" # Production, Development, Prototype -def canProbas(): - return True +class KNN(KNeighborsClassifier, BaseMonoviewClassifier): + def __init__(self, random_state=None, n_neighbors=50, + weights='uniform', algorithm='auto', p=2, **kwargs): + super(KNN, self).__init__( + n_neighbors=n_neighbors, + weights=weights, + algorithm=algorithm, + p=p + ) + self.param_names = ["n_neighbors", "weights", "algorithm", "p"] + self.classed_params = None + self.distribs = [CustomRandint(low=1, high=20), ["uniform", "distance"], + ["auto", "ball_tree", "kd_tree", "brute"], [1, 2]] + self.weird_strings = {} + self.random_state=random_state -def fit(DATASET, CLASS_LABELS, randomState, NB_CORES=1, **kwargs): - classifier = KNeighborsClassifier(n_neighbors=kwargs["n_neighbors"], - weights=kwargs["weights"], - algorithm=kwargs["algorithm"], - p=kwargs["p"], - n_jobs=NB_CORES, ) - classifier.fit(DATASET, CLASS_LABELS) - return classifier + def canProbas(self): + """Used to know if the classifier can return label probabilities""" + return True - -def paramsToSet(nIter, randomState): - paramsSet = [] - for _ in range(nIter): - paramsSet.append({"n_neighbors": randomState.randint(1, 20), - "weights": randomState.choice(["uniform", "distance"]), - "algorithm": randomState.choice(["auto", "ball_tree", "kd_tree", "brute"]), - "p": randomState.choice([1, 2])}) - return paramsSet + def getInterpret(self, directory): + interpretString = "" + return interpretString -def getKWARGS(args): +def formatCmdArgs(args): + """Used to format kwargs for the parsed args""" kwargsDict = {"n_neighbors": args.KNN_neigh, "weights":args.KNN_weights, "algorithm":args.KNN_algo, "p":args.KNN_p} return kwargsDict -def genPipeline(): - return Pipeline([('classifier', KNeighborsClassifier())]) - - -def genParamsDict(randomState): - return {"classifier__n_neighbors": np.arange(1, 20), - "classifier__weights": ["uniform", "distance"], - "classifier__algorithm": ["auto", "ball_tree", "kd_tree", "brute"], - "classifier__p": [1, 2]} - - -def genBestParams(detector): - return {"n_neighbors": detector.best_params_["classifier__n_neighbors"], - "weights": detector.best_params_["classifier__weights"], - "algorithm": detector.best_params_["classifier__algorithm"], - "p": detector.best_params_["classifier__p"]} - -def genParamsFromDetector(detector): - return [("nNeighbors", np.array(detector.cv_results_['param_classifier__n_neighbors'])), - ("weights", np.array(detector.cv_results_['param_classifier__weights'])), - ("algorithm", np.array(detector.cv_results_['param_classifier__algorithm'])), - ("p", np.array(detector.cv_results_['param_classifier__p']))] - - -def getConfig(config): - if type(config) not in [list, dict]: - return "\n\t\t- K nearest Neighbors with n_neighbors : " + str(config.n_neighbors) + \ - ", weights : " + config.weights + ", algorithm : " + config.algorithm + ", p : " + \ - str(config.p) - else: - return "\n\t\t- K nearest Neighbors with n_neighbors : " + str(config["n_neighbors"]) + \ - ", weights : " + config["weights"] + ", algorithm : " + config["algorithm"] + \ - ", p : " + str(config["p"]) - -def getInterpret(classifier, directory): - return "" \ No newline at end of file +def paramsToSet(nIter, randomState): + paramsSet = [] + for _ in range(nIter): + paramsSet.append({"n_neighbors": randomState.randint(1, 20), + "weights": randomState.choice(["uniform", "distance"]), + "algorithm": randomState.choice(["auto", "ball_tree", "kd_tree", "brute"]), + "p": randomState.choice([1, 2])}) + return paramsSet diff --git a/multiview_platform/MonoMultiViewClassifiers/MonoviewClassifiers/RandomForest.py b/multiview_platform/MonoMultiViewClassifiers/MonoviewClassifiers/RandomForest.py index a49b6113591b866e5df97f1670f383727deed2a6..31207df1feff32543e79fa8cf7fed6a57acbe235 100644 --- a/multiview_platform/MonoMultiViewClassifiers/MonoviewClassifiers/RandomForest.py +++ b/multiview_platform/MonoMultiViewClassifiers/MonoviewClassifiers/RandomForest.py @@ -1,74 +1,51 @@ from sklearn.ensemble import RandomForestClassifier -from sklearn.pipeline import Pipeline -from sklearn.model_selection import RandomizedSearchCV -from scipy.stats import randint -import numpy as np + +from ..Monoview.MonoviewUtils import CustomRandint, BaseMonoviewClassifier # Author-Info __author__ = "Baptiste Bauvin" __status__ = "Prototype" # Production, Development, Prototype -def canProbas(): - return True +class RandomForest(RandomForestClassifier, BaseMonoviewClassifier): + def __init__(self, random_state=None, n_estimators=None, + max_depth='gini', criterion='best', **kwargs): + super(RandomForest, self).__init__( + n_estimators=n_estimators, + max_depth=max_depth, + criterion=criterion, + random_state=random_state + ) + self.param_names = ["n_estimators", "max_depth", "criterion",] + self.classed_params = None + self.distribs = [CustomRandint(low=1, high=300), + CustomRandint(low=1, high=300), + ["gini", "entropy"], ] + self.weird_strings = {} -def fit(DATASET, CLASS_LABELS, randomState, NB_CORES=1, **kwargs): - classifier = RandomForestClassifier(n_estimators=kwargs['n_estimators'], - max_depth=kwargs['max_depth'], - criterion=kwargs['criterion'], - n_jobs=NB_CORES, random_state=randomState) - classifier.fit(DATASET, CLASS_LABELS) - return classifier + def canProbas(self): + """Used to know if the classifier can return label probabilities""" + return True - -def paramsToSet(nIter, randomState): - paramsSet = [] - for _ in range(nIter): - paramsSet.append({"n_estimators": randomState.randint(1, 300), - "max_depth": randomState.randint(1, 300), - "criterion": randomState.choice(["gini", "entropy"])}) - return paramsSet + def getInterpret(self, directory): + interpretString = "" + interpretString += self.getFeatureImportance(directory) + return interpretString -def getKWARGS(args): +def formatCmdArgs(args): + """Used to format kwargs for the parsed args""" kwargsDict = {"n_estimators": args.RF_trees, "max_depth": args.RF_max_depth, "criterion": args.RF_criterion} return kwargsDict -def genPipeline(): - return Pipeline([('classifier', RandomForestClassifier())]) - - -def genParamsDict(randomState): - return {"classifier__n_estimators": np.arange(1, 300), - "classifier__max_depth": np.arange(1, 300), - "classifier__criterion": ["gini", "entropy"]} - - -def genBestParams(detector): - return {"n_estimators": detector.best_params_["classifier__n_estimators"], - "max_depth": detector.best_params_["classifier__max_depth"], - "criterion": detector.best_params_["classifier__criterion"]} - - -def genParamsFromDetector(detector): - return [("nEstimators", np.array(detector.cv_results_['param_classifier__n_estimators'])), - ("maxDepth", np.array(detector.cv_results_['param_classifier__max_depth'])), - ("criterion", np.array(detector.cv_results_['param_classifier__criterion']))] - - -def getConfig(config): - if type(config) not in [list, dict]: - return "\n\t\t- Random Forest with num_esimators : " + str(config.n_estimators) + ", max_depth : " + str( - config.max_depth) + ", criterion : " + config.criterion - else: - return "\n\t\t- Random Forest with num_esimators : " + str(config["n_estimators"]) + \ - ", max_depth : " + str(config["max_depth"]) + ", criterion : " + config["criterion"] - - -def getInterpret(classifier, directory): - interpretString = getFeatureImportance(classifier, directory) - return interpretString +def paramsToSet(nIter, randomState): + paramsSet = [] + for _ in range(nIter): + paramsSet.append({"n_estimators": randomState.randint(1, 300), + "max_depth": randomState.randint(1, 300), + "criterion": randomState.choice(["gini", "entropy"])}) + return paramsSet diff --git a/multiview_platform/MonoMultiViewClassifiers/MonoviewClassifiers/SCM.py b/multiview_platform/MonoMultiViewClassifiers/MonoviewClassifiers/SCM.py index 28c09a132a7699acab4ef818019c6e39bf779b59..1047b53af0ecd163763cf09919a34ba8902d5aa6 100644 --- a/multiview_platform/MonoMultiViewClassifiers/MonoviewClassifiers/SCM.py +++ b/multiview_platform/MonoMultiViewClassifiers/MonoviewClassifiers/SCM.py @@ -1,20 +1,13 @@ -import numpy as np - +from sklearn.externals.six import iteritems from pyscm.scm import SetCoveringMachineClassifier as scm from sklearn.base import BaseEstimator, ClassifierMixin -from sklearn.pipeline import Pipeline -from sklearn.model_selection import RandomizedSearchCV -from sklearn.externals.six import iteritems -from scipy.stats import uniform, randint -from .. import Metrics -from ..utils.HyperParameterSearch import genHeatMaps +from ..Monoview.MonoviewUtils import CustomRandint, CustomUniform, BaseMonoviewClassifier # Author-Info __author__ = "Baptiste Bauvin" __status__ = "Prototype" # Production, Development, Prototype - class DecisionStumpSCMNew(BaseEstimator, ClassifierMixin): """docstring for SCM A hands on class of SCM using decision stump, built with sklearn format in order to use sklearn function on SCM like @@ -26,9 +19,9 @@ class DecisionStumpSCMNew(BaseEstimator, ClassifierMixin): self.p = p self.max_rules = max_rules self.random_state = random_state + self.clf = scm(model_type=self.model_type, max_rules=self.max_rules, p=self.p, random_state=self.random_state) def fit(self, X, y): - self.clf = scm(model_type=self.model_type, max_rules=self.max_rules, p=self.p, random_state=self.random_state) self.clf.fit(X=X, y=y) def predict(self, X): @@ -47,65 +40,44 @@ class DecisionStumpSCMNew(BaseEstimator, ClassifierMixin): return {"Binary_attributes": self.clf.model_.rules} -def canProbas(): - return False +class SCM(DecisionStumpSCMNew, BaseMonoviewClassifier): + def __init__(self, random_state=None, model_type=50, + max_rules=None, p=1.0, **kwargs): + super(SCM, self).__init__( + random_state=random_state, + model_type=model_type, + max_rules=max_rules, + p=p + ) + self.param_names = ["model_type", "max_rules", "p"] + self.distribs = [["conjunction", "disjunction"], + CustomRandint(low=1, high=15), + CustomUniform(loc=0, state=1)] + self.classed_params = None + self.weird_strings = {} -def fit(DATASET, CLASS_LABELS, randomState, NB_CORES=1, **kwargs): - classifier = DecisionStumpSCMNew(model_type=kwargs['model_type'], - max_rules=kwargs['max_rules'], - p=kwargs['p'], - random_state=randomState) - classifier.fit(DATASET, CLASS_LABELS) - return classifier + def canProbas(self): + """Used to know if the classifier can return label probabilities""" + return True - -def paramsToSet(nIter, randomState): - paramsSet = [] - for _ in range(nIter): - paramsSet.append({"model_type": randomState.choice(["conjunction", "disjunction"]), - "max_rules": randomState.randint(1, 15), - "p": randomState.random_sample()}) - return paramsSet + def getInterpret(self, directory): + interpretString = "Model used : " + str(self.clf.model_) + return interpretString -def getKWARGS(args): +def formatCmdArgs(args): + """Used to format kwargs for the parsed args""" kwargsDict = {"model_type": args.SCM_model_type, "p": args.SCM_p, "max_rules": args.SCM_max_rules} return kwargsDict -def genPipeline(): - return Pipeline([('classifier', DecisionStumpSCMNew())]) - - -def genParamsDict(randomState): - return {"classifier__model_type": ['conjunction', 'disjunction'], - "classifier__p": uniform(), - "classifier__max_rules": np.arange(1,30)} - - -def genBestParams(detector): - return {"model_type": detector.best_params_["classifier__model_type"], - "p": detector.best_params_["classifier__p"], - "max_rules": detector.best_params_["classifier__max_rules"]} - - -def genParamsFromDetector(detector): - return [("model_type", np.array(detector.cv_results_['param_classifier__model_type'])), - ("maxRules", np.array(detector.cv_results_['param_classifier__max_rules'])), - ("p", np.array(detector.cv_results_['param_classifier__p']))] - - -def getConfig(config): - if type(config) not in [list, dict]: - return "\n\t\t- SCM with model_type: " + config.model_type + ", max_rules : " + str(config.max_rules) +\ - ", p : " + str(config.p) - else: - return "\n\t\t- SCM with model_type: " + config["model_type"] + ", max_rules : " + str(config["max_rules"]) + ", p : " + \ - str(config["p"]) - - -def getInterpret(classifier, directory): - return "Model used : " + str(classifier.clf.model_) +def paramsToSet(nIter, randomState): + paramsSet = [] + for _ in range(nIter): + paramsSet.append({"model_type": randomState.choice(["conjunction", "disjunction"]), + "max_rules": randomState.randint(1, 15), + "p": randomState.random_sample()}) + return paramsSet diff --git a/multiview_platform/MonoMultiViewClassifiers/MonoviewClassifiers/SGD.py b/multiview_platform/MonoMultiViewClassifiers/MonoviewClassifiers/SGD.py index c208277599b5f3a6ecadcf77578ca007359e1f3c..9afcaea81b91380d54095fce079f2de88e7a2526 100644 --- a/multiview_platform/MonoMultiViewClassifiers/MonoviewClassifiers/SGD.py +++ b/multiview_platform/MonoMultiViewClassifiers/MonoviewClassifiers/SGD.py @@ -1,79 +1,50 @@ from sklearn.linear_model import SGDClassifier -from sklearn.pipeline import Pipeline # Pipelining in classification -from sklearn.model_selection import RandomizedSearchCV -from scipy.stats import uniform -import numpy as np -from .. import Metrics -from ..utils.HyperParameterSearch import genHeatMaps +from ..Monoview.MonoviewUtils import CustomUniform, BaseMonoviewClassifier # Author-Info __author__ = "Baptiste Bauvin" __status__ = "Prototype" # Production, Development, Prototype -def canProbas(): - return True +class SGD(SGDClassifier, BaseMonoviewClassifier): + def __init__(self, random_state=None, loss=None, + penalty='gini', alpha='best', **kwargs): + super(SGD, self).__init__( + loss=loss, + penalty=penalty, + alpha=alpha, + random_state=random_state + ) + self.param_names = ["loss", "penalty", "alpha",] + self.classed_params = None + self.distribs = [['log', 'modified_huber'], + ["l1", "l2", "elasticnet"], + CustomUniform(loc=0, state=1), ] + self.weird_strings = {} -def fit(DATASET, CLASS_LABELS, randomState, NB_CORES=1, **kwargs): - classifier = SGDClassifier(loss=kwargs['loss'], - penalty=kwargs['penalty'], - alpha=kwargs['alpha'], - random_state=randomState, n_jobs=NB_CORES) - classifier.fit(DATASET, CLASS_LABELS) - return classifier + def canProbas(self): + """Used to know if the classifier can return label probabilities""" + return True + def getInterpret(self, directory): + interpretString = "" + return interpretString -def paramsToSet(nIter, randomState): - paramsSet = [] - for _ in range(nIter): - paramsSet.append({"loss": randomState.choice(['log', 'modified_huber']), - "penalty": randomState.choice(["l1", "l2", "elasticnet"]), - "alpha": randomState.random_sample()}) - return paramsSet - -def getKWARGS(args): +def formatCmdArgs(args): + """Used to format kwargs for the parsed args""" kwargsDict = {"loss": args.SGD_loss, "penalty": args.SGD_penalty, "alpha": args.SGD_alpha} return kwargsDict -def genPipeline(): - return Pipeline([('classifier', SGDClassifier())]) - - -def genParamsDict(randomState): - losses = ['log', 'modified_huber'] - penalties = ["l1", "l2", "elasticnet"] - alphas = uniform() - return {"classifier__loss": losses, "classifier__penalty": penalties, - "classifier__alpha": alphas} - - -def genBestParams(detector): - return {"loss": detector.best_params_["classifier__loss"], - "penalty": detector.best_params_["classifier__penalty"], - "alpha": detector.best_params_["classifier__alpha"]} - - -def genParamsFromDetector(detector): - return [("loss", np.array(detector.cv_results_['param_classifier__loss'])), - ("penalty", np.array(detector.cv_results_['param_classifier__penalty'])), - ("aplha", np.array(detector.cv_results_['param_classifier__alpha']))] - - -def getConfig(config): - if type(config) not in [list, dict]: - return "\n\t\t- SGDClassifier with loss : " + config.loss + ", penalty : " + \ - config.penalty + ", alpha : " + str(config.alpha) - else: - return "\n\t\t- SGDClassifier with loss : " + config["loss"] + ", penalty : " + \ - config["penalty"] + ", alpha : " + str(config["alpha"]) - -def getInterpret(classifier, directory): - # TODO : coeffs - return "" -# \ No newline at end of file +def paramsToSet(nIter, randomState): + paramsSet = [] + for _ in range(nIter): + paramsSet.append({"loss": randomState.choice(['log', 'modified_huber']), + "penalty": randomState.choice(["l1", "l2", "elasticnet"]), + "alpha": randomState.random_sample()}) + return paramsSet \ No newline at end of file diff --git a/multiview_platform/MonoMultiViewClassifiers/MonoviewClassifiers/SVMLinear.py b/multiview_platform/MonoMultiViewClassifiers/MonoviewClassifiers/SVMLinear.py index 2517f5eb945b382e3d2acab53cc6f89a52a06eca..88e7d40bce8d5c085a4af70bf231dc48ac2464fe 100644 --- a/multiview_platform/MonoMultiViewClassifiers/MonoviewClassifiers/SVMLinear.py +++ b/multiview_platform/MonoMultiViewClassifiers/MonoviewClassifiers/SVMLinear.py @@ -1,26 +1,28 @@ -from sklearn.svm import SVC -from sklearn.pipeline import Pipeline # Pipelining in classification -from sklearn.model_selection import RandomizedSearchCV -from scipy.stats import randint -import numpy as np - -from .. import Metrics -from ..utils.HyperParameterSearch import genHeatMaps +from ..Monoview.Additions.SVCClassifier import SVCClassifier +from ..Monoview.MonoviewUtils import CustomUniform, BaseMonoviewClassifier # Author-Info __author__ = "Baptiste Bauvin" __status__ = "Prototype" # Production, Development, Prototype -def canProbas(): - return True +class SVMLinear(SVCClassifier, BaseMonoviewClassifier): + + def __init__(self, random_state=None, C=1.0, **kwargs): + super(SVMLinear, self).__init__( + C=C, + kernel='linear', + random_state=random_state + ) + self.param_names = ["C",] + self.distribs = [CustomUniform(loc=0, state=1), ] -def fit(DATASET, CLASS_LABELS, randomState, NB_CORES=1, **kwargs): - classifier = SVC(C=kwargs['C'], kernel='linear', probability=True, max_iter=1000, random_state=randomState) - classifier.fit(DATASET, CLASS_LABELS) - return classifier +def formatCmdArgs(args): + """Used to format kwargs for the parsed args""" + kwargsDict = {"C": args.SVML_C, } + return kwargsDict def paramsToSet(nIter, randomState): @@ -28,37 +30,3 @@ def paramsToSet(nIter, randomState): for _ in range(nIter): paramsSet.append({"C": randomState.randint(1, 10000), }) return paramsSet - - -def getKWARGS(args): - kwargsDict = {"C":args.SVML_C, } - return kwargsDict - - -def genPipeline(): - return Pipeline([('classifier', SVC(kernel="linear", max_iter=1000))]) - - -def genParamsDict(randomState): - return {"classifier__C": np.arange(1, 10000)} - - -def genBestParams(detector): - return {"C": detector.best_params_["classifier__C"]} - - -def genParamsFromDetector(detector): - nIter = len(detector.cv_results_['param_classifier__C']) - return [("C", np.array(detector.cv_results_['param_classifier__C'])), - ("control", np.array(["control" for _ in range(nIter)]))] - - -def getConfig(config): - if type(config) not in [list, dict]: - return "\n\t\t- SVM Linear with C : " + str(config.C) - else: - return "\n\t\t- SVM Linear with C : " + str(config["C"]) - -def getInterpret(classifier, directory): - # TODO : coeffs - return "" diff --git a/multiview_platform/MonoMultiViewClassifiers/MonoviewClassifiers/SVMPoly.py b/multiview_platform/MonoMultiViewClassifiers/MonoviewClassifiers/SVMPoly.py index 5c6aff003ed6ec427cdd27c1bb4401a9e1436d8c..662601d6a945b285a562c6919df935dd883d4767 100644 --- a/multiview_platform/MonoMultiViewClassifiers/MonoviewClassifiers/SVMPoly.py +++ b/multiview_platform/MonoMultiViewClassifiers/MonoviewClassifiers/SVMPoly.py @@ -1,26 +1,28 @@ -from sklearn.svm import SVC -from sklearn.pipeline import Pipeline # Pipelining in classification -from sklearn.model_selection import RandomizedSearchCV -from scipy.stats import randint -import numpy as np - -from .. import Metrics -from ..utils.HyperParameterSearch import genHeatMaps - +from ..Monoview.Additions.SVCClassifier import SVCClassifier +from ..Monoview.MonoviewUtils import CustomUniform, CustomRandint, BaseMonoviewClassifier # Author-Info __author__ = "Baptiste Bauvin" __status__ = "Prototype" # Production, Development, Prototype -def canProbas(): - return True +class SVMPoly(SVCClassifier, BaseMonoviewClassifier): + + def __init__(self, random_state=None, C=1.0, degree=3, **kwargs): + super(SVMPoly, self).__init__( + C=C, + kernel='poly', + degree=degree, + random_state=random_state + ) + self.param_names = ["C", "degree"] + self.distribs = [CustomUniform(loc=0, state=1), CustomRandint(low=2, high=30)] -def fit(DATASET, CLASS_LABELS, randomState, NB_CORES=1, **kwargs): - classifier = SVC(C=kwargs['C'], kernel='poly', degree=kwargs["degree"], probability=True, max_iter=1000, random_state=randomState) - classifier.fit(DATASET, CLASS_LABELS) - return classifier +def formatCmdArgs(args): + """Used to format kwargs for the parsed args""" + kwargsDict = {"C": args.SVMPoly_C, "degree": args.SVMPoly_deg} + return kwargsDict def paramsToSet(nIter, randomState): @@ -29,36 +31,3 @@ def paramsToSet(nIter, randomState): paramsSet.append({"C": randomState.randint(1, 10000), "degree": randomState.randint(1, 30)}) return paramsSet - -def getKWARGS(args): - kwargsDict = {"C": args.SVMPoly_C, "degree": args.SVMPoly_deg} - return kwargsDict - - -def genPipeline(): - return Pipeline([('classifier', SVC(kernel="poly", max_iter=1000))]) - - -def genParamsDict(randomState): - return {"classifier__C": np.arange(1, 10000), - "classifier__degree": np.arange(1, 30)} - - -def genBestParams(detector): - return {"C": detector.best_params_["classifier__C"], - "degree": detector.best_params_["classifier__degree"]} - - -def genParamsFromDetector(detector): - return [("c", np.array(detector.cv_results_['param_classifier__C'])), - ("degree", np.array(detector.cv_results_['param_classifier__degree']))] - - -def getConfig(config): - if type(config) not in [list, dict]: - return "\n\t\t- SVM Poly with C : " + str(config.C) + ", degree : " + str(config.degree) - else: - return "\n\t\t- SVM Poly with C : " + str(config["C"]) + ", degree : " + str(config["degree"]) - -def getInterpret(classifier, directory): - return "" diff --git a/multiview_platform/MonoMultiViewClassifiers/MonoviewClassifiers/SVMRBF.py b/multiview_platform/MonoMultiViewClassifiers/MonoviewClassifiers/SVMRBF.py index df99dc47fe2881537305b5746e4e8c5540528f56..c5fcb0525534b931bfa38351c5effab516f6f9b9 100644 --- a/multiview_platform/MonoMultiViewClassifiers/MonoviewClassifiers/SVMRBF.py +++ b/multiview_platform/MonoMultiViewClassifiers/MonoviewClassifiers/SVMRBF.py @@ -1,64 +1,31 @@ -from sklearn.svm import SVC -from sklearn.pipeline import Pipeline # Pipelining in classification -from sklearn.model_selection import RandomizedSearchCV -from scipy.stats import randint -import numpy as np - -from .. import Metrics -from ..utils.HyperParameterSearch import genHeatMaps - +from ..Monoview.Additions.SVCClassifier import SVCClassifier +from ..Monoview.MonoviewUtils import CustomUniform, CustomRandint, BaseMonoviewClassifier # Author-Info __author__ = "Baptiste Bauvin" __status__ = "Prototype" # Production, Development, Prototype -def canProbas(): - return True +class SVMRBF(SVCClassifier, BaseMonoviewClassifier): + + def __init__(self, random_state=None, C=1.0, **kwargs): + super(SVMRBF, self).__init__( + C=C, + kernel='rbf', + random_state=random_state + ) + self.param_names = ["C",] + self.distribs = [CustomUniform(loc=0, state=1),] -def fit(DATASET, CLASS_LABELS, randomState, NB_CORES=1, **kwargs): - classifier = SVC(C=kwargs['C'], kernel='rbf', probability=True, max_iter=1000, random_state=randomState) - classifier.fit(DATASET, CLASS_LABELS) - return classifier +def formatCmdArgs(args): + """Used to format kwargs for the parsed args""" + kwargsDict = {"C": args.SVMRBF_C} + return kwargsDict def paramsToSet(nIter, randomState): paramsSet = [] for _ in range(nIter): paramsSet.append({"C": randomState.randint(1, 10000), }) - return paramsSet - - -def getKWARGS(args): - kwargsDict = {"C": args.SVMRBF_C} - return kwargsDict - - -def genPipeline(): - return Pipeline([('classifier', SVC(kernel="rbf", max_iter=1000))]) - - -def genParamsDict(randomState): - return {"classifier__C": np.arange(1, 10000)} - - -def genBestParams(detector): - return {'C': detector.best_params_["classifier__C"]} - - -def genParamsFromDetector(detector): - nIter = len(detector.cv_results_['param_classifier__C']) - return [("c", np.array(detector.cv_results_['param_classifier__C'])), - ("control", np.array(["control" for _ in range(nIter)]))] - - -def getConfig(config): - if type(config) not in [list, dict]: - return "\n\t\t- SVM RBF with C : " + str(config.C) - else: - return "\n\t\t- SVM RBF with C : " + str(config["C"]) - - -def getInterpret(classifier, directory): - return "" \ No newline at end of file + return paramsSet \ No newline at end of file