Seperate the internal model data from the estimation algorithm

sklearn_porter/estimator/classifier/SVC/__init__.py

@@ -19,7 +19,7 @@ class SVC(Classifier):
         'c': {
             'type':     '{0}',
             'arr':      '{{{0}}}',
-            'arr[]':    '{type} {name}[] = {{{values}}};',
+            'arr[]':    '{type} {name}[{n}] = {{{values}}};',
             'arr[][]':  '{type} {name}[{n}][{m}] = {{{values}}};',
             'indent':   '    ',
         },
@@ -91,20 +91,15 @@ def __init__(self, estimator, target_language='java',
             raise ValueError(msg)
         self.params = params
 
-        # self.svs = estimator.support_vectors_
-        # self.n_svs = len(estimator.support_vectors_[0])
         self.n_features = len(estimator.support_vectors_[0])
         self.svs_rows = estimator.n_support_
         self.n_svs_rows = len(estimator.n_support_)
 
         self.weights = self.temp('arr[]', skipping=True).format(
             type='int', name='weights', values=', '.join([str(e) for e in self.svs_rows]),
             n=len(self.svs_rows))
+        self.n_weights = len(self.svs_rows)
 
-        # self.coeffs = estimator.dual_coef_
-        # self.inters = estimator._intercept_  # pylint: disable=W0212
-        # self.n_inters = len(estimator._intercept_)  # pylint: disable=W0212
-        # self.classes = estimator.classes_
         self.n_classes = len(estimator.classes_)
         self.is_binary = self.n_classes == 2
         self.prefix = 'binary' if self.is_binary else 'multi'
@@ -118,8 +113,9 @@ def __init__(self, estimator, target_language='java',
         vectors = ', '.join(vectors)
         vectors = self.temp('arr[][]', skipping=True).format(
             type='double', name='vectors', values=vectors,
-            n=len(estimator.support_vectors_), m=estimator.support_vectors_[0])
+            n=len(estimator.support_vectors_), m=len(estimator.support_vectors_[0]))
         self.vectors = vectors
+        self.n_vectors = len(estimator.support_vectors_)
 
         # Coefficients:
         coeffs = []
@@ -132,16 +128,19 @@ def __init__(self, estimator, target_language='java',
                                    values=coeffs, n=len(estimator.dual_coef_),
                                    m=len(estimator.dual_coef_[0]))
         self.coefficients = coeffs
+        self.n_coefficients = len(estimator.dual_coef_)
 
         # Interceptions:
         inters = [temp_type.format(self.repr(i)) for i in estimator._intercept_]
         inters = ', '.join(inters)
         inters = temp_arr_.format(type='double', name='intercepts',
-                                  values=inters)
+                                  values=inters, n=len(estimator._intercept_))
         self.intercepts = inters
+        self.n_intercepts = len(estimator._intercept_)
 
         # Kernel:
-        self.kernel = str(params['kernel'])
+        self.kernel = str(params['kernel'])[0] if self.target_language == 'c'\
+            else str(params['kernel'])
         self.gamma = self.repr(self.params['gamma'])
         self.coef0 = self.repr(self.params['coef0'])
         self.degree = self.repr(self.params['degree'])
