public override void Propagate(float value)
 {
     _value += value;
     Inputs.AccountSignal();
     if (Inputs.CheckCountAndReset())
     {
         _value     = Function.Activation(_value);
         _lastValue = _value;
         _value     = 0;
     }
 }
示例#2
0
        public override void Propagate(float value)
        {
            _value = Function.Activation(value);

            foreach (var output in Outputs)
            {
                output.Propagate(_value);
            }

            _lastValue = _value;
            _value     = 0;
        }
 public override void Propagate(float value)
 {
     _value += value;
     Inputs.AccountSignal();
     if (Inputs.CheckCountAndReset())
     {
         _value = Function.Activation(_value);
         foreach (var output in Outputs)
         {
             output.Propagate(_value);
         }
         _lastValue = _value;
         _value     = 0;
     }
 }
示例#4
0
        public double[,] Compute(double[][,] input)
        {
            int i, y, x, h, w;
            var outputHeight = Output.GetLength(0);
            var outputWidth  = Output.GetLength(1);
            var inputHeight  = input[0].GetLength(0);
            var inputWidth   = input[0].GetLength(1);

            Output = new double[_inHeight - _kernelSize + 1, _inWidth - _kernelSize + 1];
            Input  = new double[inputHeight, inputWidth];

            //суммируем все входные изображения
            //for (i = 0; i < input.Length; i++)
            //{
            //    for (y = 0; y < inputHeight; y++)
            //    {
            //        for (x = 0; x < inputWidth; x++)
            //        {
            //            Input[y, x] += input[i][y, x];
            //        }
            //    }
            //}

            Input = Class1.Test(input);

            //сканируем изображение ядром
            for (y = 0; y < outputHeight; y++)
            {
                for (x = 0; x < outputWidth; x++)
                {
                    for (h = 0; h < _kernelSize; h++)
                    {
                        for (w = 0; w < _kernelSize; w++)
                        {
                            Output[y, x] += Input[y + h, x + w] * Weights[h, w];
                        }
                    }

                    Output[y, x] = Function.Activation(Output[y, x]);
                }
            }

            return(Output);
        }
        public double Compute(double[] input)
        {
            double e = 0;

            unsafe
            {
                fixed(double *w = Weights, i = input)
                for (var n = 0; n < input.Length; n++)
                {
                    e += w[n] * i[n];
                }
            }

            var output = Function.Activation(e + Bias);

            Output = output;

            return(output);
        }