예제 #1
0
        public void ReferenceTest()
        {
            int channels = 7, kwidth = 3, stride = 2, inwidth = 13, batch = 2;
            int outwidth = (inwidth - kwidth) / stride + 1;

            float[] xval = (new float[batch * inwidth * channels]).Select((_, idx) => idx * 1e-3f).ToArray();
            float[] wval = (new float[kwidth * channels]).Select((_, idx) => idx * 1e-3f).Reverse().ToArray();

            Map1D    x = new Map1D(channels, inwidth, batch, xval);
            Filter1D w = new Filter1D(channels, 1, kwidth, wval);

            Map1D y = Reference(x, w, kwidth, stride);

            float[] y_expect =
            {
                1.7500000e-04f, 1.9000000e-04f, 1.9900000e-04f, 2.0200000e-04f, 1.9900000e-04f, 1.9000000e-04f, 1.7500000e-04f,
                7.2100000e-04f, 6.9400000e-04f, 6.6100000e-04f, 6.2200000e-04f, 5.7700000e-04f, 5.2600000e-04f, 4.6900000e-04f,
                1.2670000e-03f, 1.1980000e-03f, 1.1230000e-03f, 1.0420000e-03f, 9.5500000e-04f, 8.6200000e-04f, 7.6300000e-04f,
                1.8130000e-03f, 1.7020000e-03f, 1.5850000e-03f, 1.4620000e-03f, 1.3330000e-03f, 1.1980000e-03f, 1.0570000e-03f,
                2.3590000e-03f, 2.2060000e-03f, 2.0470000e-03f, 1.8820000e-03f, 1.7110000e-03f, 1.5340000e-03f, 1.3510000e-03f,
                2.9050000e-03f, 2.7100000e-03f, 2.5090000e-03f, 2.3020000e-03f, 2.0890000e-03f, 1.8700000e-03f, 1.6450000e-03f,
                3.7240000e-03f, 3.4660000e-03f, 3.2020000e-03f, 2.9320000e-03f, 2.6560000e-03f, 2.3740000e-03f, 2.0860000e-03f,
                4.2700000e-03f, 3.9700000e-03f, 3.6640000e-03f, 3.3520000e-03f, 3.0340000e-03f, 2.7100000e-03f, 2.3800000e-03f,
                4.8160000e-03f, 4.4740000e-03f, 4.1260000e-03f, 3.7720000e-03f, 3.4120000e-03f, 3.0460000e-03f, 2.6740000e-03f,
                5.3620000e-03f, 4.9780000e-03f, 4.5880000e-03f, 4.1920000e-03f, 3.7900000e-03f, 3.3820000e-03f, 2.9680000e-03f,
                5.9080000e-03f, 5.4820000e-03f, 5.0500000e-03f, 4.6120000e-03f, 4.1680000e-03f, 3.7180000e-03f, 3.2620000e-03f,
                6.4540000e-03f, 5.9860000e-03f, 5.5120000e-03f, 5.0320000e-03f, 4.5460000e-03f, 4.0540000e-03f, 3.5560000e-03f,
            };

            float[] y_actual = y.ToArray();

            AssertError.Tolerance(y_expect, y_actual, 1e-7f, 1e-5f, $"mismatch value {channels},{kwidth},{stride},{inwidth},{batch}");
        }
        public void ReferenceTest()
        {
            int scale = 2;
            int channels = 2, inwidth = 5, inheight = 4, indepth = 3, batch = 2;
            int outwidth = inwidth * scale, outheight = inheight * scale, outdepth = indepth * scale;

            float[] xval = (new float[channels * inwidth * inheight * indepth * batch]).Select((_, idx) => idx * 2e-3f).ToArray();
            float[] yval = (new float[channels * outwidth * outheight * outdepth * batch]).Select((_, idx) => idx * 1e-3f).ToArray();

            Tensor xtensor = new Tensor(Shape.Map3D(channels, inwidth, inheight, indepth, batch), xval);
            Tensor ytensor = new Tensor(Shape.Map3D(channels, outwidth, outheight, outdepth, batch), yval);

            ParameterField x        = xtensor;
            VariableField  y_actual = ytensor;

            Field y_expect = NeighborZoom3D(x);
            Field err      = y_expect - y_actual;

            (Flow flow, Parameters Parameters) = Flow.Optimize(err);

            flow.Execute();

            float[] gx_actual = x.GradTensor.State;

            AssertError.Tolerance(gx_expect, gx_actual, 1e-7f, 1e-5f, $"not equal gx");
        }
예제 #3
0
        public void ReferenceTest()
        {
            int channels = 7, width = 3, height = 5, batch = 2;

            float[] xval    = (new float[channels * width * height * batch]).Select((_, idx) => idx * 1e-3f).ToArray();
            Tensor  xtensor = new Tensor(Shape.Map2D(channels, width, height, batch), xval);

            float[] yval    = (new float[width * batch]).Select((_, idx) => idx * 1e-3f).ToArray();
            Tensor  ytensor = new Tensor(Shape.Map0D(width, batch), yval);

            VariableField x        = xtensor;
            VariableField y_actual = ytensor;

            Field y_expect = Max(x, new int[] { Axis.Map2D.Channels, Axis.Map2D.Height }, keepdims: false);
            Field err      = y_expect - y_actual;

            OutputNode errnode = err.Value.Save();

            (Flow flow, Parameters Parameters) = Flow.Optimize(err);

            flow.Execute();

            float[] err_actual = errnode.Tensor.State;

            AssertError.Tolerance(err_expect, err_actual, 1e-7f, 1e-5f, $"not equal err");
        }
