public override void Process(TransformContext context)
        {
            var concat = (ExclusiveConcatenation)context.MatchedLayers[0];
            var output = concat.Output;

            var exConcat = new QuantizedExclusiveConcatenation(concat.Inputs.Select(x => new ReadOnlyMemory <int>(x.Dimensions.ToArray())));

            for (int i = 0; i < exConcat.Inputs.Count; i++)
            {
                var input      = concat.Inputs[i].Connection.From;
                var quantize   = new Quantize(input.Dimensions);
                var requantize = new Requantize(quantize.Output.Dimensions);
                quantize.Input.SetConnection(input);
                requantize.Input.SetConnection(quantize.Output);
                exConcat.Inputs[i].SetConnection(requantize.Output);
            }

            var dequantize = new Dequantize(exConcat.Output.Dimensions);

            dequantize.Input.SetConnection(exConcat.Output);

            var oldOuts = output.Connections.Select(o => o.To).ToList();

            foreach (var oldOut in oldOuts)
            {
                oldOut.SetConnection(dequantize.Output);
            }
        }
예제 #2
0
        public override void Process(TransformContext context)
        {
            var space    = (SpaceToBatchNd)context.MatchedLayers[0];
            var dwConv2d = (DepthwiseConv2d)context.MatchedLayers[1];
            var conv2d   = (Conv2d)context.MatchedLayers[2];
            var input    = space.Input.Connection.From;
            var output   = conv2d.Output;

            space.Input.ClearConnection();
            var newDwConv2d = new DepthwiseConv2d(input.Dimensions, dwConv2d.Weights, dwConv2d.Bias, Padding.Same, 1, 1, dwConv2d.FusedActivationFunction);
            var quantize    = new Quantize(newDwConv2d.Output.Dimensions);
            var upload      = new K210Upload(quantize.Output.Dimensions);
            var newConv2d   = new K210Conv2d(upload.Output.Dimensions, K210Conv2dType.Conv2d, conv2d.Weights, conv2d.Bias, K210PoolType.LeftTop, conv2d.FusedActivationFunction, null);
            var dequantize  = new Dequantize(newConv2d.Output.Dimensions);

            newDwConv2d.Input.SetConnection(input);
            quantize.Input.SetConnection(newDwConv2d.Output);
            upload.Input.SetConnection(quantize.Output);
            newConv2d.Input.SetConnection(upload.Output);
            dequantize.Input.SetConnection(newConv2d.Output);
            var oldOuts = output.Connections.Select(o => o.To).ToList();

            foreach (var oldOut in oldOuts)
            {
                oldOut.SetConnection(dequantize.Output);
            }
        }
예제 #3
0
        public override void Process(TransformContext context)
        {
            K210Conv2d      newLayer;
            OutputConnector output;
            OutputConnector input;
            var             conv = context.MatchedLayers[0];

            if (conv is Conv2d conv2d)
            {
                newLayer = new K210Conv2d(conv2d.Input.Dimensions, K210Conv2dType.Conv2d, conv2d.Weights, conv2d.Bias, K210PoolType.LeftTop, conv2d.FusedActivationFunction, null);
                input    = conv2d.Input.Connection.From;
                output   = conv2d.Output;
            }
            else
            {
                throw new InvalidOperationException();
            }

            var quantize   = new Quantize(input.Dimensions);
            var upload     = new K210Upload(input.Dimensions);
            var dequantize = new Dequantize(newLayer.Output.Dimensions);

            quantize.Input.SetConnection(input);
            upload.Input.SetConnection(quantize.Output);
            newLayer.Input.SetConnection(upload.Output);
            dequantize.Input.SetConnection(newLayer.Output);
            var oldOuts = output.Connections.Select(o => o.To).ToList();

            foreach (var oldOut in oldOuts)
            {
                oldOut.SetConnection(dequantize.Output);
            }
        }
예제 #4
0
파일: Dequantize.cs 프로젝트: ll550/nncase
 public DequantizeLayerArgument Convert(Dequantize layer, ConvertContext context)
 {
     return(new DequantizeLayerArgument
     {
         Count = (uint)(layer.Input.Dimensions.GetSize()),
         QuantParam = context.Quantization.Distributions[layer.Input.Connection.From].Global.GetQuantizationParam(8)
     });
 }
예제 #5
0
파일: Dequantize.cs 프로젝트: ll550/nncase
        public void Infer(Dequantize layer, DequantizeLayerArgument argument, InferenceContext context)
        {
            var inputAlloc  = context.MainMemoryMap[layer.Input.Connection.From];
            var outputAlloc = context.MainMemoryMap[layer.Output];

            argument.Flags = K210LayerFlags.MainMemoryOutput;
            argument.MainMemoryInputAddress  = inputAlloc.GetAddress();
            argument.MainMemoryOutputAddress = outputAlloc.GetAddress();
        }
