np_simple监督学习模块，神经网络学习模块

zxbin1

和豆包一起熬了三个大存档，才写出来的
但是确实了解到了很多知识了

这里吧代码分享出来
和神经网络有关数学知识
太多了
这里我简单提一下
是高中会学的矩阵变换
in_向量*[w1]+b1=hidden_向量
hidden_向量（激活）*[w2]+b2=out_向量
w1,w2,b1,b2是网络矩阵，通过学习调整这些参数
in_向量是你的问题，out_向量是他的结果
刚才说到的激活是指
将hidden中每一项的分量如果<0,输出0，否则输出自己本身
使自己具有非线性能力（对于不同需要跳变的问题有不同计算方式）

那么为什么几乎所有问题都可以用这种方式解决呢？
那也不是，只是大部分问题了

因为神经网络它会自己去泛化这种问题的解题公式
但是你不知到它的过程
这就是

黑盒

内部数据是很难看懂的

总结到这了
使用文档在代码里

1. 
   
2. import numpy as np
   
3. """
   
4. simple_nn 单隐藏层神经网络模块,仅支持监督训练
   
5. ==============================
   
6. 整体架构：输入层 → 隐藏层(LeakyReLU) → 输出层(线性，无激活)
   
7. 设计思路：
   
8.     神经网络内部计算只负责非线性变换，不强行把输出压缩到0~1。
   
9.     sigmoid 单独作为外部后处理函数，使用者按需调用，用来把原生输出映射至0~1。
   
10.     D1参数：LeakyReLU负数区间斜率，缓解原生ReLU神经元死亡问题。
    
11. 
    
12. 对外可用函数：
    
13.     leaky_relu(x, d1=0.01)
    
14.     leaky_relu_deriv(x, d1=0.01)
    
15.     sigmoid(x)  # 独立后处理函数，映射实数到0~1
    
16. 
    
17. NeuralNet 类方法列表：
    
18.     forward(x)：正向传播，返回前向快照对象ForwardResult
    
19.     fit(x, y_true)：监督训练，输入+标准答案，自动反向传播更新权重
    
20.     custom_learn(x, score_func)：自定义外部打分函数训练，不需要标准答案
    
21.     set_weights_manual(w1_list,b1_list,w2_list,b2_list)：
    
22.         用原生Python嵌套列表手动设置权重偏置，不经过训练
    
23. 
    
24. ForwardResult 快照对象属性：
    
25.     x: 输入数据
    
26.     z1: 隐藏层激活前的值
    
27.     a1: 隐藏层LeakyReLU激活后的值
    
28.     z2: 输出层激活前的值
    
29.     a2: 网络原生输出（线性，无值域压缩，可正可负）
    
30.     calc_loss(y_true): 计算均方误差损失
    
31. #-----------------------------#
    
32. 参数：
    
33. T=4.0、F=-4.0、mid=0.0 为 logit 域目标；
    
34. 经过 sigmoid 压缩后对应概率约 0.98、0.02、0.5。
    
35. T、F 是偏向两端的目标，mid 是中间不确定目标。
    
36. 用于快捷匹配。
    
37. bound_dict是默认事件字典序
    
38. 事件字典序
    
39. 用途：接收0~1的概率值，按预设的区间规则解释成value
    
40. 约定：字典key是区间起点（闭区间），value是对应标签；书写顺序无关，查询时自动排序
    
41. 注意：仅用于推理阶段解释概率，训练目标是logit的 T、F、mid
    
42. 
    
43. """
    
44. 
    
45. # ===== 激活函数（模块内可用，sigmoid单独独立出来，用户按需调用） =====
    
46. def leaky_relu(x, d1=0.01):
    
47.     return np.where(x > 0, x, d1 * x)
    
48. 
    
49. def leaky_relu_deriv(x, d1=0.01):
    
50.     return np.where(x > 0, 1.0, d1)
    
51. 
    
52. # Sigmoid单独独立！网络内部forward不再自动调用它
    
53. def sigmoid(x):
    
54.     return 1.0 / (1.0 + np.exp(-x))
    
55. 
    
56. def logit(p):
    
57.     """
    
58.     逆Sigmoid函数：0~1概率转回对应的logit值
    
59.     :param p: 概率，范围0~1
    
60.     :return: logit实数
    
61.     """
    
62.     q = np.clip(p, 1e-6, 1 - 1e-6)
    
63.     return np.log(q / (1 - q))
    
64. #比对函数（事件字典序查找）
    
65. def lookup_tag(p, bound_dict):
    
66.     "对事件字典序进行查找"
    
67.     if p < 0.0 or p > 1.0:
    
68.         raise ValueError("概率数值必须在 0.0 ~ 1.0 之间")
    
69.     start_points = sorted(bound_dict.keys())
    
70.     selected = start_points[0]
    
71.     for s in start_points:
    
72.         if s <= p:
    
73.             selected = s
    
74.         else:
    
75.             break
    
76.     return bound_dict[selected]
    