예제 #4
0
        public void ExecuteTest()
        {
            const int length = 256;
            Random    rd     = new Random(1234);

            int[] idxes = (new int[length]).Select((_, idx) => idx).ToArray();

            float[] x = (new float[length]).Select((_) => (float)rd.NextDouble() * 8f - 4f).ToArray();

            {
                Tensor t = new Tensor(Shape.Vector(length), x);

                Tensor o = Tensor.Floor(t);

                AssertError.Tolerance(idxes.Select((idx) => (float)Math.Floor(x[idx])).ToArray(), o.State, 1e-7f, 1e-5f);
            }

            {
                InputNode t = new Tensor(Shape.Vector(length), x);

                var n = t + 0;

                OutputNode o = VariableNode.Floor(n).Save();

                Flow flow = Flow.FromOutputs(o);
                flow.Execute();

                AssertError.Tolerance(idxes.Select((idx) => (float)Math.Floor(x[idx])).ToArray(), o.State, 1e-7f, 1e-5f);
            }
        }
        public void OptimizeTest()
        {
            float max_err = 0;

            foreach (int batch in new int[] { 1, 2 })
            {
                foreach (int inchannels in new int[] { 1, 2, 3, 4, 5, 10, 15, 20 })
                {
                    foreach (int outchannels in new int[] { 7, 13 })
                    {
                        float[] yval = (new float[outchannels * batch]).Select((_, idx) => idx * 1e-3f).ToArray();
                        float[] wval = (new float[inchannels * outchannels]).Select((_, idx) => idx * 1e-3f).Reverse().ToArray();

                        Map0D    y = new Map0D(outchannels, batch, yval);
                        Filter0D w = new Filter0D(inchannels, outchannels, 1, wval);

                        Map0D x           = Reference(y, w);
                        Map0D x_optimized = OptimizedReference(y, w);

                        float[] x_expect = x.ToArray();
                        float[] x_actual = x_optimized.ToArray();

                        AssertError.Tolerance(x_expect, x_actual, 1e-7f, 1e-5f, ref max_err, $"mismatch value {inchannels},{outchannels},{batch}");

                        Console.WriteLine($"pass: {inchannels},{outchannels},{batch}");
                    }
                }
            }

            Console.WriteLine($"maxerr:{max_err}");
        }
        public void TheoreticalTest()
        {
            int length = 24;

            float[] xval = (new float[length]).Select((_, idx) => (float)idx * 2 - length).ToArray();
            float[] tval = (new float[length]).Select((_, idx) => (float)idx / 2).Reverse().ToArray();

            Tensor xtensor = new Tensor(Shape.Vector(length), xval);
            Tensor ttensor = new Tensor(Shape.Vector(length), tval);

            ParameterField x = xtensor;
            VariableField  t = ttensor;

            Field xr = QuaternionR(x), xi = QuaternionI(x), xj = QuaternionJ(x), xk = QuaternionK(x);
            Field norm = Square(xr) + Square(xi) + Square(xj) + Square(xk);
            Field s    = norm / (norm + 1);

            Field xy = QuaternionCast(
                xr * s,
                xi * s,
                xj * s,
                xk * s);
            Field err = xy - t;

            (Flow flow, Parameters parameters) = Flow.Optimize(err);
            flow.Execute();

            float[] gx_actual = x.GradTensor.State;

            AssertError.Tolerance(gx_expect, gx_actual, 1e-7f, 1e-5f, $"not equal gx");
        }
예제 #7
0
        public void ReferenceTest()
        {
            int channel = 5, width = 4, height = 3, batch = 2;

            float[] x1val = (new float[channel]).Select((_, idx) => idx * 1e-3f).ToArray();
            float[] x2val = (new float[channel * width * height * batch]).Select((_, idx) => idx * 1e-3f).ToArray();
            float[] yval  = (new float[channel * width * height * batch]).Select((_, idx) => idx * 1e-3f).ToArray();

            Tensor x1tensor = new Tensor(Shape.Vector(channel), x1val);
            Tensor x2tensor = new Tensor(Shape.Map2D(channel, width, height, batch), x2val);

            Tensor ytensor = new Tensor(Shape.Map2D(channel, width, height, batch), yval);

            ParameterField x1       = x1tensor;
            ParameterField x2       = x2tensor;
            VariableField  y_actual = ytensor;

            Field y_expect = x1 + x2;
            Field err      = Abs(y_expect - y_actual);

            (Flow flow, Parameters Parameters) = Flow.Optimize(err);

            flow.Execute();

            float[] gx1_actual = x1.GradTensor.State;
            float[] gx2_actual = x2.GradTensor.State;

            AssertError.Tolerance(gx1_expect, gx1_actual, 1e-7f, 1e-5f, $"not equal gx1");

            AssertError.Tolerance(gx2_expect, gx2_actual, 1e-7f, 1e-5f, $"not equal gx2");
        }
