teradataml 17.20.0.7__py3-none-any.whl → 20.0.0.0__py3-none-any.whl

teradataml/analytics/json_parser/utils.py

@@ -1,803 +1,804 @@
-"""
-Unpublished work.
-Copyright (c) 2021 by Teradata Corporation. All rights reserved.
-TERADATA CORPORATION CONFIDENTIAL AND TRADE SECRET
-
-Primary Owner: pradeep.garre@teradata.com, gouri.patwardhan@teradata.com
-Secondary Owner: PankajVinod.Purandare@teradata.com
-
-This file implements the helper methods and classes which are required to
-process In-DB Functions.
-"""
-
-from teradataml.options.configure import configure
-from teradataml.analytics.json_parser.json_store import _JsonStore
-from teradataml.analytics.json_parser.metadata import _AnlyFuncMetadata, _AnlyFuncMetadataUAF
-from teradataml.common.constants import TeradataAnalyticFunctionTypes, TeradataAnalyticFunctionInfo
-from teradataml.common.exceptions import TeradataMlException
-from teradataml.common.messages import Messages
-from teradataml.common.messagecodes import MessageCodes
-import json, os, importlib
-from teradataml import UtilFuncs
-from teradataml.common.formula import Formula
-from teradataml.utils.validators import _Validators
-from teradataml.dataframe.dataframe_utils import DataFrameUtils as df_utils
-
-# Map to store IN-DB function type and JSON directory for current database version.
-func_type_json_version = {}
-module = importlib.import_module("teradataml")
-
-def _get_json_data_from_tdml_repo():
-    """
-    DESCRIPTION:
-        An internal function to parse the json files stored in teradataml repo. This function,
-        first checks whether the version of json store is same as database version.
-        If both versions are same, it then returns an empty list, i.e., the framework
-        will neither parse the json files nor generate the SQLE functions. Otherwise cleans
-        the json store and parses the json files in the corresponding directory and adds
-        the json data to json store.
-
-    PARAMETERS:
-        None.
-
-    RAISES:
-        None.
-
-    RETURNS:
-        An iterator of _AnlyFuncMeta object OR list
-
-    EXAMPLES:
-        >>> _get_json_data_from_tdml_repo()
-    """
-
-    # Check if the json store version is matched with Vantage database version. If
-    # both versions are matched, then the json store has data available so no need
-    # to parse again.
-    if configure.database_version != _JsonStore.version:
-
-        # Json store version is different from database version. So, json's should
-        # be parsed again. Before parsing the json, first clean the json store.
-        _JsonStore.clean()
-
-        # Set the json store version to current database version.
-        _JsonStore.version = configure.database_version
-
-        # Clean existing map between IN-DB function type and corresponding JSON directory.
-        func_type_json_version.clear()
-
-        # Load the mapping information for all analytic functions which are version dependent into _JsonStore.
-        _load_anlyfuncs_jsons_versions_info()
-
-        json_file_directories = __get_json_files_directory()
-
-        # For the corresponding database version, if teradataml does not have any json
-        # files, then return an empty list. So framework will not attach any SQLE function
-        # to teradataml.
-        if not json_file_directories:
-            return []
-
-        # Read the directory, parse the json file and add the _AnlyFuncMeta object to json store
-        # and yield the same.
-        for json_file_directory_list in json_file_directories:
-            # Get the function type
-            func_type = json_file_directory_list[1]
-            # Get the json directory
-            json_file_directory = json_file_directory_list[0]
-
-            # Get the appropriate metadata class.
-            metadata_class = getattr(TeradataAnalyticFunctionInfo, func_type).value.get("metadata_class",
-                                                                                        "_AnlyFuncMetadata")
-            metadata_class = eval(metadata_class)
-
-            for json_file in os.listdir(json_file_directory):
-                file_path = os.path.join(json_file_directory, json_file)
-                with open(file_path, encoding="utf-8") as fp:
-                    json_data = json.load(fp)
-                    metadata = metadata_class(json_data, file_path, func_type=func_type)
-
-                    # Functions which do not need to participate in IN-DB Framework
-                    # should not be stored in _JsonStore.
-                    if metadata.func_name in _JsonStore._functions_to_exclude:
-                        continue
-                    _JsonStore.add(metadata)
-                    yield metadata
-
-    # If both database version and json store version are same, return an empty list so that
-    # framework will not attach any SQLE function to teradataml.
-    else:
-        return []
-
-
-def _load_anlyfuncs_jsons_versions_info():
-    """
-    DESCRIPTION:
-        Function populates following information for analytic functions:
-            * Lowest supported version.
-            * Parent directory containing JSONs.
-            * Nearest matching JSON directory for a particular database version.
-
-    PARAMETERS:
-        None
-
-    RETURNS:
-        None
-
-    RAISES:
-        None
-
-    EXAMPLES:
-        >>> _load_anlyfuncs_jsons_versions_info()
-    """
-    # Import the required package.
-    import re
-    # Get the closest matching JSON directory out of all directories corresponding
-    # to JSONs of different version.
-    # First remove any letters present in the version
-    temp_db_version = re.sub(r'[a-zA-Z]', r'', configure.database_version)
-    db_version = float(temp_db_version[:5])
-    for func_info in TeradataAnalyticFunctionInfo:
-        func_type = func_info.value["func_type"]
-        func_base_version = func_info.value["lowest_version"]
-        parent_dir = UtilFuncs._get_data_directory(dir_name="jsons",
-                                                   func_type=func_info)
-        if func_base_version:
-            if db_version >= float(func_base_version):
-                closest_version = _get_closest_version_json_dir(parent_dir, db_version)
-                if closest_version:
-                    func_type_json_version[func_type] = closest_version
-
-
-def __get_json_files_directory():
-    """
-    DESCRIPTION:
-        An internal function to get the corresponding directory name, which
-        contains the json files.
-
-    PARAMETERS:
-        None.
-
-    RAISES:
-        None.
-
-    RETURNS:
-        list
-
-    EXAMPLES:
-        >>> __get_json_files_directory()
-    """
-    # If function has version specific JSON directory, return it by using mapping information in
-    # _Jsonstore else return common JSON directory.
-    for func_info in TeradataAnalyticFunctionInfo:
-        if func_info.value["lowest_version"]:
-            # Check if current function type is allowed on connected Vantage version or not.
-            if func_info.value["func_type"] in func_type_json_version.keys():
-                yield [UtilFuncs._get_data_directory(dir_name="jsons", func_type=func_info,
-                                                    version=func_type_json_version[func_info.value["func_type"]]),
-                       func_info.name]
-        else:
-            yield [UtilFuncs._get_data_directory(dir_name="jsons", func_type=func_info), func_info.name]
-
-
-def _get_closest_version_json_dir(parent_dir, database_version):
-    """
-    DESCRIPTION:
-        Internal function to get the nearest matching JSON directory for a database
-        version from the available JSON directories for the functions.
-
-    PARAMETERS:
-        parent_dir:
-            Required Argument.
-            Specifies the parent dirctory for JSONs of all teradataml version.
-            Types: str
-
-        database_version:
-            Required Argument.
-            Specifies the database version.
-            Types: float
-
-    RAISES:
-        None.
-
-    RETURNS:
-        str
-
-    EXAMPLES:
-        >>> _get_closest_version_json_dir("path_to_teradataml/teradataml/analytics/jsons/sqle", 17.10)
-    """
-    # Get the exact matching JSON directory name for current database version.
-    # If matching directory exists, return it.
-    matching_dir = format(database_version, '.2f')
-    if matching_dir in os.listdir(parent_dir):
-        return matching_dir
-
-    # If exact matching JSON directory is not found,
-    # return the directory corresponding to the closest lower version.
-    # List all the directories, not the files, and collect lower versions only.
-    lower_versions = (json_dir for json_dir in os.listdir(parent_dir)
-                      if (os.path.isdir(os.path.join(parent_dir, json_dir))
-                          and float(json_dir) <= database_version))
-
-    # If generator generates non-empty list, return max of all versions from that list,
-    # else while an empty list is passed to max() it throws ValueError, so return None.
-    try:
-        return max(lower_versions)
-    except ValueError:
-        return None
-
-def _process_paired_functions():
-    """
-    DESCRIPTION:
-        Process and reads the paired function json.
-
-    PARAMETERS:
-        None.
-
-    RETURNS:
-        None.
-    """
-
-    json_path = os.path.join(UtilFuncs._get_data_directory(), "jsons", "paired_functions.json")
-    with open(json_path) as fp:
-        _json = json.load(fp)
-
-    _available_functions, _ = _JsonStore._get_function_list()
-    for func_type, funcs in _json.items():
-        # ToDo: Add support for VAL functions
-        if func_type == "VAL":
-            continue
-        # Set all paired functions for SQLE and UAF.
-        for func in funcs:
-            # Check if function is existed in JSonStore or not. If exists, only
-            # then process it.
-            if func in _available_functions:
-                metadata = _JsonStore.get_function_metadata(func)
-                metadata.set_paired_functions(funcs.get(func))
-
-class _UAF_paired_function:
-    """
-    Parent class for _Inverse, _Convolve, _Forecast and _Validate.
-    """
-    def _process_arguments(self, function_relation, **kwargs):
-        """
-        DESCRIPTION:
-            Method instantiate the reference function based on 'function_relation'.
-
-        PARAMETERS:
-            function_relation:
-                defines which method to instantiate.
-
-            **kwargs:
-                Keyword arguments passed based on 'function_relation'.
-
-        RETURNS:
-            object of the reference function.
-        """
-        metadata = _JsonStore.get_function_metadata(self.__class__.__name__)
-        paired_functions = metadata.get_paired_functions()
-        paired_function = \
-            [fun_relation for fun_relation in paired_functions
-             if fun_relation.function_relation == function_relation][0]
-        reference_function = paired_function.reference_function
-        for _inp, _out in paired_function.arguments:
-            kwargs[_inp] = getattr(self, _out)
-        input_art_spec = {'data': kwargs[paired_function.input_arguments[0]]}
-        if self.__class__.__name__ == "SeasonalNormalize":
-            input_art_spec['layer'] = "ARTMETADATA"
-        kwargs[paired_function.input_arguments[0]] = \
-            getattr(module, "TDAnalyticResult")(**input_art_spec)
-        return getattr(module, reference_function)(**kwargs)
-
-
-class _Convolve(_UAF_paired_function):
-    """
-    class to convolve the uaf function.
-    """
-    def convolve(self, **kwargs):
-        """
-        DESCRIPTION:
-            Method to convolve the uaf function used by instance created from below functions:
-                * DFFT
-                * DFFT2
-
-        PARAMETERS:
-            **kwargs:
-                Keyword arguments passed to the convolve method.
-                Notes:
-                    * Every function can have different arguments.
-                    * This arguments are based on inverse functions.
-
-        RETURNS:
-            object of the reference function.
-
-        EXAMPLE:
-            load_example_data("uaf", ["dfft2conv_real_4_4"])
-            data = DataFrame.from_table("dfft2conv_real_4_4")
-            td_matrix = TDMatrix(data=data,
-                                 id="id",
-                                 row_index="row_i",
-                                 row_index_style="SEQUENCE",
-                                 column_index="column_i",
-                                 column_index_style="SEQUENCE",
-                                 payload_field="magnitude",
-                                 payload_content="REAL")
-            filter_expr = td_matrix.id==33
-            dfft2_out = DFFT2(data=td_matrix,
-                              data_filter_expr=filter_expr,
-                              freq_style="K_INTEGRAL",
-                              human_readable=False,
-                              output_fmt_content="COMPLEX")
-            convolve_output = dfft2_out.convolve(conv="HR_TO_RAW",
-                                                 output_fmt_content="AMPL_PHASE_RADIANS")
-        """
-        return self._process_arguments("convolve", **kwargs)
-
-class _Inverse(_UAF_paired_function):
-    """
-    class to inverse the effects of uaf function.
-    """
-    def inverse(self, **kwargs):
-        """
-        DESCRIPTION:
-            Method to inverse the effect of uaf function used by instance created from below functions:
-                * DIFF
-                * UNDIFF
-                * DFFT
-                * IDFFT
-                * DFFT2
-                * IDFFT2
-                * SeasonalNormalize
-
-        PARAMETERS:
-            **kwargs:
-                Keyword arguments passed to the inverse method.
-                Notes:
-                    * Every function can have different arguments.
-                    * This arguments are based on inverse functions.
-
-        RETURNS:
-            object of the reference function.
-
-        EXAMPLE:
-            load_example_data("uaf", "mvdfft8")
-            data = DataFrame.from_table("mvdfft8")
-            data_series_df = TDSeries(data=data,
-                                 id="sid",
-                                 row_index="n_seqno",
-                                 row_index_style="SEQUENCE",
-                                 payload_field="magnitude1",
-                                 payload_content="REAL")
-            DFFT_result = DFFT(data=data_series_df,
-                           human_readable=True,
-                           output_fmt_content='COMPLEX')
-            inverse_output = DFFT_result.inverse()
-        """
-        return self._process_arguments("inverse", **kwargs)
-
-
-class _Forecast(_UAF_paired_function):
-    """
-    Class to forecast the model trainer object
-    """
-    def forecast(self, **kwargs):
-        """
-        DESCRIPTION:
-            Method to forecast the model trainer object and instantiate
-            the reference function.
-
-        PARAMETERS:
-            **kwargs:
-                Keyword arguments passed to the forecast method.
-                Notes:
-                    * Every function can have different arguments.
-                    * This arguments are based on forecast functions.
-
-        RETURNS:
-            object of the reference function which are:
-            * result
-
-        EXAMPLE:
-            load_example_data("uaf", ["timeseriesdatasetsd4"])
-            data = DataFrame.from_table("timeseriesdatasetsd4")
-            data_series_df = TDSeries(data=data,
-                                      id="dataset_id",
-                                      row_index="seqno",
-                                      row_index_style="SEQUENCE",
-                                      payload_field="magnitude",
-                                      payload_content="REAL")
-            arima_estimate_op = ArimaEstimate(data1=data_series_df,
-                                              nonseasonal_model_order=[2,0,0],
-                                              constant=False,
-                                              algorithm="MLE",
-                                              coeff_stats=True,
-                                              fit_metrics=True,
-                                              residuals=True,
-                                              fit_percentage=100)
-            arima_estimate_op.forecast(forecast_periods=2)
-        """
-        return self._process_arguments("forecast", **kwargs)
-
-class _Validate(_UAF_paired_function):
-    """
-    Class to validate the model trainer object
-    """
-    def validate(self, **kwargs):
-        """
-        DESCRIPTION:
-            Method to validate the model trainer object and instantiate
-            the reference function.
-
-        PARAMETERS:
-            **kwargs:
-                Keyword arguments passed to the validate method.
-                Note:
-                    * Every function can have different arguments.
-                    * This arguments are based on validate functions.
-
-        RETURNS:
-            object of the reference function which are:
-            * result
-            * fitmetadata
-            * fitresiduals
-            * model
-
-        EXAMPLE:
-            load_example_data("uaf", ["timeseriesdatasetsd4"])
-            data = DataFrame.from_table("timeseriesdatasetsd4")
-            data_series_df = TDSeries(data=data,
-                                      id="dataset_id",
-                                      row_index="seqno",
-                                      row_index_style="SEQUENCE",
-                                      payload_field="magnitude",
-                                      payload_content="REAL")
-            arima_estimate_op = ArimaEstimate(data1=data_series_df,
-                                              nonseasonal_model_order=[2,0,0],
-                                              constant=False,
-                                              algorithm="MLE",
-                                              coeff_stats=True,
-                                              fit_metrics=True,
-                                              residuals=True,
-                                              fit_percentage=80)
-            arima_estimate_op.validate(residuals=True)
-        """
-        return self._process_arguments("validate", **kwargs)
-
-class _Transform:
-    def transform(self, **kwargs):
-        """
-        DESCRIPTION:
-            Method to transform the model trainer object and instantiate
-            the reference function.
-
-        PARAMETERS:
-            **kwargs:
-                Keyword arguments passed to the transform method.
-
-        RETURNS:
-            object of the reference function.
-
-        EXAMPLES:
-            fit_df = Fit(data=iris_input,
-                         object=transformation_df,
-                         object_order_column='TargetColumn'
-                         )
-
-            fit_df.transform(data=iris_input)
-        """
-        metadata = _JsonStore.get_function_metadata(self.__class__.__name__)
-        paired_functions = metadata.get_paired_functions()
-        paired_function = [f for f in paired_functions if f.function_relation == "transform"][0]
-        reference_function = paired_function.reference_function
-        for _inp, _out in paired_function.arguments:
-            kwargs[_inp] = getattr(self, _out)
-        return getattr(module, reference_function)(**kwargs)
-
-class _Predict:
-    def predict(self, **kwargs):
-        """
-        DESCRIPTION:
-            Method to predict the model trainer object and instantiate
-            the reference function.
-
-        PARAMETERS:
-            **kwargs:
-                Keyword arguments passed to the transform method.
-
-        RETURNS:
-            object of the reference function.
-
-        EXAMPLE:
-            svm_obj = SVM(data=transform_obj.result,
-                           input_columns=['MedInc', 'HouseAge', 'AveRooms',
-                                          'AveBedrms', 'Population', 'AveOccup',
-                                          'Latitude', 'Longitude'],
-                           response_column="MedHouseVal",
-                           model_type="Regression"
-                           )
-
-            svm_obj.predict(newdata = transform_obj.result,
-                            id_column = "id"
-                            )
-        """
-        metadata = _JsonStore.get_function_metadata(self.__class__.__name__)
-        paired_functions = metadata.get_paired_functions()
-        paired_function = [f for f in paired_functions if f.function_relation == "predict"][0]
-        reference_function = paired_function.reference_function
-        for _inp, _out in paired_function.arguments:
-            kwargs[_inp] = getattr(self, _out)
-        return getattr(module, reference_function)(**kwargs)
-
-
-class _KNNPredict:
-    def predict(self, **kwargs):
-        """
-        DESCRIPTION:
-            Method to predict the KNN model trainer object and instantiate
-            the reference function.
-
-        PARAMETERS:
-            **kwargs:
-                Keyword arguments passed to the transform method.
-
-        RETURNS:
-            object of the reference function.
-
-        EXAMPLE:
-            KNN_out = KNN(train_data=computers_train1_encoded.result.iloc[:100],
-                      test_data=computers_train1_encoded.result.iloc[10:],
-                      id_column="id",
-                      input_columns=["screen", "price", "speed", "hd"],
-                      model_type="REGRESSION",
-                      response_column="computer_category_special")
-
-            res = KNN_out.evaluate(test_data=computers_train1_encoded.result.iloc[10:])
-        """
-        # response_column is required when the model_type is classification or regression.
-        # accumulate is optional in case user specifies accumulate then consider the value specified by the user,
-        # else consider the value specified for response_column.
-
-        params = {"test_data": kwargs.get("test_data"),
-                  "id_column": self.id_column,
-                  "voting_weight": self.voting_weight,
-                  "k": self.k,
-                  "tolerance": self.tolerance,
-                  "output_prob": self.output_prob,
-                  "output_responses": self.output_responses,
-                  "emit_neighbors": self.emit_neighbors,
-                  "emit_distances": self.emit_distances,
-                  "train_data": self.train_data,
-                  "input_columns": self.input_columns,
-                  "model_type": self.model_type,
-                  "response_column": kwargs.get("response_column", self.response_column),
-                  "accumulate": kwargs.get("accumulate", kwargs.get("response_column", self.response_column)
-                                if getattr(self.obj, "accumulate") is None else self.accumulate)}
-
-        return getattr(module, "KNN")(**params)
-
-
-class _Evaluate:
-    """
-    DESCRIPTION:
-        Implements the Classification and Regression evaluator.
-    """
-    _accumulate_args = {"NaiveBayesTextClassifierTrainer": "doc_category_column"}
-
-    # Mapper for mapping function names with argument names
-    _evaluator_function_mapper = {"DecisionForest": "tree_type",
-                                  "GLM": "family",
-                                  "GLMPerSegment": "family",
-                                  "SVM": "model_type",
-                                  "XGBoost": "model_type"}
-
-    def is_classification_model(self, **kwargs):
-        """
-        DESCRIPTION:
-            Returns True if the model is classification model or regression model.
-
-        PARAMETERS:
-            **kwargs:
-                Keyword arguments to access the model_type.
-
-        RETURNS:
-            Boolean.
-        """
-        is_classification_model = False
-
-        # NaiveBayesTextClassifierTrainer takes Multinomial, Bernoulli as input
-        # both comes under classification evaluator
-        if self.get_function_name() == "NaiveBayesTextClassifierTrainer":
-            return True
-        # name of argument is model_type for most of the functions but for some it is different
-        if "model_type" not in kwargs:
-            arg_name = self.get_arg_name()
-            model_type = getattr(self.obj, arg_name)
-            kwargs["model_type"] = model_type
-
-        if kwargs["model_type"].lower() == "binomial" or kwargs["model_type"].lower() == "classification":
-            is_classification_model = True
-
-        return is_classification_model
-
-    def get_function_name(self):
-        """
-        DESCRIPTION:
-            Function to get the name of the analytic function.
-
-        PARAMETERS:
-            None.
-
-        RETURNS:
-            str.
-
-        """
-        return self.__class__.__name__
-
-    def get_response_column(self):
-        """
-        DESCRIPTION:
-            Function to get the argument name for response column. For some functions
-            argument name storing the response column is different, it can
-            be fetched from the '_accumulate_arg' mapping.
-
-        PARAMETER:
-            None.
-
-        RETURNS:
-            str.
-        """
-        # By default it is 'response_column' but some functions require different names.
-        return self._accumulate_args.get(self.get_function_name(), "response_column")
-
-
-
-    def get_arg_name(self):
-        """
-        DESCRIPTION:
-            Function to get the argument name for model type. For some functions argument
-            name can be different, and it can be fetched using the '_evaluator_function_mapper'
-            mapping.
-
-        PARAMETER:
-            None.
-
-        RETURNS:
-            String representing the argument name.
-        """
-        return self._evaluator_function_mapper.get(self.get_function_name(), "model_type")
-
-    def evaluate(self, **kwargs):
-        """
-        DESCRIPTION:
-            Method to evaluate the model trainer object, using
-            either the classification or regression evaluator and
-            instantiate the reference function.
-
-        PARAMETER:
-            **kwargs:
-                Keyword arguments for specified for evaluate method.
-
-        RETURNS:
-            Attribute of Classification Evaluator or Regression Evaluator
-
-        EXAMPLE:
-            svm_obj = SVM(data=transform_obj.result,
-                           input_columns=['MedInc', 'HouseAge', 'AveRooms',
-                                          'AveBedrms', 'Population', 'AveOccup',
-                                          'Latitude', 'Longitude'],
-                           response_column="MedHouseVal",
-                           model_type="Regression"
-                           )
-
-            svm_obj.evaluate(newdata = transform_obj.result,
-                             id_column = "id"
-                             )
-        """
-
-        response_column_arg_name = self.get_response_column()
-        if hasattr(self.obj, response_column_arg_name):
-            response_column = getattr(self.obj, response_column_arg_name)
-        else:
-            # Created formula object to access the response column property of the formula.
-            formula_object = Formula(kwargs["newdata"]._metaexpr, getattr(self.obj, "formula"), "formula")
-            response_column = formula_object.response_column
-
-        # Populate 'accumulate' for predict function so that it will be available in output DataFrame.
-        if "accumulate" not in kwargs:
-            # In case accumulate is not specified by the user set the accumulate as response column.
-            kwargs["accumulate"] = response_column
-        elif response_column not in kwargs["accumulate"]:
-            # Checking if accumulate is passed, and it is not having response column then append response column
-            # to the list of values passed to accumulate.
-            if isinstance(kwargs["accumulate"], str):
-                kwargs["accumulate"] = [kwargs["accumulate"]]
-            kwargs["accumulate"].append(response_column)
-
-        predict = self.predict(**kwargs)
-        is_classification_model = self.is_classification_model(**kwargs)
-
-        if is_classification_model:
-
-            kwargs["observation_column"] = response_column
-            kwargs["prediction_column"] = "Prediction" if "Prediction" in predict.result.columns else "prediction"
-
-            # get the column_names and types from the metaexpr to check if the datatype of prediction column
-            # and observation column is same or not.
-            col_names, col_types = df_utils._get_column_names_and_types_from_metaexpr(predict.result._metaexpr)
-            res = dict(zip(col_names,col_types))
-            pre_col_name = kwargs["prediction_column"]
-            if res[kwargs["observation_column"]] != res[pre_col_name]:
-                # Converting the prediction column datatype to observation column datatype.
-                cast_cols_pre = {pre_col_name: getattr(predict.result, pre_col_name).expression.cast(
-                    type_=res[kwargs["observation_column"]])}
-                # Update the predicted result dataframe.
-                predict.result = predict.result.assign(**cast_cols_pre)
-
-            # Update the num_labels by the number of unique values.
-            kwargs["num_labels"] = predict.result.drop_duplicate(kwargs["observation_column"]).shape[0]
-
-            kwargs["data"] = predict.result
-
-            return getattr(module, "ClassificationEvaluator")(**kwargs)
-        else:
-
-            # Include the two missing metrics FSTAT and AR2, if the user did not pass the freedom_degrees and
-            # independent_features_num then appropriate error message should be displayed.
-
-            # If metrics is specified as "fstat" and "ar2".
-            if 'metrics' in kwargs:
-                metrics_list = [kwargs.get("metrics")] if isinstance(kwargs.get("metrics"), str) else kwargs.get("metrics")
-                metrics_lower_case = {metric : metric.lower() for metric in metrics_list}
-
-                if "fstat" in metrics_lower_case.values():
-                    _Validators._validate_dependent_argument("FSTAT", kwargs.get("metrics"),
-                                                             "freedom_degrees", kwargs.get("freedom_degrees"))
-
-                if "ar2" in metrics_lower_case.values():
-                    _Validators._validate_dependent_argument("AR2", kwargs.get("metrics"),
-                                                             "independent_features_num",
-                                                             kwargs.get("independent_features_num"))
-
-            if kwargs.get("metrics") is None:
-                # If metrics is not specified then evaluate for all metrics except "fstat" and "ar2".
-                metrics_list = ['MAE', 'MSE', 'MSLE', 'MAPE', 'MPE', 'RMSE', 'RMSLE', 'R2', 'EV', 'ME', 'MPD',
-                                'MGD']
-                # If the dependent and optional argument "independent_features_num" is specified then evaluate for AR2
-                # also.
-                if kwargs.get("independent_features_num") is not None:
-                    metrics_list.append("AR2")
-                # If the dependent and optional argument "freedom_degrees" is specified then evaluate for FSTAT also.
-                if kwargs.get("freedom_degrees") is not None:
-                    metrics_list.append("FSTAT")
-                kwargs["metrics"] = metrics_list
-
-            kwargs["data"] = predict.result
-            kwargs["observation_column"] = response_column
-            # The column name for predict result is "Prediction" in some cases and "prediction" in others.
-            kwargs["prediction_column"] = "Prediction" if "Prediction" in predict.result.columns else "prediction"
-
-            return getattr(module, "RegressionEvaluator")(**kwargs)
-
-
-def _get_associated_parent_classes(func_name):
-    # By this time, context is established.
-    json_path = os.path.join(UtilFuncs._get_data_directory(), "jsons", "paired_functions.json")
-    with open(json_path) as fp:
-        paired_functions = json.load(fp)
-    # Get the paired functions for func_name
-    paired_functions = [funcs.get(func_name) for _, funcs in paired_functions.items() if funcs.get(func_name, False)]
-    # paired_func_dict uses mapping between class and model trainer object.
-    paired_func_dict = {"predict": _Predict, "transform": _Transform,
-                        "evaluate": _Evaluate, "forecast": _Forecast,
-                        "validate": _Validate, "convolve": _Convolve,
-                        "inverse": _Inverse}
-    # If paired_functions is empty return empty list
-    if not paired_functions:
-        return []
-    # As there are multiple model trainer object one function can use running a loop to iterate
-    for paired_function in paired_functions[0]:
-
-        # KNN needs a special handling for predict. So, returning a specific class for KNN.
-        if func_name == "KNN" and paired_function == "predict":
-            yield _KNNPredict
-        # Here returning class which is used as parent class for func_name.
-        if paired_function in paired_func_dict:
-            yield paired_func_dict[paired_function]
+"""
+Unpublished work.
+Copyright (c) 2021 by Teradata Corporation. All rights reserved.
+TERADATA CORPORATION CONFIDENTIAL AND TRADE SECRET
+
+Primary Owner: pradeep.garre@teradata.com, gouri.patwardhan@teradata.com
+Secondary Owner: PankajVinod.Purandare@teradata.com
+
+This file implements the helper methods and classes which are required to
+process In-DB Functions.
+"""
+
+from teradataml.options.configure import configure
+from teradataml.analytics.json_parser.json_store import _JsonStore
+from teradataml.analytics.json_parser.metadata import _AnlyFuncMetadata, _AnlyFuncMetadataUAF
+from teradataml.common.constants import TeradataAnalyticFunctionTypes, TeradataAnalyticFunctionInfo
+from teradataml.common.exceptions import TeradataMlException
+from teradataml.common.messages import Messages
+from teradataml.common.messagecodes import MessageCodes
+import json, os, importlib
+from teradataml import UtilFuncs
+from teradataml.common.formula import Formula
+from teradataml.utils.validators import _Validators
+from teradataml.dataframe.dataframe_utils import DataFrameUtils as df_utils
+
+# Map to store IN-DB function type and JSON directory for current database version.
+func_type_json_version = {}
+module = importlib.import_module("teradataml")
+
+def _get_json_data_from_tdml_repo():
+    """
+    DESCRIPTION:
+        An internal function to parse the json files stored in teradataml repo. This function,
+        first checks whether the version of json store is same as database version.
+        If both versions are same, it then returns an empty list, i.e., the framework
+        will neither parse the json files nor generate the SQLE functions. Otherwise cleans
+        the json store and parses the json files in the corresponding directory and adds
+        the json data to json store.
+
+    PARAMETERS:
+        None.
+
+    RAISES:
+        None.
+
+    RETURNS:
+        An iterator of _AnlyFuncMeta object OR list
+
+    EXAMPLES:
+        >>> _get_json_data_from_tdml_repo()
+    """
+
+    # Check if the json store version is matched with Vantage database version. If
+    # both versions are matched, then the json store has data available so no need
+    # to parse again.
+    if configure.database_version != _JsonStore.version:
+
+        # Json store version is different from database version. So, json's should
+        # be parsed again. Before parsing the json, first clean the json store.
+        _JsonStore.clean()
+
+        # Set the json store version to current database version.
+        _JsonStore.version = configure.database_version
+
+        # Clean existing map between IN-DB function type and corresponding JSON directory.
+        func_type_json_version.clear()
+
+        # Load the mapping information for all analytic functions which are version dependent into _JsonStore.
+        _load_anlyfuncs_jsons_versions_info()
+
+        json_file_directories = __get_json_files_directory()
+
+        # For the corresponding database version, if teradataml does not have any json
+        # files, then return an empty list. So framework will not attach any SQLE function
+        # to teradataml.
+        if not json_file_directories:
+            return []
+
+        # Read the directory, parse the json file and add the _AnlyFuncMeta object to json store
+        # and yield the same.
+        for json_file_directory_list in json_file_directories:
+            # Get the function type
+            func_type = json_file_directory_list[1]
+            # Get the json directory
+            json_file_directory = json_file_directory_list[0]
+
+            # Get the appropriate metadata class.
+            metadata_class = getattr(TeradataAnalyticFunctionInfo, func_type).value.get("metadata_class",
+                                                                                        "_AnlyFuncMetadata")
+            metadata_class = eval(metadata_class)
+
+            for json_file in os.listdir(json_file_directory):
+                file_path = os.path.join(json_file_directory, json_file)
+                with open(file_path, encoding="utf-8") as fp:
+                    json_data = json.load(fp)
+                    metadata = metadata_class(json_data, file_path, func_type=func_type)
+
+                    # Functions which do not need to participate in IN-DB Framework
+                    # should not be stored in _JsonStore.
+                    if metadata.func_name in _JsonStore._functions_to_exclude:
+                        continue
+                    _JsonStore.add(metadata)
+                    yield metadata
+
+    # If both database version and json store version are same, return an empty list so that
+    # framework will not attach any SQLE function to teradataml.
+    else:
+        return []
+
+
+def _load_anlyfuncs_jsons_versions_info():
+    """
+    DESCRIPTION:
+        Function populates following information for analytic functions:
+            * Lowest supported version.
+            * Parent directory containing JSONs.
+            * Nearest matching JSON directory for a particular database version.
+
+    PARAMETERS:
+        None
+
+    RETURNS:
+        None
+
+    RAISES:
+        None
+
+    EXAMPLES:
+        >>> _load_anlyfuncs_jsons_versions_info()
+    """
+    # Import the required package.
+    import re
+    # Get the closest matching JSON directory out of all directories corresponding
+    # to JSONs of different version.
+    # First remove any letters present in the version
+    temp_db_version = re.sub(r'[a-zA-Z]', r'', configure.database_version)
+    db_version = float(temp_db_version[:5])
+    for func_info in TeradataAnalyticFunctionInfo:
+        func_type = func_info.value["func_type"]
+        func_base_version = func_info.value["lowest_version"]
+        parent_dir = UtilFuncs._get_data_directory(dir_name="jsons",
+                                                   func_type=func_info)
+        if func_base_version:
+            if db_version >= float(func_base_version):
+                closest_version = _get_closest_version_json_dir(parent_dir, db_version)
+                if closest_version:
+                    func_type_json_version[func_type] = closest_version
+
+
+def __get_json_files_directory():
+    """
+    DESCRIPTION:
+        An internal function to get the corresponding directory name, which
+        contains the json files.
+
+    PARAMETERS:
+        None.
+
+    RAISES:
+        None.
+
+    RETURNS:
+        list
+
+    EXAMPLES:
+        >>> __get_json_files_directory()
+    """
+    # If function has version specific JSON directory, return it by using mapping information in
+    # _Jsonstore else return common JSON directory.
+    for func_info in TeradataAnalyticFunctionInfo:
+        if func_info.value["lowest_version"]:
+            # Check if current function type is allowed on connected Vantage version or not.
+            if func_info.value["func_type"] in func_type_json_version.keys():
+                yield [UtilFuncs._get_data_directory(dir_name="jsons", func_type=func_info,
+                                                    version=func_type_json_version[func_info.value["func_type"]]),
+                       func_info.name]
+        else:
+            yield [UtilFuncs._get_data_directory(dir_name="jsons", func_type=func_info), func_info.name]
+
+
+def _get_closest_version_json_dir(parent_dir, database_version):
+    """
+    DESCRIPTION:
+        Internal function to get the nearest matching JSON directory for a database
+        version from the available JSON directories for the functions.
+
+    PARAMETERS:
+        parent_dir:
+            Required Argument.
+            Specifies the parent dirctory for JSONs of all teradataml version.
+            Types: str
+
+        database_version:
+            Required Argument.
+            Specifies the database version.
+            Types: float
+
+    RAISES:
+        None.
+
+    RETURNS:
+        str
+
+    EXAMPLES:
+        >>> _get_closest_version_json_dir("path_to_teradataml/teradataml/analytics/jsons/sqle", 17.10)
+    """
+    # Get the exact matching JSON directory name for current database version.
+    # If matching directory exists, return it.
+    matching_dir = format(database_version, '.2f')
+    if matching_dir in os.listdir(parent_dir):
+        return matching_dir
+
+    # If exact matching JSON directory is not found,
+    # return the directory corresponding to the closest lower version.
+    # List all the directories, not the files, and collect lower versions only.
+    lower_versions = (json_dir for json_dir in os.listdir(parent_dir)
+                      if (os.path.isdir(os.path.join(parent_dir, json_dir))
+                          and float(json_dir) <= database_version))
+
+    # If generator generates non-empty list, return max of all versions from that list,
+    # else while an empty list is passed to max() it throws ValueError, so return None.
+    try:
+        return max(lower_versions)
+    except ValueError:
+        return None
+
+def _process_paired_functions():
+    """
+    DESCRIPTION:
+        Process and reads the paired function json.
+
+    PARAMETERS:
+        None.
+
+    RETURNS:
+        None.
+    """
+
+    json_path = os.path.join(UtilFuncs._get_data_directory(), "jsons", "paired_functions.json")
+    with open(json_path) as fp:
+        _json = json.load(fp)
+
+    _available_functions, _ = _JsonStore._get_function_list()
+    for func_type, funcs in _json.items():
+        # ToDo: Add support for VAL functions
+        if func_type == "VAL":
+            continue
+        # Set all paired functions for SQLE and UAF.
+        for func in funcs:
+            # Check if function is existed in JSonStore or not. If exists, only
+            # then process it.
+            if func in _available_functions:
+                metadata = _JsonStore.get_function_metadata(func)
+                metadata.set_paired_functions(funcs.get(func))
+
+class _UAF_paired_function:
+    """
+    Parent class for _Inverse, _Convolve, _Forecast and _Validate.
+    """
+    def _process_arguments(self, function_relation, **kwargs):
+        """
+        DESCRIPTION:
+            Method instantiate the reference function based on 'function_relation'.
+
+        PARAMETERS:
+            function_relation:
+                defines which method to instantiate.
+
+            **kwargs:
+                Keyword arguments passed based on 'function_relation'.
+
+        RETURNS:
+            object of the reference function.
+        """
+        metadata = _JsonStore.get_function_metadata(self.__class__.__name__)
+        paired_functions = metadata.get_paired_functions()
+        paired_function = \
+            [fun_relation for fun_relation in paired_functions
+             if fun_relation.function_relation == function_relation][0]
+        reference_function = paired_function.reference_function
+        for _inp, _out in paired_function.arguments:
+            kwargs[_inp] = getattr(self, _out)
+        input_art_spec = {'data': kwargs[paired_function.input_arguments[0]]}
+        if self.__class__.__name__ == "SeasonalNormalize":
+            input_art_spec['layer'] = "ARTMETADATA"
+        kwargs[paired_function.input_arguments[0]] = \
+            getattr(module, "TDAnalyticResult")(**input_art_spec)
+        return getattr(module, reference_function)(**kwargs)
+
+
+class _Convolve(_UAF_paired_function):
+    """
+    class to convolve the uaf function.
+    """
+    def convolve(self, **kwargs):
+        """
+        DESCRIPTION:
+            Method to convolve the uaf function used by instance created from below functions:
+                * DFFT
+                * DFFT2
+
+        PARAMETERS:
+            **kwargs:
+                Keyword arguments passed to the convolve method.
+                Notes:
+                    * Every function can have different arguments.
+                    * This arguments are based on inverse functions.
+
+        RETURNS:
+            object of the reference function.
+
+        EXAMPLE:
+            load_example_data("uaf", ["dfft2conv_real_4_4"])
+            data = DataFrame.from_table("dfft2conv_real_4_4")
+            td_matrix = TDMatrix(data=data,
+                                 id="id",
+                                 row_index="row_i",
+                                 row_index_style="SEQUENCE",
+                                 column_index="column_i",
+                                 column_index_style="SEQUENCE",
+                                 payload_field="magnitude",
+                                 payload_content="REAL")
+            filter_expr = td_matrix.id==33
+            dfft2_out = DFFT2(data=td_matrix,
+                              data_filter_expr=filter_expr,
+                              freq_style="K_INTEGRAL",
+                              human_readable=False,
+                              output_fmt_content="COMPLEX")
+            convolve_output = dfft2_out.convolve(conv="HR_TO_RAW",
+                                                 output_fmt_content="AMPL_PHASE_RADIANS")
+        """
+        return self._process_arguments("convolve", **kwargs)
+
+class _Inverse(_UAF_paired_function):
+    """
+    class to inverse the effects of uaf function.
+    """
+    def inverse(self, **kwargs):
+        """
+        DESCRIPTION:
+            Method to inverse the effect of uaf function used by instance created from below functions:
+                * DIFF
+                * UNDIFF
+                * DFFT
+                * IDFFT
+                * DFFT2
+                * IDFFT2
+                * SeasonalNormalize
+
+        PARAMETERS:
+            **kwargs:
+                Keyword arguments passed to the inverse method.
+                Notes:
+                    * Every function can have different arguments.
+                    * This arguments are based on inverse functions.
+
+        RETURNS:
+            object of the reference function.
+
+        EXAMPLE:
+            load_example_data("uaf", "mvdfft8")
+            data = DataFrame.from_table("mvdfft8")
+            data_series_df = TDSeries(data=data,
+                                 id="sid",
+                                 row_index="n_seqno",
+                                 row_index_style="SEQUENCE",
+                                 payload_field="magnitude1",
+                                 payload_content="REAL")
+            DFFT_result = DFFT(data=data_series_df,
+                           human_readable=True,
+                           output_fmt_content='COMPLEX')
+            inverse_output = DFFT_result.inverse()
+        """
+        return self._process_arguments("inverse", **kwargs)
+
+
+class _Forecast(_UAF_paired_function):
+    """
+    Class to forecast the model trainer object
+    """
+    def forecast(self, **kwargs):
+        """
+        DESCRIPTION:
+            Method to forecast the model trainer object and instantiate
+            the reference function.
+
+        PARAMETERS:
+            **kwargs:
+                Keyword arguments passed to the forecast method.
+                Notes:
+                    * Every function can have different arguments.
+                    * This arguments are based on forecast functions.
+
+        RETURNS:
+            object of the reference function which are:
+            * result
+
+        EXAMPLE:
+            load_example_data("uaf", ["timeseriesdatasetsd4"])
+            data = DataFrame.from_table("timeseriesdatasetsd4")
+            data_series_df = TDSeries(data=data,
+                                      id="dataset_id",
+                                      row_index="seqno",
+                                      row_index_style="SEQUENCE",
+                                      payload_field="magnitude",
+                                      payload_content="REAL")
+            arima_estimate_op = ArimaEstimate(data1=data_series_df,
+                                              nonseasonal_model_order=[2,0,0],
+                                              constant=False,
+                                              algorithm="MLE",
+                                              coeff_stats=True,
+                                              fit_metrics=True,
+                                              residuals=True,
+                                              fit_percentage=100)
+            arima_estimate_op.forecast(forecast_periods=2)
+        """
+        return self._process_arguments("forecast", **kwargs)
+
+class _Validate(_UAF_paired_function):
+    """
+    Class to validate the model trainer object
+    """
+    def validate(self, **kwargs):
+        """
+        DESCRIPTION:
+            Method to validate the model trainer object and instantiate
+            the reference function.
+
+        PARAMETERS:
+            **kwargs:
+                Keyword arguments passed to the validate method.
+                Note:
+                    * Every function can have different arguments.
+                    * This arguments are based on validate functions.
+
+        RETURNS:
+            object of the reference function which are:
+            * result
+            * fitmetadata
+            * fitresiduals
+            * model
+
+        EXAMPLE:
+            load_example_data("uaf", ["timeseriesdatasetsd4"])
+            data = DataFrame.from_table("timeseriesdatasetsd4")
+            data_series_df = TDSeries(data=data,
+                                      id="dataset_id",
+                                      row_index="seqno",
+                                      row_index_style="SEQUENCE",
+                                      payload_field="magnitude",
+                                      payload_content="REAL")
+            arima_estimate_op = ArimaEstimate(data1=data_series_df,
+                                              nonseasonal_model_order=[2,0,0],
+                                              constant=False,
+                                              algorithm="MLE",
+                                              coeff_stats=True,
+                                              fit_metrics=True,
+                                              residuals=True,
+                                              fit_percentage=80)
+            arima_estimate_op.validate(residuals=True)
+        """
+        return self._process_arguments("validate", **kwargs)
+
+class _Transform:
+    def transform(self, **kwargs):
+        """
+        DESCRIPTION:
+            Method to transform the model trainer object and instantiate
+            the reference function.
+
+        PARAMETERS:
+            **kwargs:
+                Keyword arguments passed to the transform method.
+
+        RETURNS:
+            object of the reference function.
+
+        EXAMPLES:
+            fit_df = Fit(data=iris_input,
+                         object=transformation_df,
+                         object_order_column='TargetColumn'
+                         )
+
+            fit_df.transform(data=iris_input)
+        """
+        metadata = _JsonStore.get_function_metadata(self.__class__.__name__)
+        paired_functions = metadata.get_paired_functions()
+        paired_function = [f for f in paired_functions if f.function_relation == "transform"][0]
+        reference_function = paired_function.reference_function
+        for _inp, _out in paired_function.arguments:
+            kwargs[_inp] = getattr(self, _out)
+        return getattr(module, reference_function)(**kwargs)
+
+class _Predict:
+    def predict(self, **kwargs):
+        """
+        DESCRIPTION:
+            Method to predict the model trainer object and instantiate
+            the reference function.
+
+        PARAMETERS:
+            **kwargs:
+                Keyword arguments passed to the transform method.
+
+        RETURNS:
+            object of the reference function.
+
+        EXAMPLE:
+            svm_obj = SVM(data=transform_obj.result,
+                           input_columns=['MedInc', 'HouseAge', 'AveRooms',
+                                          'AveBedrms', 'Population', 'AveOccup',
+                                          'Latitude', 'Longitude'],
+                           response_column="MedHouseVal",
+                           model_type="Regression"
+                           )
+
+            svm_obj.predict(newdata = transform_obj.result,
+                            id_column = "id"
+                            )
+        """
+        metadata = _JsonStore.get_function_metadata(self.__class__.__name__)
+        paired_functions = metadata.get_paired_functions()
+        paired_function = [f for f in paired_functions if f.function_relation == "predict"][0]
+        reference_function = paired_function.reference_function
+        for _inp, _out in paired_function.arguments:
+            kwargs[_inp] = getattr(self, _out)
+        return getattr(module, reference_function)(**kwargs)
+
+
+class _KNNPredict:
+    def predict(self, **kwargs):
+        """
+        DESCRIPTION:
+            Method to predict the KNN model trainer object and instantiate
+            the reference function.
+
+        PARAMETERS:
+            **kwargs:
+                Keyword arguments passed to the transform method.
+
+        RETURNS:
+            object of the reference function.
+
+        EXAMPLE:
+            KNN_out = KNN(train_data=computers_train1_encoded.result.iloc[:100],
+                      test_data=computers_train1_encoded.result.iloc[10:],
+                      id_column="id",
+                      input_columns=["screen", "price", "speed", "hd"],
+                      model_type="REGRESSION",
+                      response_column="computer_category_special")
+
+            res = KNN_out.evaluate(test_data=computers_train1_encoded.result.iloc[10:])
+        """
+        params = {"test_data": kwargs.get("test_data"),
+                  "id_column": self.id_column,
+                  "train_data": self.train_data,
+                  "input_columns": self.input_columns,
+                  "response_column": kwargs.get("response_column", self.response_column),
+                  "accumulate": kwargs.get("accumulate", kwargs.get("response_column", self.response_column)
+                                if getattr(self.obj, "accumulate") is None else self.accumulate)}
+
+        # KNN works in a different way. predict calls the same function with test data along with
+        # the arguments passed to the actual function. The above parameters are required
+        # arguments so we expect them to be available in output of KNN. However, the below
+        # ones are optional arguments. They can be available or not based on user input. So, before
+        # passing those to KNN again, check whether that argument is passed or not.
+        optional_args = ["model_type", "k", "voting_weight",
+                         "tolerance", "output_prob", "output_responses",
+                         "emit_neighbors", "emit_distances"]
+
+        for optional_arg in optional_args:
+            if hasattr(self, optional_arg):
+                params[optional_arg] = getattr(self, optional_arg)
+
+        return getattr(module, "KNN")(**params)
+
+
+class _Evaluate:
+    """
+    DESCRIPTION:
+        Implements the Classification and Regression evaluator.
+    """
+    _accumulate_args = {"NaiveBayesTextClassifierTrainer": "doc_category_column"}
+
+    # Mapper for mapping function names with argument names
+    _evaluator_function_mapper = {"DecisionForest": "tree_type",
+                                  "GLM": "family",
+                                  "GLMPerSegment": "family",
+                                  "SVM": "model_type",
+                                  "XGBoost": "model_type"}
+
+    def is_classification_model(self, **kwargs):
+        """
+        DESCRIPTION:
+            Returns True if the model is classification model or regression model.
+
+        PARAMETERS:
+            **kwargs:
+                Keyword arguments to access the model_type.
+
+        RETURNS:
+            Boolean.
+        """
+        is_classification_model = False
+
+        # NaiveBayesTextClassifierTrainer takes Multinomial, Bernoulli as input
+        # both comes under classification evaluator
+        if self.get_function_name() == "NaiveBayesTextClassifierTrainer":
+            return True
+        # name of argument is model_type for most of the functions but for some it is different
+        if "model_type" not in kwargs:
+            arg_name = self.get_arg_name()
+            model_type = getattr(self.obj, arg_name)
+            kwargs["model_type"] = model_type
+
+        if kwargs["model_type"].lower() == "binomial" or kwargs["model_type"].lower() == "classification":
+            is_classification_model = True
+
+        return is_classification_model
+
+    def get_function_name(self):
+        """
+        DESCRIPTION:
+            Function to get the name of the analytic function.
+
+        PARAMETERS:
+            None.
+
+        RETURNS:
+            str.
+
+        """
+        return self.__class__.__name__
+
+    def get_response_column(self):
+        """
+        DESCRIPTION:
+            Function to get the argument name for response column. For some functions
+            argument name storing the response column is different, it can
+            be fetched from the '_accumulate_arg' mapping.
+
+        PARAMETER:
+            None.
+
+        RETURNS:
+            str.
+        """
+        # By default it is 'response_column' but some functions require different names.
+        return self._accumulate_args.get(self.get_function_name(), "response_column")
+
+
+
+    def get_arg_name(self):
+        """
+        DESCRIPTION:
+            Function to get the argument name for model type. For some functions argument
+            name can be different, and it can be fetched using the '_evaluator_function_mapper'
+            mapping.
+
+        PARAMETER:
+            None.
+
+        RETURNS:
+            String representing the argument name.
+        """
+        return self._evaluator_function_mapper.get(self.get_function_name(), "model_type")
+
+    def evaluate(self, **kwargs):
+        """
+        DESCRIPTION:
+            Method to evaluate the model trainer object, using
+            either the classification or regression evaluator and
+            instantiate the reference function.
+
+        PARAMETER:
+            **kwargs:
+                Keyword arguments for specified for evaluate method.
+
+        RETURNS:
+            Attribute of Classification Evaluator or Regression Evaluator
+
+        EXAMPLE:
+            svm_obj = SVM(data=transform_obj.result,
+                           input_columns=['MedInc', 'HouseAge', 'AveRooms',
+                                          'AveBedrms', 'Population', 'AveOccup',
+                                          'Latitude', 'Longitude'],
+                           response_column="MedHouseVal",
+                           model_type="Regression"
+                           )
+
+            svm_obj.evaluate(newdata = transform_obj.result,
+                             id_column = "id"
+                             )
+        """
+
+        response_column_arg_name = self.get_response_column()
+        if hasattr(self.obj, response_column_arg_name):
+            response_column = getattr(self.obj, response_column_arg_name)
+        else:
+            # Created formula object to access the response column property of the formula.
+            formula_object = Formula(kwargs["newdata"]._metaexpr, getattr(self.obj, "formula"), "formula")
+            response_column = formula_object.response_column
+
+        # Populate 'accumulate' for predict function so that it will be available in output DataFrame.
+        if "accumulate" not in kwargs:
+            # In case accumulate is not specified by the user set the accumulate as response column.
+            kwargs["accumulate"] = response_column
+        elif response_column not in kwargs["accumulate"]:
+            # Checking if accumulate is passed, and it is not having response column then append response column
+            # to the list of values passed to accumulate.
+            if isinstance(kwargs["accumulate"], str):
+                kwargs["accumulate"] = [kwargs["accumulate"]]
+            kwargs["accumulate"].append(response_column)
+
+        predict = self.predict(**kwargs)
+        is_classification_model = self.is_classification_model(**kwargs)
+
+        if is_classification_model:
+
+            kwargs["observation_column"] = response_column
+            kwargs["prediction_column"] = "Prediction" if "Prediction" in predict.result.columns else "prediction"
+
+            # get the column_names and types from the metaexpr to check if the datatype of prediction column
+            # and observation column is same or not.
+            col_names, col_types = df_utils._get_column_names_and_types_from_metaexpr(predict.result._metaexpr)
+            res = dict(zip(col_names,col_types))
+            pre_col_name = kwargs["prediction_column"]
+            if res[kwargs["observation_column"]] != res[pre_col_name]:
+                # Converting the prediction column datatype to observation column datatype.
+                cast_cols_pre = {pre_col_name: getattr(predict.result, pre_col_name).expression.cast(
+                    type_=res[kwargs["observation_column"]])}
+                # Update the predicted result dataframe.
+                predict.result = predict.result.assign(**cast_cols_pre)
+
+            # Update the num_labels by the number of unique values.
+            kwargs["num_labels"] = predict.result.drop_duplicate(kwargs["observation_column"]).shape[0]
+
+            kwargs["data"] = predict.result
+
+            return getattr(module, "ClassificationEvaluator")(**kwargs)
+        else:
+
+            # Include the two missing metrics FSTAT and AR2, if the user did not pass the freedom_degrees and
+            # independent_features_num then appropriate error message should be displayed.
+
+            # If metrics is specified as "fstat" and "ar2".
+            if 'metrics' in kwargs:
+                metrics_list = [kwargs.get("metrics")] if isinstance(kwargs.get("metrics"), str) else kwargs.get("metrics")
+                metrics_lower_case = {metric : metric.lower() for metric in metrics_list}
+
+                if "fstat" in metrics_lower_case.values():
+                    _Validators._validate_dependent_argument("FSTAT", kwargs.get("metrics"),
+                                                             "freedom_degrees", kwargs.get("freedom_degrees"))
+
+                if "ar2" in metrics_lower_case.values():
+                    _Validators._validate_dependent_argument("AR2", kwargs.get("metrics"),
+                                                             "independent_features_num",
+                                                             kwargs.get("independent_features_num"))
+
+            if kwargs.get("metrics") is None:
+                # If metrics is not specified then evaluate for all metrics except "fstat" and "ar2".
+                metrics_list = ['MAE', 'MSE', 'MSLE', 'MAPE', 'MPE', 'RMSE', 'RMSLE', 'R2', 'EV', 'ME', 'MPD',
+                                'MGD']
+                # If the dependent and optional argument "independent_features_num" is specified then evaluate for AR2
+                # also.
+                if kwargs.get("independent_features_num") is not None:
+                    metrics_list.append("AR2")
+                # If the dependent and optional argument "freedom_degrees" is specified then evaluate for FSTAT also.
+                if kwargs.get("freedom_degrees") is not None:
+                    metrics_list.append("FSTAT")
+                kwargs["metrics"] = metrics_list
+
+            kwargs["data"] = predict.result
+            kwargs["observation_column"] = response_column
+            # The column name for predict result is "Prediction" in some cases and "prediction" in others.
+            kwargs["prediction_column"] = "Prediction" if "Prediction" in predict.result.columns else "prediction"
+
+            return getattr(module, "RegressionEvaluator")(**kwargs)
+
+
+def _get_associated_parent_classes(func_name):
+    # By this time, context is established.
+    json_path = os.path.join(UtilFuncs._get_data_directory(), "jsons", "paired_functions.json")
+    with open(json_path) as fp:
+        paired_functions = json.load(fp)
+    # Get the paired functions for func_name
+    paired_functions = [funcs.get(func_name) for _, funcs in paired_functions.items() if funcs.get(func_name, False)]
+    # paired_func_dict uses mapping between class and model trainer object.
+    paired_func_dict = {"predict": _Predict, "transform": _Transform,
+                        "evaluate": _Evaluate, "forecast": _Forecast,
+                        "validate": _Validate, "convolve": _Convolve,
+                        "inverse": _Inverse}
+    # If paired_functions is empty return empty list
+    if not paired_functions:
+        return []
+    # As there are multiple model trainer object one function can use running a loop to iterate
+    for paired_function in paired_functions[0]:
+
+        # KNN needs a special handling for predict. So, returning a specific class for KNN.
+        if func_name == "KNN" and paired_function == "predict":
+            yield _KNNPredict
+        # Here returning class which is used as parent class for func_name.
+        if paired_function in paired_func_dict:
+            yield paired_func_dict[paired_function]