Added Operations and tests

dnnv/_manage/linux/verifiers/nnenum.py

@@ -105,14 +105,15 @@ def run(self, env: Environment, dependency: Dependency):
             "pip install --upgrade pip",
             (
                 "pip install"
-                ' "numpy>=1.19,<1.22"'
-                ' "onnx>=1.8,<1.11"'
-                ' "onnxruntime>=1.7,<1.11"'
-                ' "scipy>=1.4.1<1.8"'
-                ' "threadpoolctl==2.1.0"'
-                ' "skl2onnx==1.7.0"'
-                ' "swiglpk"'
-                ' "termcolor"'
+                ' "numpy>=1.21,<1.24"'
+                ' "onnx>=1.10,<1.12"'
+                ' "onnxruntime>=1.10,<1.13"'
+                ' "scipy>=1.7<1.10"'
+                ' "threadpoolctl==3.1.0"'
+                ' "skl2onnx==1.12"'
+                ' "swiglpk~=5.0"'
+                ' "termcolor==1.1.0"'
+                ' "packaging==21.3"'
                 ' "protobuf<=3.20"'
             ),
             f"cd {cache_dir}",

dnnv/_manage/linux/verifiers/verinet.py

@@ -123,6 +123,7 @@ def run(self, env: Environment, dependency: Dependency):
                 "pip install"
                 ' "numba>=0.50,<0.60"'
                 ' "onnx>=1.8,<1.11"'
+                ' "protobuf<=3.20"'
                 ' "torch>=1.8,<1.9"'
                 ' "torchvision>=0.9,<0.10"'
             ),

dnnv/nn/converters/onnx.py

@@ -11,6 +11,10 @@
 from ..visitors import OperationVisitor
 
 
+class OnnxConverterError(Exception):
+    pass
+
+
 def convert(op_graph: OperationGraph, *, add_missing_optional_inputs=False):
     converter = OnnxConverter(
         op_graph, add_missing_optional_inputs=add_missing_optional_inputs
@@ -79,7 +83,7 @@ def _to_onnx_proto(
     ) -> Union[onnx.NodeProto, onnx.TensorProto, onnx.ValueInfoProto]:
         if isinstance(value, Operation):
             return self.visit(value)
-        if isinstance(value, np.ndarray):
+        if isinstance(value, (np.ndarray, np.number)):
             tensor_proto = onnx.numpy_helper.from_array(value, name=opname)
             self.initializer.append(tensor_proto)
             return tensor_proto
@@ -184,6 +188,29 @@ def visit_Cast(self, operation: operations.Cast) -> onnx.NodeProto:
 
         return node
 
+    def visit_Clip(self, operation: operations.Clip) -> onnx.NodeProto:
+        op_type = str(operation)
+        idx = self.op_counts[op_type] = self.op_counts[op_type] + 1
+        opname = f"{op_type}_{idx}"
+
+        x = self._to_onnx_proto(operation.x, f"{opname}.x")
+        inputs = [x.name]
+        if operation.min is not None:
+            min = self._to_onnx_proto(operation.min, f"{opname}.min")
+            inputs.extend([min.name])
+        if operation.max is not None:
+            max = self._to_onnx_proto(operation.max, f"{opname}.max")
+            inputs.extend([max.name])
+
+        node = onnx.helper.make_node(
+            op_type,
+            inputs=inputs,
+            outputs=[opname],
+            name=opname,
+        )
+
+        return node
+
     def visit_Concat(self, operation: operations.Concat) -> onnx.NodeProto:
         idx = self.op_counts["Concat"] = self.op_counts["Concat"] + 1
         opname = f"Concat_{idx}"
@@ -508,6 +535,26 @@ def visit_OutputSelect(self, operation: operations.OutputSelect) -> onnx.NodePro
 
         return node
 
+    def visit_ReduceL2(self, operation: operations.ReduceL2) -> onnx.NodeProto:
+        op_type = str(operation)
+        idx = self.op_counts[op_type] = self.op_counts[op_type] + 1
+        opname = f"{op_type}_{idx}"
+
+        x = self._to_onnx_proto(operation.x, f"{opname}.x")
+        axes = operation.axes
+        keepdims = operation.keepdims
+
+        node = onnx.helper.make_node(
+            op_type,
+            inputs=[x.name],
+            axes=axes,
+            keepdims=keepdims,
+            outputs=[opname],
+            name=opname,
+        )
+
+        return node
+
     def visit_Relu(self, operation: operations.Relu) -> onnx.NodeProto:
         idx = self.op_counts["Relu"] = self.op_counts["Relu"] + 1
         opname = f"Relu_{idx}"
@@ -576,6 +623,25 @@ def visit_Split(self, operation: operations.Split) -> onnx.NodeProto:
 
         return node
 
+    def visit_Squeeze(self, operation: operations.Squeeze) -> onnx.NodeProto:
+        op_type = str(operation)
+        idx = self.op_counts[op_type] = self.op_counts[op_type] + 1
+        opname = f"{op_type}_{idx}"
+
+        x = self._to_onnx_proto(operation.x, f"{opname}.x")
+        inputs = [x.name]
+        if operation.axes is not None:
+            axes = self._to_onnx_proto(operation.axes, f"{opname}.axes")
+            if axes.data_type != onnx.TensorProto.INT64:
+                raise OnnxConverterError("Squeeze axes should be int64.")
+            inputs.extend([axes.name])
+
+        node = onnx.helper.make_node(
+            op_type, inputs=inputs, outputs=[opname], name=opname
+        )
+
+        return node
+
     def visit_Slice(self, operation: operations.Slice) -> onnx.NodeProto:
         op_type = str(operation)
         idx = self.op_counts[op_type] = self.op_counts[op_type] + 1
@@ -648,3 +714,21 @@ def visit_Transpose(self, operation: operations.Transpose) -> onnx.NodeProto:
         )
 
         return node
