Customer_Churn_Prediction/logs.log

2023-08-22 08:17:14,969:WARNING:
'cuml' is a soft dependency and not included in the pycaret installation. Please run: `pip install cuml` to install.
2023-08-22 08:17:14,969:WARNING:
'cuml' is a soft dependency and not included in the pycaret installation. Please run: `pip install cuml` to install.
2023-08-22 08:17:14,969:WARNING:
'cuml' is a soft dependency and not included in the pycaret installation. Please run: `pip install cuml` to install.
2023-08-22 08:17:14,969:WARNING:
'cuml' is a soft dependency and not included in the pycaret installation. Please run: `pip install cuml` to install.
2023-08-22 08:17:18,390:INFO:PyCaret ClassificationExperiment
2023-08-22 08:17:18,391:INFO:Logging name: churn1
2023-08-22 08:17:18,391:INFO:ML Usecase: MLUsecase.CLASSIFICATION
2023-08-22 08:17:18,391:INFO:version 3.0.4
2023-08-22 08:17:18,391:INFO:Initializing setup()
2023-08-22 08:17:18,391:INFO:self.USI: 8b34
2023-08-22 08:17:18,391:INFO:self._variable_keys: {'fold_groups_param', 'gpu_n_jobs_param', 'exp_name_log', 'fold_shuffle_param', 'X_test', 'data', 'y', 'X', 'log_plots_param', 'logging_param', 'fold_generator', 'y_test', 'n_jobs_param', 'y_train', '_ml_usecase', 'html_param', 'exp_id', 'seed', 'idx', 'X_train', 'target_param', 'is_multiclass', 'pipeline', 'USI', '_available_plots', 'memory', 'gpu_param', 'fix_imbalance'}
2023-08-22 08:17:18,391:INFO:Checking environment
2023-08-22 08:17:18,391:INFO:python_version: 3.9.0
2023-08-22 08:17:18,391:INFO:python_build: ('default', 'Nov 15 2020 08:30:55')
2023-08-22 08:17:18,391:INFO:machine: AMD64
2023-08-22 08:17:18,391:INFO:platform: Windows-10-10.0.22621-SP0
2023-08-22 08:17:18,396:INFO:Memory: svmem(total=25505648640, available=13015683072, percent=49.0, used=12489965568, free=13015683072)
2023-08-22 08:17:18,396:INFO:Physical Core: 4
2023-08-22 08:17:18,397:INFO:Logical Core: 8
2023-08-22 08:17:18,397:INFO:Checking libraries
2023-08-22 08:17:18,397:INFO:System:
2023-08-22 08:17:18,397:INFO:    python: 3.9.0 (default, Nov 15 2020, 08:30:55) [MSC v.1916 64 bit (AMD64)]
2023-08-22 08:17:18,397:INFO:executable: C:\Users\prvzs\anaconda3\envs\churn_prediction\python.exe
2023-08-22 08:17:18,397:INFO:   machine: Windows-10-10.0.22621-SP0
2023-08-22 08:17:18,397:INFO:PyCaret required dependencies:
2023-08-22 08:17:18,662:INFO:                 pip: 23.2.1
2023-08-22 08:17:18,662:INFO:          setuptools: 68.0.0
2023-08-22 08:17:18,662:INFO:             pycaret: 3.0.4
2023-08-22 08:17:18,662:INFO:             IPython: 8.14.0
2023-08-22 08:17:18,662:INFO:          ipywidgets: 8.1.0
2023-08-22 08:17:18,662:INFO:                tqdm: 4.66.1
2023-08-22 08:17:18,662:INFO:               numpy: 1.23.5
2023-08-22 08:17:18,662:INFO:              pandas: 1.3.0
2023-08-22 08:17:18,662:INFO:              jinja2: 3.1.2
2023-08-22 08:17:18,662:INFO:               scipy: 1.11.2
2023-08-22 08:17:18,662:INFO:              joblib: 1.2.0
2023-08-22 08:17:18,662:INFO:             sklearn: 1.2.2
2023-08-22 08:17:18,662:INFO:                pyod: 1.1.0
2023-08-22 08:17:18,662:INFO:            imblearn: 0.11.0
2023-08-22 08:17:18,678:INFO:   category_encoders: 2.6.2
2023-08-22 08:17:18,678:INFO:            lightgbm: 4.0.0
2023-08-22 08:17:18,678:INFO:               numba: 0.57.1
2023-08-22 08:17:18,678:INFO:            requests: 2.31.0
2023-08-22 08:17:18,678:INFO:          matplotlib: 3.7.2
2023-08-22 08:17:18,678:INFO:          scikitplot: 0.3.7
2023-08-22 08:17:18,678:INFO:         yellowbrick: 1.5
2023-08-22 08:17:18,678:INFO:              plotly: 5.16.1
2023-08-22 08:17:18,678:INFO:    plotly-resampler: Not installed
2023-08-22 08:17:18,678:INFO:             kaleido: 0.2.1
2023-08-22 08:17:18,678:INFO:           schemdraw: 0.15
2023-08-22 08:17:18,678:INFO:         statsmodels: 0.14.0
2023-08-22 08:17:18,678:INFO:              sktime: 0.22.0
2023-08-22 08:17:18,678:INFO:               tbats: 1.1.3
2023-08-22 08:17:18,678:INFO:            pmdarima: 2.0.3
2023-08-22 08:17:18,678:INFO:              psutil: 5.9.5
2023-08-22 08:17:18,678:INFO:          markupsafe: 2.1.3
2023-08-22 08:17:18,678:INFO:             pickle5: Not installed
2023-08-22 08:17:18,678:INFO:         cloudpickle: 2.2.1
2023-08-22 08:17:18,678:INFO:         deprecation: 2.1.0
2023-08-22 08:17:18,678:INFO:              xxhash: 3.3.0
2023-08-22 08:17:18,678:INFO:           wurlitzer: Not installed
2023-08-22 08:17:18,678:INFO:PyCaret optional dependencies:
2023-08-22 08:17:18,694:INFO:                shap: Not installed
2023-08-22 08:17:18,694:INFO:           interpret: Not installed
2023-08-22 08:17:18,694:INFO:                umap: Not installed
2023-08-22 08:17:18,694:INFO:    pandas_profiling: Not installed
2023-08-22 08:17:18,694:INFO:  explainerdashboard: Not installed
2023-08-22 08:17:18,694:INFO:             autoviz: Not installed
2023-08-22 08:17:18,694:INFO:           fairlearn: Not installed
2023-08-22 08:17:18,694:INFO:          deepchecks: Not installed
2023-08-22 08:17:18,694:INFO:             xgboost: Not installed
2023-08-22 08:17:18,694:INFO:            catboost: Not installed
2023-08-22 08:17:18,694:INFO:              kmodes: Not installed
2023-08-22 08:17:18,694:INFO:             mlxtend: Not installed
2023-08-22 08:17:18,694:INFO:       statsforecast: Not installed
2023-08-22 08:17:18,694:INFO:        tune_sklearn: Not installed
2023-08-22 08:17:18,694:INFO:                 ray: Not installed
2023-08-22 08:17:18,694:INFO:            hyperopt: Not installed
2023-08-22 08:17:18,694:INFO:              optuna: Not installed
2023-08-22 08:17:18,694:INFO:               skopt: Not installed
2023-08-22 08:17:18,694:INFO:              mlflow: 2.6.0
2023-08-22 08:17:18,694:INFO:              gradio: Not installed
2023-08-22 08:17:18,694:INFO:             fastapi: Not installed
2023-08-22 08:17:18,694:INFO:             uvicorn: Not installed
2023-08-22 08:17:18,694:INFO:              m2cgen: Not installed
2023-08-22 08:17:18,694:INFO:           evidently: Not installed
2023-08-22 08:17:18,694:INFO:               fugue: Not installed
2023-08-22 08:17:18,694:INFO:           streamlit: Not installed
2023-08-22 08:17:18,694:INFO:             prophet: Not installed
2023-08-22 08:17:18,694:INFO:None
2023-08-22 08:17:18,694:INFO:Set up data.
2023-08-22 08:17:18,725:INFO:Set up train/test split.
2023-08-22 08:17:18,835:INFO:Set up index.
2023-08-22 08:17:18,835:INFO:Set up folding strategy.
2023-08-22 08:17:18,835:INFO:Assigning column types.
2023-08-22 08:17:18,851:INFO:Engine successfully changes for model 'lr' to 'sklearn'.
2023-08-22 08:17:18,897:INFO:Engine for model 'knn' has not been set explicitly, hence returning None.
2023-08-22 08:17:18,897:INFO:Engine for model 'rbfsvm' has not been set explicitly, hence returning None.
2023-08-22 08:17:18,937:WARNING:
'xgboost' is a soft dependency and not included in the pycaret installation. Please run: `pip install xgboost` to install.
Alternately, you can install this by running `pip install pycaret[models]`
2023-08-22 08:17:18,938:WARNING:
'catboost' is a soft dependency and not included in the pycaret installation. Please run: `pip install catboost` to install.
Alternately, you can install this by running `pip install pycaret[models]`
2023-08-22 08:17:19,050:INFO:Engine for model 'knn' has not been set explicitly, hence returning None.
2023-08-22 08:17:19,065:INFO:Engine for model 'rbfsvm' has not been set explicitly, hence returning None.
2023-08-22 08:17:19,121:WARNING:
'xgboost' is a soft dependency and not included in the pycaret installation. Please run: `pip install xgboost` to install.
Alternately, you can install this by running `pip install pycaret[models]`
2023-08-22 08:17:19,121:WARNING:
'catboost' is a soft dependency and not included in the pycaret installation. Please run: `pip install catboost` to install.
Alternately, you can install this by running `pip install pycaret[models]`
2023-08-22 08:17:19,121:INFO:Engine successfully changes for model 'knn' to 'sklearn'.
2023-08-22 08:17:19,200:INFO:Engine for model 'rbfsvm' has not been set explicitly, hence returning None.
2023-08-22 08:17:19,216:WARNING:
'xgboost' is a soft dependency and not included in the pycaret installation. Please run: `pip install xgboost` to install.
Alternately, you can install this by running `pip install pycaret[models]`
2023-08-22 08:17:19,216:WARNING:
'catboost' is a soft dependency and not included in the pycaret installation. Please run: `pip install catboost` to install.
Alternately, you can install this by running `pip install pycaret[models]`
2023-08-22 08:17:19,288:INFO:Engine for model 'rbfsvm' has not been set explicitly, hence returning None.
2023-08-22 08:17:19,334:WARNING:
'xgboost' is a soft dependency and not included in the pycaret installation. Please run: `pip install xgboost` to install.
Alternately, you can install this by running `pip install pycaret[models]`
2023-08-22 08:17:19,334:WARNING:
'catboost' is a soft dependency and not included in the pycaret installation. Please run: `pip install catboost` to install.
Alternately, you can install this by running `pip install pycaret[models]`
2023-08-22 08:17:19,334:INFO:Engine successfully changes for model 'rbfsvm' to 'sklearn'.
2023-08-22 08:17:19,428:WARNING:
'xgboost' is a soft dependency and not included in the pycaret installation. Please run: `pip install xgboost` to install.
Alternately, you can install this by running `pip install pycaret[models]`
2023-08-22 08:17:19,428:WARNING:
'catboost' is a soft dependency and not included in the pycaret installation. Please run: `pip install catboost` to install.
Alternately, you can install this by running `pip install pycaret[models]`
2023-08-22 08:17:19,536:WARNING:
'xgboost' is a soft dependency and not included in the pycaret installation. Please run: `pip install xgboost` to install.
Alternately, you can install this by running `pip install pycaret[models]`
2023-08-22 08:17:19,536:WARNING:
'catboost' is a soft dependency and not included in the pycaret installation. Please run: `pip install catboost` to install.
Alternately, you can install this by running `pip install pycaret[models]`
2023-08-22 08:17:19,536:INFO:Preparing preprocessing pipeline...
2023-08-22 08:17:19,536:INFO:Set up label encoding.
2023-08-22 08:17:19,536:INFO:Set up simple imputation.
2023-08-22 08:17:19,536:INFO:Set up encoding of ordinal features.
2023-08-22 08:17:19,551:INFO:Set up encoding of categorical features.
2023-08-22 08:17:20,136:INFO:Finished creating preprocessing pipeline.
2023-08-22 08:17:20,302:INFO:Pipeline: Pipeline(memory=FastMemory(location=C:\Users\prvzs\AppData\Local\Temp\joblib),
         steps=[('label_encoding',
                 TransformerWrapperWithInverse(exclude=None, include=None,
                                               transformer=LabelEncoder())),
                ('numerical_imputer',
                 TransformerWrapper(exclude=None,
                                    include=['SeniorCitizen', 'tenure',
                                             'MonthlyCharges'],
                                    transformer=SimpleImputer(add_indicator=False,
                                                              copy=True,
                                                              f...
                                                              handle_unknown='value',
                                                              return_df=True,
                                                              use_cat_names=True,
                                                              verbose=0))),
                ('rest_encoding',
                 TransformerWrapper(exclude=None, include=['TotalCharges'],
                                    transformer=TargetEncoder(cols=['TotalCharges'],
                                                              drop_invariant=False,
                                                              handle_missing='return_nan',
                                                              handle_unknown='value',
                                                              hierarchy=None,
                                                              min_samples_leaf=20,
                                                              return_df=True,
                                                              smoothing=10,
                                                              verbose=0)))],
         verbose=False)
2023-08-22 08:17:20,303:INFO:Creating final display dataframe.
2023-08-22 08:17:21,272:INFO:Setup _display_container:                     Description            Value
0                    Session id              123
1                        Target            Churn
2                   Target type           Binary
3                Target mapping    No: 0, Yes: 1
4           Original data shape       (7043, 21)
5        Transformed data shape       (7043, 41)
6   Transformed train set shape       (4930, 41)
7    Transformed test set shape       (2113, 41)
8               Ignore features                1
9              Ordinal features                5
10             Numeric features                3
11         Categorical features               16
12                   Preprocess             True
13              Imputation type           simple
14           Numeric imputation             mean
15       Categorical imputation             mode
16     Maximum one-hot encoding               25
17              Encoding method             None
18               Fold Generator  StratifiedKFold
19                  Fold Number               10
20                     CPU Jobs               -1
21                      Use GPU            False
22               Log Experiment     MlflowLogger
23              Experiment Name           churn1
24                          USI             8b34
2023-08-22 08:17:21,404:WARNING:
'xgboost' is a soft dependency and not included in the pycaret installation. Please run: `pip install xgboost` to install.
Alternately, you can install this by running `pip install pycaret[models]`
2023-08-22 08:17:21,404:WARNING:
'catboost' is a soft dependency and not included in the pycaret installation. Please run: `pip install catboost` to install.
Alternately, you can install this by running `pip install pycaret[models]`
2023-08-22 08:17:21,479:WARNING:
'xgboost' is a soft dependency and not included in the pycaret installation. Please run: `pip install xgboost` to install.
Alternately, you can install this by running `pip install pycaret[models]`
2023-08-22 08:17:21,480:WARNING:
'catboost' is a soft dependency and not included in the pycaret installation. Please run: `pip install catboost` to install.
Alternately, you can install this by running `pip install pycaret[models]`
2023-08-22 08:17:21,480:INFO:Logging experiment in loggers
2023-08-22 08:17:22,122:INFO:SubProcess save_model() called ==================================
2023-08-22 08:17:22,404:INFO:Initializing save_model()
2023-08-22 08:17:22,404:INFO:save_model(model=Pipeline(memory=FastMemory(location=C:\Users\prvzs\AppData\Local\Temp\joblib),
         steps=[('label_encoding',
                 TransformerWrapperWithInverse(exclude=None, include=None,
                                               transformer=LabelEncoder())),
                ('numerical_imputer',
                 TransformerWrapper(exclude=None,
                                    include=['SeniorCitizen', 'tenure',
                                             'MonthlyCharges'],
                                    transformer=SimpleImputer(add_indicator=False,
                                                              copy=True,
                                                              f...
                                                              handle_unknown='value',
                                                              return_df=True,
                                                              use_cat_names=True,
                                                              verbose=0))),
                ('rest_encoding',
                 TransformerWrapper(exclude=None, include=['TotalCharges'],
                                    transformer=TargetEncoder(cols=['TotalCharges'],
                                                              drop_invariant=False,
                                                              handle_missing='return_nan',
                                                              handle_unknown='value',
                                                              hierarchy=None,
                                                              min_samples_leaf=20,
                                                              return_df=True,
                                                              smoothing=10,
                                                              verbose=0)))],
         verbose=False), model_name=C:\Users\prvzs\AppData\Local\Temp\tmp9kz26lsy\Transformation Pipeline, prep_pipe_=Pipeline(memory=FastMemory(location=C:\Users\prvzs\AppData\Local\Temp\joblib),
         steps=[('label_encoding',
                 TransformerWrapperWithInverse(exclude=None, include=None,
                                               transformer=LabelEncoder())),
                ('numerical_imputer',
                 TransformerWrapper(exclude=None,
                                    include=['SeniorCitizen', 'tenure',
                                             'MonthlyCharges'],
                                    transformer=SimpleImputer(add_indicator=False,
                                                              copy=True,
                                                              f...
                                                              handle_unknown='value',
                                                              return_df=True,
                                                              use_cat_names=True,
                                                              verbose=0))),
                ('rest_encoding',
                 TransformerWrapper(exclude=None, include=['TotalCharges'],
                                    transformer=TargetEncoder(cols=['TotalCharges'],
                                                              drop_invariant=False,
                                                              handle_missing='return_nan',
                                                              handle_unknown='value',
                                                              hierarchy=None,
                                                              min_samples_leaf=20,
                                                              return_df=True,
                                                              smoothing=10,
                                                              verbose=0)))],
         verbose=False), verbose=False, use_case=MLUsecase.CLASSIFICATION, kwargs={})
2023-08-22 08:17:22,404:INFO:Adding model into prep_pipe
2023-08-22 08:17:22,404:WARNING:Only Model saved as it was a pipeline.
2023-08-22 08:17:22,451:INFO:C:\Users\prvzs\AppData\Local\Temp\tmp9kz26lsy\Transformation Pipeline.pkl saved in current working directory
2023-08-22 08:17:22,608:INFO:Pipeline(memory=FastMemory(location=C:\Users\prvzs\AppData\Local\Temp\joblib),
         steps=[('label_encoding',
                 TransformerWrapperWithInverse(exclude=None, include=None,
                                               transformer=LabelEncoder())),
                ('numerical_imputer',
                 TransformerWrapper(exclude=None,
                                    include=['SeniorCitizen', 'tenure',
                                             'MonthlyCharges'],
                                    transformer=SimpleImputer(add_indicator=False,
                                                              copy=True,
                                                              f...
                                                              handle_unknown='value',
                                                              return_df=True,
                                                              use_cat_names=True,
                                                              verbose=0))),
                ('rest_encoding',
                 TransformerWrapper(exclude=None, include=['TotalCharges'],
                                    transformer=TargetEncoder(cols=['TotalCharges'],
                                                              drop_invariant=False,
                                                              handle_missing='return_nan',
                                                              handle_unknown='value',
                                                              hierarchy=None,
                                                              min_samples_leaf=20,
                                                              return_df=True,
                                                              smoothing=10,
                                                              verbose=0)))],
         verbose=False)