예제 #8
0
        public void ExecuteTest()
        {
            const int length = 256;
            Random    rd     = new Random(1234);

            int[] idxes = (new int[length]).Select((_, idx) => idx).ToArray();

            float[] x = (new float[length]).Select((_) => (float)rd.NextDouble() * 4 - 2).ToArray();
            float   c = 0.25f;

            {
                Tensor t = new Tensor(Shape.Vector(length), x);

                Tensor o = Tensor.LeakyRelu(t, c);

                AssertError.Tolerance(idxes.Select((idx) => Math.Max(x[idx], 0) + c * Math.Min(x[idx], 0)).ToArray(), o.State, 1e-7f, 1e-5f);
            }

            {
                InputNode t = new Tensor(Shape.Vector(length), x);

                var n = t + 0;

                OutputNode o = VariableNode.LeakyRelu(n, c).Save();

                Flow flow = Flow.FromOutputs(o);
                flow.Execute();

                AssertError.Tolerance(idxes.Select((idx) => Math.Max(x[idx], 0) + c * Math.Min(x[idx], 0)).ToArray(), o.State, 1e-7f, 1e-5f);
            }
        }
        public void ReferenceTest()
        {
            int length = 24;

            float[] vval = (new float[length]).Select((_, idx) => ((float)idx * 2 - length) * 0.01f).ToArray();
            float[] qval = (new float[length / 3 * 4]).Select((_, idx) => ((float)idx * 3 - length) * 0.01f).Reverse().ToArray();
            float[] tval = (new float[length]).Select((_, idx) => ((float)idx / 2) * 0.01f).ToArray();

            Tensor vtensor = new Tensor(Shape.Vector(length), vval);
            Tensor qtensor = new Tensor(Shape.Vector(length / 3 * 4), qval);
            Tensor ttensor = new Tensor(Shape.Vector(length), tval);

            ParameterField v = vtensor;
            ParameterField q = qtensor;
            VariableField  t = ttensor;

            Field vq  = TrivectorQuaternionMul(v, q);
            Field err = vq - t;

            (Flow flow, Parameters parameters) = Flow.Optimize(err);
            flow.Execute();

            float[] gv_actual = v.GradTensor.State;
            float[] gq_actual = q.GradTensor.State;

            AssertError.Tolerance(gv_expect, gv_actual, 1e-7f, 1e-5f, $"not equal gv");

            AssertError.Tolerance(gq_expect, gq_actual, 1e-7f, 1e-5f, $"not equal gq");
        }
        public void ReferenceTest()
        {
            int channels = 7, kwidth = 3, kheight = 5, stride = 2, inwidth = 13, inheight = 17;
            int outwidth = (inwidth - kwidth) / stride + 1, outheight = (inheight - kheight) / stride + 1, batch = 2;

            float[] xval = (new float[inwidth * inheight * channels * batch]).Select((_, idx) => idx * 1e-3f).ToArray();
            float[] yval = (new float[outwidth * outheight * channels * batch]).Select((_, idx) => idx * 1e-3f).ToArray();
            float[] wval = (new float[kwidth * kheight * channels]).Select((_, idx) => idx * 1e-3f).Reverse().ToArray();

            Tensor xtensor = new Tensor(Shape.Map2D(channels, inwidth, inheight, batch), xval);
            Tensor ytensor = new Tensor(Shape.Map2D(channels, outwidth, outheight, batch), yval);
            Tensor wtensor = new Tensor(Shape.Kernel2D(channels, 1, kwidth, kheight), wval);

            VariableField  x_actual = xtensor;
            ParameterField w        = wtensor;
            ParameterField y        = ytensor;

            Field      x_expect = ChannelwiseDeconvolution2D(y, w, stride, Shape.Map2D(channels, inwidth, inheight, batch));
            Field      err      = Abs(x_expect - x_actual);
            OutputNode err_node = err.Value.Save();

            (Flow flow, Parameters Parameters) = Flow.Optimize(err);

            flow.Execute();

            float[] err_actual = err_node.Tensor.State;
            float[] gy_actual  = y.GradTensor.State;
            float[] gw_actual  = w.GradTensor.State;

            AssertError.Tolerance(gw_expect, gw_actual, 1e-7f, 1e-5f, $"not equal gw");

            AssertError.Tolerance(gy_expect, gy_actual, 1e-7f, 1e-5f, $"not equal gy");
        }
        public void ReferenceTest()
        {
            int inchannels = 6, outchannels = 8, batch = 3;

            float[] yval = (new float[outchannels * batch]).Select((_, idx) => idx * 1e-3f).ToArray();
            float[] wval = (new float[outchannels * inchannels / 2]).Select((_, idx) => idx * 1e-3f).Reverse().ToArray();

            System.Numerics.Complex[] ycval = (new System.Numerics.Complex[yval.Length / 2])
                                              .Select((_, idx) => new System.Numerics.Complex(yval[idx * 2], yval[idx * 2 + 1])).ToArray();

            System.Numerics.Complex[] wcval = (new System.Numerics.Complex[wval.Length / 2])
                                              .Select((_, idx) => new System.Numerics.Complex(wval[idx * 2], wval[idx * 2 + 1])).ToArray();

            ComplexMap0D    y = new ComplexMap0D(outchannels / 2, batch, ycval);
            ComplexFilter0D w = new ComplexFilter0D(inchannels / 2, outchannels / 2, wcval);

            ComplexMap0D x = Reference(y, w);

            float[] x_expect =
            {
                -4.000000e-05f, 2.600000e-04f, -3.200000e-05f, 2.040000e-04f, -2.400000e-05f, 1.480000e-04f,
                -8.000000e-06f, 1.124000e-03f,  0.000000e+00f, 9.400000e-04f,  8.000000e-06f, 7.560000e-04f,
                2.400000e-05f,  1.988000e-03f,  3.200000e-05f, 1.676000e-03f,  4.000000e-05f, 1.364000e-03f,
            };

            float[] x_actual = x.ToArray();

            AssertError.Tolerance(x_expect, x_actual, 1e-9f, 1e-5f, $"mismatch value {inchannels},{outchannels},{batch}");
        }
        public void TheoreticalTest()
        {
            int length = 24;

            float[] xval = (new float[length]).Select((_, idx) => (float)idx * 2 - length).ToArray();
            float[] tval = (new float[length]).Select((_, idx) => (float)idx / 2).Reverse().ToArray();

            Tensor xtensor = new Tensor(Shape.Vector(length), xval);
            Tensor ttensor = new Tensor(Shape.Vector(length), tval);

            ParameterField x = xtensor;
            VariableField  t = ttensor;

            Field x_real = ComplexReal(x), x_imag = ComplexImag(x);

            Field xy  = ComplexCast(x_real * x_real - x_imag * x_imag, 2 * x_imag * x_real);
            Field err = xy - t;

            (Flow flow, Parameters parameters) = Flow.Optimize(err);
            flow.Execute();

            float[] gx_actual = x.GradTensor.State;

            AssertError.Tolerance(gx_expect, gx_actual, 1e-7f, 1e-5f, $"not equal gx");
        }
