caffe2 test

src/test/java/de/monticore/lang/monticar/emadl/IntegrationCaffe2Test.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;
+
+import de.monticore.lang.monticar.emadl.generator.Backend;
+import de.monticore.lang.monticar.emadl.generator.EMADLGenerator;
+import de.monticore.lang.monticar.emadl.generator.EMADLGeneratorCli;
+import de.se_rwth.commons.logging.Log;
+import freemarker.template.TemplateException;
+import org.junit.Before;
+import org.junit.Test;
+
+import java.io.IOException;
+import java.nio.charset.Charset;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.Arrays;
+import java.util.List;
+
+import static junit.framework.TestCase.assertTrue;
+import static org.junit.Assert.assertFalse;
+
+public class IntegrationCaffe2Test extends AbstractSymtabTest {
+
+    @Before
+    public void setUp() {
+        // ensure an empty log
+        Log.getFindings().clear();
+        Log.enableFailQuick(false);
+    }
+
+    
+
+    @Test
+    public void testDontRetrain() {
+        // The training hash is stored during the first training, so the second one is skipped
+        Log.getFindings().clear();
+        String[] args = {"-m", "src/test/resources/models/", "-r", "cNNCalculator.Network", "-b", "CAFFE2"};
+        EMADLGeneratorCli.main(args);
+        assertTrue(Log.getFindings().isEmpty());
+        
+        Log.getFindings().clear();
+        EMADLGeneratorCli.main(args);
+        assertTrue(Log.getFindings().size() == 1);
+        assertTrue(Log.getFindings().get(0).getMsg().contains("skipped"));
+    }
+
+}

src/test/resources/models/cNNCalculator/Add.emadl

+package cNNCalculator;
+
+component Add{
+    ports
+            in Z(0:999) num1,
+            in Z(0:999) num2,
+            out Z(0:1998) sum;
+
+    implementation Math{
+        sum = num1 + num2;
+    }
+}

src/test/resources/models/cNNCalculator/ArgMax.emadl

+package cNNCalculator;
+
+component ArgMax<Z(1:oo) n = 2>{
+    ports in Q^{n} inputVector,
+          out Z(0:oo) maxIndex,
+          out Q maxValue;
+
+    implementation Math{
+         maxIndex = 0;
+         maxValue = inputVector(1);
+
+         for i = 2:n
+            if inputVector(i) > maxValue
+                maxIndex = i - 1;
+                maxValue = inputVector(i);
+            end
+         end
+    }
+}

src/test/resources/models/cNNCalculator/Calculator.emadl

+package cNNCalculator;
+
+component Calculator {
+        ports  
+                in Q(0:1)^10 in1_1,
+                in Q(0:1)^10 in1_2,
+                in Q(0:1)^10 in1_3,
+                in Q(0:1)^10 in2_1,
+                in Q(0:1)^10 in2_2,
+                in Q(0:1)^10 in2_3,
+
+                out Z(0:1998) out1;
+        
+        instance ArgMax<10> number1_ones;
+        instance ArgMax<10> number1_tens;
+        instance ArgMax<10> number1_hundreds;
+        instance ArgMax<10> number2_ones;
+        instance ArgMax<10> number2_tens;
+        instance ArgMax<10> number2_hundreds;
+        instance DigitCombiner number1;
+        instance DigitCombiner number2;
+        instance Add add;
+        
+
+        connect in1_1 -> number1_hundreds.inputVector;
+        connect in1_2 -> number1_tens.inputVector;
+        connect in1_3 -> number1_ones.inputVector;
+        connect in2_1 -> number2_hundreds.inputVector;
+        connect in2_2 -> number2_tens.inputVector;
+        connect in2_3 -> number2_ones.inputVector;
+
+        connect number1_ones.maxIndex -> number1.ones;
+        connect number1_tens.maxIndex -> number1.tens;
+        connect number1_hundreds.maxIndex -> number1.hundreds;
+        connect number2_ones.maxIndex -> number2.ones;
+        connect number2_tens.maxIndex -> number2.tens;
+        connect number2_hundreds.maxIndex -> number2.hundreds;
+
+        connect number1.number -> add.num1;
+        connect number2.number -> add.num2;
+
+        connect add.sum -> out1;
+
+}

src/test/resources/models/cNNCalculator/Connector.emadl

