yms-kan 0.0.7__tar.gz → 0.0.10__tar.gz

yms_kan-0.0.10/MANIFEST.in

@@ -0,0 +1 @@
+recursive-include yms_kan/assets/img *.png

yms_kan-0.0.10/PKG-INFO

@@ -0,0 +1,11 @@
+Metadata-Version: 2.4
+Name: yms_kan
+Version: 0.0.10
+Summary: My awesome package
+Author-email: yms <11@qq.com>
+License-Expression: MIT
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+### 测试

yms_kan-0.0.10/README.md

@@ -0,0 +1 @@
+### 测试

yms_kan-0.0.10/pyproject.toml

@@ -0,0 +1,31 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "yms_kan"
+dynamic = ["version"]
+
+description = "My awesome package"
+authors = [{name = "yms", email = "11@qq.com"}]
+readme = "README.md"
+license = "MIT"  # 直接使用字符串格式
+
+# 可选：指定许可证文件
+license-files = ["LICENSE"]
+
+[tool.setuptools.dynamic]
+# 明确指定版本号来源
+version = {attr = "yms_kan.version.__version__"}
+
+[tool.setuptools]
+# 包含非代码文件
+include-package-data = true
+
+[tool.setuptools.package-data]
+# 指定包内资源文件的匹配规则
+yms_kan = [
+    "assets/img/*.png",      # 包含所有png文件
+    "assets/img/*.svg",      # 可扩展其他格式
+    "assets/**/*"            # 递归包含子目录
+]

{yms_kan-0.0.7/kan → yms_kan-0.0.10/yms_kan}/KANLayer.py

@@ -84,7 +84,7 @@ class KANLayer(nn.Module):
             
         Example
         -------
