devbox
凡人多烦事01
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

很牛的东西PaddleKAN（Paddle kolmogorov arnold network）_kan代码

作者：凡人多烦事01 | 2024-05-28 05:32:12

赞

踩

kan代码

全新神经网络KAN kolmogorov arnold network  ，论文一出就炸裂了，大家对它都很关注！

论文：https://arxiv.org/abs/2404.19756

飞桨代码：GitHub - yrqUni/PaddleKAN

据说这个代码并不能达到论文的效果，不过可以先了解了解思路。 

PaddleKAN代码

  1. import paddle
  2. import paddle.nn.functional as F
  3.  
  4. class KANLinear(paddle.nn.Layer):
  5.     def __init__(
  6.         self,
  7.         in_features,
  8.         out_features,
  9.         grid_size=5,
  10.         spline_order=3,
  11.         scale_noise=0.1,
  12.         scale_base=1.0,
  13.         scale_spline=1.0,
  14.         base_activation=paddle.nn.Silu,
  15.         grid_eps=0.02,
  16.         grid_range=[-1, 1],
  17.     ):
  18.         super(KANLinear, self).__init__()
  19.         self.in_features = in_features
  20.         self.out_features = out_features
  21.         self.grid_size = grid_size
  22.         self.spline_order = spline_order
  23.  
  24.         h = (grid_range[1] - grid_range[0]) / grid_size
  25.         grid = (
  26.             paddle.arange(-spline_order, grid_size + spline_order + 1, dtype=paddle.float32) * h
  27.             + grid_range[0]
  28.         ).expand([in_features, -1]).contiguous()
  29.         self.register_buffer("grid", grid)
  30.  
  31.         self.base_weight = self.create_parameter(
  32.             shape=[out_features, in_features], default_initializer=paddle.nn.initializer.Constant(value=scale_base))
  33.         self.spline_weight = self.create_parameter(
  34.             shape=[out_features, in_features, grid_size + spline_order], default_initializer=paddle.nn.initializer.Constant(value=scale_spline))
  35.  
  36.         self.scale_noise = scale_noise
  37.         self.scale_base = scale_base
  38.         self.scale_spline = scale_spline
  39.         self.base_activation = base_activation()
  40.         self.grid_eps = grid_eps
  41.  
  42.         self.reset_parameters()
  43.  
  44.     def reset_parameters(self):
  45.         self.base_weight.set_value(paddle.full([self.out_features, self.in_features], self.scale_base))
  46.         with paddle.no_grad():
  47.             noise = (
  48.                 paddle.rand([self.grid_size + 1, self.in_features, self.out_features], dtype=paddle.float32)
  49.                 - 0.5
  50.             ) * self.scale_noise / self.grid_size
  51.             self.spline_weight.set_value(
  52.                 self.scale_spline
  53.                 * self.curve2coeff(
  54.                     self.grid.T[self.spline_order:-self.spline_order],
  55.                     noise,
  56.                 )
  57.             )
  58.  
  59.     def b_splines(self, x: paddle.Tensor):
  60.         """
  61.         Compute the B-spline bases for the given input tensor.
  63.         Args:
  64.             x (paddle.Tensor): Input tensor of shape (batch_size, in_features).
  66.         Returns:
  67.             paddle.Tensor: B-spline bases tensor of shape (batch_size, in_features, grid_size + spline_order).
  68.         """
  69.         assert x.ndim == 2 and x.shape[1] == self.in_features
  70.  
  71.         grid: paddle.Tensor = (
  72.             self.grid
  73.         )  # (in_features, grid_size + 2 * spline_order + 1)
  74.         x = x.unsqueeze(-1)
  75.         bases = ((x >= grid[:, :-1]) & (x < grid[:, 1:])).cast(x.dtype)
  76.         for k in range(1, self.spline_order + 1):
  77.             bases = (
  78.                 (x - grid[:, : -(k + 1)])
  79.                 / (grid[:, k:-1] - grid[:, : -(k + 1)])
  80.                 * bases[:, :, :-1]
  81.             ) + (
  82.                 (grid[:, k + 1 :] - x)
  83.                 / (grid[:, k + 1 :] - grid[:, 1:(-k)])
  84.                 * bases[:, :, 1:]
  85.             )
  86.  
  87.         assert tuple(bases.shape) == tuple((
  88.             x.shape[0],
  89.             self.in_features,
  90.             self.grid_size + self.spline_order,
  91.         ))
  92.         return bases
  93.  
  94.  
  95.     def curve2coeff(self, x: paddle.Tensor, y: paddle.Tensor):
  96.         """
  97.         Compute the coefficients of the curve that interpolates the given points.
  99.         Args:
  100.             x (paddle.Tensor): Input tensor of shape (batch_size, in_features).
  101.             y (paddle.Tensor): Output tensor of shape (batch_size, in_features, out_features).
  103.         Returns:
  104.             paddle.Tensor: Coefficients tensor of shape (out_features, in_features, grid_size + spline_order).
  105.         """
  106.         assert x.ndim == 2 and x.shape[1] == self.in_features
  107.         assert y.shape == [x.shape[0], self.in_features, self.out_features]
  108.  
  109.         A = self.b_splines(x).transpose(
  110.             [1, 0, 2]
  111.         )  # (in_features, batch_size, grid_size + spline_order)
  112.         B = y.transpose([1, 0, 2])  # (in_features, batch_size, out_features)
  113.         solution = paddle.linalg.lstsq(
  114.             A, B
  115.         )  # solution: (in_features, grid_size + spline_order, out_features)
  116.  
  117.         result = solution[0].transpose(
  118.             [2, 0, 1]
  119.         )  # (out_features, in_features, grid_size + spline_order)
  120.  
  121.         assert result.shape == [
  122.             self.out_features,
  123.             self.in_features,
  124.             self.grid_size + self.spline_order,
  125.         ]
  126.         return result
  127.     
  128.     def forward(self, x: paddle.Tensor):
  129.         base_output = F.linear(self.base_activation(x), self.base_weight.transpose([1, 0]))
  130.         spline_output = F.linear(
  131.             self.b_splines(x).reshape([x.shape[0], -1]),
  132.             self.spline_weight.reshape([self.out_features, -1]).transpose([1, 0])
  133.         )
  134.         return base_output + spline_output
  135.     
  136.     @paddle.no_grad()
  137.     def update_grid(self, x: paddle.Tensor, margin=0.01):
  138.         assert x.ndim == 2 and x.shape[1] == self.in_features
  139.         batch = x.shape[0]
  140.  
  141.         splines = self.b_splines(x)  # (batch, in, coeff)
  142.         splines = splines.transpose([1, 0, 2])  # (in, batch, coeff)
  143.         orig_coeff = self.spline_weight  # (out, in, coeff)
  144.         orig_coeff = orig_coeff.transpose([1, 2, 0])  # (in, coeff, out)
  145.         unreduced_spline_output = paddle.bmm(splines, orig_coeff)  # (in, batch, out)
  146.         unreduced_spline_output = unreduced_spline_output.transpose([1, 0, 2])  # (batch, in, out)
  147.        
  148.         # Sort each channel individually to collect data distribution
  149.         x_sorted = paddle.sort(x, axis=0)
  150.         grid_adaptive = x_sorted[
  151.             paddle.linspace(
  152.                 0, batch - 1, self.grid_size + 1, dtype='int64'
  153.             ).astype('int32')
  154.         ]
  155.  
  156.         uniform_step = (x_sorted[-1] - x_sorted[0] + 2 * margin) / self.grid_size
  157.         grid_uniform = (
  158.             paddle.arange(
  159.                 self.grid_size + 1, dtype='float32'
  160.             ).unsqueeze(1)
  161.             * uniform_step
  162.             + x_sorted[0]
  163.             - margin
  164.         )
  165.  
  166.         grid = self.grid_eps * grid_uniform + (1 - self.grid_eps) * grid_adaptive
  167.         grid = paddle.concat(
  168.             [
  169.                 grid[:1]
  170.                 - uniform_step
  171.                 * paddle.arange(self.spline_order, 0, -1, dtype='float32').unsqueeze(1),
  172.                 grid,
  173.                 grid[-1:]
  174.                 + uniform_step
  175.                 * paddle.arange(1, self.spline_order + 1, dtype='float32').unsqueeze(1),
  176.             ],
  177.             axis=0
  178.         )
  179.  
  180.         self.grid.set_value(grid.T)
  181.         self.spline_weight.set_value(self.curve2coeff(x, unreduced_spline_output))
  182.  
  183.     def regularization_loss(self, regularize_activation=1.0, regularize_entropy=1.0):
  184.         l1_norm = paddle.mean(paddle.abs(self.spline_weight), axis=-1)
  185.         reg_loss_activation = paddle.sum(l1_norm)
  186.         p = l1_norm / reg_loss_activation
  187.         reg_loss_entropy = -paddle.sum(p * paddle.log(p + 1e-8))
  188.         return (
  189.             regularize_activation * reg_loss_activation +
  190.             regularize_entropy * reg_loss_entropy
  191.         )
  192.  
  193. class KAN(paddle.nn.Layer):
  194.     def __init__(
  195.         self,
  196.         layers_hidden,
  197.         grid_size=5,
  198.         spline_order=3,
  199.         scale_noise=0.1,
  200.         scale_base=1.0,
  201.         scale_spline=1.0,
  202.         base_activation=paddle.nn.Silu,
  203.         grid_eps=0.02,
  204.         grid_range=[-1, 1],
  205.     ):
  206.         super(KAN, self).__init__()
  207.         self.layers = paddle.nn.LayerList()
  208.         for in_features, out_features in zip(layers_hidden[:-1], layers_hidden[1:]):
  209.             self.layers.append(
  210.                 KANLinear(
  211.                     in_features,
  212.                     out_features,
  213.                     grid_size=grid_size,
  214.                     spline_order=spline_order,
  215.                     scale_noise=scale_noise,
  216.                     scale_base=scale_base,
  217.                     scale_spline=scale_spline,
  218.                     base_activation=base_activation,
  219.                     grid_eps=grid_eps,
  220.                     grid_range=grid_range,
  221.                 )
  222.             )
  223.  
  224.     def forward(self, x: paddle.Tensor, update_grid=False):
  225.         for layer in self.layers:
  226.             if update_grid:
  227.                 layer.update_grid(x)
  228.             x = layer(x)
  229.         return x
  230.  
  231.     def regularization_loss(self, regularize_activation=1.0, regularize_entropy=1.0):
  232.         return sum(
  233.             layer.regularization_loss(regularize_activation, regularize_entropy)
  234.             for layer in self.layers
  235.         )

