Mercurial > repos > bgruening > sklearn_pca

comparison search_model_validation.py @ 0:2d7016b3ae92 draft

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
"planemo upload for repository https://github.com/bgruening/galaxytools/tree/master/tools/sklearn commit 2afb24f3c81d625312186750a714d702363012b5"
author bgruening
date Fri, 02 Oct 2020 08:45:21 +0000
parents
children 132805688fa3
comparison
equal deleted inserted replaced
-1:000000000000 0:2d7016b3ae92
1 import argparse
2 import collections
3 import imblearn
4 import joblib
5 import json
6 import numpy as np
7 import os
8 import pandas as pd
9 import pickle
10 import skrebate
11 import sys
12 import warnings
13 from scipy.io import mmread
14 from sklearn import (cluster, decomposition, feature_selection,
15 kernel_approximation, model_selection, preprocessing)
16 from sklearn.exceptions import FitFailedWarning
17 from sklearn.model_selection._validation import _score, cross_validate
18 from sklearn.model_selection import _search, _validation
19 from sklearn.pipeline import Pipeline
20
21 from galaxy_ml.utils import (SafeEval, get_cv, get_scoring, load_model,
22 read_columns, try_get_attr, get_module,
23 clean_params, get_main_estimator)
24
25
26 _fit_and_score = try_get_attr('galaxy_ml.model_validations', '_fit_and_score')
27 setattr(_search, '_fit_and_score', _fit_and_score)
28 setattr(_validation, '_fit_and_score', _fit_and_score)
29
30 N_JOBS = int(os.environ.get('GALAXY_SLOTS', 1))
31 # handle disk cache
32 CACHE_DIR = os.path.join(os.getcwd(), 'cached')
33 del os
34 NON_SEARCHABLE = ('n_jobs', 'pre_dispatch', 'memory', '_path',
35 'nthread', 'callbacks')
36
37
38 def _eval_search_params(params_builder):
39 search_params = {}
40
41 for p in params_builder['param_set']:
42 search_list = p['sp_list'].strip()
43 if search_list == '':
44 continue
45
46 param_name = p['sp_name']
47 if param_name.lower().endswith(NON_SEARCHABLE):
48 print("Warning: `%s` is not eligible for search and was "
49 "omitted!" % param_name)
50 continue
51
52 if not search_list.startswith(':'):
53 safe_eval = SafeEval(load_scipy=True, load_numpy=True)
54 ev = safe_eval(search_list)
55 search_params[param_name] = ev
56 else:
57 # Have `:` before search list, asks for estimator evaluatio
58 safe_eval_es = SafeEval(load_estimators=True)
59 search_list = search_list[1:].strip()
60 # TODO maybe add regular express check
61 ev = safe_eval_es(search_list)
62 preprocessings = (
63 preprocessing.StandardScaler(), preprocessing.Binarizer(),
64 preprocessing.MaxAbsScaler(),
65 preprocessing.Normalizer(), preprocessing.MinMaxScaler(),
66 preprocessing.PolynomialFeatures(),
67 preprocessing.RobustScaler(), feature_selection.SelectKBest(),
68 feature_selection.GenericUnivariateSelect(),
69 feature_selection.SelectPercentile(),
70 feature_selection.SelectFpr(), feature_selection.SelectFdr(),
71 feature_selection.SelectFwe(),
72 feature_selection.VarianceThreshold(),
73 decomposition.FactorAnalysis(random_state=0),
74 decomposition.FastICA(random_state=0),
75 decomposition.IncrementalPCA(),
76 decomposition.KernelPCA(random_state=0, n_jobs=N_JOBS),
77 decomposition.LatentDirichletAllocation(
78 random_state=0, n_jobs=N_JOBS),
79 decomposition.MiniBatchDictionaryLearning(
80 random_state=0, n_jobs=N_JOBS),
81 decomposition.MiniBatchSparsePCA(
82 random_state=0, n_jobs=N_JOBS),
83 decomposition.NMF(random_state=0),
84 decomposition.PCA(random_state=0),
85 decomposition.SparsePCA(random_state=0, n_jobs=N_JOBS),
86 decomposition.TruncatedSVD(random_state=0),
87 kernel_approximation.Nystroem(random_state=0),
88 kernel_approximation.RBFSampler(random_state=0),
89 kernel_approximation.AdditiveChi2Sampler(),
90 kernel_approximation.SkewedChi2Sampler(random_state=0),
91 cluster.FeatureAgglomeration(),
92 skrebate.ReliefF(n_jobs=N_JOBS),
93 skrebate.SURF(n_jobs=N_JOBS),
94 skrebate.SURFstar(n_jobs=N_JOBS),
95 skrebate.MultiSURF(n_jobs=N_JOBS),
96 skrebate.MultiSURFstar(n_jobs=N_JOBS),
97 imblearn.under_sampling.ClusterCentroids(
98 random_state=0, n_jobs=N_JOBS),
99 imblearn.under_sampling.CondensedNearestNeighbour(
100 random_state=0, n_jobs=N_JOBS),
101 imblearn.under_sampling.EditedNearestNeighbours(
102 random_state=0, n_jobs=N_JOBS),
103 imblearn.under_sampling.RepeatedEditedNearestNeighbours(
104 random_state=0, n_jobs=N_JOBS),
105 imblearn.under_sampling.AllKNN(random_state=0, n_jobs=N_JOBS),
106 imblearn.under_sampling.InstanceHardnessThreshold(
107 random_state=0, n_jobs=N_JOBS),
108 imblearn.under_sampling.NearMiss(
109 random_state=0, n_jobs=N_JOBS),
110 imblearn.under_sampling.NeighbourhoodCleaningRule(
111 random_state=0, n_jobs=N_JOBS),
112 imblearn.under_sampling.OneSidedSelection(
113 random_state=0, n_jobs=N_JOBS),
114 imblearn.under_sampling.RandomUnderSampler(
115 random_state=0),
116 imblearn.under_sampling.TomekLinks(
117 random_state=0, n_jobs=N_JOBS),
118 imblearn.over_sampling.ADASYN(random_state=0, n_jobs=N_JOBS),
119 imblearn.over_sampling.RandomOverSampler(random_state=0),
120 imblearn.over_sampling.SMOTE(random_state=0, n_jobs=N_JOBS),
121 imblearn.over_sampling.SVMSMOTE(random_state=0, n_jobs=N_JOBS),
122 imblearn.over_sampling.BorderlineSMOTE(
123 random_state=0, n_jobs=N_JOBS),
124 imblearn.over_sampling.SMOTENC(
125 categorical_features=[], random_state=0, n_jobs=N_JOBS),
126 imblearn.combine.SMOTEENN(random_state=0),
127 imblearn.combine.SMOTETomek(random_state=0))
128 newlist = []
129 for obj in ev:
130 if obj is None:
131 newlist.append(None)
132 elif obj == 'all_0':
133 newlist.extend(preprocessings[0:35])
134 elif obj == 'sk_prep_all': # no KernalCenter()
135 newlist.extend(preprocessings[0:7])
136 elif obj == 'fs_all':
137 newlist.extend(preprocessings[7:14])
138 elif obj == 'decomp_all':
139 newlist.extend(preprocessings[14:25])
140 elif obj == 'k_appr_all':
141 newlist.extend(preprocessings[25:29])
142 elif obj == 'reb_all':
143 newlist.extend(preprocessings[30:35])
144 elif obj == 'imb_all':
145 newlist.extend(preprocessings[35:54])
146 elif type(obj) is int and -1 < obj < len(preprocessings):
147 newlist.append(preprocessings[obj])
148 elif hasattr(obj, 'get_params'): # user uploaded object
149 if 'n_jobs' in obj.get_params():
150 newlist.append(obj.set_params(n_jobs=N_JOBS))
151 else:
152 newlist.append(obj)
153 else:
154 sys.exit("Unsupported estimator type: %r" % (obj))
155
156 search_params[param_name] = newlist
157
158 return search_params
159
160
161 def _handle_X_y(estimator, params, infile1, infile2, loaded_df={},
162 ref_seq=None, intervals=None, targets=None,
163 fasta_path=None):
164 """read inputs
165
166 Params
167 -------
168 estimator : estimator object
169 params : dict
170 Galaxy tool parameter inputs
171 infile1 : str
172 File path to dataset containing features
173 infile2 : str
174 File path to dataset containing target values
175 loaded_df : dict
176 Contains loaded DataFrame objects with file path as keys
177 ref_seq : str
178 File path to dataset containing genome sequence file
179 interval : str
180 File path to dataset containing interval file
181 targets : str
182 File path to dataset compressed target bed file
183 fasta_path : str
184 File path to dataset containing fasta file
185
186
187 Returns
188 -------
189 estimator : estimator object after setting new attributes
190 X : numpy array
191 y : numpy array
192 """
193 estimator_params = estimator.get_params()
194
195 input_type = params['input_options']['selected_input']
196 # tabular input
197 if input_type == 'tabular':
198 header = 'infer' if params['input_options']['header1'] else None
199 column_option = (params['input_options']['column_selector_options_1']
200 ['selected_column_selector_option'])
201 if column_option in ['by_index_number', 'all_but_by_index_number',
202 'by_header_name', 'all_but_by_header_name']:
203 c = params['input_options']['column_selector_options_1']['col1']
204 else:
205 c = None
206
207 df_key = infile1 + repr(header)
208
209 if df_key in loaded_df:
210 infile1 = loaded_df[df_key]
211
212 df = pd.read_csv(infile1, sep='\t', header=header,
213 parse_dates=True)
214 loaded_df[df_key] = df
215
216 X = read_columns(df, c=c, c_option=column_option).astype(float)
217 # sparse input
218 elif input_type == 'sparse':
219 X = mmread(open(infile1, 'r'))
220
221 # fasta_file input
222 elif input_type == 'seq_fasta':
223 pyfaidx = get_module('pyfaidx')
224 sequences = pyfaidx.Fasta(fasta_path)
225 n_seqs = len(sequences.keys())
226 X = np.arange(n_seqs)[:, np.newaxis]
227 for param in estimator_params.keys():
228 if param.endswith('fasta_path'):
229 estimator.set_params(
230 **{param: fasta_path})
231 break
232 else:
233 raise ValueError(
234 "The selected estimator doesn't support "
235 "fasta file input! Please consider using "
236 "KerasGBatchClassifier with "
237 "FastaDNABatchGenerator/FastaProteinBatchGenerator "
238 "or having GenomeOneHotEncoder/ProteinOneHotEncoder "
239 "in pipeline!")
240
241 elif input_type == 'refseq_and_interval':
242 path_params = {
243 'data_batch_generator__ref_genome_path': ref_seq,
244 'data_batch_generator__intervals_path': intervals,
245 'data_batch_generator__target_path': targets
246 }
247 estimator.set_params(**path_params)
248 n_intervals = sum(1 for line in open(intervals))
249 X = np.arange(n_intervals)[:, np.newaxis]
250
251 # Get target y
252 header = 'infer' if params['input_options']['header2'] else None
253 column_option = (params['input_options']['column_selector_options_2']
254 ['selected_column_selector_option2'])
255 if column_option in ['by_index_number', 'all_but_by_index_number',
256 'by_header_name', 'all_but_by_header_name']:
257 c = params['input_options']['column_selector_options_2']['col2']
258 else:
259 c = None
260
261 df_key = infile2 + repr(header)
262 if df_key in loaded_df:
263 infile2 = loaded_df[df_key]
264 else:
265 infile2 = pd.read_csv(infile2, sep='\t',
266 header=header, parse_dates=True)
267 loaded_df[df_key] = infile2
268
269 y = read_columns(
270 infile2,
271 c=c,
272 c_option=column_option,
273 sep='\t',
274 header=header,
275 parse_dates=True)
276 if len(y.shape) == 2 and y.shape[1] == 1:
277 y = y.ravel()
278 if input_type == 'refseq_and_interval':
279 estimator.set_params(
280 data_batch_generator__features=y.ravel().tolist())
281 y = None
282 # end y
283
284 return estimator, X, y
285
286
287 def _do_outer_cv(searcher, X, y, outer_cv, scoring, error_score='raise',
288 outfile=None):
289 """Do outer cross-validation for nested CV
290
291 Parameters
292 ----------
293 searcher : object
294 SearchCV object
295 X : numpy array
296 Containing features
297 y : numpy array
298 Target values or labels
299 outer_cv : int or CV splitter
300 Control the cv splitting
301 scoring : object
302 Scorer
303 error_score: str, float or numpy float
304 Whether to raise fit error or return an value
305 outfile : str
306 File path to store the restuls
307 """
308 if error_score == 'raise':
309 rval = cross_validate(
310 searcher, X, y, scoring=scoring,
311 cv=outer_cv, n_jobs=N_JOBS, verbose=0,
312 error_score=error_score)
313 else:
314 warnings.simplefilter('always', FitFailedWarning)
315 with warnings.catch_warnings(record=True) as w:
316 try:
317 rval = cross_validate(
318 searcher, X, y,
319 scoring=scoring,
320 cv=outer_cv, n_jobs=N_JOBS,
321 verbose=0,
322 error_score=error_score)
323 except ValueError:
324 pass
325 for warning in w:
326 print(repr(warning.message))
327
328 keys = list(rval.keys())
329 for k in keys:
330 if k.startswith('test'):
331 rval['mean_' + k] = np.mean(rval[k])
332 rval['std_' + k] = np.std(rval[k])
333 if k.endswith('time'):
334 rval.pop(k)
335 rval = pd.DataFrame(rval)
336 rval = rval[sorted(rval.columns)]
337 rval.to_csv(path_or_buf=outfile, sep='\t', header=True, index=False)
338
339
340 def _do_train_test_split_val(searcher, X, y, params, error_score='raise',
341 primary_scoring=None, groups=None,
342 outfile=None):
343 """ do train test split, searchCV validates on the train and then use
344 the best_estimator_ to evaluate on the test
345
346 Returns
347 --------
348 Fitted SearchCV object
349 """
350 train_test_split = try_get_attr(
351 'galaxy_ml.model_validations', 'train_test_split')
352 split_options = params['outer_split']
353
354 # splits
355 if split_options['shuffle'] == 'stratified':
356 split_options['labels'] = y
357 X, X_test, y, y_test = train_test_split(X, y, **split_options)
358 elif split_options['shuffle'] == 'group':
359 if groups is None:
360 raise ValueError("No group based CV option was choosen for "
361 "group shuffle!")
362 split_options['labels'] = groups
363 if y is None:
364 X, X_test, groups, _ =\
365 train_test_split(X, groups, **split_options)
366 else:
367 X, X_test, y, y_test, groups, _ =\
368 train_test_split(X, y, groups, **split_options)
369 else:
370 if split_options['shuffle'] == 'None':
371 split_options['shuffle'] = None
372 X, X_test, y, y_test =\
373 train_test_split(X, y, **split_options)
374
375 if error_score == 'raise':
376 searcher.fit(X, y, groups=groups)
377 else:
378 warnings.simplefilter('always', FitFailedWarning)
379 with warnings.catch_warnings(record=True) as w:
380 try:
381 searcher.fit(X, y, groups=groups)
382 except ValueError:
383 pass
384 for warning in w:
385 print(repr(warning.message))
386
387 scorer_ = searcher.scorer_
388 if isinstance(scorer_, collections.Mapping):
389 is_multimetric = True
390 else:
391 is_multimetric = False
392
393 best_estimator_ = getattr(searcher, 'best_estimator_')
394
395 # TODO Solve deep learning models in pipeline
396 if best_estimator_.__class__.__name__ == 'KerasGBatchClassifier':
397 test_score = best_estimator_.evaluate(
398 X_test, scorer=scorer_, is_multimetric=is_multimetric)
399 else:
400 test_score = _score(best_estimator_, X_test,
401 y_test, scorer_,
402 is_multimetric=is_multimetric)
403
404 if not is_multimetric:
405 test_score = {primary_scoring: test_score}
406 for key, value in test_score.items():
407 test_score[key] = [value]
408 result_df = pd.DataFrame(test_score)
409 result_df.to_csv(path_or_buf=outfile, sep='\t', header=True,
410 index=False)
411
412 return searcher
413
414
415 def main(inputs, infile_estimator, infile1, infile2,
416 outfile_result, outfile_object=None,
417 outfile_weights=None, groups=None,
418 ref_seq=None, intervals=None, targets=None,
419 fasta_path=None):
420 """
421 Parameter
422 ---------
423 inputs : str
424 File path to galaxy tool parameter
425
426 infile_estimator : str
427 File path to estimator
428
429 infile1 : str
430 File path to dataset containing features
431
432 infile2 : str
433 File path to dataset containing target values
434
435 outfile_result : str
436 File path to save the results, either cv_results or test result
437
438 outfile_object : str, optional
439 File path to save searchCV object
440
441 outfile_weights : str, optional
442 File path to save model weights
443
444 groups : str
445 File path to dataset containing groups labels
446
447 ref_seq : str
448 File path to dataset containing genome sequence file
449
450 intervals : str
451 File path to dataset containing interval file
452
453 targets : str
454 File path to dataset compressed target bed file
455
456 fasta_path : str
457 File path to dataset containing fasta file
458 """
459 warnings.simplefilter('ignore')
460
461 # store read dataframe object
462 loaded_df = {}
463
464 with open(inputs, 'r') as param_handler:
465 params = json.load(param_handler)
466
467 # Override the refit parameter
468 params['search_schemes']['options']['refit'] = True \
469 if params['save'] != 'nope' else False
470
471 with open(infile_estimator, 'rb') as estimator_handler:
472 estimator = load_model(estimator_handler)
473
474 optimizer = params['search_schemes']['selected_search_scheme']
475 optimizer = getattr(model_selection, optimizer)
476
477 # handle gridsearchcv options
478 options = params['search_schemes']['options']
479
480 if groups:
481 header = 'infer' if (options['cv_selector']['groups_selector']
482 ['header_g']) else None
483 column_option = (options['cv_selector']['groups_selector']
484 ['column_selector_options_g']
485 ['selected_column_selector_option_g'])
486 if column_option in ['by_index_number', 'all_but_by_index_number',
487 'by_header_name', 'all_but_by_header_name']:
488 c = (options['cv_selector']['groups_selector']
489 ['column_selector_options_g']['col_g'])
490 else:
491 c = None
492
493 df_key = groups + repr(header)
494
495 groups = pd.read_csv(groups, sep='\t', header=header,
496 parse_dates=True)
497 loaded_df[df_key] = groups
498
499 groups = read_columns(
500 groups,
501 c=c,
502 c_option=column_option,
503 sep='\t',
504 header=header,
505 parse_dates=True)
506 groups = groups.ravel()
507 options['cv_selector']['groups_selector'] = groups
508
509 splitter, groups = get_cv(options.pop('cv_selector'))
510 options['cv'] = splitter
511 primary_scoring = options['scoring']['primary_scoring']
512 options['scoring'] = get_scoring(options['scoring'])
513 if options['error_score']:
514 options['error_score'] = 'raise'
515 else:
516 options['error_score'] = np.NaN
517 if options['refit'] and isinstance(options['scoring'], dict):
518 options['refit'] = primary_scoring
519 if 'pre_dispatch' in options and options['pre_dispatch'] == '':
520 options['pre_dispatch'] = None
521
522 params_builder = params['search_schemes']['search_params_builder']
523 param_grid = _eval_search_params(params_builder)
524
525 estimator = clean_params(estimator)
526
527 # save the SearchCV object without fit
528 if params['save'] == 'save_no_fit':
529 searcher = optimizer(estimator, param_grid, **options)
530 print(searcher)
531 with open(outfile_object, 'wb') as output_handler:
532 pickle.dump(searcher, output_handler,
533 pickle.HIGHEST_PROTOCOL)
534 return 0
535
536 # read inputs and loads new attributes, like paths
537 estimator, X, y = _handle_X_y(estimator, params, infile1, infile2,
538 loaded_df=loaded_df, ref_seq=ref_seq,
539 intervals=intervals, targets=targets,
540 fasta_path=fasta_path)
541
542 # cache iraps_core fits could increase search speed significantly
543 memory = joblib.Memory(location=CACHE_DIR, verbose=0)
544 main_est = get_main_estimator(estimator)
545 if main_est.__class__.__name__ == 'IRAPSClassifier':
546 main_est.set_params(memory=memory)
547
548 searcher = optimizer(estimator, param_grid, **options)
549
550 split_mode = params['outer_split'].pop('split_mode')
551
552 if split_mode == 'nested_cv':
553 # make sure refit is choosen
554 # this could be True for sklearn models, but not the case for
555 # deep learning models
556 if not options['refit'] and \
557 not all(hasattr(estimator, attr)
558 for attr in ('config', 'model_type')):
559 warnings.warn("Refit is change to `True` for nested validation!")
560 setattr(searcher, 'refit', True)
561
562 outer_cv, _ = get_cv(params['outer_split']['cv_selector'])
563 # nested CV, outer cv using cross_validate
564 if options['error_score'] == 'raise':
565 rval = cross_validate(
566 searcher, X, y, scoring=options['scoring'],
567 cv=outer_cv, n_jobs=N_JOBS,
568 verbose=options['verbose'],
569 return_estimator=(params['save'] == 'save_estimator'),
570 error_score=options['error_score'],
571 return_train_score=True)
572 else:
573 warnings.simplefilter('always', FitFailedWarning)
574 with warnings.catch_warnings(record=True) as w:
575 try:
576 rval = cross_validate(
577 searcher, X, y,
578 scoring=options['scoring'],
579 cv=outer_cv, n_jobs=N_JOBS,
580 verbose=options['verbose'],
581 return_estimator=(params['save'] == 'save_estimator'),
582 error_score=options['error_score'],
583 return_train_score=True)
584 except ValueError:
585 pass
586 for warning in w:
587 print(repr(warning.message))
588
589 fitted_searchers = rval.pop('estimator', [])
590 if fitted_searchers:
591 import os
592 pwd = os.getcwd()
593 save_dir = os.path.join(pwd, 'cv_results_in_folds')
594 try:
595 os.mkdir(save_dir)
596 for idx, obj in enumerate(fitted_searchers):
597 target_name = 'cv_results_' + '_' + 'split%d' % idx
598 target_path = os.path.join(pwd, save_dir, target_name)
599 cv_results_ = getattr(obj, 'cv_results_', None)
600 if not cv_results_:
601 print("%s is not available" % target_name)
602 continue
603 cv_results_ = pd.DataFrame(cv_results_)
604 cv_results_ = cv_results_[sorted(cv_results_.columns)]
605 cv_results_.to_csv(target_path, sep='\t', header=True,
606 index=False)
607 except Exception as e:
608 print(e)
609 finally:
610 del os
611
612 keys = list(rval.keys())
613 for k in keys:
614 if k.startswith('test'):
615 rval['mean_' + k] = np.mean(rval[k])
616 rval['std_' + k] = np.std(rval[k])
617 if k.endswith('time'):
618 rval.pop(k)
619 rval = pd.DataFrame(rval)
620 rval = rval[sorted(rval.columns)]
621 rval.to_csv(path_or_buf=outfile_result, sep='\t', header=True,
622 index=False)
623
624 return 0
625
626 # deprecate train test split mode
627 """searcher = _do_train_test_split_val(
628 searcher, X, y, params,
629 primary_scoring=primary_scoring,
630 error_score=options['error_score'],
631 groups=groups,
632 outfile=outfile_result)"""
633
634 # no outer split
635 else:
636 searcher.set_params(n_jobs=N_JOBS)
637 if options['error_score'] == 'raise':
638 searcher.fit(X, y, groups=groups)
639 else:
640 warnings.simplefilter('always', FitFailedWarning)
641 with warnings.catch_warnings(record=True) as w:
642 try:
643 searcher.fit(X, y, groups=groups)
644 except ValueError:
645 pass
646 for warning in w:
647 print(repr(warning.message))
648
649 cv_results = pd.DataFrame(searcher.cv_results_)
650 cv_results = cv_results[sorted(cv_results.columns)]
651 cv_results.to_csv(path_or_buf=outfile_result, sep='\t',
652 header=True, index=False)
653
654 memory.clear(warn=False)
655
656 # output best estimator, and weights if applicable
657 if outfile_object:
658 best_estimator_ = getattr(searcher, 'best_estimator_', None)
659 if not best_estimator_:
660 warnings.warn("GridSearchCV object has no attribute "
661 "'best_estimator_', because either it's "
662 "nested gridsearch or `refit` is False!")
663 return
664
665 # clean prams
666 best_estimator_ = clean_params(best_estimator_)
667
668 main_est = get_main_estimator(best_estimator_)
669
670 if hasattr(main_est, 'model_') \
671 and hasattr(main_est, 'save_weights'):
672 if outfile_weights:
673 main_est.save_weights(outfile_weights)
674 del main_est.model_
675 del main_est.fit_params
676 del main_est.model_class_
677 del main_est.validation_data
678 if getattr(main_est, 'data_generator_', None):
679 del main_est.data_generator_
680
681 with open(outfile_object, 'wb') as output_handler:
682 print("Best estimator is saved: %s " % repr(best_estimator_))
683 pickle.dump(best_estimator_, output_handler,
684 pickle.HIGHEST_PROTOCOL)
685
686
687 if __name__ == '__main__':
688 aparser = argparse.ArgumentParser()
689 aparser.add_argument("-i", "--inputs", dest="inputs", required=True)
690 aparser.add_argument("-e", "--estimator", dest="infile_estimator")
691 aparser.add_argument("-X", "--infile1", dest="infile1")
692 aparser.add_argument("-y", "--infile2", dest="infile2")
693 aparser.add_argument("-O", "--outfile_result", dest="outfile_result")
694 aparser.add_argument("-o", "--outfile_object", dest="outfile_object")
695 aparser.add_argument("-w", "--outfile_weights", dest="outfile_weights")
696 aparser.add_argument("-g", "--groups", dest="groups")
697 aparser.add_argument("-r", "--ref_seq", dest="ref_seq")
698 aparser.add_argument("-b", "--intervals", dest="intervals")
699 aparser.add_argument("-t", "--targets", dest="targets")
700 aparser.add_argument("-f", "--fasta_path", dest="fasta_path")
701 args = aparser.parse_args()
702
703 main(args.inputs, args.infile_estimator, args.infile1, args.infile2,
704 args.outfile_result, outfile_object=args.outfile_object,
705 outfile_weights=args.outfile_weights, groups=args.groups,
706 ref_seq=args.ref_seq, intervals=args.intervals,
707 targets=args.targets, fasta_path=args.fasta_path)