77. 
    
78. #工具包
    
79. def find_max_index(lst):
    
80.     """寻找最大值下标"""
    
81.     idx = lst.index(max(lst))
    
82.     return idx
    
83.    
    
84. def find_max_key(d):
    
85.     """寻找最大值的键,d.type为dict"""
    
86.     best_key = max(d, key=d.get)
    
87.     return best_key
    
88. 
    
89. 
    
90. # ===== 前向结果快照类 =====
    
91. class ForwardResult:
    
92.     def __init__(self, x, z1, a1, z2, a2):
    
93.         self.x = x
    
94.         self.z1 = z1
    
95.         self.a1 = a1
    
96.         self.z2 = z2
    
97.         self.a2 = a2  # a2现在是【原生线性输出】，没有经过sigmoid，可以是任意实数
    
98.         self.out = a2.flatten().tolist()
    
99.         """out才是结果向量"""
    
100. 
     
101.     def calc_loss(self, y_true):
     
102.         """内置损失：均方误差，fit方法使用"""
     
103.         return np.mean((self.a2 - y_true) ** 2)
     
104. 
     
105. # ===== 神经网络主类 =====
     
106. class NeuralNet:
     
107.     def __init__(self,input_size,hidden_size,output_size,init=True, d1=0.01):
     
108.         self.in_size = input_size
     
109.         self.hidden_size = hidden_size
     
110.         self.out_size = output_size
     
111.         self.d1 = d1 # LeakyReLU的负区间斜率D1，用来防止神经元死亡
     
112.         
     
113.         if init:
     
114.             self.w1 = np.random.randn(input_size, hidden_size) * 0.1
     
115.         else:
     
116.             self.w1 = np.zeros((input_size, hidden_size))
     
117.         self.b1 = np.zeros((1, hidden_size))
     
118.         
     
119.         if init:
     
120.             self.w2 = np.random.randn(hidden_size, output_size) * 0.1
     
121.         else:
     
122.             self.w2 = np.zeros((hidden_size, output_size))
     
123.         self.b2 = np.zeros((1, output_size))
     
124.         self.learn_rate = 0.1#学习率
     
125. 
     
126.     # 方法1：正向传播
     
127.     def forward(self, x):
     
128.         x=np.array([x])
     
129.         z1 = np.dot(x, self.w1) + self.b1
     
130.         a1 = leaky_relu(z1, self.d1)
     
131.         z2 = np.dot(a1, self.w2) + self.b2
     
132.         a2 = z2   # 输出层：线性，**不套sigmoid**，原生输出
     
133.         return ForwardResult(x, z1, a1, z2, a2)
     
134. 
     
135.     # 方法2：传统训练：输入+真实标签，自动一步训练（前向+反向更新）
     
136.     def fit(self, x, y_true):
     
137.         y_true = np.array([y_true])
     
138.         res = self.forward(x)
     
139.         loss = res.calc_loss(y_true)
     
140.         # ===== 输出层现在是线性激活，导数=1！=====
     
141.         dZ2 = (res.a2 - y_true) * 1.0
     
142.         dW2 = np.dot(res.a1.T, dZ2)
     
143.         db2 = np.sum(dZ2, axis=0, keepdims=True)
     
144. 
     
145.         # 隐藏层梯度：LeakyReLU导数，使用z1
     
146.         dZ1 = np.dot(dZ2, self.w2.T) * leaky_relu_deriv(res.z1, self.d1)
     
147.         dW1 = np.dot(res.x.T, dZ1)
     
148.         db1 = np.sum(dZ1, axis=0, keepdims=True)
     
149.         self.w2 -= self.learn_rate * dW2
     
150.         self.b2 -= self.learn_rate * db2
     
151.         self.w1 -= self.learn_rate * dW1
     
152.         self.b1 -= self.learn_rate * db1
     
153.         return loss
     
154. 
     
155.         # 5.链式反向传播，计算各参数梯度
     
156.         dW2 = np.dot(res.a1.T, dZ2)
     
157.         db2 = np.sum(dZ2, axis=0, keepdims=True)
     
158. 
     
159.         dZ1 = np.dot(dZ2, self.w2.T) * leaky_relu_deriv(res.z1, self.d1)
     
160.         dW1 = np.dot(x.T, dZ1)
     
161.         db1 = np.sum(dZ1, axis=0, keepdims=True)
     
162. 
     
163.         # 6.更新权重
     
164.         self.w2 -= self.learn_rate * dW2
     
165.         self.b2 -= self.learn_rate * db2
     
166.         self.w1 -= self.learn_rate * dW1
     
167.         self.b1 -= self.learn_rate * db1
     
168. 
     
169.         return loss
     
170.    
     
171.     # 方法4：手动设置权重，输入为原生嵌套列表
     
172.     def set_weights_manual(self, w1_list, b1_list, w2_list, b2_list):
     
