Проблемы нейронной сети в блэкджеке

Question

Я делаю нейронную сеть для блэкджека. На этом текущем этапе он должен взять карту дилера и общую сумму карты игрока, чтобы иметь возможность получить 1 за удар или 0 за палку. Я получил данные тренировок с карты стратегии для блэкджека. Но независимо от того, что я изменяю, я получаю только 1 ответ. Это мой код:

from numpy import *

# X = (dealer card, player total)
# y = Stick (0) or Hit (1)

X = array(([2, 2], [2, 3], [2, 4], [2, 5], [2, 6], [2, 7], [2, 8], [2, 9], [2, 10], [2, 11], [2, 12], [2, 13], [2, 14], [2, 15], [2, 16], [2, 17], [2, 18], [2, 19], [2, 20], [2, 21],
           [3, 2], [3, 3], [3, 4], [3, 5], [3, 6], [3, 7], [3, 8], [3, 9], [3, 10], [3, 11], [3, 12], [3, 13], [3, 14], [3, 15], [3, 16], [3, 17], [3, 18], [3, 19], [3, 20], [3, 21],
           [4, 2], [4, 3], [4, 4], [4, 5], [4, 6], [4, 7], [4, 8], [4, 9], [4, 10], [4, 11], [4, 12], [4, 13], [4, 14], [4, 15], [4, 16], [4, 17], [4, 18], [4, 19], [4, 20], [4, 21],
           [5, 2], [5, 3], [5, 4], [5, 5], [5, 6], [5, 7], [5, 8], [5, 9], [5, 10], [5, 11], [5, 12], [5, 13], [5, 14], [5, 15], [5, 16], [5, 17], [5, 18], [5, 19], [5, 20], [5, 21],
           [6, 2], [6, 3], [6, 4], [6, 5], [6, 6], [6, 7], [6, 8], [6, 9], [6, 10], [6, 11], [6, 12], [6, 13], [6, 14], [6, 15], [6, 16], [6, 17], [6, 18], [6, 19], [6, 20], [6, 21],
           [7, 2], [7, 3], [7, 4], [7, 5], [7, 6], [7, 7], [7, 8], [7, 9], [7, 10], [7, 11], [7, 12], [7, 13], [7, 14], [7, 15], [7, 16], [7, 17], [7, 18], [7, 19], [7, 20], [7, 21],
           [8, 2], [8, 3], [8, 4], [8, 5], [8, 6], [8, 7], [8, 8], [8, 9], [8, 10], [8, 11], [8, 12], [8, 13], [8, 14], [8, 15], [8, 16], [8, 17], [8, 18], [8, 19], [8, 20], [8, 21],
           [9, 2], [9, 3], [9, 4], [9, 5], [9, 6], [9, 7], [9, 8], [9, 9], [9, 10], [9, 11], [9, 12], [9, 13], [9, 14], [9, 15], [9, 16], [9, 17], [9, 18], [9, 19], [9, 20], [9, 21],
           [10, 2], [10, 3], [10, 4], [10, 5], [10, 6], [10, 7], [10, 8], [10, 9], [10, 10], [10, 11], [10, 12], [10, 13], [10, 14], [10, 15], [10, 16], [10, 17], [10, 18], [10, 19], [10, 20], [10, 21],
           [11, 2], [11, 3], [11, 4], [11, 5], [11, 6], [11, 7], [11, 8], [11, 9], [11, 10], [11, 11], [11, 12], [11, 13], [11, 14], [11, 15], [11, 16], [11, 17], [11, 18], [11, 19], [11, 20], [11, 21]), dtype=float)
y = array(([1], [1], [1], [1], [1], [1], [1], [1], [1], [1], [1], [0], [0], [0], [0], [0], [0], [0], [0], [0],
           [1], [1], [1], [1], [1], [1], [1], [1], [1], [1], [1], [0], [0], [0], [0], [0], [0], [0], [0], [0],
           [1], [1], [1], [1], [1], [1], [1], [1], [1], [1], [0], [0], [0], [0], [0], [0], [0], [0], [0], [0],
           [1], [1], [1], [1], [1], [1], [1], [1], [1], [1], [0], [0], [0], [0], [0], [0], [0], [0], [0], [0],
           [1], [1], [1], [1], [1], [1], [1], [1], [1], [1], [0], [0], [0], [0], [0], [0], [0], [0], [0], [0],
           [1], [1], [1], [1], [1], [1], [1], [1], [1], [1], [1], [1], [1], [1], [1], [0], [0], [0], [0], [0],
           [1], [1], [1], [1], [1], [1], [1], [1], [1], [1], [1], [1], [1], [1], [1], [0], [0], [0], [0], [0],
           [1], [1], [1], [1], [1], [1], [1], [1], [1], [1], [1], [1], [1], [1], [1], [0], [0], [0], [0], [0],
           [1], [1], [1], [1], [1], [1], [1], [1], [1], [1], [1], [1], [1], [1], [1], [0], [0], [0], [0], [0],
           [1], [1], [1], [1], [1], [1], [1], [1], [1], [1], [1], [1], [1], [1], [1], [0], [0], [0], [0], [0]), dtype=float)


xPredicted = array([7, 18], dtype=float)

X = X/amax(X, axis=0)
y = y/100
xPredicted = xPredicted/amax(xPredicted, axis=0)


class Neural_Network():
    def __init__(self):
        self.inputSize = 2
        self.outputSize = 1
        self.hiddenSize1 = 25
        self.hiddenSize2 = 10

        self.W1 = random.randn(self.inputSize, self.hiddenSize1)
        self.W2 = random.randn(self.hiddenSize1, self.hiddenSize2)
        self.W3 = random.randn(self.hiddenSize2, self.outputSize)

    def sigmoid(self, x):
        return 1 / (1 + exp(-x))

    def deriv_sigmoid(self, x):
        return x * (1 - x)

    def feed_forward(self, X):
        self.layer1 = self.sigmoid(dot(X, self.W1))
        self.layer2 = self.sigmoid(dot(self.layer1, self.W2))
        self.output = self.sigmoid(dot(self.layer2, self.W3))
        return self.output

    def backpropagation(self, X, y, output):
        self.output_error = (y - output) ** 2
        self.output_delta = self.output_error * self.deriv_sigmoid(output)

        self.layer2_error = self.output_delta.dot(self.W3.T)
        self.layer2_delta = self.layer2_error * self.deriv_sigmoid(self.layer2_error)

        self.layer1_error = self.layer2_delta.dot(self.W2.T)
        self.layer1_delta = self.layer1_error * self.deriv_sigmoid(self.layer1_error)

        self.W1 += X.T.dot(self.layer1_delta)
        self.W2 += self.layer1.T.dot(self.layer2_delta)
        self.W3 += self.layer2.T.dot(self.output_delta)

    def train(self, X, y):
        output = self.feed_forward(X)
        self.backpropagation(X, y, output)

    def predict(self):
        print("Predicted Input: " + str(xPredicted))
        print("Predicted Output:" + str(self.feed_forward(xPredicted)))
        print(self.W1)
        print(self.W2)
        print(self.W3)

NN = Neural_Network()
for i in range(5000):
    print('Input:\n' + str(X))
    print('Predicted Output:\n' + str(NN.feed_forward(X)))
    print('Loss:\n' + str(mean(square(y - NN.feed_forward(X)))))

    NN.train(X, y)

NN.predict()

Любая помощь будет отличной. Я построил каркас этой нейронной сети из нескольких учебных пособий, описывающих нейронную сеть XOR gate.