예제 #6
0
        public override void Process(TransformContext context)
        {
            var resize = (ResizeNearestNeighbor)context.MatchedLayers[0];
            var input  = resize.Input.Connection.From.Owner.InputConnectors[0].Connection.From;
            var output = resize.Output;

            var quantResize = new QuantizedResizeNearestNeighbor(resize.Input.Dimensions, resize.Output.Dimensions[3], resize.Output.Dimensions[2], resize.AlignCorners);
            var dequant     = new Dequantize(quantResize.Output.Dimensions);

            quantResize.Input.SetConnection(input);
            dequant.Input.SetConnection(quantResize.Output);

            var oldOuts = output.Connections.Select(o => o.To).ToList();

            foreach (var oldOut in oldOuts)
            {
                oldOut.SetConnection(dequant.Output);
            }
        }
예제 #7
0
        public override void Process(TransformContext context)
        {
            var maxPool = (MaxPool2d)context.MatchedLayers[0];
            var input   = maxPool.Input.Connection.From.Owner.InputConnectors[0].Connection.From;
            var output  = maxPool.Output;

            var quantMaxPool = new QuantizedMaxPool2d(maxPool.Input.Dimensions, maxPool.Padding, maxPool.FilterWidth, maxPool.FilterHeight, maxPool.StrideWidth, maxPool.StrideHeight, maxPool.FusedActivationFunction);
            var dequant      = new Dequantize(quantMaxPool.Output.Dimensions);

            quantMaxPool.Input.SetConnection(input);
            dequant.Input.SetConnection(quantMaxPool.Output);

            var oldOuts = output.Connections.Select(o => o.To).ToList();

            foreach (var oldOut in oldOuts)
            {
                oldOut.SetConnection(dequant.Output);
            }
        }
예제 #8
0
        public override void Process(TransformContext context)
        {
            var space = (SpaceToBatchNd)context.MatchedLayers[0];
            var input = space.Input.Connection.From;

            space.Input.ClearConnection();

            K210Conv2d      newLayer;
            OutputConnector output;
            var             conv = context.MatchedLayers[1];

            if (conv is Conv2d conv2d)
            {
                newLayer = new K210Conv2d(input.Dimensions, K210Conv2dType.Conv2d, conv2d.Weights, conv2d.Bias, conv2d.StrideWidth == 2 ? K210PoolType.LeftTop : K210PoolType.None, conv2d.FusedActivationFunction, null);
                output   = conv2d.Output;
            }
            else if (conv is DepthwiseConv2d dwConv2d)
            {
                newLayer = new K210Conv2d(input.Dimensions, K210Conv2dType.DepthwiseConv2d, dwConv2d.Weights, dwConv2d.Bias, K210PoolType.None, dwConv2d.FusedActivationFunction, null);
                output   = dwConv2d.Output;
            }
            else
            {
                throw new InvalidOperationException();
            }

            var quantize   = new Quantize(input.Dimensions);
            var upload     = new K210Upload(input.Dimensions);
            var dequantize = new Dequantize(newLayer.Output.Dimensions);

            quantize.Input.SetConnection(input);
            upload.Input.SetConnection(quantize.Output);
            newLayer.Input.SetConnection(upload.Output);
            dequantize.Input.SetConnection(newLayer.Output);
            var oldOuts = output.Connections.Select(o => o.To).ToList();

            foreach (var oldOut in oldOuts)
            {
                oldOut.SetConnection(dequantize.Output);
            }
        }
예제 #9
0
        public override void Process(TransformContext context)
        {
            var add    = (Add)context.MatchedLayers[0];
            var inputA = add.InputA.Connection.From.Owner.InputConnectors[0].Connection.From;
            var inputB = add.InputB.Connection.From.Owner.InputConnectors[0].Connection.From;
            var output = add.Output;

            var quantAdd = new QuantizedAdd(add.InputA.Dimensions, add.InputB.Dimensions);
            var dequant  = new Dequantize(quantAdd.Output.Dimensions);

            quantAdd.InputA.SetConnection(inputA);
            quantAdd.InputB.SetConnection(inputB);
            dequant.Input.SetConnection(quantAdd.Output);

            var oldOuts = output.Connections.Select(o => o.To).ToList();

            foreach (var oldOut in oldOuts)
            {
                oldOut.SetConnection(dequant.Output);
            }
        }
        public override void Process(TransformContext context)
        {
            var conv2d = (K210Conv2d)context.MatchedLayers[0];
            var act    = context.MatchedLayers[2];
            var input  = conv2d.Input.Connection.From;
            var output = act.OutputConnectors[0];

            conv2d.Input.ClearConnection();

            var newConv2d = new K210Conv2d(conv2d.Input.Dimensions, conv2d.Conv2dType, conv2d.Weights, conv2d.Bias, conv2d.PoolType, conv2d.FusedActivationFunction, act);

            newConv2d.Input.SetConnection(input);
            var newDequantize = new Dequantize(newConv2d.Output.Dimensions);

            newDequantize.Input.SetConnection(newConv2d.Output);
            var oldOuts = output.Connections.Select(o => o.To).ToList();

            foreach (var oldOut in oldOuts)
            {
                oldOut.SetConnection(newDequantize.Output);
            }
        }
