Python+Numpy, Нейронная сеть обучается но ответ не верный

import numpy as np
 
# X = (hours sleeping, hours studying), y = score on test
X = np.array((
 [2.1,1.82,1.82,3.01,8.15,120,160,120,110,70,1.9,10.5,40,33.3],
[2.2,1.82,1.83,3.01,8.15,120,170,110,110,90,1.9,10.5,39,33.4],
[2.1,1.82,1.82,3.01,8.15,120,160,110,110,90,1.9,10.5,40,33.2],
[2.1,2.05,1.85,2.9,8,125,165,120,130,105,2,10.8,39,33.3],
[2.1,1.82,1.82,3.01,8.25,130,160,110,110,95,1.9,10.5,40,33.3],
[2.2,1.82,1.83,3.2,8.15,145,170,110,100,90,1,10.5,39,33.4],
[2.1,1.82,1.82,3.01,9.15,150,160,100,110,90,1.9,11.5,36,30.2],
[2.2,2.05,1.75,2.9,8,145,165,120,130,85,2,11.8,39,33.3],
[2.1,1.82,1.82,3.01,8.15,120,160,110,140,120,1.9,10.5,32,27.3],
[2.2,2.1,1.83,3.01,8.15,120,180,112,110,90,1.9,10.5,39,33.4],
[2.3,1.82,1.82,3.4,8.15,120,200,110,110,90,1.9,10.5,40,33.2],
[2.1,2.05,1.85,2.9,8,125,165,120,130,75,2,10.8,39,39.3],
[2.2,2.05,1.75,2.9,8,145,165,120,130,85,2,11.8,39,33.3],
[2.2,1.9,1.6,3.2,9.15,150,170,130,160,100,2.5,12.5,32,27.3],
[2.2,2.1,1.83,3.01,8.15,120,180,112,110,90,1.9,10.5,25,26],
[2.3,1.82,1.82,3.4,8.15,120,200,110,110,90,1,6,40,33.2],
[2.1,2.05,1.85,2.9,8,125,165,120,130,75,2,10.8,39,39.3]), dtype=float)
y = np.array((
 [95],
[90],
[95],
[100],
[95],
[90],
[80],
[100],
[70],
[50],
[60],
[100],
[100],
[95],
[50],
[60],
[100]), dtype=float)
 
# scale units
X = X/np.amax(X, axis=0) # maximum of X array
x2=np.array((
 [2.1,1.82,1.82,3.01,8.25,130,160,110,110,95,1.9,10.5,40,33.3]),dtype=float)
y = y/100 # max test score is 100
 
class Neural_Network(object):
  def __init__(self):
    #parameters
    self.inputSize = 14
    self.outputSize = 1
    self.hiddenSize = 3
 
    #weights
    self.W1 = np.random.randn(self.inputSize, self.hiddenSize) # (3x2) weight matrix from input to hidden layer
    self.W2 = np.random.randn(self.hiddenSize, self.outputSize) # (3x1) weight matrix from hidden to output layer
 
  def forward(self, X):
    #forward propagation through our network
    self.z = np.dot(X, self.W1) # dot product of X (input) and first set of 3x2 weights
    self.z2 = self.sigmoid(self.z) # activation function
    self.z3 = np.dot(self.z2, self.W2) # dot product of hidden layer (z2) and second set of 3x1 weights
    o = self.sigmoid(self.z3) # final activation function
    return o 
 
  def sigmoid(self, s):
    # activation function 
    return 1/(1+np.exp(-s))
 
  def sigmoidPrime(self, s):
    #derivative of sigmoid
    return s * (1 - s)
 
  def backward(self, X, y, o):
    # backward propgate through the network
    self.o_error = y - o # error in output
    self.o_delta = self.o_error*self.sigmoidPrime(o) # applying derivative of sigmoid to error
 
    self.z2_error = self.o_delta.dot(self.W2.T) # z2 error: how much our hidden layer weights contributed to output error
    self.z2_delta = self.z2_error*self.sigmoidPrime(self.z2) # applying derivative of sigmoid to z2 error
 
    self.W1 += X.T.dot(self.z2_delta) # adjusting first set (input --> hidden) weights
    self.W2 += self.z2.T.dot(self.o_delta) # adjusting second set (hidden --> output) weights
 
  def train (self, X, y):
    o = self.forward(X)
    self.backward(X, y, o)
 
NN = Neural_Network()
for i in range(2000): # trains the NN 1,000 times
  print ("Input: \n" + str(X) )
  print ("Actual Output: \n" + str(y) )
  print ("Predicted Output: \n" + str(NN.forward(X)) )
  print ("Loss: \n" + str(np.mean(np.square(y - NN.forward(X))))) # mean sum squared loss
  print ("\n")
  NN.train(X, y)
print ("Kor: \n" + str(NN.forward(x2)) )