Esempio 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)
Esempio n. 2
0
def tune_linsvr():
    name = 'LinSVR'
    dimension = 'length'
  
    stage, linsvr_reg, scale, features, linsvr_checkpoint_score = stage_meta_init(meta_dimension, name, dimension)
        
    if stage == 0:
        linsvr_reg = SVR(kernel = 'linear')
        linsvr_checkpoint_score = -np.inf
        features = init_feat_selection(X, Y, linsvr_reg)
        scale, linsvr_checkpoint_score = test_scaler(linsvr_reg, X[features], Y) 
        _save_meta_model(meta_dimension, stage, dimension, name, linsvr_reg, scale, linsvr_checkpoint_score, features, final = False)
        
    elif stage == 1: 
        linsvr_checkpoint_score, features = feat_selection(X[features], Y, scale, linsvr_reg, linsvr_checkpoint_score, 10, -1, False)
        _save_meta_model(meta_dimension, stage, dimension, name, linsvr_reg, scale, linsvr_checkpoint_score, features, final = False)
    
    elif stage == 2:
        scale, linsvr_checkpoint_score = test_scaler(linsvr_reg, X[features], Y) 
        _save_meta_model(meta_dimension, stage, dimension, name, linsvr_reg, scale, linsvr_checkpoint_score, features, final = False)
            
    elif stage == 3:
        linsvr_reg, linsvr_checkpoint_score = C_parameter_tuning(X[features], Y, linsvr_reg, scale, linsvr_checkpoint_score)
        _save_meta_model(meta_dimension, stage, dimension, name, linsvr_reg, scale, linsvr_checkpoint_score, features, final = False)
    
    elif stage == 4:
        scale, linsvr_checkpoint_score = test_scaler(linsvr_reg, X[features], Y) 
        _save_meta_model(meta_dimension, stage, dimension, name, linsvr_reg, scale, linsvr_checkpoint_score, features, final = False)
                
    elif stage == 5:
        linsvr_checkpoint_score, features = feat_selection(X[features], Y, scale, linsvr_reg, linsvr_checkpoint_score, 10, -1, False)
        _save_meta_model(meta_dimension, stage, dimension, name, linsvr_reg, scale, linsvr_checkpoint_score, features, final = True)
Esempio n. 3
0
def tune_rf():
    name = 'RFreg'
    dimension = 'length'
    
    stage, rf_reg, scale, features, rf_checkpoint_score = stage_meta_init(meta_dimension, name, dimension)
    
    if stage == 0:
        rf_reg = RandomForestRegressor(random_state = 1108, n_estimators = 100)
        rf_checkpoint_score = -np.inf    
        scale, rf_checkpoint_score = test_scaler(rf_reg, X, Y) 
        _save_meta_model(meta_dimension, stage, dimension, name, rf_reg, scale, rf_checkpoint_score, list(X), final = False)

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

    elif stage == 2:
        scale, rf_checkpoint_score = test_scaler(rf_reg, X[features], Y) 
        _save_meta_model(meta_dimension, stage, dimension, name, rf_reg, scale, rf_checkpoint_score, features, final = False)
          
    elif stage == 3: 
        rf_reg, rf_checkpoint_score = forest_params(X[features], Y, rf_reg, scale, rf_checkpoint_score, iter_ = 1000)
        _save_meta_model(meta_dimension, stage, dimension, name, rf_reg, scale, rf_checkpoint_score, features, final = False)

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

    elif stage == 5: 
        rf_checkpoint_score, features = feat_selection(X[features], Y, scale, rf_reg, rf_checkpoint_score, 24, -1, False)
        _save_meta_model(meta_dimension, stage, dimension, name, rf_reg, scale, rf_checkpoint_score, features, final = False)
     
    elif stage == 6:
        rf_reg, rf_checkpoint_score = rf_trees(X, Y, scale, rf_reg, rf_checkpoint_score)
        _save_meta_model(meta_dimension, stage, dimension, name, rf_reg, scale, rf_checkpoint_score, features, final = True)
