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

teradataml/data/docs/sqle/docs_17_20/GetFutileColumns.py

@@ -1,4 +1,4 @@
-def GetFutileColumns(data=None, object=None, category_summary_column=None, threshold_value=None, **generic_arguments):
+def GetFutileColumns(data=None, object=None, category_summary_column='ColumnName', threshold_value=0.95, **generic_arguments):
     """
     DESCRIPTION:
         GetFutileColumns() function returns the futile column names if either
@@ -31,14 +31,16 @@ def GetFutileColumns(data=None, object=None, category_summary_column=None, thres
             Types: teradataml DataFrame or CategoricalSummary
         
         category_summary_column:
-            Required Argument.
+            Optional Argument.
             Specifies the column from categorical summary DataFrame which provides names of 
             the columns in "data".
+            Default Value: 'ColumnName'
             Types: str
         
         threshold_value:
-            Required Argument.
+            Optional Argument.
             Specifies the threshold value for the columns in "data".
+            Default Value: 0.95
             Types: float
         
         **generic_arguments:

teradataml/data/docs/sqle/docs_17_20/KMeans.py

@@ -1,6 +1,6 @@
 def KMeans(data=None, centroids_data=None, id_column=None, target_columns=None, num_clusters=None,
            seed=None, threshold=0.0395, iter_max=10, num_init=1, output_cluster_assignment=False,
-           **generic_arguments):
+           initialcentroids_method="RANDOM", **generic_arguments):
     """
     DESCRIPTION:
         The K-means() function groups a set of observations into k clusters
