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

teradataml/table_operators/query_generator.py

@@ -481,6 +481,9 @@ class QueryGenerator:
             return configure.read_nos_function_mapping.upper()
         elif "WriteNOS".lower() == function_name.lower():
             return configure.write_nos_function_mapping.upper()
+        # If Table Operator function is IMAGE2MATRIX, then return alias name as TD_IMAGE2MATRIX.
+        elif "IMAGE2MATRIX".lower() == function_name.lower():
+            return "TD_IMAGE2MATRIX"
             
         engine_name = UtilFuncs._get_engine_name(self._engine)
 

teradataml/table_operators/table_operator_query_generator.py

@@ -231,7 +231,9 @@ class TableOperatorQueryGenerator(QueryGenerator):
             using_clause = ""
             # If the function is a NOS function, then USING clause is needed.
             if self._function_name.lower() in [configure.write_nos_function_mapping.lower(),
-                                               configure.read_nos_function_mapping.lower()]: 
+                                               configure.read_nos_function_mapping.lower(),
+                                               "td_image2matrix"
+                                               ]: 
                 using_clause = "USING"
             invocation_sql = "{0}\n\t{1}{2}".format(invocation_sql, using_clause, self.__OTHER_ARG_CLAUSE)
 

teradataml/table_operators/table_operator_util.py

@@ -24,6 +24,7 @@ from teradataml.utils.utils import execute_sql
 from teradataml.utils.validators import _Validators
 from functools import partial
 from inspect import isfunction, getsource
+from pathlib import Path
 
 
 class _TableOperatorUtils:
@@ -281,7 +282,8 @@ class _TableOperatorUtils:
         """
         # Validate the user defined function.
 
-        if self.operation == TableOperatorConstants.UDF_OP.value:
+        if self.operation in [TableOperatorConstants.UDF_OP.value,\
+                              TableOperatorConstants.REGISTER_OP.value]:
             for udf_function in self.user_function:
                 if not isfunction(udf_function):
                     raise TypeError(Messages.get_message(
@@ -330,20 +332,30 @@ class _TableOperatorUtils:
         EXAMPLES:
             self.__create_user_script()
         """
-        # Generate script name and alias, and add entry to a Garbage Collector.
-        # script_entry is the string that is added to Garbage collector.
-        # It has the format "<databasename>"."<file_id>".
-        self.script_entry, self.script_alias, self.script_name, self.script_base_name = self.__get_script_name()
-
-        # Get the converters to use with pandas.read_csv, and to correctly
-        # typecast the numeric data.
-        python_input_col_types = [UtilFuncs._teradata_type_to_python_type(col.type)
-                                  for col in self.data._metaexpr.c]
-        input_converters = UtilFuncs._get_pandas_converters(python_input_col_types)
-
-        python_output_col_types = [UtilFuncs._teradata_type_to_python_type(type_)
-                                   for type_ in list(self.returns.values())]
-        output_converters = UtilFuncs._get_pandas_converters(python_output_col_types)
+        # If operation is register, then generate script name based on the
+        # user function name and return type.
+        # It has the format "tdml_udf_name_<registered_name>_udf_type_<return_type>_register.py"
+        if self.operation == TableOperatorConstants.REGISTER_OP.value:
+            registered_name = list(self.returns.keys())[0]
+            return_type = self.returns[registered_name]
+            self.script_name = "tdml_udf_name_{}_udf_type_{}_register.py".format(registered_name, return_type)
+            self.script_base_name = Path(self.script_name).stem
+        else:
+            # Generate script name and alias, and add entry to a Garbage Collector.
+            # script_entry is the string that is added to Garbage collector.
+            # It has the format "<databasename>"."<file_id>".
+            self.script_entry, self.script_alias, self.script_name, self.script_base_name = self.__get_script_name()
+
+        if self.operation not in [TableOperatorConstants.UDF_OP.value, TableOperatorConstants.REGISTER_OP.value]:
+            # Get the converters to use with pandas.read_csv, and to correctly
+            # typecast the numeric data.
+            python_input_col_types = [UtilFuncs._teradata_type_to_python_type(col.type)
+                                    for col in self.data._metaexpr.c]
+            input_converters = UtilFuncs._get_pandas_converters(python_input_col_types)
+
+            python_output_col_types = [UtilFuncs._teradata_type_to_python_type(type_)
+                                    for type_ in list(self.returns.values())]
+            output_converters = UtilFuncs._get_pandas_converters(python_output_col_types)
 
         # Create script in .teradataml directory.
         script_dir = GarbageCollector._get_temp_dir_name()