@@ -196,92 +195,9 @@ def create_method(self):
         :return out : string
             The built method as string.
         """
-        temp_type = self.temp('type')
-        temp_arr = self.temp('arr')
-        temp_arr_ = self.temp('arr[]')
-        temp_arr__ = self.temp('arr[][]')
-
-        # out = '\n'
-
-        # Number of support vectors:
-        # n_svs = [temp_type.format(self.repr(v)) for v in self.svs_rows]
-        # n_svs = ', '.join(n_svs)
-        # out += temp_arr_.format(type='int', name='n_svs', values=n_svs)
-        # out += '\n'
-
-        # # Support vectors:
-        # vectors = []
-        # for vector in self.svs:
-        #     _vectors = [temp_type.format(self.repr(v)) for v in vector]
-        #     _vectors = temp_arr.format(', '.join(_vectors))
-        #     vectors.append(_vectors)
-        # vectors = ', '.join(vectors)
-        # out += self.temp('arr[][]', skipping=True).format(
-        #     type='double', name='svs', values=vectors,
-        #     n=len(self.svs), m=self.n_svs)
-        # out += '\n'
-
-        # # Coefficients:
-        # coeffs = []
-        # for coeff in self.coeffs:
-        #     _coeffs = [temp_type.format(self.repr(c)) for c in coeff]
-        #     _coeffs = temp_arr.format(', '.join(_coeffs))
-        #     coeffs.append(_coeffs)
-        # coeffs = ', '.join(coeffs)
-        # out += temp_arr__.format(type='double', name='coeffs', values=coeffs,
-        #                          n=len(self.coeffs), m=len(self.coeffs[0]))
-        # out += '\n'
-
-        # Interceptions:
-        # inters = [temp_type.format(self.repr(i)) for i in self.inters]
-        # inters = ', '.join(inters)
-        # out += temp_arr_.format(type='double', name='inters', values=inters)
-        # out += '\n'
-
-        # Classes:
-        # if not self.is_binary:
-        #     classes = [temp_type.format(self.repr(c)) for c in self.classes]
-        #     classes = ', '.join(classes)
-        #     out += temp_arr_.format(type='int', name='classes', values=classes)
-        #     out += '\n'
-
-        # # Kernels:
-        # if self.params['kernel'] == 'rbf':
-        #     name = self.prefix + '.kernel.rbf'
-        #     out += self.temp(name).format(
-        #         len(self.svs), self.n_svs,
-        #         self.repr(self.params['gamma']))
-        # elif self.params['kernel'] == 'poly':
-        #     name = self.prefix + '.kernel.poly'
-        #     out += self.temp(name).format(
-        #         len(self.svs), self.n_svs,
-        #         self.repr(self.params['gamma']),
-        #         self.repr(self.params['coef0']),
-        #         self.repr(self.params['degree']))
-        # elif self.params['kernel'] == 'sigmoid':
-        #     name = self.prefix + '.kernel.sigmoid'
-        #     out += self.temp(name).format(
-        #         len(self.svs), self.n_svs,
-        #         self.repr(self.params['gamma']),
-        #         self.repr(self.params['coef0']),
-        #         self.repr(self.params['degree']))
-        # elif self.params['kernel'] == 'linear':
-        #     name = self.prefix + '.kernel.linear'
-        #     out += self.temp(name).format(
-        #         len(self.svs), self.n_svs)
-        # out += '\n'
-
-        # # Decicion:
-        # out += self.temp('starts').format(self.n_svs_rows)
-        # out += self.temp('ends').format(self.n_svs_rows)
-        # name = self.prefix + '.decisions'
-        # out += self.temp(name).format(self.n_inters, self.n_svs_rows)
-        # name = self.prefix + '.classes'
-        # out += self.temp(name).format(self.n_inters, self.n_classes)
-        n_indents = 0 if self.target_language in ['java', 'js', 'php', 'ruby'] else 1
-        # out = self.indent(out, n_indents=2-n_indents)
-
-        method = self.temp('method', n_indents=1-n_indents,
+        n_indents = 1 if self.target_language in ['java', 'js',
+                                                  'php', 'ruby'] else 0
+        method = self.temp('method', n_indents=n_indents,
                            skipping=True).format(**self.__dict__)
         return method
 

sklearn_porter/estimator/classifier/SVC/templates/c/class.txt

@@ -2,14 +2,35 @@
 #include <stdio.h>
 #include <math.h>
 
+#define N_FEATURES {n_features}
+#define N_CLASSES {n_classes}
+#define N_VECTORS {n_vectors}
+#define N_ROWS {n_svs_rows}
+#define N_COEFFICIENTS {n_coefficients}
+#define N_INTERCEPTS {n_intercepts}
+#define KERNEL_TYPE '{kernel}'
+#define KERNEL_GAMMA {gamma}
+#define KERNEL_COEF {coef0}
+#define KERNEL_DEGREE {degree}
+
+{vectors}
+{coefficients}
+{intercepts}
+{weights}
+
 {method}
 
 int main(int argc, const char * argv[]) {{
-    float atts[argc-1];
-    int i = 0;
+
+    /* Features: */
+    double features[argc-1];
+    int i;
     for (i = 1; i < argc; i++) {{
-        atts[i-1] = atof(argv[i]);
+        features[i-1] = atof(argv[i]);
     }}
-    printf("%d", {method_name}(atts));
+
+    /* Prediction: */
+    printf("%d", {method_name}(features));
     return 0;
+
 }}