Ejemplo n.º 1
0
def tune_rbfsvr():
    name = 'RbfSVR'
    dimension = 'length'
    
    stage, rbfsvr_reg, scale, features, rbfsvr_checkpoint_score = stage_meta_init(meta_dimension, name, dimension)
    
    if stage == 0:
        rbfsvr_reg = SVR(kernel = 'rbf')
        rbfsvr_checkpoint_score = -np.inf
#        features = init_feat_selection(X, Y, rbfsvr_reg)
        scale, rbfsvr_checkpoint_score = test_scaler(rbfsvr_reg, X, Y) 
        _save_meta_model(meta_dimension, stage, dimension, name, rbfsvr_reg, scale, rbfsvr_checkpoint_score, list(X), final = False)
        
    elif stage == 1: 
        rbfsvr_checkpoint_score, features = feat_selection_2(X[features], Y, scale, rbfsvr_reg, rbfsvr_checkpoint_score, 24, -1, False)
        _save_meta_model(meta_dimension, stage, dimension, name, rbfsvr_reg, scale, rbfsvr_checkpoint_score, features, final = False)
    
    elif stage == 2:
        scale, linsvc_checkpoint_score = test_scaler(rbfsvr_reg, X[features], Y) 
        _save_meta_model(meta_dimension, stage, dimension, name, rbfsvr_reg, scale, rbfsvr_checkpoint_score, features, final = False)
            
    elif stage == 3:
        rbfsvr_reg, rbfsvr_checkpoint_score = svc_hyper_parameter_tuning(X[features], Y, rbfsvr_reg, scale, rbfsvr_checkpoint_score)
        _save_meta_model(meta_dimension, stage, dimension, name, rbfsvr_reg, scale, rbfsvr_checkpoint_score, features, final = False)
    
    elif stage == 4:
        scale, rbfsvr_checkpoint_score = test_scaler(rbfsvr_reg, X[features], Y) 
        _save_meta_model(meta_dimension, stage, dimension, name, rbfsvr_reg, scale, rbfsvr_checkpoint_score, features, final = False)

    elif stage == 5:
        rbfsvr_checkpoint_score, features = feat_selection_2(X[features], Y, scale, rbfsvr_reg, rbfsvr_checkpoint_score, 10, -1, False)
        _save_meta_model(meta_dimension, stage, dimension, name, rbfsvr_reg, scale, rbfsvr_checkpoint_score, features, final = True)
Ejemplo n.º 2
0
def tune_polysvr():
    name = 'PolySVR'
    dimension = 'winner'

    stage, polysvr_reg, scale, features, polysvr_checkpoint_score = stage_meta_init(
        meta_dimension, name, dimension)

    if stage == 0:
        polysvr_reg = SVR(kernel='poly')
        polysvr_checkpoint_score = -np.inf
        #        features = init_feat_selection(X, Y, rbfsvc_clf)
        scale, polysvr_checkpoint_score = test_scaler(polysvr_reg, X, Y)
        _save_meta_model(meta_dimension,
                         stage,
                         dimension,
                         name,
                         polysvr_reg,
                         scale,
                         polysvr_checkpoint_score,
                         list(X),
                         final=False)

    elif stage == 1:
        polysvr_checkpoint_score, features = feat_selection_2(
            X[features], Y, scale, polysvr_reg, polysvr_checkpoint_score, 24,
            -1, False)
        _save_meta_model(meta_dimension,
                         stage,
                         dimension,
                         name,
                         polysvr_reg,
                         scale,
                         polysvr_checkpoint_score,
                         features,
                         final=False)

    elif stage == 2:
        scale, polysvr_checkpoint_score = test_scaler(polysvr_reg, X[features],
                                                      Y)
        _save_meta_model(meta_dimension,
                         stage,
                         dimension,
                         name,
                         polysvr_reg,
                         scale,
                         polysvr_checkpoint_score,
                         features,
                         final=False)

    elif stage == 3:
        polysvr_reg, polysvr_checkpoint_score = svc_hyper_parameter_tuning(
            X[features], Y, polysvr_reg, scale, polysvr_checkpoint_score)
        _save_meta_model(meta_dimension,
                         stage,
                         dimension,
                         name,
                         polysvr_reg,
                         scale,
                         polysvr_checkpoint_score,
                         features,
                         final=False)

    elif stage == 4:
        scale, polysvr_checkpoint_score = test_scaler(polysvr_reg, X[features],
                                                      Y)
        _save_meta_model(meta_dimension,
                         stage,
                         dimension,
                         name,
                         polysvr_reg,
                         scale,
                         polysvr_checkpoint_score,
                         features,
                         final=False)

    elif stage == 5:
        polysvr_checkpoint_score, features = feat_selection_2(
            X[features], Y, scale, polysvr_reg, polysvr_checkpoint_score, 10,
            -1, False)
        _save_meta_model(meta_dimension,
                         stage,
                         dimension,
                         name,
                         polysvr_reg,
                         scale,
                         polysvr_checkpoint_score,
                         features,
                         final=True)
