Integrate Gluon generator

pom.xml

@@ -19,6 +19,7 @@
     <CNNTrain.version>0.2.6</CNNTrain.version>
     <cnnarch-mxnet-generator.version>0.2.14-SNAPSHOT</cnnarch-mxnet-generator.version>
     <cnnarch-caffe2-generator.version>0.2.11-SNAPSHOT</cnnarch-caffe2-generator.version>
+    <cnnarch-gluon-generator.version>0.1.5</cnnarch-gluon-generator.version>
     <embedded-montiarc-math-opt-generator>0.1.4</embedded-montiarc-math-opt-generator>
 
         <!-- .. Libraries .................................................. -->
@@ -73,6 +74,12 @@
             <version>${cnnarch-mxnet-generator.version}</version>
         </dependency>
 
+        <dependency>
+            <groupId>de.monticore.lang.monticar</groupId>
+            <artifactId>cnnarch-gluon-generator</artifactId>
+            <version>${cnnarch-gluon-generator.version}</version>
+        </dependency>
+
         <dependency>
             <groupId>de.monticore.lang.monticar</groupId>
             <artifactId>cnnarch-caffe2-generator</artifactId>

src/main/java/de/monticore/lang/monticar/emadl/generator/Backend.java

@@ -2,6 +2,8 @@ package de.monticore.lang.monticar.emadl.generator;
 
 
 import de.monticore.lang.monticar.cnnarch.CNNArchGenerator;
+import de.monticore.lang.monticar.cnnarch.gluongenerator.CNNArch2Gluon;
+import de.monticore.lang.monticar.cnnarch.gluongenerator.CNNTrain2Gluon;
 import de.monticore.lang.monticar.cnnarch.mxnetgenerator.CNNArch2MxNet;
 import de.monticore.lang.monticar.cnnarch.caffe2generator.CNNArch2Caffe2;
 import de.monticore.lang.monticar.cnnarch.mxnetgenerator.CNNTrain2MxNet;
@@ -30,6 +32,16 @@ public enum Backend {
         public CNNTrainGenerator getCNNTrainGenerator() {
             return new CNNTrain2Caffe2();
         }
+    },
+    GLUON{
+        @Override
+        public CNNArchGenerator getCNNArchGenerator() {
+            return new CNNArch2Gluon();
+        }
+        @Override
+        public CNNTrainGenerator getCNNTrainGenerator() {
+            return new CNNTrain2Gluon();
+        }
     };
 
     public abstract CNNArchGenerator getCNNArchGenerator();
@@ -43,6 +55,9 @@ public enum Backend {
             case "CAFFE2":
                 return Optional.of(CAFFE2);
 
+            case "GLUON":
+                return Optional.of(GLUON);
+
             default:
                 return Optional.empty();
         }
@@ -52,8 +67,10 @@ public enum Backend {
         switch (backend){
             case CAFFE2:
                 return "CAFFE2";
+            case GLUON:
+                return "GLUON";
             default:
                 return "MXNET";
         }
     }
-}
+}
\ No newline at end of file

src/main/java/de/monticore/lang/monticar/emadl/generator/EMADLGenerator.java

@@ -160,7 +160,7 @@ public class EMADLGenerator {
 
             printWriter.println("#!/bin/bash");
             printWriter.println("cd " + getGenerationTargetPath());
-            printWriter.println("mkdir --parents build");
+            printWriter.println("mkdir -p build");
             printWriter.println("cd build");
             printWriter.println("cmake ..");
             printWriter.println("make");

src/test/java/de/monticore/lang/monticar/emadl/GenerationTest.java

@@ -160,6 +160,31 @@ public class GenerationTest extends AbstractSymtabTest {
                         "CNNTrainer_mnist_mnistClassifier_net.py"));
     }
 