Esempio n. 4
0
def tune_lasso():
    name = 'LassoRegression'
    dimension = 'length'
    
    stage, lasso_reg, scale, features, lasso_checkpoint_score = stage_meta_init(meta_dimension, name, dimension)
    
    if stage == 0:
        lasso_reg = Lasso(max_iter = 1000, random_state = 1108)
        lasso_checkpoint_score = -np.inf
        scale, lasso_checkpoint_score = test_scaler(lasso_reg, X, Y) 
        _save_meta_model(meta_dimension, stage, dimension, name, lasso_reg, scale, lasso_checkpoint_score, list(X), final = False)
    
    elif stage == 1: 
        lasso_checkpoint_score, features = feat_selection(X[features], Y, scale, lasso_reg, lasso_checkpoint_score, 24, -1, False)
        _save_meta_model(meta_dimension, stage, dimension, name, lasso_reg, scale, lasso_checkpoint_score, features, final = False)
 
    elif stage == 2:
        scale, lasso_checkpoint_score = test_scaler(lasso_reg, X, Y) 
        _save_meta_model(meta_dimension, stage, dimension, name, lasso_reg, scale, lasso_checkpoint_score, features, final = False)

    elif stage == 3:
        lasso_reg, lasso_checkpoint_score = alpha_parameter_tuning(X[features], Y, lasso_reg, scale, lasso_checkpoint_score)
        _save_meta_model(meta_dimension, stage, dimension, name, lasso_reg, scale, lasso_checkpoint_score, features, final = False)

    elif stage == 4: 
        lasso_checkpoint_score, features = feat_selection(X[features], Y, scale, lasso_reg, lasso_checkpoint_score, 24, -1, False)
        _save_meta_model(meta_dimension, stage, dimension, name, lasso_reg, scale, lasso_checkpoint_score, features, final = False)
    
    elif stage == 5:
        scale, lasso_checkpoint_score = test_scaler(lasso_reg, X, Y) 
        _save_meta_model(meta_dimension, stage, dimension, name, lasso_reg, scale, lasso_checkpoint_score, features, final = True)
Esempio n. 5
0
def tune_polysvr():
    name = 'PolySVR'
    dimension = 'length'
    
    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 = poly_hyper_parameter_tuning(X[features], Y, polysvr_reg, scale, polysvr_checkpoint_score, iter_ = 50)
        _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)
Esempio n. 6
0
def tune_dartr():
    name = 'DartrGBM'
    dimension = 'length'
    
    stage, dart_reg, scale, features, dartr_checkpoint_score = stage_meta_init(meta_dimension, name, dimension)
    
    if stage == 0:
        dart_reg = lgb.LGBMRegressor(random_state = 1108, n_estimators = 100, subsample = .8, verbose=-1)
        dartr_checkpoint_score = -np.inf    
        scale, dartr_checkpoint_score = test_scaler(dart_reg, X, Y) 
        _save_meta_model(meta_dimension, stage, dimension, name, dart_reg, scale, dartr_checkpoint_score, list(X), final = False)

    elif stage == 1: 
        dartr_checkpoint_score, features = feat_selection(X[features], Y, scale, dart_reg, dartr_checkpoint_score, 24, -1, False)
        _save_meta_model(meta_dimension, stage, dimension, name, dart_reg, scale, dartr_checkpoint_score, features, final = False)

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

    elif stage == 3:
        dart_reg, dartr_checkpoint_score = lgb_find_lr(dart_reg, X[features], Y, scale, dartr_checkpoint_score) 
        _save_meta_model(meta_dimension, stage, dimension, name, dart_reg, scale, dartr_checkpoint_score, features, final = False)
                                
    elif stage == 4:
        scale, dartr_checkpoint_score = test_scaler(dart_reg, X[features], Y) 
        _save_meta_model(meta_dimension, stage, dimension, name, dart_reg, scale, dartr_checkpoint_score, features, final = False)

    elif stage == 5: 
        dartr_checkpoint_score, features = feat_selection(X[features], Y, scale, dart_reg, dartr_checkpoint_score, 24, -1, False)
        _save_meta_model(meta_dimension, stage, dimension, name, dart_reg, scale, dartr_checkpoint_score, features, final = False)

    elif stage == 6: 
        dart_reg, dartr_checkpoint_score = lgb_tree_params(X[features], Y, dart_reg, scale, dartr_checkpoint_score, iter_ = 1000)
        _save_meta_model(meta_dimension, stage, dimension, name, dart_reg, scale, dartr_checkpoint_score, features, final = False)

    elif stage == 7:
        scale, dartr_checkpoint_score = test_scaler(dart_reg, X[features], Y) 
        _save_meta_model(meta_dimension, stage, dimension, name, dart_reg, scale, dartr_checkpoint_score, features, final = False)

    elif stage == 8: 
        dartr_checkpoint_score, features = feat_selection(X[features], Y, scale, dart_reg, dartr_checkpoint_score, 24, -1, False)
        _save_meta_model(meta_dimension, stage, dimension, name, dart_reg, scale, dartr_checkpoint_score, features, final = False)

    elif stage == 9: 
        dart_reg, dartr_checkpoint_score = lgb_drop_lr(dart_reg, X[features], Y, scale, dartr_checkpoint_score)
        _save_meta_model(meta_dimension, stage, dimension, name, dart_reg, scale, dartr_checkpoint_score, features, final = True)