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

teradataml/opensource/sklearn/_sklearn_wrapper.py

@@ -49,7 +49,7 @@ from teradataml.opensource.sklearn.constants import OpenSourcePackage, _OSML_MOD
 from teradataml.common.messagecodes import MessageCodes
 from teradataml.common.messages import Messages
 from teradataml.catalog.byom import save_byom, retrieve_byom, delete_byom
-from teradataml.dbutils.dbutils import _create_table
+from teradataml.dbutils.dbutils import _create_table, set_session_param
 from teradataml.utils.validators import _Validators
 from teradataml.dataframe.dataframe import DataFrame
 from teradataml.dataframe.dataframe_utils import DataFrameUtils
@@ -64,6 +64,10 @@ validator = _Validators()
 
 installed_model_files = defaultdict(int)
 
+## Flag to ensure the sklearn script
+## installation occurs only once.
+_file_installed = False
+
 class _GenericObjectWrapper:
     def __init__(self) -> None:
         self._db_name = _get_current_databasename()
@@ -76,7 +80,7 @@ class _GenericObjectWrapper:
         self.modelObj = None
         self._model_data = None
 
-        self._tdml_tmp_dir = os.path.join(os.path.expanduser("~"), ".teradataml")
+        self._tdml_tmp_dir = GarbageCollector._get_temp_dir_name()
 
         self._env = None
 
@@ -86,43 +90,24 @@ class _GenericObjectWrapper:
             if configure.openml_user_env is not None:
                 self._env = configure.openml_user_env
             else:
-                self._create_or_get_env()
+                self._env = UtilFuncs._create_or_get_env("open_source_ml.json")
         else:
-            execute_sql(f"SET SESSION SEARCHUIFDBPATH = {self._db_name};")
+            set_session_param("searchuifdbpath",self._db_name)
 
-    def _create_or_get_env(self):
-        """
-        Internal function to return the env if already exists else
-        creates the environment using template file and return the env.
-        """
-        # Get the template file path.
-        template_dir_path = os.path.join(_TDML_DIRECTORY, "data", "templates",
-                                         "open_source_ml.json")
+        global _file_installed
+        ## Flag to check whether trained model is installed or not.
+        self._is_trained_model_installed = False
 
-        # Read template file.
-        with open(template_dir_path, "r") as r_file:
-            data = json.load(r_file)
+        ## Install all sklearn script files on Vantage.
+        if not _file_installed:
+            sklearn_script_files = ["sklearn_fit.py", "sklearn_score.py",
+                                    "sklearn_transform.py", "sklearn_fit_predict.py",
+                                    "sklearn_neighbors.py", "sklearn_model_selection_split.py"]
+            for script_file in sklearn_script_files:
+                self._install_script_file(file_identifier=script_file.split(".")[0],
+                                          file_name=script_file)
 
-        # Get env_name.
-        _env_name = data["env_specs"][0]["env_name"]
-
-        try:
-            # Call function to 'openml_env' get env.
-            self._env = get_env(_env_name)
-        except TeradataMlException as tdml_e:
-            # We will get here when error says, env does not exist otherwise raise the exception as is.
-            # Env does not exist so create one.
-
-            exc_msg = "Failed to execute get_env(). User environment '{}' not " \
-                      "found.".format(_env_name)
-            if exc_msg in tdml_e.args[0]:
-                print(f"No OpenAF environment with name '{_env_name}' found. Creating one with "\
-                      "latest supported python and required packages.")
-                _env = create_env(template=template_dir_path)
-            else:
-                raise tdml_e
-        except Exception as exc:
-            raise exc
+            _file_installed = True
 
     def _get_columns_as_list(self, cols):
         """
@@ -205,34 +190,65 @@ class _GenericObjectWrapper:
                                   is_binary=is_binary)
         else:
             status = self._env.install_file(file_path=new_script,
-                                       replace=True,
-                                       suppress_output=True)
+                                            replace=True,
+                                            suppress_output=True)
         if not status:
             raise TeradataMlException(
                 f"Script file '{file_name}' failed to get installed/replaced in Vantage."
             )
 
-    def _get_partition_col_indices_and_types(self, data, partition_columns):
+    def _remove_script_file(self, file_name):
         """