+
+    def visit_Upsample(self, operation: operations.Upsample) -> onnx.NodeProto:
+        op_type = str(operation)
+        idx = self.op_counts[op_type] = self.op_counts[op_type] + 1
+        opname = f"{op_type}_{idx}"
+
+        x = self._to_onnx_proto(operation.x, f"{opname}.x")
+        inputs = [x.name]
+        if operation.scales is not None:
+            scales = self._to_onnx_proto(operation.scales, f"{opname}.scales")
+            inputs.extend([scales.name])
+        mode = operation.mode
+
+        node = onnx.helper.make_node(
+            op_type, inputs=inputs, outputs=[opname], name=opname, mode=mode
+        )
+
+        return node

dnnv/nn/converters/tensorflow.py

@@ -208,6 +208,21 @@ def cast_func(*inputs):
 
         return cast_func
 
+    def visit_Clip(self, operation):
+        x_ = operation.x
+        if isinstance(x_, Operation):
+            x_ = self.visit(x_)
+        _min = operation.min
+        _max = operation.max
+
+        @self._cached
+        def clip_func(*inputs):
+            x = _concretize([x_], inputs)
+            x = tf.clip_by_value(x, _min, _max)
+            return x
+
+        return clip_func
+
     def visit_Concat(self, operation):
         tensors_ = []
         for x in operation.x:
@@ -227,20 +242,24 @@ def visit_Conv(self, operation):
         x_ = operation.x
         if isinstance(x_, Operation):
             x_ = self.visit(x_)
+        w_ = operation.w
+        if isinstance(w_, Operation):
+            w_ = self.visit(w_)
 
         @self._cached
         def conv_func(*inputs):
-            x = _concretize([x_], inputs)
+            x, weights = _concretize([x_, w_], inputs)
             if len(operation.kernel_shape) != 2:
                 raise NotImplementedError(
                     "Non 2d convolutions are not currently supported."
                 )
-            weights = operation.w
+            if not isinstance(weights, np.ndarray):
+                weights = np.array(weights)
             if operation.b is not None:
                 bias = operation.b
             else:
                 bias = np.zeros((weights.shape[0],), dtype=weights.dtype)
-            assert np.all(operation.dilations == 1)
+            assert np.all(operation.group == 1)
             num_pads = len(operation.pads)
             pads = tuple(
                 zip(
@@ -258,6 +277,7 @@ def conv_func(*inputs):
                     weights.transpose((2, 3, 1, 0)),
                     operation.strides,
                     padding="VALID",
+                    dilations=operation.dilations,
                 ),
                 bias,
             )
@@ -417,11 +437,13 @@ def visit_Expand(self, operation):
         x_ = operation.x
         if isinstance(x_, Operation):
             x_ = self.visit(x_)
+        shape_ = operation.shape
+        if isinstance(shape_, Operation):
+            shape_ = self.visit(shape_)
 
         @self._cached
         def expand_func(*inputs):
-            x = _concretize([x_], inputs)
-            shape = operation.shape
+            x, shape = _concretize([x_, shape_], inputs)
             result = x * tf.ones(shape, x.dtype)
             return result
 
@@ -685,6 +707,21 @@ def pad_func(*inputs):
 
         return pad_func
 
+    def visit_ReduceL2(self, operation):
+        x_ = operation.x
+        if isinstance(x_, Operation):
+            x_ = self.visit(x_)
+        axes = operation.axes
+        keepdims = operation.keepdims
+
+        @self._cached
+        def reduceL2_func(*inputs):
+            x = _concretize([x_], inputs)
+            x = tf.norm(x, ord=2, axis=axes, keepdims=keepdims)
+            return x
+
+        return reduceL2_func
+
     def visit_Relu(self, operation):
         x_ = operation.x
         if isinstance(x_, Operation):
