示例#1
0
    // Connection Creation ---
    private GraphicConnection CreateGCon(NeuralConnection c, GraphicNode ingn, GraphicNode outgn)
    {
        if (c == null || ingn == null || outgn == null)
        {
            return(null);
        }
        GraphicConnection gc = new GraphicConnection(c, ingn, outgn);

        gCons.Add(gc);
        return(gc);
    }
示例#2
0
 private bool IsInClosedCons(NeuralConnection c, List <NeuralConnection> list)
 {
     for (int i = 0; i < list.Count; ++i)
     {
         if (list[i] == c)
         {
             return(true);
         }
     }
     return(false);
 }
        public void Ctor_InitializesClass()
        {
            // Setup test values
            var mockTarget = new Mock<INeuralNode>();
            var mockSource = new Mock<INeuralNode>();
            const double ExpectedWeight = 0.11d;

            // Execute
            var actual = new NeuralConnection(ExpectedWeight, mockSource.Object, mockTarget.Object);

            // Verify
            mockSource.Verify(mock => mock.AddOutboundConnection(actual), Times.Once());
            mockTarget.Verify(mock => mock.AddInboundConnection(actual), Times.Once());

            Assert.AreEqual(ExpectedWeight, actual.Weight);
            Assert.AreSame(mockSource.Object, actual.SourceNode);
            Assert.AreSame(mockTarget.Object, actual.TargetNode);
        }
示例#4
0
        public RecogAkshaysPictureNetwork()
        {
            Globals.LearningRateForNeurons = (decimal)0.00000000000000000043368086899420177360298112034798;
            NeuralLayer rawInputLayer = new NeuralLayer();

            for (int i = 0; i < 1024 * 1024; i++)
            {
                RawInputLayerNeuron riln = new RawInputLayerNeuron((decimal)0, (decimal)2097152);
                rawInputLayer.AddNeuronToLayer(riln);
            }
            Layers.Add(rawInputLayer);
            NeuralLayer hiddenLayer = new NeuralLayer();

            for (int i = 0; i < 1024 * 1024; i++)
            {
                HiddenLayerNeuron hln = new HiddenLayerNeuron((decimal)2199023255552);
                hiddenLayer.AddNeuronToLayer(hln);
            }
            Layers.Add(hiddenLayer);
            foreach (HiddenLayerNeuron hln in hiddenLayer.LayerNeurons)
            {
                foreach (RawInputLayerNeuron riln in rawInputLayer.LayerNeurons)
                {
                    NeuralConnection nc = new NeuralConnection(riln, hln, (decimal)2097152);
                    hln.Inputs.Add(nc);
                    riln.Outputs.Add(nc);
                }
            }
            NeuralLayer          outputLayer = new NeuralLayer();
            RawOutputLayerNeuron roln        = new RawOutputLayerNeuron((decimal)2305843009213693952);

            foreach (HiddenLayerNeuron hln in hiddenLayer.LayerNeurons)
            {
                NeuralConnection nc = new NeuralConnection(hln, roln, (decimal)2199023255552);
                hln.Outputs.Add(nc);
                roln.Inputs.Add(nc);
            }
        }
示例#5
0
 public GraphicConnection(NeuralConnection c, GraphicNode inp, GraphicNode outp)
 {
     connection = c; inNode = inp;  outNode = outp;
 }
        public void Fire_CachesInput()
        {
            // Setup test values
            var mockTarget = new Mock<INeuralNode>();
            var mockSource = new Mock<INeuralNode>();
            const double Weight = 0.1d;
            const double Expected = 0.123d;

            // Setup target
            var connection = new NeuralConnection(Weight, mockSource.Object, mockTarget.Object);

            // Execute
            connection.Fire(Expected);

            // Verify
            Assert.AreEqual(Expected, connection.CachedInput);
        }
        public void Fire_WontFireWhenAlreadyFired()
        {
            // Setup test values
            var mockTarget = new Mock<INeuralNode>();
            var mockSource = new Mock<INeuralNode>();
            const double Weight = 0.123d;
            const double Input = 2.34d;

            // Setup target
            var connection = new NeuralConnection(Weight, mockSource.Object, mockTarget.Object);

            // Execute
            connection.Fire(Input);
            connection.Fire(Input);
        }
        public void Fire_ModifiesInputSignal()
        {
            // Setup test values
            var mockTarget = new Mock<INeuralNode>();
            var mockSource = new Mock<INeuralNode>();
            const double Weight = 0.123d;
            const double Input = 2.34d;
            const double Expected = Weight * Input;

            // Setup target
            var connection = new NeuralConnection(Weight, mockSource.Object, mockTarget.Object);

            // Execute
            connection.Fire(Input);

            // Verify
            mockTarget.Verify(mock => mock.Fire(Expected));
        }
        public void Fire_MaintainsFiredFlag()
        {
            // Setup test values
            var mockTarget = new Mock<INeuralNode>();
            var mockSource = new Mock<INeuralNode>();
            const double Weight = 0.123d;
            const double Input = 2.34d;

            // Setup target
            var connection = new NeuralConnection(Weight, mockSource.Object, mockTarget.Object);

            // Execute
            var preFiredFlag = connection.IsFired;

            connection.Fire(Input);
            var postFiredFlag = connection.IsFired;

            connection.ClearFire();
            var postClearedFlag = connection.IsFired;

            // Verify
            Assert.IsFalse(preFiredFlag);
            Assert.IsTrue(postFiredFlag);
            Assert.IsFalse(postClearedFlag);
        }