예제 #1
0
        public void basic_backprop_with_1_node()
        {
            ENV.engine = new Engine();
            var x = alb.scalar(0);
            var y = alb.scalar(1);

            var dy = alb.scalar(1);

            Dictionary <int, Tensor> accumulatedGradientsMap = new Dictionary <int, Tensor>();

            accumulatedGradientsMap.Add(y.id, dy);

            var input1 = new System.Collections.Generic.Dictionary <string, Tensor>();

            input1.Add("x", x);

            TapeNode[] tape = new TapeNode[] {
                new TapeNode()
                {
                    gradient = (Tensor dy2) =>
                    {
                        NamedGradientMap ngm = new NamedGradientMap();
                        ngm.gradient.Add("x", () =>
                        {
                            return(dy2.add(alb.scalar(1)));
                        });
                        return(ngm);
                    }
                    , id     = 0
                    , inputs = input1,
                    name     = "node0",
                    output   = y
                }
            };

            Tape.backpropagateGradients(accumulatedGradientsMap, tape);


            AssertTools.ArrayIsEqual(accumulatedGradientsMap[x.id].dataSync(), new float[] { 2 });
        }
예제 #2
0
        public static void basic_backprop_with_a_split_node_accumulates_gradients()
        {
            ENV.engine = new Engine();
            var x             = alb.scalar(0);
            var intermediate1 = alb.scalar(1);
            var intermediate2 = alb.scalar(2);
            var y             = alb.scalar(3);

            var dy = alb.scalar(1);
            Dictionary <int, Tensor> accumulatedGradientsMap =
                new Dictionary <int, Tensor>();

            accumulatedGradientsMap.Add(y.id, dy);



            TapeNode node0 = new TapeNode();

            node0.id     = 0;
            node0.name   = "node0";
            node0.inputs = new Dictionary <string, Tensor>();
            node0.inputs.Add("x", x);
            node0.output   = intermediate1;
            node0.gradient = (Tensor dy2) =>
            {
                NamedGradientMap ngm = new NamedGradientMap();
                ngm.gradient.Add("x", () =>
                {
                    return(dy2.add(alb.scalar(1)));
                });
                return(ngm);
            };



            TapeNode node1 = new TapeNode();

            node1.id     = 1;
            node1.name   = "node1";
            node1.inputs = new Dictionary <string, Tensor>();
            node1.inputs.Add("x", x);
            node1.output   = intermediate2;
            node1.gradient = (Tensor dy2) =>
            {
                NamedGradientMap ngm = new NamedGradientMap();
                ngm.gradient.Add("x", () =>
                {
                    return(dy2.add(alb.scalar(1)));
                });
                return(ngm);
            };



            TapeNode node2 = new TapeNode();

            node2.id     = 2;
            node2.name   = "node2";
            node2.inputs = new Dictionary <string, Tensor>();
            node2.inputs.Add("intermediate1", intermediate1);
            node2.inputs.Add("intermediate2", intermediate2);
            node2.output   = y;
            node2.gradient = (Tensor dy2) =>
            {
                NamedGradientMap ngm = new NamedGradientMap();
                ngm.gradient.Add("intermediate1", () =>
                {
                    return(dy2.add(alb.scalar(1)));
                });
                ngm.gradient.Add("intermediate2", () =>
                {
                    return(dy2.add(alb.scalar(1)));
                });
                return(ngm);
            };

            TapeNode[] tape = new TapeNode[] { node0, node1, node2 };

            Tape.backpropagateGradients(accumulatedGradientsMap, tape);
            AssertTools.ArrayIsEqual(accumulatedGradientsMap[x.id].dataSync(), new float[] { dy.dataSync()[0] + 5 });
        }