@@ -45,6 +45,10 @@ def KMeans(data=None, centroids_data=None, id_column=None, target_columns=None,
             Optional Argument.
             Specifies the input teradataml DataFrame containing
             set of initial centroids.
+            Note:
+                * This argument is not required if "num_clusters" provided.
+                * If provided, the function uses the initial centroids
+                  from this input.
             Types: teradataml DataFrame
 
         id_column:
@@ -105,6 +109,15 @@ def KMeans(data=None, centroids_data=None, id_column=None, target_columns=None,
             Specifies whether to output Cluster Assignment information.
             Default Value: False
             Types: bool
+        
+        initialcentroids_method:
+            Optional Argument.
+            Specifies the initialization method to be used for selecting initial set of centroids.
+            Permitted Values: 'RANDOM', 'KMEANS++'
+            Default Value: 'RANDOM'
+            Note:
+                * This argument is not required if "centroids_data" is provided.
+            Types: str
 
         **generic_arguments:
             Specifies the generic keyword arguments SQLE functions accept. Below
@@ -167,9 +180,11 @@ def KMeans(data=None, centroids_data=None, id_column=None, target_columns=None,
 
         # Load the example data.
         load_example_data("kmeans", "computers_train1")
+        load_example_data("kmeans",'kmeans_table')
 
         # Create teradataml DataFrame objects.
         computers_train1 = DataFrame.from_table("computers_train1")
+        kmeans_tab = DataFrame('kmeans_table')
 
         # Check the list of available analytic functions.
         display_analytic_functions()
@@ -191,6 +206,7 @@ def KMeans(data=None, centroids_data=None, id_column=None, target_columns=None,
         # Get the set of initial centroids by accessing the group of rows
         # from input data.
         kmeans_initial_centroids_table = computers_train1.loc[[19, 97]]
+        kmeans_initial_centroids = kmeans_tab.loc[[2, 4]]
 
         KMeans_out_1 = KMeans(id_column="id",
                               target_columns=['price', 'speed'],
@@ -201,4 +217,35 @@ def KMeans(data=None, centroids_data=None, id_column=None, target_columns=None,
         print(KMeans_out_1.result)
         print(KMeans_out_1.model_data)
 
+        # Example 3 : Grouping a set of observations into 2 clusters by
+        #             specifying the number of clusters and seed value
+        #             with output cluster assignment information.
+        obj = KMeans(data=kmeans_tab,
+             id_column='id',
+             target_columns=['c1', 'c2'],
+             threshold=0.0395,
+             iter_max=3,
+             centroids_data=kmeans_initial_centroids,
+             output_cluster_assignment=True
+            )
+             
+        # Print the result DataFrames.
+        print(obj.result)
+
+        # Example 4 : Grouping a set of observations into 3 clusters by
+        #             specifying the number of clusters for initial centroids
+        #             method as KMEANS++.
+        obj = KMeans(data=kmeans_tab,
+             id_column='id',
+             target_columns=['c1', 'c2'],
+             threshold=0.0395,
+             iter_max=3,
+             num_clusters=3,
+             output_cluster_assignment=True,
+             initialcentroids_method="KMEANS++"
+            )
+        
+        # Print the result DataFrames.
+        print(obj.result) 
+
     """

teradataml/data/docs/sqle/docs_17_20/NaiveBayes.py

@@ -0,0 +1,162 @@
+def  NaiveBayes(data = None, response_column = None, numeric_inputs = None,
+                categorical_inputs = None, attribute_name_column = None,
+                attribute_value_column = None, attribute_type = None,
+                numeric_attributes = None, categorical_attributes = None,
+                **generic_arguments):
+    """
+    DESCRIPTION:
+        Function generates classification model using NaiveBayes 
+        algorithm.
+        The Naive Bayes classification algorithm uses a training dataset with known discrete outcomes
+        and either discrete or continuous numeric input variables, along with categorical variables, to generate a model.
+        This model can then be used to predict the outcomes of future observations based on their input variable values.
+    
+    PARAMETERS:
+        data:
+            Required Argument.
+            Specifies the input teradataml DataFrame .
+            Types: teradataml DataFrame
+        
+        response_column:
+            Required Argument.
+            Specifies the name of the column in "data" containing response values.
+            Types: str
+        
+        numeric_inputs:
+            Optional Argument.
+            Specifies the names of the columns in "data" containing numeric attributes values.
+            Types: str OR list of Strings (str)
+        
+        categorical_inputs:
+            Optional Argument.
+            Specifies the names of the columns in "data" containing categorical attributes values.
+            Types: str OR list of Strings (str)
+        
+        attribute_name_column:
+            Optional Argument.
+            Specifies the names of the columns in "data" containing attributes names.
+            Types: str
+        
+        attribute_value_column:
+            Optional Argument.
+            Specifies the names of the columns in "data" containing attributes values.
+            Types: str
+        
+        attribute_type:
+            Optional Argument, Required if "data" is in sparse format and
+            both "numeric_attributes" and "categorical_attributes" are not provided.
+            Specifies the attribute type. 
+            Permitted Values: 
+                * ALLNUMERIC - if all the attributes are of numeric type.
+                * ALLCATEGORICAL - if all the attributes are of categorical type.
+            Types: str
+        
+        numeric_attributes:
+            Optional Argument.
+            Specifies the numeric attributes names.
+            Types: str OR list of strs
+        
+        categorical_attributes:
+            Optional Argument.
+            Specifies the categorical attributes names.
+            Types: str OR list of strs
+        
+        **generic_arguments:
+            Specifies the generic keyword arguments SQLE functions accept. Below 
+            are the generic keyword arguments:
+                persist:
+                    Optional Argument.
+                    Specifies whether to persist the results of the 
+                    function in a table or not. When set to True, 
+                    results are persisted in a table; otherwise, 
+                    results are garbage collected at the end of the 
+                    session.
+                    Default Value: False
+                    Types: bool
+                
+                volatile:
+                    Optional Argument.
+                    Specifies whether to put the results of the 
+                    function in a volatile table or not. When set to 
+                    True, results are stored in a volatile table, 
+                    otherwise not.
+                    Default Value: False
+                    Types: bool
+                    
+            Function allows the user to partition, hash, order or local 
+            order the input data. These generic arguments are available 
+            for each argument that accepts teradataml DataFrame as 
+            input and can be accessed as:    
+                * "<input_data_arg_name>_partition_column" accepts str or 
+                    list of str (Strings)
+                * "<input_data_arg_name>_hash_column" accepts str or list 
+                    of str (Strings)
+                * "<input_data_arg_name>_order_column" accepts str or list 
+                    of str (Strings)
+                * "local_order_<input_data_arg_name>" accepts boolean
+            Note:
+                These generic arguments are supported by teradataml if 
+                the underlying SQL Engine function supports, else an 
+                exception is raised.
+    
+    RETURNS:
+        Instance of  NaiveBayes.
+        Output teradataml DataFrames can be accessed using attribute 
+        references, such as  NaiveBayesObj.<attribute_name>.
+        Output teradataml DataFrame attribute name is:
+            result
+    
+    
+    RAISES:
+        TeradataMlException, TypeError, ValueError
+    
+    
+    EXAMPLES:
+        # Notes:
+        #     1. Get the connection to Vantage, before importing the 
+        #        function in user space.
+        #     2. User can import the function, if it is available on 
+        #        Vantage user is connected to.
+        #     3. To check the list of analytic functions available on 
+        #        Vantage user connected to, use 
+        #        "display_analytic_functions()".
+        
+        # Load the example data.
+        load_example_data("decisionforestpredict", ["housing_train", "housing_test"])
+        
+        # Create teradataml DataFrame objects.
+        housing_train = DataFrame.from_table("housing_train")
+        
+        # Check the list of available analytic functions.
+        display_analytic_functions()
+        
+        # Import function  NaiveBayes.
+        from teradataml import  NaiveBayes
+        
+        # Example 1: NaiveBayes function to generate classification model using Dense input.
+        NaiveBayes_out = NaiveBayes(data=housing_train, response_column='homestyle', 
+                                    numeric_inputs=['price','lotsize','bedrooms','bathrms','stories','garagepl'], 
+                                    categorical_inputs=['driveway','recroom','fullbase','gashw','airco','prefarea'])
+        
+        # Print the result DataFrame.
+        print( NaiveBayes_out.result)
+
+        # Example 2: NaiveBayes function to generate classification model using Sparse input.
+        
+        # Unpivoting the data for sparse input to naive bayes.
+        upvt_data = Unpivoting(data = housing_train, id_column = 'sn',
+                               target_columns = ['price','lotsize','bedrooms','bathrms','stories','garagepl','driveway',
+                                                 'recroom','fullbase','gashw','airco','prefarea'],
+                               attribute_column = "AttributeName", value_column = "AttributeValue",
+                               accumulate = 'homestyle')
+
+        NaiveBayes_out = NaiveBayes(data=upvt_data.result, 
+                                    response_column='homestyle',
+                                    attribute_name_column='AttributeName', 
+                                    attribute_value_column='AttributeValue',
+                                    numeric_attributes=['price','lotsize','bedrooms','bathrms','stories','garagepl'], 
+                                    categorical_attributes=['driveway','recroom','fullbase','gashw','airco','prefarea'])
+
+        # Print the result DataFrame.
+        print( NaiveBayes_out.result)
+    """

teradataml/data/docs/sqle/docs_17_20/NonLinearCombineFit.py

@@ -1,5 +1,5 @@
 def NonLinearCombineFit(data=None, target_columns=None, formula=None,
-                        result_column=None, **generic_arguments):
+                        result_column='TD_CombinedValue', **generic_arguments):
     """
     DESCRIPTION:
         The NonLinearCombineFit() function returns the target columns and a 
@@ -31,9 +31,10 @@ def NonLinearCombineFit(data=None, target_columns=None, formula=None,
             Types: str
         
         result_column:
-            Required Argument.
+            Optional Argument.
             Specifies the name of the new feature column generated by the Transform function.
             This function saves the specified formula in this column.
+            Default Value: 'TD_CombinedValue'
             Types: str
         
         **generic_arguments:

teradataml/data/docs/sqle/docs_17_20/OneHotEncodingFit.py

@@ -12,6 +12,11 @@ def OneHotEncodingFit(data=None, category_data=None, target_column=None,
             * This function requires the UTF8 client character set for UNICODE data.
             * This function does not support Pass Through Characters (PTCs).
             * This function does not support KanjiSJIS or Graphic data types.
+            * For input to be considered as sparse input, column names should be
+              provided for 'data_partition_column' argument.
+            * In case of dense input, only allowed value for 'data_partition_column'
+              is PartitionKind.ANY and that for 'category_data_partition_column' is
+              PartitionKind.DIMENSION.
 
     PARAMETERS:
         data:

teradataml/data/docs/sqle/docs_17_20/OneHotEncodingTransform.py

@@ -3,6 +3,12 @@ def OneHotEncodingTransform(data=None, object=None, is_input_dense=None, **gener
     DESCRIPTION:
         Function encodes specified attributes and categorical values as one-hot numeric vectors,
         using OneHotEncodingFit() function output.
+        Notes:
+            * In case of sparse input, neither 'data_partition_column' nor
+              'object_partition_column' can be used independently.
+            * In case of dense input, if 'data_partition_column' is having value
+              PartitionKind.ANY, then 'object_partition_column' should have value
+              PartitionKind.DIMENSION.
 
 
     PARAMETERS:

teradataml/data/docs/sqle/docs_17_20/OutlierFilterFit.py

@@ -16,6 +16,8 @@ def OutlierFilterFit(data=None, target_columns=None, group_columns=None, lower_p
             * For information about PTCs, see Teradata Vantage™ - Analytics
               Database International Character Set Support.
             * This function does not support KanjiSJIS or Graphic data types.
+            * This function does not support "data_partition_column" and "data_order_column" 
+              if the corresponding Vantage version is greater than or equal to 17.20.03.20.
 
 
     PARAMETERS:

teradataml/data/docs/sqle/docs_17_20/Pivoting.py

@@ -0,0 +1,279 @@
+def Pivoting(data = None, partition_columns = None, target_columns = None,
+             accumulate = None, rows_per_partition = None, pivot_column = None,
+             pivot_keys = None, pivot_keys_alias = None, default_pivot_values = None,
+             aggregation = None, delimiters = None, combined_column_sizes = None,
+             truncate_columns = None, output_column_names = None,
+             **generic_arguments):
+        
+    
+    """
+    DESCRIPTION:
+        Function pivots the data, that is, changes the data from 
+        sparse format to dense format.
+        Notes:
+            * 'data_partition_column' is required argument for partitioning the input data.
+            * Provide either the 'rows_per_partition', 'pivot_column', or 'aggregation' arguments 
+              along with required arguments.
+
+    PARAMETERS:
+        data:
+            Required Argument.
+            Specifies the input teradataml DataFrame to be pivoted.
+            Types: teradataml DataFrame
+        
+        partition_columns:
+            Required Argument.
+            Specifies the name of the column(s) in "data" on which to partition the 
+            input.
+            Types: str OR list of Strings (str)
+        
+        target_columns:
+            Required Argument.
+            Specifies the name of the column(s) in "data" which contains the data for 
+            pivoting.
+            Types: str OR list of Strings (str)
+        
+        accumulate:
+            Optional Argument.
+            Specifies the name of the column(s) in "data" to copy to the output. 
+            By default, the function copies no input table columns to the output.
+            Types: str OR list of Strings (str)
+        
+        rows_per_partition:
+            Optional Argument.
+            Specifies the maximum number of rows in the partition.
+            Types: int
+        
+        pivot_column:
+            Optional Argument.
+            Specifies the name of the column in "data" that contains the pivot keys.
+            Note:
+                * This argument is not needed when 'rows_per_partition' is provided.
+            Types: str
+        
+        pivot_keys:
+            Optional Argument.
+            Specifies the names of the pivot keys, if "pivot_column" is specified. 
+            Notes:
+                * This argument is not needed when 'rows_per_partition' is provided.
+                * 'pivot_keys' are required when 'pivot_column' is specified.
+            Types: str OR list of Strings (str)
+        
+        pivot_keys_alias:
+            Optional Argument.
+            Specifies the alias names of the pivot keys, if 'pivot_column' is specified.
+            Note:
+                * This argument is not needed when 'rows_per_partition' is provided.
+            Types: str OR list of Strings (str)
+        
+        default_pivot_values:
+            Optional Argument.
+            Specifies one default value for each pivot_key. The nth 
+            default_pivot_value applies to the nth pivot_key.
+            Note:
+                * This argument is not needed when 'rows_per_partition' is provided.
+            Types: str OR list of Strings (str)
+        
+        aggregation:
+            Optional Argument.
+            Specifies the aggregation for the target columns. 
+            Provide a single value {CONCAT | UNIQUE_CONCAT | SUM | 
+            MIN | MAX | AVG}  which will be applicable to all target columns or 
+            specify multiple values for multiple target columns in 
+            following format: ['ColumnName:{CONCAT|UNIQUE_CONCAT|SUM|MIN|MAX|AVG}',...].
+            Types: str OR list of Strings (str)
+        
+        delimiters:
+            Optional Argument.
+            Specifies the delimiter to be used for concatenating the values of a target column. 
+            Provide a single delimiter value applicable to all target columns or 
+            specify multiple delimiter values for multiple target columns 
+            in the following format: ['ColumnName:single_char',...].
+            Note:
+                * This argument is not needed when 'aggregation' is not specified.
+            Types: str OR list of Strings (str)
+        
+        combined_column_sizes:
+            Optional Argument.
+            Specifies the maximum size of the concatenated string.
+            Provide a single integer value that applies to all target columns or 
+            specify multiple size values for multiple target columns 
+            in the following format ['ColumnName:size_value',...].
+            Note:
+                * This argument is not needed when 'aggregation' is not specified.
+            Types: int OR  str OR list of Strings (str)
+        
+        truncate_columns:
+            Optional Argument.
+            Specifies columns from the target columns for which 
+            to truncate the concatenated string if it exceeds the specified size.
+            Note:
+                * This argument is not needed when 'aggregation' is not specified.
+            Types: str OR list of Strings (str)
+        
+        output_column_names:
+            Optional Argument.
+            Specifies the column name to be used for the output column. The nth 
+            column name value applies to the nth output column.
+            Types: str OR list of Strings (str)
+        
+        **generic_arguments:
+            Specifies the generic keyword arguments SQLE functions accept. Below 
+            are the generic keyword arguments:
+                persist:
+                    Optional Argument.
+                    Specifies whether to persist the results of the 
+                    function in a table or not. When set to True, 
+                    results are persisted in a table; otherwise, 
+                    results are garbage collected at the end of the 
+                    session.
+                    Default Value: False
+                    Types: bool
+                
+                volatile:
+                    Optional Argument.
+                    Specifies whether to put the results of the 
+                    function in a volatile table or not. When set to 
+                    True, results are stored in a volatile table, 
+                    otherwise not.
+                    Default Value: False
+                    Types: bool
+                    
+            Function allows the user to partition, hash, order or local 
+            order the input data. These generic arguments are available 
+            for each argument that accepts teradataml DataFrame as 
+            input and can be accessed as:    
+                * "<input_data_arg_name>_partition_column" accepts str or 
+                    list of str (Strings)
+                * "<input_data_arg_name>_hash_column" accepts str or list 
+                    of str (Strings)
+                * "<input_data_arg_name>_order_column" accepts str or list 
+                    of str (Strings)
+                * "local_order_<input_data_arg_name>" accepts boolean
+            Note:
+                These generic arguments are supported by teradataml if 
+                the underlying SQL Engine function supports, else an 
+                exception is raised.
+    
+    RETURNS:
+        Instance of  Pivoting.
+        Output teradataml DataFrames can be accessed using attribute 
+        references, such as  PivotingObj.<attribute_name>.
+        Output teradataml DataFrame attribute name is:
+            result
+    
+    
+    RAISES:
+        TeradataMlException, TypeError, ValueError
+    
+    
+    EXAMPLES:
+        # Notes:
+        #     1. Get the connection to Vantage, before importing the 
+        #        function in user space.
+        #     2. User can import the function, if it is available on 
+        #        Vantage user is connected to.
+        #     3. To check the list of analytic functions available on 
+        #        Vantage user connected to, use 
+        #        "display_analytic_functions()".
+        
+        # Load the example data.
+        load_example_data('unpivot', 'titanic_dataset_unpivoted')
+        load_example_data('unpivot', 'star_pivot')
+        
+        # Create teradataml DataFrame objects.
+        titanic_unpvt = DataFrame.from_table('titanic_dataset_unpivoted')
+        star = DataFrame.from_table('star_pivot')
+        
+        # Check the list of available analytic functions.
+        display_analytic_functions()
+        
+        # Import function  Pivoting.
+        from teradataml import  Pivoting
+        
+        # Example 1 : Pivot the input data using 'rows_per_partition'.
+        pvt1 = Pivoting(data = titanic_unpvt, 
+                        partition_columns = 'passenger', 
+                        target_columns = 'AttributeValue',
+                        accumulate = 'survived', 
+                        rows_per_partition = 2,
+                        data_partition_column='passenger',
+                        data_order_column='AttributeName')
+        
+        # Print the result DataFrame.
+        print( pvt1.result)
+
+        # Example 2 : Pivot the input data using 'pivot_column' and 'pivot_keys'.
+        pvt2 = Pivoting(data = titanic_unpvt, 
+                        partition_columns = 'passenger', 
+                        target_columns = 'AttributeValue',
+                        accumulate = 'survived', 
+                        pivot_column = 'AttributeName',
+                        pivot_keys = ['pclass','gender'],
+                        data_partition_column = 'passenger')
+
+        # Print the result DataFrame.
+        print( pvt2.result)
+
+        # Example 3 : Pivot the input data with multiple target columns and
+        #             multiple aggregation functions.
+        pvt3 = Pivoting(data = star, 
+                        partition_columns = ['country', 'state'],
+                        target_columns = ['sales', 'cogs', 'rating'],
+                        accumulate = 'yr',
+                        pivot_column = 'qtr',
+                        pivot_keys = ['Q1','Q2','Q3'],
+                        aggregation = ['sales:SUM','cogs:AVG','rating:CONCAT'],
+                        delimiters = '|', 
+                        combined_column_sizes = 64001,
+                        data_partition_column = ['country', 'state'],
+                        data_order_column = ['qtr'])
+
+        # Print the result DataFrame.
+        print( pvt3.result)
+
+        # Example 4 : Pivot the input data with multiple target columns and
+        #             multiple aggregation functions.
+        pvt4 = Pivoting(data = star, 
+                        partition_columns = 'country', 
+                        target_columns = ['sales', 'cogs', 'state','rating'],
+                        accumulate = 'yr', 
+                        aggregation = ['sales:SUM','cogs:AVG','state:UNIQUE_CONCAT','rating:CONCAT'], 
+                        delimiters = '|', 
+                        combined_column_sizes = ['state:5', 'rating:10'],
+                        data_partition_column='country',
+                        data_order_column='state')
+
+        # Print the result DataFrame.
+        print( pvt4.result)
+
+        # Example 5 : Pivot the input data with truncate columns.
+        pvt5 = Pivoting(data = star, 
+                        partition_columns = ['state'],
+                        target_columns = ['country', 'rating'],
+                        accumulate = 'yr',
+                        pivot_column = 'qtr',
+                        pivot_keys = ['Q1','Q2','Q3'],
+                        aggregation = 'CONCAT',
+                        combined_column_sizes = 10,
+                        truncate_columns = 'country',
+                        data_partition_column = 'qtr',
+                        data_order_column='state')
+
+        # Print the result DataFrame.
+        print( pvt5.result)
+
+        # Example 6 : Pivot the input data with output column names.
+        pvt6 = Pivoting(data = star, 
+                        partition_columns = ['country','state'],
+                        target_columns = ['sales', 'cogs', 'rating'],
+                        accumulate = 'yr',
+                        rows_per_partition = 3,
+                        output_column_names=['sales_q1','sales_q2','sales_q3','cogs_q1','cogs_q2',
+                                             'cogs_q3','rating_q1','rating_q2','rating_q3'],
+                        data_partition_column = 'qtr',
+                        data_order_column=['country','state'])
+
+        # Print the result DataFrame.
+        print( pvt6.result)
+    """

teradataml/data/docs/sqle/docs_17_20/ROC.py

@@ -1,4 +1,4 @@
-def ROC(data=None, probability_column=None, observation_column=None, model_id_column=None, positive_label=None,
+def ROC(data=None, probability_column=None, observation_column=None, model_id_column=None, positive_class='1',
         num_thresholds=50, auc=True, gini=True, **generic_arguments):
     """
     DESCRIPTION:
@@ -48,8 +48,9 @@ def ROC(data=None, probability_column=None, observation_column=None, model_id_co
             Types: str
 
         positive_class:
-            Required Argument.
+            Optional Argument.
             Specifies the label of the positive class.
+            Default Value: '1'
             Types: str
 
         num_thresholds:

teradataml/data/docs/sqle/docs_17_20/SVMPredict.py

@@ -1,5 +1,6 @@
 def SVMPredict(object=None, newdata=None, id_column=None, accumulate=None,
-               output_prob=False, output_responses=None, **generic_arguments):
+               output_prob=False, output_responses=None, model_type='Classification',
+               **generic_arguments):
     """
     DESCRIPTION:
         The SVMPredict() function uses the model generated by the function SVM() to
@@ -57,6 +58,15 @@ def SVMPredict(object=None, newdata=None, id_column=None, accumulate=None,
             Note:
                 Only applicable when "output_prob" is 'True'.
             Types: str OR list of strs
+        
+        model_type:
+            Optional Argument.
+            Specifies the type of the analysis.
+            Note:
+                * Required for Regression problem.
+            Permitted Values: 'Classification', 'Regression'
+            Default Value: 'Classification'
+            Types: str
 
         **generic_arguments:
             Specifies the generic keyword arguments SQLE functions accept. Below
@@ -155,7 +165,8 @@ def SVMPredict(object=None, newdata=None, id_column=None, accumulate=None,
         SVMPredict_out1 = SVMPredict(newdata=transform_obj.result,
                                      object=svm_obj1.result,
                                      id_column="id",
-                                     accumulate="MedHouseVal"
+                                     accumulate="MedHouseVal",
+                                     model_type="Regression"
                                      )
 
         # Print the result DataFrame.