Ejemplo n.º 3
0
def tune_polysvc():
    name = 'PolySVC'
    dimension = 'winner'

    stage, polysvc_clf, polysvc_checkpoint_score = stage_init(
        name, dimension, extension=EXTENSION)

    if stage == 0:
        polysvc_clf = SVC(random_state=1108,
                          class_weight='balanced',
                          kernel='poly',
                          probability=True)
        polysvc_clf, polysvc_checkpoint_score = pipe_init(X, Y, polysvc_clf)
        _save_model(stage,
                    'winner',
                    name,
                    polysvc_clf,
                    polysvc_checkpoint_score,
                    final=False,
                    extension=EXTENSION)

    elif stage == 1:
        polysvc_clf, polysvc_checkpoint_score = test_scaler(
            polysvc_clf, polysvc_checkpoint_score, X, Y)
        _save_model(stage,
                    'winner',
                    name,
                    polysvc_clf,
                    polysvc_checkpoint_score,
                    final=False,
                    extension=EXTENSION)

    elif stage == 2:
        polysvc_clf, polysvc_checkpoint_score = feat_selection_2(
            X, Y, polysvc_clf, polysvc_checkpoint_score)
        _save_model(stage,
                    'winner',
                    name,
                    polysvc_clf,
                    polysvc_checkpoint_score,
                    final=False,
                    extension=EXTENSION)

    elif stage == 3:
        polysvc_clf, polysvc_checkpoint_score = test_scaler(
            polysvc_clf, polysvc_checkpoint_score, X, Y)
        _save_model(stage,
                    'winner',
                    name,
                    polysvc_clf,
                    polysvc_checkpoint_score,
                    final=False,
                    extension=EXTENSION)

    elif stage == 4:
        polysvc_clf, polysvc_checkpoint_score = pca_tune(
            X, Y, polysvc_clf, polysvc_checkpoint_score)
        _save_model(stage,
                    'winner',
                    name,
                    polysvc_clf,
                    polysvc_checkpoint_score,
                    final=False,
                    extension=EXTENSION)

    elif stage == 5:
        polysvc_clf, polysvc_checkpoint_score = feat_selection_2(
            X, Y, polysvc_clf, polysvc_checkpoint_score)
        _save_model(stage,
                    'winner',
                    name,
                    polysvc_clf,
                    polysvc_checkpoint_score,
                    final=False,
                    extension=EXTENSION)

    elif stage == 6:
        polysvc_clf, polysvc_checkpoint_score = test_scaler(
            polysvc_clf, polysvc_checkpoint_score, X, Y)
        _save_model(stage,
                    'winner',
                    name,
                    polysvc_clf,
                    polysvc_checkpoint_score,
                    final=False,
                    extension=EXTENSION)

    elif stage == 7:
        polysvc_clf, polysvc_checkpoint_score = svc_hyper_parameter_tuning(
            X, Y, polysvc_clf, polysvc_checkpoint_score)
        _save_model(stage,
                    'winner',
                    name,
                    polysvc_clf,
                    polysvc_checkpoint_score,
                    final=False,
                    extension=EXTENSION)

    elif stage == 8:
        polysvc_clf, polysvc_checkpoint_score = pca_tune(
            X, Y, polysvc_clf, polysvc_checkpoint_score, iter_=10)
        _save_model(stage,
                    'winner',
                    name,
                    polysvc_clf,
                    polysvc_checkpoint_score,
                    final=False,
                    extension=EXTENSION)

    elif stage == 9:
        polysvc_clf, polysvc_checkpoint_score = feat_selection_2(
            X, Y, polysvc_clf, polysvc_checkpoint_score)
        _save_model(stage,
                    'winner',
                    name,
                    polysvc_clf,
                    polysvc_checkpoint_score,
                    final=False,
                    extension=EXTENSION)

    elif stage == 10:
        polysvc_clf, polysvc_checkpoint_score = test_scaler(
            polysvc_clf, polysvc_checkpoint_score, X, Y)
        _save_model(stage,
                    'winner',
                    name,
                    polysvc_clf,
                    polysvc_checkpoint_score,
                    final=True,
                    extension=EXTENSION)