예제 #13
0
        public void ReferenceTest()
        {
            int stride = 3;
            int channels = 2, inwidth = 10, batch = 2;
            int outwidth = inwidth / stride;

            float[] xval = (new float[channels * inwidth * batch]).Select((_, idx) => idx * 1e-3f).ToArray();
            float[] yval = (new float[channels * outwidth * batch]).Select((_, idx) => idx * 2e-3f).ToArray();

            Tensor xtensor = new Tensor(Shape.Map1D(channels, inwidth, batch), xval);
            Tensor ytensor = new Tensor(Shape.Map1D(channels, outwidth, batch), yval);

            ParameterField x        = xtensor;
            VariableField  y_actual = ytensor;

            Field y_expect = AveragePooling1D(x, stride);
            Field err      = y_expect - y_actual;

            (Flow flow, Parameters Parameters) = Flow.Optimize(err);

            flow.Execute();

            float[] gx_actual = x.GradTensor.State;

            AssertError.Tolerance(gx_expect, gx_actual, 1e-7f, 1e-5f, $"not equal gx");
        }
예제 #14
0
        public void ReferenceTest()
        {
            int inchannels = 7, outchannels = 11, width = 13, batch = 2;

            float[] xval = (new float[width * inchannels * batch]).Select((_, idx) => idx * 1e-3f).ToArray();
            float[] yval = (new float[width * outchannels * batch]).Select((_, idx) => idx * 1e-3f).ToArray();
            float[] wval = (new float[outchannels * inchannels]).Select((_, idx) => idx * 1e-3f).Reverse().ToArray();

            Tensor xtensor = new Tensor(Shape.Map1D(inchannels, width, batch), xval);
            Tensor ytensor = new Tensor(Shape.Map1D(outchannels, width, batch), yval);
            Tensor wtensor = new Tensor(Shape.Kernel0D(inchannels, outchannels), wval);

            ParameterField x        = xtensor;
            ParameterField w        = wtensor;
            VariableField  y_actual = ytensor;

            Field y_expect = PointwiseConvolution1D(x, w);
            Field err      = Abs(y_expect - y_actual);

            (Flow flow, Parameters Parameters) = Flow.Optimize(err);

            flow.Execute();

            float[] gx_actual = x.GradTensor.State;
            float[] gw_actual = w.GradTensor.State;

            AssertError.Tolerance(gw_expect, gw_actual, 1e-7f, 1e-5f, $"not equal gw");

            AssertError.Tolerance(gx_expect, gx_actual, 1e-7f, 1e-5f, $"not equal gx");
        }
        public void ExecuteTest()
        {
            float max_err = 0;

            Random rd = new Random(1234);

            foreach (int batch in new int[] { 1, 2 })
            {
                foreach (int channels in new int[] { 1, 2, 3, 4, 5, 6, 7, 8 })
                {
                    foreach (int stride in new int[] { 2, 3, 4 })
                    {
                        foreach (int inwidth in new int[] { 5, 7, 11 })
                        {
                            foreach (int inheight in new int[] { 5, 7, 11 })
                            {
                                int outwidth = inwidth / stride, outheight = inheight / stride;

                                float[] xval  = (new float[inwidth * inheight * channels * batch]).Select((_) => (float)rd.NextDouble()).ToArray();
                                float[] gyval = (new float[outwidth * outheight * channels * batch]).Select((_) => (float)rd.NextDouble()).ToArray();

                                Map2D x  = new Map2D(channels, inwidth, inheight, batch, xval);
                                Map2D gy = new Map2D(channels, outwidth, outheight, batch, gyval);

                                Map2D gx = Reference(x, gy, stride);

                                OverflowCheckedTensor x_tensor  = new OverflowCheckedTensor(Shape.Map2D(channels, inwidth, inheight, batch), xval);
                                OverflowCheckedTensor y_tensor  = new OverflowCheckedTensor(Shape.Map2D(channels, outwidth, outheight, batch));
                                OverflowCheckedTensor gy_tensor = new OverflowCheckedTensor(Shape.Map2D(channels, outwidth, outheight, batch), gyval);
                                OverflowCheckedTensor gx_tensor = new OverflowCheckedTensor(Shape.Map2D(channels, inwidth, inheight, batch));

                                MaxPooling ope_pool = new MaxPooling(inwidth, inheight, channels, stride, batch);
                                ope_pool.Execute(x_tensor, y_tensor);

                                MaxUnpooling ope_unpool = new MaxUnpooling(inwidth, inheight, channels, stride, batch);
                                ope_unpool.Execute(gy_tensor, x_tensor, y_tensor, gx_tensor);

                                float[] gx_expect = gx.ToArray();
                                float[] gx_actual = gx_tensor.State;

                                int gx_expect_nonzero = gx_expect.Count((v) => v != 0);
                                int gx_actual_nonzero = gx_expect.Count((v) => v != 0);

                                CollectionAssert.AreEqual(xval, x_tensor.State);
                                CollectionAssert.AreEqual(gyval, gy_tensor.State);

                                Assert.AreEqual(y_tensor.Length, gx_expect_nonzero);
                                Assert.AreEqual(y_tensor.Length, gx_actual_nonzero);

                                AssertError.Tolerance(gx_expect, gx_actual, 1e-7f, 1e-5f, ref max_err, $"mismatch value {channels},{stride},{inwidth},{inheight},{batch}");

                                Console.WriteLine($"pass: {channels},{stride},{inwidth},{inheight},{batch}");
                            }
                        }
                    }
                }
            }

            Console.WriteLine($"maxerr:{max_err}");
        }
        public void OptimizeTest()
        {
            float max_err = 0;

            foreach (int batch in new int[] { 1, 2 })
            {
                foreach (int inchannels in new int[] { 1, 2, 3, 4, 5, 10, 15, 20 })
                {
                    foreach (int outchannels in new int[] { 7, 13 })
                    {
                        foreach (int inwidth in new int[] { 8, 9, 13, 17 })
                        {
                            float[] xval = (new float[inwidth * inchannels * batch]).Select((_, idx) => idx * 1e-3f).ToArray();
                            float[] wval = (new float[inchannels * outchannels]).Select((_, idx) => idx * 1e-3f).Reverse().ToArray();

                            Map1D    x = new Map1D(inchannels, inwidth, batch, xval);
                            Filter1D w = new Filter1D(inchannels, outchannels, 1, wval);

                            Map1D y           = Reference(x, w);
                            Map1D y_optimized = OptimizedReference(x, w);

                            float[] y_expect = y.ToArray();
                            float[] y_actual = y_optimized.ToArray();

                            AssertError.Tolerance(y_expect, y_actual, 1e-7f, 1e-5f, ref max_err, $"mismatch value {inchannels},{outchannels},{inwidth},{batch}");

                            Console.WriteLine($"pass: {inchannels},{outchannels},{inwidth},{batch}");
                        }
                    }
                }
            }

            Console.WriteLine($"maxerr:{max_err}");
        }
        public void ReferenceTest()
        {
            int inchannels = 9, outchannels = 12, batch = 3;

            float[] xval = (new float[inchannels * batch]).Select((_, idx) => idx * 1e-2f).ToArray();
            float[] yval = (new float[outchannels * batch]).Select((_, idx) => idx * 1e-2f).ToArray();
            float[] wval = (new float[outchannels * inchannels / 9 * 4]).Select((_, idx) => idx * 1e-2f).Reverse().ToArray();

            Tensor xtensor = new Tensor(Shape.Map0D(inchannels, batch), xval);
            Tensor ytensor = new Tensor(Shape.Map0D(outchannels, batch), yval);
            Tensor wtensor = new Tensor(Shape.Kernel0D(inchannels / 3 * 4, outchannels / 3), wval);

            ParameterField x        = xtensor;
            ParameterField w        = wtensor;
            VariableField  y_actual = ytensor;

            Field y_expect = TrivectorDense(x, w);
            Field err      = y_expect - y_actual;

            (Flow flow, Parameters Parameters) = Flow.Optimize(err);

            flow.Execute();

            float[] gx_actual = x.GradTensor.State;
            float[] gw_actual = w.GradTensor.State;

            AssertError.Tolerance(gw_expect, gw_actual, 1e-6f, 1e-5f, $"not equal gw");

            AssertError.Tolerance(gx_expect, gx_actual, 1e-6f, 1e-5f, $"not equal gx");
        }
        public void ReferenceTest()
        {
            Shape inshape  = new Shape(ShapeType.Map, 85, 32);
            Shape outshape = new Shape(ShapeType.Map, 23, 32);

            float[] xval = (new float[inshape.Length]).Select((_, idx) => (float)(idx)).Reverse().ToArray();

            float[] tval = (new float[outshape.Length]).Select((_, idx) => (float)(idx * 2)).ToArray();

            Tensor xtensor = new Tensor(inshape, xval);
            Tensor ttensor = new Tensor(outshape, tval);

            ParameterField x = xtensor;
            VariableField  t = ttensor;

            Field y = ExtractChannel(x, 13, 23);

            StoreField o = y.Save();

            Field err = y - t;

            (Flow flow, Parameters Parameters) = Flow.Optimize(err);

            flow.Execute();

            float[] gx_actual = x.GradTensor.State;

            AssertError.Tolerance(gx_expect, gx_actual, 1e-7f, 1e-5f, $"not equal gx");
        }
