[MINOR] Update Python generated builtins

Author: Baunsgaard

src/main/python/systemds/operator/algorithm/__init__.py

@@ -61,6 +61,7 @@
 from .builtin.fit_pipeline import fit_pipeline 
 from .builtin.fixInvalidLengths import fixInvalidLengths 
 from .builtin.fixInvalidLengthsApply import fixInvalidLengthsApply 
+from .builtin.flattenQuantile import flattenQuantile 
 from .builtin.frameSort import frameSort 
 from .builtin.frequencyEncode import frequencyEncode 
 from .builtin.frequencyEncodeApply import frequencyEncodeApply 
@@ -113,11 +114,15 @@
 from .builtin.lmPredict import lmPredict 
 from .builtin.lmPredictStats import lmPredictStats 
 from .builtin.logSumExp import logSumExp 
+from .builtin.mae import mae 
+from .builtin.mape import mape 
 from .builtin.matrixProfile import matrixProfile 
 from .builtin.mcc import mcc 
 from .builtin.mdedup import mdedup 
 from .builtin.mice import mice 
 from .builtin.miceApply import miceApply 
+from .builtin.mse import mse 
+from .builtin.msmape import msmape 
 from .builtin.msvm import msvm 
 from .builtin.msvmPredict import msvmPredict 
 from .builtin.multiLogReg import multiLogReg 
@@ -127,6 +132,7 @@
 from .builtin.naiveBayesPredict import naiveBayesPredict 
 from .builtin.normalize import normalize 
 from .builtin.normalizeApply import normalizeApply 
+from .builtin.nrmse import nrmse 
 from .builtin.outlier import outlier 
 from .builtin.outlierByArima import outlierByArima 
 from .builtin.outlierByIQR import outlierByIQR 
@@ -138,8 +144,10 @@
 from .builtin.pcaTransform import pcaTransform 
 from .builtin.pnmf import pnmf 
 from .builtin.ppca import ppca 
+from .builtin.psnr import psnr 
 from .builtin.randomForest import randomForest 
 from .builtin.randomForestPredict import randomForestPredict 
+from .builtin.rmse import rmse 
 from .builtin.scale import scale 
 from .builtin.scaleApply import scaleApply 
 from .builtin.scaleMinMax import scaleMinMax 
@@ -149,7 +157,9 @@
 from .builtin.sherlockPredict import sherlockPredict 
 from .builtin.shortestPath import shortestPath 
 from .builtin.sigmoid import sigmoid 
+from .builtin.skewness import skewness 
 from .builtin.slicefinder import slicefinder 
+from .builtin.smape import smape 
 from .builtin.smote import smote 
 from .builtin.softmax import softmax 
 from .builtin.split import split 
@@ -215,6 +225,7 @@
  'fit_pipeline',
  'fixInvalidLengths',
  'fixInvalidLengthsApply',
+ 'flattenQuantile',
  'frameSort',
  'frequencyEncode',
  'frequencyEncodeApply',
@@ -267,11 +278,15 @@
  'lmPredict',
  'lmPredictStats',
  'logSumExp',
+ 'mae',
+ 'mape',
  'matrixProfile',
  'mcc',
  'mdedup',
  'mice',
  'miceApply',
+ 'mse',
+ 'msmape',
  'msvm',
  'msvmPredict',
  'multiLogReg',
@@ -281,6 +296,7 @@
  'naiveBayesPredict',
  'normalize',
  'normalizeApply',
+ 'nrmse',
  'outlier',
  'outlierByArima',
  'outlierByIQR',
@@ -292,8 +308,10 @@
  'pcaTransform',
  'pnmf',
  'ppca',
+ 'psnr',
  'randomForest',
  'randomForestPredict',
+ 'rmse',
  'scale',
  'scaleApply',
  'scaleMinMax',
@@ -303,7 +321,9 @@
  'sherlockPredict',
  'shortestPath',
  'sigmoid',
+ 'skewness',
  'slicefinder',
+ 'smape',
  'smote',
  'softmax',
  'split',

src/main/python/systemds/operator/algorithm/builtin/decisionTree.py