@@ -357,35 +369,16 @@ class _TableOperatorUtils:
                                             "templates")
         # Get the template.
         template = {TableOperatorConstants.APPLY_OP.value: TableOperatorConstants.APPLY_TEMPLATE.value,
-                    TableOperatorConstants.UDF_OP.value: TableOperatorConstants.UDF_TEMPLATE.value}
+                    TableOperatorConstants.UDF_OP.value: TableOperatorConstants.UDF_TEMPLATE.value,
+                    TableOperatorConstants.REGISTER_OP.value: TableOperatorConstants.REGISTER_TEMPLATE.value                    }
         template_name = template.get(self.operation, TableOperatorConstants.MAP_TEMPLATE.value)
         # Write to the script based on the template.
         try:
             with open(os.path.join(template_dir, template_name), 'r') as input_file:
                 with open(self.script_path, 'w') as output_file:
                     if self.operation == TableOperatorConstants.UDF_OP.value:
-
-                        # Function can have udf as decorator. Remove that.
-                        # The below notation
-                            # @udf
-                            # def to_upper(s):
-                            #     return s.upper()
-                            # Then source code will be as it is.
-                        # But if below notation is used,
-                            # f = udf(to_upper)
-                            # Then source code will not have udf.
-                        # So, remove first line if it comes with first notation.
-                        # For both notations if in starting function defination have any extra space. Remove that.
-                        # If multiple UDF's are there append them as a single string.
                         
-                        user_function_code = ""
-                        for udf_code in self.user_function:
-                            udf_code = getsource(udf_code)
-                            udf_code = udf_code.lstrip()
-                            if udf_code.startswith("@"):
-                                udf_code = udf_code[udf_code.find("\n")+1: ].lstrip()
-                            user_function_code += udf_code + '\n'
-
+                        user_function_code = UtilFuncs._func_to_string(self.user_function)
                         output_file.write(input_file.read().format(
                             DELIMITER=self.delimiter,
                             QUOTECHAR=self.quotechar,
@@ -396,6 +389,13 @@ class _TableOperatorUtils:
                             COLUMNS_DEFINITIONS=json.dumps(self.columns_definitions),
                             OUTPUT_TYPE_CONVERTERS=json.dumps(self.output_type_converters)
                         ))