5.11日有直播课：

周六晚上20：00-22：00 大家可以到集智乐园观看。

据说效果非常好，期待

期待自己能看懂！

论文摘要：

受Kolmogorov Arnold表示定理的启发，我们提出了Kolmogorov-Anold网络（KAN）作为多层感知器（MLP）的有前途的替代方案。
虽然MLP在节点（“神经元”）上具有固定的激活功能，但KAN具有可学习性
边上的激活函数（“权重”）。KANs根本没有线性权重——每
权重参数由参数化为样条曲线的单变量函数代替。我们展示
这个看似简单的变化使KANs在准确性方面优于MLP
以及可解释性。就准确性而言，更小的KANs可以实现相当或更好的结果
在数据拟合和PDE求解中，精度远大于MLP。理论上和经验上，KANs拥有比MLP更快的神经缩放定律。对于可解释性，KANs
可以直观地可视化并且可以容易地与人类用户交互。通过数学和物理学中的两个例子，KAN被证明是有用的“合作者”，有助于科学家重新发现数学和物理定律。总之，KANs很有希望
MLP的替代方案，为进一步改进当今严重依赖MLP的模型的深度学习提供了机会。

介绍

多层感知器（MLP）[1，2，3]，也称为全连接前馈神经网络，是当今深度学习模型的基础构建块。由于MLP表达能力受到普遍逼近定理[3]的保证，MLP是机器学习中用于近似的默认非线性函数模型，他们的重要性毋庸置疑。然而，MLP是我们能建立的最好的非线性回归器吗？尽管普遍使用MLP，它们也有有显著的缺点。例如，在Transformer模型[4]中，MLP几乎消耗了所有非嵌入参数，并且通常不太可解释（相对于注意力层）后分析工具[5]。