173.         """
     
174.         手动填入权重、偏置，使用Python嵌套list，不是numpy数组
     
175.         w1_list: 嵌套列表，shape [input_size, hidden_size]
     
176.         b1_list: 嵌套列表，shape [1, hidden_size]
     
177.         w2_list: 嵌套列表，shape [hidden_size, output_size]
     
178.         b2_list: 嵌套列表，shape [1, output_size]
     
179.         """
     
180.         new_w1 = np.array(w1_list, dtype=np.float64)
     
181.         new_b1 = np.array(b1_list, dtype=np.float64)
     
182.         new_w2 = np.array(w2_list, dtype=np.float64)
     
183.         new_b2 = np.array(b2_list, dtype=np.float64)
     
184. 
     
185.         if new_w1.shape != (self.in_size, self.hidden_size):
     
186.             raise ValueError(f"w1_list 维度错误！需要 ({self.in_size},{self.hidden_size})")
     
187.         if new_b1.shape != (1, self.hidden_size):
     
188.             raise ValueError(f"b1_list 维度错误！需要 (1,{self.hidden_size})")
     
189.         if new_w2.shape != (self.hidden_size, self.out_size):
     
190.             raise ValueError(f"w2_list 维度错误！需要 ({self.hidden_size},{self.out_size})")
     
191.         if new_b2.shape != (1, self.out_size):
     
192.             raise ValueError(f"b2_list 维度错误！需要 (1,{self.out_size})")
     
193.         
     
194.         self.w1 = new_w1
     
195.         self.b1 = new_b1
     
196.         self.w2 = new_w2
     
197.         self.b2 = new_b2
     
198. 
     
199.     def train(self,callback,epoch=10):#批训练 epoch：次数
     
200.         """
     
201.         函数callback无输入，输出两个列表in和out 自动生成训练数据
     
202.         last输出最后一次损失
     
203.         """
     
204.         for i in range(epoch):
     
205.             in_,out_=callback()
     
206.             last = self.fit(in_,out_)
     
207.         return last
     
208.    
     
209.     def explore(self,temp):
     
210.         """给自己产生神经扰动并附加于自身"""
     
211.         noise_w1 = np.random.normal(-temp,temp,size=self.w1.shape)
     
212.         self.w1 += noise_w1
     
213. 
     
214.         noise_w2 = np.random.normal(-temp,temp,size=self.w2.shape)
     
215.         self.w2 += noise_w2
     
216.         
     
217.     def copy(self):
     
218.         """返回自身数据到新的NeuralNet对象"""
     
219.         co = NeuralNet(self.input_size,self.hidden_size,self.output_size,dl = self.dl)
     
220.         co.learn_rate = self.learn_rate
     
221.         co.w1 = self.w1.copy()
     
222.         co.b1 = self.b1.copy()
     
223.         co.w2 = self.w2.copy()
     
224.         co.b2 = self.b2.copy()
     
225.         return co
     
226. 
     
227. #默认参数
     
228. T=sigmoid(4.0)#在神经训练中大约为sigmoid(0.98)近似表示是
     
229. F=sigmoid(-4.0)#在神经训练中大约为sigmoid(0.02)近似表示否
     
230. mid=sigmoid(0)#中间
     
231. 
     
232. 
     
233. bound_dict = {
     
234.     0.0: "NO",
     
235.     0.1: "UNCERTAIN",
     
236.     0.9: "YES"
     
237. }
     

复制代码

还有测试程序

1. 
   
2. import simple_nn
   
3. 
   
4. ne = simple_nn.NeuralNet(2,10,1)
   
5. ne.learn_rate = 0.02
   
6. 
   
7. in_ = ([0,0],[0,1],[1,0],[1,1])
   
8. out_ = (0, 1, 1, 0) # 与门
   
9. 
   
10. for i in range(0,19999):
    
11.     if i % 1000== 0:
    
12.         print(f"训练了{i}次")
    
13.     for x_list, target in zip(in_, out_):
    
14.         if target==0:
    
15.             loss = ne.fit(x_list,[simple_nn.logit(0.05)])
    
16.         else:
    
17.             loss = ne.fit(x_list,[simple_nn.logit(0.95)])
    
18.     if i % 1000 == 0:
    
19.         print(f"轮{i}, loss={loss:.4f}")
    
20. 
    
21. print("\n=====预测，输入两个0/1=====")
    
22. v1 = float(input("输入第一个值："))
    
23. v2 = float(input("输入第二个值："))
    
24. res = ne.forward([v1,v2])
    
25. print("神经网络输出out：", res.a2[0][0])
    
26. p = simple_nn.sigmoid(res.out[0])
    
27. print("映射概率sigmoid0~1:", p)
    
28. if p>=0.9:
    
29.     print("答案是1吗?")
    
30. if p<=0.1:
    
31.     print("答案是0吗?")
    
32. 
    

复制代码

大致功能，给它一大堆或门的真值表
最后看它记不记得住

可以把v1,v2换成浮点值发现它可以得出答案
说明程序成功运行
记得在pip下载numpy