예제 #19
0
        public async Task Should_Return_Error_When_Not_Logged()
        {
            var getMyVotes         = new GetMyVotes();
            var getMyVotesResponse = await Mediator.Send(getMyVotes);

            AssertError <AuthorizationError> .Of(getMyVotesResponse);
        }
예제 #20
0
        public void ReferenceTest()
        {
            int length = 24;

            float[] xval = (new float[length]).Select((_, idx) => (idx - 11.5f) / 12f).ToArray();
            float[] yval = (new float[length]).Select((_, idx) => (float)idx / 24).ToArray();

            Tensor xtensor = new Tensor(Shape.Vector(length), xval);

            Tensor ytensor = new Tensor(Shape.Vector(length), yval);

            ParameterField x        = xtensor;
            VariableField  y_actual = ytensor;

            Field y_expect = Arcsin(x);
            Field err      = y_expect - y_actual;

            OutputNode n = err.Value.Save();

            (Flow flow, Parameters Parameters) = Flow.Optimize(err);

            flow.Execute();

            float[] div = n.Tensor.State;

            float[] gx_actual = x.GradTensor.State;

            AssertError.Tolerance(gx_expect, gx_actual, 1e-6f, 8e-4f, $"not equal gx"); /*nonlinear tolerance*/
        }
