diff --git a/Code/MonoMutliViewClassifiers/ExecClassif.py b/Code/MonoMutliViewClassifiers/ExecClassif.py
index e3ed083d6d7638c174ab491dd435e0a219085b7d..4f52c31c050776fb9542b0e8c82743ffd7a3ff0e 100644
--- a/Code/MonoMutliViewClassifiers/ExecClassif.py
+++ b/Code/MonoMutliViewClassifiers/ExecClassif.py
@@ -41,7 +41,7 @@ groupClass.add_argument('--CL_split', metavar='FLOAT', action='store',
help='Determine the learning rate if > 1.0, number of fold for cross validation', type=float,
default=0.7)
groupClass.add_argument('--CL_nbFolds', metavar='INT', action='store', help='Number of folds in cross validation',
- type=int, default=5)
+ type=int, default=5 )
groupClass.add_argument('--CL_nb_class', metavar='INT', action='store', help='Number of classes, -1 for all', type=int,
default=4)
groupClass.add_argument('--CL_classes', metavar='STRING', action='store',
@@ -51,12 +51,11 @@ groupClass.add_argument('--CL_type', metavar='STRING', action='store',
help='Determine whether to use Multiview, Monoview, or Benchmark, separate with : if multiple',
default='Benchmark')
groupClass.add_argument('--CL_algorithm', metavar='STRING', action='store',
- help='Determine which classifier to use, if CL_type = Benchmark, fill monoview and multiview '
- 'options', default='')
+ help='Determine which classifier to use, if empty, considering all', default='')
groupClass.add_argument('--CL_algos_monoview', metavar='STRING', action='store',
- help='Determine which monoview classifier to use, separate with : if multiple', default='')
+ help='Determine which monoview classifier to use, separate with : if multiple, if empty, considering all', default='')
groupClass.add_argument('--CL_algos_multiview', metavar='STRING', action='store',
- help='Determine which multiview classifier to use, separate with : if multiple', default='')
+ help='Determine which multiview classifier to use, separate with : if multiple, if empty, considering all', default='')
groupClass.add_argument('--CL_cores', metavar='INT', action='store', help='Number of cores, -1 for all', type=int,
default=1)
diff --git a/Code/MonoMutliViewClassifiers/Metrics/__init__.py b/Code/MonoMutliViewClassifiers/Metrics/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/Code/MonoMutliViewClassifiers/Metrics/accuracy_score.py b/Code/MonoMutliViewClassifiers/Metrics/accuracy_score.py
new file mode 100644
index 0000000000000000000000000000000000000000..08d5c30d78216e48e4d8002988d19192e6f09625
--- /dev/null
+++ b/Code/MonoMutliViewClassifiers/Metrics/accuracy_score.py
@@ -0,0 +1,10 @@
+from sklearn.metrics import accuracy_score as metric
+
+
+def score(y_true, y_pred, **kwargs):
+ try:
+ sample_weight = kwargs["0"]
+ except:
+ sample_weight=None
+ score = metric(y_true, y_pred, sample_weight=sample_weight)
+ return score
diff --git a/Code/MonoMutliViewClassifiers/Metrics/f1_score.py b/Code/MonoMutliViewClassifiers/Metrics/f1_score.py
new file mode 100644
index 0000000000000000000000000000000000000000..3dc8c3ae10c51a44c476fb0e39e8870a76e365b7
--- /dev/null
+++ b/Code/MonoMutliViewClassifiers/Metrics/f1_score.py
@@ -0,0 +1,22 @@
+from sklearn.metrics import f1_score as metric
+
+
+def score(y_true, y_pred, **kwargs):
+ try:
+ sample_weight = kwargs["0"]
+ except:
+ sample_weight=None
+ try:
+ labels = kwargs["1"]
+ except:
+ labels=None
+ try:
+ pos_label = kwargs["2"]
+ except:
+ pos_label = 1
+ try:
+ average = kwargs["3"]
+ except:
+ average = "binary"
+ score = metric(y_true, y_pred, sample_weight=sample_weight, labels=labels, pos_label=pos_label, average=average)
+ return score
diff --git a/Code/MonoMutliViewClassifiers/Metrics/fbeta_score.py b/Code/MonoMutliViewClassifiers/Metrics/fbeta_score.py
new file mode 100644
index 0000000000000000000000000000000000000000..74f1e24138178bfec9308ddc51cfce51909a2c8e
--- /dev/null
+++ b/Code/MonoMutliViewClassifiers/Metrics/fbeta_score.py
@@ -0,0 +1,26 @@
+from sklearn.metrics import fbeta_score as metric
+
+
+def score(y_true, y_pred, **kwargs):
+ try:
+ sample_weight = kwargs["0"]
+ except:
+ sample_weight=None
+ try:
+ beta = kwargs["1"]
+ except:
+ beta=1.0
+ try:
+ labels = kwargs["2"]
+ except:
+ labels=None
+ try:
+ pos_label = kwargs["3"]
+ except:
+ pos_label = 1
+ try:
+ average = kwargs["4"]
+ except:
+ average = "binary"
+ score = metric(y_true, y_pred, beta, sample_weight=sample_weight, labels=labels, pos_label=pos_label, average=average)
+ return score
diff --git a/Code/MonoMutliViewClassifiers/Metrics/hamming_loss.py b/Code/MonoMutliViewClassifiers/Metrics/hamming_loss.py
new file mode 100644
index 0000000000000000000000000000000000000000..fe35066d783cfea89eb27f89bc3c15b77e090026
--- /dev/null
+++ b/Code/MonoMutliViewClassifiers/Metrics/hamming_loss.py
@@ -0,0 +1,10 @@
+from sklearn.metrics import hamming_loss as metric
+
+
+def score(y_true, y_pred, **kwargs):
+ try:
+ classes = kwargs["0"]
+ except:
+ classes=None
+ score = metric(y_true, y_pred, classes=classes)
+ return score
diff --git a/Code/MonoMutliViewClassifiers/Metrics/jaccard_similarity_score.py b/Code/MonoMutliViewClassifiers/Metrics/jaccard_similarity_score.py
new file mode 100644
index 0000000000000000000000000000000000000000..c6d134ad15497130aa88eacb905d19aefa22074e
--- /dev/null
+++ b/Code/MonoMutliViewClassifiers/Metrics/jaccard_similarity_score.py
@@ -0,0 +1,10 @@
+from sklearn.metrics import jaccard_similarity_score as metric
+
+
+def score(y_true, y_pred, **kwargs):
+ try:
+ sample_weight = kwargs["0"]
+ except:
+ sample_weight = None
+ score = metric(y_true, y_pred, sample_weight=sample_weight)
+ return score
diff --git a/Code/MonoMutliViewClassifiers/Metrics/log_loss.py b/Code/MonoMutliViewClassifiers/Metrics/log_loss.py
new file mode 100644
index 0000000000000000000000000000000000000000..a6dbf8a3c295ae7bd06d19360939fb731b0a7b3a
--- /dev/null
+++ b/Code/MonoMutliViewClassifiers/Metrics/log_loss.py
@@ -0,0 +1,14 @@
+from sklearn.metrics import log_loss as metric
+
+
+def score(y_true, y_pred, **kwargs):
+ try:
+ sample_weight = kwargs["0"]
+ except:
+ sample_weight = None
+ try:
+ eps = kwargs["1"]
+ except:
+ eps = 1e-15
+ score = metric(y_true, y_pred, sample_weight=sample_weight, eps=eps)
+ return score
diff --git a/Code/MonoMutliViewClassifiers/Metrics/matthews_corrcoef.py b/Code/MonoMutliViewClassifiers/Metrics/matthews_corrcoef.py
new file mode 100644
index 0000000000000000000000000000000000000000..b1ec857aa2937d437bcc7953b5ceaa3927143ddc
--- /dev/null
+++ b/Code/MonoMutliViewClassifiers/Metrics/matthews_corrcoef.py
@@ -0,0 +1,6 @@
+from sklearn.metrics import matthews_corrcoef as metric
+
+
+def score(y_true, y_pred, **kwargs):
+ score = metric(y_true, y_pred)
+ return score
\ No newline at end of file
diff --git a/Code/MonoMutliViewClassifiers/Metrics/precision_score.py b/Code/MonoMutliViewClassifiers/Metrics/precision_score.py
new file mode 100644
index 0000000000000000000000000000000000000000..2a6cccad17d45dc1cbecf039044266e3f713675a
--- /dev/null
+++ b/Code/MonoMutliViewClassifiers/Metrics/precision_score.py
@@ -0,0 +1,22 @@
+from sklearn.metrics import precision_score as metric
+
+
+def score(y_true, y_pred, **kwargs):
+ try:
+ sample_weight = kwargs["0"]
+ except:
+ sample_weight=None
+ try:
+ labels = kwargs["1"]
+ except:
+ labels=None
+ try:
+ pos_label = kwargs["2"]
+ except:
+ pos_label = 1
+ try:
+ average = kwargs["3"]
+ except:
+ average = "binary"
+ score = metric(y_true, y_pred, sample_weight=sample_weight, labels=labels, pos_label=pos_label, average=average)
+ return score
diff --git a/Code/MonoMutliViewClassifiers/Metrics/recall_score.py b/Code/MonoMutliViewClassifiers/Metrics/recall_score.py
new file mode 100644
index 0000000000000000000000000000000000000000..a4d10284db2ee2a1bb3a477c204c8dbd28299fbd
--- /dev/null
+++ b/Code/MonoMutliViewClassifiers/Metrics/recall_score.py
@@ -0,0 +1,22 @@
+from sklearn.metrics import recall_score as metric
+
+
+def score(y_true, y_pred, **kwargs):
+ try:
+ sample_weight = kwargs["0"]
+ except:
+ sample_weight=None
+ try:
+ labels = kwargs["1"]
+ except:
+ labels=None
+ try:
+ pos_label = kwargs["2"]
+ except:
+ pos_label = 1
+ try:
+ average = kwargs["3"]
+ except:
+ average = "binary"
+ score = metric(y_true, y_pred, sample_weight=sample_weight, labels=labels, pos_label=pos_label, average=average)
+ return score
diff --git a/Code/MonoMutliViewClassifiers/Metrics/roc_auc_score.py b/Code/MonoMutliViewClassifiers/Metrics/roc_auc_score.py
new file mode 100644
index 0000000000000000000000000000000000000000..5a9f7cfb9561dbcd99acee59bbfe653cc8ea149c
--- /dev/null
+++ b/Code/MonoMutliViewClassifiers/Metrics/roc_auc_score.py
@@ -0,0 +1,14 @@
+from sklearn.metrics import roc_auc_score as metric
+
+
+def score(y_true, y_pred, **kwargs):
+ try:
+ sample_weight = kwargs["0"]
+ except:
+ sample_weight=None
+ try:
+ average = kwargs["1"]
+ except:
+ average = "binary"
+ score = metric(y_true, y_pred, sample_weight=sample_weight, average=average)
+ return score
diff --git a/Code/MonoMutliViewClassifiers/Metrics/zero_one_loss.py b/Code/MonoMutliViewClassifiers/Metrics/zero_one_loss.py
new file mode 100644
index 0000000000000000000000000000000000000000..a741825bec49fd400f4a8b0fa60423352062d5f6
--- /dev/null
+++ b/Code/MonoMutliViewClassifiers/Metrics/zero_one_loss.py
@@ -0,0 +1,10 @@
+from sklearn.metrics import zero_one_loss as metric
+
+
+def score(y_true, y_pred, **kwargs):
+ try:
+ sample_weight = kwargs["0"]
+ except:
+ sample_weight=None
+ score = metric(y_true, y_pred, sample_weight=sample_weight)
+ return score
diff --git a/Code/MonoMutliViewClassifiers/MonoviewClassifiers/Adaboost.py b/Code/MonoMutliViewClassifiers/MonoviewClassifiers/Adaboost.py
index d1c45281a2105e7c5b16d1d8d91cda5d84c000a8..6eba0119ae9bbff786240f614125e57c071597cf 100644
--- a/Code/MonoMutliViewClassifiers/MonoviewClassifiers/Adaboost.py
+++ b/Code/MonoMutliViewClassifiers/MonoviewClassifiers/Adaboost.py
@@ -1,7 +1,10 @@
from sklearn.ensemble import AdaBoostClassifier
from sklearn.pipeline import Pipeline
-from sklearn.grid_search import GridSearchCV
+from sklearn.grid_search import RandomizedSearchCV
from sklearn.tree import DecisionTreeClassifier
+from sklearn.utils.testing import all_estimators
+import inspect
+import numpy as np
def fit(DATASET, CLASS_LABELS, NB_CORES=1,**kwargs):
@@ -9,20 +12,33 @@ def fit(DATASET, CLASS_LABELS, NB_CORES=1,**kwargs):
base_estimators = int(kwargs['1'])
classifier = AdaBoostClassifier(n_estimators=num_estimators, base_estimator=base_estimators)
classifier.fit(DATASET, CLASS_LABELS)
- return classifier
+ return "No desc", classifier
def fit_gridsearch(X_train, y_train, nbFolds=4, nbCores=1, **kwargs):
-
pipeline = Pipeline([('classifier', AdaBoostClassifier())])
param= {"classifier__n_estimators": map(int, kwargs['0']),
"classifier__base_estimator": [DecisionTreeClassifier() for arg in kwargs["1"]]}
- grid = GridSearchCV(pipeline,param_grid=param,refit=True,n_jobs=nbCores,scoring='accuracy',cv=nbFolds)
+ grid = RandomizedSearchCV(pipeline,param_distributions=param,refit=True,n_jobs=nbCores,scoring='accuracy',cv=nbFolds)
detector = grid.fit(X_train, y_train)
desc_estimators = [detector.best_params_["classifier__n_estimators"]]
description = "Classif_" + "RF" + "-" + "CV_" + str(nbFolds) + "-" + "Trees_" + str(map(str,desc_estimators))
return description, detector
+def gridSearch(X_train, y_train, nbFolds=4, nbCores=1):
+ pipeline = Pipeline([('classifier', AdaBoostClassifier())])
+ classifiers = [clf for name, clf in all_estimators(type_filter='classifier')
+ if 'sample_weight' in inspect.getargspec(clf().fit)[0]
+ and (name != "AdaBoostClassifier" and name !="GradientBoostingClassifier")]
+ param= {"classifier__n_estimators": np.random.randint(1, 30, 10),
+ "classifier__base_estimator": classifiers}
+ grid = RandomizedSearchCV(pipeline,param_distributions=param,refit=True,n_jobs=nbCores,scoring='accuracy',cv=nbFolds)
+ detector = grid.fit(X_train, y_train)
+ desc_estimators = [detector.best_params_["classifier__n_estimators"],
+ detector.best_params_["classifier__base_estimator"]]
+ return desc_estimators
+
+
def getConfig(config):
return "\n\t\t- Adaboost with num_esimators : "+config[0]+", base_estimators : "+config[1]
\ No newline at end of file
diff --git a/Code/MonoMutliViewClassifiers/MonoviewClassifiers/DecisionTree.py b/Code/MonoMutliViewClassifiers/MonoviewClassifiers/DecisionTree.py
index 8fe4de8daf27ffa9bcf7e4f4c33fd5d665ee03b7..c9c86c357f15ad84fbc0453e5544a8851224f62b 100644
--- a/Code/MonoMutliViewClassifiers/MonoviewClassifiers/DecisionTree.py
+++ b/Code/MonoMutliViewClassifiers/MonoviewClassifiers/DecisionTree.py
@@ -1,13 +1,13 @@
from sklearn.tree import DecisionTreeClassifier
from sklearn.pipeline import Pipeline # Pipelining in classification
from sklearn.grid_search import GridSearchCV
-
+import numpy as np
def fit(DATASET, CLASS_LABELS, NB_CORES=1, **kwargs):
maxDepth = int(kwargs['0'])
classifier = DecisionTreeClassifier(max_depth=maxDepth)
classifier.fit(DATASET, CLASS_LABELS)
- return classifier
+ return "No desc", classifier
def fit_gridsearch(X_train, y_train, nbFolds=4, nbCores=1, **kwargs):
@@ -22,5 +22,16 @@ def fit_gridsearch(X_train, y_train, nbFolds=4, nbCores=1, **kwargs):
return description, DT_detector
+def gridSearch(X_train, y_train, nbFolds=4, nbCores=1, **kwargs):
+ pipeline_DT = Pipeline([('classifier', DecisionTreeClassifier())])
+ param_DT = {"classifier__max_depth":np.random.randint(1, 30, 10)}
+
+ grid_DT = GridSearchCV(pipeline_DT, param_grid=param_DT, refit=True, n_jobs=nbCores, scoring='accuracy',
+ cv=nbFolds)
+ DT_detector = grid_DT.fit(X_train, y_train)
+ desc_params = [DT_detector.best_params_["classifier__max_depth"]]
+ return desc_params
+
+
def getConfig(config):
return "\n\t\t- Decision Tree with max_depth : "+config[0]
\ No newline at end of file
diff --git a/Code/MonoMutliViewClassifiers/MonoviewClassifiers/KNN.py b/Code/MonoMutliViewClassifiers/MonoviewClassifiers/KNN.py
index ae03c3555610b793ef54c94baa157ba3df1df32e..60cc21c1a2a884e7c675f56c0ea800161c38afd8 100644
--- a/Code/MonoMutliViewClassifiers/MonoviewClassifiers/KNN.py
+++ b/Code/MonoMutliViewClassifiers/MonoviewClassifiers/KNN.py
@@ -1,13 +1,13 @@
from sklearn.neighbors import KNeighborsClassifier
from sklearn.pipeline import Pipeline # Pipelining in classification
from sklearn.grid_search import GridSearchCV
-
+import numpy as np
def fit(DATASET, CLASS_LABELS, NB_CORES=1,**kwargs):
nNeighbors = int(kwargs['0'])
classifier = KNeighborsClassifier(n_neighbors=nNeighbors)
classifier.fit(DATASET, CLASS_LABELS)
- return classifier
+ return "No desc", classifier
def fit_gridsearch(X_train, y_train, nbFolds=4, nbCores=1, **kwargs):
@@ -21,6 +21,15 @@ def fit_gridsearch(X_train, y_train, nbFolds=4, nbCores=1, **kwargs):
return description, KNN_detector
+def gridSearch(X_train, y_train, nbFolds=4, nbCores=1, **kwargs):
+ pipeline_KNN = Pipeline([('classifier', KNeighborsClassifier())])
+ param_KNN = {"classifier__n_neighbors": np.random.randint(1, 30, 10)}
+ grid_KNN = GridSearchCV(pipeline_KNN, param_grid=param_KNN, refit=True, n_jobs=nbCores, scoring='accuracy',
+ cv=nbFolds)
+ KNN_detector = grid_KNN.fit(X_train, y_train)
+ desc_params = [KNN_detector.best_params_["classifier__n_neighbors"]]
+ return desc_params
+
def getConfig(config):
return "\n\t\t- K nearest Neighbors with n_neighbors: "+config[0]
\ No newline at end of file
diff --git a/Code/MonoMutliViewClassifiers/MonoviewClassifiers/RandomForest.py b/Code/MonoMutliViewClassifiers/MonoviewClassifiers/RandomForest.py
index 968d83d2f66abec190c9dcf0510b36e148d1cd0e..1b3a1f415d74c959e9f82aadf7abbea634fa89e0 100644
--- a/Code/MonoMutliViewClassifiers/MonoviewClassifiers/RandomForest.py
+++ b/Code/MonoMutliViewClassifiers/MonoviewClassifiers/RandomForest.py
@@ -8,7 +8,7 @@ def fit(DATASET, CLASS_LABELS, NB_CORES=1,**kwargs):
maxDepth = int(kwargs['1'])
classifier = RandomForestClassifier(n_estimators=num_estimators, max_depth=maxDepth, n_jobs=NB_CORES)
classifier.fit(DATASET, CLASS_LABELS)
- return classifier
+ return "No desc", classifier
def fit_gridsearch(X_train, y_train, nbFolds=4, nbCores=1, **kwargs):
@@ -42,5 +42,16 @@ def fit_gridsearch(X_train, y_train, nbFolds=4, nbCores=1, **kwargs):
return description, rf_detector
+def gridSearch(X_train, y_train, nbFolds=4, nbCores=1, **kwargs):
+ pipeline_rf = Pipeline([('classifier', RandomForestClassifier())])
+ param_rf = {"classifier__n_estimators": np.random.randint(1, 30, 10)}
+
+ grid_rf = GridSearchCV(pipeline_rf,param_grid=param_rf,refit=True,n_jobs=nbCores,scoring='accuracy',cv=nbFolds)
+ rf_detector = grid_rf.fit(X_train, y_train)
+
+ desc_estimators = [rf_detector.best_params_["classifier__n_estimators"]]
+ return desc_estimators
+
+
def getConfig(config):
return "\n\t\t- Random Forest with num_esimators : "+config[0]+", max_depth : "+config[1]
\ No newline at end of file
diff --git a/Code/MonoMutliViewClassifiers/MonoviewClassifiers/SGD.py b/Code/MonoMutliViewClassifiers/MonoviewClassifiers/SGD.py
index 3a2bc27f097a3503fa09a4ac4ad34255dcd2da11..9ad1f292683875633ba718003d0557c9d271887f 100644
--- a/Code/MonoMutliViewClassifiers/MonoviewClassifiers/SGD.py
+++ b/Code/MonoMutliViewClassifiers/MonoviewClassifiers/SGD.py
@@ -1,6 +1,7 @@
from sklearn.linear_model import SGDClassifier
from sklearn.pipeline import Pipeline # Pipelining in classification
from sklearn.grid_search import GridSearchCV
+import numpy as np
def fit(DATASET, CLASS_LABELS, NB_CORES=1,**kwargs):
@@ -12,7 +13,7 @@ def fit(DATASET, CLASS_LABELS, NB_CORES=1,**kwargs):
alpha = 0.15
classifier = SGDClassifier(loss=loss, penalty=penalty, alpha=alpha)
classifier.fit(DATASET, CLASS_LABELS)
- return classifier
+ return "No desc", classifier
def fit_gridsearch(X_train, y_train, nbFolds=4, nbCores=1, **kwargs):
@@ -28,5 +29,19 @@ def fit_gridsearch(X_train, y_train, nbFolds=4, nbCores=1, **kwargs):
return description, SGD_detector
+def gridSearch(X_train, y_train, nbFolds=4, nbCores=1, **kwargs):
+ pipeline_SGD = Pipeline([('classifier', SGDClassifier())])
+ losses = ['hinge', 'log', 'modified_huber', 'squared_hinge', 'perceptron']
+ penalties = ["l1", "l2", "elasticnet"]
+ alphas = list(np.random.randint(1,10,10))+list(np.random.random_sample(10))
+ param_SGD = {"classifier__loss": losses, "classifier__penalty": penalties,
+ "classifier__alpha": alphas}
+ grid_SGD = GridSearchCV(pipeline_SGD, param_grid=param_SGD, refit=True, n_jobs=nbCores, scoring='accuracy',
+ cv=nbFolds)
+ SGD_detector = grid_SGD.fit(X_train, y_train)
+ desc_params = [SGD_detector.best_params_["classifier__loss"], SGD_detector.best_params_["classifier__penalty"],
+ SGD_detector.best_params_["classifier__alpha"]]
+ return desc_params
+
def getConfig(config):
return "\n\t\t- SGDClassifier with loss : "+config[0]+", penalty : "+config[1]
\ No newline at end of file
diff --git a/Code/MonoMutliViewClassifiers/MonoviewClassifiers/SVMLinear.py b/Code/MonoMutliViewClassifiers/MonoviewClassifiers/SVMLinear.py
index 568badb41da2130e116459ba4123d47b3430befa..6f59cb29a4da54eb2b88fb2e0c87becdef0070e3 100644
--- a/Code/MonoMutliViewClassifiers/MonoviewClassifiers/SVMLinear.py
+++ b/Code/MonoMutliViewClassifiers/MonoviewClassifiers/SVMLinear.py
@@ -1,13 +1,14 @@
from sklearn.svm import SVC
from sklearn.pipeline import Pipeline # Pipelining in classification
from sklearn.grid_search import GridSearchCV
+import numpy as np
def fit(DATASET, CLASS_LABELS, NB_CORES=1,**kwargs):
C = int(kwargs['0'])
classifier = SVC(C=C, kernel='linear', probability=True)
classifier.fit(DATASET, CLASS_LABELS)
- return classifier
+ return "No desc", classifier
def fit_gridsearch(X_train, y_train, nbFolds=4, nbCores=1, **kwargs):
@@ -21,5 +22,15 @@ def fit_gridsearch(X_train, y_train, nbFolds=4, nbCores=1, **kwargs):
return description, SVMLinear_detector
+def gridSearch(X_train, y_train, nbFolds=4, nbCores=1, **kwargs):
+ pipeline_SVMLinear = Pipeline([('classifier', SVC(kernel="linear"))])
+ param_SVMLinear = {"classifier__C":np.random.randint(1,2000,30)}
+ grid_SVMLinear = GridSearchCV(pipeline_SVMLinear, param_grid=param_SVMLinear, refit=True, n_jobs=nbCores, scoring='accuracy',
+ cv=nbFolds)
+ SVMLinear_detector = grid_SVMLinear.fit(X_train, y_train)
+ desc_params = [SVMLinear_detector.best_params_["classifier__C"]]
+ return desc_params
+
+
def getConfig(config):
return "\n\t\t- SVM with C : "+config[0]+", kernel : "+config[1]
\ No newline at end of file
diff --git a/Code/MonoMutliViewClassifiers/MonoviewClassifiers/SVMPoly.py b/Code/MonoMutliViewClassifiers/MonoviewClassifiers/SVMPoly.py
index 9f43f0b9417e7defb873a384b25d4a676f15b50f..1c7ee599a855e26681e76b1bb35c3e082e57c1d5 100644
--- a/Code/MonoMutliViewClassifiers/MonoviewClassifiers/SVMPoly.py
+++ b/Code/MonoMutliViewClassifiers/MonoviewClassifiers/SVMPoly.py
@@ -1,6 +1,7 @@
from sklearn.svm import SVC
from sklearn.pipeline import Pipeline # Pipelining in classification
from sklearn.grid_search import GridSearchCV
+import numpy as np
def fit(DATASET, CLASS_LABELS, NB_CORES=1,**kwargs):
@@ -8,18 +9,19 @@ def fit(DATASET, CLASS_LABELS, NB_CORES=1,**kwargs):
degree = int(kwargs['1'])
classifier = SVC(C=C, kernel='poly', degree=degree, probability=True)
classifier.fit(DATASET, CLASS_LABELS)
- return classifier
+ return "No desc", classifier
def fit_gridsearch(X_train, y_train, nbFolds=4, nbCores=1, **kwargs):
- pipeline_SVMLinear = Pipeline([('classifier', SVC(kernel="linear"))])
- param_SVMLinear = {"classifier__C": map(int, kwargs['0']), "classifier__degree": map(int, kwargs["1"])}
- grid_SVMLinear = GridSearchCV(pipeline_SVMLinear, param_grid=param_SVMLinear, refit=True, n_jobs=nbCores, scoring='accuracy',
+ pipeline_SVMPoly = Pipeline([('classifier', SVC(kernel="poly"))])
+ param_SVMPoly= {"classifier__C": np.random.randint(1,2000,30), "classifier__degree": np.random.randint(1,10,5)}
+ grid_SVMPoly = GridSearchCV(pipeline_SVMPoly, param_grid=param_SVMPoly, refit=True, n_jobs=nbCores, scoring='accuracy',
cv=nbFolds)
- SVMLinear_detector = grid_SVMLinear.fit(X_train, y_train)
- desc_params = [SVMLinear_detector.best_params_["classifier__C"], SVMLinear_detector.best_params_["classifier__degree"]]
- description = "Classif_" + "SVC" + "-" + "CV_" + str(nbFolds) + "-" + "-".join(map(str,desc_params))
- return description, SVMLinear_detector
+ SVMPoly_detector = grid_SVMPoly.fit(X_train, y_train)
+ desc_params = [SVMPoly_detector.best_params_["classifier__C"], SVMPoly_detector.best_params_["classifier__degree"]]
+ return desc_params
+
+
def getConfig(config):
diff --git a/Code/MonoMutliViewClassifiers/MonoviewClassifiers/SVMRBF.py b/Code/MonoMutliViewClassifiers/MonoviewClassifiers/SVMRBF.py
index 202cc076a9a92223b92626334d38f2ae67515c64..ae527e05634010dff000fd4046aa39ceb38717d4 100644
--- a/Code/MonoMutliViewClassifiers/MonoviewClassifiers/SVMRBF.py
+++ b/Code/MonoMutliViewClassifiers/MonoviewClassifiers/SVMRBF.py
@@ -1,13 +1,14 @@
from sklearn.svm import SVC
from sklearn.pipeline import Pipeline # Pipelining in classification
from sklearn.grid_search import GridSearchCV
+import numpy as np
def fit(DATASET, CLASS_LABELS, NB_CORES=1,**kwargs):
C = int(kwargs['0'])
classifier = SVC(C=C, kernel='rbf', probability=True)
classifier.fit(DATASET, CLASS_LABELS)
- return classifier
+ return "No desc", classifier
def fit_gridsearch(X_train, y_train, nbFolds=4, nbCores=1, **kwargs):
@@ -21,5 +22,15 @@ def fit_gridsearch(X_train, y_train, nbFolds=4, nbCores=1, **kwargs):
return description, SVMRBF_detector
+def gridSearch(X_train, y_train, nbFolds=4, nbCores=1, **kwargs):
+ pipeline_SVMRBF = Pipeline([('classifier', SVC(kernel="rbf"))])
+ param_SVMRBF = {"classifier__C": np.random.randint(1,2000,30)}
+ grid_SVMRBF = GridSearchCV(pipeline_SVMRBF, param_grid=param_SVMRBF, refit=True, n_jobs=nbCores, scoring='accuracy',
+ cv=nbFolds)
+ SVMRBF_detector = grid_SVMRBF.fit(X_train, y_train)
+ desc_params = [SVMRBF_detector.best_params_["classifier__C"]]
+ return desc_params
+
+
def getConfig(config):
return "\n\t\t- SVM with C : "+config[0]+", kernel : "+config[1]
\ No newline at end of file
diff --git a/Code/MonoMutliViewClassifiers/Multiview/ExecMultiview.py b/Code/MonoMutliViewClassifiers/Multiview/ExecMultiview.py
index 09268a897df07c3fc0460c9fa39bfa5254e6eed6..75dceac7ae3c2baa3e2444918bea5b6855a3f3a9 100644
--- a/Code/MonoMutliViewClassifiers/Multiview/ExecMultiview.py
+++ b/Code/MonoMutliViewClassifiers/Multiview/ExecMultiview.py
@@ -78,8 +78,12 @@ def ExecMultiview(DATASET, name, learningRate, nbFolds, nbCores, databaseType, p
if gridSearch:
logging.info("Start:\t Gridsearching best settings for monoview classifiers")
- bestSettings = classifierGridSearch(DATASET, classificationKWARGS["classifiersNames"])
+ bestSettings, fusionConfig = classifierGridSearch(DATASET, classificationKWARGS, learningIndices)
classificationKWARGS["classifiersConfigs"] = bestSettings
+ try:
+ classificationKWARGS["fusionMethodConfig"] = fusionConfig
+ except:
+ pass
logging.info("Done:\t Gridsearching best settings for monoview classifiers")
# Begin Classification
diff --git a/Code/MonoMutliViewClassifiers/Multiview/Fusion/Fusion.py b/Code/MonoMutliViewClassifiers/Multiview/Fusion/Fusion.py
index 3fe09168bc42f9ab8581d944057475a1efab5a93..899350e0da04bd08fce7bf66f4c78d1fce759d8b 100644
--- a/Code/MonoMutliViewClassifiers/Multiview/Fusion/Fusion.py
+++ b/Code/MonoMutliViewClassifiers/Multiview/Fusion/Fusion.py
@@ -1,14 +1,22 @@
from Methods import *
+import MonoviewClassifiers
-def gridSearch_hdf5(DATASET, classifiersNames):
+def gridSearch_hdf5(DATASET, classificationKWARGS):
+ fusionTypeName = classificationKWARGS["fusionType"]
+ fusionTypePackage = globals()[fusionTypeName+"Package"]
+ fusionMethodModuleName = classificationKWARGS["fusionMethod"]
+ fusionMethodModule = getattr(fusionTypePackage, fusionMethodModuleName)
+ classifiersNames = classificationKWARGS["classifiersNames"]
bestSettings = []
for classifierIndex, classifierName in enumerate(classifiersNames):
- classifierModule = globals()[classifierName] # Permet d'appeler une fonction avec une string
+ classifierModule = getattr(MonoviewClassifiers, classifierName)
classifierMethod = getattr(classifierModule, "gridSearch")
bestSettings.append(classifierMethod(DATASET.get("View"+str(classifierIndex))[...],
DATASET.get("labels")[...]))
- return bestSettings
+ classificationKWARGS["classifiersConfigs"] = bestSettings
+ fusionMethodConfig = fusionMethodModule.gridSearch(DATASET, classificationKWARGS)
+ return bestSettings, fusionMethodConfig
class Fusion:
diff --git a/Code/MonoMutliViewClassifiers/Multiview/Fusion/Methods/EarlyFusion.py b/Code/MonoMutliViewClassifiers/Multiview/Fusion/Methods/EarlyFusion.py
index 35877675fb93e5d0491407c0cfdcfb329e8711f1..5c0875c31f3ee99529aada82e2339ae323d18d90 100644
--- a/Code/MonoMutliViewClassifiers/Multiview/Fusion/Methods/EarlyFusion.py
+++ b/Code/MonoMutliViewClassifiers/Multiview/Fusion/Methods/EarlyFusion.py
@@ -38,7 +38,7 @@ class WeightedLinear(EarlyFusionClassifier):
trainIndices = range(DATASET.get("Metadata").attrs["datasetLength"])
self.makeMonoviewData_hdf5(DATASET, weights=self.weights, usedIndices=trainIndices)
monoviewClassifierModule = getattr(MonoviewClassifiers, self.monoviewClassifierName)
- self.monoviewClassifier = monoviewClassifierModule.fit(self.monoviewData, DATASET.get("labels")[trainIndices],
+ desc, self.monoviewClassifier = monoviewClassifierModule.fit(self.monoviewData, DATASET.get("labels")[trainIndices],
NB_CORES=self.nbCores,
**dict((str(configIndex),config) for configIndex,config in
enumerate(self.monoviewClassifiersConfig)))
@@ -70,3 +70,7 @@ class WeightedLinear(EarlyFusionClassifier):
configString += monoviewClassifierModule.getConfig(monoviewClassifiersConfigs[0])
return configString
+ def gridSearch(self, classificationKWARGS):
+
+ return
+
diff --git a/Code/MonoMutliViewClassifiers/Multiview/Fusion/Methods/EarlyFusionPackage/WeightedLinear.py b/Code/MonoMutliViewClassifiers/Multiview/Fusion/Methods/EarlyFusionPackage/WeightedLinear.py
new file mode 100644
index 0000000000000000000000000000000000000000..4965f8312ff487ebfd7b7c3fd76b9529283bcb74
--- /dev/null
+++ b/Code/MonoMutliViewClassifiers/Multiview/Fusion/Methods/EarlyFusionPackage/WeightedLinear.py
@@ -0,0 +1,70 @@
+from EarlyFusion import EarlyFusionClassifier
+import MonoviewClassifiers
+import numpy as np
+from sklearn.metrics import accuracy_score
+
+
+def gridSearch(DATASET, classificationKWARGS, trainIndices):
+ bestScore = 0.0
+ bestConfig = None
+ if classificationKWARGS["fusionMethodConfig"][0] is not None:
+ for i in range(0):
+ randomWeightsArray = np.random.random_sample(len(DATASET.get("Metadata").attrs["nbView"]))
+ normalizedArray = randomWeightsArray/np.sum(randomWeightsArray)
+ classificationKWARGS["fusionMethodConfig"][0] = normalizedArray
+ classifier = WeightedLinear(1, **classificationKWARGS)
+ classifier.fit_hdf5(DATASET, trainIndices)
+ predictedLabels = classifier.predict_hdf5(DATASET, trainIndices)
+ accuracy = accuracy_score(DATASET.get("labels")[trainIndices], predictedLabels)
+ if accuracy > bestScore:
+ bestScore = accuracy
+ bestConfig = normalizedArray
+ return bestConfig
+
+
+class WeightedLinear(EarlyFusionClassifier):
+ def __init__(self, NB_CORES=1, **kwargs):
+ EarlyFusionClassifier.__init__(self, kwargs['classifiersNames'], kwargs['monoviewClassifiersConfigs'],
+ NB_CORES=NB_CORES)
+ self.weights = np.array(map(float, kwargs['fusionMethodConfig'][0]))
+
+ def fit_hdf5(self, DATASET, trainIndices=None):
+ if not trainIndices:
+ trainIndices = range(DATASET.get("Metadata").attrs["datasetLength"])
+ self.makeMonoviewData_hdf5(DATASET, weights=self.weights, usedIndices=trainIndices)
+ monoviewClassifierModule = getattr(MonoviewClassifiers, self.monoviewClassifierName)
+ desc, self.monoviewClassifier = monoviewClassifierModule.fit(self.monoviewData, DATASET.get("labels")[trainIndices],
+ NB_CORES=self.nbCores,
+ **dict((str(configIndex),config) for configIndex,config in
+ enumerate(self.monoviewClassifiersConfig)))
+
+ def predict_hdf5(self, DATASET, usedIndices=None):
+ if usedIndices == None:
+ usedIndices = range(DATASET.get("Metadata").attrs["datasetLength"])
+ if usedIndices:
+ self.makeMonoviewData_hdf5(DATASET, weights=self.weights, usedIndices=usedIndices)
+ predictedLabels = self.monoviewClassifier.predict(self.monoviewData)
+ else:
+ predictedLabels=[]
+ return predictedLabels
+
+ def predict_proba_hdf5(self, DATASET, usedIndices=None):
+ if usedIndices == None:
+ usedIndices = range(DATASET.get("Metadata").attrs["datasetLength"])
+ if usedIndices:
+ self.makeMonoviewData_hdf5(DATASET, weights=self.weights, usedIndices=usedIndices)
+ predictedLabels = self.monoviewClassifier.predict_proba(self.monoviewData)
+ else:
+ predictedLabels=[]
+ return predictedLabels
+
+ def getConfig(self, fusionMethodConfig ,monoviewClassifiersNames, monoviewClassifiersConfigs):
+ configString = "with weighted concatenation, using weights : "+", ".join(map(str, self.weights))+ \
+ " with monoview classifier : "
+ monoviewClassifierModule = getattr(MonoviewClassifiers, monoviewClassifiersNames[0])
+ configString += monoviewClassifierModule.getConfig(monoviewClassifiersConfigs[0])
+ return configString
+
+ def gridSearch(self, classificationKWARGS):
+
+ return
\ No newline at end of file
diff --git a/Code/MonoMutliViewClassifiers/Multiview/Fusion/Methods/EarlyFusionPackage/__init__.py b/Code/MonoMutliViewClassifiers/Multiview/Fusion/Methods/EarlyFusionPackage/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/Code/MonoMutliViewClassifiers/Multiview/Fusion/Methods/LateFusion.py b/Code/MonoMutliViewClassifiers/Multiview/Fusion/Methods/LateFusion.py
index 9222d7339935418485a66e4c55ad1dbd04042474..844f9969af49973876abcdd1e98d1ee584fe77c5 100644
--- a/Code/MonoMutliViewClassifiers/Multiview/Fusion/Methods/LateFusion.py
+++ b/Code/MonoMutliViewClassifiers/Multiview/Fusion/Methods/LateFusion.py
@@ -24,6 +24,7 @@ def fifMonoviewClassifier(classifierName, data, labels, classifierConfig):
)))
return classifier
+
class LateFusionClassifier(object):
def __init__(self, monoviewClassifiersNames, monoviewClassifiersConfigs, NB_CORES=1):
self.monoviewClassifiersNames = monoviewClassifiersNames
@@ -35,200 +36,201 @@ class LateFusionClassifier(object):
if trainIndices == None:
trainIndices = range(DATASET.get("Metadata").attrs["datasetLength"])
nbView = DATASET.get("Metadata").attrs["nbView"]
- self.monoviewClassifiers = Parallel(n_jobs=self.nbCores)(
+ monoviewResults = Parallel(n_jobs=self.nbCores)(
delayed(fifMonoviewClassifier)(self.monoviewClassifiersNames[viewIndex],
DATASET.get("View"+str(viewIndex))[trainIndices, :],
DATASET.get("labels")[trainIndices],
self.monoviewClassifiersConfigs[viewIndex])
for viewIndex in range(nbView))
+ self.monoviewClassifiers = [monoviewClassifier for desc, monoviewClassifier in monoviewResults]
-class WeightedLinear(LateFusionClassifier):
- def __init__(self, NB_CORES=1, **kwargs):
- LateFusionClassifier.__init__(self, kwargs['classifiersNames'], kwargs['monoviewClassifiersConfigs'],
- NB_CORES=NB_CORES)
- self.weights = map(float, kwargs['fusionMethodConfig'][0])
-
- def predict_hdf5(self, DATASET, usedIndices=None):
- # Normalize weights ?
- # weights = weights/float(max(weights))
- if usedIndices == None:
- usedIndices = range(DATASET.get("Metadata").attrs["datasetLength"])
- if usedIndices:
- predictedLabels = []
- viewScores = np.zeros((DATASET.get("Metadata").attrs["nbView"], len(usedIndices), DATASET.get("Metadata").attrs["nbClass"]))
- for viewIndex in range(DATASET.get("Metadata").attrs["nbView"]):
- viewScores[viewIndex] = self.monoviewClassifiers[viewIndex].predict_proba(
- DATASET.get("View" + str(viewIndex))[usedIndices])
- for currentIndex, usedIndex in enumerate(usedIndices):
- predictedLabel = np.argmax(np.array(
- [max(viewScore) * weight for viewScore, weight in zip(viewScores[:, currentIndex], self.weights)],
- dtype=float))
- predictedLabels.append(predictedLabel)
- # fusedExamples = np.array([sum(np.array([featureScores * weight for weight, featureScores in zip(weights, exampleDecisions)])) for exampleDecisions in monoViewDecisions])
- else:
- predictedLabels = []
-
- return predictedLabels
-
- def getConfig(self, fusionMethodConfig, monoviewClassifiersNames,monoviewClassifiersConfigs):
- configString = "with Weighted linear using a weight for each view : "+", ".join(self.weights) + \
- "\n\t-With monoview classifiers : "
- for monoviewClassifierConfig, monoviewClassifierName in zip(monoviewClassifiersConfigs, monoviewClassifiersNames):
- monoviewClassifierModule = getattr(MonoviewClassifiers, monoviewClassifierName)
- configString += monoviewClassifierModule.getConfig(monoviewClassifierConfig)
- return configString
-
-
-
-# The SVMClassifier is here used to find the right weights for linear fusion
-# Here we have a function to train it, one to fuse.
-# And one to do both.
-class SVMForLinear(LateFusionClassifier):
- def __init__(self, NB_CORES=1, **kwargs):
- LateFusionClassifier.__init__(self, kwargs['classifiersNames'], kwargs['monoviewClassifiersConfigs'],
- NB_CORES=NB_CORES)
- self.SVMClassifier = None
-
- def fit_hdf5(self, DATASET, trainIndices=None):
- if trainIndices == None:
- trainIndices = range(DATASET.get("Metadata").attrs["datasetLength"])
- nbViews = DATASET.get("Metadata").attrs["nbView"]
- for viewIndex in range(nbViews):
- monoviewClassifier = getattr(MonoviewClassifiers, self.monoviewClassifiersNames[viewIndex])
- self.monoviewClassifiers.append(
- monoviewClassifier.fit(DATASET.get("View" + str(viewIndex))[trainIndices],
- DATASET.get("labels")[trainIndices],
- NB_CORES=self.nbCores,
- **dict((str(configIndex), config) for configIndex, config in
- enumerate(self.monoviewClassifiersConfigs[viewIndex]
- ))))
- self.SVMForLinearFusionFit(DATASET, usedIndices=trainIndices)
-
- def predict_hdf5(self, DATASET, usedIndices=None):
- # Normalize weights ?
- # weights = weights/float(max(weights))
- if usedIndices == None:
- usedIndices = range(DATASET.get("Metadata").attrs["datasetLength"])
- if usedIndices:
- monoviewDecisions = np.zeros((len(usedIndices), DATASET.get("Metadata").attrs["nbView"]), dtype=int)
- for viewIndex in range(DATASET.get("Metadata").attrs["nbView"]):
- monoviewClassifier = getattr(MonoviewClassifiers, self.monoviewClassifiersNames[viewIndex])
- monoviewDecisions[:, viewIndex] = self.monoviewClassifiers[viewIndex].predict(
- DATASET.get("View" + str(viewIndex))[usedIndices])
- predictedLabels = self.SVMClassifier.predict(monoviewDecisions)
- else:
- predictedLabels = []
- return predictedLabels
-
- def SVMForLinearFusionFit(self, DATASET, usedIndices=None):
- self.SVMClassifier = OneVsOneClassifier(SVC())
- monoViewDecisions = np.zeros((len(usedIndices), DATASET.get("Metadata").attrs["nbView"]), dtype=int)
- for viewIndex in range(DATASET.get("Metadata").attrs["nbView"]):
- monoViewDecisions[:, viewIndex] = self.monoviewClassifiers[viewIndex].predict(
- DATASET.get("View" + str(viewIndex))[usedIndices])
-
- self.SVMClassifier.fit(monoViewDecisions, DATASET.get("labels")[usedIndices])
-
- def getConfig(self, fusionMethodConfig, monoviewClassifiersNames,monoviewClassifiersConfigs):
- configString = "with SVM for linear \n\t-With monoview classifiers : "
- for monoviewClassifierConfig, monoviewClassifierName in zip(monoviewClassifiersConfigs, monoviewClassifiersNames):
- monoviewClassifierModule = getattr(MonoviewClassifiers, monoviewClassifierName)
- configString += monoviewClassifierModule.getConfig(monoviewClassifierConfig)
- return configString
-
-
-# For majority voting, we have a problem : we have 5 fetures and 101 classes
-# on Calthech, so if each feature votes for one class, we can't find a good
-# result
-class MajorityVoting(LateFusionClassifier):
- def __init__(self, NB_CORES=1, **kwargs):
- LateFusionClassifier.__init__(self, kwargs['classifiersNames'], kwargs['monoviewClassifiersConfigs'],
- NB_CORES=NB_CORES)
-
- def predict_hdf5(self, DATASET, usedIndices=None):
- if usedIndices == None:
- usedIndices = range(DATASET.get("Metadata").attrs["datasetLength"])
- if usedIndices:
- datasetLength = len(usedIndices)
- votes = np.zeros((datasetLength, DATASET.get("Metadata").attrs["nbClass"]), dtype=int)
- monoViewDecisions = np.zeros((len(usedIndices),DATASET.get("Metadata").attrs["nbView"]), dtype=int)
- for viewIndex in range(DATASET.get("Metadata").attrs["nbView"]):
- monoViewDecisions[:, viewIndex] = self.monoviewClassifiers[viewIndex].predict(
- DATASET.get("View" + str(viewIndex))[usedIndices])
- for exampleIndex in range(datasetLength):
- for featureClassification in monoViewDecisions[exampleIndex, :]:
- votes[exampleIndex, featureClassification] += 1
- nbMaximum = len(np.where(votes[exampleIndex] == max(votes[exampleIndex]))[0])
- try:
- assert nbMaximum != DATASET.get("Metadata").attrs["nbView"]
- except:
- print "Majority voting can't decide, each classifier has voted for a different class"
- raise
- predictedLabels = np.argmax(votes, axis=1)
- # Can be upgraded by restarting a new classification process if
- # there are multiple maximums ?:
- # while nbMaximum>1:
- # relearn with only the classes that have a maximum number of vote
- # votes = revote
- # nbMaximum = len(np.where(votes==max(votes))[0])
- else:
- predictedLabels = []
- return predictedLabels
-
- def getConfig(self, fusionMethodConfig, monoviewClassifiersNames,monoviewClassifiersConfigs):
- configString = "with Majority Voting \n\t-With monoview classifiers : "
- for monoviewClassifierConfig, monoviewClassifierName in zip(monoviewClassifiersConfigs, monoviewClassifiersNames):
- monoviewClassifierModule = getattr(MonoviewClassifiers, monoviewClassifierName)
- configString += monoviewClassifierModule.getConfig(monoviewClassifierConfig)
- return configString
-
-
-# For probabilistic classifiers, we need to add more late fusion methods
-# For example, in the bayesian inference
-# probabilisticClassifiers is a nbExample array of sklearn probabilistic classifiers
-# (such as Naive Bayesian Gaussian
-# http://scikit-learn.org/stable/modules/generated/sklearn.naive_bayes.GaussianNB.html#sklearn.naive_bayes.GaussianNB)
-class BayesianInference(LateFusionClassifier):
- def __init__(self, NB_CORES=1, **kwargs):
- LateFusionClassifier.__init__(self, kwargs['classifiersNames'], kwargs['monoviewClassifiersConfigs'],
- NB_CORES=NB_CORES)
- self.weights = np.array(map(float, kwargs['fusionMethodConfig'][0]))
-
- def predict_hdf5(self, DATASET, usedIndices=None):
- nbView = DATASET.get("nbView").value
- if usedIndices == None:
- usedIndices = range(DATASET.get("Metadata").attrs["datasetLength"])
- if sum(self.weights)!=1.0:
- self.weights = self.weights/sum(self.weights)
- if usedIndices:
-
- viewScores = np.zeros((nbView, len(usedIndices), DATASET.get("Metadata").attrs["nbClass"]))
- for viewIndex in range(nbView):
- viewScores[viewIndex] = np.power(self.monoviewClassifiers[viewIndex].predict_proba(DATASET.get("View" + str(viewIndex))
- [usedIndices]),
- self.weights[viewIndex])
- predictedLabels = np.argmax(np.prod(viewScores, axis=1), axis=1)
- else:
- predictedLabels = []
- return predictedLabels
-
- def getConfig(self, fusionMethodConfig, monoviewClassifiersNames,monoviewClassifiersConfigs):
- configString = "with Bayesian Inference using a weight for each view : "+", ".join(self.weights) + \
- "\n\t-With monoview classifiers : "
- for monoviewClassifierConfig, monoviewClassifierName in zip(monoviewClassifiersConfigs, monoviewClassifiersNames):
- monoviewClassifierModule = getattr(MonoviewClassifiers, monoviewClassifierName)
- configString += monoviewClassifierModule.getConfig(monoviewClassifierConfig)
- return configString
-
-
-
-
+# class WeightedLinear(LateFusionClassifier):
+# def __init__(self, NB_CORES=1, **kwargs):
+# LateFusionClassifier.__init__(self, kwargs['classifiersNames'], kwargs['monoviewClassifiersConfigs'],
+# NB_CORES=NB_CORES)
+# self.weights = map(float, kwargs['fusionMethodConfig'][0])
+#
+# def predict_hdf5(self, DATASET, usedIndices=None):
+# # Normalize weights ?
+# # weights = weights/float(max(weights))
+# if usedIndices == None:
+# usedIndices = range(DATASET.get("Metadata").attrs["datasetLength"])
+# if usedIndices:
+# predictedLabels = []
+# viewScores = np.zeros((DATASET.get("Metadata").attrs["nbView"], len(usedIndices), DATASET.get("Metadata").attrs["nbClass"]))
+# for viewIndex in range(DATASET.get("Metadata").attrs["nbView"]):
+# viewScores[viewIndex] = self.monoviewClassifiers[viewIndex].predict_proba(
+# DATASET.get("View" + str(viewIndex))[usedIndices])
+# for currentIndex, usedIndex in enumerate(usedIndices):
+# predictedLabel = np.argmax(np.array(
+# [max(viewScore) * weight for viewScore, weight in zip(viewScores[:, currentIndex], self.weights)],
+# dtype=float))
+# predictedLabels.append(predictedLabel)
+# # fusedExamples = np.array([sum(np.array([featureScores * weight for weight, featureScores in zip(weights, exampleDecisions)])) for exampleDecisions in monoViewDecisions])
+# else:
+# predictedLabels = []
+#
+# return predictedLabels
+#
+# def getConfig(self, fusionMethodConfig, monoviewClassifiersNames,monoviewClassifiersConfigs):
+# configString = "with Weighted linear using a weight for each view : "+", ".join(self.weights) + \
+# "\n\t-With monoview classifiers : "
+# for monoviewClassifierConfig, monoviewClassifierName in zip(monoviewClassifiersConfigs, monoviewClassifiersNames):
+# monoviewClassifierModule = getattr(MonoviewClassifiers, monoviewClassifierName)
+# configString += monoviewClassifierModule.getConfig(monoviewClassifierConfig)
+# return configString
+#
+#
+#
+# # The SVMClassifier is here used to find the right weights for linear fusion
+# # Here we have a function to train it, one to fuse.
+# # And one to do both.
+# class SVMForLinear(LateFusionClassifier):
+# def __init__(self, NB_CORES=1, **kwargs):
+# LateFusionClassifier.__init__(self, kwargs['classifiersNames'], kwargs['monoviewClassifiersConfigs'],
+# NB_CORES=NB_CORES)
+# self.SVMClassifier = None
+#
+# def fit_hdf5(self, DATASET, trainIndices=None):
+# if trainIndices == None:
+# trainIndices = range(DATASET.get("Metadata").attrs["datasetLength"])
+# nbViews = DATASET.get("Metadata").attrs["nbView"]
+# for viewIndex in range(nbViews):
+# monoviewClassifier = getattr(MonoviewClassifiers, self.monoviewClassifiersNames[viewIndex])
+# self.monoviewClassifiers.append(
+# monoviewClassifier.fit(DATASET.get("View" + str(viewIndex))[trainIndices],
+# DATASET.get("labels")[trainIndices],
+# NB_CORES=self.nbCores,
+# **dict((str(configIndex), config) for configIndex, config in
+# enumerate(self.monoviewClassifiersConfigs[viewIndex]
+# )))[1])
+# self.SVMForLinearFusionFit(DATASET, usedIndices=trainIndices)
+#
+# def predict_hdf5(self, DATASET, usedIndices=None):
+# # Normalize weights ?
+# # weights = weights/float(max(weights))
+# if usedIndices == None:
+# usedIndices = range(DATASET.get("Metadata").attrs["datasetLength"])
+# if usedIndices:
+# monoviewDecisions = np.zeros((len(usedIndices), DATASET.get("Metadata").attrs["nbView"]), dtype=int)
+# for viewIndex in range(DATASET.get("Metadata").attrs["nbView"]):
+# monoviewClassifier = getattr(MonoviewClassifiers, self.monoviewClassifiersNames[viewIndex])
+# monoviewDecisions[:, viewIndex] = self.monoviewClassifiers[viewIndex].predict(
+# DATASET.get("View" + str(viewIndex))[usedIndices])
+# predictedLabels = self.SVMClassifier.predict(monoviewDecisions)
+# else:
+# predictedLabels = []
+# return predictedLabels
+#
+# def SVMForLinearFusionFit(self, DATASET, usedIndices=None):
+# self.SVMClassifier = OneVsOneClassifier(SVC())
+# monoViewDecisions = np.zeros((len(usedIndices), DATASET.get("Metadata").attrs["nbView"]), dtype=int)
+# for viewIndex in range(DATASET.get("Metadata").attrs["nbView"]):
+# monoViewDecisions[:, viewIndex] = self.monoviewClassifiers[viewIndex].predict(
+# DATASET.get("View" + str(viewIndex))[usedIndices])
+#
+# self.SVMClassifier.fit(monoViewDecisions, DATASET.get("labels")[usedIndices])
+#
+# def getConfig(self, fusionMethodConfig, monoviewClassifiersNames,monoviewClassifiersConfigs):
+# configString = "with SVM for linear \n\t-With monoview classifiers : "
+# for monoviewClassifierConfig, monoviewClassifierName in zip(monoviewClassifiersConfigs, monoviewClassifiersNames):
+# monoviewClassifierModule = getattr(MonoviewClassifiers, monoviewClassifierName)
+# configString += monoviewClassifierModule.getConfig(monoviewClassifierConfig)
+# return configString
+#
+#
+# # For majority voting, we have a problem : we have 5 fetures and 101 classes
+# # on Calthech, so if each feature votes for one class, we can't find a good
+# # result
+# class MajorityVoting(LateFusionClassifier):
+# def __init__(self, NB_CORES=1, **kwargs):
+# LateFusionClassifier.__init__(self, kwargs['classifiersNames'], kwargs['monoviewClassifiersConfigs'],
+# NB_CORES=NB_CORES)
+#
+# def predict_hdf5(self, DATASET, usedIndices=None):
+# if usedIndices == None:
+# usedIndices = range(DATASET.get("Metadata").attrs["datasetLength"])
+# if usedIndices:
+# datasetLength = len(usedIndices)
+# votes = np.zeros((datasetLength, DATASET.get("Metadata").attrs["nbClass"]), dtype=int)
+# monoViewDecisions = np.zeros((len(usedIndices),DATASET.get("Metadata").attrs["nbView"]), dtype=int)
+# for viewIndex in range(DATASET.get("Metadata").attrs["nbView"]):
+# monoViewDecisions[:, viewIndex] = self.monoviewClassifiers[viewIndex].predict(
+# DATASET.get("View" + str(viewIndex))[usedIndices])
+# for exampleIndex in range(datasetLength):
+# for featureClassification in monoViewDecisions[exampleIndex, :]:
+# votes[exampleIndex, featureClassification] += 1
+# nbMaximum = len(np.where(votes[exampleIndex] == max(votes[exampleIndex]))[0])
+# try:
+# assert nbMaximum != DATASET.get("Metadata").attrs["nbView"]
+# except:
+# print "Majority voting can't decide, each classifier has voted for a different class"
+# raise
+# predictedLabels = np.argmax(votes, axis=1)
+# # Can be upgraded by restarting a new classification process if
+# # there are multiple maximums ?:
+# # while nbMaximum>1:
+# # relearn with only the classes that have a maximum number of vote
+# # votes = revote
+# # nbMaximum = len(np.where(votes==max(votes))[0])
+# else:
+# predictedLabels = []
+# return predictedLabels
+#
+# def getConfig(self, fusionMethodConfig, monoviewClassifiersNames,monoviewClassifiersConfigs):
+# configString = "with Majority Voting \n\t-With monoview classifiers : "
+# for monoviewClassifierConfig, monoviewClassifierName in zip(monoviewClassifiersConfigs, monoviewClassifiersNames):
+# monoviewClassifierModule = getattr(MonoviewClassifiers, monoviewClassifierName)
+# configString += monoviewClassifierModule.getConfig(monoviewClassifierConfig)
+# return configString
+#
+#
+# # For probabilistic classifiers, we need to add more late fusion methods
+# # For example, in the bayesian inference
+# # probabilisticClassifiers is a nbExample array of sklearn probabilistic classifiers
+# # (such as Naive Bayesian Gaussian
+# # http://scikit-learn.org/stable/modules/generated/sklearn.naive_bayes.GaussianNB.html#sklearn.naive_bayes.GaussianNB)
+# class BayesianInference(LateFusionClassifier):
+# def __init__(self, NB_CORES=1, **kwargs):
+# LateFusionClassifier.__init__(self, kwargs['classifiersNames'], kwargs['monoviewClassifiersConfigs'],
+# NB_CORES=NB_CORES)
+# self.weights = np.array(map(float, kwargs['fusionMethodConfig'][0]))
+#
+# def predict_hdf5(self, DATASET, usedIndices=None):
+# nbView = DATASET.get("nbView").value
+# if usedIndices == None:
+# usedIndices = range(DATASET.get("Metadata").attrs["datasetLength"])
+# if sum(self.weights)!=1.0:
+# self.weights = self.weights/sum(self.weights)
+# if usedIndices:
+#
+# viewScores = np.zeros((nbView, len(usedIndices), DATASET.get("Metadata").attrs["nbClass"]))
+# for viewIndex in range(nbView):
+# viewScores[viewIndex] = np.power(self.monoviewClassifiers[viewIndex].predict_proba(DATASET.get("View" + str(viewIndex))
+# [usedIndices]),
+# self.weights[viewIndex])
+# predictedLabels = np.argmax(np.prod(viewScores, axis=1), axis=1)
+# else:
+# predictedLabels = []
+# return predictedLabels
+#
+# def getConfig(self, fusionMethodConfig, monoviewClassifiersNames,monoviewClassifiersConfigs):
+# configString = "with Bayesian Inference using a weight for each view : "+", ".join(self.weights) + \
+# "\n\t-With monoview classifiers : "
+# for monoviewClassifierConfig, monoviewClassifierName in zip(monoviewClassifiersConfigs, monoviewClassifiersNames):
+# monoviewClassifierModule = getattr(MonoviewClassifiers, monoviewClassifierName)
+# configString += monoviewClassifierModule.getConfig(monoviewClassifierConfig)
+# return configString
+#
+#
+#
#
-# def weightedProduct(featureProbas, weights):
-# try:
-# assert np.sum(weights) == 1.0
-# except:
+# #
+# # def weightedProduct(featureProbas, weights):
+# # try:
+# # assert np.sum(weights) == 1.0
+# # except:
# print "Need to give a weight array that sums to one"
# raise
# weightedProbas = np.power(featureProbas, weights)
diff --git a/Code/MonoMutliViewClassifiers/Multiview/Fusion/Methods/LateFusionPackage/BayesianInference.py b/Code/MonoMutliViewClassifiers/Multiview/Fusion/Methods/LateFusionPackage/BayesianInference.py
new file mode 100644
index 0000000000000000000000000000000000000000..af908e11bf76d1ba37ab0b92cfac9e84c0ecd935
--- /dev/null
+++ b/Code/MonoMutliViewClassifiers/Multiview/Fusion/Methods/LateFusionPackage/BayesianInference.py
@@ -0,0 +1,54 @@
+from LateFusion import LateFusionClassifier
+import MonoviewClassifiers
+import numpy as np
+from sklearn.metrics import accuracy_score
+
+def gridSearch(DATASET, classificationKWARGS, trainIndices):
+ bestScore = 0.0
+ bestConfig = None
+ if classificationKWARGS["fusionMethodConfig"][0] is not None:
+ for i in range(0):
+ randomWeightsArray = np.random.random_sample(len(DATASET.get("Metadata").attrs["nbView"]))
+ normalizedArray = randomWeightsArray/np.sum(randomWeightsArray)
+ classificationKWARGS["fusionMethodConfig"][0] = normalizedArray
+ classifier = BayesianInference(1, **classificationKWARGS)
+ classifier.fit_hdf5(DATASET, trainIndices)
+ predictedLabels = classifier.predict_hdf5(DATASET, trainIndices)
+ accuracy = accuracy_score(DATASET.get("labels")[trainIndices], predictedLabels)
+ if accuracy > bestScore:
+ bestScore = accuracy
+ bestConfig = normalizedArray
+ return bestConfig
+
+
+class BayesianInference(LateFusionClassifier):
+ def __init__(self, NB_CORES=1, **kwargs):
+ LateFusionClassifier.__init__(self, kwargs['classifiersNames'], kwargs['monoviewClassifiersConfigs'],
+ NB_CORES=NB_CORES)
+ self.weights = np.array(map(float, kwargs['fusionMethodConfig'][0]))
+
+ def predict_hdf5(self, DATASET, usedIndices=None):
+ nbView = DATASET.get("nbView").value
+ if usedIndices == None:
+ usedIndices = range(DATASET.get("Metadata").attrs["datasetLength"])
+ if sum(self.weights)!=1.0:
+ self.weights = self.weights/sum(self.weights)
+ if usedIndices:
+
+ viewScores = np.zeros((nbView, len(usedIndices), DATASET.get("Metadata").attrs["nbClass"]))
+ for viewIndex in range(nbView):
+ viewScores[viewIndex] = np.power(self.monoviewClassifiers[viewIndex].predict_proba(DATASET.get("View" + str(viewIndex))
+ [usedIndices]),
+ self.weights[viewIndex])
+ predictedLabels = np.argmax(np.prod(viewScores, axis=1), axis=1)
+ else:
+ predictedLabels = []
+ return predictedLabels
+
+ def getConfig(self, fusionMethodConfig, monoviewClassifiersNames,monoviewClassifiersConfigs):
+ configString = "with Bayesian Inference using a weight for each view : "+", ".join(self.weights) + \
+ "\n\t-With monoview classifiers : "
+ for monoviewClassifierConfig, monoviewClassifierName in zip(monoviewClassifiersConfigs, monoviewClassifiersNames):
+ monoviewClassifierModule = getattr(MonoviewClassifiers, monoviewClassifierName)
+ configString += monoviewClassifierModule.getConfig(monoviewClassifierConfig)
+ return configString
\ No newline at end of file
diff --git a/Code/MonoMutliViewClassifiers/Multiview/Fusion/Methods/LateFusionPackage/MajorityVoting.py b/Code/MonoMutliViewClassifiers/Multiview/Fusion/Methods/LateFusionPackage/MajorityVoting.py
new file mode 100644
index 0000000000000000000000000000000000000000..ce837a4c4475fa971d2365c2ee4e984e877cde3c
--- /dev/null
+++ b/Code/MonoMutliViewClassifiers/Multiview/Fusion/Methods/LateFusionPackage/MajorityVoting.py
@@ -0,0 +1,66 @@
+from LateFusion import LateFusionClassifier
+import MonoviewClassifiers
+import numpy as np
+from sklearn.metrics import accuracy_score
+
+
+def gridSearch(DATASET, classificationKWARGS, trainIndices):
+ bestScore = 0.0
+ bestConfig = None
+ if classificationKWARGS["fusionMethodConfig"][0] is not None:
+ for i in range(0):
+ randomWeightsArray = np.random.random_sample(len(DATASET.get("Metadata").attrs["nbView"]))
+ normalizedArray = randomWeightsArray/np.sum(randomWeightsArray)
+ classificationKWARGS["fusionMethodConfig"][0] = normalizedArray
+ classifier = MajorityVoting(1, **classificationKWARGS)
+ classifier.fit_hdf5(DATASET, trainIndices)
+ predictedLabels = classifier.predict_hdf5(DATASET, trainIndices)
+ accuracy = accuracy_score(DATASET.get("labels")[trainIndices], predictedLabels)
+ if accuracy > bestScore:
+ bestScore = accuracy
+ bestConfig = normalizedArray
+ return bestConfig
+
+
+class MajorityVoting(LateFusionClassifier):
+ def __init__(self, NB_CORES=1, **kwargs):
+ LateFusionClassifier.__init__(self, kwargs['classifiersNames'], kwargs['monoviewClassifiersConfigs'],
+ NB_CORES=NB_CORES)
+ self.weights = np.array(map(float, kwargs['fusionMethodConfig'][0]))
+
+ def predict_hdf5(self, DATASET, usedIndices=None):
+ if usedIndices == None:
+ usedIndices = range(DATASET.get("Metadata").attrs["datasetLength"])
+ if usedIndices:
+ datasetLength = len(usedIndices)
+ votes = np.zeros((datasetLength, DATASET.get("Metadata").attrs["nbClass"]), dtype=int)
+ monoViewDecisions = np.zeros((len(usedIndices),DATASET.get("Metadata").attrs["nbView"]), dtype=int)
+ for viewIndex in range(DATASET.get("Metadata").attrs["nbView"]):
+ monoViewDecisions[:, viewIndex] = self.monoviewClassifiers[viewIndex].predict(
+ DATASET.get("View" + str(viewIndex))[usedIndices])
+ for exampleIndex in range(datasetLength):
+ for viewIndex, featureClassification in enumerate(monoViewDecisions[exampleIndex, :]):
+ votes[exampleIndex, featureClassification] += self.weights[viewIndex]
+ nbMaximum = len(np.where(votes[exampleIndex] == max(votes[exampleIndex]))[0])
+ try:
+ assert nbMaximum != DATASET.get("Metadata").attrs["nbView"]
+ except:
+ print "Majority voting can't decide, each classifier has voted for a different class"
+ raise
+ predictedLabels = np.argmax(votes, axis=1)
+ # Can be upgraded by restarting a new classification process if
+ # there are multiple maximums ?:
+ # while nbMaximum>1:
+ # relearn with only the classes that have a maximum number of vote
+ # votes = revote
+ # nbMaximum = len(np.where(votes==max(votes))[0])
+ else:
+ predictedLabels = []
+ return predictedLabels
+
+ def getConfig(self, fusionMethodConfig, monoviewClassifiersNames,monoviewClassifiersConfigs):
+ configString = "with Majority Voting \n\t-With monoview classifiers : "
+ for monoviewClassifierConfig, monoviewClassifierName in zip(monoviewClassifiersConfigs, monoviewClassifiersNames):
+ monoviewClassifierModule = getattr(MonoviewClassifiers, monoviewClassifierName)
+ configString += monoviewClassifierModule.getConfig(monoviewClassifierConfig)
+ return configString
\ No newline at end of file
diff --git a/Code/MonoMutliViewClassifiers/Multiview/Fusion/Methods/LateFusionPackage/SVMForLinear.py b/Code/MonoMutliViewClassifiers/Multiview/Fusion/Methods/LateFusionPackage/SVMForLinear.py
new file mode 100644
index 0000000000000000000000000000000000000000..a64644062d7206b5605ac64dc243ce5f8d57aaf4
--- /dev/null
+++ b/Code/MonoMutliViewClassifiers/Multiview/Fusion/Methods/LateFusionPackage/SVMForLinear.py
@@ -0,0 +1,63 @@
+from LateFusion import LateFusionClassifier
+import MonoviewClassifiers
+import numpy as np
+from sklearn.multiclass import OneVsOneClassifier
+from sklearn.svm import SVC
+
+
+def gridSearch(DATASET, classificationKWARGS, trainIndices):
+ return None
+
+
+class SVMForLinear(LateFusionClassifier):
+ def __init__(self, NB_CORES=1, **kwargs):
+ LateFusionClassifier.__init__(self, kwargs['classifiersNames'], kwargs['monoviewClassifiersConfigs'],
+ NB_CORES=NB_CORES)
+ self.SVMClassifier = None
+
+ def fit_hdf5(self, DATASET, trainIndices=None):
+ if trainIndices == None:
+ trainIndices = range(DATASET.get("Metadata").attrs["datasetLength"])
+ nbViews = DATASET.get("Metadata").attrs["nbView"]
+ for viewIndex in range(nbViews):
+ monoviewClassifier = getattr(MonoviewClassifiers, self.monoviewClassifiersNames[viewIndex])
+ self.monoviewClassifiers.append(
+ monoviewClassifier.fit(DATASET.get("View" + str(viewIndex))[trainIndices],
+ DATASET.get("labels")[trainIndices],
+ NB_CORES=self.nbCores,
+ **dict((str(configIndex), config) for configIndex, config in
+ enumerate(self.monoviewClassifiersConfigs[viewIndex]
+ )))[1])
+ self.SVMForLinearFusionFit(DATASET, usedIndices=trainIndices)
+
+ def predict_hdf5(self, DATASET, usedIndices=None):
+ # Normalize weights ?
+ # weights = weights/float(max(weights))
+ if usedIndices == None:
+ usedIndices = range(DATASET.get("Metadata").attrs["datasetLength"])
+ if usedIndices:
+ monoviewDecisions = np.zeros((len(usedIndices), DATASET.get("Metadata").attrs["nbView"]), dtype=int)
+ for viewIndex in range(DATASET.get("Metadata").attrs["nbView"]):
+ monoviewClassifier = getattr(MonoviewClassifiers, self.monoviewClassifiersNames[viewIndex])
+ monoviewDecisions[:, viewIndex] = self.monoviewClassifiers[viewIndex].predict(
+ DATASET.get("View" + str(viewIndex))[usedIndices])
+ predictedLabels = self.SVMClassifier.predict(monoviewDecisions)
+ else:
+ predictedLabels = []
+ return predictedLabels
+
+ def SVMForLinearFusionFit(self, DATASET, usedIndices=None):
+ self.SVMClassifier = OneVsOneClassifier(SVC())
+ monoViewDecisions = np.zeros((len(usedIndices), DATASET.get("Metadata").attrs["nbView"]), dtype=int)
+ for viewIndex in range(DATASET.get("Metadata").attrs["nbView"]):
+ monoViewDecisions[:, viewIndex] = self.monoviewClassifiers[viewIndex].predict(
+ DATASET.get("View" + str(viewIndex))[usedIndices])
+
+ self.SVMClassifier.fit(monoViewDecisions, DATASET.get("labels")[usedIndices])
+
+ def getConfig(self, fusionMethodConfig, monoviewClassifiersNames,monoviewClassifiersConfigs):
+ configString = "with SVM for linear \n\t-With monoview classifiers : "
+ for monoviewClassifierConfig, monoviewClassifierName in zip(monoviewClassifiersConfigs, monoviewClassifiersNames):
+ monoviewClassifierModule = getattr(MonoviewClassifiers, monoviewClassifierName)
+ configString += monoviewClassifierModule.getConfig(monoviewClassifierConfig)
+ return configString
\ No newline at end of file
diff --git a/Code/MonoMutliViewClassifiers/Multiview/Fusion/Methods/LateFusionPackage/WeightedLinear.py b/Code/MonoMutliViewClassifiers/Multiview/Fusion/Methods/LateFusionPackage/WeightedLinear.py
new file mode 100644
index 0000000000000000000000000000000000000000..3ba4b76b104a1179e276df6b583c0a7dfa1b8dcf
--- /dev/null
+++ b/Code/MonoMutliViewClassifiers/Multiview/Fusion/Methods/LateFusionPackage/WeightedLinear.py
@@ -0,0 +1,59 @@
+from LateFusion import LateFusionClassifier
+import MonoviewClassifiers
+import numpy as np
+from sklearn.metrics import accuracy_score
+
+
+def gridSearch(DATASET, classificationKWARGS, trainIndices):
+ bestScore = 0.0
+ bestConfig = None
+ if classificationKWARGS["fusionMethodConfig"][0] is not None:
+ for i in range(0):
+ randomWeightsArray = np.random.random_sample(len(DATASET.get("Metadata").attrs["nbView"]))
+ normalizedArray = randomWeightsArray/np.sum(randomWeightsArray)
+ classificationKWARGS["fusionMethodConfig"][0] = normalizedArray
+ classifier = WeightedLinear(1, **classificationKWARGS)
+ classifier.fit_hdf5(DATASET, trainIndices)
+ predictedLabels = classifier.predict_hdf5(DATASET, trainIndices)
+ accuracy = accuracy_score(DATASET.get("labels")[trainIndices], predictedLabels)
+ if accuracy > bestScore:
+ bestScore = accuracy
+ bestConfig = normalizedArray
+ return bestConfig
+
+
+class WeightedLinear(LateFusionClassifier):
+ def __init__(self, NB_CORES=1, **kwargs):
+ LateFusionClassifier.__init__(self, kwargs['classifiersNames'], kwargs['monoviewClassifiersConfigs'],
+ NB_CORES=NB_CORES)
+ self.weights = map(float, kwargs['fusionMethodConfig'][0])
+
+ def predict_hdf5(self, DATASET, usedIndices=None):
+ # Normalize weights ?
+ # weights = weights/float(max(weights))
+ if usedIndices == None:
+ usedIndices = range(DATASET.get("Metadata").attrs["datasetLength"])
+ if usedIndices:
+ predictedLabels = []
+ viewScores = np.zeros((DATASET.get("Metadata").attrs["nbView"], len(usedIndices), DATASET.get("Metadata").attrs["nbClass"]))
+ for viewIndex in range(DATASET.get("Metadata").attrs["nbView"]):
+ viewScores[viewIndex] = self.monoviewClassifiers[viewIndex].predict_proba(
+ DATASET.get("View" + str(viewIndex))[usedIndices])
+ for currentIndex, usedIndex in enumerate(usedIndices):
+ predictedLabel = np.argmax(np.array(
+ [max(viewScore) * weight for viewScore, weight in zip(viewScores[:, currentIndex], self.weights)],
+ dtype=float))
+ predictedLabels.append(predictedLabel)
+ # fusedExamples = np.array([sum(np.array([featureScores * weight for weight, featureScores in zip(weights, exampleDecisions)])) for exampleDecisions in monoViewDecisions])
+ else:
+ predictedLabels = []
+
+ return predictedLabels
+
+ def getConfig(self, fusionMethodConfig, monoviewClassifiersNames,monoviewClassifiersConfigs):
+ configString = "with Weighted linear using a weight for each view : "+", ".join(self.weights) + \
+ "\n\t-With monoview classifiers : "
+ for monoviewClassifierConfig, monoviewClassifierName in zip(monoviewClassifiersConfigs, monoviewClassifiersNames):
+ monoviewClassifierModule = getattr(MonoviewClassifiers, monoviewClassifierName)
+ configString += monoviewClassifierModule.getConfig(monoviewClassifierConfig)
+ return configString
diff --git a/Code/MonoMutliViewClassifiers/Multiview/Fusion/Methods/LateFusionPackage/__init__.py b/Code/MonoMutliViewClassifiers/Multiview/Fusion/Methods/LateFusionPackage/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/Code/MonoMutliViewClassifiers/Multiview/Fusion/Methods/__init__.py b/Code/MonoMutliViewClassifiers/Multiview/Fusion/Methods/__init__.py
index 5604e81d6a3edf7aadd8aec8628e91f08f94ec38..b99d85d7dfafb8eb7c2cd4d152d73bfb9e719ec6 100644
--- a/Code/MonoMutliViewClassifiers/Multiview/Fusion/Methods/__init__.py
+++ b/Code/MonoMutliViewClassifiers/Multiview/Fusion/Methods/__init__.py
@@ -1,2 +1 @@
-
-from . import EarlyFusion, LateFusion
\ No newline at end of file
+from . import EarlyFusionPackage, LateFusionPackage
\ No newline at end of file
diff --git a/Code/MonoMutliViewClassifiers/Multiview/Mumbo/Classifiers/DecisionTree.py b/Code/MonoMutliViewClassifiers/Multiview/Mumbo/Classifiers/DecisionTree.py
index 2981081de25a515c7055d3f12155f37c3eea0df9..5aa54619ae299b60ad7dfd32821a2efe8e0cb6ed 100644
--- a/Code/MonoMutliViewClassifiers/Multiview/Mumbo/Classifiers/DecisionTree.py
+++ b/Code/MonoMutliViewClassifiers/Multiview/Mumbo/Classifiers/DecisionTree.py
@@ -24,11 +24,13 @@ def DecisionTree(data, labels, arg, weights):
return classifier, prediction, isBad, accuracy
+
def getConfig(classifierConfig):
depth = classifierConfig[0]
subSampling = classifierConfig[1]
return 'with depth ' + str(depth) + ', ' + ' sub-sampled at ' + str(subSampling) + ' '
+
def gridSearch(data, labels):
minSubSampling = 1.0/(len(labels)/2)
bestSettings = []
diff --git a/Code/MonoMutliViewClassifiers/Multiview/Mumbo/Mumbo.py b/Code/MonoMutliViewClassifiers/Multiview/Mumbo/Mumbo.py
index 084192fbb8d3a9548f09d2990ee35a889ee8bc74..c4a02a2849006cd79bbf4d80a4578ccf5f73d8b2 100644
--- a/Code/MonoMutliViewClassifiers/Multiview/Mumbo/Mumbo.py
+++ b/Code/MonoMutliViewClassifiers/Multiview/Mumbo/Mumbo.py
@@ -39,7 +39,8 @@ def trainWeakClassifier_hdf5(classifierName, monoviewDataset, CLASS_LABELS, DATA
logging.debug("\t\t\tView " + str(viewIndice) + " : " + str(averageAccuracy))
return classifier, classes, isBad, averageAccuracy
-def gridSearch_hdf5(DATASET, classifiersNames):
+def gridSearch_hdf5(DATASET, classificationKWARGS):
+ classifiersNames = classificationKWARGS["classifiersNames"]
bestSettings = []
for classifierIndex, classifierName in enumerate(classifiersNames):
logging.debug("\tStart:\t Gridsearch for "+classifierName+" on "+DATASET.get("View"+str(classifierIndex)).attrs["name"])
@@ -48,7 +49,7 @@ def gridSearch_hdf5(DATASET, classifiersNames):
bestSettings.append(classifierMethod(DATASET.get("View"+str(classifierIndex))[...],
DATASET.get("labels")[...]))
logging.debug("\tDone:\t Gridsearch for "+classifierName)
- return bestSettings
+ return bestSettings, None