Merge pull request IntelPython#7 from SAT/feature/logreg

adding logistic regression and fixing indents in generated code

Author: fschlimb

examples/data/batch/binary_cls_test.csv

@@ -0,0 +1,61 @@
+#*******************************************************************************
+# Copyright 2014-2018 Intel Corporation
+# All Rights Reserved.
+#
+# This software is licensed under the Apache License, Version 2.0 (the
+# "License"), the following terms apply:
+#
+# 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.
+#*******************************************************************************
+
+# daal4py logistic regression example for shared memory systems
+
+import daal4py as d4p
+import numpy as np
+
+# let's try to use pandas' fast csv reader
+try:
+    import pandas
+    read_csv = lambda f, c: pandas.read_csv(f, usecols=c, delimiter=',').values
+except:
+    # fall back to numpy loadtxt
+    read_csv = lambda f, c: np.loadtxt(f, usecols=c, delimiter=',')
+
+
+def main():
+    nClasses = 2
+    nFeatures = 20
+
+    # read training data from file with 20 features per observation and 1 class label
+    trainfile = "./data/batch/binary_cls_train.csv"
+    train_data = read_csv(trainfile, range(nFeatures))
+    train_labels = read_csv(trainfile, range(nFeatures, nFeatures + 1))
+    train_labels.shape = (train_data.shape[0], 1)  # must be a 2d array
+
+    # set parameters and train
+    train_alg = d4p.logistic_regression_training(nClasses=nClasses)
+    train_result = train_alg.compute(train_data, train_labels)
+
+    # read testing data from file with 20 features per observation
+    testfile = "./data/batch/binary_cls_test.csv"
+    predict_data = read_csv(testfile, range(nFeatures))
+
+    # set parameters and compute predictions
+    predict_alg = d4p.logistic_regression_prediction(nClasses=nClasses)
+    predict_result = predict_alg.compute(predict_data, train_result.model)
+
+    # the prediction result provides prediction
+    assert predict_result.prediction.shape == (predict_data.shape[0], train_labels.shape[1])
+
+
+if __name__ == "__main__":
+    main()
+    print('All looks good!')

examples/data/batch/binary_cls_train.csv

@@ -0,0 +1,66 @@
+#*******************************************************************************
+# Copyright 2014-2018 Intel Corporation
+# All Rights Reserved.
+#
+# This software is licensed under the Apache License, Version 2.0 (the
+# "License"), the following terms apply:
+#
+# 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.
+#*******************************************************************************
+
+# daal4py logistic regression example for shared memory systems
+
+import daal4py as d4p
+import numpy as np
+
+# let's try to use pandas' fast csv reader
+try:
+    import pandas
+    read_csv = lambda f, c: pandas.read_csv(f, usecols=c, delimiter=',').values
+except:
+    # fall back to numpy loadtxt
+    read_csv = lambda f, c: np.loadtxt(f, usecols=c, delimiter=',')
+
+
+def main():
+    nClasses = 5
+    nFeatures = 6
+
+    # read training data from file with 6 features per observation and 1 class label
+    trainfile = "./data/batch/logreg_train.csv"
+    train_data = read_csv(trainfile, range(nFeatures))
+    train_labels = read_csv(trainfile, range(nFeatures, nFeatures + 1))
+    train_labels.shape = (train_data.shape[0], 1)  # must be a 2d array
+
+    # set parameters and train
+    train_alg = d4p.logistic_regression_training(nClasses=nClasses,
+                                                 penaltyL1=0.1,
+                                                 penaltyL2=0.1)
+    train_result = train_alg.compute(train_data, train_labels)
+
+    # read testing data from file with 6 features per observation
+    testfile = "./data/batch/logreg_test.csv"
+    predict_data = read_csv(testfile, range(nFeatures))
+
+    # set parameters and compute predictions
+    predict_alg = d4p.logistic_regression_prediction(nClasses=nClasses,
+                                                     resultsToCompute="computeClassesLabels|computeClassesProbabilities|computeClassesLogProbabilities")
+    predict_result = predict_alg.compute(predict_data, train_result.model)
+
+    # the prediction result provides prediction, probabilities and logProbabilities
+    assert predict_result.prediction.shape == (predict_data.shape[0], train_labels.shape[1])
+    assert predict_result.probabilities.shape == (predict_data.shape[0], nClasses)
+    assert predict_result.logProbabilities.shape == (predict_data.shape[0], nClasses)
+
+
+if __name__ == "__main__":
+    main()
+    print('All looks good!')

examples/data/batch/logreg_test.csv

@@ -257,10 +257,10 @@ def get_all_attrs(self, ns, cls, attr, ons=None):
 
 
 ###############################################################################
-    def to_lltype(self, ns, t):
+    def to_lltype(self, t):
         """
         return low level (C++ type). Usually the same as input.
-         Only very specific casesneed a conversion.
+         Only very specific cases need a conversion.
         """
         if t in ['DAAL_UINT64']:
             return 'ResultToComputeId'
@@ -290,6 +290,9 @@ def to_hltype(self, ns, t):
             return ('daal::' + thens + '::ModelPtr', 'class', tns)
         if t in ['data_management::NumericTablePtr',] or t in ifaces.values():
             return ('daal::' + t, 'class', tns)
