コード例 #1
0
        /// <summary>
        /// Backpropagate "errors" to previous layer for future use
        /// </summary>
        protected override void DoBackprop(DeepLayerBase prevLayer, double[][,] prevValues, double[][,] prevErrors, double[][,] errors)
        {
            if (prevLayer == null)
            {
                throw new MLException("Prev layer is null");
            }

            for (int p = 0; p < m_InputDepth; p++)
            {
                for (int y = 0; y < m_WindowHeight; y++)
                {
                    for (int x = 0; x < m_WindowWidth; x++)
                    {
                        var g = 0.0D;

                        for (int q = 0; q < m_OutputDepth; q++)
                        {
                            var idx = x + y * m_WindowWidth + p * m_KernelParamCount + q * m_FeatureMapParamCount;
                            g += errors[q][0, 0] * m_Weights[idx]; // Kernel(q, p, y, x)
                        }

                        var value = prevValues[p][y, x];
                        var deriv = (prevLayer.ActivationFunction != null) ? prevLayer.ActivationFunction.DerivativeFromValue(value) : 1;
                        prevErrors[p][y, x] = g * deriv;
                    }
                }
            }
        }
コード例 #2
0
        protected override void DoBackprop(DeepLayerBase prevLayer, double[][,] prevValues, double[][,] prevErrors, double[][,] errors)
        {
            for (int i = 0; i < prevErrors.Length; i++)
            {
                Array.Clear(prevErrors[i], 0, prevErrors[i].Length);
            }

            var maxPos = MaxIndexPositions;

            // backpropagate "errors" to previous layer for future use
            for (int q = 0; q < m_OutputDepth; q++)
            {
                for (int i = 0; i < m_OutputHeight; i++)
                {
                    for (int j = 0; j < m_OutputWidth; j++)
                    {
                        var xmaxIdx = maxPos.Value[q][i, j, 0];
                        var ymaxIdx = maxPos.Value[q][i, j, 1];
                        var value   = prevValues[q][ymaxIdx, xmaxIdx];
                        var deriv   = (prevLayer.ActivationFunction != null) ? prevLayer.ActivationFunction.DerivativeFromValue(value) : 1;
                        prevErrors[q][ymaxIdx, xmaxIdx] += errors[q][i, j] * deriv;
                    }
                }
            }
        }
コード例 #3
0
        /// <summary>
        /// Backpropagate "errors" to previous layer for future use
        /// </summary>
        /// <param name="prevLayer">Previous layer</param>
        /// <param name="errors">Current layer gradient "errors"</param>
        /// <param name="updates">Previous layer gradient "errors"</param>
        public void Backprop(DeepLayerBase prevLayer, double[][,] prevValues, double[][,] prevErrors, double[][,] errors)
        {
            if (!m_IsTraining)
            {
                throw new MLException("Backpropagation can not run in test mode");
            }

            DoBackprop(prevLayer, prevValues, prevErrors, errors);
        }
コード例 #4
0
ファイル: ConvLayer.cs プロジェクト: itadapter/ML
        /// <summary>
        /// Backpropagate "errors" to previous layer for future use
        /// </summary>
        protected override void DoBackprop(DeepLayerBase prevLayer, double[][,] prevValues, double[][,] prevErrors, double[][,] errors)
        {
            if (prevLayer == null)
            {
                throw new MLException("Prev layer is null");
            }

            for (int p = 0; p < m_InputDepth; p++)
            {
                for (int i = 0; i < m_InputHeight; i++)
                {
                    for (int j = 0; j < m_InputWidth; j++)
                    {
                        var g = 0.0D;

                        for (int q = 0; q < m_OutputDepth; q++)
                        {
                            var y = i + m_PaddingHeight + m_StrideHeight;
                            for (int k = 0; k < m_OutputHeight; k++)
                            {
                                y -= m_StrideHeight;
                                if (y >= m_WindowHeight)
                                {
                                    continue;
                                }
                                if (y < 0)
                                {
                                    break;
                                }

                                var x = j + m_PaddingWidth + m_StrideWidth;
                                for (int m = 0; m < m_OutputWidth; m++)
                                {
                                    x -= m_StrideWidth;
                                    if (x >= m_WindowWidth)
                                    {
                                        continue;
                                    }
                                    if (x < 0)
                                    {
                                        break;
                                    }

                                    var idx = x + y * m_WindowWidth + p * m_KernelParamCount + q * m_FeatureMapParamCount;
                                    g += errors[q][k, m] * m_Weights[idx]; // Kernel(q, p, y, x)
                                }
                            }
                        }

                        var value = prevValues[p][i, j];
                        var deriv = (prevLayer.ActivationFunction != null) ? prevLayer.ActivationFunction.DerivativeFromValue(value) : 1;
                        prevErrors[p][i, j] = g * deriv;
                    }
                }
            }
        }
コード例 #5
0
 protected override void DoBackprop(DeepLayerBase prevLayer, double[][,] prevValues, double[][,] prevError, double[][,] errors)
 {
     for (int p = 0; p < m_OutputDepth; p++)
     {
         for (int i = 0; i < m_OutputHeight; i++)
         {
             for (int j = 0; j < m_OutputWidth; j++)
             {
                 var value = prevValues[p][i, j];
                 var deriv = (prevLayer.ActivationFunction != null) ? prevLayer.ActivationFunction.DerivativeFromValue(value) : 1;
                 prevError[p][i, j] = errors[p][i, j] * deriv;
             }
         }
     }
 }
コード例 #6
0
        /// <summary>
        /// Backpropagate "errors" to previous layer for future use
        /// </summary>
        protected override void DoBackprop(DeepLayerBase prevLayer, double[][,] prevValues, double[][,] prevError, double[][,] errors)
        {
            if (prevLayer == null)
            {
                throw new MLException("Prev layer is null");
            }

            var plen = m_InputDepth + 1;

            for (int p = 0; p < m_InputDepth; p++)
            {
                var g = 0.0D;
                for (int q = 0; q < m_OutputDepth; q++)
                {
                    g += errors[q][0, 0] * m_Weights[p + q * plen]; // Kernel(q, p, 0, 0)
                }
                var value = prevValues[p][0, 0];
                var deriv = (prevLayer.ActivationFunction != null) ? prevLayer.ActivationFunction.DerivativeFromValue(value) : 1;
                prevError[p][0, 0] = g * deriv;
            }
        }
コード例 #7
0
 protected override void DoBackprop(DeepLayerBase prevLayer, double[][,] prevValues, double[][,] prevErrors, double[][,] errors)
 {
     throw new NotImplementedException(); //TODO
 }
コード例 #8
0
 protected abstract void DoBackprop(DeepLayerBase prevLayer, double[][,] prevValues, double[][,] prevError, double[][,] errors);
コード例 #9
0
 protected override void DoBackprop(DeepLayerBase prevLayer, double[][,] prevValues, double[][,] prevError, double[][,] errors)
 {
     throw new NotSupportedException();
 }