开源、低代码机器学习库 PyCaret 2.0 现已发布

# create a conda environmentconda create --name yourenvname python=3.6# activate environmentconda activate yourenvname# install pycaretpip install pycaret==2.0# create notebook kernel linked with the conda environment python -m ipykernel install --user --name yourenvname --display-name "display-name"

!pip install pycaret==2.0

# Import modulefrom pycaret.classification import *
# Initialize setup (when using Notebook environment)clf1 = setup(data, target = 'target-variable')
# Initialize setup (outside of Notebook environment)clf1 = setup(data, target = 'target-variable', html = False)
# Initialize setup (When using remote execution such as Kaggle / GitHub actions / CI-CD pipelines)clf1 = setup(data, target = 'target-variable', html = False, silent = True)

# import classification modulefrom pycaret.classification import *
# init setupclf1 = setup(data, target = 'name-of-target')
# return best modelbest = compare_models()
# return best model based on Recallbest = compare_models(sort = 'Recall') #default is 'Accuracy'
# compare specific modelsbest_specific = compare_models(whitelist = ['dt','rf','xgboost'])
# blacklist certain modelsbest_specific = compare_models(blacklist = ['catboost','svm'])
# return top 3 models based on Accuracytop3 = compare_models(n_select = 3)

# import classification modulefrom pycaret.classification import *
# init setupclf1 = setup(data, target = 'name-of-target')
# train logistic regression modellr = create_model('lr') #lr is the id of the model
# check the model library to see all modelsmodels()
# train rf model using 5 fold CVrf = create_model('rf', fold = 5)
# train svm model without CVsvm = create_model('svm', cross_validation = False)
# train xgboost model with max_depth = 10xgboost = create_model('xgboost', max_depth = 10)
# train xgboost model on gpuxgboost_gpu = create_model('xgboost', tree_method = 'gpu_hist', gpu_id = 0) #0 is gpu-id
# train multiple lightgbm models with n learning_ratelgbms = [create_model('lightgbm', learning_rate = i) for i in np.arange(0.1,1,0.1)]
# train custom modelfrom gplearn.genetic import SymbolicClassifiersymclf = SymbolicClassifier(generation = 50)sc = create_model(symclf)

# import classification modulefrom pycaret.classification import *
# init setupclf1 = setup(data, target = 'name-of-target')
# train a decision tree modeldt = create_model('dt')
# tune hyperparameters of decision treetuned_dt = tune_model(dt)
# tune hyperparameters with increased n_itertuned_dt = tune_model(dt, n_iter = 50)
# tune hyperparameters to optimize AUCtuned_dt = tune_model(dt, optimize = 'AUC') #default is 'Accuracy'
# tune hyperparameters with custom_gridparams = {"max_depth": np.random.randint(1, (len(data.columns)*.85),20),          "max_features": np.random.randint(1, len(data.columns),20),          "min_samples_leaf": [2,3,4,5,6],          "criterion": ["gini", "entropy"]          }
tuned_dt_custom = tune_model(dt, custom_grid = params)
# tune multiple models dynamicallytop3 = compare_models(n_select = 3)tuned_top3 = [tune_model(i) for i in top3]

# import classification modulefrom pycaret.classification import *
# init setupclf1 = setup(data, target = 'name-of-target')
# train a decision tree modeldt = create_model('dt')
# train a bagging classifier on dtbagged_dt = ensemble_model(dt, method = 'Bagging')
# train a adaboost classifier on dt with 100 estimatorsboosted_dt = ensemble_model(dt, method = 'Boosting', n_estimators = 100)
# train a votingclassifier on all models in libraryblender = blend_models()
# train a voting classifier on specific modelsdt = create_model('dt')rf = create_model('rf')adaboost = create_model('ada')blender_specific = blend_models(estimator_list = [dt,rf,adaboost], method = 'soft')
# train a voting classifier dynamicallyblender_top5 = blend_models(compare_models(n_select = 5))
# train a stacking classifierstacker = stack_models(estimator_list = [dt,rf], meta_model = adaboost)
# stack multiple models dynamicallytop7 = compare_models(n_select = 7)stacker = stack_models(estimator_list = top7[1:], meta_model = top7[0])

# train a catboost modelcatboost = create_model('catboost')
# predict on holdout set (when no data is passed)pred_holdout = predict_model(catboost)
# predict on new datasetnew_data = pd.read_csv('new-data.csv')pred_new = predict_model(catboost, data = new_data)

# import classification modulefrom pycaret.classification import *
# init setupclf1 = setup(data, target = 'name-of-target')
# train adaboost modeladaboost = create_model('ada')
# AUC plotplot_model(adaboost, plot = 'auc')
# Decision Boundaryplot_model(adaboost, plot = 'boundary')
# Precision Recall Curveplot_model(adaboost, plot = 'pr')
# Validation Curveplot_model(adaboost, plot = 'vc')

# select and finalize the best model in the active runbest_model = automl() #returns the best model based on CV score
# select and finalize the best model based on 'F1' on hold_out setbest_model_holdout = automl(optimize = 'F1', use_holdout = True)
# save modelsave_model(model, 'c:/path-to-directory/model-name')
# load modelmodel = load_model('c:/path-to-directory/model-name')
# retrieve score grid as pandas dfdt = create_model('dt')dt_results = pull() #this will store dt score grid as pandas df
# get global environment variableX_train = get_config('X_train') #returns X_train dataset after preprocessingseed = get_config('seed') returns seed from global environment
# set global environment variableset_seed(seed, 999) #seed set to 999 in global environment of active run
# get experiment logs as csv filelogs = get_logs() #for active run by default
# get system logs for auditsystem_logs = get_system_logs() #read logs.log file from active directory

# import classification modulefrom pycaret.classification import *
# init setupclf1 = setup(data, target = 'name-of-target', log_experiment = True, experiment_name = 'exp-name-here')
# compare modelsbest = compare_models()
# start mlflow server on localhost:5000 (when using notebook)!mlflow ui

# import librariesimport pandas as pdimport sys
# define command line parametersdata = sys.argv[1]target = sys.argv[2]
# load data (replace this part with your own script)from pycaret.datasets import get_datainput_data = get_data(data)
# init setupfrom pycaret.classification import *clf1 = setup(data = input_data, target = target, log_experiment = True)
# compare baseline models and select top5top5 = compare_models(n_select = 5)
# tune top5 modelstuned_top5 = [tune_model(i) for i in top5]
# ensemble top5 tuned modelsbagged_tuned_top5 = [ensemble_model(i, method = 'Bagging') for i in tuned_top5]
# blend top5 modelsblender = blend_models(estimator_list = top5)
# stack top5 modelsstacker = stack_models(estimator_list = top5[1:], meta_model = top5[0])
# select best model based on recallbest_model = automl(optimize = 'Recall')
# save modelsave_model(best_model, 'c:/path-to-directory/final-model')