+        if 'Batch' in self.namespace_dict[ns].classes and t in self.namespace_dict[ns].classes['Batch'].typedefs:
+            tns, tname = splitns(self.namespace_dict[ns].classes['Batch'].typedefs[t])
+            return (self.namespace_dict[ns].classes['Batch'].typedefs[t], 'class', tns)
         tt = re.sub(r'(?<!daal::)services::SharedPtr', r'daal::services::SharedPtr', t)
         tt = re.sub(r'(?<!daal::)algorithms::', r'daal::algorithms::', tt)
         if tt in ifaces.values():
@@ -612,7 +615,7 @@ def prepare_hlwrapper(self, ns, mode, func):
                             hlt = self.to_hltype(pns, parms[p])
                             if hlt and hlt[1] in ['stdtype', 'enum', 'class']:
                                 (hlt, hlt_type, hlt_ns) = hlt
-                                llt = self.to_lltype(*splitns(parms[p]))
+                                llt = self.to_lltype(parms[p])
                                 needed = True
                                 pval = None
                                 if hlt_type == 'enum':
@@ -814,6 +817,7 @@ def gen_daal4py(daalroot, outdir, warn_all=False):
                                             'decision_forest',
                                             'ridge_regression',
                                             'optimization_solver',
+                                            'logistic_regression',
     ])
     # 'ridge_regression', parametertype is a template without any need
     with open(jp(outdir, 'daal4py_cpp.h'), 'w') as f:

examples/data/batch/logreg_train.csv

@@ -45,6 +45,12 @@
     'algorithms::gbt::classification::prediction': {
         'Batch': [('nClasses', 'size_t')],
     },
+    'algorithms::logistic_regression::training': {
+        'Batch': [('nClasses', 'size_t')],
+    },
+    'algorithms::logistic_regression::prediction': {
+        'Batch': [('nClasses', 'size_t')],
+    },
     'algorithms::decision_tree::classification::training': {
         'Batch': [('nClasses', 'size_t')],
     },
@@ -100,6 +106,7 @@
     'algorithms::kmeans::init': ['nRowsTotal', 'offset',],
     'algorithms::gbt::regression::training': ['dependentVariables'],
     'algorithms::gbt::classification::training': ['weights',],
+    'algorithms::logistic_regression::training': ['weights',],
     'algorithms::decision_tree::classification::training': ['weights',],
     'algorithms::decision_forest::classification::training': ['weights', 'updatedEngine',],
     'algorithms::decision_forest::regression::training': ['algorithms::regression::training::InputId', 'updatedEngine',],
@@ -123,6 +130,7 @@
     'classifier::training::Batch': 'daal::services::SharedPtr<daal::algorithms::classifier::training::Batch>',
     'engines::BatchBase': 'daal::algorithms::engines::EnginePtr',
     'optimization_solver::sum_of_functions::Batch': 'daal::algorithms::optimization_solver::sum_of_functions::BatchPtr',
+    'optimization_solver::iterative_solver::Batch': 'daal::algorithms::optimization_solver::iterative_solver::BatchPtr',
 }
 
 # By default input arguments have no default value (e.g. they are required).
@@ -391,10 +399,12 @@
     'algorithms::decision_tree::regression': ['Result',],
     'algorithms::engines::mcg59::Batch': ['ParameterType',],
     'algorithms::engines::mt19937::Batch': ['ParameterType',],
+    'algorithms::engines::mt2203::Batch': ['ParameterType',],
     'algorithms::gbt': ['Result',],
     'algorithms::gbt::classification': ['Result',],
     'algorithms::gbt::regression': ['Result',],
     'algorithms::gbt::training': ['Result',],
+    'algorithms::logistic_regression': ['Result',],
     'algorithms::linear_model': ['Result',],
     'algorithms::linear_regression': ['Result',],
     'algorithms::linear_regression::prediction::Batch': ['ParameterType',],

examples/log_reg_binary_dense_batch.py

@@ -18,6 +18,7 @@
 #define _HLAPI_H_INCLUDED_
 
 #include <daal.h>
+#include "daal_compat.h"
 
 #include <iostream>
 #include <stdexcept>

examples/log_reg_dense_batch.py

@@ -0,0 +1,41 @@
+/*******************************************************************************
+* Copyright 2014-2018 Intel Corporation
+*
+* Licensed 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.
+*******************************************************************************/
+
+#ifndef _DAALCOMPAT_H_INCLUDED_
+#define _DAALCOMPAT_H_INCLUDED_
+
+#include <services/library_version_info.h>
+#include <services/daal_shared_ptr.h>
+
+// DAAL version < 2018 is what we are looking for.
+// Some DAAL versions seem broken, e.g. '2199' so we need to check that, too
+#if __INTEL_DAAL__ < 2019 || __INTEL_DAAL__ > 2100
+
+namespace daal {
+namespace algorithms {
+namespace optimization_solver {
+namespace iterative_solver {
+    // BatchPtr typedef not existent in older DAAL versions
+    typedef daal::services::SharedPtr<interface1::Batch> BatchPtr;
+
+}
+}
+}
+}
+
+#endif
+
+#endif // _DAALCOMPAT_H_INCLUDED_