@@ -738,6 +775,7 @@ def resize_func(*inputs):
             assert operation.coordinate_transformation_mode in [
                 "asymmetric",
                 "tf_crop_and_resize",
+                "align_corners",
             ]
             assert operation.mode in ["nearest", "linear"]
             assert operation.exclude_outside == 0
@@ -873,6 +911,22 @@ def split_func(*inputs):
 
         return split_func
 
+    def visit_Squeeze(self, operation):
+        x_ = operation.x
+        if isinstance(x_, Operation):
+            x_ = self.visit(x_)
+        axes = operation.axes
+        if isinstance(axes, np.ndarray):
+            axes = axes.tolist()
+
+        @self._cached
+        def squeeze_func(*inputs):
+            x = _concretize([x_], inputs)
+            x = tf.squeeze(x, axis=axes)
+            return x
+
+        return squeeze_func
+
     def visit_Sub(self, operation):
         a_ = operation.a
         if isinstance(a_, Operation):
@@ -948,3 +1002,21 @@ def unsqueeze_func(*inputs):
             return x
 
         return unsqueeze_func
+
+    def visit_Upsample(self, operation):
+        x_ = operation.x
+        if isinstance(x_, Operation):
+            x_ = self.visit(x_)
+        scales = operation.scales
+        mode = operation.mode
+
+        @self._cached
+        def upsample_func(*inputs):
+            x = _concretize([x_], inputs)
+            scaled_dim = [int(sd) for sd in x.shape[2:] * scales[2:]]
+            xr = tf.transpose(x, perm=[0, 2, 3, 1])
+            xr = tf.image.resize(xr, scaled_dim, method="nearest")
+            xr = tf.transpose(xr, perm=[0, 3, 1, 2])
+            return xr
+
+        return upsample_func

dnnv/nn/operations/tensor.py

@@ -19,6 +19,23 @@ def from_onnx(cls, onnx_node, *inputs):
         return cls(*inputs, to=to, name=onnx_node.name)
 
 
+class Clip(Operation):
+    def __init__(self, x, min=None, max=None, *, name: Optional[str] = None):
+        super().__init__(name=name)
+        self.x = x
+        self.min = min
+        self.max = max
+
+    @classmethod
+    def from_onnx(cls, onnx_node, *inputs):
+        attributes = {a.name: as_numpy(a) for a in onnx_node.attribute}
+        if len(inputs) == 1:
+            _min = attributes.get("min")
+            _max = attributes.get("max")
+            return cls(*inputs, min=_min, max=_max, name=onnx_node.name)
+        return cls(*inputs, name=onnx_node.name)
+
+
 class Concat(Operation):
     def __init__(self, x, axis, *, name: Optional[str] = None):
         super().__init__(name=name)
@@ -256,6 +273,48 @@ def from_onnx(cls, onnx_node, *inputs):
         return cls(*inputs, axes=axes, name=onnx_node.name)
 
 
+class ReduceL2(Operation):
+    def __init__(self, x, axes, keepdims, *, name: Optional[str] = None):
+        super().__init__(name=name)
+        self.x = x
+        self.axes = axes
+        self.keepdims = keepdims
+
+    @classmethod
+    def from_onnx(cls, onnx_node, *inputs):
+        attributes = {a.name: as_numpy(a) for a in onnx_node.attribute}
+        axes = attributes.get("axes")
+        keepdims = attributes.get("keepdims")
+        return cls(*inputs, axes=axes, keepdims=keepdims, name=onnx_node.name)
+
+
+class Squeeze(Operation):
+    def __init__(self, x, axes, *, name: Optional[str] = None):
+        super().__init__(name=name)
+        self.x = x
+        self.axes = axes
+
+    @classmethod
+    def from_onnx(cls, onnx_node, *inputs):
+        attributes = {a.name: as_numpy(a) for a in onnx_node.attribute}
+        axes = attributes.get("axes")
+        return cls(*inputs, axes=axes, name=onnx_node.name)
+
+
+class Upsample(Operation):
+    def __init__(self, x, scales, mode, *, name: Optional[str] = None):
+        super().__init__(name=name)
+        self.x = x
+        self.scales = scales
+        self.mode = mode
+
+    @classmethod
+    def from_onnx(cls, onnx_node, *inputs):
+        attributes = {a.name: as_numpy(a) for a in onnx_node.attribute}
+        mode = attributes.get("mode")
+        return cls(*inputs, mode=mode, name=onnx_node.name)
+
+
 __all__ = [
     "Cast",
     "Concat",
@@ -272,4 +331,8 @@ def from_onnx(cls, onnx_node, *inputs):
     "Tile",
     "Transpose",
     "Unsqueeze",
+    "ReduceL2",
+    "Clip",
+    "Squeeze",
+    "Upsample",
 ]