-            partition_columns can be from feature columns and label columns.
-            So, get the indices and types of these columns from the data columns.
+        Internal function to remove script file in Vantage.
         """
-        partition_indices = []
-        partition_types = []
+        # _env is set while object creation
+        # If not set, it is Vantage Enterprise. Otherwise, it is Vantage Lake.
+
+        if not self._is_lake_system:
+            status = remove_file(file_identifier=file_name.split(".")[0],
+                                 force_remove=True,
+                                 suppress_output=True)
+        else:
+            status = self._env.remove_file(file_name=file_name,
+                                           suppress_output=True)
+        if not status:
+            raise TeradataMlException(
+                f"Script file '{file_name}' failed to remove in Vantage."
+            )
+    def _get_data_col_types_and_partition_col_indices_and_types(self, data, partition_columns,
+                                                                idx_delim=",",
+                                                                types_delim="--"):
+        """
+        Internal function to get the data column types and partition column names, indices and types.
+        Function returns delimiter separated string of types and indices if idx_delim and
+        types_delim are provided. Otherwise, it returns list of types and indices. Partition names
+        are returned as list always.
+        """
+        data_column_types = "" if types_delim else []
+        partition_indices = "" if idx_delim else []
+        partition_types = "" if types_delim else []
         new_partition_columns = []
+        j = 0
         for i, col in enumerate(data.columns):
+            _type = data._td_column_names_and_sqlalchemy_types[col.lower()].python_type.__name__
+            if types_delim:
+                data_column_types += (_type if i == 0 else f"{types_delim}{_type}")
+            else:
+                data_column_types.append(_type)
             if col in partition_columns:
                 new_partition_columns.append(col)
-                partition_indices.append(i)
-                partition_types.append(data._td_column_names_and_sqlalchemy_types[col.lower()].\
-                                       python_type.__name__)
-        # Converting to string "None" if they are not present as empty string can't be passed
-        # to Script script_commands' command line arguments.
-        # Otherwise, pass the values as comma separated string.
-        partition_indices = ",".join([str(x) for x in partition_indices])\
-            if partition_indices else "None"
-        partition_types = ",".join([x for x in partition_types]) if partition_types else "None"
-        return partition_indices, partition_types, new_partition_columns
+                if idx_delim:
+                    partition_indices += (str(i) if j == 0 else f"{idx_delim}{str(i)}")
+                else:
+                    partition_indices.append(i)
+                if types_delim:
+                    partition_types += (_type if j == 0 else f"{types_delim}{_type}")
+                else:
+                    partition_types.append(_type)
+                j += 1
+        # Return types of all columns (as list or str), partition column indices (as list or str)
+        # and partition column types (as list or str).
+        return data_column_types, partition_indices, partition_types, new_partition_columns
 
     def _get_kwargs_str(self, kwargs):
         """
