Teradata Package for Python Function Reference | 20.00 - fit - Teradata Package for Python - Look here for syntax, methods and examples for the functions included in the Teradata Package for Python.

Teradata® Package for Python Function Reference - 20.00

Deployment
VantageCloud
VantageCore
Edition
Enterprise
IntelliFlex
VMware
Product
Teradata Package for Python
Release Number
20.00
Published
March 2024
Language
English (United States)
Last Update
2024-04-10
dita:id
TeradataPython_FxRef_Enterprise_2000
Product Category
Teradata Vantage
teradataml.hyperparameter_tuner.optimizer.RandomSearch.fit = fit(self, data=None, evaluation_metric=None, early_stop=None, frac=0.8, run_parallel=True, wait=True, verbose=0, **kwargs)
DESCRIPTION:
    Function to run the teradataml analytic function for all sets of 
    hyperparameters. Sets of hyperparameters chosen for execution
    from the parameter grid were the parameter grid is populated 
    based on search algorithm.
    Notes:
        * In the Model trainer function, the best parameters are 
          selected based on training results.
        * In the Non model trainer function, First execution parameter
          set is selected as the best parameters.
 
PARAMETERS:
    data:
        Optional Argument.
        Specifies the input teradataml DataFrame for model trainer function.
        Notes:
            * DataFrame need not to be passed in fit() methods, when "data" is 
              passed as a model hyperparameters ("params"). 
            * "data" is a required argument for model trainer functions.
            * "data" is ignored for non-model trainer functions.
            * "data" can be contain single DataFrame or multiple DataFrame.
            * One can pass multiple dataframes to "data". Hyperparameter 
              tuning is performed on all the dataframes for every model 
              parameter.
            * "data" can be either a dictionary OR a tuple OR a dataframe.
                * If it is a dictionary then Key represents the label for 
                  dataframe and Value represents the dataframe.
                * If it is a tuple then teradataml converts it to dictionary
                  by generating the labels internally.
                * If it is a dataframe then teradataml label it as "DF_0".
        Types: teradataml DataFrame, dictionary, tuples
 
    evaluation_metric:
        Optional Argument.
        Specifies the evaluation metrics to considered for model 
        evaluation.
        Notes:
            * evaluation_metric applicable for model trainer functions.
            * Best model is not selected when evaluation returns 
              non-finite values.
        Permitted Values:
            * Classification: Accuracy, Micro-Precision, Micro-Recall,
                              Micro-F1, Macro-Precision, Macro-Recall,
                              Macro-F1, Weighted-Precision, 
                              Weighted-Recall,
                              Weighted-F1.
            * Regression: MAE, MSE, MSLE, MAPE, MPE, RMSE, RMSLE, ME, 
                          R2, EV, MPD, MGD
            
        Default Value:
            * Classification: Accuracy
            * Regression: MAE
        Types: str
 
    early_stop:
        Optional Argument.
        Specifies the early stop mechanism value for model trainer 
        functions. Hyperparameter tuning ends model training when 
        the training model evaluation metric attains "early_stop" value.
        Note:
            * Early stopping supports only when evaluation returns 
              finite value.
        Types: int or float
 
    frac:
        Optional Argument.
        Specifies the split percentage of rows to be sampled for training 
        and testing dataset. "frac" argument value must range between (0, 1).
        Notes: 
            * This "frac" argument is not supported for non-model trainer 
              function.
            * The "frac" value is considered as train split percentage and 
              The remaining percentage is taken into account for test splitting.
        Default Value: 0.8
        Types: float
    
    run_parallel:
        Optional Argument.
        Specifies the parallel execution functionality of hyperparameter 
        tuning. When "run_parallel" set to true, model functions are 
        executed concurrently. Otherwise, model functions are executed 
        sequentially.
        Note:
            * Early stopping is not supported when parallel run is 
              enabled.
        Default Value: True
        Types: bool
    
    wait:
        Optional Argument.
        Specifies whether to wait for the completion of execution 
        of hyperparameter tuning or not. When set to False, hyperparameter 
        tuning is executed in the background and user can use "is_running()" 
        method to check the status. Otherwise it waits until the execution 
        is complete to return the control back to user.
        Default Value: True
        Type: bool
 
    verbose:
        Optional Argument.
        Specifies whether to log the model training information and display 
        the logs. When it is set to 1, progress bar alone logged in the 
        console. When it is set to 2, along with progress bar, execution 
        steps and execution time is logged in the console. When it is set 
        to 0, nothing is logged in the console. 
        Note:
            * verbose is not significant when "wait" is 'False'.
        Default Value: 0
        Type: bool
 
    kwargs:
        Optional Argument.
        Specifies the keyword arguments. Accepts additional arguments 
        required for the teradataml analytic function.
 
RETURNS:
    None
 
RAISES:
    TeradataMlException, TypeError, ValueError
 
EXAMPLES:
    >>> # Create an instance of the RandomSearch algorithm called "optimizer_obj" 
    >>> optimizer_obj = RandomSearch(func=SVM, params=params, n_iter=3)
 
    >>> eval_params = {"id_column": "id",
                       "accumulate": "MedHouseVal"}
    >>> # Example 1: Passing single DataFrame for model trainer function.
    >>> optimizer_obj.fit(data=train_df,
                          evaluation_metric="MAE",
                          early_stop=70.9,
                          **eval_params)
    
    >>> # Example 2: Passing multiple datasets as tuple of DataFrames for 
    >>> #            model trainer function.
    >>> optimizer_obj.fit(data=(train_df_1, train_df_2),
                          evaluation_metric="MAE",
                          early_stop=70.9,
                          **eval_params)  
    
    >>> # Example 3: Passing multiple datasets as dictionary of DataFrames 
    >>> #            for model trainer function.
    >>> optimizer_obj.fit(data={"Data-1":train_df_1, "Data-2":train_df_2},
                          evaluation_metric="MAE",
                          early_stop=70.9,
                          **eval_params)  
 
    >>> # Example 4: No data argument passed in fit() method for model trainer function.
    >>> #            Note: data argument must be passed while creating HPT object as 
    >>> #                  model hyperparameters.
    
    >>> # Define parameter space for model training with "data" argument.
    >>> params = {"data":(df1, df2),
                  "input_columns":['MedInc', 'HouseAge', 'AveRooms',
                                   'AveBedrms', 'Population', 'AveOccup',
                                   'Latitude', 'Longitude'],
                  "response_column":"MedHouseVal",
                  "model_type":"regression",
                  "batch_size":(11, 50, 75),
                  "iter_max":(100, 301),
                  "intercept":False,
                  "learning_rate":"INVTIME",
                  "nesterov_optimization":True,
                  "local_sgd_iterations":1}
    
    >>> # Create "optimizer_obj" using RandomSearch algorithm and perform 
    >>> # fit() method without any "data" argument for model trainer function.
    >>> optimizer_obj.fit(evaluation_metric="MAE",
                          early_stop=70.9,
                          **eval_params) 
 
    >>> # Example 5: Do not pass data argument in fit() method for 
    >>> #            non-model trainer function.
    >>> #            Note: data argument must be passed while creating HPT  
    >>> #                  object as model hyperparameters.
    >>> optimizer_obj.fit() 
 
    >>> # Example 6: Passing "verbose" argument value '1' in fit() method to 
    >>> #            display model log.
    >>> optimizer_obj.fit(data=train_df, evaluation_metric="R2",
                          verbose=1, **eval_params)
        completed: |████████████████████████████████████████████████████████████| 100% - 6/6