我们提出了一种很有前途的MLP替代方案，称为Kolmogorov Arnold Networks（KAN）。
MLP受到普遍近似定理的启发，而KAN受到
Kolmogorov-Anold表示定理[6，7]。与MLP一样，KAN具有完全连接的结构。然而，当MLP在节点（“神经元”）上放置固定的激活函数时，KAN放置
边缘上的可学习激活函数（“权重”），如图0.1所示。因此，KAN
根本没有线性权重矩阵：相反，每个权重参数都被可学习的1D代替
函数参数化为样条曲线。KAN的节点简单地对输入信号求和，而不应用任何
非线性。人们可能会担心KAN的价格高得令人绝望，因为每个MLP的重量
参数变为KAN的样条函数。幸运的是，KAN通常允许比MLP小得多的计算图。例如，我们展示了对于PDE求解，2层宽度为10的KAN(2-Layer width-10 KAN) 100次求解 精度要高于
4层宽度-100 MLP（4-Layer width-100 MLP  10−7 vs 10−5 MSE）求解100次， 参数也更高效(10^2 vs 10^4 parameters)

公式

f(x_1, ... ,x_N ) = exp (\frac{1}{N} \sum_{i=1}^{n} sin^2 (xi) )

 这个公式太简单了，以至于大家争论非常大。连我这看不懂公式的人，也感觉简单。