@@ -357,6 +373,23 @@ class _OpenSourceObjectWrapper(_GenericObjectWrapper):
         Internal function to get attributes of all sklearn model objects when multiple models are
         generated by fit.
         """
+
+        def __generate_model_object(model_obj_value):
+            """
+            Internal function to generate _SkLearnWrapperObject model object from model_obj_value.
+            """
+            # Create _SkLearnObjectWrapper object from opensource model object.
+            model_obj = self.__class__(model=first_atrribute_instance)
+            model_obj.modelObj = model_obj_value
+            model_obj._is_model_installed = True
+
+            # Setting other model attributes.
+            model_obj._is_default_partition_value_fit = self._is_default_partition_value_fit
+            model_obj._is_default_partition_value_predict = self._is_default_partition_value_predict
+            model_obj._fit_partition_colums_non_default = self._fit_partition_colums_non_default
+            model_obj._fit_partition_unique_values = self._fit_partition_unique_values
+            return model_obj
+
         # Wrapper function to invoke dynamic method, using arguments
         # passed by user, on model in each row.
         def __sklearn_method_invoker_for_multimodel(*c, **kwargs):
@@ -364,36 +397,58 @@ class _OpenSourceObjectWrapper(_GenericObjectWrapper):
             for i in range(multi_models.shape[0]):
                 curr_model = multi_models.iloc[i]["model"]
                 multi_models.at[i, "model"] = getattr(curr_model, name)(*c, **kwargs)
+            
+            first_function_instance = multi_models.at[0, "model"]
+            if self.__class__._validate_model_supportability(first_function_instance):
+                return __generate_model_object(multi_models)
+
             return multi_models.rename(columns={"model": name})
 
-        # Identify if attribute is callable or not to avoid
-        # this check in loop for every model.
-        is_attr_callable = False
         # Assuming that self.modelObj will have at least 1 row.
-        is_attr_callable = callable(getattr(self.modelObj.iloc[0]["model"], name))
 
-        # If attribute is callable, it should be applied on model in each row
+        # Get attribute instance from first model object.
+        first_atrribute_instance = getattr(self.modelObj.iloc[0]["model"], name)
+
+        # If first_atrribute_instance is callable, it should be applied on model in each row
         # using passed arguments.
-        if is_attr_callable:
+        if callable(first_atrribute_instance):
             return __sklearn_method_invoker_for_multimodel
 
         output_attributes = self.modelObj.copy()
         for i in range(output_attributes.shape[0]):
             model = output_attributes.iloc[i]["model"]
             output_attributes.at[i, "model"] = getattr(model, name)
+
+        if self.__class__._validate_model_supportability(first_atrribute_instance):
+            return __generate_model_object(output_attributes)
+
         return output_attributes.rename(columns={"model": name})
 
     def __getattr__(self, name):
         # This just run attributes (functions and properties) from sklearn object.
         def __sklearn_method_invoker(*c, **kwargs):
-            return atrribute_instance(*c, **kwargs)
+            # sklearn model is returned from the function call. Create _SkLearnObjectWrapper object.
+            model_obj = attribute_instance(*c, **kwargs)
+            if self.__class__._validate_model_supportability(model_obj):
+                model_obj = self.__class__(model=model_obj)
+                model_obj._is_model_installed = True # Trained model is returned by function call.
+            return model_obj
+
         if isinstance(self.modelObj, pd.DataFrame):
             return self.__get_obj_attributes_multi_model(name)
 
-        atrribute_instance = getattr(self.modelObj, name)
-        if callable(atrribute_instance):
+        attribute_instance = getattr(self.modelObj, name)
+
+        if callable(attribute_instance):
             return __sklearn_method_invoker
-        return atrribute_instance
+
+        if self.__class__._validate_model_supportability(attribute_instance):
+            # sklearn model is returned from the attribute. Create _SkLearnObjectWrapper object.
+            model_obj = self.__class__(model=attribute_instance)
+            model_obj._is_model_installed = True # Trained model is returned as attribute.
+            return model_obj
+
+        return attribute_instance
 
     @classmethod
     def _validate_model_supportability(cls, model):
@@ -404,15 +459,25 @@ class _OpenSourceObjectWrapper(_GenericObjectWrapper):
         error_msg = Messages.get_message(MessageCodes.MODEL_CATALOGING_OPERATION_FAILED, "validate",
                                          "The given model is not a supported opensource model.")
         msg_code = MessageCodes.MODEL_CATALOGING_OPERATION_FAILED
+        package_name = None
+        class_name = None
         try:
             # For scikit-learn, model.__module__ is similar to 'sklearn.linear_model._base'.
             # TODO: check for other supported packages.
-            if model.__module__.split(".")[0] not in OpenSourcePackage.values():
-                raise TeradataMlException(error_msg, msg_code)
+            if hasattr(model, "__module__"):
+                package_name = model.__module__.split(".")[0]
+                if package_name not in OpenSourcePackage.values():
+                    return False
+            if hasattr(model, "__class__"):
+                class_name = model.__class__.__name__
         except Exception as ex:
             # If in case, model.__module__ fails.
             raise TeradataMlException(error_msg, msg_code) from ex
 
+        # True only if package name is opensource package name and class name is not internal class.
+        return True if package_name and class_name and \
+            package_name == cls.OPENSOURCE_PACKAGE_NAME.value and not class_name.startswith("_") else False
+
     def _save_model(self, model_name, replace_if_exists=False):
         """
         Internal function to save the model stored in file at location mentioned by class variable
