Все входы дают (более или менее) один и тот же выход для этой необученной нейронной сети со случайно инициализированными весами

Question

Новичок ie для нейронных сетей здесь.

Следующий код - это то, что я сделал до сих пор, я еще не написал функцию обратного распространения. Все, что делает сеть, - это дает выход для ввода со случайно сгенерированными весами в диапазоне [-1 / input_neurons ^ 0.5, 1 / input_neurons ^ 0.5]

Так что это полностью необученная сеть, но результаты я Вижу сейчас не нормально я верю. Независимо от введенного изображения, вывод невероятно похож, поэтому нейронная сеть распознает только определенное число c каждый раз.

Я поиграл с количеством скрытых нейронов и слоев, но увеличение их только делает проблема хуже (вывод не имеет различий).

На входе находится изображение, 28 х 28, каждый пиксель имеет значение в диапазоне от 0 до 255. Первоначально значения, входящие в мою сигмовидную функцию, были слишком большими насыщающими поэтому я делю на 255, чтобы получить входные данные в диапазоне от 0 до 1.

Я читал некоторые подобные вопросы здесь, но ответы не слишком помогли, есть идеи относительно того, почему это происходит?

class Network:
    def __init__(self):
        self.input_neurons = 784
        self.hidden_neurons = 128
        self.hidden_layers = 2
        self.output_neurons = 10
        self.weights = {}
        self.layers = {}
        self.bias = {}

    def generate_weights_and_bias(self):
        self.weights["0"] = np.random.uniform(low=(-1/(self.input_neurons ** 0.5)), high=(1/(self.input_neurons ** 0.5)), size=(self.hidden_neurons, self.input_neurons))

        for weight in range(1, self.hidden_layers):
            self.weights[str(weight)] = np.random.uniform(low=(-1/(self.hidden_neurons ** 0.5)), high=(1/(self.hidden_neurons ** 0.5)), size=(self.hidden_neurons, self.hidden_neurons))

        self.weights[str(self.hidden_layers)] = np.random.uniform(low=(-1/(self.output_neurons ** 0.5)), high=(1/(self.output_neurons ** 0.5)), size=(self.output_neurons, self.hidden_neurons))

        for hidden_layer in range(self.hidden_layers):
            self.bias[str(hidden_layer)] = np.zeros((self.hidden_neurons, 1))

        self.bias[str(self.hidden_layers)] = np.zeros((self.output_neurons, 1))

    def feed_forward(self):
        self.layers["hidden0"] = sigmoid((self.weights.get("0") @ self.layers.get("input")) + self.bias.get("0"))

        for layer in range(1, self.hidden_layers):
            self.layers["hidden" + str(layer)] =  sigmoid((self.weights.get(str(layer)) @ self.layers.get("hidden" + str(layer - 1))) + self.bias.get(str(layer)))

        self.layers["output"] =  sigmoid((self.weights.get(str(self.hidden_layers)) @ self.layers.get("hidden" + str(self.hidden_layers - 1))) + self.bias.get(str(self.hidden_layers)))

    def test(self):
        images = IMAGES # list of bytearrays which contain 784 bytes each in the range 0 to 255
        labels = LABELS # list of digits 0 to 9

        total_images = len(images)
        successfully_recognised = 0

        for image in enumerate(images):
            self.layers["input"] = np.array(image[1]).reshape(self.input_neurons, 1) / 255
            self.feed_forward()

            print(labels[image[0]], self.layers.get("output"))
            if labels[image[0]] == self.layers.get("output").argmax():
                print(f"{labels[image[0]]} was recognised successfully")
                successfully_recognised += 1

        print(f"Accuracy is {(successfully_recognised / total_images * 100)}%")
        print(f"{successfully_recognised} images successfully recognised of {total_images}")


def sigmoid(x):
        return 1 / (1 + np.exp(-x))

if __name__ == "__main__":
    network = Network()
    network.generate_weights_and_bias()
    network.test()