# 全局变量定义
输出层 = 2
输入层 = 3
样本数 = 6


中间层 = 0
中间层权矩阵 = 新建数组（输入层，50）
输出层权矩阵 = 新建数组（50，输出层）
学习率 = 0.0
控制精度 = 0.0
最大循环数 = 1

函数：BP初始化（）
{
	全局：中间层，学习率，控制精度，最大循环数
	全局：中间层权矩阵，输出层权矩阵
	全局：输入层，输出层，样本数

	中间层 = 50
	学习率 = 0.5
	控制精度 = 0.005
	最大循环数 = 50

	循环：行 = 0，行 < 输入层，行++ {
		循环：列 = 0，列 < 中间层，列++ {
			中间层权矩阵【行】【列】 = 随机数（10）
		}
	}

	循环：行 = 0，行 < 中间层，行++ {
		循环：列 = 0，列 < 输出层，列++ {
			输出层权矩阵【行】【列】 = 随机数（10）
		}
	}
#	打印（中间层权矩阵）
# 	打印（输出层权矩阵）	
}

函数：BP训练（样本，理想输出）
{
	全局：中间层，学习率，控制精度，最大循环数
	全局：中间层权矩阵，输出层权矩阵
	全局：输入层，输出层，样本数

	中间权修改 = 新建数组（50）
	输出权修改 = 新建数组（输出层）

	中间层输出量 = 新建数组（50）
	输出层输出量 = 新建数组（输出层）
	误差 = 控制精度 + 1
	# 初始化
	循环：位 = 0，位 < 50，位++ {
		中间权修改【位】 = 随机数（10）
		中间层输出量【位】 = 随机数（10）	
	}
	循环：位 = 0， 位 < 输出层，位++ {
		输出权修改【位】 = 随机数（10）
		输出层输出量【位】 = 随机数（10）	
	}

	# 对每个样本训练网络
	循环：次数 = 0，误差 > 控制精度 && 次数 < 最大循环数，次数++ {
		误差 = 0
		循环：行 = 0，行 < 样本数，行++ {
			# 计算中间层输出
			循环：列 = 0，列 < 中间层，列++ {
				暂存 = 0
				循环：标志 = 0，标志 < 输入层，标志++ {
					暂存 = 暂存 + 样本【行】【标志】 * 中间层权矩阵【标志】【列】
				}	
				中间层输出量【列】 = sigmoid函数（暂存）
			}
			# 计算输出层输出
			循环：列 = 0，列 < 输出层，列++ {
				暂存 = 0
				循环：标志 = 0，标志 < 中间层，标志++ {
					暂存 = 暂存 + 中间层输出量【标志】 + 输出层权矩阵【标志】【列】
				}	
				输出层输出量【列】 = sigmoid函数（暂存）
			}
			# 计算输出层的权修改量
			循环：标志 = 0，标志 < 输出层，标志++ {
				输出权修改【标志】 = 输出层输出量【标志】*（1 - 输出层输出量【标志】）*（理想输出【行】【标志】 - 输出层输出量【标志】）
			}
			# 计算输出误差
			循环：标志 = 0， 标志 < 输出层，标志++ {
				误差 = 误差 + （理想输出【行】【标志】 - 输出层输出量【标志】）*（理想输出【行】【标志】 - 输出层输出量【标志】）
			}
			# 计算中间层权修改量
			循环：标志 = 0，标志 < 中间层，标志++ {
				暂存 = 0
				循环：列 = 0，列 < 输出层，列++ {
					暂存 = 暂存 + 输出层权矩阵【标志】【列】 *  输出权修改【列】
				}
				中间权修改【标志】 = 暂存 * 中间层输出量【标志】*（1 - 中间层输出量【标志】）
			}
			# 修改输出层权矩阵
			循环：标 = 0，标 < 中间层，标++ {
				循环：列 = 0，列 < 输出层，列++ {
					输出层权矩阵【标】【列】 = 输出层权矩阵【标】【列】 + 学习率 *中间层输出量【标】*输出权修改【列】
				}
			}
			循环：标 = 0，标 < 输入层，标++ {
				循环：列 = 0，列 < 中间层，列++{
					中间层权矩阵【标】【列】 = 中间层权矩阵【标】【列】 + 学习率 * 样本【行】【标】*中间权修改【列】
				}
			}
		}
		如果：次数 % 10 == 0 {
			调试（“误差：”）
			打印（误差）	
		}
	}
	调试（“循环次数：”）
	打印（次数）	
#	打印（中间层权矩阵）
#	打印（输出层权矩阵）
	打印（“训练结束！”）
}

函数：BP执行（）
{
	全局：输入层，输出层
	全局：中间层
	全局：中间层权矩阵，输出层权矩阵

	输入 = {0.2，0.7，0.3}
	中间层输出 = 新建数组（50）
	输出层输出 = 新建数组（输出层）	

	循环：标 = 0，标 < 50，标++ {
		中间层输出【标】 = 随机数（10）
	}
	循环：标 = 0，标 < 输出层，标++ {
		输出层输出【标】 = 随机数（10）
	}

	缓存 = 0
	循环：标 = 0，标 < 中间层，标++ {
		循环：位 = 0，位 < 输入层，位++ {
			缓存 += 输入【位】*中间层权矩阵【位】【标】
		}
		中间层输出【标】 = sigmoid函数（缓存）
	}
	缓存 = 0
	循环：标 = 0，标 < 输出层，标++ {
		循环：位 = 0，位 < 中间层，位++ {
			缓存 += 中间层输出【位】 * 输出层权矩阵【位】【标】
		}
		输出层输出【标】 = sigmoid函数（缓存）
	}
	打印（“结果：”）
	调试（“输入：”）
	打印（输入）	
	调试（“输出：”）
	打印（输出层输出）
}




样本 = {{0.8，0.5，0}，{0.9，0.7，0.3}，{1，0.8，0.5}，{0，0.2，0.3}，{0.2，0.1，1.3}，{0.2，0.7，0.8}}
输出 = {{0，1}，{0，1}，{0，1}，{1，1}，{1，0}，{1，0}}
#打印（“训练数据：”）
循环：标 = 0， 标 < 6，标++ {
#	调试（“输入：”）	
#	调试（样本【标】）
#	调试（“\t\t”）	
#	调试（“输出：”）	
#	打印（输出【标】）	
}
调试（“\n”）

#BP初始化（）
#BP训练（样本，输出）
#BP执行（）