@@ -423,7 +488,8 @@ class _OpenSourceObjectWrapper(_GenericObjectWrapper):
         conn = get_connection()
         osml_models_table_exists = conn.dialect.has_table(conn,
                                                           table_name=_OSML_MODELS_TABLE_NAME,
-                                                          schema=self._db_name)
+                                                          schema=self._db_name,
+                                                          table_only=True)
         if not osml_models_table_exists:
             all_columns = _OSML_MODELS_TABLE_COLUMNS_TYPE_DICT.copy()
             all_columns.update(_OSML_ADDITIONAL_COLUMN_TYPES)
@@ -471,7 +537,11 @@ class _OpenSourceObjectWrapper(_GenericObjectWrapper):
         Internal function to create an instance of the class using the model and deploy
         the model to Vantage.
         """
-        cls._validate_model_supportability(model=model)
+        is_model_supportable = cls._validate_model_supportability(model=model)
+        if not is_model_supportable:
+            raise TeradataMlException(Messages.get_message(MessageCodes.MODEL_CATALOGING_OPERATION_FAILED,
+                                                           "deploy", "The given model is not a supported opensource model."),
+                                      MessageCodes.MODEL_CATALOGING_OPERATION_FAILED)
 
         cls = cls(model=model)
         # Load the model file into Vantage node as file can be used in
@@ -817,7 +887,6 @@ class _SkLearnObjectWrapper(_OpenSourceObjectWrapper):
                         for col in new_partition_columns] + [("model", model_type)]
 
         file_name = "sklearn_fit.py"
-        self._install_script_file(file_identifier=file_name.split(".")[0], file_name=file_name)
 
         if classes:
             class_type = type(classes[0]).__name__
@@ -825,15 +894,15 @@ class _SkLearnObjectWrapper(_OpenSourceObjectWrapper):
         else:
             classes = str(None)
             class_type = str(None)
-
-        partition_indices, partition_types, new_partition_columns = \
-            self._get_partition_col_indices_and_types(data, new_partition_columns)
+        
+        data_column_types_str, partition_indices_str, _, new_partition_columns = \
+            self._get_data_col_types_and_partition_col_indices_and_types(data, new_partition_columns)
 
         # db_name is applicable for enterprise system.
         db_file_name = file_name if self._is_lake_system else f"./{self._db_name}/{file_name}"
         py_exc = UtilFuncs._get_python_execution_path()
         script_command = f"{py_exc} {db_file_name} {func} {len(feature_columns)} "\
-            f"{len(label_columns)} {partition_indices} {partition_types} "\
+            f"{len(label_columns)} {partition_indices_str} {data_column_types_str} "\
             f"{self._model_file_name_prefix} {classes} {class_type} {self._is_lake_system}"
 
         # Get unique values in partitioning columns.
@@ -852,6 +921,13 @@ class _SkLearnObjectWrapper(_OpenSourceObjectWrapper):
         self._fit_label_columns_types = [data._td_column_names_and_sqlalchemy_types[l_c.lower()]
                                          for l_c in label_columns]
 
+        # If the model is trained a second time after the object creation,
+        # or if set_params() is called after the first model training,
+        # this flag will reset to False. So that for subsequent predict/score
+        # operations, the newly trained model will be installed.
+        if self._is_trained_model_installed:
+            self._is_trained_model_installed = False
+
     def partial_fit(self, X=None, y=None, classes=None, **kwargs):
         """
         Please check the description in Docs/OpensourceML/sklearn.py.
@@ -972,7 +1048,6 @@ class _SkLearnObjectWrapper(_OpenSourceObjectWrapper):
                                           feature_columns,
                                           label_columns,
                                           func_name,