예제 #21
0
        public void ReferenceTest()
        {
            int length = 24;

            float[] xval = (new float[length]).Select((_, idx) => (float)idx - 12).ToArray();
            float[] yval = (new float[length]).Select((_, idx) => (float)idx / 24).ToArray();

            Tensor xtensor = new Tensor(Shape.Vector(length), xval);

            Tensor ytensor = new Tensor(Shape.Vector(length), yval);

            VariableField x        = xtensor;
            VariableField y_actual = ytensor;

            Field y_expect = Sign(x);
            Field err      = y_expect - y_actual;

            OutputNode errnode = err.Value.Save();

            (Flow flow, Parameters Parameters) = Flow.Optimize(err);

            flow.Execute();

            float[] err_actual = errnode.Tensor.State;

            AssertError.Tolerance(err_expect, err_actual, 1e-7f, 1e-5f, $"not equal err");
        }
예제 #22
0
        public void ReferenceTest()
        {
            int length = 24;

            float[] vval = (new float[length]).Select((_, idx) => ((float)idx * 2 - length)).ToArray();
            float[] uval = (new float[length]).Select((_, idx) => ((float)idx * 3 - length)).Reverse().ToArray();
            float[] tval = (new float[length]).Select((_, idx) => ((float)idx / 2)).ToArray();

            Tensor vtensor = new Tensor(Shape.Vector(length), vval);
            Tensor utensor = new Tensor(Shape.Vector(length), uval);
            Tensor ttensor = new Tensor(Shape.Vector(length), tval);

            ParameterField v = vtensor;
            ParameterField u = utensor;
            VariableField  t = ttensor;

            Field vu  = TrivectorCross(v, u);
            Field err = vu - t;

            (Flow flow, Parameters parameters) = Flow.Optimize(err);
            flow.Execute();

            float[] gv_actual = v.GradTensor.State;
            float[] gu_actual = u.GradTensor.State;

            AssertError.Tolerance(gv_expect, gv_actual, 1e-7f, 1e-5f, $"not equal gv");

            AssertError.Tolerance(gu_expect, gu_actual, 1e-7f, 1e-5f, $"not equal gu");
        }