+    @Test
+    public void testMnistClassifierForGluon() throws IOException, TemplateException {
+        Log.getFindings().clear();
+        String[] args = {"-m", "src/test/resources/models/", "-r", "mnist.MnistClassifier", "-b", "GLUON", "-f", "n", "-c", "n"};
+        EMADLGeneratorCli.main(args);
+        assertTrue(Log.getFindings().isEmpty());
+
+        checkFilesAreEqual(
+                Paths.get("./target/generated-sources-emadl"),
+                Paths.get("./src/test/resources/target_code/gluon"),
+                Arrays.asList(
+                        "CNNBufferFile.h",
+                        "CNNNet_mnist_mnistClassifier_net.py",
+                        "mnist_mnistClassifier.cpp",
+                        "mnist_mnistClassifier.h",
+                        "CNNCreator_mnist_mnistClassifier_net.py",
+                        "CNNPredictor_mnist_mnistClassifier_net.h",
+                        "mnist_mnistClassifier_net.h",
+                        "HelperA.h",
+                        "CNNTranslator.h",
+                        "mnist_mnistClassifier_calculateClass.h",
+                        "CNNTrainer_mnist_mnistClassifier_net.py",
+                        "mnist_mnistClassifier_net.h"));
+    }
+
     @Test
     public void testHashFunction() {
         EMADLGenerator tester = new EMADLGenerator(Backend.MXNET);

src/test/java/de/monticore/lang/monticar/emadl/IntegrationGluonTest.java

+/**
+ *
+ *  ******************************************************************************
+ *  MontiCAR Modeling Family, www.se-rwth.de
+ *  Copyright (c) 2017, Software Engineering Group at RWTH Aachen,
+ *  All rights reserved.
+ *
+ *  This project is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Lesser General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 3.0 of the License, or (at your option) any later version.
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ *  Lesser General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Lesser General Public
+ *  License along with this project. If not, see <http://www.gnu.org/licenses/>.
+ * *******************************************************************************
+ */
+package de.monticore.lang.monticar.emadl;
+
+public class IntegrationGluonTest extends IntegrationTest {
+    public IntegrationGluonTest() {
+        super("GLUON", "39253EC049D4A4E5FA0536AD34874B9D#1DBAEE1B1BD83FB7CB5F70AE91B29638#C4C23549E737A759721D6694C75D9771#5AF0CE68E408E8C1F000E49D72AC214A");
+    }
+}

src/test/resources/target_code/gluon/CNNBufferFile.h

+#ifndef CNNBUFFERFILE_H
+#define CNNBUFFERFILE_H
+
+#include <stdio.h>
+#include <iostream>
+#include <fstream>
+
+// Read file to buffer
+class BufferFile {
+ public :
+    std::string file_path_;
+    int length_;
+    char* buffer_;
+
+    explicit BufferFile(std::string file_path)
+    :file_path_(file_path) {
+
+        std::ifstream ifs(file_path.c_str(), std::ios::in | std::ios::binary);
+        if (!ifs) {
+            std::cerr << "Can't open the file. Please check " << file_path << ". \n";
+            length_ = 0;
+            buffer_ = NULL;
+            return;
+        }
+
+        ifs.seekg(0, std::ios::end);
+        length_ = ifs.tellg();
+        ifs.seekg(0, std::ios::beg);
+        std::cout << file_path.c_str() << " ... "<< length_ << " bytes\n";
+
+        buffer_ = new char[sizeof(char) * length_];
+        ifs.read(buffer_, length_);
+        ifs.close();
+    }
+
+    int GetLength() {
+        return length_;
+    }
+    char* GetBuffer() {
+        return buffer_;
+    }
+
+    ~BufferFile() {
+        if (buffer_) {
+          delete[] buffer_;
+          buffer_ = NULL;
+        }
+    }
+};
+
+#endif // CNNBUFFERFILE_H

src/test/resources/target_code/gluon/CNNCreator_mnist_mnistClassifier_net.py

+import mxnet as mx
+import logging
+import os
+import errno
+import shutil
+import h5py
+import sys
+import numpy as np
+import time
+from mxnet import gluon, autograd, nd
+from CNNNet_mnist_mnistClassifier_net import Net
+
+@mx.init.register
+class MyConstant(mx.init.Initializer):
+    def __init__(self, value):
+        super(MyConstant, self).__init__(value=value)
+        self.value = value
+    def _init_weight(self, _, arr):
+        arr[:] = mx.nd.array(self.value)
+
+class CNNCreator_mnist_mnistClassifier_net:
+
+    _data_dir_ = "data/mnist.LeNetNetwork/"
+    _model_dir_ = "model/mnist.LeNetNetwork/"
+    _model_prefix_ = "model"
+    _input_names_ = ['image']
+    _input_shapes_ = [(1,28,28)]
+    _output_names_ = ['predictions_label']
+
+    def __init__(self):
+        self.weight_initializer = mx.init.Normal()
+        self.net = None
+
+    def load(self, context):
+        lastEpoch = 0
+        param_file = None
+
+        try:
+            os.remove(self._model_dir_ + self._model_prefix_ + "_newest-0000.params")
+        except OSError:
+            pass
+        try:
+            os.remove(self._model_dir_ + self._model_prefix_ + "_newest-symbol.json")
+        except OSError:
+            pass
+
+        if os.path.isdir(self._model_dir_):
+            for file in os.listdir(self._model_dir_):
+                if ".params" in file and self._model_prefix_ in file:
+                    epochStr = file.replace(".params","").replace(self._model_prefix_ + "-","")
+                    epoch = int(epochStr)
+                    if epoch > lastEpoch:
+                        lastEpoch = epoch
+                        param_file = file
+        if param_file is None:
+            return 0
+        else:
+            logging.info("Loading checkpoint: " + param_file)
+            self.net.load_parameters(self._model_dir_ + param_file)
+            return lastEpoch
+
+
+    def load_data(self, batch_size):
+        train_h5, test_h5 = self.load_h5_files()
+
+        data_mean = train_h5[self._input_names_[0]][:].mean(axis=0)
+        data_std = train_h5[self._input_names_[0]][:].std(axis=0) + 1e-5
+
+        train_iter = mx.io.NDArrayIter(train_h5[self._input_names_[0]],
+                                       train_h5[self._output_names_[0]],
+                                       batch_size=batch_size,
+                                       data_name=self._input_names_[0],
+                                       label_name=self._output_names_[0])
+        test_iter = None
+        if test_h5 != None:
+            test_iter = mx.io.NDArrayIter(test_h5[self._input_names_[0]],
+                                          test_h5[self._output_names_[0]],
+                                          batch_size=batch_size,
+                                          data_name=self._input_names_[0],
+                                          label_name=self._output_names_[0])
+        return train_iter, test_iter, data_mean, data_std
+
+    def load_h5_files(self):
+        train_h5 = None
+        test_h5 = None
+        train_path = self._data_dir_ + "train.h5"
+        test_path = self._data_dir_ + "test.h5"
+        if os.path.isfile(train_path):
+            train_h5 = h5py.File(train_path, 'r')
+            if not (self._input_names_[0] in train_h5 and self._output_names_[0] in train_h5):
+                logging.error("The HDF5 file '" + os.path.abspath(train_path) + "' has to contain the datasets: "
+                              + "'" + self._input_names_[0] + "', '" + self._output_names_[0] + "'")
+                sys.exit(1)
+            test_iter = None
+            if os.path.isfile(test_path):
+                test_h5 = h5py.File(test_path, 'r')
+                if not (self._input_names_[0] in test_h5 and self._output_names_[0] in test_h5):
+                    logging.error("The HDF5 file '" + os.path.abspath(test_path) + "' has to contain the datasets: "
+                                  + "'" + self._input_names_[0] + "', '" + self._output_names_[0] + "'")
+                    sys.exit(1)
+            else:
+                logging.warning("Couldn't load test set. File '" + os.path.abspath(test_path) + "' does not exist.")
+            return train_h5, test_h5
+        else:
+            logging.error("Data loading failure. File '" + os.path.abspath(train_path) + "' does not exist.")
+            sys.exit(1)
+
+
+    def train(self, batch_size=64,
+              num_epoch=10,
+              eval_metric='acc',
+              optimizer='adam',
+              optimizer_params=(('learning_rate', 0.001),),
+              load_checkpoint=True,
+              context='gpu',
+              checkpoint_period=5,
+              normalize=True):
+        if context == 'gpu':
+            mx_context = mx.gpu()
+        elif context == 'cpu':
+            mx_context = mx.cpu()
+        else:
+            logging.error("Context argument is '" + context + "'. Only 'cpu' and 'gpu are valid arguments'.")
+
+        if 'weight_decay' in optimizer_params:
+            optimizer_params['wd'] = optimizer_params['weight_decay']
+            del optimizer_params['weight_decay']
+        if 'learning_rate_decay' in optimizer_params:
+            min_learning_rate = 1e-08
+            if 'learning_rate_minimum' in optimizer_params:
+                min_learning_rate = optimizer_params['learning_rate_minimum']
+                del optimizer_params['learning_rate_minimum']
+            optimizer_params['lr_scheduler'] = mx.lr_scheduler.FactorScheduler(
+                                                   optimizer_params['step_size'],
+                                                   factor=optimizer_params['learning_rate_decay'],
+                                                   stop_factor_lr=min_learning_rate)
+            del optimizer_params['step_size']
+            del optimizer_params['learning_rate_decay']
+
+
+        train_iter, test_iter, data_mean, data_std = self.load_data(batch_size)
+        if self.net == None:
+            if normalize:
+                self.construct(context=mx_context, data_mean=nd.array(data_mean), data_std=nd.array(data_std))
+            else:
+                self.construct(context=mx_context)
+
+        begin_epoch = 0
+        if load_checkpoint:
+            begin_epoch = self.load(mx_context)
+        else:
+            if os.path.isdir(self._model_dir_):
+                shutil.rmtree(self._model_dir_)
+
+        try:
+            os.makedirs(self._model_dir_)
+        except OSError:
+            if not os.path.isdir(self._model_dir_):
+                raise
+
+        trainer = mx.gluon.Trainer(self.net.collect_params(), optimizer, optimizer_params)
+
+        if self.net.last_layer == 'softmax':
+            loss_function = mx.gluon.loss.SoftmaxCrossEntropyLoss()
+        elif self.net.last_layer == 'sigmoid':
+            loss_function = mx.gluon.loss.SigmoidBinaryCrossEntropyLoss()
+        elif self.net.last_layer == 'linear':
+            loss_function = mx.gluon.loss.L2Loss()
+        else: # TODO: Change default?
+            loss_function = mx.gluon.loss.L2Loss()
+            logging.warning("Invalid last_layer, defaulting to L2 loss")
+
+        speed_period = 50
+        tic = None
+
+        for epoch in range(begin_epoch, begin_epoch + num_epoch):
+            train_iter.reset()
+            for batch_i, batch in enumerate(train_iter):
+                data = batch.data[0].as_in_context(mx_context)
+                label = batch.label[0].as_in_context(mx_context)
+                with autograd.record():
+                    output = self.net(data)
+                    loss = loss_function(output, label)
+
+                loss.backward()
+                trainer.step(batch_size)
+
+                if tic is None:
+                    tic = time.time()
+                else:
+                    if batch_i % speed_period == 0:
+                        try:
+                            speed = speed_period * batch_size / (time.time() - tic)
+                        except ZeroDivisionError:
+                            speed = float("inf")
+
+                        logging.info("Epoch[%d] Batch[%d] Speed: %.2f samples/sec" % (epoch, batch_i, speed))
+
+                        tic = time.time()
+
+            tic = None
+
+            train_iter.reset()
+            metric = mx.metric.create(eval_metric)
+            for batch_i, batch in enumerate(train_iter):
+                data = batch.data[0].as_in_context(mx_context)
+                label = batch.label[0].as_in_context(mx_context)
+                output = self.net(data)
+                predictions = mx.nd.argmax(output, axis=1)
+                metric.update(preds=predictions, labels=label)
+            train_metric_score = metric.get()[1]
+
+            test_iter.reset()
+            metric = mx.metric.create(eval_metric)
+            for batch_i, batch in enumerate(test_iter):
+                data = batch.data[0].as_in_context(mx_context)
+                label = batch.label[0].as_in_context(mx_context)
+                output = self.net(data)
+                predictions = mx.nd.argmax(output, axis=1)
+                metric.update(preds=predictions, labels=label)
+            test_metric_score = metric.get()[1]
+
+            logging.info("Epoch[%d] Train: %f, Test: %f" % (epoch, train_metric_score, test_metric_score))
+
+            if (epoch - begin_epoch) % checkpoint_period == 0:
+                self.net.save_parameters(self._model_dir_ + self._model_prefix_ + '-' + str(epoch).zfill(4) + '.params')
+
+        self.net.save_parameters(self._model_dir_ + self._model_prefix_ + '-'
+                                 + str(num_epoch + begin_epoch).zfill(4) + '.params')
+        self.net.export(self._model_dir_ + self._model_prefix_ + '_newest', epoch=0)
+
+
+    def construct(self, context, data_mean=None, data_std=None):
+        self.net = Net(data_mean=data_mean, data_std=data_std)
+        self.net.collect_params().initialize(self.weight_initializer, ctx=context)
+        self.net.hybridize()
+        self.net(mx.nd.zeros((1,)+self._input_shapes_[0], ctx=context))
+
+        if not os.path.exists(self._model_dir_):
+            os.makedirs(self._model_dir_)
+
+        self.net.export(self._model_dir_ + self._model_prefix_, epoch=0)

src/test/resources/target_code/gluon/CNNNet_mnist_mnistClassifier_net.py

+import mxnet as mx
+import numpy as np
+from mxnet import gluon
+
+class Softmax(gluon.HybridBlock):
+    def __init__(self, **kwargs):
+        super(Softmax, self).__init__(**kwargs)
+
+    def hybrid_forward(self, F, x):
+        return F.softmax(x)
+
+
+class Split(gluon.HybridBlock):
+    def __init__(self, num_outputs, axis=1, **kwargs):
+        super(Split, self).__init__(**kwargs)
+        with self.name_scope():
+            self.axis = axis
+            self.num_outputs = num_outputs
+
+    def hybrid_forward(self, F, x):
+        return F.split(data=x, axis=self.axis, num_outputs=self.num_outputs)
+
+
+class Concatenate(gluon.HybridBlock):
+    def __init__(self, dim=1, **kwargs):
+        super(Concatenate, self).__init__(**kwargs)
+        with self.name_scope():
+            self.dim = dim
+
+    def hybrid_forward(self, F, *x):
+        return F.concat(*x, dim=self.dim)
+
+
+class ZScoreNormalization(gluon.HybridBlock):
+    def __init__(self, data_mean, data_std, **kwargs):
+        super(ZScoreNormalization, self).__init__(**kwargs)
+        with self.name_scope():
+            self.data_mean = self.params.get('data_mean', shape=data_mean.shape,
+                init=mx.init.Constant(data_mean.asnumpy().tolist()), differentiable=False)
+            self.data_std = self.params.get('data_std', shape=data_mean.shape,
+                init=mx.init.Constant(data_std.asnumpy().tolist()), differentiable=False)
+
+    def hybrid_forward(self, F, x, data_mean, data_std):
+        x = F.broadcast_sub(x, data_mean)
+        x = F.broadcast_div(x, data_std)
+        return x
+
+
+class Padding(gluon.HybridBlock):
+    def __init__(self, padding, **kwargs):
+        super(Padding, self).__init__(**kwargs)
+        with self.name_scope():
+            self.pad_width = padding
+
+    def hybrid_forward(self, F, x):
+        x = F.pad(data=x,
+            mode='constant',
+            pad_width=self.pad_width,
+            constant_value=0)
+        return x
+
+
+class NoNormalization(gluon.HybridBlock):
+    def __init__(self, **kwargs):
+        super(NoNormalization, self).__init__(**kwargs)
+
+    def hybrid_forward(self, F, x):
+        return x
+
+
+class Net(gluon.HybridBlock):
+    def __init__(self, data_mean=None, data_std=None, **kwargs):
+        super(Net, self).__init__(**kwargs)
+        with self.name_scope():
+            if not data_mean is None:
+                assert(not data_std is None)
+                self.input_normalization = ZScoreNormalization(data_mean=data_mean, data_std=data_std)
+            else:
+                self.input_normalization = NoNormalization()
+
+            self.conv1_ = gluon.nn.Conv2D(channels=20,
+                kernel_size=(5,5),
+                strides=(1,1),
+                use_bias=True)
+            # conv1_, output shape: {[20,24,24]}
+
+            self.pool1_ = gluon.nn.MaxPool2D(
+                pool_size=(2,2),
+                strides=(2,2))
+            # pool1_, output shape: {[20,12,12]}
+
+            self.conv2_ = gluon.nn.Conv2D(channels=50,
+                kernel_size=(5,5),
+                strides=(1,1),
+                use_bias=True)
+            # conv2_, output shape: {[50,8,8]}
+
+            self.pool2_ = gluon.nn.MaxPool2D(
+                pool_size=(2,2),
+                strides=(2,2))
+            # pool2_, output shape: {[50,4,4]}
+
+            self.fc2_flatten = gluon.nn.Flatten()
+            self.fc2_ = gluon.nn.Dense(units=500, use_bias=True)
+            # fc2_, output shape: {[500,1,1]}
+
+            self.relu2_ = gluon.nn.Activation(activation='relu')
+            self.fc3_ = gluon.nn.Dense(units=10, use_bias=True)
+            # fc3_, output shape: {[10,1,1]}
+
+
+        self.last_layer = 'softmax'
+
+
+    def hybrid_forward(self, F, x):
+        image = self.input_normalization(x)
+        conv1_ = self.conv1_(image)
+        pool1_ = self.pool1_(conv1_)
+        conv2_ = self.conv2_(pool1_)
+        pool2_ = self.pool2_(conv2_)
+        fc2_flatten_ = self.fc2_flatten(pool2_)
+        fc2_ = self.fc2_(fc2_flatten_)
+        relu2_ = self.relu2_(fc2_)
+        fc3_ = self.fc3_(relu2_)