+                    elif self.operation == TableOperatorConstants.REGISTER_OP.value:
+                        # Get the source code of the user function.
+                        user_function_code = UtilFuncs._func_to_string(self.user_function)
+                        output_file.write(input_file.read().format(
+                            FUNCTION_DEFINITION=user_function_code,
+                            FUNCTION_NAME = self.user_function[0].__name__
+                        ))   
                     else:
                         # prepare script file from template file for maprow and mappartition.
                         output_file.write(
@@ -494,7 +494,6 @@ class _TableOperatorUtils:
         script_name = script_alias  # alias now contains extension also.
 
         # Extract the base name without extension.
-        from pathlib import Path
         script_base_name = Path(script_alias).stem
         return script_entry, script_alias, script_name, script_base_name
 

teradataml/table_operators/templates/dataframe_register.template

@@ -0,0 +1,69 @@
+import json
+import sys, csv
+import datetime
+import urllib.parse
+
+td_buffer = {{}}
+
+
+{FUNCTION_DEFINITION}
+
+# Decode the URL encoded string and store it back as dictionary.
+dec = urllib.parse.unquote_plus(sys.argv[1])
+script_data = json.loads(dec)
+
+# Information that is required to help with the script usage.
+#  The delimiter to use with the input and output text.
+delimiter = script_data["delimiter"]
+#  The quotechar to use.
+quotechar = script_data["qoutechar"]
+#  The names of columns in the input teradataml DataFrame.
+_input_columns = script_data["input_cols"]
+#  The names of columns in the output teradataml DataFrame.
+_output_columns = script_data["output_cols"]
+#  The types of columns in the input/output teradataml DataFrame.
+# The mapper of output column name to function arguments
+function_args = script_data["function_args"]
+#  The definition for new columns in output.
+columns_definitions = {{_output_columns[-1]: "{FUNCTION_NAME}"}}
+output_type_converters = script_data["output_type_converters"]
+for k,v in output_type_converters.items():
+    if v == 'datetime.date' or v == 'datetime.time' or v == 'datetime.datetime':
+        output_type_converters[k] = 'str'
+output_type_converters = {{k:getattr(__builtins__, v) for k,v in output_type_converters.items()}}
+
+
+
+# The entry point to the script.
+if __name__ == "__main__":
+
+    records = csv.reader(sys.stdin.readlines(), delimiter=delimiter, quotechar=quotechar)
+    for record in records:
+        record = dict(zip(_input_columns, record))
+        out_rec = []
+        for column in _output_columns:
+
+            # If it is a new column, get the value from definition.
+            if column in columns_definitions:
+                f_args = tuple()
+                # Convert the argument types first.
+                for v in function_args[column]:
+                    if v in _input_columns:
+                        c_type_ = output_type_converters.get(v)
+                        if record[v]:
+                            # If it is a float, replace the empty character.
+                            if c_type_.__name__ == 'float':
+                                arg = output_type_converters.get(v)(record[v].replace(' ', ''))
+                            else:
+                                arg = output_type_converters.get(v)(record[v])
+                        else:
+                            arg = record[v]
+                    else:
+                        arg = v
+                    f_args = f_args + (arg, )
+                func_ = globals()[columns_definitions[column]]
+                out_rec.append(output_type_converters[column](func_(*f_args)))
+            else:
+                out_rec.append(record[column])
+
+        print("{{}}".format(delimiter).join((str(i) for i in out_rec)))

teradataml/utils/dtypes.py

@@ -641,11 +641,13 @@ class _Dtypes:
 
         """
         from teradataml.dataframe.dataframe import TDSeries, TDMatrix, TDGenSeries, TDAnalyticResult
+        from teradataml.store.feature_store.feature_store import Feature
         _DtypesMappers.JSON_TD_TO_PYTHON_TYPE_MAPPER.update({"SERIES": TDSeries,
                         "MATRIX": TDMatrix,
                         "ART": TDAnalyticResult,
-                        "GENSERIES": TDGenSeries})
-
+                        "GENSERIES": TDGenSeries,
+                        "COLUMN": (str, Feature),
+                        "COLUMNS": (str, Feature)})
 
         return _DtypesMappers.JSON_TD_TO_PYTHON_TYPE_MAPPER.get(json_td_type.upper())
 

teradataml/utils/validators.py

@@ -1,3 +1,4 @@
+import enum
 import numbers
 import os
 import pandas as pd
@@ -11,6 +12,8 @@ from teradataml.options.configure import configure
 from teradataml.dataframe.sql_interfaces import ColumnExpression
 from functools import wraps, reduce
 
+from teradataml.utils.internal_buffer import _InternalBuffer
+
 
 def skip_validation():
     """
@@ -545,7 +548,7 @@ class _Validators:
                 raise TypeError("Third element in argument information matrix should be bool.")
 
             if not (isinstance(args[3], tuple) or isinstance(args[3], type) or
-                    isinstance(args[3], (_ListOf, _TupleOf))):
+                    isinstance(args[3], (_ListOf, _TupleOf)) or isinstance(args[3], enum.EnumMeta)):
                 err_msg = "Fourth element in argument information matrix should be a 'tuple of types' or 'type' type."
                 raise TypeError(err_msg)
 
@@ -2274,4 +2277,33 @@ class _Validators:
                 MessageCodes.INVALID_ARG_VALUE).format(ip_address, "ip_address",
                                                        'of four numbers (each between 0 and 255) separated by periods'))
 
+        return True
+    
+
+    @staticmethod
+    @skip_validation()
+    def _check_auth_token(func_name):
+        """
+        DESCRIPTION:
+            Check if the user has set the authentication token.
+
+        PARAMETERS:
+            func_name:
+                Required Argument.
+                Specifies the function name where the authentication token is required.
+                Types: str
+
+        RAISES:
+            TeradataMLException
+
+        RETURNS:
+            None.
+
+        EXAMPLES:
+            >>> _Validators._check_auth_token("udf")
+        """
+        if _InternalBuffer.get("auth_token") is None:
+            raise TeradataMlException(Messages.get_message(MessageCodes.AUTH_TOKEN_REQUIRED,\
+                                                           func_name), MessageCodes.AUTH_TOKEN_REQUIRED)
+        
         return True