2023-08-22 08:17:22,608:INFO:save_model() successfully completed......................................
2023-08-22 08:17:22,703:INFO:SubProcess save_model() end ==================================
2023-08-22 08:17:22,705:INFO:setup() successfully completed in 3.1s...............
2023-08-22 08:18:12,462:INFO:Initializing compare_models()
2023-08-22 08:18:12,462:INFO:compare_models(self=<pycaret.classification.oop.ClassificationExperiment object at 0x00000172522BAA90>, include=None, fold=None, round=4, cross_validation=True, sort=Accuracy, n_select=1, budget_time=None, turbo=True, errors=ignore, fit_kwargs=None, groups=None, experiment_custom_tags=None, probability_threshold=None, verbose=True, parallel=None, caller_params={'self': <pycaret.classification.oop.ClassificationExperiment object at 0x00000172522BAA90>, 'include': None, 'exclude': None, 'fold': None, 'round': 4, 'cross_validation': True, 'sort': 'Accuracy', 'n_select': 1, 'budget_time': None, 'turbo': True, 'errors': 'ignore', 'fit_kwargs': None, 'groups': None, 'experiment_custom_tags': None, 'probability_threshold': None, 'engine': None, 'verbose': True, 'parallel': None, '__class__': <class 'pycaret.classification.oop.ClassificationExperiment'>}, exclude=None)
2023-08-22 08:18:12,462:INFO:Checking exceptions
2023-08-22 08:18:12,473:INFO:Preparing display monitor
2023-08-22 08:18:12,536:INFO:Initializing Logistic Regression
2023-08-22 08:18:12,537:INFO:Total runtime is 1.6709168752034504e-05 minutes
2023-08-22 08:18:12,546:INFO:SubProcess create_model() called ==================================
2023-08-22 08:18:12,547:INFO:Initializing create_model()
2023-08-22 08:18:12,547:INFO:create_model(self=<pycaret.classification.oop.ClassificationExperiment object at 0x00000172522BAA90>, estimator=lr, fold=StratifiedKFold(n_splits=10, random_state=None, shuffle=False), round=4, cross_validation=True, predict=True, fit_kwargs={}, groups=None, refit=False, probability_threshold=None, experiment_custom_tags=None, verbose=False, system=False, add_to_model_list=True, metrics=None, display=<pycaret.internal.display.display.CommonDisplay object at 0x0000017231089160>, model_only=True, return_train_score=False, kwargs={})
2023-08-22 08:18:12,547:INFO:Checking exceptions
2023-08-22 08:18:12,548:INFO:Importing libraries
2023-08-22 08:18:12,548:INFO:Copying training dataset
2023-08-22 08:18:12,555:INFO:Defining folds
2023-08-22 08:18:12,555:INFO:Declaring metric variables
2023-08-22 08:18:12,561:INFO:Importing untrained model
2023-08-22 08:18:12,567:INFO:Logistic Regression Imported successfully
2023-08-22 08:18:12,592:INFO:Starting cross validation
2023-08-22 08:18:12,600:INFO:Cross validating with StratifiedKFold(n_splits=10, random_state=None, shuffle=False), n_jobs=-1
2023-08-22 08:18:21,216:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\pipeline.py:231: UserWarning: Persisting input arguments took 0.60s to run.
If this happens often in your code, it can cause performance problems 
(results will be correct in all cases). 
The reason for this is probably some large input arguments for a wrapped
 function (e.g. large strings).
