add PrincipalFFT

Author: agrimagsrl

micromlgen/micromlgen.py

@@ -7,14 +7,16 @@
 from micromlgen.logisticregression import is_logisticregression, port_logisticregression
 from micromlgen.gaussiannb import is_gaussiannb, port_gaussiannb
 from micromlgen.pca import is_pca, port_pca
+from micromlgen.principalfft import is_principalfft, port_principalfft
 
 
 def port(
         clf,
         classname=None,
         classmap=None,
         platform=platforms.ARDUINO,
-        precision=None):
+        precision=None,
+        **kwargs):
     """Port a classifier to plain C++"""
     assert platform in platforms.ALL, 'Unknown platform %s. Use one of %s' % (platform, ', '.join(platforms.ALL))
     if is_svm(clf):
@@ -33,4 +35,6 @@ def port(
         return port_gaussiannb(**locals())
     elif is_pca(clf):
         return port_pca(**locals())
+    elif is_principalfft(clf):
+        return port_principalfft(**locals(), **kwargs)
     raise TypeError('clf MUST be one of %s' % ', '.join(platforms.ALLOWED_CLASSIFIERS))

micromlgen/platforms.py

@@ -15,5 +15,6 @@
     'RandomForest',
     'GaussianNB',
     'LogisticRegression',
-    'PCA'
+    'PCA',
+    'PrincipalFFT'
 ]

micromlgen/principalfft.py

@@ -0,0 +1,19 @@
+from micromlgen.utils import jinja, check_type
+from math import pi
+
+
+def is_principalfft(clf):
+    """Test if classifier can be ported"""
+    return check_type(clf, 'PrincipalFFT')
+
+
+def port_principalfft(clf, optimize_sin=False, lookup_cos=None, lookup_sin=None, **kwargs):
+    """Port PrincipalFFT classifier"""
+    return jinja('principalfft/principalfft.jinja', {
+        'fft': clf,
+        'PI': pi,
+        'size': len(clf.idx),
+        'optmize_sin': optimize_sin,
+        'lookup_cos': lookup_cos,
+        'lookup_sin': lookup_sin,
+    }, **kwargs)

micromlgen/templates/principalfft/lut.jinja

@@ -0,0 +1,5 @@
+const float {{ op }}LUT[{{ size }}][{{ fft.original_size }}] = {
+    {% for i in range(0, size) %}
+        { {% for n in range(0, fft.original_size) %} {{ math[op](2 * PI / fft.original_size * fft.idx[i] * n) }}, {% endfor %} },
+    {% endfor %}
+};

micromlgen/templates/principalfft/lut_bool.jinja

@@ -0,0 +1,5 @@
+const bool {{ op }}LUT[{{ size }}][{{ fft.original_size }}] = {
+    {% for i in range(0, size) %}
+        { {% for n in range(0, fft.original_size) %} {{ "true" if math[op](2 * PI / fft.original_size * fft.idx[i] * n) > 0 else "false" }}, {% endfor %} },
+    {% endfor %}
+};

micromlgen/templates/principalfft/principalfft.jinja

@@ -0,0 +1,59 @@
+void principalFFT(float *features, float *fft) {
+    // apply principal FFT (naive implementation for the top N frequencies only)
+    const int topFrequencies[] = { {{ f.to_array(fft.idx, True) }} };
+
+    {% if lookup_cos %}
+        {% with op="cos" %}
+            {% include "principalfft/lut.jinja" %}
+        {% endwith %}
+
+        {# sin lookup is available only if cos lookup is used #}
+        {% if lookup_sin %}
+            {% with op="sin" %}
+                {% include "principalfft/lut.jinja" %}
+            {% endwith %}
+        {% else %}
+            {% with op="sin" %}
+                {% include "principalfft/lut_bool.jinja" %}
+            {% endwith %}
+        {% endif %}
+    {% endif %}
+
+    for (int i = 0; i < {{ size }}; i++) {
+        const int k = topFrequencies[i];
+        {% if not lookup_cos %}
+            const float harmonic = {{ 2 * PI / fft.original_size }} * k;
+        {% endif %}
+        float re = 0;
+        float im = 0;
+
+        // optimized case
+        if (k == 0) {
+            for (int n = 0; n < {{ fft.original_size }}; n++) {
+                re += features[n];
+            }
+        }
+        else {
+            for (int n = 0; n < {{ fft.original_size }}; n++) {
+                {% if lookup_cos %}
+                    const float cos_n = cosLUT[i][n];
+
+                    {% if lookup_sin %}
+                        const float sin_n = sinLUT[i][n];
+                    {% else %}
+                        const float sin_n = sinLUT[i][n] * sqrt(1 - cos_n * cos_n);
+                    {% endif %}
+                {% else %}
+                    const float harmonicN = harmonic * n;
+                    const float cos_n = cos(harmonicN);
+                    const float sin_n = sin(harmonicN);
+                {% endif %}
+
+                re += features[n] * cos_n;
+                im -= features[n] * sin_n;
+            }
+        }
+
+        fft[i] = sqrt(re * re + im * im);
+    }
+}

micromlgen/utils.py

@@ -1,5 +1,6 @@
 import os
 import re
+from math import sin, cos
 from inspect import getmro
 from jinja2 import FileSystemLoader, Environment
 
@@ -51,16 +52,23 @@ def jinja(template_file, data, defaults=None, **kwargs):
     template = Environment(loader=loader).get_template(template_file)
     data = {k: v for k, v in data.items() if v is not None}
     kwargs = {k: v for k, v in kwargs.items() if v is not None}
+    precision = data.get('precision', 12) or 12
+    precision_fmt = '%.' + str(precision) + 'f'
     if defaults is None:
         defaults = {}
     defaults.setdefault('platform', 'arduino')
     defaults.setdefault('classmap', None)
     defaults.update({
         'f': {
             'enumerate': enumerate,
-            'round': lambda x: round(x, data.get('precision', 12) or 12),
+            'round': lambda x: round(x, precision),
             'zip': zip,
-            'signed': lambda x: '' if x == 0 else '+' + str(x) if x >= 0 else x
+            'signed': lambda x: '' if x == 0 else '+' + str(x) if x >= 0 else x,
+            'to_array': lambda x, as_int=False: ', '.join([precision_fmt % xx if not as_int else str(xx) for xx in x])
+        },
+        'math': {
+            'cos': cos,
+            'sin': sin
         }
     })
     data = {

setup.py

@@ -7,13 +7,13 @@
 setup(
   name = 'micromlgen',
   packages = ['micromlgen'],
-  version = '1.1.8',
+  version = '1.1.9',
   license='MIT',
   description = 'Generate C code for microcontrollers from Python\'s sklearn classifiers',
   author = 'Simone Salerno',
   author_email = 'eloquentarduino@gmail.com',
   url = 'https://github.com/eloquentarduino/micromlgen',
-  download_url = 'https://github.com/eloquentarduino/micromlgen/archive/v_118.tar.gz',
+  download_url = 'https://github.com/eloquentarduino/micromlgen/archive/v_119.tar.gz',
   keywords = [
     'ML',
     'microcontrollers',