-        >>> from kan.KANLayer import *
+        >>> from yms_kan.KANLayer import *
         >>> model = KANLayer(in_dim=3, out_dim=5)
         >>> (model.in_dim, model.out_dim)
         '''
@@ -144,7 +144,7 @@ class KANLayer(nn.Module):
         
         Example
         -------
-        >>> from kan.KANLayer import *
+        >>> from yms_kan.KANLayer import *
         >>> model = KANLayer(in_dim=3, out_dim=5)
         >>> x = torch.normal(0,1,size=(100,3))
         >>> y, preacts, postacts, postspline = model(x)
@@ -342,7 +342,7 @@ class KANLayer(nn.Module):
             
         Example
         -------
-        >>> from kan.KANLayer import *
+        >>> from yms_kan.KANLayer import *
         >>> model = KANLayer(in_dim=2, out_dim=2, num=5, k=3)
         >>> print(model.coef)
         >>> model.swap(0,1,mode='in')

{yms_kan-0.0.7/kan → yms_kan-0.0.10/yms_kan}/MLP.py

@@ -3,43 +3,44 @@ import torch.nn as nn
 import matplotlib.pyplot as plt
 import numpy as np
 from tqdm import tqdm
+
+from . import plot_tree
 from .LBFGS import LBFGS
 
 seed = 0
 torch.manual_seed(seed)
 
+
 class MLP(nn.Module):
-    
+
     def __init__(self, width, act='silu', save_act=True, seed=0, device='cpu'):
         super(MLP, self).__init__()
-        
+
         torch.manual_seed(seed)
-        
+
         linears = []
         self.width = width
         self.depth = depth = len(width) - 1
         for i in range(depth):
-            linears.append(nn.Linear(width[i], width[i+1]))
+            linears.append(nn.Linear(width[i], width[i + 1]))
         self.linears = nn.ModuleList(linears)
-        
+
         #if activation == 'silu':
         self.act_fun = torch.nn.SiLU()
         self.save_act = save_act
         self.acts = None
-        
+
         self.cache_data = None
-        
+
         self.device = device
         self.to(device)
-        
-        
+
     def to(self, device):
         super(MLP, self).to(device)
         self.device = device
-        
+
         return self
-        
-        
+
     def get_act(self, x=None):
         if isinstance(x, dict):
             x = x['train_input']
@@ -52,23 +53,23 @@ class MLP(nn.Module):
         self.save_act = True
         self.forward(x)
         self.save_act = save_act
-        
+
     @property
     def w(self):
         return [self.linears[l].weight for l in range(self.depth)]
-        
+
     def forward(self, x):
-        
+
         # cache data
         self.cache_data = x
-        
+
         self.acts = []
         self.acts_scale = []
         self.wa_forward = []
         self.a_forward = []
-        
+
         for i in range(self.depth):
-            
+
             if self.save_act:
                 act = x.clone()
                 act_scale = torch.std(x, dim=0)
@@ -77,7 +78,7 @@ class MLP(nn.Module):
                 if i > 0:
                     self.acts_scale.append(act_scale)
                 self.wa_forward.append(wa_forward)
-            
+
             x = self.linears[i](x)
             if i < self.depth - 1:
                 x = self.act_fun(x)
@@ -85,9 +86,9 @@ class MLP(nn.Module):
                 if self.save_act:
                     act_scale = torch.std(x, dim=0)
                     self.acts_scale.append(act_scale)
-                
+
         return x
-    
+
     def attribute(self):
         if self.acts == None:
             self.get_act()
@@ -99,47 +100,47 @@ class MLP(nn.Module):
         node_score = torch.ones(self.width[-1]).requires_grad_(True).to(self.device)
         node_scores.append(node_score)
 
-        for l in range(self.depth,0,-1):
-
-            edge_score = torch.einsum('ij,i->ij', torch.abs(self.wa_forward[l-1]), node_score/(self.acts_scale[l-1]+1e-4))
+        for l in range(self.depth, 0, -1):
+            edge_score = torch.einsum('ij,i->ij', torch.abs(self.wa_forward[l - 1]),
+                                      node_score / (self.acts_scale[l - 1] + 1e-4))
             edge_scores.append(edge_score)
 
             # this might be improper for MLPs (although reasonable for KANs)
-            node_score = torch.sum(edge_score, dim=0)/torch.sqrt(torch.tensor(self.width[l-1], device=self.device))
+            node_score = torch.sum(edge_score, dim=0) / torch.sqrt(torch.tensor(self.width[l - 1], device=self.device))
             #print(self.width[l])
             node_scores.append(node_score)
 
         self.node_scores = list(reversed(node_scores))
         self.edge_scores = list(reversed(edge_scores))
         self.wa_backward = self.edge_scores
-    
+
     def plot(self, beta=3, scale=1., metric='w'):
         # metric = 'w', 'act' or 'fa'
-        
+
         if metric == 'fa':
             self.attribute()
-        
+
         depth = self.depth
         y0 = 0.5
-        fig, ax = plt.subplots(figsize=(3*scale,3*y0*depth*scale))
+        fig, ax = plt.subplots(figsize=(3 * scale, 3 * y0 * depth * scale))
         shp = self.width
-        
-        min_spacing = 1/max(self.width)
+
+        min_spacing = 1 / max(self.width)
         for j in range(len(shp)):
             N = shp[j]
             for i in range(N):
                 plt.scatter(1 / (2 * N) + i / N, j * y0, s=min_spacing ** 2 * 5000 * scale ** 2, color='black')
-                
-        plt.ylim(-0.1*y0,y0*depth+0.1*y0)
-        plt.xlim(-0.02,1.02)
+
+        plt.ylim(-0.1 * y0, y0 * depth + 0.1 * y0)
+        plt.xlim(-0.02, 1.02)
 
         linears = self.linears
-        
+
         for ii in range(len(linears)):
             linear = linears[ii]
             p = linear.weight
             p_shp = p.shape
-            
+
             if metric == 'w':
                 pass
             elif metric == 'act':
@@ -150,12 +151,15 @@ class MLP(nn.Module):
                 raise Exception('metric = \'{}\' not recognized. Choices are \'w\', \'act\', \'fa\'.'.format(metric))
             for i in range(p_shp[0]):
                 for j in range(p_shp[1]):
-                    plt.plot([1/(2*p_shp[0])+i/p_shp[0], 1/(2*p_shp[1])+j/p_shp[1]], [y0*(ii+1),y0*ii], lw=0.5*scale, alpha=np.tanh(beta*np.abs(p[i,j].cpu().detach().numpy())), color="blue" if p[i,j]>0 else "red")
-                    
+                    plt.plot([1 / (2 * p_shp[0]) + i / p_shp[0], 1 / (2 * p_shp[1]) + j / p_shp[1]],
+                             [y0 * (ii + 1), y0 * ii], lw=0.5 * scale,
+                             alpha=np.tanh(beta * np.abs(p[i, j].cpu().detach().numpy())),
+                             color="blue" if p[i, j] > 0 else "red")
+
         ax.axis('off')
-        
+
     def reg(self, reg_metric, lamb_l1, lamb_entropy):
-        
+
         if reg_metric == 'w':
             acts_scale = self.w
         if reg_metric == 'act':
@@ -164,7 +168,7 @@ class MLP(nn.Module):
             acts_scale = self.wa_backward
         if reg_metric == 'a':
             acts_scale = self.acts_scale
-        
+
         if len(acts_scale[0].shape) == 2:
             reg_ = 0.
 
@@ -178,9 +182,9 @@ class MLP(nn.Module):
                 entropy_row = - torch.mean(torch.sum(p_row * torch.log2(p_row + 1e-4), dim=1))
                 entropy_col = - torch.mean(torch.sum(p_col * torch.log2(p_col + 1e-4), dim=0))
                 reg_ += lamb_l1 * l1 + lamb_entropy * (entropy_row + entropy_col)
-                
+
         elif len(acts_scale[0].shape) == 1:
-            
+
             reg_ = 0.
 
             for i in range(len(acts_scale)):
@@ -193,20 +197,21 @@ class MLP(nn.Module):
                 reg_ += lamb_l1 * l1 + lamb_entropy * entropy
 
         return reg_
-    
+
     def get_reg(self, reg_metric, lamb_l1, lamb_entropy):
         return self.reg(reg_metric, lamb_l1, lamb_entropy)
-        
-    def fit(self, dataset, opt="LBFGS", steps=100, log=1, lamb=0., lamb_l1=1., lamb_entropy=2., loss_fn=None, lr=1., batch=-1,
-              metrics=None, in_vars=None, out_vars=None, beta=3, device='cpu', reg_metric='w', display_metrics=None):
+
+    def fit(self, dataset, opt="LBFGS", steps=100, log=1, lamb=0., lamb_l1=1., lamb_entropy=2., loss_fn=None, lr=1.,
+            batch=-1,
+            metrics=None, device='cpu', reg_metric='w', display_metrics=None):
 
         if lamb > 0. and not self.save_act:
             print('setting lamb=0. If you want to set lamb > 0, set =True')
-            
+
         old_save_act = self.save_act
         if lamb == 0.:
             self.save_act = False
-       
+
         pbar = tqdm(range(steps), desc='description', ncols=100)
 
         if loss_fn == None:
@@ -217,7 +222,8 @@ class MLP(nn.Module):
         if opt == "Adam":
             optimizer = torch.optim.Adam(self.parameters(), lr=lr)
         elif opt == "LBFGS":
-            optimizer = LBFGS(self.parameters(), lr=lr, history_size=10, line_search_fn="strong_wolfe", tolerance_grad=1e-32, tolerance_change=1e-32, tolerance_ys=1e-32)
+            optimizer = LBFGS(self.parameters(), lr=lr, history_size=10, line_search_fn="strong_wolfe",
+                              tolerance_grad=1e-32, tolerance_change=1e-32, tolerance_ys=1e-32)
 
         results = {}
         results['train_loss'] = []
@@ -252,10 +258,10 @@ class MLP(nn.Module):
             return objective
 
         for _ in pbar:
-            
-            if _ == steps-1 and old_save_act:
+
+            if _ == steps - 1 and old_save_act:
                 self.save_act = True
-            
+
             train_id = np.random.choice(dataset['train_input'].shape[0], batch_size, replace=False)
             test_id = np.random.choice(dataset['test_input'].shape[0], batch_size_test, replace=False)
 
@@ -274,9 +280,9 @@ class MLP(nn.Module):
                 loss.backward()
                 optimizer.step()
 
-            test_loss = loss_fn_eval(self.forward(dataset['test_input'][test_id].to(self.device)), dataset['test_label'][test_id].to(self.device))
-            
-            
+            test_loss = loss_fn_eval(self.forward(dataset['test_input'][test_id].to(self.device)),
+                                     dataset['test_label'][test_id].to(self.device))
+
             if metrics != None:
                 for i in range(len(metrics)):
                     results[metrics[i].__name__].append(metrics[i]().item())
@@ -287,7 +293,9 @@ class MLP(nn.Module):
 
             if _ % log == 0:
                 if display_metrics == None:
-                    pbar.set_description("| train_loss: %.2e | test_loss: %.2e | reg: %.2e | " % (torch.sqrt(train_loss).cpu().detach().numpy(), torch.sqrt(test_loss).cpu().detach().numpy(), reg_.cpu().detach().numpy()))
+                    pbar.set_description("| train_loss: %.2e | test_loss: %.2e | reg: %.2e | " % (
+                    torch.sqrt(train_loss).cpu().detach().numpy(), torch.sqrt(test_loss).cpu().detach().numpy(),
+                    reg_.cpu().detach().numpy()))
                 else:
                     string = ''
                     data = ()
@@ -299,9 +307,9 @@ class MLP(nn.Module):
                             raise Exception(f'{metric} not recognized')
                         data += (results[metric][-1],)
                     pbar.set_description(string % data)
-           
+
         return results
-    
+
     @property
     def connection_cost(self):
 
@@ -309,8 +317,9 @@ class MLP(nn.Module):
             cc = 0.
             for linear in self.linears:
                 t = torch.abs(linear.weight)
+
                 def get_coordinate(n):
-                    return torch.linspace(0,1,steps=n+1, device=self.device)[:n] + 1/(2*n)
+                    return torch.linspace(0, 1, steps=n + 1, device=self.device)[:n] + 1 / (2 * n)
 
                 in_dim = t.shape[0]
                 x_in = get_coordinate(in_dim)
@@ -318,44 +327,45 @@ class MLP(nn.Module):
                 out_dim = t.shape[1]
                 x_out = get_coordinate(out_dim)
 
-                dist = torch.abs(x_in[:,None] - x_out[None,:])
+                dist = torch.abs(x_in[:, None] - x_out[None, :])
                 cc += torch.sum(dist * t)
 
         return cc
-    
+
     def swap(self, l, i1, i2):
 
         def swap_row(data, i1, i2):
             data[i1], data[i2] = data[i2].clone(), data[i1].clone()
 
         def swap_col(data, i1, i2):
-            data[:,i1], data[:,i2] = data[:,i2].clone(), data[:,i1].clone()
+            data[:, i1], data[:, i2] = data[:, i2].clone(), data[:, i1].clone()
 
-        swap_row(self.linears[l-1].weight.data, i1, i2)
-        swap_row(self.linears[l-1].bias.data, i1, i2)
+        swap_row(self.linears[l - 1].weight.data, i1, i2)
+        swap_row(self.linears[l - 1].bias.data, i1, i2)
         swap_col(self.linears[l].weight.data, i1, i2)
-    
+
     def auto_swap_l(self, l):
 
         num = self.width[l]
         for i in range(num):
             ccs = []
             for j in range(num):
-                self.swap(l,i,j)
+                self.swap(l, i, j)
                 self.get_act()
                 self.attribute()
                 cc = self.connection_cost.detach().clone()
                 ccs.append(cc)
-                self.swap(l,i,j)
+                self.swap(l, i, j)
             j = torch.argmin(torch.tensor(ccs))
-            self.swap(l,i,j)
+            self.swap(l, i, j)
 
     def auto_swap(self):
         depth = self.depth
         for l in range(1, depth):
             self.auto_swap_l(l)
-            
+
     def tree(self, x=None, in_var=None, style='tree', sym_th=1e-3, sep_th=1e-1, skip_sep_test=False, verbose=False):
         if x == None:
             x = self.cache_data
-        plot_tree(self, x, in_var=in_var, style=style, sym_th=sym_th, sep_th=sep_th, skip_sep_test=skip_sep_test, verbose=verbose)
+        plot_tree(self, x, in_var=in_var, style=style, sym_th=sym_th, sep_th=sep_th, skip_sep_test=skip_sep_test,
+                  verbose=verbose)