예제 #23
0
        public void ReferenceTest()
        {
            int inchannels = 9, outchannels = 12, kwidth = 3, kheight = 5, stride = 2, inwidth = 7, inheight = 8;
            int outwidth = (inwidth - kwidth) / stride + 1, outheight = (inheight - kheight) / stride + 1, batch = 3;

            float[] xval = (new float[inwidth * inheight * inchannels * batch]).Select((_, idx) => idx * 1e-3f).ToArray();
            float[] yval = (new float[outwidth * outheight * outchannels * batch]).Select((_, idx) => idx * 1e-3f).ToArray();
            float[] wval = (new float[kwidth * kheight * outchannels * inchannels / 9 * 4]).Select((_, idx) => idx * 1e-3f).Reverse().ToArray();

            Tensor xtensor = new Tensor(Shape.Map2D(inchannels, inwidth, inheight, batch), xval);
            Tensor ytensor = new Tensor(Shape.Map2D(outchannels, outwidth, outheight, batch), yval);
            Tensor wtensor = new Tensor(Shape.Kernel2D(inchannels / 3 * 4, outchannels / 3, kwidth, kheight), wval);

            VariableField  x_actual = xtensor;
            ParameterField w        = wtensor;
            ParameterField y        = ytensor;

            Field x_expect = TrivectorDeconvolution2D(y, w, stride, Shape.Map2D(inchannels, inwidth, inheight, batch));
            Field err      = x_expect - x_actual;

            (Flow flow, Parameters Parameters) = Flow.Optimize(err);

            flow.Execute();

            float[] gy_actual = y.GradTensor.State;
            float[] gw_actual = w.GradTensor.State;

            AssertError.Tolerance(gw_expect, gw_actual, 1e-6f, 1e-5f, $"not equal gw");

            AssertError.Tolerance(gy_expect, gy_actual, 1e-6f, 1e-5f, $"not equal gy");
        }
        public void ReferenceTest()
        {
            int pad_left = 2, pad_right = 1, pad_top = 3, pad_bottom = 5, pad_front = 4, pad_rear = 2;
            int channels = 3, inwidth = 5, inheight = 6, indepth = 7, batch = 2;
            int outwidth  = inwidth + pad_left + pad_right;
            int outheight = inheight + pad_top + pad_bottom;
            int outdepth  = indepth + pad_front + pad_rear;

            float[] xval = (new float[channels * inwidth * inheight * indepth * batch]).Select((_, idx) => idx * 1e-3f).ToArray();
            float[] yval = (new float[channels * outwidth * outheight * outdepth * batch]).Select((_, idx) => idx * 2e-3f).ToArray();

            Tensor xtensor = new Tensor(Shape.Map3D(channels, inwidth, inheight, indepth, batch), xval);
            Tensor ytensor = new Tensor(Shape.Map3D(channels, outwidth, outheight, outdepth, batch), yval);

            ParameterField x        = xtensor;
            VariableField  y_actual = ytensor;

            Field y_expect = EdgePadding3D(x, pad_left, pad_right, pad_top, pad_bottom, pad_front, pad_rear);
            Field err      = y_expect - y_actual;

            (Flow flow, Parameters Parameters) = Flow.Optimize(err);

            flow.Execute();

            float[] gx_actual = x.GradTensor.State;

            AssertError.Tolerance(gx_expect, gx_actual, 1e-7f, 1e-5f, $"not equal gx");
        }
예제 #25
0
        public void ReferenceTest()
        {
            int length = 24;

            float[] xval = (new float[length]).Select((_, idx) => ((float)idx - 12) / 12f).ToArray();
            float[] yval = (new float[length]).Select((_, idx) => (float)idx / 24).ToArray();

            Tensor xtensor = new Tensor(Shape.Vector(length), xval);

            Tensor ytensor = new Tensor(Shape.Vector(length), yval);

            ParameterField x        = xtensor;
            VariableField  y_actual = ytensor;

            Field y_expect = 5 - x;
            Field err      = y_expect - y_actual;

            (Flow flow, Parameters Parameters) = Flow.Optimize(err);

            flow.Execute();

            float[] gx_actual = x.GradTensor.State;

            AssertError.Tolerance(gx_expect, gx_actual, 1e-7f, 1e-5f, $"not equal gx");
        }