{teradataml-20.0.0.2.dist-info → teradataml-20.0.0.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: teradataml
-Version: 20.0.0.2
+Version: 20.0.0.3
 Summary: Teradata Vantage Python package for Advanced Analytics
 Home-page: http://www.teradata.com/
 Author: Teradata Corporation
@@ -17,8 +17,8 @@ Classifier: Topic :: Database :: Front-Ends
 Classifier: License :: Other/Proprietary License
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
-Requires-Dist: teradatasql (>=17.10.0.11)
-Requires-Dist: teradatasqlalchemy (>=20.0.0.2)
+Requires-Dist: teradatasql (>=20.0.0.19)
+Requires-Dist: teradatasqlalchemy (>=20.0.0.3)
 Requires-Dist: pandas (>=0.22)
 Requires-Dist: psutil
 Requires-Dist: requests (>=2.25.1)
@@ -28,6 +28,7 @@ Requires-Dist: imbalanced-learn (>=0.8.0)
 Requires-Dist: pyjwt (>=2.8.0)
 Requires-Dist: cryptography (>=42.0.5)
 Requires-Dist: sqlalchemy (>=2.0)
+Requires-Dist: lightgbm (>=3.3.3)
 
 ## Teradata Python package for Advanced Analytics.
 
@@ -47,6 +48,187 @@ Copyright 2024, Teradata. All Rights Reserved.
 * [License](#license)
 
 ## Release Notes:
+
+#### teradataml 20.00.00.03
+
+* teradataml no longer supports setting the `auth_token` using `set_config_params()`. Users should use `set_auth_token()` to set the token. 
+
+* ##### New Features/Functionality
+  * ###### teradataml: DataFrame
+    * New Function
+      * `alias()` - Creates a DataFrame with alias name.
+    * New Properties
+      * `db_object_name` - Get the underlying database object name, on which DataFrame is created.
+
+  * ###### teradataml: GeoDataFrame
+    * New Function
+      * `alias()` - Creates a GeoDataFrame with alias name.
+
+  * ###### teradataml: DataFrameColumn a.k.a. ColumnExpression
+    * _Arithmetic Functions_
+      * `DataFrameColumn.isnan()` - Function evaluates expression to determine if the floating-point
+                                    argument is a NaN (Not-a-Number) value.
+      * `DataFrameColumn.isinf()` - Function evaluates expression to determine if the floating-point
+                                    argument is an infinite number.
+      * `DataFrameColumn.isfinite()` - Function evaluates expression to determine if it is a finite
+                                       floating value.
+
+  * ###### FeatureStore - handles feature management within the Vantage environment
+    * FeatureStore Components
+      * Feature - Represents a feature which is used in ML Modeling. 
+      * Entity - Represents the columns which serves as uniqueness for the data used in ML Modeling. 
+      * DataSource - Represents the source of Data.
+      * FeatureGroup - Collection of Feature, Entity and DataSource.
+        * Methods
+          * `apply()` - Adds Feature, Entity, DataSource to a FeatureGroup.
+          * `from_DataFrame()` - Creates a FeatureGroup from teradataml DataFrame.
+          * `from_query()` - Creates a FeatureGroup using a SQL query.
+          * `remove()` - Removes Feature, Entity, or DataSource from a FeatureGroup.
+          * `reset_labels()` - Removes the labels assigned to the FeatureGroup, that are set using `set_labels()`.
+          * `set_labels()` - Sets the Features as labels for a FeatureGroup.
+        * Properties
+          * `features` - Get the features of a FeatureGroup.
+          * `labels` - Get the labels of FeatureGroup.
+    * FeatureStore 
+      * Methods
+        * `apply()` - Adds Feature, Entity, DataSource, FeatureGroup to FeatureStore.
+        * `archive_data_source()` - Archives a specified DataSource from a FeatureStore.
+        * `archive_entity()` - Archives a specified Entity from a FeatureStore.
+        * `archive_feature()` - Archives a specified Feature from a FeatureStore.
+        * `archive_feature_group()` - Archives a specified FeatureGroup from a FeatureStore. Method archives underlying Feature, Entity, DataSource also.
+        * `delete_data_source()` - Deletes an archived DataSource.
+        * `delete_entity()` - Deletes an archived Entity.
+        * `delete_feature()` - Deletes an archived Feature.
+        * `delete_feature_group()` - Deletes an archived FeatureGroup. 
+        * `get_data_source()` - Get the DataSources associated with FeatureStore.
+        * `get_dataset()` - Get the teradataml DataFrame based on Features, Entities and DataSource from FeatureGroup.
+        * `get_entity()` - Get the Entity associated with FeatureStore.
+        * `get_feature()` - Get the Feature associated with FeatureStore.
+        * `get_feature_group()` - Get the FeatureGroup associated with FeatureStore.
+        * `list_data_sources()` - List DataSources.
+        * `list_entities()` - List Entities.
+        * `list_feature_groups()` - List FeatureGroups.
+        * `list_features()` - List Features.
+        * `list_repos()` - List available repos which are configured for FeatureStore. 
+        * `repair()` - Repairs the underlying FeatureStore schema on database.  
+        * `set_features_active()` - Marks the Features as active.
+        * `set_features_inactive()` - Marks the Features as inactive.
+        * `setup()` - Setup the FeatureStore for a repo.
+      * Property
+        * `repo` - Property for FeatureStore repo.
+        * `grant` - Property to Grant access on FeatureStore to user.
+        * `revoke` - Property to Revoke access on FeatureStore from user.
+
+  * ###### teradataml: Table Operator Functions
+    * `Image2Matrix()` - Converts an image into a matrix.
+
+  * ###### teradataml: SQLE Engine Analytic Functions
+    * New Analytics Database Analytic Functions:
+      * `CFilter()`
+      * `NaiveBayes()`
+      * `TDNaiveBayesPredict()`
+      * `Shap()`
+      * `SMOTE()`
+
+    * ###### teradataml: Unbounded Array Framework (UAF) Functions
+      * New Unbounded Array Framework(UAF) Functions:
+        * `CopyArt()`
+
+  * ###### General functions
+    * Vantage File Management Functions
+      * `list_files()` - List the installed files in Database.
+
+  * ###### OpensourceML: LightGBM
+    * teradataml adds support for lightGBM package through `OpensourceML` (`OpenML`) feature.
+      The following functionality is added in the current release:
+      * `td_lightgbm` - Interface object to run lightgbm functions and classes through Teradata Vantage.
+      Example usage below:
+        ```
+        from teradataml import td_lightgbm, DataFrame
+
+        df_train = DataFrame("multi_model_classification")
+
+        feature_columns = ["col1", "col2", "col3", "col4"]
+        label_columns = ["label"]
+        part_columns = ["partition_column_1", "partition_column_2"]
+
+        df_x = df_train.select(feature_columns)
+        df_y = df_train.select(label_columns)
+
+        # Dataset creation.
+        # Single model case.
+        obj_s = td_lightgbm.Dataset(df_x, df_y, silent=True, free_raw_data=False)
+
+        # Multi model case.
+        obj_m = td_lightgbm.Dataset(df_x, df_y, free_raw_data=False, partition_columns=part_columns)
+        obj_m_v = td_lightgbm.Dataset(df_x, df_y, free_raw_data=False, partition_columns=part_columns)
+
+        ## Model training.
+        # Single model case.
+        opt = td_lightgbm.train(params={}, train_set = obj_s, num_boost_round=30)
+
+        opt.predict(data=df_x, num_iteration=20, pred_contrib=True)
+
+        # Multi model case.
+        opt = td_lightgbm.train(params={}, train_set = obj_m, num_boost_round=30,
+                                callbacks=[td_lightgbm.record_evaluation(rec)],
+                                valid_sets=[obj_m_v, obj_m_v])
+
+        # Passing `label` argument to get it returned in output DataFrame.
+        opt.predict(data=df_x, label=df_y, num_iteration=20)
+
+        ```
+      * Added support for accessing scikit-learn APIs using exposed inteface object `td_lightgbm`.
+
+    Refer Teradata Python Package User Guide for more details of this feature, arguments, usage, examples and supportability in Vantage.
+
+  * ###### teradataml: Functions
+    * `register()` - Registers a user defined function (UDF).
+    * `call_udf()` - Calls a registered user defined function (UDF) and returns ColumnExpression.
+    * `list_udfs()` - List all the UDFs registered using 'register()' function.
+    * `deregister()` - Deregisters a user defined function (UDF).
+
+  * ###### teradataml: Options
+    * Configuration Options
+      * `table_operator` - Specifies the name of table operator.
+
+* ##### Updates
+  * ###### General functions
+    * `set_auth_token()` - Added `base_url` parameter which accepts the CCP url. 
+                           'ues_url' will be deprecated in future and users
+                           will need to specify 'base_url' instead.
+
+  * ###### teradataml: DataFrame function
+     * `join()`
+       * Now supports compound ColumExpression having more than one binary operator in `on` argument.
+       * Now supports ColumExpression containing FunctionExpression(s) in `on` argument.
+       * self-join now expects aliased DataFrame in `other` argument.
+
+  * ###### teradataml: GeoDataFrame function
+     * `join()`
+       * Now supports compound ColumExpression having more than one binary operator in `on` argument.
+       * Now supports ColumExpression containing FunctionExpression(s) in `on` argument.
+       * self-join now expects aliased DataFrame in `other` argument.
+
+  * ###### teradataml: Unbounded Array Framework (UAF) Functions
+    * `SAX()` - Default value added for `window_size` and `output_frequency`.
+    * `DickeyFuller()`
+      * Supports TDAnalyticResult as input.
+      * Default value added for `max_lags`.
+      * Removed parameter `drift_trend_formula`.
+      * Updated permitted values for `algorithm`.
+
+  * ##### teradataml: AutoML
+    * `AutoML`, `AutoRegressor` and `AutoClassifier`
+      * Now supports DECIMAL datatype as input.
+
+  * ##### teradataml: SQLE Engine Analytic Functions
+    * `TextParser()`
+      * Argument name `covert_to_lowercase` changed to `convert_to_lowercase`.
+
+* ##### Bug Fixes
+  * `db_list_tables()` now returns correct results when '%' is used.
+
 #### teradataml 20.00.00.02
 
 * teradataml will no longer be supported with SQLAlchemy < 2.0.
@@ -115,6 +297,10 @@ Copyright 2024, Teradata. All Rights Reserved.
         * `ues_url`
         * `auth_token`
 
+  * #### teradata DataFrame
+    * `to_pandas()` - Function returns the pandas dataframe with Decimal columns types as float instead of object.
+                      If user want datatype to be object, set argument `coerce_float` to False.
+
   * ###### Database Utility
       * `list_td_reserved_keywords()` - Accepts a list of strings as argument.
 
@@ -133,7 +319,7 @@ Copyright 2024, Teradata. All Rights Reserved.
 * ##### Bug Fixes
   * KNN `predict()` function can now predict on test data which does not contain target column.
   * Metrics functions are supported on the Lake system.
-  * The following OpensourceML functions from different sklearn modules are fixed.
+  * The following OpensourceML functions from different sklearn modules in single model case are fixed.
     * `sklearn.ensemble`:
       * ExtraTreesClassifier - `apply()`
       * ExtraTreesRegressor - `apply()`
@@ -146,12 +332,21 @@ Copyright 2024, Teradata. All Rights Reserved.
       * Nystroem - `transform()`, `fit_transform()`
       * PolynomialCountSketch - `transform()`, `fit_transform()`
       * RBFSampler - `transform()`, `fit_transform()`
-    * `sklearn.neighbours`:
+    * `sklearn.neighbors`:
       * KNeighborsTransformer - `transform()`, `fit_transform()`
       * RadiusNeighborsTransformer - `transform()`, `fit_transform()`
     * `sklearn.preprocessing`:
       * KernelCenterer - `transform()`
       * OneHotEncoder - `transform()`, `inverse_transform()`
+  * The following OpensourceML functions from different sklearn modules in multi model case are fixed.
+    * `sklearn.feature_selection`:
+      * SelectFpr - `transform()`, `fit_transform()`, `inverse_transform()`
+      * SelectFdr - `transform()`, `fit_transform()`, `inverse_transform()`
+      * SelectFromModel - `transform()`, `fit_transform()`, `inverse_transform()`
+      * SelectFwe - `transform()`, `fit_transform()`, `inverse_transform()`
+      * RFECV - `transform()`, `fit_transform()`, `inverse_transform()`
+    * `sklearn.clustering`:
+      * Birch - `transform()`, `fit_transform()`
   * OpensourceML returns teradataml objects for model attributes and functions instead of sklearn
     objects so that the user can perform further operations like `score()`, `predict()` etc on top
     of the returned objects.