本文以蓝桥杯的Fibonacci数列、大等于n的最小完全平方数为例，用飞桨解决问题。先阐述神经网络原理，从简单神经元到多层网络，再说明其工作机制。接着分别对两道题生成数据、构建模型、优化器和损失函数，经训练和验证，模型能近似拟合结果，展示了用机器学习解决算法题的思路。
☞☞☞AI 智能聊天, 问答助手, AI 智能搜索, 免费无限量使用 DeepSeek R1 模型☜☜☜
假如人工智能也玩起了蓝桥杯算法题... ...
目前，蓝桥杯上几乎所有算法题都是每个输入都有唯一确定的输出，对于一些输入输出是线性关系的题目，利用机器学习可以做一个对应的拟合，从而根据拟合出来的模型得到最终结果。
本文会以蓝桥杯的2道算法题（Fibonacci数列、大等于n的最小完全平方数）为例，尝试使用飞桨解决上面这两道算法题。
虽然都说神经网络是个大黑盒，但是，其实这个黑盒并不是那么黑。
是不是有点像傅里叶级数？（傅里叶发现任何周期函数都可以用正弦函数和余弦函数构成的无穷级数来表示）
在学习机器学习的过程中，大家对神经网络应该都有一个基本概念：神经网络就像一个函数拟合器，它可以拟合任意函数。
举个例子，输入一个数，输出它的相反数，那么这个函数就是正比例函数，且它的比例系数为-1，我们试着构造一个刚刚描述的神经网络：
def NeuralNetwork(inputs, weight): # 定义神经网络
prediction = inputs * weight # 将数据与权重相乘
return prediction
inputs = 2 # 输入数据，可随意更换weight = -1 # 权重pred = NeuralNetwork(inputs, weight) # 前向传播，即获得预测结果print(pred)-2
刚刚我们完成的就是前向传播的过程，也就是一个预测的过程 。
预测其实就是神经网络对输入数据进行“思考”后得到的结果，更复杂的例子有：基于昨天的天气预测今天的天气
上面的那个神经网络将输入乘以权重，将输入数据“缩放”一定的比例。神经网络的交互其实很简单：
目前为止，所有的神经网络都是这样工作的，它使用权重中的知识解释输入数据中的信息。
看到这里，你心中也许会有疑惑，为什么可以把权重当作知识？
另一种理解神经网络权重值的方法，是将权重作为网络的输入和预测之间敏感度的度量：
在实际场景中，如果能给神经网络提供的信息越多，那么神经网络应该能做出更准确的预测。
事实上，一个网络也可以同时接受多个输入数据点。就像下面这个例子：
weights = [0.012, 0.3, 0.25] #温度、湿度、风速的权重inputs = [26, 0.75, 1.2] #温度、湿度、风速数据def PredSum(inputs, weights):
assert(len(inputs) == len(weights))
output = 0
for item in range(len(inputs)):
output += inputs[item] * weights[item] #将输入分别乘以其对应的权重
return outputdef NeuralNetwork(inputs, weights):
pred = PredSum(inputs, weights) return pred
pred = NeuralNetwork(inputs, weights)print(pred) #一段时间后发生某事的概率，如下雨的概率0.837
这种新的神经网络可以同时接受多个输入并作出预测。这使得网络能够结合多种形式的信息，做出更明智的决定。但是它使用权重的基本机制并没有改变。
这里带来的新特性是，因为有多个输入，所以要把他们各自的预测结果合在一起。因此，将每个输入乘以其各自的权重，然后对所有局部预测结果进行求和，这称为输入的加权和。
不过，像上面这样的代码虽然一次就可以处理多个输入，但是还是显得太麻烦了，因此，我们需要用到新工具：Numpy
对于创建向量和执行常见函数（如点积运算）来说，它的代码效率很高，下面是利用Numpy实现相同功能的代码：
import numpy as np
weights = np.array([0.012, 0.3, 0.25])
inputs = np.array([26, 0.75, 1.2])def NeuralNetwork(inputs, weights):
pred = inputs.dot(weights) return pred
pred = NeuralNetwork(inputs, weights)print(pred)0.837
多输出可能是比多输入更简单的拓展。如果是3个输出，则预测过程与三个单一权重的独立神经网络是一样的。需要注意的是，这3个预测结果完全独立。
假设我们在一场球赛上，想通过某个球队的胜负记录预测球员的心情（是高兴还是悲伤）、下一场比赛的结果以及队员的受伤比例，来看看这个例子怎么做：
import numpy as np
weights = np.array([0.3, 0.2, 0.9])
inputs = 0.65def NeuralNetwork(inputs, weights):
pred = inputs * weights return pred
pred = NeuralNetwork(inputs, weights)# print(pred)print("受伤比例预测：{}".format(pred[0]))print("比赛胜负预测：{}".format(pred[1]))print("悲伤程度预测：{}".format(pred[2]))受伤比例预测：0.195 比赛胜负预测：0.13 悲伤程度预测：0.5850000000000001
基于给定的多个输入，神经网络预测得到多个输出。
假设我们在一场球赛上，想通过某个球队的胜负记录、粉丝数和球员数量来预测球员的心情（是高兴还是悲伤）、下一场比赛的结果以及队员的受伤比例，来看看这个例子怎么做：
import numpy as np#从左到右分别是：[是否受伤, 是否胜利, 是否难过]weights = np.array([[0.02, 0.01, 0.05], #胜负记录
[0.001, 0.025, 0.04], #粉丝数量
[0.013, 0.03, 0.001]]) #球员数量inputs = np.array([0.65, 12.0, 8.0]) #分别是该球队的胜负记录、粉丝数量、球员数量def NeuralNetwork(inputs, weights):
pred = inputs.dot(weights) return pred
pred = NeuralNetwork(inputs, weights)# print(pred)print("受伤比例预测：{}".format(pred[0]))print("比赛胜负预测：{}".format(pred[1]))print("悲伤程度预测：{}".format(pred[2]))受伤比例预测：0.129 比赛胜负预测：0.5465 悲伤程度预测：0.5205
分析一下上面这个例子，这个神经网络对输入数据执行了3次独立的加权和操作，产生了3个预测结果。其实就是简单的矩阵运算，横行乘竖列再相加。
神经网络是可以堆叠的！可以将一个网络的输出提供给另一个网路作为输入。这相当于两个连续的向量矩阵乘法。
这样做的原因是：在处理复杂问题时，对于单一权重矩阵来说过于复杂（即参数的数量不够）。
还是上面的例子：在一场球赛上，想通过某个球队的胜负记录、粉丝数和球员数量来预测球员的心情（是高兴还是悲伤）、下一场比赛的结果以及队员的受伤比例：
import numpy as np#从左到右分别是：[是否受伤, 是否胜利, 是否难过]InputHiddent = np.array([[0.2, 0.01, 0.05], #隐藏层第一个单元
[0.01, 0.025, 0.04], #隐藏层第二个单元
[0.13, 0.03, 0.001]]) #隐藏层第三个单元#从左到右分别是：隐藏层第一个单元到第三个单元的权重HiddentPrediction = np.array([[0.02, 0.1, 0.5], #胜负记录
[0.01, 0.25, 0.04], #粉丝数量
[0.013, 0.3, 0.01]]) #球员数量weights = [InputHiddent, HiddentPrediction] #存放权重值，[输入到隐藏层的权重， 隐藏层到输出的权重]inputs = np.array([0.65, 12.0, 8.0]) #分别是该球队的胜负记录、粉丝数量、球员数量def NeuralNetwork(inputs, weights):
hid = inputs.dot(weights[0]) #计算隐藏层的输出
pred = hid.dot(weights[1]) #将上一层（隐藏层）的输出带入下一层的输入
return pred
pred = NeuralNetwork(inputs, weights)# print(pred)print("受伤比例预测：{}".format(pred[0]))print("比赛胜负预测：{}".format(pred[1]))print("悲伤程度预测：{}".format(pred[2]))受伤比例预测：0.0380315 比赛胜负预测：0.421775 悲伤程度预测：0.672065
Fibonacci数列是蓝桥杯试题入门训练的题目，算是一道入门的题目，我们尝试让神经网络试试看，看看能不能解决这道题
斐波那契数列的递推公式为：Fn=Fn−1+Fn−2，其中F1=F2=1。
当n比较大时，Fn也非常大，现在我们想知道，Fn除以10007的余数是多少。
输入包含一个整数n。
输出一行，包含一个整数，表示Fn除以10007的余数。
数据几乎是所有模型的关键，它决定着模型的天花板。
这里我们用到的是numpy里生成随机数的函数：
numpy.random.randint(low, high=None, size=None, dtype='l')
函数的作用是，返回一个随机整型数，范围从低（包括）到高（不包括），即[low,high)。如果没有写参数high的值，则返回[0,low)的值。
参数如下：
low: int
生成的数值最低要大于等于low。 （hign = None时，生成的数值要在[0,low)区间内）
high: int (可选)
如果使用这个值，则生成的数值在[low, high)区间。
size: int or tuple of ints(可选)
输出随机数的尺寸，比如size = (m * n* k)则输出同规模即m * n* k个随机数。默认是None的，仅仅返回满足要求的单一随机数。
dtype: dtype(可选)
想要输出的格式。如int64、int等等
输出：
# 生成输入数据import numpy num_inputs=1num_examples=10features = numpy.random.randint(1, 10, (num_examples, num_inputs)) # 生成含有10个1~10的元素的二维列表
print(features[:,0])
def Fibonacci(n): # 求斐波契那数列的函数，输入n，输出第n项对应的值
F = [1, 1] if n <= 2: for item in range(n):
F.append(F[item] + F[item + 1]) return F[n - 1]%10007
else: for item in range(n - 2):
result = (F[0] + F[1]) % 10007 # 计算出下一项后直接取余数，不影响结果
F[0], F[1] = F[1], result return result # 直接输出余数，不需要再除10007# 输出斐波那契数列的前9项for item in range(1, 10): print(Fibonacci(item), end=" ")
1 1 2 3 5 8 13 21 34
# 生成输入对应的标签labels = []for item in features[:,0].tolist():
labels.append(Fibonacci(item))
labels = numpy.expand_dims(labels, axis=-1) #注意：需要在最后增加一个维度print(labels[:,0])
# 将数据转换成tensorimport paddle
features = features.astype('float32')
labels = labels.astype('float32')
train_datas = paddle.to_tensor(features)
y_true = paddle.to_tensor(labels)飞桨框架2.0中，组网相关的API都在paddle.nn目录下，你可以通过 Sequential 或 SubClass 的方式构建具体的模型。
这里我们使用最简单的线性变换层组网：
class paddle.nn.Linear(in_features, out_features, weight_attr=None, bias_attr=None, name=None)
参数：
import paddleclass Regressor(paddle.nn.Layer):
def __init__(self):
super(Regressor, self).__init__()
self.fc1 = paddle.nn.Linear(1, 2) # 输入数据的维度是1，所以in_features必须为1
self.fc2 = paddle.nn.Linear(2, 2) # 上一层的输出维度是2，所以in_features必须为2
self.fc3 = paddle.nn.Linear(2, 1) # 根据题目，输出斐波那契数列数列第n项的值，因此输出维度为1
def forward(self, inputs):
inputs = self.fc1(inputs)
hiddent = self.fc2(inputs)
pred = self.fc3(hiddent) return pred
model = Regressor()最优化问题是计算数学中最为重要的研究方向之一。在深度学习领域，优化算法同样是关键环节之一。即使完全相同的数据集与模型架构，不同的优化算法也很可能导致不同的训练结果，甚至有的模型出现不收敛现象。
训练的过程包含以下几点：
度下降是目前神经网络中使用最为广泛的优化算法之一。为弥补基本梯度下降的种种缺陷，研究者们提出了一系列的变种算法，从最初的SGD逐步演变到Adam、RMSprop等。
这里我们使用的是Adam算法：
# 定义Adam优化器lr = paddle.optimizer.lr.CosineAnnealingDecay(learning_rate=0.5, T_max=50)
optimizer = paddle.optimizer.Adam(learning_rate=lr,
parameters=model.parameters(),
weight_decay=paddle.regularizer.L2Decay(0.0001))
mse_loss = paddle.nn.MSELoss() # 计算预测值和目标值的均方差误差模型训练主要有下面几个步骤：
for i in range(1000): # 训练100轮
y_predict = model(train_datas) # 前向传播得到预测结果
loss = mse_loss(y_predict, y_true) # 计算预测结果与期望值的差距
loss.backward() # 根据损失进行反向传播
optimizer.step() # 更新参数
optimizer.clear_grad() # 梯度清零print(loss.numpy())[3.0985627]
斐波那契数列的前9项：
| n | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 |
|---|---|---|---|---|---|---|---|---|---|
| F(n) | 1 | 1 | 2 | 3 | 5 | 8 | 13 | 21 | 34 |
infer_features = numpy.random.randint(1, 10, (1, 1)).astype('float32') # 随机生成一个数据infer_features = paddle.to_tensor(infer_features)
fetch_list = model(infer_features) # 前向传播print(infer_features)print(fetch_list)
Tensor(shape=[1, 1], dtype=float32, place=CUDAPlace(0), stop_gradient=True,
[[6.]])
Tensor(shape=[1, 1], dtype=float32, place=CUDAPlace(0), stop_gradient=False,
[[9.02307510]])斐波那契数列的第6项是8，模型的预测输出是9.02，取整就是9，虽然不是很准确，但是结果接近。
大等于n的最小完全平方数是蓝桥杯试题算法训练里的练习题，难度比斐波那契数列要难一些，我们用飞桨来解这一题，过程跟上一题类似。
输出大等于n的最小的完全平方数。
若一个数能表示成某个自然数的平方的形式，则称这个数为完全平方数
Tips：注意数据范围
一个整数n
大等于n的最小的完全平方数
71711
71824
数据生成的方法跟上一题类似，关于numpy.random模块还有很多用法，可以尝试使用该模块生成更多的数据。
# 生成输入数据import numpy num_inputs=1num_examples=10features = numpy.random.randint(1, 10, (num_examples, num_inputs))
import mathdef PerfectSquare(n): # 求最小完全平方数的方法
result = 0
if n >= 0:
result = n ** 0.5
result = math.ceil(result)
result = result ** 2
return result# 输出1~10的最小完全平方数for item in range(1, 10): print(PerfectSquare(item), end=" ")
1 4 4 4 9 9 9 9 9
# 生成输入对应的标签labels = []for item in features[:,0].tolist():
labels.append(PerfectSquare(item))
labels = numpy.expand_dims(labels, axis=-1) #注意：需要在最后增加一个维度# 将数据转换成tensorimport paddle
features = features.astype('float32')
labels = labels.astype('float32')
train_datas = paddle.to_tensor(features)
y_true = paddle.to_tensor(labels)飞桨框架2.0中，组网相关的API都在paddle.nn目录下，你可以通过 Sequential 或 SubClass 的方式构建具体的模型。
这里我们使用最简单的线性变换层组网：
class paddle.nn.Linear(in_features, out_features, weight_attr=None, bias_attr=None, name=None)
参数：
import paddle model = paddle.nn.Linear(in_features=1, out_features=1) # 使用最简单的线性变换层
最优化问题是计算数学中最为重要的研究方向之一。在深度学习领域，优化算法同样是关键环节之一。即使完全相同的数据集与模型架构，不同的优化算法也很可能导致不同的训练结果，甚至有的模型出现不收敛现象。
训练的过程包含以下几点：
度下降是目前神经网络中使用最为广泛的优化算法之一。为弥补基本梯度下降的种种缺陷，研究者们提出了一系列的变种算法，从最初的SGD逐步演变到Adam、RMSprop等。
这里我们使用的是Adam算法：
# 定义Momentum优化器lr = paddle.optimizer.lr.CosineAnnealingDecay(learning_rate=0.25, T_max=100)
optimizer = paddle.optimizer.Adam(learning_rate=lr,
parameters=model.parameters(),
weight_decay=paddle.regularizer.L2Decay(0.0002))
mse_loss = paddle.nn.MSELoss() # 计算预测值和目标值的均方差误差模型训练主要有下面几个步骤：
for i in range(100):
y_predict = model(train_datas)
loss = mse_loss(y_predict, y_true)
loss.backward()
optimizer.step()
optimizer.clear_grad()print(loss.numpy())[0.77032995]
infer_features = numpy.random.randint(1, 10, (1, 1)).astype('float32')
infer_features = paddle.to_tensor(infer_features)
fetch_list = model(infer_features)print(infer_features)print(fetch_list)
Tensor(shape=[1, 1], dtype=float32, place=CUDAPlace(0), stop_gradient=True,
[[6.]])
Tensor(shape=[1, 1], dtype=float32, place=CUDAPlace(0), stop_gradient=False,
[[8.56781006]])6的最小完全平方数是9，模型的输出是8.56，比较接近9，但是还有点差距，不过总的来说，是可以近似拟合的。
以上就是原来飞桨还可以这么玩！当人工智能邂逅蓝桥杯算法题，会擦出怎样的火花？的详细内容，更多请关注php中文网其它相关文章！
每个人都需要一台速度更快、更稳定的 PC。随着时间的推移，垃圾文件、旧注册表数据和不必要的后台进程会占用资源并降低性能。幸运的是，许多工具可以让 Windows 保持平稳运行。
广告
收藏
收藏
收藏
Copyright 2014-2025 https://www.php.cn/ All Rights Reserved | php.cn | 湘ICP备2023035733号
448