예제 #11
0
        public override void Process(TransformContext context)
        {
            var space    = context.MatchedLayers[0];
            var dwConv2d = (DepthwiseConv2d)context.MatchedLayers[1];
            var conv2d   = (Conv2d)context.MatchedLayers.Last();
            var input    = space.InputConnectors[0].Connection.From;
            var output   = conv2d.Output;

            space.InputConnectors[0].ClearConnection();
            var newDwConv2d = new DepthwiseConv2d(input.Dimensions, dwConv2d.Weights, dwConv2d.Bias, Padding.Same, 1, 1, dwConv2d.FusedActivationFunction);
            var quantize    = new Quantize(newDwConv2d.Output.Dimensions);
            var upload      = new K210Upload(quantize.Output.Dimensions);
            var newConv2d   = new K210Conv2d(upload.Output.Dimensions, K210Conv2dType.Conv2d, conv2d.Weights, conv2d.Bias, K210PoolType.LeftTop, conv2d.FusedActivationFunction, null);
            var dequantize  = new Dequantize(newConv2d.Output.Dimensions);

            newDwConv2d.Input.SetConnection(input);
            quantize.Input.SetConnection(newDwConv2d.Output);
            upload.Input.SetConnection(quantize.Output);
            newConv2d.Input.SetConnection(upload.Output);
            dequantize.Input.SetConnection(newConv2d.Output);

            var oldOuts = output.Connections.Select(o => o.To).ToList();

            if (context.MatchedLayers.Count == 3)
            {
                foreach (var oldOut in oldOuts)
                {
                    oldOut.SetConnection(dequantize.Output);
                }
            }
            else
            {
                var newOutput = dequantize.Output;

                foreach (var middleLayer in context.MatchedLayers.Skip(2).Take(context.MatchedLayers.Count - 3))
                {
                    Layer newLayer;
                    switch (middleLayer)
                    {
                    case Quantize _:
                        newLayer = new Quantize(newOutput.Dimensions);
                        break;

                    case Dequantize _:
                        newLayer = new Dequantize(newOutput.Dimensions);
                        break;

                    case LeakyRelu l:
                        newLayer = new LeakyRelu(newOutput.Dimensions, l.Slope);
                        break;

                    default:
                        throw new NotImplementedException();
                    }

                    newLayer.InputConnectors[0].SetConnection(newOutput);
                    newOutput = newLayer.OutputConnectors[0];
                }

                foreach (var oldOut in oldOuts)
                {
                    oldOut.SetConnection(newOutput);
                }
            }
        }
예제 #12
0
        public override void Process(TransformContext context)
        {
            var             conv2d = (K210Conv2d)context.MatchedLayers[0];
            var             input  = conv2d.Input.Connection.From;
            OutputConnector output;

            conv2d.Input.ClearConnection();

            K210PoolType poolType;

            if (context.MatchedLayers[2] is MaxPool2d maxPool)
            {
                if (maxPool.FilterWidth == 2 && maxPool.StrideWidth == 2)
                {
                    poolType = K210PoolType.MaxPool2x2;
                }
                else if (maxPool.FilterWidth == 2 && maxPool.StrideWidth == 1)
                {
                    poolType = K210PoolType.MaxPool2x2Stride1;
                }
                else if (maxPool.FilterWidth == 4 && maxPool.StrideWidth == 4)
                {
                    poolType = K210PoolType.MaxPool4x4;
                }
                else
                {
                    throw new NotSupportedException("Unsupported max pool.");
                }
                output = maxPool.Output;
            }
            else
            {
                var avgPool = (AveragePool2d)context.MatchedLayers[2];
                if (avgPool.FilterWidth == 2 && avgPool.StrideWidth == 2)
                {
                    poolType = K210PoolType.AveragePool2x2;
                }
                else if (avgPool.FilterWidth == 2 && avgPool.StrideWidth == 1)
                {
                    poolType = K210PoolType.AveragePool2x2Stride1;
                }
                else if (avgPool.FilterWidth == 4 && avgPool.StrideWidth == 4)
                {
                    poolType = K210PoolType.AveragePool4x4;
                }
                else
                {
                    throw new NotSupportedException("Unsupported average pool.");
                }
                output = avgPool.Output;
            }

            var newConv2d = new K210Conv2d(conv2d.Input.Dimensions, conv2d.Conv2dType, conv2d.Weights, conv2d.Bias, poolType, conv2d.FusedActivationFunction, conv2d.NonTrivialActivation);

            newConv2d.Input.SetConnection(input);
            var newDequantize = new Dequantize(newConv2d.Output.Dimensions);

            newDequantize.Input.SetConnection(newConv2d.Output);
            var oldOuts = output.Connections.Select(o => o.To).ToList();

            foreach (var oldOut in oldOuts)
            {
                oldOut.SetConnection(newDequantize.Output);
            }
        }