-                                          n_partitions,
                                           kwargs):
         """
         Internal function to return list of column names and their sqlalchemy types
@@ -1010,7 +1085,7 @@ class _SkLearnObjectWrapper(_OpenSourceObjectWrapper):
 
         # For paritioning columns, it will be a dataframe and getattr(modelObj, func_name) fails.
         # Just for getting the number of columns and their types, using only one model of all.
-        if n_partitions == 1:
+        if len(self._fit_partition_unique_values) == 1:
             # Single model case.
             skl_obj = self.modelObj
         else:
@@ -1038,11 +1113,10 @@ class _SkLearnObjectWrapper(_OpenSourceObjectWrapper):
                 "path() returns tuple of ndarrays of different shapes. Not Implemented yet."
             )
 
-        # This import is as per scipy version 1.10.x in local machine as teradataml does not
-        # impose restrictions on this package in setup.py. TODO
-        from scipy.sparse import csr_matrix
-
-        if isinstance(trans_opt, csr_matrix):
+        if isinstance(trans_opt, numpy.ndarray) and trans_opt.shape == (X.shape[0],):
+            trans_opt = trans_opt.reshape(X.shape[0], 1)
+        
+        if type(trans_opt).__name__ in ["csr_matrix", "csc_matrix"]:
             no_of_columns = trans_opt.get_shape()[1]
             trans_opt = trans_opt.toarray()
         elif isinstance(trans_opt, dict):
@@ -1054,6 +1128,14 @@ class _SkLearnObjectWrapper(_OpenSourceObjectWrapper):
         else:
             no_of_columns = 1
 
+        # Special handling when inverse_transform of no_of_columns returns no of rows 
+        # less than the no of classes. Such columns are filled with NaN values.
+        # Updating number of columns here (new columns with NaN values will be added).
+        if func_name == "inverse_transform" and self.class_name == "MultiLabelBinarizer":
+            no_of_columns = len(self.classes_)
+            for i in range(len(ten_row_data)):
+                trans_opt[i] += tuple([numpy.nan] * (no_of_columns - len(trans_opt[i])))
+
         # Special handling required for cross_decomposition classes's transform function, which
         # takes label columns also. In this case, output is a tuple of numpy arrays - x_scores and
         # y_scores. If label columns are not provided, only x_scores are returned.
@@ -1084,6 +1166,30 @@ class _SkLearnObjectWrapper(_OpenSourceObjectWrapper):
         # Get new column sqlalchemy types for pandas df columns of transform output.
         opt_pd = pd.DataFrame(trans_opt)
 
+        # Get output column types for each column in pandas df from the output of transform
+        # type functions.
+        types = {}
+        for idx, col in enumerate(list(opt_pd.columns)):
+            # Get type of column using data from all rows, in case if the column has None values.
+            # 'and' of types of all values in the column with type(None) gives the type of the column.
+            type_ = type(None)
+            for i in range(len(trans_opt)):
+                type_ = type_ and type(trans_opt[i][idx])
+            
+            # If all the values of the output (trans_opt) is None, thelen use `str` as type since
+            # pandas astype() does not accept None type.
+            if type_ is type(None):
+                type_ = str
+
+            # numpy integer columns with nan values can't be typecasted using pd.astype() to int64.
+            # It raises error like "Cannot convert non-finite values (NA or inf) to integer: 
+            #                       Error while type casting for column '2'"
+            # Hence, using pd.Int64Dtype() for integer columns with nan values.
+            types[col] = type_ if type_ not in [int, numpy.int64] else pd.Int64Dtype()
+
+        # Without this, all columns will be of object type and gets converted to VARCHAR in Vantage.
+        opt_pd = opt_pd.astype(types)
+
         # If the datatype is not specified then check if the datatype is datetime64 and timezone is present then map it to
         # TIMESTAMP(timezone=True) else map it according to default value.
         col_types = [TIMESTAMP(timezone=True)
@@ -1118,26 +1224,29 @@ class _SkLearnObjectWrapper(_OpenSourceObjectWrapper):
                                                                                 partition_columns)
 
         file_name = "sklearn_score.py"
-        self._install_script_file(file_identifier=file_name.split(".")[0], file_name=file_name)
 
         script_file_path = f"{file_name}" if self._is_lake_system \
             else f"./{self._db_name}/{file_name}"
 
-        partition_indices, partition_types, new_partition_columns = \
-            self._get_partition_col_indices_and_types(data, new_partition_columns)
+        data_column_types_str, partition_indices_str, _, new_partition_columns = \
+            self._get_data_col_types_and_partition_col_indices_and_types(data, new_partition_columns)
 
         self._validate_unique_partition_values(data, new_partition_columns)
 
         py_exc = UtilFuncs._get_python_execution_path()
         script_command = f"{py_exc} {script_file_path} {func_name} {len(feature_columns)} "\
-            f"{len(label_columns)} {partition_indices} {partition_types} "\
+            f"{len(label_columns)} {partition_indices_str} {data_column_types_str} "\
             f"{self._model_file_name_prefix} {self._is_lake_system}"
 
         # score, aic, bic returns float values.
         return_types = [(col, data._td_column_names_and_sqlalchemy_types[col.lower()])
                         for col in new_partition_columns] + [(func_name, FLOAT())]
 
-        self._install_initial_model_file()
+        # Checking the trained model installation. If not installed,
+        # install it and set flag to True.
+        if not self._is_trained_model_installed:
+            self._install_initial_model_file()
+            self._is_trained_model_installed = True
 
         opt = self._run_script(data, script_command, new_partition_columns, return_types)
 
@@ -1186,19 +1295,18 @@ class _SkLearnObjectWrapper(_OpenSourceObjectWrapper):
             kwargs.pop("label_columns")
 
         file_name = "sklearn_transform.py"
-        self._install_script_file(file_identifier=file_name.split(".")[0], file_name=file_name)
 
         script_file_path = f"{file_name}" if self._is_lake_system \
             else f"./{self._db_name}/{file_name}"
 
-        partition_indices, partition_types, new_partition_columns = \
-            self._get_partition_col_indices_and_types(data, new_partition_columns)
+        data_column_types_str, partition_indices_str, _, new_partition_columns = \
+            self._get_data_col_types_and_partition_col_indices_and_types(data, new_partition_columns)
 
         self._validate_unique_partition_values(data, new_partition_columns)
 
         py_exc = UtilFuncs._get_python_execution_path()
         script_command = f"{py_exc} {script_file_path} {func_name} {len(feature_columns)} "\
-            f"{len(label_columns)} {partition_indices} {partition_types} "\
+            f"{len(label_columns)} {partition_indices_str} {data_column_types_str} "\
             f"{self._model_file_name_prefix} {self._is_lake_system}"
 
         # Returning feature columns also along with transformed columns because we don't know the
@@ -1208,15 +1316,18 @@ class _SkLearnObjectWrapper(_OpenSourceObjectWrapper):
         if func_name in ["predict", "decision_function"] and label_columns:
             return_types += [(col, data._td_column_names_and_sqlalchemy_types[col.lower()])
                              for col in label_columns]
+
         return_types += self._get_return_columns_for_function_(data,
                                                                feature_columns,
                                                                label_columns,
                                                                func_name,
-                                                               len(new_partition_columns),
                                                                kwargs)
 
-        # Installing model files before running sklearn_transform.py.
-        self._install_initial_model_file()
+        # Checking the trained model installation. If not installed,
+        # install it and set flag to True.
+        if not self._is_trained_model_installed:
+            self._install_initial_model_file()
+            self._is_trained_model_installed = True
 
         opt = self._run_script(data, script_command, new_partition_columns, return_types)
 
@@ -1253,7 +1364,6 @@ class _SkLearnObjectWrapper(_OpenSourceObjectWrapper):
                                                                    feature_columns,
                                                                    label_columns,
                                                                    func_name,
-                                                                   len(new_partition_columns),
                                                                    {})
         else:
             # If there are no label_columns, we will have only one
@@ -1261,22 +1371,25 @@ class _SkLearnObjectWrapper(_OpenSourceObjectWrapper):
             return_types += [(f"{self.class_name.lower()}_{func_name}_1", FLOAT())]
 
         file_name = "sklearn_fit_predict.py"
-        self._install_script_file(file_identifier=file_name.split(".")[0], file_name=file_name)
 
-        partition_indices, partition_types, new_partition_columns = \
-            self._get_partition_col_indices_and_types(data, new_partition_columns)
+        data_column_types_str, partition_indices_str, _, new_partition_columns = \
+            self._get_data_col_types_and_partition_col_indices_and_types(data, new_partition_columns)
 
         script_file_name = f"{file_name}" if self._is_lake_system \
             else f"./{self._db_name}/{file_name}"
         py_exc = UtilFuncs._get_python_execution_path()
         script_command = f"{py_exc} {script_file_name} {len(feature_columns)} "\
-            f"{len(label_columns)} {partition_indices} {partition_types} "\
+            f"{len(label_columns)} {partition_indices_str} {data_column_types_str} "\
             f"{self._model_file_name_prefix} {self._is_lake_system}"
 
         # Get unique values in partitioning columns.
         self._fit_partition_unique_values = data.drop_duplicate(new_partition_columns).get_values()
 
-        self._install_initial_model_file()
+        # Checking the trained model installation. If not installed,
+        # install it and flag to True.
+        if not self._is_trained_model_installed:
+            self._install_initial_model_file()
+            self._is_trained_model_installed = True
 
         opt = self._run_script(data, script_command, new_partition_columns, return_types)
 
@@ -1354,7 +1467,6 @@ class _SkLearnObjectWrapper(_OpenSourceObjectWrapper):
         args_str = self._get_kwargs_str(kwargs)
 
         file_name = "sklearn_neighbors.py"
-        self._install_script_file(file_identifier=file_name.split(".")[0], file_name=file_name)
 
         script_file_path = f"{file_name}" if self._is_lake_system \
             else f"./{self._db_name}/{file_name}"
@@ -1377,18 +1489,22 @@ class _SkLearnObjectWrapper(_OpenSourceObjectWrapper):
         else:
             return_types += [("output", VARCHAR())]
 
-        partition_indices, partition_types, new_partition_columns = \
-            self._get_partition_col_indices_and_types(data, new_partition_columns)
+        data_column_types_str, partition_indices_str, _, new_partition_columns = \
+            self._get_data_col_types_and_partition_col_indices_and_types(data, new_partition_columns)
 
         py_exc = UtilFuncs._get_python_execution_path()
         script_command = f"{py_exc} {script_file_path} {func_name} {len(feature_columns)} "\
-            f"{partition_indices} {partition_types} {self._model_file_name_prefix} {self._is_lake_system} "\
+            f"{partition_indices_str} {data_column_types_str} {self._model_file_name_prefix} {self._is_lake_system} "\
             f"{args_str}"
 
         # Get unique values in partitioning columns.
         self._fit_partition_unique_values = data.drop_duplicate(new_partition_columns).get_values()
 
-        self._install_initial_model_file()
+        # Checking the trained model installation. If not installed,
+        # install it and set flag to True.
+        if not self._is_trained_model_installed:
+            self._install_initial_model_file()
+            self._is_trained_model_installed = True
 
         opt = self._run_script(data, script_command, new_partition_columns, return_types)
 
@@ -1472,7 +1588,6 @@ class _SkLearnObjectWrapper(_OpenSourceObjectWrapper):
                                                                                 group_columns)
 
         file_name = "sklearn_model_selection_split.py"
-        self._install_script_file(file_identifier=file_name.split(".")[0], file_name=file_name)
 
         script_file_path = f"{file_name}" if self._is_lake_system \
             else f"./{self._db_name}/{file_name}"
@@ -1496,18 +1611,22 @@ class _SkLearnObjectWrapper(_OpenSourceObjectWrapper):
         return_types = [(col, data._td_column_names_and_sqlalchemy_types[col.lower()])
                         for col in new_partition_columns] + return_types
 
-        partition_indices, partition_types, new_partition_columns = \
-            self._get_partition_col_indices_and_types(data, new_partition_columns)
+        data_column_types_str, partition_indices_str, _, new_partition_columns = \
+            self._get_data_col_types_and_partition_col_indices_and_types(data, new_partition_columns)
 
         py_exc = UtilFuncs._get_python_execution_path()
         script_command = f"{py_exc} {script_file_path} {func_name} {len(feature_columns)} "\
-            f"{len(label_columns)} {len(group_columns)} {partition_indices} {partition_types} "\
+            f"{len(label_columns)} {len(group_columns)} {partition_indices_str} {data_column_types_str} "\
             f"{self._model_file_name_prefix} {self._is_lake_system}"
 
         # Get unique values in partitioning columns.
         self._fit_partition_unique_values = data.drop_duplicate(new_partition_columns).get_values()
 
-        self._install_initial_model_file()
+        # Checking the trained model installation. If not installed,
+        # install it and set flag to True.
+        if not self._is_trained_model_installed:
+            self._install_initial_model_file()
+            self._is_trained_model_installed = True
 
         opt = self._run_script(data, script_command, new_partition_columns, return_types)
 
@@ -1586,19 +1705,25 @@ class _SKLearnFunctionWrapper(_GenericObjectWrapper):
 
         self.__params = kwargs
 
-        # Get indices and types of partition_columns.
-        idxs, types, partition_cols = self._get_partition_col_indices_and_types(self.__tdml_df,
-                                                                                partition_cols)
+        # Get indices of partition_columns and types of all columns.
+        data_column_types_str, partition_indices_str, _, partition_cols = \
+            self._get_data_col_types_and_partition_col_indices_and_types(self.__tdml_df, partition_cols)
 
         script_file_path = f"{self._model_file_name}" if self._is_lake_system \
             else f"./{self._db_name}/{self._model_file_name}"
+
+        model_file_prefix = None
+        if self._is_lake_system:
+            model_file_prefix = self._model_file_name.replace(".py", "")
+
         py_exc = UtilFuncs._get_python_execution_path()
-        script_command = (f"{py_exc} {script_file_path} {idxs}"
-                          f" ") + \
-            f"{types} {data_args_str}"
+        script_command = (f"{py_exc} {script_file_path} {partition_indices_str} "\
+                          f"{data_column_types_str} {data_args_str} {self._is_lake_system}"\
+                          f" {model_file_prefix}")
 
-        return_types = [(col, self.__tdml_df._td_column_names_and_sqlalchemy_types[col.lower()]) 
-                        for col in partition_cols] + [(self.__func_name, CLOB())]
+        model_type = BLOB() if self._is_lake_system else CLOB()
+        return_types = [(col, self.__tdml_df._td_column_names_and_sqlalchemy_types[col.lower()])
+                        for col in partition_cols] + [(self.__func_name, model_type)]
 
         # Generate new file in .teradataml directory and install it to Vantage.
         self._prepare_and_install_file()
@@ -1613,23 +1738,30 @@ class _SKLearnFunctionWrapper(_GenericObjectWrapper):
 
         # File cleanup after processing.
         os.remove(self._model_file_local)
-        remove_file(file_identifier=self._model_file_name.split(".")[0], suppress_output=True,
-                    force_remove=True)
+        self._remove_script_file(self._model_file_name)
 
         return self.modelObj
 
     def _prepare_data_args_string(self, kwargs):
+        """
+        Get column indices and types of each data related arguments in the format:
+        "{<arg_name>-<comma separated indices>-<comma separated types>}--
+         {<arg_name>-<comma separated indices>-<comma separated types>}"
+        """
         data_args_str = []
         for arg_name in list(self.__data_args.keys()):
             # Remove DataFrame arguments from kwargs, which will be passed to Script.
             kwargs.pop(arg_name)
 
             # Get column indices and their types for each dataframe from parent dataframe.
-            _indices, _types, _ = self._get_partition_col_indices_and_types(self.__tdml_df,
-                                                                self.__data_args[arg_name].columns)
-            
-            # Format "<arg_name>-<comma separated indices>-<comma separated types>"
-            data_args_str.append(f"{arg_name}-{_indices}-{_types}")
+            _, partition_indices_str, partition_types_str, _ = \
+                self._get_data_col_types_and_partition_col_indices_and_types(self.__tdml_df,
+                                                                   self.__data_args[arg_name].columns,
+                                                                   idx_delim=",",
+                                                                   types_delim=",")
+        
+            # Format "<arg_name>-<comma separated indices>-<comma separated types>"            
+            data_args_str.append(f"{arg_name}-{partition_indices_str}-{partition_types_str}")
         
         # Format "{<arg_name>-<comma separated indices>-<comma separated types>}--
         #    {<arg_name>-<comma separated indices>-<comma separated types>}"
@@ -1650,7 +1782,7 @@ class _SKLearnFunctionWrapper(_GenericObjectWrapper):
 
     def _prepare_and_install_file(self):
         """
-        Prepare function script file from template file and install it in Vaantage.
+        Prepare function script file from template file and install it in Vantage.
         """
         with open(os.path.join(self._scripts_path, "sklearn_function.template")) as fp:
             script_data = fp.read()