+package cNNCalculator;
+
+component Connector {
+    ports in Z(0:255)^{1, 28, 28} image1,
+          in Z(0:255)^{1, 28, 28} image2,
+          in Z(0:255)^{1, 28, 28} image3,
+          in Z(0:255)^{1, 28, 28} image4,
+          in Z(0:255)^{1, 28, 28} image5,
+          in Z(0:255)^{1, 28, 28} image6,
+          out Z(0:1998) res;
+
+    instance Network<10> predictor1;
+    instance Network<10> predictor2;
+    instance Network<10> predictor3;
+    instance Network<10> predictor4;
+    instance Network<10> predictor5;
+    instance Network<10> predictor6;
+    instance Calculator cal;
+
+    instance ArgMax<10> maxi;
+
+    connect image1 -> predictor1.image;
+    connect image2 -> predictor2.image;
+    connect image3 -> predictor3.image;
+    connect image4 -> predictor4.image;
+    connect image5 -> predictor5.image;
+    connect image6 -> predictor6.image;
+
+    connect predictor1.predictions -> cal.in1_1;
+    connect predictor2.predictions -> cal.in1_2;
+    connect predictor3.predictions -> cal.in1_3;
+    connect predictor4.predictions -> cal.in2_1;
+    connect predictor5.predictions -> cal.in2_2;
+    connect predictor6.predictions -> cal.in2_3;
+
+    connect cal.out1 -> res;
+
+}

src/test/resources/models/cNNCalculator/DigitCombiner.emadl

+package cNNCalculator;
+
+component DigitCombiner{
+    ports
+            in Z(0:9) hundreds,
+            in Z(0:9) tens,
+            in Z(0:9) ones,
+            out Z(0:999) number;
+
+    implementation Math{
+        number = ones + 10 * tens + 100 * hundreds;
+    }
+}

src/test/resources/models/cNNCalculator/Network.cnnt

+configuration Network{
+     num_epoch:11
+     batch_size:64
+     context:gpu
+     eval_metric:accuracy
+     optimizer:adam{
+         learning_rate:0.001
+         learning_rate_policy:fixed
+         weight_decay:0.001
+         epsilon:0.00000001
+         beta1:0.9
+         beta2:0.999
+     }
+}

src/test/resources/models/cNNCalculator/Network.emadl

+package cNNCalculator;
+
+component Network<Z(2:oo) classes = 10>{
+    ports in Z(0:255)^{1, 28, 28} image,
+         out Q(0:1)^{classes} predictions;
+
+    implementation CNN {
+        image ->
+        Convolution(kernel=(5,5), channels=20, padding="valid") ->
+        Pooling(pool_type="max", kernel=(2,2), stride=(2,2), padding="valid") ->
+        Convolution(kernel=(5,5), channels=50, padding="valid") ->
+        Pooling(pool_type="max", kernel=(2,2), stride=(2,2), padding="valid") ->
+        FullyConnected(units=500) ->
+        Relu() ->
+        FullyConnected(units=classes) ->
+        Softmax() ->
+        predictions
+
+    }
+}

src/test/resources/models/cNNCalculator/VGG16.cnnt

+configuration VGG16{
+    num_epoch:1
+    batch_size:64
+    normalize:true
+    load_checkpoint:false
+    optimizer:adam{
+        learning_rate:0.01
+        learning_rate_decay:0.8
+        step_size:1000
+        weight_decay: 0.01
+    }
+}
+

src/test/resources/models/cNNCalculator/VGG16.emadl

+package cNNCalculator;
+
+component VGG16{
+    ports in Z(0:255)^{1, 28, 28} image,
+         out Q(0:1)^{10} predictions;
+
+         implementation CNN {
+
+             def conv(filter, channels){
+                 Convolution(kernel=(filter,filter), channels=channels) ->
+                 Relu()
+             }
+             def fc(){
+                 FullyConnected(units=100) ->
+                 Relu() ->
+                 Dropout(p=0.5)
+             }
+
+             image ->
+             conv(filter=2, channels=64, ->=2) ->
+             Pooling(pool_type="max", kernel=(2,2), stride=(1,1)) ->
+             fc() ->
+             FullyConnected(units=10) ->
+             Softmax() ->
+             predictions
+         }
+  }

src/test/resources/models/data_paths.txt

 
 cifar10.CifarNetwork src/test/resources/training_data
+cNNCalculator.Network src/test/resources/training_data
 MultipleOutputs data/MultipleOutputs
 InstanceTest.NetworkB data/InstanceTest.NetworkB
 Alexnet data/Alexnet
@@ -7,4 +8,4 @@ ThreeInputCNN_M14 data/ThreeInputCNN_M14
 VGG16 data/VGG16
 ResNeXt50 data/ResNeXt50
 instanceTestCifar.CifarNetwork src/test/resources/training_data
-mnist.LeNetNetwork data/mnist.LeNetNetwork
\ No newline at end of file
+mnist.LeNetNetwork data/mnist.LeNetNetwork