在我的python/numpy神经网络中实现偏差节点的最佳方法是什么？

我最初基于在线教程构建了一个仅限numpy的神经网络，并逐渐意识到我应该有某种偏向神经元。然而，我一直在努力弄清楚如何将其实现到我的代码中，非常感谢您的指导

import numpy as np

class NN():   
    def __init__(self, layers, type):
        """
        layers: a list of layers, eg:
              2 input neurons
              1 hidden layer of 3 neurons
              2 output neurons
              will look like [2,3,2]
        type: initialisation type, "random" or "uniform" distribution
        """

        self.p = 0.1

        self.layers = len(layers) - 1

        self.inputSize = layers[0]
        self.outputSize = layers[self.layers]

        self.layerSizes = layers[:-1] #input layer, hiddens, discard output layer

        self.inputs = np.zeros(self.inputSize, dtype=float)
        self.outputs = np.zeros(self.outputSize, dtype=float)

        self.L = {}

        if type == "random":
            for i in range(1,self.layers+1):
                if i < self.layers:
                    self.L[i] = (np.random.ranf(( self.layerSizes[i-1] , self.layerSizes[i] )).astype(np.float) - 0.5) * 2
                else:
                    self.L[i] = (np.random.ranf(( self.layerSizes[i-1] , self.outputSize )).astype(np.float) - 0.5)*2
        elif type == "uniform":            
            for i in range(1,self.layers+1):
                if i < self.layers:
                    self.L[i] = np.random.uniform( -1 , 1 , (self.layerSizes[i-1],self.layerSizes[i]) )
                else:
                    self.L[i] = np.random.uniform( -1 , 1 , (self.layerSizes[i-1],self.outputSize) )

        else:
            print("unknown initialization type")

    def updateS(self): #forward propogation Sigmoid
        for i in range(1,self.layers+1):
            if 1 == self.layers:  #dodgy no hidden layers fix
                self.z = np.dot(self.inputs, self.L[i])
                self.outputs = ( self.sigmoid(self.z) - 0.5)*2           
            elif i == 1:  #input layer
                self.z = np.dot(self.inputs, self.L[i])
                self.temp = self.sigmoid(self.z)
            elif i < self.layers: #hidden layers
                self.z = np.dot(self.temp, self.L[i])
                self.temp = self.sigmoid(self.z)
            else: #output layer
                self.z = np.dot(self.temp, self.L[i])
                self.outputs = ( self.sigmoid(self.z) - 0.5)*2

    def sigmoid(self, s):
        #activation funtion
        return 1/(1+np.exp(-s/self.p))

将numpy导入为np
类NN（）：
定义初始化（自身、层、类型）：
"""
层：层的列表，例如：
2个输入神经元
1个由3个神经元组成的隐藏层
2输出神经元
将看起来像[2,3,2]
类型：初始化类型，“随机”或“均匀”分布
"""
自相关系数p=0.1
self.layers=len（层）-1
self.inputSize=层[0]
self.outputSize=层[self.layers]
self.layerSizes=层[：-1]#输入层，隐藏，放弃输出层
self.inputs=np.zero（self.inputSize，dtype=float）
self.outputs=np.zero（self.outputSize，dtype=float）
self.L={}
如果类型==“随机”：
对于范围内的i（1，self.layers+1）：
如果i

偏差只是在神经网络前馈过程中添加到每个神经元的一个变量。因此，从一个神经元层到下一个神经元层的前馈过程将是所有权重乘以馈入下一个神经元的前一个神经元的总和，然后将该神经元的偏差相加，或者：

输出=总和（权重*输入）+偏差

要将其置于上下文中，请查看下图：

其中：

X1: Input value 1.

X2: Input value 2.

B1n: Layer 1, neuron n bias.

H1: Hidden layer neuron 1.

H2: Hidden layer neuron 2.

a(…): activation function.

B2n: Layer 2, neuron n bias.

Y1: network output neuron 1.

Y2: network output neuron 2.

Y1out: network output 1.

Y2out: network output 2.

T1: Training output 1.

T2: Training output 2.

计算H1时，需要使用以下公式：

H1 = (X1 * W1) + (X2 * W2) + B11    

注意，在通过激活函数完全计算神经元的值之前

因此，我非常确定偏差将输入前馈函数中：

def updateS(self): #forward propogation Sigmoid
        for i in range(1,self.layers+1):
            if 1 == self.layers:  #dodgy no hidden layers fix
                self.z = np.dot(self.inputs, self.L[i])
                self.outputs = ( self.sigmoid(self.z) - 0.5)*2           
            elif i == 1:  #input layer
                self.z = np.dot(self.inputs, self.L[i])
                self.temp = self.sigmoid(self.z)
            elif i < self.layers: #hidden layers
                self.z = np.dot(self.temp, self.L[i])
                self.temp = self.sigmoid(self.z)
            else: #output layer
                self.z = np.dot(self.temp, self.L[i])
                self.outputs = ( self.sigmoid(self.z) - 0.5)*2

def更新（自身）：#向前推进乙状结肠
对于范围内的i（1，self.layers+1）：
如果1==self.layers:#不可靠没有隐藏层修复
self.z=np.dot（self.inputs，self.L[i]）
self.outputs=（self.sigmoid（self.z）-0.5）*2
elif i==1:#输入层
self.z=np.dot（self.inputs，self.L[i]）
self.temp=self.sigmoid（self.z）
elif i

---

通过在self.z值的末尾添加一个值。我认为这些值可以是您想要的任何值，因为偏差只会移动线性方程的截距

，请阅读此处的帮助：stackoverflow.com/help/dont-ask。您没有尝试解释您尝试过的内容，显示输入/输出，解释出了什么地方出了问题，并询问了具体问题，以了解您需要什么帮助。请你用这些信息编辑你的问题，然后人们就能帮助你了。谢谢你的帮助。我为每层制作了一个偏移权重，该权重乘以偏移值。然后，我按照建议将其添加到self.z行的末尾。听起来对吗？你听起来差不多对。我有一个研究神经网络的java小项目，如果您想了解它，它可能会对GitHub有所帮助：