Не работает программа по распознаванию цифр (машинное обучение, numpy)

import numpy as np
 
 
def parse_labels(filename):
    with open(filename, 'rb') as f:
        text = f.read()
        barr = bytearray(text)
        array = []
        for byte in barr[8:]:
            array.append(byte)
        return np.array(array)
 
 
# Возвращает матрицу картинок
# Картинка это одномерный список, с которым при этом работать нужно как с двумерным
def parse_img(filename, num_of_imgs):
    with open(filename, 'rb') as f:
        text = f.read()
        barr = bytearray(text)[16:]
        array = []
        for z in range(num_of_imgs):
            array.append([])
            for i in range(28):
                for k in range(28):
                    array[z].append(barr[784 * z + i * 28 + k])
        return np.array(array)
 
 
def write_weigth_to_file(filename, weight):
    with open(filename, 'w') as f:
        weight = list(weight)
        for i in range(len(weight)):
            weight[i] = list(weight[i])
            for k in range(len(weight[i])):
                weight[i][k] = str(weight[i][k])
        print(weight)
        weight = [' '.join(w) for w in weight]
        weight = '\n'.join(weight)
        f.write(weight)
 
 
def get_weight(filename, r1, r2):
    if filename is not None:
        with open(filename, 'r') as f:
            text = f.read()
            text = text.split('\n')
            weights = [i.split() for i in text]
 
        for i in range(len(weights)):
            for k in range(len(weights[i])):
                weights[i][k] = float(weights[i][k])
 
        return np.array(weights)
    else:
        # Это плохо, но нам нужны детерменированные веса!
        return np.array([[0.0 for i in range(r2)] for k in range(r1)])
        # Тут надо настроить чтобы рандомились небольшие числа. Иначе корректировки просто их не могут победить
        # return np.random.random((r1, r2))

import numpy as np
from skimage.io import imread, imsave
from helper import parse_img, parse_labels, write_weigth_to_file, get_weight
 
 
class Neuro2:
 
    # Количество слоев равно количеству имен файлов
    # weights_from_file -- булева переменная, отвечающая за то берем ли мы веса из файла
    # shapes -- кортежи содержащие в себе размерности матриц весов (список кортежей)
    def __init__(self, filenames, weights_from_file, shapes):
        self.filenames = filenames
        self.shapes = shapes
        self.weights = []
        self.get_weights(weights_from_file)
 
    def get_weights(self, from_file):
        if from_file:
            for i, filename in enumerate(self.filenames):
                self.weights.append(get_weight(filename, self.shapes[i][0], self.shapes[i][1]))
        else:
            for i in range(len(self.filenames)):
                self.weights.append(get_weight(None, self.shapes[i][0], self.shapes[i][1]))
 
    def write_weights_to_file(self):
        for i in range(len(self.filenames)):
            write_weigth_to_file(self.filenames[i], self.weights[i])
 
    def learn(self, iterations):
        # Получам пикчи и ожидаемые результаты
        array_imgs = parse_img('train-images-idx3-ubyte', 60000)
        expected = parse_labels('train-labels-idx1-ubyte')
        for something in range(iterations):
            for index, img in enumerate(array_imgs):
                exp = np.array([0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0])
                exp[expected[index]] += 1
                alpha = 0.0000000001
                layers = [np.array(img)]
                for i in range(len(self.weights)):
                    layers.append(np.array(layers[i].dot(self.weights[i])))
                layers = np.array(layers)
                final_res = layers[len(layers) - 1]
                deltas = [(np.array(final_res - exp))]
                # У нас должно в итоге быть 2 дельты. На 0 вес умножать не нужно. Поэтому -1
                for i in range(len(self.weights) - 1):
                    deltas.append(np.array(deltas[i].dot(self.weights[len(self.weights) - 1 - i].T)))
                deltas = np.array(deltas)
                for i in range(len(deltas) // 2):
                    deltas[i], deltas[len(deltas) - 1 - i] = deltas[len(deltas) - 1 - i], deltas[i]
                for i in range(len(self.weights)):
                    self.weights[i] -= alpha * np.matrix(layers[i]).T.dot(np.matrix(deltas[i]))
            print('Итерация номер %s' % something)
            self.write_weights_to_file()
 
    def predict(self, img):
        result = img.dot(self.weights[0])
        for i in range(1, len(self.weights)):
            result = result.dot(self.weights[i])
        m = result[0]
        ind = 0
        for i, res in enumerate(result):
            if res > m:
                m = res
                ind = i
        return ind, m
 
    def predict_by_mnist(self):
        array_imgs = parse_img('t10k-images-idx3-ubyte', 10000)
        expected = parse_labels('t10k-labels-idx1-ubyte')
        error = 0
        for i, img in enumerate(array_imgs):
            ind, m = self.predict(img)
            print('Число на картинке это %s. На самом деле %s' % (ind, expected[i]))
            if ind != expected[i]:
                error += 1
        print('Количество ошибок %s' % error)
        print('Всего чисел было %s' % len(expected))
 
 
# o = Neuro2(['w1.txt', 'w2.txt'], weights_from_file=False, shapes=[(28 * 28, 40), (40, 10)])
o = Neuro2(['w1.txt'], weights_from_file=False, shapes=[(28 * 28, 10)])
o.learn(1)
o.predict_by_mnist()