Почему весовая матрица 3 x 3 в этом коде, когда это нейронная сеть с 2 входными узлами и 3 скрытыми узлами?

Question

Я пытаюсь понять некоторые коды из книги здесь, однако я не могу понять, почему в этом коде использовалась весовая матрица 3x3.

import numpy as np

class NeuralNetwork:
    def __init__(self,layers,alpha=0.1):
        self.W = []
        self.layers = layers
        self.alpha = alpha
        for i in np.arange(0,len(layers) - 2):
        #similar to range but arange returns an array
            w = np.random.randn(layers[i]+1,layers[i+1]+1)
            self.W.append(w/np.sqrt(layers[i]))
            w = np.random.randn(layers[-2]+1,layers[-1])
            self.W.append(w/np.sqrt(layers[-2]))


    def __repr__(self):
        return "NeuralNetwork: {}".format("-".join(str(l) for l in self.layers))


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

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

    def fit(self,X,y,epochs=1000,displayUpdate=100):
        X=np.c_[X, np.ones((X.shape[0]))]
        for epoch in np.arange(0,epochs):    
            for (x,target) in zip(X,y):
                self.fit_partial(x,target)
            if epoch == 0 or (epoch+1) % displayUpdate == 0:
                loss = self.calculate_loss(X,y)
                print("[INFO] epoch = {}, loss={:.7f}".format(epoch+1,loss))

    def fit_partial(self,x,y):
        A = [np.atleast_2d(x)]
        #len(self.w) = 2
        for layer in np.arange(0, len(self.W)):
            print(self.W)
            #np.arange(0,2) = [0 1]
            #feedforward portion
            net = A[layer].dot(self.W[layer])
            out = self.sigmoid(net)
            print(A)
            #adds output to A
            A.append(out)
            print(A)
            #calculate error term
            error = A[-1] - y
            #backpropagation portion
            D = [error * self.sigmoid_deriv(A[-1])]
            for layer in np.arange(len(A)-2,0,-1):
                #arange(start,end,step)
                print(len(A))
                print(layer)
                delta = D[-1].dot(self.W[layer].T)
                delta = delta * self.sigmoid_deriv(A[layer])
                D.append(delta)
                D = D[::-1]
                for layer in np.arange(0,len(self.W)):
                    self.W[layer] += -self.alpha * A[layer].T.dot(D[layer])

    def predict(self,X,addBias=True):
        p = np.atleast_2d(X)
        if addBias:
            p = np.c_[p,np.ones((p.shape[0]))]
        for layer in np.arange(0, len(self.W)):
            p = self.sigmoid(np.dot(p,self.W[layer]))
        return p

    def calculate_loss(self,X,targets):
        targets = np.atleast_2d(targets)
        predictions = self.predict(X, addBias = False)
        loss = 0.5*np.sum((predictions - targets)**2)
        return loss

Это код, используемый для вызова функций:

import neuralnetwork
import numpy as np

X = np.array([[0,0],[0,1],[1,0],[1,1]])
y = np.array([[0],[1],[1],[0]])

nn = NeuralNetwork([2,2,1],alpha=0.5)
nn.fit(X,y,epochs=1)

for (x,target) in zip(X,y):
    pred = nn.predict(x)[0][0]
    if pred> 0.5:
        step = 1
    else:
        step = 0
    print("[INFO] data={}, ground-truth ={}, pred={:.4f}, step={}".format(x,target[0],pred,step))

Мой вопрос: нейронная сеть имеет структуру 2-2-1. С учетом предвзятости, почему в коде используется весовая матрица 3x3 вместо 3x2 для первого уровня и еще 3x2 для 2-го уровня?

Спасибо, что прочитали это.