@@ -70,6 +70,12 @@ def decisionTree(X: Matrix,
         candidates at tree nodes: m = ceil(num_features^max_features)
     :param max_values: Parameter controlling the number of values per feature used
         as split candidates: nb = ceil(num_values^max_values)
+    :param max_dataratio: Parameter in [0,1] controlling when to materialize data
+        subsets of X and y on node splits. When set to 0, we always
+        scan the original X and y, which has the benefit of avoiding
+        the allocation and maintenance of data for all active nodes.
+        When set to 0.01 we rematerialize whenever the sub-tree data
+        would be less than 1% of last the parent materialize data size.
     :param impurity: Impurity measure: entropy, gini (default), rss (regression)
     :param seed: Fixed seed for randomization of samples and split candidates
     :param verbose: Flag indicating verbose debug output

src/main/python/systemds/operator/algorithm/builtin/flattenQuantile.py

@@ -0,0 +1,48 @@
+# -------------------------------------------------------------
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+# -------------------------------------------------------------
+
+# Autogenerated By   : src/main/python/generator/generator.py
+# Autogenerated From : scripts/builtin/flattenQuantile.dml
+
+from typing import Dict, Iterable
+
+from systemds.operator import OperationNode, Matrix, Frame, List, MultiReturn, Scalar
+from systemds.script_building.dag import OutputType
+from systemds.utils.consts import VALID_INPUT_TYPES
+
+
+def flattenQuantile(X: Matrix,
+                    P: Matrix):
+    """
+     Returns the quantiles requested, but treating the input matrix X as a flattened matrix
+     to return quantiles of all cells as if it was a continuous allocation.
+    
+    
+    
+    :param X: Matrix with values to extract quantiles from.
+    :param P: Quantiles to extract as well if empty matrix not calculated
+    :return: Quantiles calculated
+    """
+
+    params_dict = {'X': X, 'P': P}
+    return Matrix(X.sds_context,
+        'flattenQuantile',
+        named_input_nodes=params_dict)

src/main/python/systemds/operator/algorithm/builtin/mae.py

@@ -0,0 +1,59 @@
+# -------------------------------------------------------------
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+# -------------------------------------------------------------
+
+# Autogenerated By   : src/main/python/generator/generator.py
+# Autogenerated From : scripts/builtin/mae.dml
+
+from typing import Dict, Iterable
+
+from systemds.operator import OperationNode, Matrix, Frame, List, MultiReturn, Scalar
+from systemds.script_building.dag import OutputType
+from systemds.utils.consts import VALID_INPUT_TYPES
+
+
+def mae(X: Matrix,
+        Y: Matrix,
+        **kwargs: Dict[str, VALID_INPUT_TYPES]):
+    """
+     Returns the means absolute error between the two inputs
+    
+    
+    
+    :param X: First Matrix to compare
+    :param Y: Second Matrix to compare
+    :param P: Quantiles to extract as well if empty matrix not calculated
+    :return: Mean absolute error
+    :return: Quantiles calculated
+    """
+
+    params_dict = {'X': X, 'Y': Y}
+    params_dict.update(kwargs)
+    
+    vX_0 = Matrix(X.sds_context, '')
+    vX_1 = Matrix(X.sds_context, '')
+    output_nodes = [vX_0, vX_1, ]
+
+    op = MultiReturn(X.sds_context, 'mae', output_nodes, named_input_nodes=params_dict)
+
+    vX_0._unnamed_input_nodes = [op]
+    vX_1._unnamed_input_nodes = [op]
+
+    return op

src/main/python/systemds/operator/algorithm/builtin/mape.py

@@ -0,0 +1,65 @@
+# -------------------------------------------------------------
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+# -------------------------------------------------------------
+
+# Autogenerated By   : src/main/python/generator/generator.py
+# Autogenerated From : scripts/builtin/mape.dml
+
+from typing import Dict, Iterable
+
+from systemds.operator import OperationNode, Matrix, Frame, List, MultiReturn, Scalar
+from systemds.script_building.dag import OutputType
+from systemds.utils.consts import VALID_INPUT_TYPES
+
+
+def mape(X: Matrix,
+         Y: Matrix,
+         **kwargs: Dict[str, VALID_INPUT_TYPES]):
+    """
+     Returns the means absolute percentage error between the two inputs
+    
+    
+     Monash Time Series Forecasting Archive
+     Rakshitha Godahewaa,∗, Christoph Bergmeira , Geoffrey I. Webba , Rob J. Hyndmanb ,
+     Pablo Montero-Mansoc
+    
+    
+    
+    
+    :param X: First Matrix to compare
+    :param Y: Second Matrix to compare
+    :param P: Quantiles to extract as well if empty matrix not calculated
+    :return: Mean absolute percentage error
+    :return: Quantiles calculated
+    """
+
+    params_dict = {'X': X, 'Y': Y}
+    params_dict.update(kwargs)
+    
+    vX_0 = Matrix(X.sds_context, '')
+    vX_1 = Matrix(X.sds_context, '')
+    output_nodes = [vX_0, vX_1, ]
+
+    op = MultiReturn(X.sds_context, 'mape', output_nodes, named_input_nodes=params_dict)
+
+    vX_0._unnamed_input_nodes = [op]
+    vX_1._unnamed_input_nodes = [op]
+
+    return op

src/main/python/systemds/operator/algorithm/builtin/mse.py

@@ -0,0 +1,59 @@
+# -------------------------------------------------------------
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+# -------------------------------------------------------------
+
+# Autogenerated By   : src/main/python/generator/generator.py
+# Autogenerated From : scripts/builtin/mse.dml
+
+from typing import Dict, Iterable
+
+from systemds.operator import OperationNode, Matrix, Frame, List, MultiReturn, Scalar
+from systemds.script_building.dag import OutputType
+from systemds.utils.consts import VALID_INPUT_TYPES
+
+
+def mse(X: Matrix,
+        Y: Matrix,
+        **kwargs: Dict[str, VALID_INPUT_TYPES]):
+    """
+     Returns the means square error between the two inputs
+    
+    
+    
+    :param X: First Matrix to compare
+    :param Y: Second Matrix to compare
+    :param P: Quantiles to extract as well if empty matrix not calculated
+    :return: Mean Square error
+    :return: Quantiles calculated
+    """
+
+    params_dict = {'X': X, 'Y': Y}
+    params_dict.update(kwargs)
+    
+    vX_0 = Matrix(X.sds_context, '')
+    vX_1 = Matrix(X.sds_context, '')
+    output_nodes = [vX_0, vX_1, ]
+
+    op = MultiReturn(X.sds_context, 'mse', output_nodes, named_input_nodes=params_dict)
+
+    vX_0._unnamed_input_nodes = [op]
+    vX_1._unnamed_input_nodes = [op]
+
+    return op