예제 #26
0
        public void ReferenceTest()
        {
            int scale = 3;
            int inchannels = 2, outwidth = 4, outheight = 3, batch = 2;
            int outchannels = inchannels * scale * scale, inwidth = outwidth * scale, inheight = outheight * scale;

            float[] xval = (new float[inchannels * inwidth * inheight * batch]).Select((_, idx) => idx * 2e-3f).ToArray();
            float[] yval = (new float[outchannels * outwidth * outheight * batch]).Select((_, idx) => idx * 1e-3f).ToArray();

            Tensor xtensor = new Tensor(Shape.Map2D(inchannels, inwidth, inheight, batch), xval);
            Tensor ytensor = new Tensor(Shape.Map2D(outchannels, outwidth, outheight, batch), yval);

            ParameterField x        = xtensor;
            VariableField  y_actual = ytensor;

            Field y_expect = SpaceToChannel2D(x, scale);
            Field err      = y_expect - y_actual;

            (Flow flow, Parameters Parameters) = Flow.Optimize(err);

            flow.Execute();

            float[] gx_actual = x.GradTensor.State;

            AssertError.Tolerance(gx_expect, gx_actual, 1e-7f, 1e-5f, $"not equal gx");
        }
        public void ReferenceTest()
        {
            int inchannels = 6, outchannels = 8, kwidth = 3, stride = 2, inwidth = 13;
            int outwidth = (inwidth - kwidth) / stride + 1, batch = 3;

            float[] xval = (new float[inwidth * inchannels * batch]).Select((_, idx) => idx * 1e-3f).ToArray();
            float[] yval = (new float[outwidth * outchannels * batch]).Select((_, idx) => idx * 1e-3f).ToArray();
            float[] wval = (new float[kwidth * outchannels * inchannels / 2]).Select((_, idx) => idx * 1e-3f).Reverse().ToArray();

            Tensor xtensor = new Tensor(Shape.Map1D(inchannels, inwidth, batch), xval);
            Tensor ytensor = new Tensor(Shape.Map1D(outchannels, outwidth, batch), yval);
            Tensor wtensor = new Tensor(Shape.Kernel1D(inchannels, outchannels / 2, kwidth), wval);

            ParameterField x        = xtensor;
            ParameterField w        = wtensor;
            VariableField  y_actual = ytensor;

            Field y_expect = ComplexConvolution1D(x, w, stride);
            Field err      = y_expect - y_actual;

            (Flow flow, Parameters Parameters) = Flow.Optimize(err);

            flow.Execute();

            float[] gx_actual = x.GradTensor.State;
            float[] gw_actual = w.GradTensor.State;

            AssertError.Tolerance(gw_expect, gw_actual, 1e-7f, 1e-5f, $"not equal gw");

            AssertError.Tolerance(gx_expect, gx_actual, 1e-7f, 1e-5f, $"not equal gx");
        }
        public void ReferenceTest()
        {
            int inchannels = 6, outchannels = 8, batch = 3;

            float[] xval = (new float[batch * inchannels]).Select((_, idx) => idx * 1e-3f).ToArray();
            float[] wval = (new float[outchannels * inchannels / 2]).Select((_, idx) => idx * 1e-3f).Reverse().ToArray();

            System.Numerics.Complex[] xcval = (new System.Numerics.Complex[xval.Length / 2])
                                              .Select((_, idx) => new System.Numerics.Complex(xval[idx * 2], xval[idx * 2 + 1])).ToArray();

            System.Numerics.Complex[] wcval = (new System.Numerics.Complex[wval.Length / 2])
                                              .Select((_, idx) => new System.Numerics.Complex(wval[idx * 2], wval[idx * 2 + 1])).ToArray();

            ComplexMap0D    x = new ComplexMap0D(inchannels / 2, batch, xcval);
            ComplexFilter0D w = new ComplexFilter0D(inchannels / 2, outchannels / 2, wcval);

            ComplexMap0D y = Reference(x, w);

            float[] y_expect =
            {
                -5.400000e-05f, 2.930000e-04f, -3.600000e-05f, 2.030000e-04f, -1.800000e-05f, 1.130000e-04f,
                0.000000e+00f,  2.300000e-05f, -3.600000e-05f, 1.031000e-03f, -1.800000e-05f, 7.250000e-04f,
                -2.710505e-20f, 4.190000e-04f,  1.800000e-05f, 1.130000e-04f, -1.800000e-05f, 1.769000e-03f,
                0.000000e+00f,  1.247000e-03f,  1.800000e-05f, 7.250000e-04f,  3.600000e-05f, 2.030000e-04f,
            };

            float[] y_actual = y.ToArray();

            AssertError.Tolerance(y_expect, y_actual, 1e-9f, 1e-5f, $"mismatch value {inchannels},{outchannels},{batch}");
        }
예제 #29
0
        public void ReferenceTest()
        {
            int length = 24;

            float[] x1val = (new float[length]).Select((_, idx) => (float)idx).ToArray();
            float[] x2val = (new float[length]).Select((_, idx) => (float)idx + 1).Reverse().ToArray();
            float[] yval  = (new float[length]).Select((_, idx) => (float)idx * 2).ToArray();

            Tensor x1tensor = new Tensor(Shape.Vector(length), x1val);
            Tensor x2tensor = new Tensor(Shape.Vector(length), x2val);

            Tensor ytensor = new Tensor(Shape.Vector(length), yval);

            ParameterField x1       = x1tensor;
            ParameterField x2       = x2tensor;
            VariableField  y_actual = ytensor;

            Field y_expect = x1 + x2;
            Field err      = y_expect - y_actual;

            (Flow flow, Parameters Parameters) = Flow.Optimize(err);

            flow.Execute();

            float[] gx1_actual = x1.GradTensor.State;
            float[] gx2_actual = x2.GradTensor.State;

            AssertError.Tolerance(gx1_expect, gx1_actual, 1e-7f, 1e-5f, $"not equal gx1");

            AssertError.Tolerance(gx2_expect, gx2_actual, 1e-7f, 1e-5f, $"not equal gx2");
        }
예제 #30
0
        public void ReferenceTest()
        {
            int length = 24;

            float[] xval = (new float[length]).Select((_, idx) => (float)idx / 12).ToArray();
            float[] yval = (new float[length]).Select((_, idx) => (float)idx / 24).ToArray();

            ParameterField x = new Tensor(Shape.Vector(length), xval);
            ParameterField p = new Tensor(Shape.Scalar(), new float[] { 1.5f });

            VariableField y_actual = new Tensor(Shape.Vector(length), yval);

            Field y_expect = Pow(x, p);
            Field err      = y_expect - y_actual;

            (Flow flow, Parameters Parameters) = Flow.Optimize(err);

            flow.Execute();

            float[] gx_actual = x.GradTensor.State;

            AssertError.Tolerance(gx_expect, gx_actual, 1e-7f, 1e-5f, $"not equal gx");

            float[] gp_actual = p.GradTensor.State;

            AssertError.Tolerance(gp_expect, gp_actual, 1e-7f, 1e-5f, $"not equal gp");
        }