Mercurial > repos > jay > pdaug_peptide_core_functions
comparison PDAUG_ML_Models/PDAUG_ML_Models.py @ 0:e743e76b8991 draft
"planemo upload for repository https://github.com/jaidevjoshi83/pdaug commit a9bd83f6a1afa6338cb6e4358b63ebff5bed155e"
author | jay |
---|---|
date | Wed, 28 Oct 2020 02:07:30 +0000 |
parents | |
children |
comparison
equal
deleted
inserted
replaced
-1:000000000000 | 0:e743e76b8991 |
---|---|
1 | |
2 import numpy as np | |
3 import sys,os | |
4 from scipy import interp | |
5 import pandas as pd | |
6 | |
7 ############################################################### | |
8 from sklearn.metrics import * | |
9 from sklearn import preprocessing | |
10 from sklearn.metrics import accuracy_score | |
11 from sklearn.metrics import precision_recall_fscore_support | |
12 from sklearn.metrics import roc_curve, auc | |
13 from sklearn.model_selection import StratifiedKFold | |
14 from sklearn.preprocessing import StandardScaler | |
15 from sklearn.preprocessing import MinMaxScaler | |
16 ############################################################### | |
17 from sklearn.linear_model import LogisticRegression | |
18 from sklearn.naive_bayes import GaussianNB | |
19 from sklearn.neighbors import KNeighborsClassifier | |
20 from sklearn.tree import DecisionTreeClassifier | |
21 from sklearn.svm import SVC | |
22 from sklearn.ensemble import RandomForestClassifier | |
23 from sklearn.linear_model import SGDClassifier | |
24 from sklearn.ensemble import GradientBoostingClassifier | |
25 from sklearn.neural_network import MLPClassifier | |
26 ############################################################### | |
27 from itertools import cycle | |
28 ################################################################ | |
29 from sklearn.model_selection import train_test_split | |
30 | |
31 | |
32 | |
33 def ReturnData(TrainFile, TestMethod, TestFile=None): | |
34 | |
35 if (TestFile == None) and (TestMethod == 'Internal' or 'CrossVal'): | |
36 | |
37 df = pd.read_csv(TrainFile, sep='\t') | |
38 clm_list = df.columns.tolist() | |
39 X_train = df[clm_list[0:len(clm_list)-1]].values | |
40 y_train = df[clm_list[len(clm_list)-1]].values | |
41 X_test = None | |
42 y_test = None | |
43 return X_train, y_train, X_test, y_test | |
44 | |
45 elif (TestFile is not None) and (TestMethod == 'External'): | |
46 | |
47 df = pd.read_csv(TrainFile, sep='\t') | |
48 clm_list = df.columns.tolist() | |
49 X_train = df[clm_list[0:len(clm_list)-1]].values | |
50 y_train = df[clm_list[len(clm_list)-1]].values | |
51 df1 = pd.read_csv(TestFile, sep='\t') | |
52 clm_list = df1.columns.tolist() | |
53 X_test = df1[clm_list[0:len(clm_list)-1]].values | |
54 y_test = df1[clm_list[len(clm_list)-1]].values | |
55 return X_train, y_train, X_test, y_test | |
56 | |
57 elif (TestFile is not None) and (TestMethod == 'Predict'): | |
58 | |
59 df = pd.read_csv(TrainFile, sep='\t') | |
60 clm_list = df.columns.tolist() | |
61 X_train = df[clm_list[0:len(clm_list)-1]].values | |
62 y_train = df[clm_list[len(clm_list)-1]].values | |
63 | |
64 df = pd.read_csv(TestFile, sep='\t') | |
65 X_test = df | |
66 y_test = None | |
67 return X_train, y_train, X_train, y_train | |
68 | |
69 def Fit_Model(TrainData, Test_Method, Algo, Selected_Sclaer, Workdirpath, htmlOutDir, OutFile, htmlFname, NoOfFolds=None, TestSize=None, TestData=None ): | |
70 | |
71 if not os.path.exists(htmlOutDir): | |
72 os.makedirs(htmlOutDir) | |
73 | |
74 if Test_Method == 'Internal': | |
75 X,y,_,_ = ReturnData(TrainData, Test_Method) | |
76 | |
77 mean_tpr = 0.0 | |
78 mean_fpr = np.linspace(0, 1, 100) | |
79 | |
80 specificity_list = [] | |
81 sensitivity_list = [] | |
82 precison_list = [] | |
83 mcc_list = [] | |
84 f1_list = [] | |
85 | |
86 folds = StratifiedKFold(n_splits=5) | |
87 mean_tpr = 0.0 | |
88 mean_fpr = np.linspace(0, 1, 100) | |
89 | |
90 ########################## | |
91 accuracy_score_l = [] | |
92 cohen_kappa_score_l = [] | |
93 matthews_corrcoef_l = [] | |
94 precision_l = [] | |
95 recall_l = [] | |
96 f_score_l = [] | |
97 ########################## | |
98 | |
99 folds = StratifiedKFold(n_splits=5) | |
100 | |
101 for i, (train, test) in enumerate(folds.split(X, y)): | |
102 | |
103 if Selected_Sclaer=='Min_Max': | |
104 scaler = MinMaxScaler().fit(X[train]) | |
105 x_train = scaler.transform(X[train]) | |
106 x_test = scaler.transform(X[test]) | |
107 | |
108 elif Selected_Sclaer=='Standard_Scaler': | |
109 scaler = preprocessing.StandardScaler().fit(X[train]) | |
110 x_train = scaler.transform(X[train]) | |
111 x_test = scaler.transform(X[test]) | |
112 | |
113 elif Selected_Sclaer == 'No_Scaler': | |
114 x_train = X[train] | |
115 x_test = X[test] | |
116 | |
117 else: | |
118 print('Scalling Method option was not correctly selected...!') | |
119 | |
120 prob = Algo.fit(x_train, y[train]).predict_proba(x_test) | |
121 predicted = Algo.fit(x_train, y[train]).predict(x_test) | |
122 | |
123 fpr, tpr, thresholds = roc_curve(y[test], prob[:, 1]) | |
124 mean_tpr += interp(mean_fpr, fpr, tpr) | |
125 mean_tpr[0] = 0.0 | |
126 | |
127 TN, FP, FN, TP = confusion_matrix(y[test], predicted).ravel() | |
128 | |
129 accuracy_score_l.append(round(accuracy_score(y[test], predicted),3)) | |
130 a = precision_recall_fscore_support(y[test], predicted, average='macro') | |
131 precision_l.append(round(a[0],3)) | |
132 recall_l.append(round(a[1],3)) | |
133 f_score_l .append(round(a[2],3)) | |
134 | |
135 accuracy_score_mean = round(float(sum(accuracy_score_l)/float(len(accuracy_score_l))),3) | |
136 precision_mean = round(float(sum(precision_l)/float(len(precision_l))),3) | |
137 recall_mean = round(float(sum(recall_l)/float(len(recall_l))),3) | |
138 f_score_mean = round(float(sum(f_score_l )/float(len(f_score_l ))),3) | |
139 | |
140 | |
141 mean_tpr /= folds.get_n_splits(X, y) | |
142 mean_tpr[-1] = 1.0 | |
143 mean_auc = auc(mean_fpr, mean_tpr) | |
144 | |
145 ######################################################################################################################################## | |
146 V_header = ["Algo","accuracy","precision","recall","f1","mean_auc"] # | |
147 v_values = [sys.argv[1], round(accuracy_score_mean, 3), round(precision_mean, 3), round(recall_mean, 3),round(f_score_mean, 3), round(mean_auc, 3)] # | |
148 ######################################################################################################################################## | |
149 | |
150 df = pd.DataFrame([v_values], columns=V_header) | |
151 df.to_csv(os.path.join(Workdirpath, OutFile), columns=V_header, sep='\t', index=None) | |
152 | |
153 ############################################################ | |
154 from plotly.subplots import make_subplots | |
155 import plotly.graph_objects as go | |
156 | |
157 fig = make_subplots( | |
158 rows=1, cols=2, | |
159 specs=[[{"type": "xy"}, {"type": "scatter"}],], subplot_titles=("Algorithm performance", " ROC curve (AUC Score = %0.2f" % mean_auc+')'), | |
160 | |
161 ) | |
162 | |
163 fig.add_trace( go.Bar(x=V_header[1:], y=v_values[1:],marker_color=['#F58518','#109618','#E45756','#1F77B4','#19D3F3']), row=1, col=1) | |
164 | |
165 print (mean_fpr, mean_tpr) | |
166 | |
167 fig.add_trace(go.Scatter(x=mean_fpr, y=mean_tpr), row=1, col=2) | |
168 fig.update_yaxes(title_text="True Positive Rate", range=[0, 1], row=1, col=2) | |
169 fig.update_xaxes(title_text="False Positive Rate", range=[0, 1], row=1, col=2) | |
170 fig.update_yaxes(title_text="Score", range=[0, 1], row=1, col=1) | |
171 fig.update_xaxes(title_text="Performance measures",row=1, col=1) | |
172 fig.update_layout(height=700, showlegend=False, title="Machine ") | |
173 fig.write_html(os.path.join(Workdirpath, htmlOutDir, htmlFname)) | |
174 | |
175 ############################################################ | |
176 | |
177 elif Test_Method == 'External': | |
178 | |
179 X_train,y_train,X_test,y_test = ReturnData(TrainData, Test_Method, TestData) | |
180 | |
181 if Selected_Sclaer=='Min_Max': | |
182 scaler = MinMaxScaler().fit(X_train) | |
183 x_train = scaler.transform(X_train) | |
184 x_test = scaler.transform(X_test) | |
185 | |
186 elif Selected_Sclaer=='Standard_Scaler': | |
187 scaler = preprocessing.StandardScaler().fit(X_train) | |
188 x_train = scaler.transform(X_train) | |
189 x_test = scaler.transform(X_test) | |
190 | |
191 elif Selected_Sclaer == 'No_Scaler': | |
192 x_train = X_train | |
193 x_test = X_test | |
194 | |
195 else: | |
196 print('Scalling Method option was not correctly selected...!') | |
197 | |
198 prob = Algo.fit(x_train, y_train).predict_proba(x_test) | |
199 predicted = Algo.fit(x_train, y_train).predict(x_test) | |
200 | |
201 fpr, tpr, thresholds = roc_curve(y_test, prob[:, 1]) | |
202 TN, FP, FN, TP = confusion_matrix(y_test, predicted).ravel() | |
203 accu_score = accuracy_score(y_test, predicted) | |
204 | |
205 a = precision_recall_fscore_support(y_test, predicted, average='macro') | |
206 | |
207 pre_score = round(a[0],3) | |
208 recall_score= round(a[1],3) | |
209 f_score= round(a[2],3) | |
210 | |
211 pl.plot(fpr, tpr, '--', lw=2) | |
212 auc_score = auc(fpr, tpr) | |
213 | |
214 a = precision_recall_fscore_support(y_test, predicted, average='macro') | |
215 pre_score = round(a[0],3) | |
216 rec_score = round(a[1],3) | |
217 f_score = round(a[2],3) | |
218 | |
219 V_header = ["accuracy","presision","recall","f1","mean_auc"] | |
220 v_values = [accu_score, pre_score, rec_score, f_score, auc_score] | |
221 | |
222 pl.figure() | |
223 pl.plot(fpr, tpr, '-', color='red',label='AUC = %0.2f' % auc_score, lw=2) | |
224 pl.xlim([0.0, 1.0]) | |
225 pl.ylim([0.0, 1.05]) | |
226 pl.xlabel('False Positive Rate') | |
227 pl.ylabel('True Positive Rate') | |
228 pl.title('ROC Cureve') | |
229 pl.legend(loc="lower right") | |
230 | |
231 df = pd.DataFrame([v_values], columns=V_header) | |
232 pl.savefig(os.path.join(Workdirpath, htmlOutDir, "out.png")) | |
233 df.to_csv(os.path.join(Workdirpath, OutFile), columns=V_header, sep='\t') | |
234 pl.figure() | |
235 pl.bar(V_header, v_values, color=(0.2, 0.4, 0.6, 0.6)) | |
236 pl.xlabel('Accuracy Perameters', fontweight='bold', color = 'orange', fontsize='17', horizontalalignment='center') | |
237 pl.savefig(os.path.join(Workdirpath, htmlOutDir, "2.png")) | |
238 #pl.show() | |
239 HTML_Gen(os.path.join(Workdirpath, htmlOutDir, htmlFname)) | |
240 | |
241 elif Test_Method == "TestSplit": | |
242 | |
243 X_train,y_train,_,_ = ReturnData(TrainData, Test_Method) | |
244 X_train, X_test, y_train, y_test = train_test_split(X_train, y_train, test_size=float(TestSize), random_state=0) | |
245 | |
246 | |
247 if Selected_Sclaer=='Min_Max': | |
248 scaler = MinMaxScaler().fit(X_train) | |
249 x_train = scaler.transform(X_train) | |
250 x_test = scaler.transform(X_test) | |
251 | |
252 elif Selected_Sclaer=='Standard_Scaler': | |
253 scaler = preprocessing.StandardScaler().fit(X_train) | |
254 x_train = scaler.transform(X_train) | |
255 x_test = scaler.transform(X_test) | |
256 | |
257 elif Selected_Sclaer == 'No_Scaler': | |
258 x_train = X_train | |
259 x_test = X_test | |
260 | |
261 else: | |
262 print('Scalling Method option was not correctly selected...!') | |
263 | |
264 prob = Algo.fit(x_train, y_train).predict_proba(x_test) | |
265 predicted = Algo.fit(x_train, y_train).predict(x_test) | |
266 fpr, tpr, thresholds = roc_curve(y_test, prob[:, 1]) | |
267 accu_score = accuracy_score(y_test, predicted) | |
268 | |
269 a = precision_recall_fscore_support(y_test, predicted, average='macro') | |
270 | |
271 pre_score = round(a[0],3) | |
272 recall_score= round(a[1],3) | |
273 f_score= round(a[2],3) | |
274 | |
275 pl.plot(fpr, tpr, '-', color='red',label='AUC = %0.2f' % accu_score, lw=2) | |
276 | |
277 pl.xlim([0.0, 1.0]) | |
278 pl.ylim([0.0, 1.05]) | |
279 pl.xlabel('False Positive Rate') | |
280 pl.ylabel('True Positive Rate') | |
281 pl.title('ROC Cureve') | |
282 pl.legend(loc="lower right") | |
283 pl.savefig(os.path.join(Workdirpath, htmlOutDir, "out.png")) | |
284 pl.plot(fpr, tpr, '--', lw=2) | |
285 | |
286 auc_score = auc(fpr, tpr) | |
287 | |
288 a = precision_recall_fscore_support(y_test, predicted, average='macro') | |
289 pre_score = round(a[0],3) | |
290 rec_score = round(a[1],3) | |
291 f_score = round(a[2],3) | |
292 | |
293 V_header = ["accuracy","presision","recall","f1","mean_auc"] | |
294 v_values = [accu_score, pre_score, rec_score, f_score, auc_score] | |
295 df = pd.DataFrame([v_values], columns=V_header) | |
296 df.to_csv(os.path.join(Workdirpath, OutFile), columns=V_header, sep='\t') | |
297 pl.figure() | |
298 pl.bar(V_header, v_values, color=(0.2, 0.4, 0.6, 0.6)) | |
299 pl.xlabel('Accuracy Perameters', fontweight='bold', color = 'orange', fontsize='17', horizontalalignment='center') | |
300 pl.savefig(os.path.join(Workdirpath, htmlOutDir, "2.png")) | |
301 #pl.show() | |
302 HTML_Gen(os.path.join(Workdirpath, htmlOutDir, htmlFname)) | |
303 | |
304 elif Test_Method == "Predict": | |
305 | |
306 X_train, y_train, X_test, _ = ReturnData(TrainData, Test_Method,TestData) | |
307 | |
308 if Selected_Sclaer=='Min_Max': | |
309 scaler = MinMaxScaler().fit(X_train) | |
310 x_train = scaler.transform(X_train) | |
311 x_test = scaler.transform(X_test) | |
312 | |
313 elif Selected_Sclaer=='Standard_Scaler': | |
314 scaler = preprocessing.StandardScaler().fit(X_train) | |
315 x_train = scaler.transform(X_train) | |
316 x_test = scaler.transform(X_test) | |
317 | |
318 elif Selected_Sclaer == 'No_Scaler': | |
319 x_train = X_train | |
320 x_test = X_test | |
321 | |
322 else: | |
323 print('Scalling Method option was not correctly selected...!') | |
324 | |
325 predicted = model.fit(x_train, y_train).predict(x_test) | |
326 | |
327 | |
328 return predicted | |
329 | |
330 def SVM_Classifier(C, kernel, degree, gamma, coef0, shrinking, probability, tol, cache_size, verbose, max_iter, decision_function_shape, randomState, breakties, TrainFile, TestMethod, SelectedSclaer, NFolds, TestFile, OutFile, htmlOutDir, htmlFname, Workdirpath): | |
331 | |
332 if randomState == None: | |
333 randomState =None | |
334 else: | |
335 randomState = int(randomState) | |
336 | |
337 | |
338 if cache_size == None: | |
339 cache_size =None | |
340 else: | |
341 cache_size = float(cache_size) | |
342 | |
343 | |
344 if probability or shrinking == 'true': | |
345 probability, shrinking = True, True | |
346 else: | |
347 probability, shrinking = False, False | |
348 | |
349 | |
350 if verbose == 'true': | |
351 verbose = True | |
352 else: | |
353 verbose = False | |
354 | |
355 | |
356 if breakties == 'true': | |
357 breakties = True | |
358 else: | |
359 breakties = False | |
360 | |
361 | |
362 | |
363 | |
364 pera={ | |
365 | |
366 'C':float(C), | |
367 'kernel':kernel, | |
368 'degree':int(degree), #3 | |
369 'gamma':gamma, #default=scale | |
370 'coef0':float(coef0), #default=0.0 | |
371 'shrinking':shrinking, #P | |
372 'probability':probability, | |
373 'tol':float(tol), #default=1e-3 | |
374 'cache_size':cache_size, | |
375 'verbose':verbose, | |
376 'max_iter':int(max_iter),#default=-1 | |
377 'decision_function_shape':decision_function_shape, | |
378 'random_state':randomState, | |
379 'break_ties':breakties | |
380 } | |
381 | |
382 | |
383 model = SVC(**pera ) | |
384 | |
385 Fit_Model(TrainData=TrainFile, Test_Method=TestMethod, Algo=model, Selected_Sclaer=SelectedSclaer, Workdirpath=Workdirpath, htmlOutDir=htmlOutDir, OutFile=OutFile, htmlFname=htmlFname, NoOfFolds=int(NFolds), TestData=TestFile) | |
386 | |
387 | |
388 def SGD_Classifier( loss, penalty, alpha, l1_ratio, fit_intercept, max_iter, tol, shuffle, verbose, epsilon, n_jobs, random_state, learning_rate, eta0, power_t, early_stopping, validation_fraction, n_iter_no_change, warm_start, average, TrainFile, TestMethod, SelectedSclaer, NFolds, TestFile, OutFile, htmlOutDir, htmlFname, Workdirpath): | |
389 | |
390 if n_jobs == 'none': | |
391 n_jobs =None | |
392 else: | |
393 n_jobs = int(n_jobs) | |
394 | |
395 if random_state == 'none': | |
396 random_state =None | |
397 else: | |
398 random_state = int(random_state) | |
399 | |
400 if fit_intercept == 'true': | |
401 fit_intercept = True | |
402 else: | |
403 fit_intercept = False | |
404 | |
405 if shuffle == 'true': | |
406 shuffle = True | |
407 else: | |
408 shuffle = False | |
409 | |
410 if early_stopping == 'true': | |
411 early_stopping = True | |
412 else: | |
413 early_stopping = False | |
414 | |
415 if warm_start == 'true': | |
416 warm_start = True | |
417 else: | |
418 warm_start = False | |
419 | |
420 if average == 'true': | |
421 average = True | |
422 else: | |
423 average = False | |
424 | |
425 pera = {"loss":loss, | |
426 "penalty":penalty, | |
427 "alpha":float(alpha),#0.0001 | |
428 "l1_ratio":float(l1_ratio),#0.15 | |
429 "fit_intercept":fit_intercept,#true | |
430 "max_iter":int(max_iter),#default=1000 | |
431 "tol":float(tol),#default=1e-3 | |
432 "shuffle":shuffle, | |
433 "verbose":int(verbose), #default=0 | |
434 "epsilon":float(epsilon), #default=0.1 | |
435 "n_jobs":n_jobs, #default=None | |
436 "random_state":random_state, #default=None | |
437 "learning_rate":learning_rate, | |
438 "eta0":float(eta0), #default=0.0 | |
439 "power_t":float(power_t), #default=0.5 | |
440 "early_stopping":early_stopping, | |
441 "validation_fraction":float(validation_fraction), #default=0.1 | |
442 "n_iter_no_change":int(n_iter_no_change), #default=5 | |
443 "warm_start":warm_start, | |
444 "average":average} | |
445 | |
446 model = SGDClassifier(**pera) | |
447 | |
448 Fit_Model(TrainData=TrainFile, Test_Method=TestMethod, Algo=model, Selected_Sclaer=SelectedSclaer, Workdirpath=Workdirpath, htmlOutDir=htmlOutDir, OutFile=OutFile, htmlFname=htmlFname, NoOfFolds=int(NFolds), TestData=TestFile) | |
449 | |
450 | |
451 def DT_Classifier(criterion, splitter, max_depth, min_samples_split, min_samples_leaf, min_weight_fraction_leaf, random_state, max_leaf_nodes, min_impurity_decrease, min_impurity_split, presort, ccpalpha, max_features, TrainFile, TestMethod, SelectedSclaer, NFolds, TestFile, OutFile, htmlOutDir, htmlFname, Workdirpath): | |
452 | |
453 if max_depth == 'none': | |
454 max_depth =None | |
455 else: | |
456 max_depth = int(max_depth) | |
457 | |
458 if '.' in min_samples_split: | |
459 min_samples_split = float(min_samples_split) | |
460 else: | |
461 min_samples_split = int(min_samples_split) | |
462 | |
463 if '.' in min_samples_leaf: | |
464 min_samples_split = float(min_samples_leaf) | |
465 else: | |
466 min_samples_leaf = int(min_samples_leaf) | |
467 | |
468 if max_features == 'none': | |
469 max_features = None | |
470 else: | |
471 if '.' in max_features: | |
472 max_features = float(max_features) | |
473 else: | |
474 max_features = int(max_features) | |
475 | |
476 if random_state == 'none': | |
477 random_state = None | |
478 else: | |
479 random_state = int(random_state) | |
480 | |
481 | |
482 if max_leaf_nodes == 'none': | |
483 max_leaf_nodes = None | |
484 else: | |
485 max_leaf_nodes = int(max_leaf_nodes) | |
486 | |
487 | |
488 pera = {"criterion":criterion, | |
489 "splitter":splitter, | |
490 "max_depth":max_depth,#int, default=None | |
491 "min_samples_split":int(min_samples_split),#default=2 | |
492 "min_samples_leaf":int(min_samples_leaf), #default=1 | |
493 "min_weight_fraction_leaf":float(min_weight_fraction_leaf),#default=0.0 | |
494 "random_state":random_state, #default=None | |
495 "max_leaf_nodes":max_leaf_nodes, #default=None | |
496 "min_impurity_decrease":float(min_impurity_decrease),#float, default=0.0 | |
497 "min_impurity_split":float(min_impurity_split), #float, default=1e-7 | |
498 "presort":presort,#default=deprecated | |
499 'ccp_alpha':float(ccpalpha),#non-negative float, default=0.0 | |
500 'max_features': max_features}#int, float or {"auto", "sqrt", "log2"}, default=None | |
501 | |
502 model = DecisionTreeClassifier(**pera) | |
503 | |
504 #Fit_Model('GBC.tsv', 'Internal', model, 'Min_Max', os.getcwd(), os.path.join(os.getcwd(),'report_dir'), 'out.tsv', 'out.html', NoOfFolds=3) | |
505 Fit_Model(TrainData=TrainFile, Test_Method=TestMethod, Algo=model, Selected_Sclaer=SelectedSclaer, Workdirpath=Workdirpath, htmlOutDir=htmlOutDir, OutFile=OutFile, htmlFname=htmlFname, NoOfFolds=int(NFolds), TestData=TestFile) | |
506 | |
507 | |
508 def GB_Classifier(loss, learning_rate, n_estimators, subsample, criterion, min_samples_split, min_samples_leaf, min_weight_fraction_leaf, max_depth, min_impurity_decrease,min_impurity_split, init, random_state, verbose, max_leaf_nodes, warm_start, presort, validation_fraction, n_iter_no_change, tol, ccpalpha, max_features, TrainFile, TestMethod, SelectedSclaer, NFolds, TestFile, OutFile, htmlOutDir, htmlFname, Workdirpath): | |
509 | |
510 if '.' in min_samples_split: | |
511 min_samples_split = float(min_samples_split) | |
512 else: | |
513 min_samples_split = int(min_samples_split) | |
514 | |
515 if '.' in min_samples_leaf: | |
516 min_samples_split = float(min_samples_leaf) | |
517 else: | |
518 min_samples_leaf = int(min_samples_leaf) | |
519 | |
520 if max_features == 'none': | |
521 max_features = None | |
522 else: | |
523 if '.' in max_features: | |
524 max_features = float(max_features) | |
525 else: | |
526 max_features = int(max_features) | |
527 | |
528 if random_state == 'none': | |
529 random_state = None | |
530 else: | |
531 random_state = int(random_state) | |
532 | |
533 if max_leaf_nodes == 'none': | |
534 max_leaf_nodes = None | |
535 else: | |
536 max_leaf_nodes = int(max_leaf_nodes) | |
537 | |
538 if warm_start == 'true': | |
539 warm_start = True | |
540 else: | |
541 warm_start = False | |
542 | |
543 | |
544 if n_iter_no_change == 'none': | |
545 n_iter_no_change = None | |
546 else: | |
547 n_iter_no_change = int(n_iter_no_change) | |
548 | |
549 | |
550 if init == 'none': | |
551 init = None | |
552 else: | |
553 init = init | |
554 | |
555 | |
556 pera = {"loss":loss, | |
557 "learning_rate":float(learning_rate), | |
558 "n_estimators":int(n_estimators), #int (default=100) | |
559 "subsample":float(subsample), #float, optional (default=1.0) | |
560 "criterion":criterion, | |
561 "min_samples_split":min_samples_split, #int, float, optional (default=2) | |
562 "min_samples_leaf":min_samples_leaf, #int, float, optional (default=1) | |
563 "min_weight_fraction_leaf":float(min_weight_fraction_leaf), #float, optional (default=0.) | |
564 "max_depth":int(max_depth), #integer, optional (default=3) | |
565 "min_impurity_decrease":float(min_impurity_decrease),#float, optional (default=0.) | |
566 "min_impurity_split":float(min_impurity_split), #float, (default=1e-7) | |
567 "init":init, #estimator or zero, optional (default=None) | |
568 "random_state":random_state, #int, RandomState instance or None, optional (default=None) | |
569 "verbose":int(verbose), #int, default: 0 | |
570 "max_features": max_features,#int, float, string or None, optional (default=None) | |
571 "max_leaf_nodes":max_leaf_nodes, #int or None, optional (default=None) | |
572 "warm_start":warm_start, #bool, default: False | |
573 "presort":presort, #deprecated, default=deprecated | |
574 "validation_fraction":float(validation_fraction), #float, optional, default 0.1 | |
575 "n_iter_no_change":n_iter_no_change, #int, default None | |
576 "tol":float(tol),#default 1e-4 | |
577 "ccp_alpha":float(ccpalpha)} #non-negative float, optional (default=0.0) | |
578 | |
579 | |
580 model = GradientBoostingClassifier(**pera) | |
581 | |
582 #Fit_Model('GBC.tsv', 'Internal', model, 'Min_Max', os.getcwd(), os.path.join(os.getcwd(),'report_dir'), 'out.tsv', 'out.html', NoOfFolds=3) | |
583 Fit_Model(TrainData=TrainFile, Test_Method=TestMethod, Algo=model, Selected_Sclaer=SelectedSclaer, Workdirpath=Workdirpath, htmlOutDir=htmlOutDir, OutFile=OutFile, htmlFname=htmlFname, NoOfFolds=int(NFolds), TestData=TestFile) | |
584 | |
585 | |
586 def RF_Classifier( n_estimators, criterion, max_depth, min_samples_split, min_samples_leaf, min_weight_fraction_leaf, max_features, max_leaf_nodes, min_impurity_decrease, min_impurity_split, bootstrap, oob_score, n_jobs, random_state, verbose, warm_start, ccp_alpha, max_samples, TrainFile, TestMethod, SelectedSclaer, NFolds, TestFile, OutFile, htmlOutDir, htmlFname, Workdirpath): | |
587 | |
588 if max_depth == 'none': | |
589 max_depth = None | |
590 else: | |
591 max_depth = int(max_depth) | |
592 | |
593 if '.' in min_samples_split: | |
594 min_samples_split = float(min_samples_split) | |
595 else: | |
596 min_samples_split = int(min_samples_split) | |
597 | |
598 if '.' in min_samples_leaf: | |
599 min_samples_split = float(min_samples_leaf) | |
600 else: | |
601 min_samples_leaf = int(min_samples_leaf) | |
602 | |
603 if max_features == 'auto': | |
604 max_features = 'auto' | |
605 else: | |
606 if '.' in max_features: | |
607 max_features = float(max_features) | |
608 else: | |
609 max_features = int(max_features) | |
610 | |
611 if max_leaf_nodes == 'none': | |
612 max_leaf_nodes = None | |
613 else: | |
614 max_leaf_nodes = int(max_leaf_nodes) | |
615 | |
616 if bootstrap == 'true': | |
617 bootstrap = True | |
618 else: | |
619 bootstrap = False | |
620 | |
621 if oob_score == 'true': | |
622 oob_score = True | |
623 else: | |
624 oob_score = False | |
625 | |
626 if n_jobs == 'none': | |
627 n_jobs = None | |
628 else: | |
629 n_jobs = int(n_jobs) | |
630 | |
631 if random_state == 'none': | |
632 random_state = None | |
633 else: | |
634 random_state = int(random_state) | |
635 | |
636 if warm_start == 'true': | |
637 warm_start = True | |
638 else: | |
639 warm_start = False | |
640 | |
641 if max_samples == 'none': | |
642 max_samples = None | |
643 else: | |
644 if '.' in max_samples: | |
645 max_samples = float(max_samples) | |
646 else: | |
647 max_samples = int(max_samples) | |
648 | |
649 | |
650 pera = { | |
651 "n_estimators":int(n_estimators), #integer, optional (default=100) | |
652 "criterion":criterion, #string, optional (default='gini') | |
653 "max_depth":max_depth, #integer #or None, optional (default=None) | |
654 "min_samples_split":min_samples_split,# int, float, optional (default=2) | |
655 "min_samples_leaf":min_samples_leaf, #int, float, optional (default=1) | |
656 "min_weight_fraction_leaf":float(min_weight_fraction_leaf),#float, optional (default=0.) | |
657 "max_features":max_features, #int, float, string or None, optional (default='auto') | |
658 "max_leaf_nodes":max_leaf_nodes, #int or None, optional (default=None) | |
659 "min_impurity_decrease":float(min_impurity_decrease), #float, optional (default=0.) | |
660 "min_impurity_split":float(min_samples_split), #float, (default=1e-7) | |
661 "bootstrap":bootstrap, #boolean, optional (default=True) | |
662 "oob_score":oob_score, #bool (default=False) | |
663 "n_jobs":n_jobs, #int or None, optional (default=None) | |
664 "random_state":random_state, #int, RandomState instance or None, optional (default=None) | |
665 "verbose":int(verbose), #int, optional (default=0) | |
666 "warm_start":warm_start,#bool, optional (default=False) | |
667 "ccp_alpha":float(ccp_alpha),#non-negative float, optional (default=0.0) | |
668 "max_samples": max_samples #int or float, default=None | |
669 } | |
670 | |
671 model = RandomForestClassifier(**pera) | |
672 #Fit_Model('GBC.tsv', 'Internal', model, 'Min_Max', os.getcwd(), os.path.join(os.getcwd(),'report_dir'), 'out.tsv', 'out.html', NoOfFolds=3) | |
673 Fit_Model(TrainData=TrainFile, Test_Method=TestMethod, Algo=model, Selected_Sclaer=SelectedSclaer, Workdirpath=Workdirpath, htmlOutDir=htmlOutDir, OutFile=OutFile, htmlFname=htmlFname, NoOfFolds=int(NFolds), TestData=TestFile) | |
674 | |
675 | |
676 def LR_Classifier(penalty, dual, tol, C, fit_intercept, intercept_scaling, random_state, solver, max_iter, multi_class, verbose, warm_start, n_jobs, l1_ratio, TrainFile, TestMethod, SelectedSclaer, NFolds, TestFile, OutFile, htmlOutDir, htmlFname, Workdirpath): | |
677 | |
678 if dual == 'true': | |
679 dual = True | |
680 else: | |
681 dual = False | |
682 | |
683 if fit_intercept == "true": | |
684 fit_intercept = True | |
685 else: | |
686 fit_intercept = False | |
687 | |
688 if random_state == 'none': | |
689 random_state = None | |
690 else: | |
691 random_state = int(random_state) | |
692 | |
693 if warm_start == 'true': | |
694 warm_start = True | |
695 else: | |
696 warm_start = False | |
697 | |
698 if n_jobs == "none": | |
699 n_jobs = None | |
700 else: | |
701 n_jobs = int(n_jobs) | |
702 | |
703 if l1_ratio == "none": | |
704 l1_ratio = None | |
705 else: | |
706 l1_ratio =float(l1_ratio) | |
707 | |
708 pera = { | |
709 "penalty":penalty, #l2 | |
710 "dual":dual, #false | |
711 "tol":float(tol), #1e-4 | |
712 "C":float(C), #1.0 | |
713 "fit_intercept":fit_intercept, #True | |
714 "intercept_scaling":float(intercept_scaling), #1 | |
715 "random_state":random_state, #None | |
716 "solver":solver, #lbfgs | |
717 "max_iter":int(max_iter), #100 | |
718 "multi_class":multi_class, #auto | |
719 "verbose":int(verbose), #0 | |
720 "warm_start":warm_start,#False | |
721 "n_jobs":n_jobs, #None | |
722 "l1_ratio":l1_ratio} #None | |
723 | |
724 model = LogisticRegression(**pera) | |
725 | |
726 Fit_Model(TrainData=TrainFile, Test_Method=TestMethod, Algo=model, Selected_Sclaer=SelectedSclaer, Workdirpath=Workdirpath, htmlOutDir=htmlOutDir, OutFile=OutFile, htmlFname=htmlFname, NoOfFolds=int(NFolds), TestData=TestFile) | |
727 | |
728 | |
729 def KN_Classifier(n_neighbors, weights, algorithm, leaf_size, p, metric, metric_params, n_jobs, TrainFile, TestMethod, SelectedSclaer, NFolds, TestFile, OutFile, htmlOutDir, htmlFname, Workdirpath): | |
730 | |
731 if n_jobs == 'none': | |
732 n_jobs = None | |
733 else: | |
734 n_jobs = int(n_jobs) | |
735 | |
736 pera = { | |
737 "n_neighbors":int(n_neighbors),#int5 | |
738 "weights":weights, | |
739 "algorithm":algorithm, | |
740 "leaf_size":int(leaf_size), #int30 | |
741 "p":int(p), #int2 | |
742 "metric":metric, #minkowski | |
743 "n_jobs":n_jobs} #none | |
744 | |
745 model = KNeighborsClassifier(**pera) | |
746 | |
747 #Fit_Model('GBC.tsv', 'Internal', model, 'Min_Max', os.getcwd(), os.path.join(os.getcwd(),'report_dir'), 'out.tsv', 'out.html', NoOfFolds=3) | |
748 Fit_Model(TrainData=TrainFile, Test_Method=TestMethod, Algo=model, Selected_Sclaer=SelectedSclaer, Workdirpath=Workdirpath, htmlOutDir=htmlOutDir, OutFile=OutFile, htmlFname=htmlFname, NoOfFolds=int(NFolds), TestData=TestFile) | |
749 | |
750 def GNB_Classifier( var_smoothing, TrainFile, TestMethod, SelectedSclaer, NFolds, TestFile, OutFile, htmlOutDir, htmlFname, Workdirpath): | |
751 | |
752 pera = { | |
753 "var_smoothing":float(var_smoothing)} # | |
754 | |
755 model = GaussianNB(**pera) | |
756 | |
757 #Fit_Model('GBC.tsv', 'Internal', model, 'Min_Max', os.getcwd(), os.path.join(os.getcwd(),'report_dir'), 'out.tsv', 'out.html', NoOfFolds=3) | |
758 Fit_Model(TrainData=TrainFile, Test_Method=TestMethod, Algo=model, Selected_Sclaer=SelectedSclaer, Workdirpath=Workdirpath, htmlOutDir=htmlOutDir, OutFile=OutFile, htmlFname=htmlFname, NoOfFolds=int(NFolds), TestData=TestFile) | |
759 | |
760 | |
761 def MLP_Classifier(hidden_layer_sizes, activation,solver,alpha,batch_size,learning_rate,learning_rate_init,power_t,max_iter,shuffle,random_state,tol,verbose,warm_start,momentum,nesterovs_momentum,early_stopping,validation_fraction,beta_1,beta_2,epsilon,n_iter_no_change,max_fun,TrainFile, TestMethod, SelectedSclaer, NFolds, Testspt, TestFile, OutFile, htmlOutDir, htmlFname, Workdirpath): | |
762 | |
763 if shuffle == 'true': | |
764 shuffle = True | |
765 else: | |
766 shuffle = False | |
767 | |
768 if nesterovs_momentum == 'true': | |
769 nesterovs_momentum = True | |
770 else: | |
771 nesterovs_momentum = False | |
772 | |
773 if early_stopping == 'true': | |
774 early_stopping = True | |
775 else: | |
776 early_stopping = False | |
777 | |
778 if random_state == 'none': | |
779 random_state = None | |
780 else: | |
781 random_state = int(random_state) | |
782 | |
783 if verbose == 'false': | |
784 verbose = False | |
785 else: | |
786 verbose = True | |
787 | |
788 if warm_start == 'true': | |
789 warm_start = True | |
790 else: | |
791 warm_start = False | |
792 | |
793 pera ={ | |
794 'hidden_layer_sizes':hidden_layer_sizes, #=(100,), | |
795 'activation':activation, #='relu', | |
796 'solver':solver, #='adam', | |
797 'alpha':alpha, #=0.0001, | |
798 'batch_size':batch_size, #='auto', | |
799 'learning_rate':learning_rate, #='constant', | |
800 'learning_rate_init':learning_rate_init, #=0.001, | |
801 'power_t':power_t, #=0.5, | |
802 'max_iter':max_iter, #=200, | |
803 'shuffle':shuffle, #=True, | |
804 'random_state':random_state, #=None, | |
805 'tol':tol, #=0.0001, | |
806 'verbose':verbose, #=False, | |
807 'warm_start':warm_start, #=False, | |
808 'momentum':momentum, #=0.9, | |
809 'nesterovs_momentum':nesterovs_momentum, #=True, | |
810 'early_stopping':early_stopping, #=False, | |
811 'validation_fraction':validation_fraction, #=0.1, | |
812 'beta_1':beta_1, #=0.9, | |
813 'beta_2':beta_2, #=0.999, | |
814 'epsilon':epsilon, #=1e-08, | |
815 'n_iter_no_change':n_iter_no_change, #=10, | |
816 'max_fun':max_fun #=15000 | |
817 } | |
818 | |
819 model = MLPClassifier(**pera) | |
820 | |
821 Fit_Model(TrainData=TrainFile, Test_Method=TestMethod, Algo=model, Selected_Sclaer=SelectedSclaer, Workdirpath=Workdirpath, htmlOutDir=htmlOutDir, OutFile=OutFile, htmlFname=htmlFname, NoOfFolds=NFolds, TestSize=Testspt, TestData=TestFile) | |
822 | |
823 | |
824 if __name__=="__main__": | |
825 | |
826 import argparse | |
827 | |
828 parser = argparse.ArgumentParser(description='Deployment tool') | |
829 subparsers = parser.add_subparsers() | |
830 | |
831 svmc = subparsers.add_parser('SVMC') | |
832 svmc.add_argument("--C", required=False, default=1.0, help="Regularization parameter. The strength of the regularization is inversely proportional to C. Must be strictly positive. The penalty is a squared l2 penalty.") | |
833 svmc.add_argument("--kernel", required=False, default='rbf', help="Specifies the kernel type to be used in the algorithm. It must be one of 'linear', 'poly', 'rbf', 'sigmoid', 'precomputed' or a callable. If none is given, 'rbf' will be used. If a callable is given it is used to pre-compute the kernel matrix from data matrices; that matrix should be an array of shape (n_samples, n_samples).") | |
834 svmc.add_argument("--degree", required=False, default=3, help="Degree of the polynomial kernel function ('poly'). Ignored by all other kernels.") | |
835 svmc.add_argument("--gamma", required=False, default='scale', help="Kernel coefficient for 'rbf', 'poly' and 'sigmoid'. if gamma='scale' (default) is passed then it uses 1 / (n_features * X.var()) as value of gamma, if 'auto', uses 1 / n_features.") | |
836 svmc.add_argument("--coef0", required=False, default=0.0, help="Independent term in kernel function. It is only significant in 'poly' and 'sigmoid'.") | |
837 svmc.add_argument("--shrinking", required=False, default=True, help="Whether to use the shrinking heuristic.") | |
838 svmc.add_argument("--probability", required=False, default=True, help="Whether to enable probability estimates. This must be enabled prior to calling fit, will slow down that method as it internally uses 5-fold cross-validation, and predict_proba may be inconsistent with predict") | |
839 svmc.add_argument("--tol", required=False, default=0.001, help="Tolerance for stopping criterion.") | |
840 svmc.add_argument("--cache_size", required=False, default=200, help="Specify the size of the kernel cache (in MB).") | |
841 svmc.add_argument("--verbose", required=False, default=False, help="Enable verbose output. Note that this setting takes advantage of a per-process runtime setting in libsvm that, if enabled, may not work properly in a multithreaded context.") | |
842 svmc.add_argument("--max_iter", required=False, default=-1, help="Hard limit on iterations within solver, or -1 for no limit.") | |
843 svmc.add_argument("--decision_function_shape", required=False, default='ovr', help="Whether to return a one-vs-rest ('ovr') decision function of shape (n_samples, n_classes) as all other classifiers, or the original one-vs-one ('ovo') decision function of libsvm which has shape (n_samples, n_classes * (n_classes - 1) / 2). However, one-vs-one ('ovo') is always used as multi-class strategy.") | |
844 svmc.add_argument("--randomState", required=False, default=None, help="The seed of the pseudo random number generator used when shuffling the data for probability estimates. If int, random_state is the seed used by the random number generator; If RandomState instance, random_state is the random number generator; If None, the random number generator is the RandomState instance used by np.random.") | |
845 svmc.add_argument("--breakties", required=False, default=False, help="If true, decision_function_shape='ovr', and number of classes > 2, predict will break ties according to the confidence values of decision_function; otherwise the first class among the tied classes is returned. Please note that breaking ties comes at a relatively high computational cost compared to a simple predict." ) | |
846 svmc.add_argument("--TrainFile", required=True, default=None, help="Positive negative dataset Ex. 'Train.csv'") | |
847 svmc.add_argument("--TestMethod", required=True, default=None, help="Internal','CrossVal', 'External', 'Predict'") | |
848 svmc.add_argument("--SelectedSclaer", required=True, help="'Min_Max','Standard_Scaler','No_Scaler'") | |
849 svmc.add_argument("--NFolds", required=False, default=5, help="int, Max=10") | |
850 svmc.add_argument("--TestFile", required=False, default=None, help="Test data, 'Test.csv'") | |
851 svmc.add_argument("--OutFile", required=False, default='Out.csv', help="Out.csv") | |
852 svmc.add_argument("--htmlOutDir", required=False, default=os.path.join(os.getcwd(),'report_dir'), help="HTML Out Dir") | |
853 svmc.add_argument("--htmlFname", required=False, default='Out.html', help="HTML out file") | |
854 svmc.add_argument("--Workdirpath", required=False, default=os.getcwd(), help="Working Directory Path") | |
855 | |
856 sgdc = subparsers.add_parser('SGDC') | |
857 sgdc.add_argument("--loss", required=False, default='log', help="The loss function to be used. Defaults to 'hinge', which gives a linear SVM. The possible options are 'hinge', 'log', 'modified_huber', 'squared_hinge', 'perceptron', or a regression loss: 'squared_loss', 'huber', 'epsilon_insensitive', or squared_epsilon_insensitive'.") | |
858 sgdc.add_argument("--penalty", required=False, default='l2', help="The penalty (aka regularization term) to be used. Defaults to 'l2' which is the standard regularizer for linear SVM models. 'l1' and 'elasticnet' might bring sparsity to the model (feature selection) not achievable with 'l2'.") | |
859 sgdc.add_argument("--alpha", required=False, default=0.0001, help="Constant that multiplies the regularization term. Defaults to 0.0001. Also used to compute learning_rate when set to 'optimal'.") | |
860 sgdc.add_argument("--l1_ratio", required=False, default=0.15, help="The Elastic Net mixing parameter, with 0 <= l1_ratio <= 1. l1_ratio=0 corresponds to L2 penalty, l1_ratio=1 to L1. Defaults to 0.15.") | |
861 sgdc.add_argument("--fit_intercept", required=False, default=True, help="Whether the intercept should be estimated or not. If False, the data is assumed to be already centered. Defaults to True.") | |
862 sgdc.add_argument("--max_iter", required=False, default=1000, help="The maximum number of passes over the training data (aka epochs). It only impacts the behavior in the fit method, and not the partial_fit method.") | |
863 sgdc.add_argument("--tol", required=False, default=0.001, help="The stopping criterion. If it is not None, the iterations will stop when (loss > best_loss - tol) for n_iter_no_change consecutive epochs.") | |
864 sgdc.add_argument("--shuffle", required=False, default=True, help="Whether or not the training data should be shuffled after each epoch. Defaults to True.") | |
865 sgdc.add_argument("--verbose", required=False, default=0, help="The verbosity level.") | |
866 sgdc.add_argument("--epsilon", required=False, default=0.1, help="Epsilon in the epsilon-insensitive loss functions; only if loss is 'huber', 'epsilon_insensitive', or 'squared_epsilon_insensitive'. For 'huber', determines the threshold at which it becomes less important to get the prediction exactly right. For epsilon-insensitive, any differences between the current prediction and the correct label are ignored if they are less than this threshold.") | |
867 sgdc.add_argument("--n_jobs", required=False, default='none', help="The number of CPUs to use to do the OVA (One Versus All, for multi-class problems) computation. None means 1 unless in a joblib.parallel_backend context. -1 means using all processors. See Glossary for more details.") | |
868 sgdc.add_argument("--random_state", required=False, default='none', help="The seed of the pseudo random number generator to use when shuffling the data. If int, random_state is the seed used by the random number generator; If RandomState instance, random_state is the random number generator; If None, the random number generator is the RandomState instance used by np.random.") | |
869 sgdc.add_argument("--learning_rate", required=False, default='optimal', help="The learning rate schedule:") | |
870 sgdc.add_argument("--eta0", required=False, default=0.0, help="eta = eta0") | |
871 sgdc.add_argument("--power_t", required=False, default=0.5, help="eta = 1.0 / (alpha * (t + t0)) where t0 is chosen by a heuristic proposed by Leon Bottou.") | |
872 sgdc.add_argument("--early_stopping", required=False, default=False, help="MinMaxScaler") | |
873 sgdc.add_argument("--validation_fraction", required=False, default=0.1, help="The proportion of training data to set aside as validation set for early stopping. Must be between 0 and 1. Only used if early_stopping is True.") | |
874 sgdc.add_argument("--n_iter_no_change", required=False, default=5, help="Number of iterations with no improvement to wait before early stopping.") | |
875 sgdc.add_argument("--warm_start", required=False, default=False, help="When set to True, reuse the solution of the previous call to fit as initialization, otherwise, just erase the previous solution.") | |
876 sgdc.add_argument("--average", required=False, default=False, help="MinMaxScaler") | |
877 sgdc.add_argument("--TrainFile", required=True, default=None, help="Positive negative dataset Ex. 'Train.csv'") | |
878 sgdc.add_argument("--TestMethod", required=True, default=None, help="Internal','CrossVal', 'External', 'Predict'") | |
879 sgdc.add_argument("--SelectedSclaer", required=True, help="'Min_Max','Standard_Scaler','No_Scaler'") | |
880 sgdc.add_argument("--NFolds", required=False, default=5, help="int, Max=10") | |
881 sgdc.add_argument("--TestFile", required=False, default=None, help="Test data, 'Test.csv'") | |
882 sgdc.add_argument("--OutFile", required=False, default='Out.csv', help="float, Max=1.0") | |
883 sgdc.add_argument("--htmlOutDir", required=False, default=os.path.join(os.getcwd(),'report_dir'), help="HTML Out Dir") | |
884 sgdc.add_argument("--htmlFname", required=False, default='Out.html', help="") | |
885 sgdc.add_argument("--Workdirpath", required=False, default=os.getcwd(), help="Working Directory Path") | |
886 | |
887 dtc = subparsers.add_parser('DTC') | |
888 dtc.add_argument("--criterion", required=False, default='gini', help="The function to measure the quality of a split. Supported criteria are 'gini' for the Gini impurity and 'entropy' for the information gain.") | |
889 dtc.add_argument("--splitter", required=False, default='best', help="The strategy used to choose the split at each node. Supported strategies are 'best' to choose the best split and 'random' to choose the best random split." ) | |
890 dtc.add_argument("--max_depth", required=False, default='none', help="The maximum depth of the tree. If None, then nodes are expanded until all leaves are pure or until all leaves contain less than min_samples_split samples.") | |
891 dtc.add_argument("--min_samples_split", required=False, default='2', help="The minimum number of samples required to split an internal node: If int, then consider min_samples_split as the minimum number. If float, then min_samples_split is a fraction and ceil(min_samples_split * n_samples) are the minimum number of samples for each split.") | |
892 dtc.add_argument("--min_samples_leaf", required=False, default='1', help="The minimum number of samples required to be at a leaf node. A split point at any depth will only be considered if it leaves at least min_samples_leaf training samples in each of the left and right branches. This may have the effect of smoothing the model, especially in regression.") | |
893 dtc.add_argument("--min_weight_fraction_leaf", required=False, default=0.0, help="The minimum weighted fraction of the sum total of weights (of all the input samples) required to be at a leaf node. Samples have equal weight when sample_weight is not provided.") | |
894 dtc.add_argument("--random_state", required=False, default='none', help="If int, random_state is the seed used by the random number generator; If RandomState instance, random_state is the random number generator; If None, the random number generator is the RandomState instance used by np.random.") | |
895 dtc.add_argument("--max_leaf_nodes", required=False, default='none', help="A node will be split if this split induces a decrease of the impurity greater than or equal to this value. The weighted impurity decrease equation is the following") | |
896 dtc.add_argument("--min_impurity_decrease", required=False, default=0.0, help="") | |
897 dtc.add_argument("--min_impurity_split", required=False, default=1e-09, help="Threshold for early stopping in tree growth. A node will split if its impurity is above the threshold, otherwise it is a leaf.") | |
898 dtc.add_argument("--presort", required=False, default='deprecate', help="This parameter is deprecated and will be removed in v0.24.") | |
899 dtc.add_argument("--ccpalpha", required=False, default=0.0, help="Complexity parameter used for Minimal Cost-Complexity Pruning. The subtree with the largest cost complexity that is smaller than ccp_alpha will be chosen. By default, no pruning is performed. See Minimal Cost-Complexity Pruning for details.") | |
900 dtc.add_argument("--TrainFile", required=True, default=None, help="Positive negative dataset Ex. 'Train.csv'") | |
901 dtc.add_argument("--TestMethod", required=True, default=None, help="Internal','CrossVal', 'External', 'Predict'") | |
902 dtc.add_argument("--max_features", required=False, default='none') | |
903 dtc.add_argument("--SelectedSclaer", required=True, help="'Min_Max',Standard_Scaler','No_Scaler'") | |
904 dtc.add_argument("--NFolds", required=False, default=5, help="int, Max=10") | |
905 dtc.add_argument("--TestFile", required=False, default=None, help="Test data, 'Test.csv'") | |
906 dtc.add_argument("--OutFile", required=False, default='Out.csv', help="Out.tsv") | |
907 dtc.add_argument("--htmlOutDir", required=False, default=os.path.join(os.getcwd(),'report_dir'), help="HTML Out Dir") | |
908 dtc.add_argument("--htmlFname", required=False, default='Out.html', help="") | |
909 dtc.add_argument("--Workdirpath", required=False, default=os.getcwd(), help="Working Directory Path") | |
910 | |
911 gbc = subparsers.add_parser('GBC') | |
912 gbc.add_argument("--loss", required=False, default='deviance', help="loss function to be optimized. 'deviance' refers to deviance (= logistic regression) for classification with probabilistic outputs. For loss 'exponential' gradient boosting recovers the AdaBoost algorithm.") | |
913 gbc.add_argument("--learning_rate", required=False, default=0.1, help="learning rate shrinks the contribution of each tree by learning_rate. There is a trade-off between learning_rate and n_estimators.") | |
914 gbc.add_argument("--n_estimators", required=False, default=100, help="The number of boosting stages to perform. Gradient boosting is fairly robust to over-fitting so a large number usually results in better performance.") | |
915 gbc.add_argument("--subsample", required=False, default=1.0, help="The fraction of samples to be used for fitting the individual base learners. If smaller than 1.0 this results in Stochastic Gradient Boosting. subsample interacts with the parameter n_estimators. Choosing subsample < 1.0 leads to a reduction of variance and an increase in bias.") | |
916 gbc.add_argument("--criterion", required=False,default='friedman_mse', help="The function to measure the quality of a split. Supported criteria are 'friedman_mse' for the mean squared error with improvement score by Friedman, 'mse' for mean squared error, and 'mae' for the mean absolute error. The default value of 'friedman_mse' is generally the best as it can provide a better approximation in some cases.") | |
917 gbc.add_argument("--min_samples_split", required=False, default='2', help="The minimum number of samples required to split an internal node: If int, then consider min_samples_split as the minimum number. If float, then min_samples_split is a fraction and ceil(min_samples_split * n_samples) are the minimum number of samples for each split.") | |
918 gbc.add_argument("--min_samples_leaf", required=False, default='1', help="The minimum number of samples required to be at a leaf node. A split point at any depth will only be considered if it leaves at least min_samples_leaf training samples in each of the left and right branches. This may have the effect of smoothing the model, especially in regression.If int, then consider min_samples_leaf as the minimum number. If float, then min_samples_leaf is a fraction and ceil(min_samples_leaf * n_samples) are the minimum number of samples for each node.") | |
919 gbc.add_argument("--min_weight_fraction_leaf", required=False, default=0, help="The minimum weighted fraction of the sum total of weights (of all the input samples) required to be at a leaf node. Samples have equal weight when sample_weight is not provided.") | |
920 gbc.add_argument("--max_depth", required=False, default=3, help="maximum depth of the individual regression estimators. The maximum depth limits the number of nodes in the tree. Tune this parameter for best performance; the best value depends on the interaction of the input variables.") | |
921 gbc.add_argument("--min_impurity_decrease", required=False, default=0.0, help="A node will be split if this split induces a decrease of the impurity greater than or equal to this value. The weighted impurity decrease equation is the following: 'N_t / N * (impurity - N_t_R / N_t * right_impurity - N_t_L / N_t * left_impurity'), where N is the total number of samples, N_t is the number of samples at the current node, N_t_L is the number of samples in the left child, and N_t_R is the number of samples in the right child. N, N_t, N_t_R and N_t_L all refer to the weighted sum, if sample_weight is passed. New in version 0.19.") | |
922 gbc.add_argument("--min_impurity_split", required=False, default=0.00000007, help="Threshold for early stopping in tree growth. A node will split if its impurity is above the threshold, otherwise it is a leaf.") | |
923 gbc.add_argument("--init", required=False,default='none', help="An estimator object that is used to compute the initial predictions. init has to provide fit and predict_proba. If 'zero', the initial raw predictions are set to zero. By default, a DummyEstimator predicting the classes priors is used.") | |
924 gbc.add_argument("--random_state", required=False, default='none', help="If int, random_state is the seed used by the random number generator; If RandomState instance, random_state is the random number generator; If None, the random number generator is the RandomState instance used by np.random.") | |
925 gbc.add_argument("--max_features", required=False, default='none', help="The number of features to consider when looking for the best split: If int, then consider max_features features at each split. If float, then max_features is a fraction and int(max_features * n_features) features are considered at each split.If 'auto', then max_features=sqrt(n_features). If 'sqrt', then max_features=sqrt(n_features). If 'log2', then max_features=log2(n_features). If None, then max_features=n_features. Choosing max_features < n_features leads to a reduction of variance and an increase in bias. Note: the search for a split does not stop until at least one valid partition of the node samples is found, even if it requires to effectively inspect more than max_features features.") | |
926 gbc.add_argument("--verbose",required=False, default=0, help="Enable verbose output. If 1 then it prints progress and performance once in a while (the more trees the lower the frequency). If greater than 1 then it prints progress and performance for every tree.") | |
927 gbc.add_argument("--max_leaf_nodes", required=False, default=4, help="Grow trees with max_leaf_nodes in best-first fashion. Best nodes are defined as relative reduction in impurity. If None then unlimited number of leaf nodes.") | |
928 gbc.add_argument("--warm_start", required=False, default='false', help="When set to True, reuse the solution of the previous call to fit and add more estimators to the ensemble, otherwise, just erase the previous solution." ) | |
929 gbc.add_argument("--presort", required=False,default='auto', help="This parameter is deprecated and will be removed in v0.24.") | |
930 gbc.add_argument("--validation_fraction", required=False, default=0.1, help="The proportion of training data to set aside as validation set for early stopping. Must be between 0 and 1. Only used if n_iter_no_change is set to an integer.") | |
931 gbc.add_argument("--n_iter_no_change", required=False, default=10, help="n_iter_no_change is used to decide if early stopping will be used to terminate training when validation score is not improving. By default it is set to None to disable early stopping. If set to a number, it will set aside validation_fraction size of the training data as validation and terminate training when validation score is not improving in all of the previous n_iter_no_change numbers of iterations. The split is stratified.") | |
932 gbc.add_argument("--tol", required=False, default=0.0001, help="Tolerance for the early stopping. When the loss is not improving by at least tol for n_iter_no_change iterations (if set to a number), the training stops.") | |
933 gbc.add_argument("--ccpalpha", required=False, default=0.0, help="Complexity parameter used for Minimal Cost-Complexity Pruning. The subtree with the largest cost complexity that is smaller than ccp_alpha will be chosen. By default, no pruning is performed. See Minimal Cost-Complexity Pruning for details.") | |
934 gbc.add_argument("--TrainFile", required=True, default=None, help="Positive negative dataset Ex. 'Train.csv'") | |
935 gbc.add_argument("--TestMethod", required=True, default=None, help="Internal','CrossVal', 'External', 'Predict'") | |
936 gbc.add_argument("--SelectedSclaer", required=True, help="'Min_Max',Standard_Scaler','No_Scaler'") | |
937 gbc.add_argument("--NFolds", required=False, default=5, help="int, Max=10") | |
938 gbc.add_argument("--TestFile", required=False, default=None, help="Test data, 'Test.csv'") | |
939 gbc.add_argument("--OutFile", required=False, default='Out.csv', help="Out.tsv") | |
940 gbc.add_argument("--htmlOutDir", required=False, default=os.path.join(os.getcwd(),'report_dir'), help="HTML Out Dir") | |
941 gbc.add_argument("--htmlFname", required=False, default='Out.html', help="") | |
942 gbc.add_argument("--Workdirpath", required=False, default=os.getcwd(), help="Working Directory Path") | |
943 | |
944 rfc = subparsers.add_parser('RFC') | |
945 rfc.add_argument("--n_estimators", required=False, default=100, help="The number of trees in the forest.") | |
946 rfc.add_argument("--criterion", required=False, default='gini', help="The function to measure the quality of a split. Supported criteria are 'gini' for the Gini impurity and 'entropy' for the information gain. Note: this parameter is tree-specific." ) | |
947 rfc.add_argument("--max_depth", required=False, default='none', help="The maximum depth of the tree. If None, then nodes are expanded until all leaves are pure or until all leaves contain less than min_samples_split samples.") | |
948 rfc.add_argument("--min_samples_split", required=False, default='2', help="The minimum number of samples required to split an internal node: If int, then consider min_samples_split as the minimum number. If float, then min_samples_split is a fraction and ceil(min_samples_split * n_samples) are the minimum number of samples for each split.") | |
949 rfc.add_argument("--min_samples_leaf", required=False, default='1', help="The minimum number of samples required to be at a leaf node. A split point at any depth will only be considered if it leaves at least min_samples_leaf training samples in each of the left and right branches. This may have the effect of smoothing the model, especially in regression.") | |
950 rfc.add_argument("--min_weight_fraction_leaf", required=False, default=0.0, help="The minimum weighted fraction of the sum total of weights (of all the input samples) required to be at a leaf node. Samples have equal weight when sample_weight is not provided.") | |
951 rfc.add_argument("--max_features", required=False, default='auto', help="The number of features to consider when looking for the best split:") | |
952 rfc.add_argument("--max_leaf_nodes", required=False, default='none', help="Grow trees with max_leaf_nodes in best-first fashion. Best nodes are defined as relative reduction in impurity. If None then unlimited number of leaf nodes.") | |
953 rfc.add_argument("--min_impurity_decrease", required=False, default=0.0, help="A node will be split if this split induces a decrease of the impurity greater than or equal to this value. The weighted impurity decrease equation is the following: N_t / N * (impurity - N_t_R / N_t * right_impurity - N_t_L / N_t * left_impurity) where N is the total number of samples, N_t is the number of samples at the current node, N_t_L is the number of samples in the left child, and N_t_R is the number of samples in the right child. N, N_t, N_t_R and N_t_L all refer to the weighted sum, if sample_weight is passed. New in version 0.19.") | |
954 rfc.add_argument("--min_impurity_split", required=False, default=1e-7, help="Threshold for early stopping in tree growth. A node will split if its impurity is above the threshold, otherwise it is a leaf.") | |
955 rfc.add_argument("--bootstrap", required=False, default='true', help="Whether bootstrap samples are used when building trees. If False, the whole datset is used to build each tree.") | |
956 rfc.add_argument("--oob_score", required=False, default='false', help="Whether to use out-of-bag samples to estimate the generalization accuracy.") | |
957 rfc.add_argument("--n_jobs", required=False, default=-1, help="The number of jobs to run in parallel. fit, predict, decision_path and apply are all parallelized over the trees. None means 1 unless in a joblib.parallel_backend context. -1 means using all processors. See Glossary for more details." ) | |
958 rfc.add_argument("--random_state", required=False, default='none', help="Controls both the randomness of the bootstrapping of the samples used when building trees (if bootstrap=True) and the sampling of the features to consider when looking for the best split at each node (if max_features < n_features). See Glossary for details.") | |
959 rfc.add_argument("--verbose", required=False, default=0, help="Controls the verbosity when fitting and predicting." ) | |
960 rfc.add_argument("--max_samples", required=False, default='none', help="") | |
961 rfc.add_argument("--ccp_alpha", required=False, default=0.0, help="") | |
962 rfc.add_argument("--warm_start", required=False, default='false', help="When set to True, reuse the solution of the previous call to fit and add more estimators to the ensemble, otherwise, just fit a whole new forest. See the Glossary.") | |
963 rfc.add_argument("--TrainFile", required=True, default=None, help="Positive negative dataset Ex. 'Train.csv'") | |
964 rfc.add_argument("--TestMethod", required=True, default=None, help="Internal','CrossVal', 'External', 'Predict'") | |
965 rfc.add_argument("--SelectedSclaer", required=True, help="'Min_Max',Standard_Scaler','No_Scaler'") | |
966 rfc.add_argument("--NFolds", required=False, default=5, help="int, Max=10") | |
967 rfc.add_argument("--TestFile", required=False, default=None, help="Test data, 'Test.csv'") | |
968 rfc.add_argument("--OutFile", required=False, default='Out.csv', help="Out.tsv") | |
969 rfc.add_argument("--htmlOutDir", required=False, default=os.path.join(os.getcwd(),'report_dir'), help="HTML Out Dir") | |
970 rfc.add_argument("--htmlFname", required=False, default='Out.html', help="") | |
971 rfc.add_argument("--Workdirpath", required=False, default=os.getcwd(), help="Working Directory Path") | |
972 | |
973 lrc = subparsers.add_parser('LRC') | |
974 lrc.add_argument("--penalty", required=False, default='l2', help="Used to specify the norm used in the penalization. The 'newton-cg', 'sag' and 'lbfgs' solvers support only l2 penalties. 'elasticnet' is only supported by the 'saga' solver. If 'none' (not supported by the liblinear solver), no regularization is applied." ) | |
975 lrc.add_argument("--dual", required=False, default='false', help="Dual or primal formulation. Dual formulation is only implemented for l2 penalty with liblinear solver. Prefer dual=False when n_samples > n_features.") | |
976 lrc.add_argument("--tol", required=False, default=0.0001, help="Tolerance for stopping criteria.") | |
977 lrc.add_argument("--C", required=False, default=1.0, help="Inverse of regularization strength; must be a positive float. Like in support vector machines, smaller values specify stronger regularization." ) | |
978 lrc.add_argument("--fit_intercept", required=False, default='true', help="Specifies if a constant (a.k.a. bias or intercept) should be added to the decision function." ) | |
979 lrc.add_argument("--intercept_scaling", required=False, default=1, help="Useful only when the solver 'liblinear' is used and self.fit_intercept is set to True. In this case, x becomes [x, self.intercept_scaling], i.e. a 'synthetic' feature with constant value equal to intercept_scaling is appended to the instance vector. The intercept becomes intercept_scaling * synthetic_feature_weight." ) | |
980 lrc.add_argument("--random_state", required=False, default=10, help="The seed of the pseudo random number generator to use when shuffling the data. If int, random_state is the seed used by the random number generator; If RandomState instance, random_state is the random number generator; If None, the random number generator is the RandomState instance used by np.random. Used when solver == 'sag' or 'liblinear'.") | |
981 lrc.add_argument("--solver", required=False, default='lbfgs', help="Algorithm to use in the optimization problem. For small datasets, 'liblinear' is a good choice, whereas 'sag' and 'saga' are faster for large ones. For multiclass problems, only 'newton-cg', 'sag', 'saga' and 'lbfgs' handle multinomial loss; 'liblinear' is limited to one-versus-rest schemes. 'newton-cg', 'lbfgs', 'sag' and 'saga' handle L2 or no penalty 'liblinear' and 'saga' also handle L1 penalty 'saga' also supports 'elasticnet' penalty 'liblinear' does not support setting penalty='none' Note that 'sag' and 'saga' fast convergence is only guaranteed on features with approximately the same scale. You can preprocess the data with a scaler from sklearn.preprocessing. New in version 0.17: Stochastic Average Gradient descent solver.") | |
982 lrc.add_argument("--max_iter", required=False, default=100, help="Maximum number of iterations taken for the solvers to converge."), | |
983 lrc.add_argument("--multi_class", required=False, default='auto', help="If the option chosen is 'ovr', then a binary problem is fit for each label. For 'multinomial' the loss minimised is the multinomial loss fit across the entire probability distribution, even when the data is binary. 'multinomial' is unavailable when solver='liblinear'. 'auto' selects 'ovr' if the data is binary, or if solver='liblinear', and otherwise selects 'multinomial'. New in version 0.18: Stochastic Average Gradient descent solver for 'multinomial' case.") | |
984 lrc.add_argument("--verbose", required=False, default=0, help="For the liblinear and lbfgs solvers set verbose to any positive number for verbosity.") | |
985 lrc.add_argument("--warm_start", required=False, default='false', help="When set to True, reuse the solution of the previous call to fit as initialization, otherwise, just erase the previous solution. Useless for liblinear solver. See the Glossary. New in version 0.17: warm_start to support lbfgs, newton-cg, sag, saga solvers.") | |
986 lrc.add_argument("--n_jobs", required=False, default='none', help="Number of CPU cores used when parallelizing over classes if multi_class='ovr'. This parameter is ignored when the solver is set to 'liblinear' regardless of whether 'multi_class' is specified or not. None means 1 unless in a joblib.parallel_backend context. -1 means using all processors. See Glossary for more details." ) | |
987 lrc.add_argument("--l1_ratio", required=False, default='none', help="The Elastic-Net mixing parameter, with 0 <= l1_ratio <= 1. Only used if penalty='elasticnet'. Setting 'l1_ratio=0 is equivalent to using penalty='l2', while setting l1_ratio=1 is equivalent to using penalty='l1'. For 0 < l1_ratio <1, the penalty is a combination of L1 and L2.") | |
988 lrc.add_argument("--TrainFile", required=True, default=None, help="Positive negative dataset Ex. 'Train.csv'") | |
989 lrc.add_argument("--TestMethod", required=True, default=None, help="Internal','CrossVal', 'External', 'Predict'") | |
990 lrc.add_argument("--SelectedSclaer", required=True, help="'Min_Max',Standard_Scaler','No_Scaler'") | |
991 lrc.add_argument("--NFolds", required=False, default=5, help="int, Max=10") | |
992 lrc.add_argument("--TestFile", required=False, default=None, help="Test data, 'Test.csv'") | |
993 lrc.add_argument("--OutFile", required=False, default='Out.csv', help="Out.tsv") | |
994 lrc.add_argument("--htmlOutDir", required=False, default=os.path.join(os.getcwd(),'report_dir'), help="HTML Out Dir") | |
995 lrc.add_argument("--htmlFname", required=False, default='Out.html', help="") | |
996 lrc.add_argument("--Workdirpath", required=False, default=os.getcwd(), help="Working Directory Path") | |
997 | |
998 knc = subparsers.add_parser('KNC') | |
999 knc.add_argument("--n_neighbors", required=False, default=5, help="Number of neighbors to use by default for kneighbors queries.") | |
1000 knc.add_argument("--weights",required=False, default='uniform', help="weight function used in prediction. Possible values: 'uniform' : uniform weights. All points in each neighborhood are weighted equally. 'distance' : weight points by the inverse of their distance. in this case, closer neighbors of a query point will have a greater influence than neighbors which are further away. [callable] : a user-defined function which accepts an array of distances, and returns an array of the same shape containing the weights.") | |
1001 knc.add_argument("--algorithm", required=False, default='auto', help="Algorithm used to compute the nearest neighbors:'ball_tree' will use BallTree 'kd_tree' will use KDTree 'brute' will use a brute-force search. 'auto' will attempt to decide the most appropriate algorithm based on the values passed to fit method. Note: fitting on sparse input will override the setting of this parameter, using brute force." ) | |
1002 knc.add_argument("--leaf_size", required=False, default=30, help="Leaf size passed to BallTree or KDTree. This can affect the speed of the construction and query, as well as the memory required to store the tree. The optimal value depends on the nature of the problem.") | |
1003 knc.add_argument("--p", required=False, default=2, help="Power parameter for the Minkowski metric. When p = 1, this is equivalent to using manhattan_distance (l1), and euclidean_distance (l2) for p = 2. For arbitrary p, minkowski_distance (l_p) is used." ) | |
1004 knc.add_argument("--metric", required=False, default='minkowski', help="the distance metric to use for the tree. The default metric is minkowski, and with p=2 is equivalent to the standard Euclidean metric. See the documentation of the DistanceMetric class for a list of available metrics. If metric is 'precomputed', X is assumed to be a distance matrix and must be square during fit. X may be a Glossary, in which case only 'nonzero' elements may be considered neighbors.") | |
1005 knc.add_argument("--metric_params", required=False, default=None, help="Additional keyword arguments for the metric function." ) | |
1006 knc.add_argument("--n_jobs", required=False, default='none', help="The number of parallel jobs to run for neighbors search. None means 1 unless in a joblib.parallel_backend context. -1 means using all processors. See Glossary for more details. Doesn't affect fit method.") | |
1007 knc.add_argument("--TrainFile", required=True, default=None, help="Positive negative dataset Ex. 'Train.csv'") | |
1008 knc.add_argument("--TestMethod", required=True, default=None, help="Internal','CrossVal', 'External', 'Predict'") | |
1009 knc.add_argument("--SelectedSclaer", required=True, help="'Min_Max',Standard_Scaler','No_Scaler'") | |
1010 knc.add_argument("--NFolds", required=False, default=5, help="int, Max=10") | |
1011 knc.add_argument("--TestFile", required=False, default=None, help="Test data, 'Test.csv'") | |
1012 knc.add_argument("--OutFile", required=False, default='Out.csv', help="Out.tsv") | |
1013 knc.add_argument("--htmlOutDir", required=False, default=os.path.join(os.getcwd(),'report_dir'), help="HTML Out Dir") | |
1014 knc.add_argument("--htmlFname", required=False, default='Out.html', help="") | |
1015 knc.add_argument("--Workdirpath", required=False, default=os.getcwd(), help="Working Directory Path") | |
1016 | |
1017 gnbc = subparsers.add_parser('GNBC') | |
1018 #gnbc.add_argument("--priors", required=False, default=None, help="Prior probabilities of the classes. If specified the priors are not adjusted according to the data.") | |
1019 gnbc.add_argument("--var_smoothing", required=False, default=1e-09, help="Portion of the largest variance of all features that is added to variances for calculation stability.") | |
1020 gnbc.add_argument("--TrainFile", required=True, default=None, help="Positive negative dataset Ex. 'Train.csv'") | |
1021 gnbc.add_argument("--TestMethod", required=True, default=None, help="Internal','CrossVal', 'External', 'Predict'") | |
1022 gnbc.add_argument("--SelectedSclaer", required=True, help="'Min_Max',Standard_Scaler','No_Scaler'") | |
1023 gnbc.add_argument("--NFolds", required=False, default=5, help="int, Max=10") | |
1024 gnbc.add_argument("--TestFile", required=False, default=None, help="Test data, 'Test.csv'") | |
1025 gnbc.add_argument("--OutFile", required=False, default='Out.csv', help="Out.tsv") | |
1026 gnbc.add_argument("--htmlOutDir", required=False, default=os.path.join(os.getcwd(),'report_dir'), help="HTML Out Dir") | |
1027 gnbc.add_argument("--htmlFname", required=False, default='Out.html', help="") | |
1028 gnbc.add_argument("--Workdirpath", required=False, default=os.getcwd(), help="Working Directory Path") | |
1029 | |
1030 MLP = subparsers.add_parser('MLP') | |
1031 MLP.add_argument("--hidden_layer_sizes", required=False, default=(100,), help="") | |
1032 MLP.add_argument("--activation", required=False, default='relu', help="") | |
1033 MLP.add_argument("--solver", required=False, default='adam', help="") | |
1034 MLP.add_argument("--alpha", required=False, default=0.0001 , help="") | |
1035 MLP.add_argument("--batch_size", required=False, default='auto', help="") | |
1036 MLP.add_argument("--learning_rate", required=False, default='constant', help="") | |
1037 MLP.add_argument("--learning_rate_init", required=False, default=0.001, help="") | |
1038 MLP.add_argument("--power_t", required=False, default=0.5, help="") | |
1039 MLP.add_argument("--max_iter", required=False, default=200, help="") | |
1040 MLP.add_argument("--shuffle", required=False, default='true', help="") | |
1041 MLP.add_argument("--random_state", required=False, default='none', help="") | |
1042 MLP.add_argument("--tol", required=False, default=0.0001, help="") | |
1043 MLP.add_argument("--verbose", required=False, default='false', help="") | |
1044 MLP.add_argument("--warm_start", required=False, default='false', help="") | |
1045 MLP.add_argument("--momentum", required=False, default=0.9, help="") | |
1046 MLP.add_argument("--nesterovs_momentum", required=False, default='true' ,help="") | |
1047 MLP.add_argument("--early_stopping", required=False, default='false' ,help="") | |
1048 MLP.add_argument("--validation_fraction", required=False, default=0.1 ,help="") | |
1049 MLP.add_argument("--beta_1", required=False, default=0.9, help="") | |
1050 MLP.add_argument("--beta_2", required=False , default=0.999, help="") | |
1051 MLP.add_argument("--epsilon", required=False, default=1e-08, help="") | |
1052 MLP.add_argument("--n_iter_no_change", required=False, default=10, help="") | |
1053 MLP.add_argument("--max_fun", required=False, default=15000, help="") | |
1054 MLP.add_argument("--TrainFile", required=True, default=None, help="Positive negative dataset Ex. 'Train.csv'") | |
1055 MLP.add_argument("--TestMethod", required=True, default=None, help="Internal','CrossVal', 'External', 'Predict'") | |
1056 MLP.add_argument("--SelectedSclaer", required=True, help="'Min_Max',Standard_Scaler','No_Scaler'") | |
1057 MLP.add_argument("--NFolds", required=False, default=5, help="int, Max=10") | |
1058 MLP.add_argument("--Testspt", required=False, default=0.2, help="float, Max=1.0") | |
1059 MLP.add_argument("--TestFile", required=False, default=None, help="Test data, 'Test.csv'") | |
1060 MLP.add_argument("--OutFile", required=False, default='Out.csv', help="Out.tsv") | |
1061 MLP.add_argument("--htmlOutDir", required=False, default=os.path.join(os.getcwd(),'report_dir'), help="HTML Out Dir") | |
1062 MLP.add_argument("--htmlFname", required=False, help="HTML out file", default="jai.html") | |
1063 MLP.add_argument("--Workdirpath", required=False, default=os.getcwd(), help="Working Directory Path") | |
1064 | |
1065 args = parser.parse_args() | |
1066 | |
1067 if sys.argv[1] == 'SVMC': | |
1068 SVM_Classifier(args.C, args.kernel, args.degree, args.gamma, args.coef0, args.shrinking, args.probability, args.tol, args.cache_size, args.verbose, args.max_iter, args.decision_function_shape, args.randomState, args.breakties, args.TrainFile, args.TestMethod, args.SelectedSclaer, args.NFolds, args.TestFile, args.OutFile, args.htmlOutDir, args.htmlFname, args.Workdirpath) | |
1069 elif sys.argv[1] == 'SGDC': | |
1070 SGD_Classifier( args.loss, args.penalty, args.alpha, args.l1_ratio, args.fit_intercept, args.max_iter, args.tol, args.shuffle, args.verbose, args.epsilon, args.n_jobs, args.random_state, args.learning_rate, args.eta0, args.power_t, args.early_stopping, args.validation_fraction, args.n_iter_no_change, args.warm_start, args.average, args.TrainFile, args.TestMethod, args.SelectedSclaer, args.NFolds, args.TestFile, args.OutFile, args.htmlOutDir, args.htmlFname, args.Workdirpath) | |
1071 elif sys.argv[1] == 'DTC': | |
1072 DT_Classifier(args.criterion, args.splitter, args.max_depth, args.min_samples_split, args.min_samples_leaf, args.min_weight_fraction_leaf, args.random_state, args.max_leaf_nodes, args.min_impurity_decrease, args.min_impurity_split, args.presort, args.ccpalpha, args.max_features, args.TrainFile, args.TestMethod, args.SelectedSclaer, args.NFolds, args.TestFile, args.OutFile, args.htmlOutDir, args.htmlFname, args.Workdirpath) | |
1073 elif sys.argv[1] == 'GBC': | |
1074 GB_Classifier(args.loss, args.learning_rate, args.n_estimators, args.subsample, args.criterion, args.min_samples_split, args.min_samples_leaf, args.min_weight_fraction_leaf, args.max_depth, args.min_impurity_decrease, args.min_impurity_split, args.init, args.random_state, args.verbose, args.max_leaf_nodes, args.warm_start, args.presort, args.validation_fraction, args.n_iter_no_change, args.tol, args.ccpalpha, args.max_features, args.TrainFile, args.TestMethod, args.SelectedSclaer, args.NFolds, args.TestFile, args.OutFile, args.htmlOutDir, args.htmlFname, args.Workdirpath) | |
1075 elif sys.argv[1] == 'RFC': | |
1076 RF_Classifier( args.n_estimators, args.criterion, args.max_depth, args.min_samples_split, args.min_samples_leaf, args.min_weight_fraction_leaf, args.max_features, args.max_leaf_nodes, args.min_impurity_decrease, args.min_impurity_split, args.bootstrap, args.oob_score, args.n_jobs, args.random_state, args.verbose, args.warm_start, args.ccp_alpha, args.max_samples, args.TrainFile, args.TestMethod, args.SelectedSclaer, args.NFolds, args.TestFile, args.OutFile, args.htmlOutDir, args.htmlFname, args.Workdirpath) | |
1077 elif sys.argv[1] == 'LRC': | |
1078 LR_Classifier(args.penalty, args.dual, args.tol, args.C, args.fit_intercept, args.intercept_scaling, args.random_state, args.solver, args.max_iter, args.multi_class, args.verbose, args.warm_start, args.n_jobs, args.l1_ratio, args.TrainFile, args.TestMethod, args.SelectedSclaer, args.NFolds, args.TestFile, args.OutFile, args.htmlOutDir, args.htmlFname, args.Workdirpath) | |
1079 elif sys.argv[1] == 'KNC': | |
1080 KN_Classifier(args.n_neighbors, args.weights, args.algorithm, args.leaf_size, args.p, args.metric, args.metric_params, args.n_jobs, args.TrainFile, args.TestMethod, args.SelectedSclaer, args.NFolds, args.TestFile, args.OutFile, args.htmlOutDir, args.htmlFname, args.Workdirpath) | |
1081 elif sys.argv[1] == 'GNBC': | |
1082 GNB_Classifier( args.var_smoothing, args.TrainFile, args.TestMethod, args.SelectedSclaer, args.NFolds, args.TestFile, args.OutFile, args.htmlOutDir, args.htmlFname, args.Workdirpath) | |
1083 elif sys.argv[1] == 'MLP' : | |
1084 MLP_Classifier(args.hidden_layer_sizes, args.activation, args.solver, args.alpha, args.batch_size, args.learning_rate, args.learning_rate_init, args.power_t, args.max_iter, args.shuffle, args.random_state, args.tol, args.verbose, args.warm_start, args.momentum, args.nesterovs_momentum, args.early_stopping, args.validation_fraction, args.beta_1, args.beta_2, args.epsilon, args.n_iter_no_change, args.max_fun, args.TrainFile, args.TestMethod, args.SelectedSclaer, args.NFolds, args.Testspt, args.TestFile, args.OutFile, args.htmlOutDir, args.htmlFname, args.Workdirpath) | |
1085 else: | |
1086 print ("option not correct") | |
1087 exit() | |
1088 |