Неправильные веса и полученная ошибка, как я могу улучшить обратное распространение?

Question

Я пытаюсь создать простую программу распознавания букв в Visual Basic (в конечном итоге я перейду на Python), но у меня, похоже, возникают проблемы с моими окончательными результатами. Сеть рассматривает изображения размером 5 x 5 (очень маленькие), и все буквы для простоты являются черно-белыми - я беру эти изображения и обрабатываю их, чтобы получить свои веса.

Я принципиально застрял, я считаю, что я не должен понимать свое влияние на ошибки и вычисления, поскольку я много раз пытался настроить формулу обратного распространения (пересчитать * дельта-вес, пытаясь ввести другую функцию активации, проверяя мой вес верен с другой программой, которая, как доказано, работает, такой как ввод в Google или различные онлайн программы).

Private Sub Train(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles btnTrain.Click

        Dim i, j, k, epoch, p, np, op As Integer
        Dim random As Random = New Random(CInt(DateTime.Now.Ticks >> 32))

        ' Read bitmap files.
        GetInputs()

        ' Initialize weights.
        If (Not chkUseLoadedWeights.Checked) Then
            InitializeWeights()
        End If

        Dim outPutText As Integer


        For epoch = 0 To NumberEpochs.Value
            Err = 0

            ' Randomize sample order.
            For p = 1 To NumberPatterns
                RandomPattern(p) = p
            Next p
            For p = 1 To NumberPatterns
                np = CInt((p + random.NextDouble() * (NumberPatterns + 1 - p)))
                op = RandomPattern(p)
                RandomPattern(p) = RandomPattern(np)
                RandomPattern(np) = op
            Next p

            ' Repeat for all the training patterns.
            For np = 1 To NumberPatterns
                p = RandomPattern(np)

                ' Compute the hidden units activations.
                For j = 1 To NumberHiddenNodes
                    SumH(p, j) = WeightIH(p, j)
                    For i = 1 To NumberInputNodes
                        SumH(p, j) += Input(p, i) * WeightIH(i, j)
                    Next i
                    Hidden(p, j) = g(SumH(p, j))
                Next j

                ' Compute the output.
                For k = 1 To NumberOutputNodes
                    SumO(p, k) = WeightHO(p, k)
                    For j = 1 To NumberHiddenNodes
                        SumO(p, k) += Hidden(p, j) * WeightHO(j, k)
                    Next
                    Output(p, k) = g(SumO(p, k))
                Next k

                ' ========= BACKPROPAGATION =========

                ' Calculate the error DeltaO[k] (k from 1 to NumberOutputNodes).
                ' DeltaO(k)=g'(SumO)*(Target-Output)
                For k = 1 To NumberOutputNodes
                    DeltaO(k) = g_prime(SumO(p, k)) * (Target(p, k) - Output(p, k))
                Next k

                ' Develop error
                For j = 1 To NumberHiddenNodes
                    Dim err1 As Double = 0
                    For k = 1 To NumberOutputNodes
                        err1 += SumO(p, k) * DeltaO(k)
                    Next k
                    SumDOW(j) = err1
                Next j

                ' Calculate DeltaH=SumDOW*g_prime(SumH)
                For j = 0 To NumberHiddenNodes
                    DeltaH(j) = SumDOW(j) * g_prime(SumH(p, j))
                Next j

            ' ========= UPDATE WEIGHTS =========
                For k = 1 To NumberOutputNodes
                    For j = 0 To NumberHiddenNodes
                        'check this formula
                        'nn.HiddenToOutputWeights[j, i] += nn.LearningRate * delta_outputs[i] * nn.Hidden[j];
                        WeightHO(j, k) += alpha * DeltaO(k) * Hidden(p, j)
                    Next j
                Next k

                For j = 1 To NumberHiddenNodes
                    For i = 0 To NumberInputNodes
                        'check this formula
                        'nn.InputToHiddenWeights[j, i] += nn.LearningRate * delta_hidden[i] * nn.Inputs[j];
                        WeightIH(i, j) += alpha * DeltaH(j) * Input(p, i)
                    Next i
                Next j

            Next np

            'Display the error in txtStatus
            'check this formula for total error
            'Err{total} = sum((1/2(target - output)^{2}

            Dim Text As String = txtStatus.Text
            For k = 1 To NumberOutputNodes
                Dim error1 As Double = Math.Pow(Target(p, k) - Output(p, k), 2)
                Err += error1
            Next k

            'Display the error in txtStatus
            Dim Epp As Integer = DisplayEpoch.Value
            outPutText += 1
            If (outPutText Mod Epp) = 0 Then
                txtStatus.Text = Text + Err.ToString() & Environment.NewLine
            End If

        Next epoch
    End Sub

Ожидаемые результаты будут, по крайней мере, на 80% уровне достоверности, но мой код, кажется, никогда не генерирует такие значения, и я считаю, что я переизбираюсь, когда превышаю 1 миллион итераций, скорость обучения составляет 0,5 / 100.

Result: 0.2306194111 (for letter M)


Weights created:
0.251910848975917
0.250919678999437
0.254997426200398
0.242402996120349
0.267449545482946
0.290554079223225
0.323177654667404
0.350248279677399
0.0640194934321697
0.0438716025375704