拆开之后，结果就是求下面累加和的平均数，简直太简单了。

sin^2 (x_1) ) + sin^2 (x_2) ) +sin^2 (x_3) ) 

不过考虑到论文作者是北大数学系毕业，我认为其严谨的工作态度，还真可能就找到这么简洁而漂亮的人工智能密码。

讨论

KAN作为人工智能+科学的“语言模型”，大语言模型之所以如此
流行是因为它们对任何会说自然语言的人都很有用，同样KAN也是这样，KAN由可解释的函数组成，因此当用户使用KAN时就像使用函数语言（大模型语言）与它进行通信一样。本段旨在
推广人工智能科学家协作模式，而不是我们的特定工具KAN。就像
人们使用不同的语言进行交流，我们预计在未来KAN将只是一种
人工智能+科学的语言之一，尽管KANs语言将是最早的
使人工智能和人类能够进行通信语言之一。然而，在KAN的支持下，人工智能科学家合作
范式从来没有这么容易和方便，这导致我们重新思考如何
促进人工智能+科学：我们想要人工智能科学家，还是想要帮助科学家的人工智能？
（全自动化）人工智能科学家的内在困难在于很难做出人类的偏好
量化，把人类偏好编码成人工智能目标。事实上，不同领域的科学家
可能对哪些函数是简单的或可解释的有不同的感受。因此，
科学家们更希望拥有一种能说科学语言（功能）并能
方便地与个别科学家的归纳偏见互动，以适应特定的科学
领域的人工智能。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/凡人多烦事01/article/detail/635851
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号