Merge pull request #472 from aseemw/dev/coremltools_3.0_release

aseemw · web-flow · commit 97be3f420a65 · 2019-10-04T12:30:33.000-07:00
3.0 release
diff --git a/README.md b/README.md
@@ -5,12 +5,12 @@ Core ML community tools contains all supporting tools for Core ML model
 conversion and validation. This includes scikit-learn, LIBSVM, Caffe,
 Keras and XGBoost.
 
-coremltools 3.0 beta
+coremltools 3.0
 --------------------
-[Release notes](https://github.com/apple/coremltools/releases/tag/v3.0-beta)
+[Release notes](https://github.com/apple/coremltools/releases/)
 ```shell
 # Install using pip
-pip install coremltools==3.0b6
+pip install coremltools==3.0
 ```
 
 API
diff --git a/coremltools/models/model.py b/coremltools/models/model.py
@@ -102,11 +102,6 @@ def _get_proxy_and_spec(filename, use_cpu_only=False):
             # version of the engine can support so we'll not try to have a proxy object
             return None, specification
 
-        # check if there are custom layers
-        if _has_custom_layer(specification):
-            # custom layers can't be supported directly by compiling and loading the model here
-            return None, specification
-
         try:
             return _MLModelProxy(filename, use_cpu_only), specification
         except RuntimeError as e:
diff --git a/coremltools/test/test_keras2.py b/coremltools/test/test_keras2.py
@@ -1159,13 +1159,87 @@ def test_updatable_model_flag_no_loss_optimizer(self):
         """
         import coremltools
         from keras.layers import Dense
-        from keras.losses import categorical_crossentropy
+        updatable = Sequential()
+        updatable.add(Dense(128, input_shape=(16,)))
+        updatable.add(Dense(10, name="foo", activation='softmax',
+                            trainable=True))
+        input = ['data']
+        output = ['output']
+        cml = coremltools.converters.keras.convert(
+            updatable, input, output, respect_trainable=True
+        )
+        spec = cml.get_spec()
+        self.assertTrue(spec.isUpdatable)
+        layers = spec.neuralNetwork.layers
+        self.assertIsNotNone(layers[1].innerProduct)
+        self.assertTrue(layers[1].innerProduct)
+        self.assertTrue(layers[1].isUpdatable)
+
+    # when loss was specified as a string the converter had failed to work.
+    def test_updatable_model_flag_mse_string_adam(self):
+        """
+        Tests the 'respect_trainable' flag when used along with string
+        for the loss(here mse), conversion is successful
+        """
+        import coremltools
+        from keras.layers import Dense
+        from keras.optimizers import Adam
+
+        updatable = Sequential()
+        updatable.add(Dense(128, input_shape=(16,)))
+        updatable.add(Dense(10, name="foo", activation='relu',
+                            trainable=True))
+        updatable.compile(loss='mean_squared_error',
+                          optimizer=Adam(lr=1.0, beta_1=0.5, beta_2=0.75,
+                                         epsilon=0.25),
+                          metrics=['accuracy'])
+        input = ['data']
+        output = ['output']
+        cml = coremltools.converters.keras.convert(
+            updatable, input, output, respect_trainable=True
+        )
+        spec = cml.get_spec()
+        self.assertTrue(spec.isUpdatable)
+        layers = spec.neuralNetwork.layers
+        self.assertIsNotNone(layers[1].innerProduct)
+        self.assertTrue(layers[1].innerProduct)
+        self.assertTrue(layers[1].isUpdatable)
+
+        self.assertEqual(len(spec.neuralNetwork.updateParams.lossLayers), 1)
+        # check that mean squared error input name and output name is set
+        # check length is non-zero for mse
+        self.assertTrue(len(spec.neuralNetwork.updateParams.lossLayers[
+                            0].meanSquaredErrorLossLayer.input))
+        self.assertTrue(len(spec.neuralNetwork.updateParams.lossLayers[
+                                0].meanSquaredErrorLossLayer.target))
+        # check length is 0 for cce
+        self.assertFalse(len(spec.neuralNetwork.updateParams.lossLayers[
+                                0].categoricalCrossEntropyLossLayer.input))
+        self.assertFalse(len(spec.neuralNetwork.updateParams.lossLayers[
+                                 0].categoricalCrossEntropyLossLayer.target))
+
+        adopt = spec.neuralNetwork.updateParams.optimizer.adamOptimizer
+        # verify default values
+        self.assertEqual(adopt.learningRate.defaultValue, 1.0)
+        self.assertEqual(adopt.beta1.defaultValue, 0.5)
+        self.assertEqual(adopt.beta2.defaultValue, 0.75)
+        self.assertEqual(adopt.eps.defaultValue, 0.25)
+
+    def test_updatable_model_flag_cce_string_sgd(self):
+        """
+        Tests the 'respect_trainable' flag when used along with string
+        for the loss(here cce), conversion is successful
+        """
+        import coremltools
+        from keras.layers import Dense
         from keras.optimizers import SGD
 
         updatable = Sequential()
         updatable.add(Dense(128, input_shape=(16,)))
         updatable.add(Dense(10, name="foo", activation='softmax',
                             trainable=True))
+        updatable.compile(loss='categorical_crossentropy',
+                          optimizer=SGD(lr=1.0), metrics=['accuracy'])
         input = ['data']
         output = ['output']
         cml = coremltools.converters.keras.convert(
@@ -1177,3 +1251,97 @@ def test_updatable_model_flag_no_loss_optimizer(self):
         self.assertIsNotNone(layers[1].innerProduct)
         self.assertTrue(layers[1].innerProduct)
         self.assertTrue(layers[1].isUpdatable)
+        self.assertEqual(len(spec.neuralNetwork.updateParams.lossLayers), 1)
+
+        # check that cce input name and output name is set
+        # check length is non-zero for cce
+        self.assertTrue(len(spec.neuralNetwork.updateParams.lossLayers[
+                            0].categoricalCrossEntropyLossLayer.input))
+        self.assertTrue(len(spec.neuralNetwork.updateParams.lossLayers[
+                                0].categoricalCrossEntropyLossLayer.target))
+        # check length is 0 for mse
+        self.assertFalse(len(spec.neuralNetwork.updateParams.lossLayers[
+                                0].meanSquaredErrorLossLayer.input))
+        self.assertFalse(len(spec.neuralNetwork.updateParams.lossLayers[
+                                 0].meanSquaredErrorLossLayer.target))
+
+        sgdopt = spec.neuralNetwork.updateParams.optimizer.sgdOptimizer
+        self.assertEqual(sgdopt.learningRate.defaultValue, 1.0)
+        self.assertEqual(sgdopt.miniBatchSize.defaultValue, 16)
+        self.assertEqual(sgdopt.momentum.defaultValue, 0.0)
+
+    
+    def test_updatable_model_flag_cce_sgd_string(self):
+        """
+        Tests the 'respect_trainable' flag when used along with string
+        for the optimizer(keras internally creates an instance, here sgd),
+        conversion is successful
+        """
+        import coremltools
+        from keras.layers import Dense, Input
+        from keras.losses import categorical_crossentropy
+        input = ['data']
+        output = ['output']
+
+        # This should result in an updatable model.
+        inputs = Input(shape=(16,))
+        d1 = Dense(128)(inputs)
+        d2 = Dense(10, name="foo", activation='softmax', trainable=True)(d1)
+        kmodel = Model(inputs=inputs, outputs=d2)
+        kmodel.compile(loss=categorical_crossentropy,
+                       optimizer='sgd', metrics=['accuracy'])
+        cml = coremltools.converters.keras.convert(
+            kmodel, input, output, respect_trainable=True
+        )
+        spec = cml.get_spec()
+        self.assertTrue(spec.isUpdatable)
+        layers = spec.neuralNetwork.layers
+        self.assertIsNotNone(layers[1].innerProduct)
+        self.assertTrue(layers[1].innerProduct)
+        self.assertTrue(layers[1].isUpdatable)
+        self.assertEqual(len(spec.neuralNetwork.updateParams.lossLayers), 1)
+        sgdopt = spec.neuralNetwork.updateParams.optimizer.sgdOptimizer
+        # use almost equal for default verification with at least 5 decimal
+        # places of closeness
+        self.assertAlmostEqual(sgdopt.learningRate.defaultValue, 0.01,
+                               places=5)
+        self.assertEqual(sgdopt.miniBatchSize.defaultValue, 16)
+        self.assertEqual(sgdopt.momentum.defaultValue, 0.0)
+
+    def test_updatable_model_flag_cce_adam_string(self):
+        """
+        Tests the 'respect_trainable' flag when used along with string
+        for the optimizer(keras internally creates an instance, here adam),
+        conversion is successful
+        """
+        import coremltools
+        from keras.layers import Dense, Input
+        from keras.losses import categorical_crossentropy
+        input = ['data']
+        output = ['output']
+
+        # This should result in an updatable model.
+        inputs = Input(shape=(16,))
+        d1 = Dense(128)(inputs)
+        d2 = Dense(10, name="foo", activation='softmax', trainable=True)(d1)
+        kmodel = Model(inputs=inputs, outputs=d2)
+        kmodel.compile(loss=categorical_crossentropy,
+                       optimizer='adam', metrics=['accuracy'])
+        cml = coremltools.converters.keras.convert(
+            kmodel, input, output, respect_trainable=True
+        )
+        spec = cml.get_spec()
+        self.assertTrue(spec.isUpdatable)
+        layers = spec.neuralNetwork.layers
+        self.assertIsNotNone(layers[1].innerProduct)
+        self.assertTrue(layers[1].innerProduct)
+        self.assertTrue(layers[1].isUpdatable)
+        self.assertEqual(len(spec.neuralNetwork.updateParams.lossLayers), 1)
+        adopt = spec.neuralNetwork.updateParams.optimizer.adamOptimizer
+        # use almost equal for default verification with at least 5 decimal
+        # places of closeness
+        self.assertAlmostEqual(adopt.learningRate.defaultValue, 0.001, places=5)
+        self.assertAlmostEqual(adopt.miniBatchSize.defaultValue, 16)
+        self.assertAlmostEqual(adopt.beta1.defaultValue, 0.90, places=5)
+        self.assertAlmostEqual(adopt.beta2.defaultValue, 0.999, places=5)
+
diff --git a/docs/conf.py b/docs/conf.py
@@ -56,7 +56,7 @@
 try:
     version = pkg_resources.require("coremltools")[0].version
 except:
-    version = "3.0b6"
+    version = "3.0"
 
 # The short X.Y version.
 version = version
diff --git a/examples/updatable_models/README.md b/examples/updatable_models/README.md
@@ -18,4 +18,4 @@ The model is a 'linked' pipeline composed of a 'linked' drawing embedding model
 - [Updatable Nearest Neighbor Classifier](https://github.com/apple/coremltools/tree/master/examples/updatable_models/updatable_nearest_neighbor_classifier.ipynb)  
 This notebook makes an empty updatable nearest neighbor classifier. Before updating with training examples it predicts 'defaultLabel' for all input. 
 
-In addition of the above examples, a short document on CoreML 3.0 Update Task API usage is provided [here](https://github.com/apple/coremltools/tree/master/examples/updatable_models/OnDeviceTraining_API_Usage.md).
+In addition of the above examples, a short document on CoreML 3.0 Update Task API usage is provided [here](https://github.com/apple/coremltools/tree/master/examples/updatable_models/OnDeviceTraining_API_Usage.md).
diff --git a/mlmodel/format/NeuralNetwork.proto b/mlmodel/format/NeuralNetwork.proto
@@ -3517,7 +3517,7 @@ message BatchedMatMulLayerParams {
  *
  *      y = ConcatNDLayer(x1,x2,....)
  *
- * Requires at least 1 input and produces 1 output.
+ * Requires at least 2 input and produces 1 output.
  *
  * Input
  *     A Sequence of N-dimensional tensors. The rank of the input tensors must match and all dimensions except 'axis' must be equal.
diff --git a/mlmodel/src/NeuralNetwork/NeuralNetworkLayerValidator.cpp b/mlmodel/src/NeuralNetwork/NeuralNetworkLayerValidator.cpp
@@ -1048,12 +1048,6 @@ Result NeuralNetworkSpecValidator::validateGRULayer(const Specification::NeuralN
     const auto& params = layer.gru();
     bool hasBiasVectors = params.hasbiasvectors();
     
-    // Validate that all weightParam types match
-    WeightParamType gateWeightMatrixValueType, gateRecursionMatrixValueType, gateBiasVectorValueType;
-    gateWeightMatrixValueType = valueType(params.updategateweightmatrix());
-    gateRecursionMatrixValueType = valueType(params.updategaterecursionmatrix());
-    gateBiasVectorValueType = valueType(params.updategatebiasvector());
-    
     std::vector<CoreML::WeightParamType> weightTypeList;
     weightTypeList.push_back(valueType(params.updategateweightmatrix()));
     weightTypeList.push_back(valueType(params.updategaterecursionmatrix()));
diff --git a/setup.py b/setup.py
@@ -10,7 +10,7 @@
     long_description = f.read()
 
 setup(name='coremltools',
-    version='3.0b6',
+    version='3.0',
     description='Community Tools for CoreML',
     long_description=long_description,
     author='Apple Inc.',
@@ -60,7 +60,7 @@
         'console_scripts': ['coremlconverter = coremltools:_main']
     },
     classifiers=[
-          'Development Status :: 4 - Beta',
+          'Development Status :: 5 - Production/Stable',
           'Intended Audience :: End Users/Desktop',
           'Intended Audience :: Developers',
           'Operating System :: MacOS :: MacOS X',

Original file line number	Diff line number	Diff line change
`@@ -3517,7 +3517,7 @@ message BatchedMatMulLayerParams {`
`3517`	`3517`	`*`
`3518`	`3518`	`* y = ConcatNDLayer(x1,x2,....)`
`3519`	`3519`	`*`
`3520`		`- * Requires at least 1 input and produces 1 output.`
	`3520`	`+ * Requires at least 2 input and produces 1 output.`
`3521`	`3521`	`*`
`3522`	`3522`	`* Input`
`3523`	`3523`	`* A Sequence of N-dimensional tensors. The rank of the input tensors must match and all dimensions except 'axis' must be equal.`