THIS IS A JOBLIB ISSUE. If you can, kindly provide the joblib's team with an
 example so that they can fix the problem.
  fitted_transformer = self._memory_fit(

2023-08-22 08:18:21,649:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\sklearn\linear_model\_logistic.py:458: ConvergenceWarning: lbfgs failed to converge (status=1):
STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.

Increase the number of iterations (max_iter) or scale the data as shown in:
    https://scikit-learn.org/stable/modules/preprocessing.html
Please also refer to the documentation for alternative solver options:
    https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression
  n_iter_i = _check_optimize_result(

2023-08-22 08:18:21,784:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\sklearn\linear_model\_logistic.py:458: ConvergenceWarning: lbfgs failed to converge (status=1):
STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.

Increase the number of iterations (max_iter) or scale the data as shown in:
    https://scikit-learn.org/stable/modules/preprocessing.html
Please also refer to the documentation for alternative solver options:
    https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression
  n_iter_i = _check_optimize_result(

2023-08-22 08:18:22,145:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\sklearn\linear_model\_logistic.py:458: ConvergenceWarning: lbfgs failed to converge (status=1):
STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.

Increase the number of iterations (max_iter) or scale the data as shown in:
    https://scikit-learn.org/stable/modules/preprocessing.html
Please also refer to the documentation for alternative solver options:
    https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression
  n_iter_i = _check_optimize_result(

2023-08-22 08:18:22,175:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\sklearn\linear_model\_logistic.py:458: ConvergenceWarning: lbfgs failed to converge (status=1):
STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.

Increase the number of iterations (max_iter) or scale the data as shown in:
    https://scikit-learn.org/stable/modules/preprocessing.html
Please also refer to the documentation for alternative solver options:
    https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression
  n_iter_i = _check_optimize_result(

2023-08-22 08:18:22,459:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\sklearn\linear_model\_logistic.py:458: ConvergenceWarning: lbfgs failed to converge (status=1):
STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.

Increase the number of iterations (max_iter) or scale the data as shown in:
    https://scikit-learn.org/stable/modules/preprocessing.html
Please also refer to the documentation for alternative solver options:
    https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression
  n_iter_i = _check_optimize_result(

2023-08-22 08:18:23,826:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\pipeline.py:310: UserWarning: Persisting input arguments took 0.81s to run.
If this happens often in your code, it can cause performance problems 
(results will be correct in all cases). 
The reason for this is probably some large input arguments for a wrapped
 function (e.g. large strings).
THIS IS A JOBLIB ISSUE. If you can, kindly provide the joblib's team with an
 example so that they can fix the problem.
  X, _ = self._memory_full_transform(self, X, None, with_final=False)

2023-08-22 08:18:23,842:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\pipeline.py:310: UserWarning: Persisting input arguments took 0.91s to run.
If this happens often in your code, it can cause performance problems 
(results will be correct in all cases). 
The reason for this is probably some large input arguments for a wrapped
 function (e.g. large strings).
THIS IS A JOBLIB ISSUE. If you can, kindly provide the joblib's team with an
 example so that they can fix the problem.
  X, _ = self._memory_full_transform(self, X, None, with_final=False)

2023-08-22 08:18:23,873:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\pipeline.py:310: UserWarning: Persisting input arguments took 0.63s to run.
If this happens often in your code, it can cause performance problems 
(results will be correct in all cases). 
The reason for this is probably some large input arguments for a wrapped
 function (e.g. large strings).
THIS IS A JOBLIB ISSUE. If you can, kindly provide the joblib's team with an
 example so that they can fix the problem.
  X, _ = self._memory_full_transform(self, X, None, with_final=False)

2023-08-22 08:18:23,920:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\pipeline.py:310: UserWarning: Persisting input arguments took 0.59s to run.
If this happens often in your code, it can cause performance problems 
(results will be correct in all cases). 
The reason for this is probably some large input arguments for a wrapped
 function (e.g. large strings).
THIS IS A JOBLIB ISSUE. If you can, kindly provide the joblib's team with an
 example so that they can fix the problem.
  X, _ = self._memory_full_transform(self, X, None, with_final=False)

2023-08-22 08:18:23,967:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\pipeline.py:310: UserWarning: Persisting input arguments took 0.57s to run.
If this happens often in your code, it can cause performance problems 
(results will be correct in all cases). 
The reason for this is probably some large input arguments for a wrapped
 function (e.g. large strings).
THIS IS A JOBLIB ISSUE. If you can, kindly provide the joblib's team with an
 example so that they can fix the problem.
  X, _ = self._memory_full_transform(self, X, None, with_final=False)

2023-08-22 08:18:24,042:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\pipeline.py:310: UserWarning: Persisting input arguments took 0.50s to run.
If this happens often in your code, it can cause performance problems 
(results will be correct in all cases). 
The reason for this is probably some large input arguments for a wrapped
 function (e.g. large strings).
THIS IS A JOBLIB ISSUE. If you can, kindly provide the joblib's team with an
 example so that they can fix the problem.
  X, _ = self._memory_full_transform(self, X, None, with_final=False)

2023-08-22 08:18:24,074:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\pipeline.py:310: UserWarning: Persisting input arguments took 0.51s to run.
If this happens often in your code, it can cause performance problems 
(results will be correct in all cases). 
The reason for this is probably some large input arguments for a wrapped
 function (e.g. large strings).
THIS IS A JOBLIB ISSUE. If you can, kindly provide the joblib's team with an
 example so that they can fix the problem.
  X, _ = self._memory_full_transform(self, X, None, with_final=False)

2023-08-22 08:18:24,555:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\pipeline.py:310: UserWarning: Persisting input arguments took 0.69s to run.
If this happens often in your code, it can cause performance problems 
(results will be correct in all cases). 
The reason for this is probably some large input arguments for a wrapped
 function (e.g. large strings).
THIS IS A JOBLIB ISSUE. If you can, kindly provide the joblib's team with an
 example so that they can fix the problem.
  X, _ = self._memory_full_transform(self, X, None, with_final=False)

2023-08-22 08:18:25,925:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\sklearn\linear_model\_logistic.py:458: ConvergenceWarning: lbfgs failed to converge (status=1):
STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.

Increase the number of iterations (max_iter) or scale the data as shown in:
    https://scikit-learn.org/stable/modules/preprocessing.html
Please also refer to the documentation for alternative solver options:
    https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression
  n_iter_i = _check_optimize_result(

2023-08-22 08:18:25,964:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\sklearn\linear_model\_logistic.py:458: ConvergenceWarning: lbfgs failed to converge (status=1):
STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.

Increase the number of iterations (max_iter) or scale the data as shown in:
    https://scikit-learn.org/stable/modules/preprocessing.html
Please also refer to the documentation for alternative solver options:
    https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression
  n_iter_i = _check_optimize_result(

2023-08-22 08:18:26,923:INFO:Calculating mean and std
2023-08-22 08:18:26,924:INFO:Creating metrics dataframe
2023-08-22 08:18:27,012:INFO:Uploading results into container
2023-08-22 08:18:27,013:INFO:Uploading model into container now
2023-08-22 08:18:27,013:INFO:_master_model_container: 1
2023-08-22 08:18:27,013:INFO:_display_container: 2
2023-08-22 08:18:27,014:INFO:LogisticRegression(C=1.0, class_weight=None, dual=False, fit_intercept=True,
                   intercept_scaling=1, l1_ratio=None, max_iter=1000,
                   multi_class='auto', n_jobs=None, penalty='l2',
                   random_state=123, solver='lbfgs', tol=0.0001, verbose=0,
                   warm_start=False)
2023-08-22 08:18:27,015:INFO:create_model() successfully completed......................................
2023-08-22 08:18:27,124:INFO:SubProcess create_model() end ==================================
2023-08-22 08:18:27,124:INFO:Creating metrics dataframe
2023-08-22 08:18:27,159:INFO:Initializing K Neighbors Classifier
2023-08-22 08:18:27,159:INFO:Total runtime is 0.24371531407038372 minutes
2023-08-22 08:18:27,168:INFO:SubProcess create_model() called ==================================
2023-08-22 08:18:27,169:INFO:Initializing create_model()
2023-08-22 08:18:27,169:INFO:create_model(self=<pycaret.classification.oop.ClassificationExperiment object at 0x00000172522BAA90>, estimator=knn, fold=StratifiedKFold(n_splits=10, random_state=None, shuffle=False), round=4, cross_validation=True, predict=True, fit_kwargs={}, groups=None, refit=False, probability_threshold=None, experiment_custom_tags=None, verbose=False, system=False, add_to_model_list=True, metrics=None, display=<pycaret.internal.display.display.CommonDisplay object at 0x0000017231089160>, model_only=True, return_train_score=False, kwargs={})
2023-08-22 08:18:27,169:INFO:Checking exceptions
2023-08-22 08:18:27,169:INFO:Importing libraries
2023-08-22 08:18:27,170:INFO:Copying training dataset
2023-08-22 08:18:27,191:INFO:Defining folds
2023-08-22 08:18:27,192:INFO:Declaring metric variables
2023-08-22 08:18:27,195:INFO:Importing untrained model
2023-08-22 08:18:27,211:INFO:K Neighbors Classifier Imported successfully
2023-08-22 08:18:27,227:INFO:Starting cross validation
2023-08-22 08:18:27,227:INFO:Cross validating with StratifiedKFold(n_splits=10, random_state=None, shuffle=False), n_jobs=-1
2023-08-22 08:18:29,574:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\pipeline.py:310: UserWarning: Persisting input arguments took 0.53s to run.
If this happens often in your code, it can cause performance problems 
(results will be correct in all cases). 
The reason for this is probably some large input arguments for a wrapped
 function (e.g. large strings).
THIS IS A JOBLIB ISSUE. If you can, kindly provide the joblib's team with an
 example so that they can fix the problem.
  X, _ = self._memory_full_transform(self, X, None, with_final=False)

2023-08-22 08:18:29,617:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\pipeline.py:310: UserWarning: Persisting input arguments took 0.51s to run.
If this happens often in your code, it can cause performance problems 
(results will be correct in all cases). 
The reason for this is probably some large input arguments for a wrapped
 function (e.g. large strings).
THIS IS A JOBLIB ISSUE. If you can, kindly provide the joblib's team with an
 example so that they can fix the problem.
  X, _ = self._memory_full_transform(self, X, None, with_final=False)

2023-08-22 08:18:29,684:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\pipeline.py:310: UserWarning: Persisting input arguments took 0.51s to run.
If this happens often in your code, it can cause performance problems 
(results will be correct in all cases). 
The reason for this is probably some large input arguments for a wrapped
 function (e.g. large strings).
THIS IS A JOBLIB ISSUE. If you can, kindly provide the joblib's team with an
 example so that they can fix the problem.
  X, _ = self._memory_full_transform(self, X, None, with_final=False)

2023-08-22 08:18:29,700:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\pipeline.py:310: UserWarning: Persisting input arguments took 0.50s to run.
If this happens often in your code, it can cause performance problems 
(results will be correct in all cases). 
The reason for this is probably some large input arguments for a wrapped
 function (e.g. large strings).
THIS IS A JOBLIB ISSUE. If you can, kindly provide the joblib's team with an
 example so that they can fix the problem.
  X, _ = self._memory_full_transform(self, X, None, with_final=False)

2023-08-22 08:18:29,748:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\pipeline.py:310: UserWarning: Persisting input arguments took 0.53s to run.
If this happens often in your code, it can cause performance problems 
(results will be correct in all cases). 
The reason for this is probably some large input arguments for a wrapped
 function (e.g. large strings).
THIS IS A JOBLIB ISSUE. If you can, kindly provide the joblib's team with an
 example so that they can fix the problem.
  X, _ = self._memory_full_transform(self, X, None, with_final=False)

2023-08-22 08:18:32,318:INFO:Calculating mean and std
2023-08-22 08:18:32,321:INFO:Creating metrics dataframe
2023-08-22 08:18:32,430:INFO:Uploading results into container
2023-08-22 08:18:32,432:INFO:Uploading model into container now
2023-08-22 08:18:32,433:INFO:_master_model_container: 2
2023-08-22 08:18:32,434:INFO:_display_container: 2
2023-08-22 08:18:32,435:INFO:KNeighborsClassifier(algorithm='auto', leaf_size=30, metric='minkowski',
                     metric_params=None, n_jobs=-1, n_neighbors=5, p=2,
                     weights='uniform')
2023-08-22 08:18:32,435:INFO:create_model() successfully completed......................................
2023-08-22 08:18:32,535:INFO:SubProcess create_model() end ==================================
2023-08-22 08:18:32,535:INFO:Creating metrics dataframe
2023-08-22 08:18:32,566:INFO:Initializing Naive Bayes
2023-08-22 08:18:32,566:INFO:Total runtime is 0.33383540709813436 minutes
2023-08-22 08:18:32,585:INFO:SubProcess create_model() called ==================================
2023-08-22 08:18:32,585:INFO:Initializing create_model()
2023-08-22 08:18:32,585:INFO:create_model(self=<pycaret.classification.oop.ClassificationExperiment object at 0x00000172522BAA90>, estimator=nb, fold=StratifiedKFold(n_splits=10, random_state=None, shuffle=False), round=4, cross_validation=True, predict=True, fit_kwargs={}, groups=None, refit=False, probability_threshold=None, experiment_custom_tags=None, verbose=False, system=False, add_to_model_list=True, metrics=None, display=<pycaret.internal.display.display.CommonDisplay object at 0x0000017231089160>, model_only=True, return_train_score=False, kwargs={})
2023-08-22 08:18:32,585:INFO:Checking exceptions
2023-08-22 08:18:32,585:INFO:Importing libraries
2023-08-22 08:18:32,585:INFO:Copying training dataset
2023-08-22 08:18:32,604:INFO:Defining folds
2023-08-22 08:18:32,605:INFO:Declaring metric variables
2023-08-22 08:18:32,617:INFO:Importing untrained model
2023-08-22 08:18:32,624:INFO:Naive Bayes Imported successfully
2023-08-22 08:18:32,647:INFO:Starting cross validation
2023-08-22 08:18:32,652:INFO:Cross validating with StratifiedKFold(n_splits=10, random_state=None, shuffle=False), n_jobs=-1
2023-08-22 08:18:34,518:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\pipeline.py:310: UserWarning: Persisting input arguments took 0.52s to run.
If this happens often in your code, it can cause performance problems 
(results will be correct in all cases). 
The reason for this is probably some large input arguments for a wrapped
 function (e.g. large strings).
THIS IS A JOBLIB ISSUE. If you can, kindly provide the joblib's team with an
 example so that they can fix the problem.
  X, _ = self._memory_full_transform(self, X, None, with_final=False)

2023-08-22 08:18:35,054:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\pipeline.py:310: UserWarning: Persisting input arguments took 0.56s to run.
If this happens often in your code, it can cause performance problems 
(results will be correct in all cases). 
The reason for this is probably some large input arguments for a wrapped
 function (e.g. large strings).
THIS IS A JOBLIB ISSUE. If you can, kindly provide the joblib's team with an
 example so that they can fix the problem.
  X, _ = self._memory_full_transform(self, X, None, with_final=False)

2023-08-22 08:18:35,085:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\pipeline.py:310: UserWarning: Persisting input arguments took 0.51s to run.
If this happens often in your code, it can cause performance problems 
(results will be correct in all cases). 
The reason for this is probably some large input arguments for a wrapped
 function (e.g. large strings).
THIS IS A JOBLIB ISSUE. If you can, kindly provide the joblib's team with an
 example so that they can fix the problem.
  X, _ = self._memory_full_transform(self, X, None, with_final=False)

2023-08-22 08:18:36,437:INFO:Calculating mean and std
2023-08-22 08:18:36,437:INFO:Creating metrics dataframe
2023-08-22 08:18:36,547:INFO:Uploading results into container
2023-08-22 08:18:36,547:INFO:Uploading model into container now
2023-08-22 08:18:36,547:INFO:_master_model_container: 3
2023-08-22 08:18:36,547:INFO:_display_container: 2
2023-08-22 08:18:36,547:INFO:GaussianNB(priors=None, var_smoothing=1e-09)
2023-08-22 08:18:36,547:INFO:create_model() successfully completed......................................
2023-08-22 08:18:36,665:INFO:SubProcess create_model() end ==================================
2023-08-22 08:18:36,665:INFO:Creating metrics dataframe
2023-08-22 08:18:36,684:INFO:Initializing Decision Tree Classifier
2023-08-22 08:18:36,684:INFO:Total runtime is 0.4024739702542623 minutes
2023-08-22 08:18:36,691:INFO:SubProcess create_model() called ==================================
2023-08-22 08:18:36,692:INFO:Initializing create_model()
2023-08-22 08:18:36,692:INFO:create_model(self=<pycaret.classification.oop.ClassificationExperiment object at 0x00000172522BAA90>, estimator=dt, fold=StratifiedKFold(n_splits=10, random_state=None, shuffle=False), round=4, cross_validation=True, predict=True, fit_kwargs={}, groups=None, refit=False, probability_threshold=None, experiment_custom_tags=None, verbose=False, system=False, add_to_model_list=True, metrics=None, display=<pycaret.internal.display.display.CommonDisplay object at 0x0000017231089160>, model_only=True, return_train_score=False, kwargs={})
2023-08-22 08:18:36,693:INFO:Checking exceptions
2023-08-22 08:18:36,693:INFO:Importing libraries
2023-08-22 08:18:36,693:INFO:Copying training dataset
2023-08-22 08:18:36,708:INFO:Defining folds
2023-08-22 08:18:36,709:INFO:Declaring metric variables
2023-08-22 08:18:36,719:INFO:Importing untrained model
2023-08-22 08:18:36,729:INFO:Decision Tree Classifier Imported successfully
2023-08-22 08:18:36,743:INFO:Starting cross validation
2023-08-22 08:18:36,749:INFO:Cross validating with StratifiedKFold(n_splits=10, random_state=None, shuffle=False), n_jobs=-1
2023-08-22 08:18:38,820:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\pipeline.py:310: UserWarning: Persisting input arguments took 0.72s to run.
If this happens often in your code, it can cause performance problems 
(results will be correct in all cases). 
The reason for this is probably some large input arguments for a wrapped
 function (e.g. large strings).
THIS IS A JOBLIB ISSUE. If you can, kindly provide the joblib's team with an
 example so that they can fix the problem.
  X, _ = self._memory_full_transform(self, X, None, with_final=False)

2023-08-22 08:18:38,833:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\pipeline.py:310: UserWarning: Persisting input arguments took 0.67s to run.
If this happens often in your code, it can cause performance problems 
(results will be correct in all cases). 
The reason for this is probably some large input arguments for a wrapped
 function (e.g. large strings).
THIS IS A JOBLIB ISSUE. If you can, kindly provide the joblib's team with an
 example so that they can fix the problem.
  X, _ = self._memory_full_transform(self, X, None, with_final=False)

2023-08-22 08:18:38,864:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\pipeline.py:310: UserWarning: Persisting input arguments took 0.65s to run.
If this happens often in your code, it can cause performance problems 
(results will be correct in all cases). 
The reason for this is probably some large input arguments for a wrapped
 function (e.g. large strings).
THIS IS A JOBLIB ISSUE. If you can, kindly provide the joblib's team with an
 example so that they can fix the problem.
  X, _ = self._memory_full_transform(self, X, None, with_final=False)

2023-08-22 08:18:38,879:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\pipeline.py:310: UserWarning: Persisting input arguments took 0.60s to run.
If this happens often in your code, it can cause performance problems 
(results will be correct in all cases). 
The reason for this is probably some large input arguments for a wrapped
 function (e.g. large strings).
THIS IS A JOBLIB ISSUE. If you can, kindly provide the joblib's team with an
 example so that they can fix the problem.
  X, _ = self._memory_full_transform(self, X, None, with_final=False)

2023-08-22 08:18:38,883:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\pipeline.py:310: UserWarning: Persisting input arguments took 0.66s to run.
If this happens often in your code, it can cause performance problems 
(results will be correct in all cases). 
The reason for this is probably some large input arguments for a wrapped
 function (e.g. large strings).
THIS IS A JOBLIB ISSUE. If you can, kindly provide the joblib's team with an
 example so that they can fix the problem.
  X, _ = self._memory_full_transform(self, X, None, with_final=False)

2023-08-22 08:18:38,887:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\pipeline.py:310: UserWarning: Persisting input arguments took 0.63s to run.
If this happens often in your code, it can cause performance problems 
(results will be correct in all cases). 
The reason for this is probably some large input arguments for a wrapped
 function (e.g. large strings).
THIS IS A JOBLIB ISSUE. If you can, kindly provide the joblib's team with an
 example so that they can fix the problem.
  X, _ = self._memory_full_transform(self, X, None, with_final=False)

2023-08-22 08:18:39,223:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\pipeline.py:310: UserWarning: Persisting input arguments took 0.68s to run.
If this happens often in your code, it can cause performance problems 
(results will be correct in all cases). 
The reason for this is probably some large input arguments for a wrapped
 function (e.g. large strings).
THIS IS A JOBLIB ISSUE. If you can, kindly provide the joblib's team with an
 example so that they can fix the problem.
  X, _ = self._memory_full_transform(self, X, None, with_final=False)

2023-08-22 08:18:39,400:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\pipeline.py:310: UserWarning: Persisting input arguments took 0.73s to run.
If this happens often in your code, it can cause performance problems 
(results will be correct in all cases). 
The reason for this is probably some large input arguments for a wrapped
 function (e.g. large strings).
THIS IS A JOBLIB ISSUE. If you can, kindly provide the joblib's team with an
 example so that they can fix the problem.
  X, _ = self._memory_full_transform(self, X, None, with_final=False)

2023-08-22 08:18:40,619:INFO:Calculating mean and std
2023-08-22 08:18:40,624:INFO:Creating metrics dataframe
2023-08-22 08:18:40,773:INFO:Uploading results into container
2023-08-22 08:18:40,775:INFO:Uploading model into container now
2023-08-22 08:18:40,777:INFO:_master_model_container: 4
2023-08-22 08:18:40,778:INFO:_display_container: 2
2023-08-22 08:18:40,779:INFO:DecisionTreeClassifier(ccp_alpha=0.0, class_weight=None, criterion='gini',
                       max_depth=None, max_features=None, max_leaf_nodes=None,
                       min_impurity_decrease=0.0, min_samples_leaf=1,
                       min_samples_split=2, min_weight_fraction_leaf=0.0,
                       random_state=123, splitter='best')
2023-08-22 08:18:40,780:INFO:create_model() successfully completed......................................
2023-08-22 08:18:40,933:INFO:SubProcess create_model() end ==================================
2023-08-22 08:18:40,934:INFO:Creating metrics dataframe
2023-08-22 08:18:40,981:INFO:Initializing SVM - Linear Kernel
2023-08-22 08:18:40,982:INFO:Total runtime is 0.47409364382425945 minutes
2023-08-22 08:18:40,991:INFO:SubProcess create_model() called ==================================
2023-08-22 08:18:40,992:INFO:Initializing create_model()
2023-08-22 08:18:40,993:INFO:create_model(self=<pycaret.classification.oop.ClassificationExperiment object at 0x00000172522BAA90>, estimator=svm, fold=StratifiedKFold(n_splits=10, random_state=None, shuffle=False), round=4, cross_validation=True, predict=True, fit_kwargs={}, groups=None, refit=False, probability_threshold=None, experiment_custom_tags=None, verbose=False, system=False, add_to_model_list=True, metrics=None, display=<pycaret.internal.display.display.CommonDisplay object at 0x0000017231089160>, model_only=True, return_train_score=False, kwargs={})
2023-08-22 08:18:40,993:INFO:Checking exceptions
2023-08-22 08:18:40,993:INFO:Importing libraries
2023-08-22 08:18:40,993:INFO:Copying training dataset
2023-08-22 08:18:41,012:INFO:Defining folds
2023-08-22 08:18:41,014:INFO:Declaring metric variables
2023-08-22 08:18:41,027:INFO:Importing untrained model
2023-08-22 08:18:41,044:INFO:SVM - Linear Kernel Imported successfully
2023-08-22 08:18:41,068:INFO:Starting cross validation
2023-08-22 08:18:41,080:INFO:Cross validating with StratifiedKFold(n_splits=10, random_state=None, shuffle=False), n_jobs=-1
2023-08-22 08:18:43,507:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\pipeline.py:310: UserWarning: Persisting input arguments took 0.60s to run.
If this happens often in your code, it can cause performance problems 
(results will be correct in all cases). 
The reason for this is probably some large input arguments for a wrapped
 function (e.g. large strings).
THIS IS A JOBLIB ISSUE. If you can, kindly provide the joblib's team with an
 example so that they can fix the problem.
  X, _ = self._memory_full_transform(self, X, None, with_final=False)

2023-08-22 08:18:43,520:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\pipeline.py:310: UserWarning: Persisting input arguments took 0.59s to run.
If this happens often in your code, it can cause performance problems 
(results will be correct in all cases). 
The reason for this is probably some large input arguments for a wrapped
 function (e.g. large strings).
THIS IS A JOBLIB ISSUE. If you can, kindly provide the joblib's team with an
 example so that they can fix the problem.
  X, _ = self._memory_full_transform(self, X, None, with_final=False)

2023-08-22 08:18:43,523:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\metrics.py:138: FitFailedWarning: Metric 'make_scorer(roc_auc_score, needs_proba=True, error_score=0.0, average=weighted, multi_class=ovr)' failed and error score 0.0 has been returned instead. If this is a custom metric, this usually means that the error is in the metric code. Full exception below:
Traceback (most recent call last):
  File "C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\sklearn\metrics\_scorer.py", line 76, in _cached_call
    return cache[method]
KeyError: 'predict_proba'

During handling of the above exception, another exception occurred:

Traceback (most recent call last):
  File "C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\metrics.py", line 130, in _score
    return super()._score(
  File "C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\sklearn\metrics\_scorer.py", line 316, in _score
    y_pred = method_caller(clf, "predict_proba", X)
  File "C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\sklearn\metrics\_scorer.py", line 78, in _cached_call
    result = getattr(estimator, method)(*args, **kwargs)
  File "C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\pipeline.py", line 121, in __getattr__
    return getattr(self._final_estimator, name)
  File "C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\sklearn\utils\_available_if.py", line 32, in __get__
    if not self.check(obj):
  File "C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\sklearn\linear_model\_stochastic_gradient.py", line 1235, in _check_proba
    raise AttributeError(
AttributeError: probability estimates are not available for loss='hinge'

  warnings.warn(

2023-08-22 08:18:43,533:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\metrics.py:138: FitFailedWarning: Metric 'make_scorer(roc_auc_score, needs_proba=True, error_score=0.0, average=weighted, multi_class=ovr)' failed and error score 0.0 has been returned instead. If this is a custom metric, this usually means that the error is in the metric code. Full exception below:
Traceback (most recent call last):
  File "C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\sklearn\metrics\_scorer.py", line 76, in _cached_call
    return cache[method]
KeyError: 'predict_proba'

During handling of the above exception, another exception occurred:

Traceback (most recent call last):
  File "C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\metrics.py", line 130, in _score
    return super()._score(
  File "C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\sklearn\metrics\_scorer.py", line 316, in _score
    y_pred = method_caller(clf, "predict_proba", X)
  File "C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\sklearn\metrics\_scorer.py", line 78, in _cached_call
    result = getattr(estimator, method)(*args, **kwargs)
  File "C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\pipeline.py", line 121, in __getattr__
    return getattr(self._final_estimator, name)
  File "C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\sklearn\utils\_available_if.py", line 32, in __get__
    if not self.check(obj):
  File "C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\sklearn\linear_model\_stochastic_gradient.py", line 1235, in _check_proba
    raise AttributeError(
AttributeError: probability estimates are not available for loss='hinge'

  warnings.warn(

2023-08-22 08:18:43,617:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\pipeline.py:310: UserWarning: Persisting input arguments took 0.59s to run.
If this happens often in your code, it can cause performance problems 
(results will be correct in all cases). 
The reason for this is probably some large input arguments for a wrapped
 function (e.g. large strings).
THIS IS A JOBLIB ISSUE. If you can, kindly provide the joblib's team with an
 example so that they can fix the problem.
  X, _ = self._memory_full_transform(self, X, None, with_final=False)

2023-08-22 08:18:43,632:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\metrics.py:138: FitFailedWarning: Metric 'make_scorer(roc_auc_score, needs_proba=True, error_score=0.0, average=weighted, multi_class=ovr)' failed and error score 0.0 has been returned instead. If this is a custom metric, this usually means that the error is in the metric code. Full exception below:
Traceback (most recent call last):
  File "C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\sklearn\metrics\_scorer.py", line 76, in _cached_call
    return cache[method]
KeyError: 'predict_proba'

During handling of the above exception, another exception occurred:

Traceback (most recent call last):
  File "C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\metrics.py", line 130, in _score
    return super()._score(
  File "C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\sklearn\metrics\_scorer.py", line 316, in _score
    y_pred = method_caller(clf, "predict_proba", X)
  File "C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\sklearn\metrics\_scorer.py", line 78, in _cached_call
    result = getattr(estimator, method)(*args, **kwargs)
  File "C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\pipeline.py", line 121, in __getattr__
    return getattr(self._final_estimator, name)
  File "C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\sklearn\utils\_available_if.py", line 32, in __get__
    if not self.check(obj):
  File "C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\sklearn\linear_model\_stochastic_gradient.py", line 1235, in _check_proba
    raise AttributeError(
AttributeError: probability estimates are not available for loss='hinge'

  warnings.warn(

2023-08-22 08:18:43,732:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\pipeline.py:310: UserWarning: Persisting input arguments took 0.54s to run.
If this happens often in your code, it can cause performance problems 
(results will be correct in all cases). 
The reason for this is probably some large input arguments for a wrapped
 function (e.g. large strings).
THIS IS A JOBLIB ISSUE. If you can, kindly provide the joblib's team with an
 example so that they can fix the problem.
  X, _ = self._memory_full_transform(self, X, None, with_final=False)

2023-08-22 08:18:43,747:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\metrics.py:138: FitFailedWarning: Metric 'make_scorer(roc_auc_score, needs_proba=True, error_score=0.0, average=weighted, multi_class=ovr)' failed and error score 0.0 has been returned instead. If this is a custom metric, this usually means that the error is in the metric code. Full exception below:
Traceback (most recent call last):
  File "C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\sklearn\metrics\_scorer.py", line 76, in _cached_call
    return cache[method]
KeyError: 'predict_proba'

During handling of the above exception, another exception occurred:

Traceback (most recent call last):
  File "C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\metrics.py", line 130, in _score
    return super()._score(
  File "C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\sklearn\metrics\_scorer.py", line 316, in _score
    y_pred = method_caller(clf, "predict_proba", X)
  File "C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\sklearn\metrics\_scorer.py", line 78, in _cached_call
    result = getattr(estimator, method)(*args, **kwargs)
  File "C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\pipeline.py", line 121, in __getattr__
    return getattr(self._final_estimator, name)
  File "C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\sklearn\utils\_available_if.py", line 32, in __get__
    if not self.check(obj):
  File "C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\sklearn\linear_model\_stochastic_gradient.py", line 1235, in _check_proba
    raise AttributeError(
AttributeError: probability estimates are not available for loss='hinge'

  warnings.warn(

2023-08-22 08:18:43,752:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\pipeline.py:310: UserWarning: Persisting input arguments took 0.56s to run.
If this happens often in your code, it can cause performance problems 
(results will be correct in all cases). 
The reason for this is probably some large input arguments for a wrapped
 function (e.g. large strings).
THIS IS A JOBLIB ISSUE. If you can, kindly provide the joblib's team with an
 example so that they can fix the problem.
  X, _ = self._memory_full_transform(self, X, None, with_final=False)

2023-08-22 08:18:43,767:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\metrics.py:138: FitFailedWarning: Metric 'make_scorer(roc_auc_score, needs_proba=True, error_score=0.0, average=weighted, multi_class=ovr)' failed and error score 0.0 has been returned instead. If this is a custom metric, this usually means that the error is in the metric code. Full exception below:
Traceback (most recent call last):
  File "C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\sklearn\metrics\_scorer.py", line 76, in _cached_call
    return cache[method]
KeyError: 'predict_proba'

During handling of the above exception, another exception occurred:

Traceback (most recent call last):
  File "C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\metrics.py", line 130, in _score
    return super()._score(
  File "C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\sklearn\metrics\_scorer.py", line 316, in _score
    y_pred = method_caller(clf, "predict_proba", X)
  File "C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\sklearn\metrics\_scorer.py", line 78, in _cached_call
    result = getattr(estimator, method)(*args, **kwargs)
  File "C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\pipeline.py", line 121, in __getattr__
    return getattr(self._final_estimator, name)
  File "C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\sklearn\utils\_available_if.py", line 32, in __get__
    if not self.check(obj):
  File "C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\sklearn\linear_model\_stochastic_gradient.py", line 1235, in _check_proba
    raise AttributeError(
AttributeError: probability estimates are not available for loss='hinge'

  warnings.warn(

2023-08-22 08:18:43,919:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\pipeline.py:310: UserWarning: Persisting input arguments took 0.60s to run.
If this happens often in your code, it can cause performance problems 
(results will be correct in all cases). 
The reason for this is probably some large input arguments for a wrapped
 function (e.g. large strings).
THIS IS A JOBLIB ISSUE. If you can, kindly provide the joblib's team with an
 example so that they can fix the problem.
  X, _ = self._memory_full_transform(self, X, None, with_final=False)

2023-08-22 08:18:43,936:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\metrics.py:138: FitFailedWarning: Metric 'make_scorer(roc_auc_score, needs_proba=True, error_score=0.0, average=weighted, multi_class=ovr)' failed and error score 0.0 has been returned instead. If this is a custom metric, this usually means that the error is in the metric code. Full exception below:
Traceback (most recent call last):
  File "C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\sklearn\metrics\_scorer.py", line 76, in _cached_call
    return cache[method]
KeyError: 'predict_proba'

During handling of the above exception, another exception occurred:

Traceback (most recent call last):
  File "C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\metrics.py", line 130, in _score
    return super()._score(
  File "C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\sklearn\metrics\_scorer.py", line 316, in _score
    y_pred = method_caller(clf, "predict_proba", X)
  File "C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\sklearn\metrics\_scorer.py", line 78, in _cached_call
    result = getattr(estimator, method)(*args, **kwargs)
  File "C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\pipeline.py", line 121, in __getattr__
    return getattr(self._final_estimator, name)
  File "C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\sklearn\utils\_available_if.py", line 32, in __get__
    if not self.check(obj):
  File "C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\sklearn\linear_model\_stochastic_gradient.py", line 1235, in _check_proba
    raise AttributeError(
AttributeError: probability estimates are not available for loss='hinge'

  warnings.warn(

2023-08-22 08:18:43,942:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\pipeline.py:310: UserWarning: Persisting input arguments took 0.62s to run.
If this happens often in your code, it can cause performance problems 
(results will be correct in all cases). 
The reason for this is probably some large input arguments for a wrapped
 function (e.g. large strings).
THIS IS A JOBLIB ISSUE. If you can, kindly provide the joblib's team with an
 example so that they can fix the problem.
  X, _ = self._memory_full_transform(self, X, None, with_final=False)

2023-08-22 08:18:43,955:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\metrics.py:138: FitFailedWarning: Metric 'make_scorer(roc_auc_score, needs_proba=True, error_score=0.0, average=weighted, multi_class=ovr)' failed and error score 0.0 has been returned instead. If this is a custom metric, this usually means that the error is in the metric code. Full exception below:
Traceback (most recent call last):
  File "C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\sklearn\metrics\_scorer.py", line 76, in _cached_call
    return cache[method]
KeyError: 'predict_proba'

During handling of the above exception, another exception occurred:

Traceback (most recent call last):
  File "C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\metrics.py", line 130, in _score
    return super()._score(
  File "C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\sklearn\metrics\_scorer.py", line 316, in _score
    y_pred = method_caller(clf, "predict_proba", X)
  File "C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\sklearn\metrics\_scorer.py", line 78, in _cached_call
    result = getattr(estimator, method)(*args, **kwargs)
  File "C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\pipeline.py", line 121, in __getattr__
    return getattr(self._final_estimator, name)
  File "C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\sklearn\utils\_available_if.py", line 32, in __get__
    if not self.check(obj):
  File "C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\sklearn\linear_model\_stochastic_gradient.py", line 1235, in _check_proba
    raise AttributeError(
AttributeError: probability estimates are not available for loss='hinge'

  warnings.warn(

2023-08-22 08:18:43,961:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\sklearn\metrics\_classification.py:1344: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 due to no predicted samples. Use `zero_division` parameter to control this behavior.
  _warn_prf(average, modifier, msg_start, len(result))

2023-08-22 08:18:43,989:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\pipeline.py:310: UserWarning: Persisting input arguments took 0.66s to run.
If this happens often in your code, it can cause performance problems 
(results will be correct in all cases). 
The reason for this is probably some large input arguments for a wrapped
 function (e.g. large strings).
THIS IS A JOBLIB ISSUE. If you can, kindly provide the joblib's team with an
 example so that they can fix the problem.
  X, _ = self._memory_full_transform(self, X, None, with_final=False)

2023-08-22 08:18:44,002:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\metrics.py:138: FitFailedWarning: Metric 'make_scorer(roc_auc_score, needs_proba=True, error_score=0.0, average=weighted, multi_class=ovr)' failed and error score 0.0 has been returned instead. If this is a custom metric, this usually means that the error is in the metric code. Full exception below:
Traceback (most recent call last):
  File "C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\sklearn\metrics\_scorer.py", line 76, in _cached_call
    return cache[method]
KeyError: 'predict_proba'

During handling of the above exception, another exception occurred:

Traceback (most recent call last):
  File "C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\metrics.py", line 130, in _score
    return super()._score(
  File "C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\sklearn\metrics\_scorer.py", line 316, in _score
    y_pred = method_caller(clf, "predict_proba", X)
  File "C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\sklearn\metrics\_scorer.py", line 78, in _cached_call
    result = getattr(estimator, method)(*args, **kwargs)
  File "C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\pipeline.py", line 121, in __getattr__
    return getattr(self._final_estimator, name)
  File "C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\sklearn\utils\_available_if.py", line 32, in __get__
    if not self.check(obj):
  File "C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\sklearn\linear_model\_stochastic_gradient.py", line 1235, in _check_proba
    raise AttributeError(
AttributeError: probability estimates are not available for loss='hinge'

  warnings.warn(

2023-08-22 08:18:44,999:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\metrics.py:138: FitFailedWarning: Metric 'make_scorer(roc_auc_score, needs_proba=True, error_score=0.0, average=weighted, multi_class=ovr)' failed and error score 0.0 has been returned instead. If this is a custom metric, this usually means that the error is in the metric code. Full exception below:
Traceback (most recent call last):
  File "C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\sklearn\metrics\_scorer.py", line 76, in _cached_call
    return cache[method]
KeyError: 'predict_proba'

During handling of the above exception, another exception occurred:

Traceback (most recent call last):
  File "C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\metrics.py", line 130, in _score
    return super()._score(
  File "C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\sklearn\metrics\_scorer.py", line 316, in _score
    y_pred = method_caller(clf, "predict_proba", X)
  File "C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\sklearn\metrics\_scorer.py", line 78, in _cached_call
    result = getattr(estimator, method)(*args, **kwargs)
  File "C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\pipeline.py", line 121, in __getattr__
    return getattr(self._final_estimator, name)
  File "C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\sklearn\utils\_available_if.py", line 32, in __get__
    if not self.check(obj):
  File "C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\sklearn\linear_model\_stochastic_gradient.py", line 1235, in _check_proba
    raise AttributeError(
AttributeError: probability estimates are not available for loss='hinge'

  warnings.warn(

2023-08-22 08:18:44,999:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\sklearn\metrics\_classification.py:1344: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 due to no predicted samples. Use `zero_division` parameter to control this behavior.
  _warn_prf(average, modifier, msg_start, len(result))

2023-08-22 08:18:45,215:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\metrics.py:138: FitFailedWarning: Metric 'make_scorer(roc_auc_score, needs_proba=True, error_score=0.0, average=weighted, multi_class=ovr)' failed and error score 0.0 has been returned instead. If this is a custom metric, this usually means that the error is in the metric code. Full exception below:
Traceback (most recent call last):
  File "C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\sklearn\metrics\_scorer.py", line 76, in _cached_call
    return cache[method]
KeyError: 'predict_proba'

During handling of the above exception, another exception occurred:

Traceback (most recent call last):
  File "C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\metrics.py", line 130, in _score
    return super()._score(
  File "C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\sklearn\metrics\_scorer.py", line 316, in _score
    y_pred = method_caller(clf, "predict_proba", X)
  File "C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\sklearn\metrics\_scorer.py", line 78, in _cached_call
    result = getattr(estimator, method)(*args, **kwargs)
  File "C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\pipeline.py", line 121, in __getattr__
    return getattr(self._final_estimator, name)
  File "C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\sklearn\utils\_available_if.py", line 32, in __get__
    if not self.check(obj):
  File "C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\sklearn\linear_model\_stochastic_gradient.py", line 1235, in _check_proba
    raise AttributeError(
AttributeError: probability estimates are not available for loss='hinge'

  warnings.warn(

2023-08-22 08:18:45,238:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\sklearn\metrics\_classification.py:1344: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 due to no predicted samples. Use `zero_division` parameter to control this behavior.
  _warn_prf(average, modifier, msg_start, len(result))

2023-08-22 08:18:45,247:INFO:Calculating mean and std
2023-08-22 08:18:45,247:INFO:Creating metrics dataframe
2023-08-22 08:18:45,398:INFO:Uploading results into container
2023-08-22 08:18:45,408:INFO:Uploading model into container now
2023-08-22 08:18:45,410:INFO:_master_model_container: 5
2023-08-22 08:18:45,411:INFO:_display_container: 2
2023-08-22 08:18:45,412:INFO:SGDClassifier(alpha=0.0001, average=False, class_weight=None,
              early_stopping=False, epsilon=0.1, eta0=0.001, fit_intercept=True,
              l1_ratio=0.15, learning_rate='optimal', loss='hinge',
              max_iter=1000, n_iter_no_change=5, n_jobs=-1, penalty='l2',
              power_t=0.5, random_state=123, shuffle=True, tol=0.001,
              validation_fraction=0.1, verbose=0, warm_start=False)
2023-08-22 08:18:45,412:INFO:create_model() successfully completed......................................
2023-08-22 08:18:45,524:INFO:SubProcess create_model() end ==================================
2023-08-22 08:18:45,524:INFO:Creating metrics dataframe
2023-08-22 08:18:45,629:INFO:Initializing Ridge Classifier
2023-08-22 08:18:45,630:INFO:Total runtime is 0.5515607277552287 minutes
2023-08-22 08:18:45,639:INFO:SubProcess create_model() called ==================================
2023-08-22 08:18:45,644:INFO:Initializing create_model()
2023-08-22 08:18:45,644:INFO:create_model(self=<pycaret.classification.oop.ClassificationExperiment object at 0x00000172522BAA90>, estimator=ridge, fold=StratifiedKFold(n_splits=10, random_state=None, shuffle=False), round=4, cross_validation=True, predict=True, fit_kwargs={}, groups=None, refit=False, probability_threshold=None, experiment_custom_tags=None, verbose=False, system=False, add_to_model_list=True, metrics=None, display=<pycaret.internal.display.display.CommonDisplay object at 0x0000017231089160>, model_only=True, return_train_score=False, kwargs={})
2023-08-22 08:18:45,645:INFO:Checking exceptions
2023-08-22 08:18:45,645:INFO:Importing libraries
2023-08-22 08:18:45,645:INFO:Copying training dataset
2023-08-22 08:18:45,664:INFO:Defining folds
2023-08-22 08:18:45,664:INFO:Declaring metric variables
2023-08-22 08:18:45,676:INFO:Importing untrained model
2023-08-22 08:18:45,686:INFO:Ridge Classifier Imported successfully
2023-08-22 08:18:45,714:INFO:Starting cross validation
2023-08-22 08:18:45,720:INFO:Cross validating with StratifiedKFold(n_splits=10, random_state=None, shuffle=False), n_jobs=-1
2023-08-22 08:18:47,650:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\pipeline.py:310: UserWarning: Persisting input arguments took 0.53s to run.
If this happens often in your code, it can cause performance problems 
(results will be correct in all cases). 
The reason for this is probably some large input arguments for a wrapped
 function (e.g. large strings).
THIS IS A JOBLIB ISSUE. If you can, kindly provide the joblib's team with an
 example so that they can fix the problem.
  X, _ = self._memory_full_transform(self, X, None, with_final=False)

2023-08-22 08:18:47,650:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\pipeline.py:310: UserWarning: Persisting input arguments took 0.55s to run.
If this happens often in your code, it can cause performance problems 
(results will be correct in all cases). 
The reason for this is probably some large input arguments for a wrapped
 function (e.g. large strings).
THIS IS A JOBLIB ISSUE. If you can, kindly provide the joblib's team with an
 example so that they can fix the problem.
  X, _ = self._memory_full_transform(self, X, None, with_final=False)

2023-08-22 08:18:47,650:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\metrics.py:138: FitFailedWarning: Metric 'make_scorer(roc_auc_score, needs_proba=True, error_score=0.0, average=weighted, multi_class=ovr)' failed and error score 0.0 has been returned instead. If this is a custom metric, this usually means that the error is in the metric code. Full exception below:
Traceback (most recent call last):
  File "C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\sklearn\metrics\_scorer.py", line 76, in _cached_call
    return cache[method]
KeyError: 'predict_proba'

During handling of the above exception, another exception occurred:

Traceback (most recent call last):
  File "C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\metrics.py", line 130, in _score
    return super()._score(
  File "C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\sklearn\metrics\_scorer.py", line 316, in _score
    y_pred = method_caller(clf, "predict_proba", X)
  File "C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\sklearn\metrics\_scorer.py", line 78, in _cached_call
    result = getattr(estimator, method)(*args, **kwargs)
  File "C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\pipeline.py", line 121, in __getattr__
    return getattr(self._final_estimator, name)
AttributeError: 'RidgeClassifier' object has no attribute 'predict_proba'

  warnings.warn(

2023-08-22 08:18:47,665:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\metrics.py:138: FitFailedWarning: Metric 'make_scorer(roc_auc_score, needs_proba=True, error_score=0.0, average=weighted, multi_class=ovr)' failed and error score 0.0 has been returned instead. If this is a custom metric, this usually means that the error is in the metric code. Full exception below:
Traceback (most recent call last):
  File "C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\sklearn\metrics\_scorer.py", line 76, in _cached_call
    return cache[method]
KeyError: 'predict_proba'

During handling of the above exception, another exception occurred:

Traceback (most recent call last):
  File "C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\metrics.py", line 130, in _score
    return super()._score(
  File "C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\sklearn\metrics\_scorer.py", line 316, in _score
    y_pred = method_caller(clf, "predict_proba", X)
  File "C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\sklearn\metrics\_scorer.py", line 78, in _cached_call
    result = getattr(estimator, method)(*args, **kwargs)
  File "C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\pipeline.py", line 121, in __getattr__
    return getattr(self._final_estimator, name)
AttributeError: 'RidgeClassifier' object has no attribute 'predict_proba'

  warnings.warn(

2023-08-22 08:18:47,743:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\pipeline.py:310: UserWarning: Persisting input arguments took 0.52s to run.
If this happens often in your code, it can cause performance problems 
(results will be correct in all cases). 
The reason for this is probably some large input arguments for a wrapped
 function (e.g. large strings).
THIS IS A JOBLIB ISSUE. If you can, kindly provide the joblib's team with an
 example so that they can fix the problem.
  X, _ = self._memory_full_transform(self, X, None, with_final=False)

2023-08-22 08:18:47,753:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\metrics.py:138: FitFailedWarning: Metric 'make_scorer(roc_auc_score, needs_proba=True, error_score=0.0, average=weighted, multi_class=ovr)' failed and error score 0.0 has been returned instead. If this is a custom metric, this usually means that the error is in the metric code. Full exception below:
Traceback (most recent call last):
  File "C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\sklearn\metrics\_scorer.py", line 76, in _cached_call
    return cache[method]
KeyError: 'predict_proba'

During handling of the above exception, another exception occurred:

Traceback (most recent call last):
  File "C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\metrics.py", line 130, in _score
    return super()._score(
  File "C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\sklearn\metrics\_scorer.py", line 316, in _score
    y_pred = method_caller(clf, "predict_proba", X)
  File "C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\sklearn\metrics\_scorer.py", line 78, in _cached_call
    result = getattr(estimator, method)(*args, **kwargs)
  File "C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\pipeline.py", line 121, in __getattr__
    return getattr(self._final_estimator, name)
AttributeError: 'RidgeClassifier' object has no attribute 'predict_proba'

  warnings.warn(

2023-08-22 08:18:47,762:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\pipeline.py:310: UserWarning: Persisting input arguments took 0.52s to run.
If this happens often in your code, it can cause performance problems 
(results will be correct in all cases). 
The reason for this is probably some large input arguments for a wrapped
 function (e.g. large strings).
THIS IS A JOBLIB ISSUE. If you can, kindly provide the joblib's team with an
 example so that they can fix the problem.
  X, _ = self._memory_full_transform(self, X, None, with_final=False)

2023-08-22 08:18:47,766:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\pipeline.py:310: UserWarning: Persisting input arguments took 0.51s to run.
If this happens often in your code, it can cause performance problems 
(results will be correct in all cases). 
The reason for this is probably some large input arguments for a wrapped
 function (e.g. large strings).
THIS IS A JOBLIB ISSUE. If you can, kindly provide the joblib's team with an
 example so that they can fix the problem.
  X, _ = self._memory_full_transform(self, X, None, with_final=False)

2023-08-22 08:18:47,768:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\metrics.py:138: FitFailedWarning: Metric 'make_scorer(roc_auc_score, needs_proba=True, error_score=0.0, average=weighted, multi_class=ovr)' failed and error score 0.0 has been returned instead. If this is a custom metric, this usually means that the error is in the metric code. Full exception below:
Traceback (most recent call last):
  File "C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\sklearn\metrics\_scorer.py", line 76, in _cached_call
    return cache[method]
KeyError: 'predict_proba'

During handling of the above exception, another exception occurred:

Traceback (most recent call last):
  File "C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\metrics.py", line 130, in _score
    return super()._score(
  File "C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\sklearn\metrics\_scorer.py", line 316, in _score
    y_pred = method_caller(clf, "predict_proba", X)
  File "C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\sklearn\metrics\_scorer.py", line 78, in _cached_call
    result = getattr(estimator, method)(*args, **kwargs)
  File "C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\pipeline.py", line 121, in __getattr__
    return getattr(self._final_estimator, name)
AttributeError: 'RidgeClassifier' object has no attribute 'predict_proba'

  warnings.warn(

2023-08-22 08:18:47,772:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\metrics.py:138: FitFailedWarning: Metric 'make_scorer(roc_auc_score, needs_proba=True, error_score=0.0, average=weighted, multi_class=ovr)' failed and error score 0.0 has been returned instead. If this is a custom metric, this usually means that the error is in the metric code. Full exception below:
Traceback (most recent call last):
  File "C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\sklearn\metrics\_scorer.py", line 76, in _cached_call
    return cache[method]
KeyError: 'predict_proba'

During handling of the above exception, another exception occurred:

Traceback (most recent call last):
  File "C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\metrics.py", line 130, in _score
    return super()._score(
  File "C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\sklearn\metrics\_scorer.py", line 316, in _score
    y_pred = method_caller(clf, "predict_proba", X)
  File "C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\sklearn\metrics\_scorer.py", line 78, in _cached_call
    result = getattr(estimator, method)(*args, **kwargs)
  File "C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\pipeline.py", line 121, in __getattr__
    return getattr(self._final_estimator, name)
AttributeError: 'RidgeClassifier' object has no attribute 'predict_proba'

  warnings.warn(

2023-08-22 08:18:47,815:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\pipeline.py:310: UserWarning: Persisting input arguments took 0.52s to run.
If this happens often in your code, it can cause performance problems 
(results will be correct in all cases). 
The reason for this is probably some large input arguments for a wrapped
 function (e.g. large strings).
THIS IS A JOBLIB ISSUE. If you can, kindly provide the joblib's team with an
 example so that they can fix the problem.
  X, _ = self._memory_full_transform(self, X, None, with_final=False)

2023-08-22 08:18:47,815:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\metrics.py:138: FitFailedWarning: Metric 'make_scorer(roc_auc_score, needs_proba=True, error_score=0.0, average=weighted, multi_class=ovr)' failed and error score 0.0 has been returned instead. If this is a custom metric, this usually means that the error is in the metric code. Full exception below:
Traceback (most recent call last):
  File "C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\sklearn\metrics\_scorer.py", line 76, in _cached_call
    return cache[method]
KeyError: 'predict_proba'

During handling of the above exception, another exception occurred:

Traceback (most recent call last):
  File "C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\metrics.py", line 130, in _score
    return super()._score(
  File "C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\sklearn\metrics\_scorer.py", line 316, in _score
    y_pred = method_caller(clf, "predict_proba", X)
  File "C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\sklearn\metrics\_scorer.py", line 78, in _cached_call
    result = getattr(estimator, method)(*args, **kwargs)
  File "C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\pipeline.py", line 121, in __getattr__
    return getattr(self._final_estimator, name)
AttributeError: 'RidgeClassifier' object has no attribute 'predict_proba'

  warnings.warn(

2023-08-22 08:18:48,242:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\pipeline.py:310: UserWarning: Persisting input arguments took 0.81s to run.
If this happens often in your code, it can cause performance problems 
(results will be correct in all cases). 
The reason for this is probably some large input arguments for a wrapped
 function (e.g. large strings).
THIS IS A JOBLIB ISSUE. If you can, kindly provide the joblib's team with an
 example so that they can fix the problem.
  X, _ = self._memory_full_transform(self, X, None, with_final=False)

2023-08-22 08:18:48,242:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\pipeline.py:310: UserWarning: Persisting input arguments took 0.80s to run.
If this happens often in your code, it can cause performance problems 
(results will be correct in all cases). 
The reason for this is probably some large input arguments for a wrapped
 function (e.g. large strings).
THIS IS A JOBLIB ISSUE. If you can, kindly provide the joblib's team with an
 example so that they can fix the problem.
  X, _ = self._memory_full_transform(self, X, None, with_final=False)

2023-08-22 08:18:48,253:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\metrics.py:138: FitFailedWarning: Metric 'make_scorer(roc_auc_score, needs_proba=True, error_score=0.0, average=weighted, multi_class=ovr)' failed and error score 0.0 has been returned instead. If this is a custom metric, this usually means that the error is in the metric code. Full exception below:
Traceback (most recent call last):
  File "C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\sklearn\metrics\_scorer.py", line 76, in _cached_call
    return cache[method]
KeyError: 'predict_proba'

During handling of the above exception, another exception occurred:

Traceback (most recent call last):
  File "C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\metrics.py", line 130, in _score
    return super()._score(
  File "C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\sklearn\metrics\_scorer.py", line 316, in _score
    y_pred = method_caller(clf, "predict_proba", X)
  File "C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\sklearn\metrics\_scorer.py", line 78, in _cached_call
    result = getattr(estimator, method)(*args, **kwargs)
  File "C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\pipeline.py", line 121, in __getattr__
    return getattr(self._final_estimator, name)
AttributeError: 'RidgeClassifier' object has no attribute 'predict_proba'

  warnings.warn(

2023-08-22 08:18:49,171:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\metrics.py:138: FitFailedWarning: Metric 'make_scorer(roc_auc_score, needs_proba=True, error_score=0.0, average=weighted, multi_class=ovr)' failed and error score 0.0 has been returned instead. If this is a custom metric, this usually means that the error is in the metric code. Full exception below:
Traceback (most recent call last):
  File "C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\sklearn\metrics\_scorer.py", line 76, in _cached_call
    return cache[method]
KeyError: 'predict_proba'

During handling of the above exception, another exception occurred:

Traceback (most recent call last):
  File "C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\metrics.py", line 130, in _score
    return super()._score(
  File "C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\sklearn\metrics\_scorer.py", line 316, in _score
    y_pred = method_caller(clf, "predict_proba", X)
  File "C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\sklearn\metrics\_scorer.py", line 78, in _cached_call
    result = getattr(estimator, method)(*args, **kwargs)
  File "C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\pipeline.py", line 121, in __getattr__
    return getattr(self._final_estimator, name)
AttributeError: 'RidgeClassifier' object has no attribute 'predict_proba'

  warnings.warn(

2023-08-22 08:18:49,193:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\metrics.py:138: FitFailedWarning: Metric 'make_scorer(roc_auc_score, needs_proba=True, error_score=0.0, average=weighted, multi_class=ovr)' failed and error score 0.0 has been returned instead. If this is a custom metric, this usually means that the error is in the metric code. Full exception below:
Traceback (most recent call last):
  File "C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\sklearn\metrics\_scorer.py", line 76, in _cached_call
    return cache[method]
KeyError: 'predict_proba'

During handling of the above exception, another exception occurred:

Traceback (most recent call last):
  File "C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\metrics.py", line 130, in _score
    return super()._score(
  File "C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\sklearn\metrics\_scorer.py", line 316, in _score
    y_pred = method_caller(clf, "predict_proba", X)
  File "C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\sklearn\metrics\_scorer.py", line 78, in _cached_call
    result = getattr(estimator, method)(*args, **kwargs)
  File "C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\pipeline.py", line 121, in __getattr__
    return getattr(self._final_estimator, name)
AttributeError: 'RidgeClassifier' object has no attribute 'predict_proba'

  warnings.warn(

2023-08-22 08:18:49,329:INFO:Calculating mean and std
2023-08-22 08:18:49,332:INFO:Creating metrics dataframe
2023-08-22 08:18:49,626:INFO:Uploading results into container
2023-08-22 08:18:49,628:INFO:Uploading model into container now
2023-08-22 08:18:49,630:INFO:_master_model_container: 6
2023-08-22 08:18:49,631:INFO:_display_container: 2
2023-08-22 08:18:49,632:INFO:RidgeClassifier(alpha=1.0, class_weight=None, copy_X=True, fit_intercept=True,
                max_iter=None, positive=False, random_state=123, solver='auto',
                tol=0.0001)
2023-08-22 08:18:49,633:INFO:create_model() successfully completed......................................
2023-08-22 08:18:49,766:INFO:SubProcess create_model() end ==================================
2023-08-22 08:18:49,766:INFO:Creating metrics dataframe
2023-08-22 08:18:49,785:INFO:Initializing Random Forest Classifier
2023-08-22 08:18:49,785:INFO:Total runtime is 0.6208162307739258 minutes
2023-08-22 08:18:49,794:INFO:SubProcess create_model() called ==================================
2023-08-22 08:18:49,794:INFO:Initializing create_model()
2023-08-22 08:18:49,795:INFO:create_model(self=<pycaret.classification.oop.ClassificationExperiment object at 0x00000172522BAA90>, estimator=rf, fold=StratifiedKFold(n_splits=10, random_state=None, shuffle=False), round=4, cross_validation=True, predict=True, fit_kwargs={}, groups=None, refit=False, probability_threshold=None, experiment_custom_tags=None, verbose=False, system=False, add_to_model_list=True, metrics=None, display=<pycaret.internal.display.display.CommonDisplay object at 0x0000017231089160>, model_only=True, return_train_score=False, kwargs={})
2023-08-22 08:18:49,796:INFO:Checking exceptions
2023-08-22 08:18:49,796:INFO:Importing libraries
2023-08-22 08:18:49,796:INFO:Copying training dataset
2023-08-22 08:18:49,811:INFO:Defining folds
2023-08-22 08:18:49,811:INFO:Declaring metric variables
2023-08-22 08:18:49,822:INFO:Importing untrained model
2023-08-22 08:18:49,835:INFO:Random Forest Classifier Imported successfully
2023-08-22 08:18:49,852:INFO:Starting cross validation
2023-08-22 08:18:49,861:INFO:Cross validating with StratifiedKFold(n_splits=10, random_state=None, shuffle=False), n_jobs=-1
2023-08-22 08:18:51,876:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\pipeline.py:238: UserWarning: Persisting input arguments took 1.12s to run.
If this happens often in your code, it can cause performance problems 
(results will be correct in all cases). 
The reason for this is probably some large input arguments for a wrapped
 function (e.g. large strings).
THIS IS A JOBLIB ISSUE. If you can, kindly provide the joblib's team with an
 example so that they can fix the problem.
  X, y = self._memory_transform(

2023-08-22 08:18:52,067:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\pipeline.py:238: UserWarning: Persisting input arguments took 1.29s to run.
If this happens often in your code, it can cause performance problems 
(results will be correct in all cases). 
The reason for this is probably some large input arguments for a wrapped
 function (e.g. large strings).
THIS IS A JOBLIB ISSUE. If you can, kindly provide the joblib's team with an
 example so that they can fix the problem.
  X, y = self._memory_transform(

2023-08-22 08:18:52,798:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\pipeline.py:260: UserWarning: Persisting input arguments took 0.53s to run.
If this happens often in your code, it can cause performance problems 
(results will be correct in all cases). 
The reason for this is probably some large input arguments for a wrapped
 function (e.g. large strings).
THIS IS A JOBLIB ISSUE. If you can, kindly provide the joblib's team with an
 example so that they can fix the problem.
  fitted_estimator = self._memory_fit(

2023-08-22 08:18:52,889:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\pipeline.py:260: UserWarning: Persisting input arguments took 0.56s to run.
If this happens often in your code, it can cause performance problems 
(results will be correct in all cases). 
The reason for this is probably some large input arguments for a wrapped
 function (e.g. large strings).
THIS IS A JOBLIB ISSUE. If you can, kindly provide the joblib's team with an
 example so that they can fix the problem.
  fitted_estimator = self._memory_fit(

2023-08-22 08:18:53,121:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\pipeline.py:260: UserWarning: Persisting input arguments took 0.63s to run.
If this happens often in your code, it can cause performance problems 
(results will be correct in all cases). 
The reason for this is probably some large input arguments for a wrapped
 function (e.g. large strings).
THIS IS A JOBLIB ISSUE. If you can, kindly provide the joblib's team with an
 example so that they can fix the problem.
  fitted_estimator = self._memory_fit(

2023-08-22 08:18:53,503:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\pipeline.py:260: UserWarning: Persisting input arguments took 0.90s to run.
If this happens often in your code, it can cause performance problems 
(results will be correct in all cases). 
The reason for this is probably some large input arguments for a wrapped
 function (e.g. large strings).
THIS IS A JOBLIB ISSUE. If you can, kindly provide the joblib's team with an
 example so that they can fix the problem.
  fitted_estimator = self._memory_fit(

2023-08-22 08:18:54,652:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\pipeline.py:310: UserWarning: Persisting input arguments took 0.72s to run.
If this happens often in your code, it can cause performance problems 
(results will be correct in all cases). 
The reason for this is probably some large input arguments for a wrapped
 function (e.g. large strings).
THIS IS A JOBLIB ISSUE. If you can, kindly provide the joblib's team with an
 example so that they can fix the problem.
  X, _ = self._memory_full_transform(self, X, None, with_final=False)

2023-08-22 08:18:54,668:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\pipeline.py:310: UserWarning: Persisting input arguments took 0.78s to run.
If this happens often in your code, it can cause performance problems 
(results will be correct in all cases). 
The reason for this is probably some large input arguments for a wrapped
 function (e.g. large strings).
THIS IS A JOBLIB ISSUE. If you can, kindly provide the joblib's team with an
 example so that they can fix the problem.
  X, _ = self._memory_full_transform(self, X, None, with_final=False)

2023-08-22 08:18:54,683:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\pipeline.py:310: UserWarning: Persisting input arguments took 0.76s to run.
If this happens often in your code, it can cause performance problems 
(results will be correct in all cases). 
The reason for this is probably some large input arguments for a wrapped
 function (e.g. large strings).
THIS IS A JOBLIB ISSUE. If you can, kindly provide the joblib's team with an
 example so that they can fix the problem.
  X, _ = self._memory_full_transform(self, X, None, with_final=False)

2023-08-22 08:18:54,833:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\pipeline.py:310: UserWarning: Persisting input arguments took 0.83s to run.
If this happens often in your code, it can cause performance problems 
(results will be correct in all cases). 
The reason for this is probably some large input arguments for a wrapped
 function (e.g. large strings).
THIS IS A JOBLIB ISSUE. If you can, kindly provide the joblib's team with an
 example so that they can fix the problem.
  X, _ = self._memory_full_transform(self, X, None, with_final=False)

2023-08-22 08:18:54,883:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\pipeline.py:310: UserWarning: Persisting input arguments took 0.82s to run.
If this happens often in your code, it can cause performance problems 
(results will be correct in all cases). 
The reason for this is probably some large input arguments for a wrapped
 function (e.g. large strings).
THIS IS A JOBLIB ISSUE. If you can, kindly provide the joblib's team with an
 example so that they can fix the problem.
  X, _ = self._memory_full_transform(self, X, None, with_final=False)

2023-08-22 08:18:55,071:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\pipeline.py:310: UserWarning: Persisting input arguments took 0.86s to run.
If this happens often in your code, it can cause performance problems 
(results will be correct in all cases). 
The reason for this is probably some large input arguments for a wrapped
 function (e.g. large strings).
THIS IS A JOBLIB ISSUE. If you can, kindly provide the joblib's team with an
 example so that they can fix the problem.
  X, _ = self._memory_full_transform(self, X, None, with_final=False)

2023-08-22 08:18:55,584:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\pipeline.py:310: UserWarning: Persisting input arguments took 0.96s to run.
If this happens often in your code, it can cause performance problems 
(results will be correct in all cases). 
The reason for this is probably some large input arguments for a wrapped
 function (e.g. large strings).
THIS IS A JOBLIB ISSUE. If you can, kindly provide the joblib's team with an
 example so that they can fix the problem.
  X, _ = self._memory_full_transform(self, X, None, with_final=False)

2023-08-22 08:18:55,849:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\pipeline.py:310: UserWarning: Persisting input arguments took 1.07s to run.
If this happens often in your code, it can cause performance problems 
(results will be correct in all cases). 
The reason for this is probably some large input arguments for a wrapped
 function (e.g. large strings).
THIS IS A JOBLIB ISSUE. If you can, kindly provide the joblib's team with an
 example so that they can fix the problem.
  X, _ = self._memory_full_transform(self, X, None, with_final=False)

2023-08-22 08:18:59,283:INFO:Calculating mean and std
2023-08-22 08:18:59,287:INFO:Creating metrics dataframe
2023-08-22 08:18:59,581:INFO:Uploading results into container
2023-08-22 08:18:59,581:INFO:Uploading model into container now
2023-08-22 08:18:59,581:INFO:_master_model_container: 7
2023-08-22 08:18:59,581:INFO:_display_container: 2
2023-08-22 08:18:59,581:INFO:RandomForestClassifier(bootstrap=True, ccp_alpha=0.0, class_weight=None,
                       criterion='gini', max_depth=None, max_features='sqrt',
                       max_leaf_nodes=None, max_samples=None,
                       min_impurity_decrease=0.0, min_samples_leaf=1,
                       min_samples_split=2, min_weight_fraction_leaf=0.0,
                       n_estimators=100, n_jobs=-1, oob_score=False,
                       random_state=123, verbose=0, warm_start=False)
2023-08-22 08:18:59,581:INFO:create_model() successfully completed......................................
2023-08-22 08:18:59,705:INFO:SubProcess create_model() end ==================================
2023-08-22 08:18:59,706:INFO:Creating metrics dataframe
2023-08-22 08:18:59,737:INFO:Initializing Quadratic Discriminant Analysis
2023-08-22 08:18:59,738:INFO:Total runtime is 0.7867085218429566 minutes
2023-08-22 08:18:59,746:INFO:SubProcess create_model() called ==================================
2023-08-22 08:18:59,746:INFO:Initializing create_model()
2023-08-22 08:18:59,746:INFO:create_model(self=<pycaret.classification.oop.ClassificationExperiment object at 0x00000172522BAA90>, estimator=qda, fold=StratifiedKFold(n_splits=10, random_state=None, shuffle=False), round=4, cross_validation=True, predict=True, fit_kwargs={}, groups=None, refit=False, probability_threshold=None, experiment_custom_tags=None, verbose=False, system=False, add_to_model_list=True, metrics=None, display=<pycaret.internal.display.display.CommonDisplay object at 0x0000017231089160>, model_only=True, return_train_score=False, kwargs={})
2023-08-22 08:18:59,746:INFO:Checking exceptions
2023-08-22 08:18:59,746:INFO:Importing libraries
2023-08-22 08:18:59,746:INFO:Copying training dataset
2023-08-22 08:18:59,759:INFO:Defining folds
2023-08-22 08:18:59,759:INFO:Declaring metric variables
2023-08-22 08:18:59,770:INFO:Importing untrained model
2023-08-22 08:18:59,770:INFO:Quadratic Discriminant Analysis Imported successfully
2023-08-22 08:18:59,785:INFO:Starting cross validation
2023-08-22 08:18:59,801:INFO:Cross validating with StratifiedKFold(n_splits=10, random_state=None, shuffle=False), n_jobs=-1
2023-08-22 08:19:00,625:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\sklearn\discriminant_analysis.py:926: UserWarning: Variables are collinear
  warnings.warn("Variables are collinear")

2023-08-22 08:19:00,655:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\sklearn\discriminant_analysis.py:926: UserWarning: Variables are collinear
  warnings.warn("Variables are collinear")

2023-08-22 08:19:00,776:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\sklearn\discriminant_analysis.py:926: UserWarning: Variables are collinear
  warnings.warn("Variables are collinear")

2023-08-22 08:19:00,807:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\sklearn\discriminant_analysis.py:926: UserWarning: Variables are collinear
  warnings.warn("Variables are collinear")

2023-08-22 08:19:00,815:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\sklearn\discriminant_analysis.py:926: UserWarning: Variables are collinear
  warnings.warn("Variables are collinear")

2023-08-22 08:19:00,820:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\sklearn\discriminant_analysis.py:926: UserWarning: Variables are collinear
  warnings.warn("Variables are collinear")

2023-08-22 08:19:00,826:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\sklearn\discriminant_analysis.py:926: UserWarning: Variables are collinear
  warnings.warn("Variables are collinear")

2023-08-22 08:19:01,262:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\pipeline.py:238: UserWarning: Persisting input arguments took 0.68s to run.
If this happens often in your code, it can cause performance problems 
(results will be correct in all cases). 
The reason for this is probably some large input arguments for a wrapped
 function (e.g. large strings).
THIS IS A JOBLIB ISSUE. If you can, kindly provide the joblib's team with an
 example so that they can fix the problem.
  X, y = self._memory_transform(

2023-08-22 08:19:01,583:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\sklearn\discriminant_analysis.py:926: UserWarning: Variables are collinear
  warnings.warn("Variables are collinear")

2023-08-22 08:19:01,968:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\pipeline.py:310: UserWarning: Persisting input arguments took 0.69s to run.
If this happens often in your code, it can cause performance problems 
(results will be correct in all cases). 
The reason for this is probably some large input arguments for a wrapped
 function (e.g. large strings).
THIS IS A JOBLIB ISSUE. If you can, kindly provide the joblib's team with an
 example so that they can fix the problem.
  X, _ = self._memory_full_transform(self, X, None, with_final=False)

2023-08-22 08:19:01,968:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\pipeline.py:310: UserWarning: Persisting input arguments took 0.70s to run.
If this happens often in your code, it can cause performance problems 
(results will be correct in all cases). 
The reason for this is probably some large input arguments for a wrapped
 function (e.g. large strings).
THIS IS A JOBLIB ISSUE. If you can, kindly provide the joblib's team with an
 example so that they can fix the problem.
  X, _ = self._memory_full_transform(self, X, None, with_final=False)

2023-08-22 08:19:02,094:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\pipeline.py:310: UserWarning: Persisting input arguments took 0.78s to run.
If this happens often in your code, it can cause performance problems 
(results will be correct in all cases). 
The reason for this is probably some large input arguments for a wrapped
 function (e.g. large strings).
THIS IS A JOBLIB ISSUE. If you can, kindly provide the joblib's team with an
 example so that they can fix the problem.
  X, _ = self._memory_full_transform(self, X, None, with_final=False)

2023-08-22 08:19:02,159:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\pipeline.py:310: UserWarning: Persisting input arguments took 0.77s to run.
If this happens often in your code, it can cause performance problems 
(results will be correct in all cases). 
The reason for this is probably some large input arguments for a wrapped
 function (e.g. large strings).
THIS IS A JOBLIB ISSUE. If you can, kindly provide the joblib's team with an
 example so that they can fix the problem.
  X, _ = self._memory_full_transform(self, X, None, with_final=False)

2023-08-22 08:19:02,173:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\pipeline.py:310: UserWarning: Persisting input arguments took 0.79s to run.
If this happens often in your code, it can cause performance problems 
(results will be correct in all cases). 
The reason for this is probably some large input arguments for a wrapped
 function (e.g. large strings).
THIS IS A JOBLIB ISSUE. If you can, kindly provide the joblib's team with an
 example so that they can fix the problem.
  X, _ = self._memory_full_transform(self, X, None, with_final=False)

2023-08-22 08:19:02,188:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\pipeline.py:310: UserWarning: Persisting input arguments took 0.78s to run.
If this happens often in your code, it can cause performance problems 
(results will be correct in all cases). 
The reason for this is probably some large input arguments for a wrapped
 function (e.g. large strings).
THIS IS A JOBLIB ISSUE. If you can, kindly provide the joblib's team with an
 example so that they can fix the problem.
  X, _ = self._memory_full_transform(self, X, None, with_final=False)

2023-08-22 08:19:02,298:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\pipeline.py:310: UserWarning: Persisting input arguments took 0.84s to run.
If this happens often in your code, it can cause performance problems 
(results will be correct in all cases). 
The reason for this is probably some large input arguments for a wrapped
 function (e.g. large strings).
THIS IS A JOBLIB ISSUE. If you can, kindly provide the joblib's team with an
 example so that they can fix the problem.
  X, _ = self._memory_full_transform(self, X, None, with_final=False)

2023-08-22 08:19:03,147:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\pipeline.py:310: UserWarning: Persisting input arguments took 0.90s to run.
If this happens often in your code, it can cause performance problems 
(results will be correct in all cases). 
The reason for this is probably some large input arguments for a wrapped
 function (e.g. large strings).
THIS IS A JOBLIB ISSUE. If you can, kindly provide the joblib's team with an
 example so that they can fix the problem.
  X, _ = self._memory_full_transform(self, X, None, with_final=False)

2023-08-22 08:19:03,448:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\sklearn\discriminant_analysis.py:926: UserWarning: Variables are collinear
  warnings.warn("Variables are collinear")

2023-08-22 08:19:03,542:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\sklearn\discriminant_analysis.py:926: UserWarning: Variables are collinear
  warnings.warn("Variables are collinear")

2023-08-22 08:19:04,609:INFO:Calculating mean and std
2023-08-22 08:19:04,609:INFO:Creating metrics dataframe
2023-08-22 08:19:04,865:INFO:Uploading results into container
2023-08-22 08:19:04,865:INFO:Uploading model into container now
2023-08-22 08:19:04,865:INFO:_master_model_container: 8
2023-08-22 08:19:04,865:INFO:_display_container: 2
2023-08-22 08:19:04,865:INFO:QuadraticDiscriminantAnalysis(priors=None, reg_param=0.0,
                              store_covariance=False, tol=0.0001)
2023-08-22 08:19:04,865:INFO:create_model() successfully completed......................................
2023-08-22 08:19:04,971:INFO:SubProcess create_model() end ==================================
2023-08-22 08:19:04,971:INFO:Creating metrics dataframe
2023-08-22 08:19:04,986:INFO:Initializing Ada Boost Classifier
2023-08-22 08:19:04,986:INFO:Total runtime is 0.8741718888282777 minutes
2023-08-22 08:19:04,986:INFO:SubProcess create_model() called ==================================
2023-08-22 08:19:04,986:INFO:Initializing create_model()
2023-08-22 08:19:04,986:INFO:create_model(self=<pycaret.classification.oop.ClassificationExperiment object at 0x00000172522BAA90>, estimator=ada, fold=StratifiedKFold(n_splits=10, random_state=None, shuffle=False), round=4, cross_validation=True, predict=True, fit_kwargs={}, groups=None, refit=False, probability_threshold=None, experiment_custom_tags=None, verbose=False, system=False, add_to_model_list=True, metrics=None, display=<pycaret.internal.display.display.CommonDisplay object at 0x0000017231089160>, model_only=True, return_train_score=False, kwargs={})
2023-08-22 08:19:04,986:INFO:Checking exceptions
2023-08-22 08:19:04,986:INFO:Importing libraries
2023-08-22 08:19:04,986:INFO:Copying training dataset
2023-08-22 08:19:05,002:INFO:Defining folds
2023-08-22 08:19:05,002:INFO:Declaring metric variables
2023-08-22 08:19:05,017:INFO:Importing untrained model
2023-08-22 08:19:05,017:INFO:Ada Boost Classifier Imported successfully
2023-08-22 08:19:05,049:INFO:Starting cross validation
2023-08-22 08:19:05,049:INFO:Cross validating with StratifiedKFold(n_splits=10, random_state=None, shuffle=False), n_jobs=-1
2023-08-22 08:19:08,291:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\pipeline.py:310: UserWarning: Persisting input arguments took 0.66s to run.
If this happens often in your code, it can cause performance problems 
(results will be correct in all cases). 
The reason for this is probably some large input arguments for a wrapped
 function (e.g. large strings).
THIS IS A JOBLIB ISSUE. If you can, kindly provide the joblib's team with an
 example so that they can fix the problem.
  X, _ = self._memory_full_transform(self, X, None, with_final=False)

2023-08-22 08:19:08,338:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\pipeline.py:310: UserWarning: Persisting input arguments took 0.71s to run.
If this happens often in your code, it can cause performance problems 
(results will be correct in all cases). 
The reason for this is probably some large input arguments for a wrapped
 function (e.g. large strings).
THIS IS A JOBLIB ISSUE. If you can, kindly provide the joblib's team with an
 example so that they can fix the problem.
  X, _ = self._memory_full_transform(self, X, None, with_final=False)

2023-08-22 08:19:08,371:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\pipeline.py:310: UserWarning: Persisting input arguments took 0.72s to run.
If this happens often in your code, it can cause performance problems 
(results will be correct in all cases). 
The reason for this is probably some large input arguments for a wrapped
 function (e.g. large strings).
THIS IS A JOBLIB ISSUE. If you can, kindly provide the joblib's team with an
 example so that they can fix the problem.
  X, _ = self._memory_full_transform(self, X, None, with_final=False)

2023-08-22 08:19:08,416:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\pipeline.py:310: UserWarning: Persisting input arguments took 0.68s to run.
If this happens often in your code, it can cause performance problems 
(results will be correct in all cases). 
The reason for this is probably some large input arguments for a wrapped
 function (e.g. large strings).
THIS IS A JOBLIB ISSUE. If you can, kindly provide the joblib's team with an
 example so that they can fix the problem.
  X, _ = self._memory_full_transform(self, X, None, with_final=False)

2023-08-22 08:19:08,589:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\pipeline.py:310: UserWarning: Persisting input arguments took 0.69s to run.
If this happens often in your code, it can cause performance problems 
(results will be correct in all cases). 
The reason for this is probably some large input arguments for a wrapped
 function (e.g. large strings).
THIS IS A JOBLIB ISSUE. If you can, kindly provide the joblib's team with an
 example so that they can fix the problem.
  X, _ = self._memory_full_transform(self, X, None, with_final=False)

2023-08-22 08:19:08,636:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\pipeline.py:310: UserWarning: Persisting input arguments took 0.74s to run.
If this happens often in your code, it can cause performance problems 
(results will be correct in all cases). 
The reason for this is probably some large input arguments for a wrapped
 function (e.g. large strings).
THIS IS A JOBLIB ISSUE. If you can, kindly provide the joblib's team with an
 example so that they can fix the problem.
  X, _ = self._memory_full_transform(self, X, None, with_final=False)

2023-08-22 08:19:08,793:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\pipeline.py:310: UserWarning: Persisting input arguments took 0.68s to run.
If this happens often in your code, it can cause performance problems 
(results will be correct in all cases). 
The reason for this is probably some large input arguments for a wrapped
 function (e.g. large strings).
THIS IS A JOBLIB ISSUE. If you can, kindly provide the joblib's team with an
 example so that they can fix the problem.
  X, _ = self._memory_full_transform(self, X, None, with_final=False)

2023-08-22 08:19:11,518:INFO:Calculating mean and std
2023-08-22 08:19:11,518:INFO:Creating metrics dataframe
2023-08-22 08:19:11,727:INFO:Uploading results into container
2023-08-22 08:19:11,727:INFO:Uploading model into container now
2023-08-22 08:19:11,727:INFO:_master_model_container: 9
2023-08-22 08:19:11,727:INFO:_display_container: 2
2023-08-22 08:19:11,727:INFO:AdaBoostClassifier(algorithm='SAMME.R', base_estimator='deprecated',
                   estimator=None, learning_rate=1.0, n_estimators=50,
                   random_state=123)
2023-08-22 08:19:11,727:INFO:create_model() successfully completed......................................
2023-08-22 08:19:11,806:INFO:SubProcess create_model() end ==================================
2023-08-22 08:19:11,806:INFO:Creating metrics dataframe
2023-08-22 08:19:11,830:INFO:Initializing Gradient Boosting Classifier
2023-08-22 08:19:11,830:INFO:Total runtime is 0.9882330099741619 minutes
2023-08-22 08:19:11,837:INFO:SubProcess create_model() called ==================================
2023-08-22 08:19:11,838:INFO:Initializing create_model()
2023-08-22 08:19:11,838:INFO:create_model(self=<pycaret.classification.oop.ClassificationExperiment object at 0x00000172522BAA90>, estimator=gbc, fold=StratifiedKFold(n_splits=10, random_state=None, shuffle=False), round=4, cross_validation=True, predict=True, fit_kwargs={}, groups=None, refit=False, probability_threshold=None, experiment_custom_tags=None, verbose=False, system=False, add_to_model_list=True, metrics=None, display=<pycaret.internal.display.display.CommonDisplay object at 0x0000017231089160>, model_only=True, return_train_score=False, kwargs={})
2023-08-22 08:19:11,838:INFO:Checking exceptions
2023-08-22 08:19:11,838:INFO:Importing libraries
2023-08-22 08:19:11,838:INFO:Copying training dataset
2023-08-22 08:19:11,846:INFO:Defining folds
2023-08-22 08:19:11,846:INFO:Declaring metric variables
2023-08-22 08:19:11,861:INFO:Importing untrained model
2023-08-22 08:19:11,877:INFO:Gradient Boosting Classifier Imported successfully
2023-08-22 08:19:11,893:INFO:Starting cross validation
2023-08-22 08:19:11,909:INFO:Cross validating with StratifiedKFold(n_splits=10, random_state=None, shuffle=False), n_jobs=-1
2023-08-22 08:19:15,569:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\pipeline.py:310: UserWarning: Persisting input arguments took 0.64s to run.
If this happens often in your code, it can cause performance problems 
(results will be correct in all cases). 
The reason for this is probably some large input arguments for a wrapped
 function (e.g. large strings).
THIS IS A JOBLIB ISSUE. If you can, kindly provide the joblib's team with an
 example so that they can fix the problem.
  X, _ = self._memory_full_transform(self, X, None, with_final=False)

2023-08-22 08:19:15,600:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\pipeline.py:310: UserWarning: Persisting input arguments took 0.61s to run.
If this happens often in your code, it can cause performance problems 
(results will be correct in all cases). 
The reason for this is probably some large input arguments for a wrapped
 function (e.g. large strings).
THIS IS A JOBLIB ISSUE. If you can, kindly provide the joblib's team with an
 example so that they can fix the problem.
  X, _ = self._memory_full_transform(self, X, None, with_final=False)

2023-08-22 08:19:15,616:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\pipeline.py:310: UserWarning: Persisting input arguments took 0.61s to run.
If this happens often in your code, it can cause performance problems 
(results will be correct in all cases). 
The reason for this is probably some large input arguments for a wrapped
 function (e.g. large strings).
THIS IS A JOBLIB ISSUE. If you can, kindly provide the joblib's team with an
 example so that they can fix the problem.
  X, _ = self._memory_full_transform(self, X, None, with_final=False)

2023-08-22 08:19:15,632:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\pipeline.py:310: UserWarning: Persisting input arguments took 0.60s to run.
If this happens often in your code, it can cause performance problems 
(results will be correct in all cases). 
The reason for this is probably some large input arguments for a wrapped
 function (e.g. large strings).
THIS IS A JOBLIB ISSUE. If you can, kindly provide the joblib's team with an
 example so that they can fix the problem.
  X, _ = self._memory_full_transform(self, X, None, with_final=False)

2023-08-22 08:19:15,663:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\pipeline.py:310: UserWarning: Persisting input arguments took 0.60s to run.
If this happens often in your code, it can cause performance problems 
(results will be correct in all cases). 
The reason for this is probably some large input arguments for a wrapped
 function (e.g. large strings).
THIS IS A JOBLIB ISSUE. If you can, kindly provide the joblib's team with an
 example so that they can fix the problem.
  X, _ = self._memory_full_transform(self, X, None, with_final=False)

2023-08-22 08:19:15,695:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\pipeline.py:310: UserWarning: Persisting input arguments took 0.60s to run.
If this happens often in your code, it can cause performance problems 
(results will be correct in all cases). 
The reason for this is probably some large input arguments for a wrapped
 function (e.g. large strings).
THIS IS A JOBLIB ISSUE. If you can, kindly provide the joblib's team with an
 example so that they can fix the problem.
  X, _ = self._memory_full_transform(self, X, None, with_final=False)

2023-08-22 08:19:15,726:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\pipeline.py:310: UserWarning: Persisting input arguments took 0.59s to run.
If this happens often in your code, it can cause performance problems 
(results will be correct in all cases). 
The reason for this is probably some large input arguments for a wrapped
 function (e.g. large strings).
THIS IS A JOBLIB ISSUE. If you can, kindly provide the joblib's team with an
 example so that they can fix the problem.
  X, _ = self._memory_full_transform(self, X, None, with_final=False)

2023-08-22 08:19:15,742:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\pipeline.py:310: UserWarning: Persisting input arguments took 0.61s to run.
If this happens often in your code, it can cause performance problems 
(results will be correct in all cases). 
The reason for this is probably some large input arguments for a wrapped
 function (e.g. large strings).
THIS IS A JOBLIB ISSUE. If you can, kindly provide the joblib's team with an
 example so that they can fix the problem.
  X, _ = self._memory_full_transform(self, X, None, with_final=False)

2023-08-22 08:19:19,092:INFO:Calculating mean and std
2023-08-22 08:19:19,096:INFO:Creating metrics dataframe
2023-08-22 08:19:19,375:INFO:Uploading results into container
2023-08-22 08:19:19,375:INFO:Uploading model into container now
2023-08-22 08:19:19,391:INFO:_master_model_container: 10
2023-08-22 08:19:19,391:INFO:_display_container: 2
2023-08-22 08:19:19,393:INFO:GradientBoostingClassifier(ccp_alpha=0.0, criterion='friedman_mse', init=None,
                           learning_rate=0.1, loss='log_loss', max_depth=3,
                           max_features=None, max_leaf_nodes=None,
                           min_impurity_decrease=0.0, min_samples_leaf=1,
                           min_samples_split=2, min_weight_fraction_leaf=0.0,
                           n_estimators=100, n_iter_no_change=None,
                           random_state=123, subsample=1.0, tol=0.0001,
                           validation_fraction=0.1, verbose=0,
                           warm_start=False)
2023-08-22 08:19:19,393:INFO:create_model() successfully completed......................................
2023-08-22 08:19:19,485:INFO:SubProcess create_model() end ==================================
2023-08-22 08:19:19,485:INFO:Creating metrics dataframe
2023-08-22 08:19:19,517:INFO:Initializing Linear Discriminant Analysis
2023-08-22 08:19:19,517:INFO:Total runtime is 1.1163523276646932 minutes
2023-08-22 08:19:19,533:INFO:SubProcess create_model() called ==================================
2023-08-22 08:19:19,533:INFO:Initializing create_model()
2023-08-22 08:19:19,533:INFO:create_model(self=<pycaret.classification.oop.ClassificationExperiment object at 0x00000172522BAA90>, estimator=lda, fold=StratifiedKFold(n_splits=10, random_state=None, shuffle=False), round=4, cross_validation=True, predict=True, fit_kwargs={}, groups=None, refit=False, probability_threshold=None, experiment_custom_tags=None, verbose=False, system=False, add_to_model_list=True, metrics=None, display=<pycaret.internal.display.display.CommonDisplay object at 0x0000017231089160>, model_only=True, return_train_score=False, kwargs={})
2023-08-22 08:19:19,533:INFO:Checking exceptions
2023-08-22 08:19:19,533:INFO:Importing libraries
2023-08-22 08:19:19,533:INFO:Copying training dataset
2023-08-22 08:19:19,548:INFO:Defining folds
2023-08-22 08:19:19,548:INFO:Declaring metric variables
2023-08-22 08:19:19,564:INFO:Importing untrained model
2023-08-22 08:19:19,580:INFO:Linear Discriminant Analysis Imported successfully
2023-08-22 08:19:19,596:INFO:Starting cross validation
2023-08-22 08:19:19,611:INFO:Cross validating with StratifiedKFold(n_splits=10, random_state=None, shuffle=False), n_jobs=-1
2023-08-22 08:19:21,306:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\pipeline.py:310: UserWarning: Persisting input arguments took 0.58s to run.
If this happens often in your code, it can cause performance problems 
(results will be correct in all cases). 
The reason for this is probably some large input arguments for a wrapped
 function (e.g. large strings).
THIS IS A JOBLIB ISSUE. If you can, kindly provide the joblib's team with an
 example so that they can fix the problem.
  X, _ = self._memory_full_transform(self, X, None, with_final=False)

2023-08-22 08:19:21,321:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\pipeline.py:310: UserWarning: Persisting input arguments took 0.56s to run.
If this happens often in your code, it can cause performance problems 
(results will be correct in all cases). 
The reason for this is probably some large input arguments for a wrapped
 function (e.g. large strings).
THIS IS A JOBLIB ISSUE. If you can, kindly provide the joblib's team with an
 example so that they can fix the problem.
  X, _ = self._memory_full_transform(self, X, None, with_final=False)

2023-08-22 08:19:21,335:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\pipeline.py:310: UserWarning: Persisting input arguments took 0.58s to run.
If this happens often in your code, it can cause performance problems 
(results will be correct in all cases). 
The reason for this is probably some large input arguments for a wrapped
 function (e.g. large strings).
THIS IS A JOBLIB ISSUE. If you can, kindly provide the joblib's team with an
 example so that they can fix the problem.
  X, _ = self._memory_full_transform(self, X, None, with_final=False)

2023-08-22 08:19:21,360:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\pipeline.py:310: UserWarning: Persisting input arguments took 0.52s to run.
If this happens often in your code, it can cause performance problems 
(results will be correct in all cases). 
The reason for this is probably some large input arguments for a wrapped
 function (e.g. large strings).
THIS IS A JOBLIB ISSUE. If you can, kindly provide the joblib's team with an
 example so that they can fix the problem.
  X, _ = self._memory_full_transform(self, X, None, with_final=False)

2023-08-22 08:19:21,360:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\pipeline.py:310: UserWarning: Persisting input arguments took 0.52s to run.
If this happens often in your code, it can cause performance problems 
(results will be correct in all cases). 
The reason for this is probably some large input arguments for a wrapped
 function (e.g. large strings).
THIS IS A JOBLIB ISSUE. If you can, kindly provide the joblib's team with an
 example so that they can fix the problem.
  X, _ = self._memory_full_transform(self, X, None, with_final=False)

2023-08-22 08:19:21,423:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\pipeline.py:310: UserWarning: Persisting input arguments took 0.53s to run.
If this happens often in your code, it can cause performance problems 
(results will be correct in all cases). 
The reason for this is probably some large input arguments for a wrapped
 function (e.g. large strings).
THIS IS A JOBLIB ISSUE. If you can, kindly provide the joblib's team with an
 example so that they can fix the problem.
  X, _ = self._memory_full_transform(self, X, None, with_final=False)

2023-08-22 08:19:21,470:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\pipeline.py:310: UserWarning: Persisting input arguments took 0.52s to run.
If this happens often in your code, it can cause performance problems 
(results will be correct in all cases). 
The reason for this is probably some large input arguments for a wrapped
 function (e.g. large strings).
THIS IS A JOBLIB ISSUE. If you can, kindly provide the joblib's team with an
 example so that they can fix the problem.
  X, _ = self._memory_full_transform(self, X, None, with_final=False)

2023-08-22 08:19:23,566:INFO:Calculating mean and std
2023-08-22 08:19:23,568:INFO:Creating metrics dataframe
2023-08-22 08:19:23,892:INFO:Uploading results into container
2023-08-22 08:19:23,893:INFO:Uploading model into container now
2023-08-22 08:19:23,894:INFO:_master_model_container: 11
2023-08-22 08:19:23,894:INFO:_display_container: 2
2023-08-22 08:19:23,895:INFO:LinearDiscriminantAnalysis(covariance_estimator=None, n_components=None,
                           priors=None, shrinkage=None, solver='svd',
                           store_covariance=False, tol=0.0001)
2023-08-22 08:19:23,895:INFO:create_model() successfully completed......................................
2023-08-22 08:19:24,000:INFO:SubProcess create_model() end ==================================
2023-08-22 08:19:24,000:INFO:Creating metrics dataframe
2023-08-22 08:19:24,021:INFO:Initializing Extra Trees Classifier
2023-08-22 08:19:24,022:INFO:Total runtime is 1.1914376258850097 minutes
2023-08-22 08:19:24,035:INFO:SubProcess create_model() called ==================================
2023-08-22 08:19:24,036:INFO:Initializing create_model()
2023-08-22 08:19:24,036:INFO:create_model(self=<pycaret.classification.oop.ClassificationExperiment object at 0x00000172522BAA90>, estimator=et, fold=StratifiedKFold(n_splits=10, random_state=None, shuffle=False), round=4, cross_validation=True, predict=True, fit_kwargs={}, groups=None, refit=False, probability_threshold=None, experiment_custom_tags=None, verbose=False, system=False, add_to_model_list=True, metrics=None, display=<pycaret.internal.display.display.CommonDisplay object at 0x0000017231089160>, model_only=True, return_train_score=False, kwargs={})
2023-08-22 08:19:24,037:INFO:Checking exceptions
2023-08-22 08:19:24,037:INFO:Importing libraries
2023-08-22 08:19:24,037:INFO:Copying training dataset
2023-08-22 08:19:24,052:INFO:Defining folds
2023-08-22 08:19:24,052:INFO:Declaring metric variables
2023-08-22 08:19:24,065:INFO:Importing untrained model
2023-08-22 08:19:24,078:INFO:Extra Trees Classifier Imported successfully
2023-08-22 08:19:24,107:INFO:Starting cross validation
2023-08-22 08:19:24,114:INFO:Cross validating with StratifiedKFold(n_splits=10, random_state=None, shuffle=False), n_jobs=-1
2023-08-22 08:19:26,659:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\pipeline.py:260: UserWarning: Persisting input arguments took 0.61s to run.
If this happens often in your code, it can cause performance problems 
(results will be correct in all cases). 
The reason for this is probably some large input arguments for a wrapped
 function (e.g. large strings).
THIS IS A JOBLIB ISSUE. If you can, kindly provide the joblib's team with an
 example so that they can fix the problem.
  fitted_estimator = self._memory_fit(

2023-08-22 08:19:26,706:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\pipeline.py:260: UserWarning: Persisting input arguments took 0.58s to run.
If this happens often in your code, it can cause performance problems 
(results will be correct in all cases). 
The reason for this is probably some large input arguments for a wrapped
 function (e.g. large strings).
THIS IS A JOBLIB ISSUE. If you can, kindly provide the joblib's team with an
 example so that they can fix the problem.
  fitted_estimator = self._memory_fit(

2023-08-22 08:19:28,120:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\pipeline.py:260: UserWarning: Persisting input arguments took 0.53s to run.
If this happens often in your code, it can cause performance problems 
(results will be correct in all cases). 
The reason for this is probably some large input arguments for a wrapped
 function (e.g. large strings).
THIS IS A JOBLIB ISSUE. If you can, kindly provide the joblib's team with an
 example so that they can fix the problem.
  fitted_estimator = self._memory_fit(

2023-08-22 08:19:28,736:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\pipeline.py:310: UserWarning: Persisting input arguments took 1.07s to run.
If this happens often in your code, it can cause performance problems 
(results will be correct in all cases). 
The reason for this is probably some large input arguments for a wrapped
 function (e.g. large strings).
THIS IS A JOBLIB ISSUE. If you can, kindly provide the joblib's team with an
 example so that they can fix the problem.
  X, _ = self._memory_full_transform(self, X, None, with_final=False)

2023-08-22 08:19:28,842:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\pipeline.py:310: UserWarning: Persisting input arguments took 1.08s to run.
If this happens often in your code, it can cause performance problems 
(results will be correct in all cases). 
The reason for this is probably some large input arguments for a wrapped
 function (e.g. large strings).
THIS IS A JOBLIB ISSUE. If you can, kindly provide the joblib's team with an
 example so that they can fix the problem.
  X, _ = self._memory_full_transform(self, X, None, with_final=False)

2023-08-22 08:19:28,920:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\pipeline.py:310: UserWarning: Persisting input arguments took 1.15s to run.
If this happens often in your code, it can cause performance problems 
(results will be correct in all cases). 
The reason for this is probably some large input arguments for a wrapped
 function (e.g. large strings).
THIS IS A JOBLIB ISSUE. If you can, kindly provide the joblib's team with an
 example so that they can fix the problem.
  X, _ = self._memory_full_transform(self, X, None, with_final=False)

2023-08-22 08:19:28,976:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\pipeline.py:310: UserWarning: Persisting input arguments took 1.14s to run.
If this happens often in your code, it can cause performance problems 
(results will be correct in all cases). 
The reason for this is probably some large input arguments for a wrapped
 function (e.g. large strings).
THIS IS A JOBLIB ISSUE. If you can, kindly provide the joblib's team with an
 example so that they can fix the problem.
  X, _ = self._memory_full_transform(self, X, None, with_final=False)

2023-08-22 08:19:29,403:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\pipeline.py:310: UserWarning: Persisting input arguments took 1.40s to run.
If this happens often in your code, it can cause performance problems 
(results will be correct in all cases). 
The reason for this is probably some large input arguments for a wrapped
 function (e.g. large strings).
THIS IS A JOBLIB ISSUE. If you can, kindly provide the joblib's team with an
 example so that they can fix the problem.
  X, _ = self._memory_full_transform(self, X, None, with_final=False)

2023-08-22 08:19:29,446:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\pipeline.py:310: UserWarning: Persisting input arguments took 1.52s to run.
If this happens often in your code, it can cause performance problems 
(results will be correct in all cases). 
The reason for this is probably some large input arguments for a wrapped
 function (e.g. large strings).
THIS IS A JOBLIB ISSUE. If you can, kindly provide the joblib's team with an
 example so that they can fix the problem.
  X, _ = self._memory_full_transform(self, X, None, with_final=False)

2023-08-22 08:19:29,991:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\pipeline.py:310: UserWarning: Persisting input arguments took 1.52s to run.
If this happens often in your code, it can cause performance problems 
(results will be correct in all cases). 
The reason for this is probably some large input arguments for a wrapped
 function (e.g. large strings).
THIS IS A JOBLIB ISSUE. If you can, kindly provide the joblib's team with an
 example so that they can fix the problem.
  X, _ = self._memory_full_transform(self, X, None, with_final=False)

2023-08-22 08:19:31,176:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\pipeline.py:310: UserWarning: Persisting input arguments took 1.39s to run.
If this happens often in your code, it can cause performance problems 
(results will be correct in all cases). 
The reason for this is probably some large input arguments for a wrapped
 function (e.g. large strings).
THIS IS A JOBLIB ISSUE. If you can, kindly provide the joblib's team with an
 example so that they can fix the problem.
  X, _ = self._memory_full_transform(self, X, None, with_final=False)

2023-08-22 08:19:33,663:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\pipeline.py:310: UserWarning: Persisting input arguments took 0.55s to run.
If this happens often in your code, it can cause performance problems 
(results will be correct in all cases). 
The reason for this is probably some large input arguments for a wrapped
 function (e.g. large strings).
THIS IS A JOBLIB ISSUE. If you can, kindly provide the joblib's team with an
 example so that they can fix the problem.
  X, _ = self._memory_full_transform(self, X, None, with_final=False)

2023-08-22 08:19:34,338:INFO:Calculating mean and std
2023-08-22 08:19:34,354:INFO:Creating metrics dataframe
2023-08-22 08:19:34,762:INFO:Uploading results into container
2023-08-22 08:19:34,762:INFO:Uploading model into container now
2023-08-22 08:19:34,762:INFO:_master_model_container: 12
2023-08-22 08:19:34,762:INFO:_display_container: 2
2023-08-22 08:19:34,762:INFO:ExtraTreesClassifier(bootstrap=False, ccp_alpha=0.0, class_weight=None,
                     criterion='gini', max_depth=None, max_features='sqrt',
                     max_leaf_nodes=None, max_samples=None,
                     min_impurity_decrease=0.0, min_samples_leaf=1,
                     min_samples_split=2, min_weight_fraction_leaf=0.0,
                     n_estimators=100, n_jobs=-1, oob_score=False,
                     random_state=123, verbose=0, warm_start=False)
2023-08-22 08:19:34,762:INFO:create_model() successfully completed......................................
2023-08-22 08:19:34,840:INFO:SubProcess create_model() end ==================================
2023-08-22 08:19:34,840:INFO:Creating metrics dataframe
2023-08-22 08:19:34,856:INFO:Initializing Light Gradient Boosting Machine
2023-08-22 08:19:34,856:INFO:Total runtime is 1.3719988385836284 minutes
2023-08-22 08:19:34,871:INFO:SubProcess create_model() called ==================================
2023-08-22 08:19:34,871:INFO:Initializing create_model()
2023-08-22 08:19:34,871:INFO:create_model(self=<pycaret.classification.oop.ClassificationExperiment object at 0x00000172522BAA90>, estimator=lightgbm, fold=StratifiedKFold(n_splits=10, random_state=None, shuffle=False), round=4, cross_validation=True, predict=True, fit_kwargs={}, groups=None, refit=False, probability_threshold=None, experiment_custom_tags=None, verbose=False, system=False, add_to_model_list=True, metrics=None, display=<pycaret.internal.display.display.CommonDisplay object at 0x0000017231089160>, model_only=True, return_train_score=False, kwargs={})
2023-08-22 08:19:34,871:INFO:Checking exceptions
2023-08-22 08:19:34,871:INFO:Importing libraries
2023-08-22 08:19:34,871:INFO:Copying training dataset
2023-08-22 08:19:34,891:INFO:Defining folds
2023-08-22 08:19:34,891:INFO:Declaring metric variables
2023-08-22 08:19:34,904:INFO:Importing untrained model
2023-08-22 08:19:34,919:INFO:Light Gradient Boosting Machine Imported successfully
2023-08-22 08:19:34,950:INFO:Starting cross validation
2023-08-22 08:19:34,950:INFO:Cross validating with StratifiedKFold(n_splits=10, random_state=None, shuffle=False), n_jobs=-1
2023-08-22 08:19:41,815:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\pipeline.py:310: UserWarning: Persisting input arguments took 1.25s to run.
If this happens often in your code, it can cause performance problems 
(results will be correct in all cases). 
The reason for this is probably some large input arguments for a wrapped
 function (e.g. large strings).
THIS IS A JOBLIB ISSUE. If you can, kindly provide the joblib's team with an
 example so that they can fix the problem.
  X, _ = self._memory_full_transform(self, X, None, with_final=False)

2023-08-22 08:19:41,862:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\pipeline.py:310: UserWarning: Persisting input arguments took 0.92s to run.
If this happens often in your code, it can cause performance problems 
(results will be correct in all cases). 
The reason for this is probably some large input arguments for a wrapped
 function (e.g. large strings).
THIS IS A JOBLIB ISSUE. If you can, kindly provide the joblib's team with an
 example so that they can fix the problem.
  X, _ = self._memory_full_transform(self, X, None, with_final=False)

2023-08-22 08:19:41,958:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\pipeline.py:310: UserWarning: Persisting input arguments took 0.75s to run.
If this happens often in your code, it can cause performance problems 
(results will be correct in all cases). 
The reason for this is probably some large input arguments for a wrapped
 function (e.g. large strings).
THIS IS A JOBLIB ISSUE. If you can, kindly provide the joblib's team with an
 example so that they can fix the problem.
  X, _ = self._memory_full_transform(self, X, None, with_final=False)

2023-08-22 08:19:43,370:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\pipeline.py:310: UserWarning: Persisting input arguments took 1.86s to run.
If this happens often in your code, it can cause performance problems 
(results will be correct in all cases). 
The reason for this is probably some large input arguments for a wrapped
 function (e.g. large strings).
THIS IS A JOBLIB ISSUE. If you can, kindly provide the joblib's team with an
 example so that they can fix the problem.
  X, _ = self._memory_full_transform(self, X, None, with_final=False)

2023-08-22 08:19:43,934:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\pipeline.py:310: UserWarning: Persisting input arguments took 2.39s to run.
If this happens often in your code, it can cause performance problems 
(results will be correct in all cases). 
The reason for this is probably some large input arguments for a wrapped
 function (e.g. large strings).
THIS IS A JOBLIB ISSUE. If you can, kindly provide the joblib's team with an
 example so that they can fix the problem.
  X, _ = self._memory_full_transform(self, X, None, with_final=False)

2023-08-22 08:19:44,315:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\pipeline.py:108: UserWarning: Persisting input arguments took 1.13s to run.
If this happens often in your code, it can cause performance problems 
(results will be correct in all cases). 
The reason for this is probably some large input arguments for a wrapped
 function (e.g. large strings).
THIS IS A JOBLIB ISSUE. If you can, kindly provide the joblib's team with an
 example so that they can fix the problem.
  X, y = pipeline._memory_transform(transformer, X, y)

2023-08-22 08:19:45,308:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\pipeline.py:310: UserWarning: Persisting input arguments took 0.76s to run.
If this happens often in your code, it can cause performance problems 
(results will be correct in all cases). 
The reason for this is probably some large input arguments for a wrapped
 function (e.g. large strings).
THIS IS A JOBLIB ISSUE. If you can, kindly provide the joblib's team with an
 example so that they can fix the problem.
  X, _ = self._memory_full_transform(self, X, None, with_final=False)

2023-08-22 08:19:45,613:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\pipeline.py:310: UserWarning: Persisting input arguments took 0.71s to run.
If this happens often in your code, it can cause performance problems 
(results will be correct in all cases). 
The reason for this is probably some large input arguments for a wrapped
 function (e.g. large strings).
THIS IS A JOBLIB ISSUE. If you can, kindly provide the joblib's team with an
 example so that they can fix the problem.
  X, _ = self._memory_full_transform(self, X, None, with_final=False)

2023-08-22 08:19:45,968:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\pipeline.py:310: UserWarning: Persisting input arguments took 0.89s to run.
If this happens often in your code, it can cause performance problems 
(results will be correct in all cases). 
The reason for this is probably some large input arguments for a wrapped
 function (e.g. large strings).
THIS IS A JOBLIB ISSUE. If you can, kindly provide the joblib's team with an
 example so that they can fix the problem.
  X, _ = self._memory_full_transform(self, X, None, with_final=False)

2023-08-22 08:19:48,798:INFO:Calculating mean and std
2023-08-22 08:19:48,805:INFO:Creating metrics dataframe
2023-08-22 08:19:49,362:INFO:Uploading results into container
2023-08-22 08:19:49,363:INFO:Uploading model into container now
2023-08-22 08:19:49,365:INFO:_master_model_container: 13
2023-08-22 08:19:49,365:INFO:_display_container: 2
2023-08-22 08:19:49,366:INFO:LGBMClassifier(boosting_type='gbdt', class_weight=None, colsample_bytree=1.0,
               importance_type='split', learning_rate=0.1, max_depth=-1,
               min_child_samples=20, min_child_weight=0.001, min_split_gain=0.0,
               n_estimators=100, n_jobs=-1, num_leaves=31, objective=None,
               random_state=123, reg_alpha=0.0, reg_lambda=0.0, subsample=1.0,
               subsample_for_bin=200000, subsample_freq=0)
2023-08-22 08:19:49,367:INFO:create_model() successfully completed......................................
2023-08-22 08:19:49,491:INFO:SubProcess create_model() end ==================================
2023-08-22 08:19:49,491:INFO:Creating metrics dataframe
2023-08-22 08:19:49,529:INFO:Initializing Dummy Classifier
2023-08-22 08:19:49,530:INFO:Total runtime is 1.6165675719579062 minutes
2023-08-22 08:19:49,537:INFO:SubProcess create_model() called ==================================
2023-08-22 08:19:49,538:INFO:Initializing create_model()
2023-08-22 08:19:49,538:INFO:create_model(self=<pycaret.classification.oop.ClassificationExperiment object at 0x00000172522BAA90>, estimator=dummy, fold=StratifiedKFold(n_splits=10, random_state=None, shuffle=False), round=4, cross_validation=True, predict=True, fit_kwargs={}, groups=None, refit=False, probability_threshold=None, experiment_custom_tags=None, verbose=False, system=False, add_to_model_list=True, metrics=None, display=<pycaret.internal.display.display.CommonDisplay object at 0x0000017231089160>, model_only=True, return_train_score=False, kwargs={})
2023-08-22 08:19:49,538:INFO:Checking exceptions
2023-08-22 08:19:49,538:INFO:Importing libraries
2023-08-22 08:19:49,538:INFO:Copying training dataset
2023-08-22 08:19:49,553:INFO:Defining folds
2023-08-22 08:19:49,553:INFO:Declaring metric variables
2023-08-22 08:19:49,561:INFO:Importing untrained model
2023-08-22 08:19:49,574:INFO:Dummy Classifier Imported successfully
2023-08-22 08:19:49,593:INFO:Starting cross validation
2023-08-22 08:19:49,600:INFO:Cross validating with StratifiedKFold(n_splits=10, random_state=None, shuffle=False), n_jobs=-1
2023-08-22 08:19:51,079:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\pipeline.py:238: UserWarning: Persisting input arguments took 0.83s to run.
If this happens often in your code, it can cause performance problems 
(results will be correct in all cases). 
The reason for this is probably some large input arguments for a wrapped
 function (e.g. large strings).
THIS IS A JOBLIB ISSUE. If you can, kindly provide the joblib's team with an
 example so that they can fix the problem.
  X, y = self._memory_transform(

2023-08-22 08:19:51,585:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\pipeline.py:310: UserWarning: Persisting input arguments took 0.62s to run.
If this happens often in your code, it can cause performance problems 
(results will be correct in all cases). 
The reason for this is probably some large input arguments for a wrapped
 function (e.g. large strings).
THIS IS A JOBLIB ISSUE. If you can, kindly provide the joblib's team with an
 example so that they can fix the problem.
  X, _ = self._memory_full_transform(self, X, None, with_final=False)

2023-08-22 08:19:51,819:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\sklearn\metrics\_classification.py:1344: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 due to no predicted samples. Use `zero_division` parameter to control this behavior.
  _warn_prf(average, modifier, msg_start, len(result))

2023-08-22 08:19:51,842:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\sklearn\metrics\_classification.py:1344: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 due to no predicted samples. Use `zero_division` parameter to control this behavior.
  _warn_prf(average, modifier, msg_start, len(result))

2023-08-22 08:19:51,900:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\pipeline.py:310: UserWarning: Persisting input arguments took 0.72s to run.
If this happens often in your code, it can cause performance problems 
(results will be correct in all cases). 
The reason for this is probably some large input arguments for a wrapped
 function (e.g. large strings).
THIS IS A JOBLIB ISSUE. If you can, kindly provide the joblib's team with an
 example so that they can fix the problem.
  X, _ = self._memory_full_transform(self, X, None, with_final=False)

2023-08-22 08:19:51,910:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\pipeline.py:310: UserWarning: Persisting input arguments took 0.74s to run.
If this happens often in your code, it can cause performance problems 
(results will be correct in all cases). 
The reason for this is probably some large input arguments for a wrapped
 function (e.g. large strings).
THIS IS A JOBLIB ISSUE. If you can, kindly provide the joblib's team with an
 example so that they can fix the problem.
  X, _ = self._memory_full_transform(self, X, None, with_final=False)

2023-08-22 08:19:52,086:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\sklearn\metrics\_classification.py:1344: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 due to no predicted samples. Use `zero_division` parameter to control this behavior.
  _warn_prf(average, modifier, msg_start, len(result))

2023-08-22 08:19:52,086:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\pipeline.py:310: UserWarning: Persisting input arguments took 0.71s to run.
If this happens often in your code, it can cause performance problems 
(results will be correct in all cases). 
The reason for this is probably some large input arguments for a wrapped
 function (e.g. large strings).
THIS IS A JOBLIB ISSUE. If you can, kindly provide the joblib's team with an
 example so that they can fix the problem.
  X, _ = self._memory_full_transform(self, X, None, with_final=False)

2023-08-22 08:19:52,101:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\sklearn\metrics\_classification.py:1344: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 due to no predicted samples. Use `zero_division` parameter to control this behavior.
  _warn_prf(average, modifier, msg_start, len(result))

2023-08-22 08:19:52,101:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\pipeline.py:310: UserWarning: Persisting input arguments took 0.71s to run.
If this happens often in your code, it can cause performance problems 
(results will be correct in all cases). 
The reason for this is probably some large input arguments for a wrapped
 function (e.g. large strings).
THIS IS A JOBLIB ISSUE. If you can, kindly provide the joblib's team with an
 example so that they can fix the problem.
  X, _ = self._memory_full_transform(self, X, None, with_final=False)

2023-08-22 08:19:52,268:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\sklearn\metrics\_classification.py:1344: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 due to no predicted samples. Use `zero_division` parameter to control this behavior.
  _warn_prf(average, modifier, msg_start, len(result))

2023-08-22 08:19:52,268:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\sklearn\metrics\_classification.py:1344: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 due to no predicted samples. Use `zero_division` parameter to control this behavior.
  _warn_prf(average, modifier, msg_start, len(result))

2023-08-22 08:19:52,299:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\pipeline.py:310: UserWarning: Persisting input arguments took 0.91s to run.
If this happens often in your code, it can cause performance problems 
(results will be correct in all cases). 
The reason for this is probably some large input arguments for a wrapped
 function (e.g. large strings).
THIS IS A JOBLIB ISSUE. If you can, kindly provide the joblib's team with an
 example so that they can fix the problem.
  X, _ = self._memory_full_transform(self, X, None, with_final=False)

2023-08-22 08:19:52,493:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\sklearn\metrics\_classification.py:1344: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 due to no predicted samples. Use `zero_division` parameter to control this behavior.
  _warn_prf(average, modifier, msg_start, len(result))

2023-08-22 08:19:53,144:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\pycaret\internal\pipeline.py:310: UserWarning: Persisting input arguments took 1.09s to run.
If this happens often in your code, it can cause performance problems 
(results will be correct in all cases). 
The reason for this is probably some large input arguments for a wrapped
 function (e.g. large strings).
THIS IS A JOBLIB ISSUE. If you can, kindly provide the joblib's team with an
 example so that they can fix the problem.
  X, _ = self._memory_full_transform(self, X, None, with_final=False)

2023-08-22 08:19:53,295:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\sklearn\metrics\_classification.py:1344: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 due to no predicted samples. Use `zero_division` parameter to control this behavior.
  _warn_prf(average, modifier, msg_start, len(result))

2023-08-22 08:19:54,336:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\sklearn\metrics\_classification.py:1344: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 due to no predicted samples. Use `zero_division` parameter to control this behavior.
  _warn_prf(average, modifier, msg_start, len(result))

2023-08-22 08:19:54,730:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\sklearn\metrics\_classification.py:1344: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 due to no predicted samples. Use `zero_division` parameter to control this behavior.
  _warn_prf(average, modifier, msg_start, len(result))

2023-08-22 08:19:55,269:INFO:Calculating mean and std
2023-08-22 08:19:55,285:INFO:Creating metrics dataframe
2023-08-22 08:19:55,624:INFO:Uploading results into container
2023-08-22 08:19:55,624:INFO:Uploading model into container now
2023-08-22 08:19:55,624:INFO:_master_model_container: 14
2023-08-22 08:19:55,624:INFO:_display_container: 2
2023-08-22 08:19:55,624:INFO:DummyClassifier(constant=None, random_state=123, strategy='prior')
2023-08-22 08:19:55,624:INFO:create_model() successfully completed......................................
2023-08-22 08:19:55,771:INFO:SubProcess create_model() end ==================================
2023-08-22 08:19:55,771:INFO:Creating metrics dataframe
2023-08-22 08:19:55,825:INFO:Initializing create_model()
2023-08-22 08:19:55,825:INFO:create_model(self=<pycaret.classification.oop.ClassificationExperiment object at 0x00000172522BAA90>, estimator=GaussianNB(priors=None, var_smoothing=1e-09), fold=StratifiedKFold(n_splits=10, random_state=None, shuffle=False), round=4, cross_validation=False, predict=False, fit_kwargs={}, groups=None, refit=True, probability_threshold=None, experiment_custom_tags=None, verbose=False, system=False, add_to_model_list=True, metrics=None, display=None, model_only=True, return_train_score=False, kwargs={})
2023-08-22 08:19:55,825:INFO:Checking exceptions
2023-08-22 08:19:55,839:INFO:Importing libraries
2023-08-22 08:19:55,839:INFO:Copying training dataset
2023-08-22 08:19:55,848:INFO:Defining folds
2023-08-22 08:19:55,851:INFO:Declaring metric variables
2023-08-22 08:19:55,852:INFO:Importing untrained model
2023-08-22 08:19:55,852:INFO:Declaring custom model
2023-08-22 08:19:55,854:INFO:Naive Bayes Imported successfully
2023-08-22 08:19:55,856:INFO:Cross validation set to False
2023-08-22 08:19:55,856:INFO:Fitting Model
2023-08-22 08:19:56,581:INFO:GaussianNB(priors=None, var_smoothing=1e-09)
2023-08-22 08:19:56,581:INFO:create_model() successfully completed......................................
2023-08-22 08:19:56,688:INFO:Creating Dashboard logs
2023-08-22 08:19:56,691:INFO:Model: Naive Bayes
2023-08-22 08:19:56,770:INFO:Logged params: {'priors': None, 'var_smoothing': 1e-09}
2023-08-22 08:19:56,931:INFO:Initializing predict_model()
2023-08-22 08:19:56,931:INFO:predict_model(self=<pycaret.classification.oop.ClassificationExperiment object at 0x00000172522BAA90>, estimator=GaussianNB(priors=None, var_smoothing=1e-09), probability_threshold=None, encoded_labels=False, raw_score=False, round=4, verbose=False, ml_usecase=None, preprocess=True, encode_labels=<function _SupervisedExperiment.predict_model.<locals>.encode_labels at 0x0000017257584670>)
2023-08-22 08:19:56,931:INFO:Checking exceptions
2023-08-22 08:19:56,932:INFO:Preloading libraries
2023-08-22 08:19:57,288:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\_distutils_hack\__init__.py:33: UserWarning: Setuptools is replacing distutils.
  warnings.warn("Setuptools is replacing distutils.")

2023-08-22 08:19:57,638:INFO:Creating Dashboard logs
2023-08-22 08:19:57,652:INFO:Model: K Neighbors Classifier
2023-08-22 08:19:57,721:INFO:Logged params: {'algorithm': 'auto', 'leaf_size': 30, 'metric': 'minkowski', 'metric_params': None, 'n_jobs': -1, 'n_neighbors': 5, 'p': 2, 'weights': 'uniform'}
2023-08-22 08:19:58,299:INFO:Creating Dashboard logs
2023-08-22 08:19:58,315:INFO:Model: Quadratic Discriminant Analysis
2023-08-22 08:19:58,414:INFO:Logged params: {'priors': None, 'reg_param': 0.0, 'store_covariance': False, 'tol': 0.0001}
2023-08-22 08:19:58,839:INFO:Creating Dashboard logs
2023-08-22 08:19:58,848:INFO:Model: Logistic Regression
2023-08-22 08:19:58,934:INFO:Logged params: {'C': 1.0, 'class_weight': None, 'dual': False, 'fit_intercept': True, 'intercept_scaling': 1, 'l1_ratio': None, 'max_iter': 1000, 'multi_class': 'auto', 'n_jobs': None, 'penalty': 'l2', 'random_state': 123, 'solver': 'lbfgs', 'tol': 0.0001, 'verbose': 0, 'warm_start': False}
2023-08-22 08:19:59,540:INFO:Creating Dashboard logs
2023-08-22 08:19:59,547:INFO:Model: Random Forest Classifier
2023-08-22 08:19:59,625:INFO:Logged params: {'bootstrap': True, 'ccp_alpha': 0.0, 'class_weight': None, 'criterion': 'gini', 'max_depth': None, 'max_features': 'sqrt', 'max_leaf_nodes': None, 'max_samples': None, 'min_impurity_decrease': 0.0, 'min_samples_leaf': 1, 'min_samples_split': 2, 'min_weight_fraction_leaf': 0.0, 'n_estimators': 100, 'n_jobs': -1, 'oob_score': False, 'random_state': 123, 'verbose': 0, 'warm_start': False}
2023-08-22 08:20:00,155:INFO:Creating Dashboard logs
2023-08-22 08:20:00,161:INFO:Model: SVM - Linear Kernel
2023-08-22 08:20:00,218:INFO:Logged params: {'alpha': 0.0001, 'average': False, 'class_weight': None, 'early_stopping': False, 'epsilon': 0.1, 'eta0': 0.001, 'fit_intercept': True, 'l1_ratio': 0.15, 'learning_rate': 'optimal', 'loss': 'hinge', 'max_iter': 1000, 'n_iter_no_change': 5, 'n_jobs': -1, 'penalty': 'l2', 'power_t': 0.5, 'random_state': 123, 'shuffle': True, 'tol': 0.001, 'validation_fraction': 0.1, 'verbose': 0, 'warm_start': False}
2023-08-22 08:20:00,817:INFO:Creating Dashboard logs
2023-08-22 08:20:00,822:INFO:Model: Ridge Classifier
2023-08-22 08:20:00,891:INFO:Logged params: {'alpha': 1.0, 'class_weight': None, 'copy_X': True, 'fit_intercept': True, 'max_iter': None, 'positive': False, 'random_state': 123, 'solver': 'auto', 'tol': 0.0001}
2023-08-22 08:20:01,417:INFO:Creating Dashboard logs
2023-08-22 08:20:01,431:INFO:Model: Linear Discriminant Analysis
2023-08-22 08:20:01,496:INFO:Logged params: {'covariance_estimator': None, 'n_components': None, 'priors': None, 'shrinkage': None, 'solver': 'svd', 'store_covariance': False, 'tol': 0.0001}
2023-08-22 08:20:02,066:INFO:Creating Dashboard logs
2023-08-22 08:20:02,066:INFO:Model: Extra Trees Classifier
2023-08-22 08:20:02,131:INFO:Logged params: {'bootstrap': False, 'ccp_alpha': 0.0, 'class_weight': None, 'criterion': 'gini', 'max_depth': None, 'max_features': 'sqrt', 'max_leaf_nodes': None, 'max_samples': None, 'min_impurity_decrease': 0.0, 'min_samples_leaf': 1, 'min_samples_split': 2, 'min_weight_fraction_leaf': 0.0, 'n_estimators': 100, 'n_jobs': -1, 'oob_score': False, 'random_state': 123, 'verbose': 0, 'warm_start': False}
2023-08-22 08:20:02,737:INFO:Creating Dashboard logs
2023-08-22 08:20:02,737:INFO:Model: Light Gradient Boosting Machine
2023-08-22 08:20:02,806:INFO:Logged params: {'boosting_type': 'gbdt', 'class_weight': None, 'colsample_bytree': 1.0, 'importance_type': 'split', 'learning_rate': 0.1, 'max_depth': -1, 'min_child_samples': 20, 'min_child_weight': 0.001, 'min_split_gain': 0.0, 'n_estimators': 100, 'n_jobs': -1, 'num_leaves': 31, 'objective': None, 'random_state': 123, 'reg_alpha': 0.0, 'reg_lambda': 0.0, 'subsample': 1.0, 'subsample_for_bin': 200000, 'subsample_freq': 0}
2023-08-22 08:20:03,278:INFO:Creating Dashboard logs
2023-08-22 08:20:03,291:INFO:Model: Dummy Classifier
2023-08-22 08:20:03,367:INFO:Logged params: {'constant': None, 'random_state': 123, 'strategy': 'prior'}
2023-08-22 08:20:03,852:INFO:Creating Dashboard logs
2023-08-22 08:20:03,859:INFO:Model: Ada Boost Classifier
2023-08-22 08:20:03,918:INFO:Logged params: {'algorithm': 'SAMME.R', 'base_estimator': 'deprecated', 'estimator': None, 'learning_rate': 1.0, 'n_estimators': 50, 'random_state': 123}
2023-08-22 08:20:04,399:INFO:Creating Dashboard logs
2023-08-22 08:20:04,414:INFO:Model: Gradient Boosting Classifier
2023-08-22 08:20:04,475:INFO:Logged params: {'ccp_alpha': 0.0, 'criterion': 'friedman_mse', 'init': None, 'learning_rate': 0.1, 'loss': 'log_loss', 'max_depth': 3, 'max_features': None, 'max_leaf_nodes': None, 'min_impurity_decrease': 0.0, 'min_samples_leaf': 1, 'min_samples_split': 2, 'min_weight_fraction_leaf': 0.0, 'n_estimators': 100, 'n_iter_no_change': None, 'random_state': 123, 'subsample': 1.0, 'tol': 0.0001, 'validation_fraction': 0.1, 'verbose': 0, 'warm_start': False}
2023-08-22 08:20:05,040:INFO:Creating Dashboard logs
2023-08-22 08:20:05,040:INFO:Model: Decision Tree Classifier
2023-08-22 08:20:05,116:INFO:Logged params: {'ccp_alpha': 0.0, 'class_weight': None, 'criterion': 'gini', 'max_depth': None, 'max_features': None, 'max_leaf_nodes': None, 'min_impurity_decrease': 0.0, 'min_samples_leaf': 1, 'min_samples_split': 2, 'min_weight_fraction_leaf': 0.0, 'random_state': 123, 'splitter': 'best'}
2023-08-22 08:20:05,671:INFO:_master_model_container: 14
2023-08-22 08:20:05,671:INFO:_display_container: 2
2023-08-22 08:20:05,671:INFO:GaussianNB(priors=None, var_smoothing=1e-09)
2023-08-22 08:20:05,672:INFO:compare_models() successfully completed......................................
2023-08-22 08:20:22,051:INFO:Initializing plot_model()
2023-08-22 08:20:22,051:INFO:plot_model(plot=auc, fold=None, verbose=True, display=None, display_format=None, estimator=GaussianNB(priors=None, var_smoothing=1e-09), feature_name=None, fit_kwargs=None, groups=None, label=False, plot_kwargs=None, save=False, scale=1, self=<pycaret.classification.oop.ClassificationExperiment object at 0x00000172522BAA90>, system=True)
2023-08-22 08:20:22,051:INFO:Checking exceptions
2023-08-22 08:20:22,065:INFO:Preloading libraries
2023-08-22 08:20:22,065:INFO:Copying training dataset
2023-08-22 08:20:22,065:INFO:Plot type: auc
2023-08-22 08:20:22,325:INFO:Fitting Model
2023-08-22 08:20:22,325:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\sklearn\base.py:439: UserWarning: X does not have valid feature names, but GaussianNB was fitted with feature names
  warnings.warn(

2023-08-22 08:20:22,325:INFO:Scoring test/hold-out set
2023-08-22 08:20:22,680:INFO:Visual Rendered Successfully
2023-08-22 08:20:22,761:INFO:plot_model() successfully completed......................................
2023-08-22 08:20:28,563:INFO:Initializing plot_model()
2023-08-22 08:20:28,563:INFO:plot_model(plot=confusion_matrix, fold=None, verbose=True, display=None, display_format=None, estimator=GaussianNB(priors=None, var_smoothing=1e-09), feature_name=None, fit_kwargs=None, groups=None, label=False, plot_kwargs=None, save=False, scale=1, self=<pycaret.classification.oop.ClassificationExperiment object at 0x00000172522BAA90>, system=True)
2023-08-22 08:20:28,564:INFO:Checking exceptions
2023-08-22 08:20:28,572:INFO:Preloading libraries
2023-08-22 08:20:28,573:INFO:Copying training dataset
2023-08-22 08:20:28,574:INFO:Plot type: confusion_matrix
2023-08-22 08:20:28,788:INFO:Fitting Model
2023-08-22 08:20:28,788:WARNING:C:\Users\prvzs\anaconda3\envs\churn_prediction\lib\site-packages\sklearn\base.py:439: UserWarning: X does not have valid feature names, but GaussianNB was fitted with feature names
  warnings.warn(

2023-08-22 08:20:28,788:INFO:Scoring test/hold-out set
2023-08-22 08:20:28,993:INFO:Visual Rendered Successfully
2023-08-22 08:20:29,072:INFO:plot_model() successfully completed......................................
2023-08-22 08:20:33,458:INFO:Initializing plot_model()
2023-08-22 08:20:33,458:INFO:plot_model(plot=boundary, fold=None, verbose=True, display=None, display_format=None, estimator=GaussianNB(priors=None, var_smoothing=1e-09), feature_name=None, fit_kwargs=None, groups=None, label=False, plot_kwargs=None, save=False, scale=1, self=<pycaret.classification.oop.ClassificationExperiment object at 0x00000172522BAA90>, system=True)
2023-08-22 08:20:33,458:INFO:Checking exceptions
2023-08-22 08:20:33,467:INFO:Preloading libraries
2023-08-22 08:20:33,467:INFO:Copying training dataset
2023-08-22 08:20:33,468:INFO:Plot type: boundary
2023-08-22 08:20:33,594:INFO:Fitting StandardScaler()
2023-08-22 08:20:33,609:INFO:Fitting PCA()
2023-08-22 08:20:33,798:INFO:Fitting Model
2023-08-22 08:20:35,092:INFO:Visual Rendered Successfully
2023-08-22 08:20:35,253:INFO:plot_model() successfully completed......................................
2023-08-22 08:20:35,296:INFO:Initializing plot_model()
2023-08-22 08:20:35,296:INFO:plot_model(plot=feature, fold=None, verbose=True, display=None, display_format=None, estimator=GaussianNB(priors=None, var_smoothing=1e-09), feature_name=None, fit_kwargs=None, groups=None, label=False, plot_kwargs=None, save=False, scale=1, self=<pycaret.classification.oop.ClassificationExperiment object at 0x00000172522BAA90>, system=True)
2023-08-22 08:20:35,297:INFO:Checking exceptions
2023-08-22 08:22:09,802:INFO:Initializing save_model()
2023-08-22 08:22:09,802:INFO:save_model(model=GaussianNB(priors=None, var_smoothing=1e-09), model_name=outputs\model, prep_pipe_=Pipeline(memory=FastMemory(location=C:\Users\prvzs\AppData\Local\Temp\joblib),
         steps=[('label_encoding',
                 TransformerWrapperWithInverse(exclude=None, include=None,
                                               transformer=LabelEncoder())),
                ('numerical_imputer',
                 TransformerWrapper(exclude=None,
                                    include=['SeniorCitizen', 'tenure',
                                             'MonthlyCharges'],
                                    transformer=SimpleImputer(add_indicator=False,
                                                              copy=True,
                                                              f...
                                                              handle_unknown='value',
                                                              return_df=True,
                                                              use_cat_names=True,
                                                              verbose=0))),
                ('rest_encoding',
                 TransformerWrapper(exclude=None, include=['TotalCharges'],
                                    transformer=TargetEncoder(cols=['TotalCharges'],
                                                              drop_invariant=False,
                                                              handle_missing='return_nan',
                                                              handle_unknown='value',
                                                              hierarchy=None,
                                                              min_samples_leaf=20,
                                                              return_df=True,
                                                              smoothing=10,
                                                              verbose=0)))],
         verbose=False), verbose=True, use_case=MLUsecase.CLASSIFICATION, kwargs={})
2023-08-22 08:22:09,802:INFO:Adding model into prep_pipe
2023-08-22 08:22:50,157:INFO:Initializing save_model()
2023-08-22 08:22:50,157:INFO:save_model(model=GaussianNB(priors=None, var_smoothing=1e-09), model_name=outputs\model, prep_pipe_=Pipeline(memory=FastMemory(location=C:\Users\prvzs\AppData\Local\Temp\joblib),
         steps=[('label_encoding',
                 TransformerWrapperWithInverse(exclude=None, include=None,
                                               transformer=LabelEncoder())),
                ('numerical_imputer',
                 TransformerWrapper(exclude=None,
                                    include=['SeniorCitizen', 'tenure',
                                             'MonthlyCharges'],
                                    transformer=SimpleImputer(add_indicator=False,
                                                              copy=True,
                                                              f...
                                                              handle_unknown='value',
                                                              return_df=True,
                                                              use_cat_names=True,
                                                              verbose=0))),
                ('rest_encoding',
                 TransformerWrapper(exclude=None, include=['TotalCharges'],
                                    transformer=TargetEncoder(cols=['TotalCharges'],
                                                              drop_invariant=False,
                                                              handle_missing='return_nan',
                                                              handle_unknown='value',
                                                              hierarchy=None,
                                                              min_samples_leaf=20,
                                                              return_df=True,
                                                              smoothing=10,
                                                              verbose=0)))],
         verbose=False), verbose=True, use_case=MLUsecase.CLASSIFICATION, kwargs={})
2023-08-22 08:22:50,157:INFO:Adding model into prep_pipe
2023-08-22 08:22:50,203:INFO:outputs\model.pkl saved in current working directory
2023-08-22 08:22:50,450:INFO:Pipeline(memory=FastMemory(location=C:\Users\prvzs\AppData\Local\Temp\joblib),
         steps=[('label_encoding',
                 TransformerWrapperWithInverse(exclude=None, include=None,
                                               transformer=LabelEncoder())),
                ('numerical_imputer',
                 TransformerWrapper(exclude=None,
                                    include=['SeniorCitizen', 'tenure',
                                             'MonthlyCharges'],
                                    transformer=SimpleImputer(add_indicator=False,
                                                              copy=True,
                                                              f...
                                                              verbose=0))),
                ('rest_encoding',
                 TransformerWrapper(exclude=None, include=['TotalCharges'],
                                    transformer=TargetEncoder(cols=['TotalCharges'],
                                                              drop_invariant=False,
                                                              handle_missing='return_nan',
                                                              handle_unknown='value',
                                                              hierarchy=None,
                                                              min_samples_leaf=20,
                                                              return_df=True,
                                                              smoothing=10,
                                                              verbose=0))),
                ('trained_model',
                 GaussianNB(priors=None, var_smoothing=1e-09))],
         verbose=False)
2023-08-22 08:22:50,451:INFO:save_model() successfully completed......................................