diff --git a/kan/MultKAN.py b/kan/MultKAN.py
index 1d39ba3e..61d0c870 100644
--- a/kan/MultKAN.py
+++ b/kan/MultKAN.py
@@ -24,7 +24,7 @@
 class MultKAN(nn.Module):
 
     # include mult_ops = []
-    def __init__(self, width=None, grid=3, k=3, mult_arity = 2, noise_scale=1.0, scale_base_mu=0.0, scale_base_sigma=1.0, base_fun='silu', symbolic_enabled=True, affine_trainable=False, grid_eps=1.0, grid_range=[-1, 1], sp_trainable=True, sb_trainable=True, device='cpu', seed=0, save_plot_data=True, sparse_init=False, auto_save=True, first_init=True, ckpt_path='./model', state_id=0):
+    def __init__(self, width=None, grid=3, k=3, mult_arity = 2, noise_scale=1.0, scale_base_mu=0.0, scale_base_sigma=1.0, base_fun='silu', symbolic_enabled=True, affine_trainable=False, grid_eps=1.0, grid_range=[-1, 1], sp_trainable=True, sb_trainable=True, device='cpu', seed=1, save_act=True, sparse_init=False, auto_save=True, first_init=True, ckpt_path='./model', state_id=0, round=0):
         
         super(MultKAN, self).__init__()
 
@@ -111,7 +111,7 @@ def __init__(self, width=None, grid=3, k=3, mult_arity = 2, noise_scale=1.0, sca
         self.sb_trainable = sb_trainable
         
         self.device = device
-        self.save_plot_data = save_plot_data
+        self.save_act = save_act
             
         self.node_scores = None
         self.edge_scores = None
@@ -123,20 +123,22 @@ def __init__(self, width=None, grid=3, k=3, mult_arity = 2, noise_scale=1.0, sca
         self.auto_save = auto_save
         self.state_id = 0
         self.ckpt_path = ckpt_path
+        self.round = round
+        
         
         if auto_save:
             if first_init:
                 if not os.path.exists(ckpt_path):
                     # Create the directory
                     os.makedirs(ckpt_path)
-                    print(f"Directory created: {ckpt_path}")
-                else:
-                    print(f"Directory already exists: {ckpt_path}")
+                print(f"checkpoint directory created: {ckpt_path}")
+                print('saving model version 0.0')
 
                 history_path = self.ckpt_path+'/history.txt'
                 with open(history_path, 'w') as file:
-                    file.write('init => 0' + '\n')
-                self.saveckpt(path=self.ckpt_path+'/'+'0')
+                    file.write(f'### Round {self.round} ###' + '\n')
+                    file.write('init => 0.0' + '\n')
+                self.saveckpt(path=self.ckpt_path+'/'+'0.0')
             else:
                 self.state_id = state_id
             
@@ -181,13 +183,14 @@ def log_history(self, method_name):
             # save to log file
             #print(func.__name__)
             with open(self.ckpt_path+'/history.txt', 'a') as file:
-                file.write(str(self.state_id)+' => '+ method_name + ' => ' + str(self.state_id+1) + '\n')
+                file.write(str(self.round)+'.'+str(self.state_id)+' => '+ method_name + ' => ' + str(self.round)+'.'+str(self.state_id+1) + '\n')
 
             # update state_id
             self.state_id += 1
 
             # save to ckpt
-            self.saveckpt(path=self.ckpt_path+'/'+str(self.state_id))
+            self.saveckpt(path=self.ckpt_path+'/'+str(self.round)+'.'+str(self.state_id))
+            print('saving model version '+str(self.round)+'.'+str(self.state_id))
 
     
     def refine(self, new_grid):
@@ -207,10 +210,12 @@ def refine(self, new_grid):
                      ckpt_path=self.ckpt_path,
                      auto_save=True,
                      first_init=False,
-                     state_id=self.state_id)
+                     state_id=self.state_id,
+                     round=self.round)
             
         model_new.initialize_from_another_model(self, self.cache_data)
         model_new.cache_data = self.cache_data
+        model_new.grid = new_grid
         
         self.log_history('refine')
         model_new.state_id += 1
@@ -237,7 +242,8 @@ def saveckpt(self, path='model'):
             device = model.device,
             state_id = model.state_id,
             auto_save = model.auto_save,
-            ckpt_path = model.ckpt_path
+            ckpt_path = model.ckpt_path,
+            round = model.round
         )
 
         for i in range (model.depth):
@@ -247,6 +253,68 @@ def saveckpt(self, path='model'):
             yaml.dump(dic, outfile, default_flow_style=False)
 
         torch.save(model.state_dict(), f'{path}_state')
+        torch.save(model.cache_data, f'{path}_cache_data')
+    
+    @staticmethod
+    def loadckpt(path='model'):
+        with open(f'{path}_config.yml', 'r') as stream:
+            config = yaml.safe_load(stream)
+
+        state = torch.load(f'{path}_state')
+
+        model_load = MultKAN(width=config['width'], 
+                     grid=config['grid'], 
+                     k=config['k'], 
+                     mult_arity = config['mult_arity'], 
+                     base_fun=config['base_fun_name'], 
+                     symbolic_enabled=config['symbolic_enabled'], 
+                     affine_trainable=config['affine_trainable'], 
+                     grid_eps=config['grid_eps'], 
+                     grid_range=config['grid_range'], 
+                     sp_trainable=config['sp_trainable'],
+                     sb_trainable=config['sb_trainable'],
+                     device=config['device'],
+                     state_id=config['state_id'],
+                     auto_save=config['auto_save'],
+                     first_init=False,
+                     ckpt_path=config['ckpt_path'],
+                     round = config['round']+1)
+
+        model_load.load_state_dict(state)
+        model_load.cache_data = torch.load(f'{path}_cache_data')
+        
+        depth = len(model_load.width) - 1
+        for l in range(depth):
+            out_dim = model_load.symbolic_fun[l].out_dim
+            in_dim = model_load.symbolic_fun[l].in_dim
+            funs_name = config[f'symbolic.funs_name.{l}']
+            for j in range(out_dim):
+                for i in range(in_dim):
+                    fun_name = funs_name[j][i]
+                    model_load.symbolic_fun[l].funs_name[j][i] = fun_name
+                    model_load.symbolic_fun[l].funs[j][i] = SYMBOLIC_LIB[fun_name][0]
+                    model_load.symbolic_fun[l].funs_sympy[j][i] = SYMBOLIC_LIB[fun_name][1]
+                    model_load.symbolic_fun[l].funs_avoid_singularity[j][i] = SYMBOLIC_LIB[fun_name][3]
+        return model_load
+    
+    def rewind(self, model_id):
+        
+        self.round += 1
+        self.state_id = model_id.split('.')[-1]
+        
+        history_path = self.ckpt_path+'/history.txt'
+        with open(history_path, 'a') as file:
+            file.write(f'### Round {self.round} ###' + '\n')
+
+        self.saveckpt(path=self.ckpt_path+'/'+f'{self.round}.{self.state_id}')
+        
+        print('rewind to model version '+f'{self.round-1}.{self.state_id}'+', renamed as '+f'{self.round}.{self.state_id}')
+
+        return MultKAN.loadckpt(path=self.ckpt_path+'/'+str(model_id))
+    
+    
+    def checkout(self, model_id):
+        return MultKAN.loadckpt(path=self.ckpt_path+'/'+str(model_id))
 
     @property
     def width_in(self):
@@ -285,6 +353,7 @@ def feature_score(self):
     
     def update_grid_from_samples(self, x):
         for l in range(self.depth):
+            #print(l)
             self.forward(x)
             self.act_fun[l].update_grid_from_samples(self.acts[l])
 
@@ -326,14 +395,14 @@ def forward(self, x, singularity_avoiding=False, y_th=10.):
 
             x = x_numerical + x_symbolic
             
-            if self.save_plot_data:
+            if self.save_act:
                 # save subnode_scale
                 self.subnode_actscale.append(torch.std(x, dim=0).detach())
             
             # subnode affine transform
             x = self.subnode_scale[l][None,:] * x + self.subnode_bias[l][None,:]
             
-            if self.save_plot_data:
+            if self.save_act:
                 postacts = postacts_numerical + postacts_symbolic
 
                 # self.neurons_scale.append(torch.mean(torch.abs(x), dim=0))
@@ -454,11 +523,13 @@ def plot(self, folder="./figures", beta=3, mask=False, metric='fa', scale=0.5, t
         
         global Symbol
         
-        if not self.save_plot_data:
-            print('cannot plot since data are not saved. Set save_plot_data=True first.')
+        if not self.save_act:
+            print('cannot plot since data are not saved. Set save_act=True first.')
         
         # forward to obtain activations
         if self.acts == None:
+            if self.cache_data == None:
+                raise Exception('model hasn\'t seen any data yet.')
             self.forward(self.cache_data)
             
         if metric == 'fa':
@@ -713,11 +784,32 @@ def score2alpha(score):
         if title != None:
             plt.gcf().get_axes()[0].text(0.5, (y0+z0) * (len(self.width) - 1) + 0.3, title, fontsize=40 * scale, horizontalalignment='center', verticalalignment='center')
 
+            
+            
+            
+            
     def fit(self, dataset, opt="LBFGS", steps=100, log=1, lamb=0., lamb_l1=1., lamb_entropy=2., lamb_coef=0., lamb_coefdiff=0., update_grid=True, grid_update_num=10, loss_fn=None, lr=1.,start_grid_update_step=-1, stop_grid_update_step=50, batch=-1,
-              small_mag_threshold=1e-16, small_reg_factor=1., metrics=None, save_fig=False, in_vars=None, out_vars=None, beta=3, save_fig_freq=1, img_folder='./video', device='cpu', singularity_avoiding=False, y_th=1000., reg_metric='fa'):
+              small_mag_threshold=1e-16, small_reg_factor=1., metrics=None, save_fig=False, in_vars=None, out_vars=None, beta=3, save_fig_freq=1, img_folder='./video', device='cpu', singularity_avoiding=False, y_th=1000., reg_metric='fa', display_metrics=None):
+
+        if lamb > 0. and not self.save_act:
+            print('setting lamb=0. If you want to set lamb > 0, set self.save_act=True')
+            
+        old_save_act = self.save_act
+        if lamb == 0.:
+            self.save_act = False
+            
+            
+        # skip symbolic if no symbolic is turned on
+        depth = len(self.symbolic_fun)
+        no_symbolic = True
+        for l in range(depth):
+            no_symbolic *= torch.sum(torch.abs(self.symbolic_fun[l].mask)) == 0
+
+        old_symbolic_enabled = self.symbolic_enabled
+
+        if no_symbolic:
+            self.symbolic_enabled = False
 
-        if lamb > 0. and not self.save_plot_data:
-            print('setting lamb=0. If you want to set lamb > 0, set self.save_plot_data=True')
         
         def reg(acts_scale):
 
@@ -782,7 +874,7 @@ def closure():
             optimizer.zero_grad()
             pred = self.forward(dataset['train_input'][train_id].to(self.device), singularity_avoiding=singularity_avoiding, y_th=y_th)
             train_loss = loss_fn(pred, dataset['train_label'][train_id].to(self.device))
-            if self.save_plot_data:
+            if self.save_act:
                 if reg_metric == 'act':
                     reg_ = reg(self.acts_scale_spline)
                 if reg_metric == 'fa':
@@ -798,8 +890,13 @@ def closure():
             if not os.path.exists(img_folder):
                 os.makedirs(img_folder)
 
+        
+        
         for _ in pbar:
-
+            
+            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)
 
@@ -812,7 +909,7 @@ def closure():
             if opt == "Adam":
                 pred = self.forward(dataset['train_input'][train_id].to(self.device), singularity_avoiding=singularity_avoiding, y_th=y_th)
                 train_loss = loss_fn(pred, dataset['train_label'][train_id].to(self.device))
-                if self.save_plot_data:
+                if self.save_act:
                     if reg_metric == 'act':
                         reg_ = reg(self.acts_scale_spline)
                     if reg_metric == 'fa':
@@ -826,10 +923,8 @@ def closure():
                 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))
-
-            if _ % log == 0:
-                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()))
-
+            
+            
             if metrics != None:
                 for i in range(len(metrics)):
                     results[metrics[i].__name__].append(metrics[i]().item())
@@ -838,16 +933,38 @@ def closure():
             results['test_loss'].append(torch.sqrt(test_loss).cpu().detach().numpy())
             results['reg'].append(reg_.cpu().detach().numpy())
 
+            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()))
+                else:
+                    string = ''
+                    data = ()
+                    for metric in display_metrics:
+                        string += f' {metric}: %.2e |'
+                        try:
+                            results[metric]
+                        except:
+                            raise Exception(f'{metric} not recognized')
+                        data += (results[metric][-1],)
+                    pbar.set_description(string % data)
+                    
+                
+            
             if save_fig and _ % save_fig_freq == 0:
                 self.plot(folder=img_folder, in_vars=in_vars, out_vars=out_vars, title="Step {}".format(_), beta=beta)
                 plt.savefig(img_folder + '/' + str(_) + '.jpg', bbox_inches='tight', dpi=200)
                 plt.close()
 
-        self.log_history('train')
+        self.log_history('fit')
+        # revert back to original state
+        self.symbolic_enabled = old_symbolic_enabled
         return results
 
     def prune_node(self, threshold=1e-2, mode="auto", active_neurons_id=None, log_history=True):
 
+        if self.acts == None:
+            self.get_act()
+        
         mask_up = [torch.ones(self.width_in[0], )]
         mask_down = []
         active_neurons_up = [list(range(self.width_in[0]))]
@@ -915,7 +1032,7 @@ def prune_node(self, threshold=1e-2, mode="auto", active_neurons_id=None, log_hi
                 if i not in active_neurons_down[l]:
                     self.remove_node(l + 1, i, mode='down',log_history=False)
 
-        model2 = MultKAN(copy.deepcopy(self.width), grid=self.grid, k=self.k, base_fun=self.base_fun_name, device=self.device, mult_arity=self.mult_arity, ckpt_path=self.ckpt_path, auto_save=True, first_init=False, state_id=self.state_id)
+        model2 = MultKAN(copy.deepcopy(self.width), grid=self.grid, k=self.k, base_fun=self.base_fun_name, device=self.device, mult_arity=self.mult_arity, ckpt_path=self.ckpt_path, auto_save=True, first_init=False, state_id=self.state_id, round=self.round)
         model2.load_state_dict(self.state_dict())
         
         width_new = [self.width[0]]
@@ -958,6 +1075,10 @@ def prune_node(self, threshold=1e-2, mode="auto", active_neurons_id=None, log_hi
         return model2
     
     def prune_edge(self, threshold=3e-2, log_history=True):
+        
+        if self.acts == None:
+            self.get_act()
+        
         for i in range(len(self.width)-1):
             #self.act_fun[i].mask.data = ((self.acts_scale[i] > threshold).permute(1,0)).float()
             old_mask = self.act_fun[i].mask.data
@@ -967,6 +1088,10 @@ def prune_edge(self, threshold=3e-2, log_history=True):
             self.log_history('fix_symbolic')
     
     def prune(self, node_th=1e-2, edge_th=3e-2):
+        
+        if self.acts == None:
+            self.get_act()
+        
         self = self.prune_node(node_th, log_history=False)
         #self.prune_node(node_th, log_history=False)
         self.forward(self.cache_data)
@@ -987,7 +1112,7 @@ def prune_input(self, threshold=1e-2, active_inputs=None, log_history=True):
         else:
             input_id = torch.tensor(active_inputs, dtype=torch.long)
         
-        model2 = MultKAN(copy.deepcopy(self.width), grid=self.grid, k=self.k, base_fun=self.base_fun, device=self.device, mult_arity=self.mult_arity, ckpt_path=self.ckpt_path, auto_save=True, first_init=False, state_id=self.state_id)
+        model2 = MultKAN(copy.deepcopy(self.width), grid=self.grid, k=self.k, base_fun=self.base_fun, device=self.device, mult_arity=self.mult_arity, ckpt_path=self.ckpt_path, auto_save=True, first_init=False, state_id=self.state_id, round=self.round)
         model2.load_state_dict(self.state_dict())
 
         model2.act_fun[0] = model2.act_fun[0].get_subset(input_id, torch.arange(self.width_out[1]))
@@ -1030,7 +1155,7 @@ def remove_node(self, l ,i, mode='all', log_history=True):
     def attribute(self):
         
         if self.acts == None:
-            print('the model has not seen any data yet :). Do you forward pass first with model(data).')
+            self.get_act()
 
         def score_node2subnode(node_score, width, mult_arity):
 
@@ -1484,17 +1609,25 @@ def tree(self, x=None, in_var=None, style='tree', sym_th=1e-3, sep_th=1e-1):
         
     def speed(self, compile=False):
         self.symbolic_enabled=False
-        self.save_plot_data=False
+        self.save_act=False
         self.auto_save=False
         if compile == True:
             return torch.compile(self)
         else:
             return self
         
-    def get_act(self, x):
+    def get_act(self, x=None):
         if isinstance(x, dict):
             x = x['train_input']
+        if x == None:
+            if self.cache_data != None:
+                x = self.cache_data
+            else:
+                raise Exception("missing input data x")
+        save_act = self.save_act
+        self.save_act = True
         self.forward(x)
+        self.save_act = save_act
         
     def get_fun(self, l, i, j):
         inputs = self.spline_preacts[l][:,j,i]
@@ -1507,4 +1640,32 @@ def get_fun(self, l, i, j):
         plt.plot(inputs, outputs, marker="o")
         return inputs, outputs
         
+        
+    def history(self, k='all'):
+        
+        with open(self.ckpt_path+'/history.txt', 'r') as f:
+            data = f.readlines()
+            n_line = len(data)
+            if k == 'all':
+                k = n_line
+
+            data = data[-k:]
+            for line in data:
+                print(line[:-1])
+    @property
+    def n_edge(self):
+        depth = len(self.act_fun)
+        complexity = 0
+        for l in range(depth):
+            complexity += torch.sum(self.act_fun[l].mask > 0.)
+        return complexity.item()
+    
+    def evaluate(self, dataset):
+        evaluation = {}
+        evaluation['test_loss'] = torch.sqrt(torch.mean((self.forward(dataset['test_input']) - dataset['test_label'])**2)).item()
+        evaluation['n_edge'] = self.n_edge
+        evaluation['n_grid'] = self.grid
+        # add other metrics (maybe accuracy)
+        return evaluation
+
 KAN = MultKAN
diff --git a/kan/experiment.py b/kan/experiment.py
new file mode 100644
index 00000000..9ab9e9de
--- /dev/null
+++ b/kan/experiment.py
@@ -0,0 +1,55 @@
+import torch
+from .MultKAN import *
+
+
+def runner1(width, dataset, grids=[5,10,20], steps=20, lamb=0.001, prune_round=3, refine_round=3, edge_th=1e-2, node_th=1e-2, metrics=None, seed=1):
+
+    result = {}
+    result['test_loss'] = []
+    result['c'] = []
+    result['G'] = []
+    result['id'] = []
+    if metrics != None:
+        for i in range(len(metrics)):
+            result[metrics[i].__name__] = []
+
+    def collect(evaluation):
+        result['test_loss'].append(evaluation['test_loss'])
+        result['c'].append(evaluation['n_edge'])
+        result['G'].append(evaluation['n_grid'])
+        result['id'].append(f'{model.round}.{model.state_id}')
+        if metrics != None:
+            for i in range(len(metrics)):
+                result[metrics[i].__name__].append(metrics[i](model, dataset).item())
+
+    for i in range(prune_round):
+        # train and prune
+        if i == 0:
+            model = KAN(width=width, grid=grids[0], seed=seed)
+        else:
+            model = model.rewind(f'{i-1}.{2*i}')
+
+        model.fit(dataset, steps=steps, lamb=lamb)
+        model = model.prune(edge_th=edge_th, node_th=node_th)
+        evaluation = model.evaluate(dataset)
+        collect(evaluation)
+
+        for j in range(refine_round):
+            model = model.refine(grids[j])
+            model.fit(dataset, steps=steps)
+            evaluation = model.evaluate(dataset)
+            collect(evaluation)
+
+    for key in list(result.keys()):
+        result[key] = np.array(result[key])
+
+    return result
+
+
+def pareto_frontier(x,y):
+
+    pf_id = np.where(np.sum((x[:,None] <= x[None,:]) * (y[:,None] <= y[None,:]), axis=0) == 1)[0]
+    x_pf = x[pf_id]
+    y_pf = y[pf_id]
+
+    return x_pf, y_pf, pf_id
\ No newline at end of file
diff --git a/kan/spline.py b/kan/spline.py
index 4cac8f3d..4cfbc01f 100644
--- a/kan/spline.py
+++ b/kan/spline.py
@@ -70,6 +70,9 @@ def extend_grid(grid, k_extend=0):
         
         value = (x - grid[:, :, :-(k + 1)]) / (grid[:, :, k:-1] - grid[:, :, :-(k + 1)]) * B_km1[:, :, :-1] + (
                     grid[:, :, k + 1:] - x) / (grid[:, :, k + 1:] - grid[:, :, 1:(-k)]) * B_km1[:, :, 1:]
+    
+    # in case grid is degenerate
+    value = torch.nan_to_num(value)
     return value
 
 
@@ -164,6 +167,7 @@ def curve2coef(x_eval, y_eval, grid, k, device="cpu"):
     mat = mat.permute(1,0,2)[:,None,:,:].expand(in_dim, out_dim, batch, n_coef) # (in_dim, out_dim, batch, n_coef)
     # coef shape: (in_dim, outdim, G+k) 
     y_eval = y_eval.permute(1,2,0).unsqueeze(dim=3) # y_eval: (in_dim, out_dim, batch, 1)
+    #print(mat)
     coef = torch.linalg.lstsq(mat.to(device), y_eval.to(device),
                               driver='gelsy' if device == 'cpu' else 'gels').solution[:,:,:,0]
     return coef.to(device)
diff --git a/tutorials/.ipynb_checkpoints/Example_14_knot_supervised-checkpoint.ipynb b/tutorials/.ipynb_checkpoints/Example_14_knot_supervised-checkpoint.ipynb
new file mode 100644
index 00000000..2cd85919
--- /dev/null
+++ b/tutorials/.ipynb_checkpoints/Example_14_knot_supervised-checkpoint.ipynb
@@ -0,0 +1,188 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "0893a344",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import pandas as pd\n",
+    "import numpy as np\n",
+    "import torch\n",
+    "from kan import *\n",
+    "import copy\n",
+    "\n",
+    "\n",
+    "seed = 42\n",
+    "torch.manual_seed(seed)\n",
+    "np.random.seed(seed)\n",
+    "\n",
+    "# Download data: https://colab.research.google.com/github/deepmind/mathematics_conjectures/blob/main/knot_theory.ipynb#scrollTo=l10N2ZbHu6Ob\n",
+    "df = pd.read_csv(\"./knot_data.csv\")\n",
+    "df.keys()\n",
+    "\n",
+    "X = df[df.keys()[1:-1]].to_numpy()\n",
+    "Y = df[['signature']].to_numpy()\n",
+    "\n",
+    "# normalize X\n",
+    "X_mean = np.mean(X, axis=0)\n",
+    "X_std = np.std(X, axis=0)\n",
+    "X = (X - X_mean[np.newaxis,:])/X_std[np.newaxis,:]\n",
+    "input_normalier = [X_mean, X_std]\n",
+    "\n",
+    "# normalize Y\n",
+    "max_signature = np.max(Y)\n",
+    "min_signature = np.min(Y)\n",
+    "Y = ((Y-min_signature)/2).astype(int)\n",
+    "n_class = int((max_signature-min_signature)/2+1)\n",
+    "output_normalier = [min_signature, 2]\n",
+    "\n",
+    "dataset = {}\n",
+    "num = X.shape[0]\n",
+    "n_feature = X.shape[1]\n",
+    "train_ratio = 0.8\n",
+    "train_id_ = np.random.choice(num, int(num*train_ratio), replace=False)\n",
+    "test_id_ = np.array(list(set(range(num))-set(train_id_)))\n",
+    "\n",
+    "dtype = torch.get_default_dtype()\n",
+    "dataset['train_input'] = torch.from_numpy(X[train_id_]).type(dtype)\n",
+    "dataset['train_label'] = torch.from_numpy(Y[train_id_][:,0]).type(torch.long)\n",
+    "dataset['test_input'] = torch.from_numpy(X[test_id_]).type(dtype)\n",
+    "dataset['test_label'] = torch.from_numpy(Y[test_id_][:,0]).type(torch.long)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "e262aeca",
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "checkpoint directory created: ./model\n",
+      "saving model version 0.0\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " train_loss: 7.68e-01 | reg: 3.85e+01 | train_acc: 7.62e-01 | test_acc: 7.66e-01 |: 100%|█| 100/100 "
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "saving model version 0.1\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "def train_acc():\n",
+    "    return torch.mean((torch.argmax(model(dataset['train_input']), dim=1) == dataset['train_label']).float())\n",
+    "\n",
+    "def test_acc():\n",
+    "    return torch.mean((torch.argmax(model(dataset['test_input']), dim=1) == dataset['test_label']).float())\n",
+    "\n",
+    "model = KAN(width=[n_feature,1,n_class], grid=5, k=3, seed=seed)\n",
+    "model.fit(dataset, lamb=0.005, batch=1024, loss_fn = nn.CrossEntropyLoss(), metrics=[train_acc, test_acc], display_metrics=['train_loss', 'reg', 'train_acc', 'test_acc']);"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "2254d060",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1000x800 with 47 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "model.plot(scale=1.0, beta=0.2)\n",
+    "\n",
+    "n = 17\n",
+    "for i in range(n):\n",
+    "    plt.gcf().get_axes()[0].text(1/(2*n)+i/n-0.005,-0.02,df.keys()[1:-1][i], rotation=270, rotation_mode=\"anchor\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "54778a24",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Text(0, 0.5, 'feature importance')"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "scores = model.feature_score\n",
+    "features = list(df.keys()[1:-1])\n",
+    "\n",
+    "y_pos = range(len(features))\n",
+    "plt.bar(y_pos, scores)\n",
+    "plt.xticks(y_pos, features, rotation=90);\n",
+    "plt.ylabel('feature importance')"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.7"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/tutorials/.ipynb_checkpoints/Example_15_knot_unsupervised-checkpoint.ipynb b/tutorials/.ipynb_checkpoints/Example_15_knot_unsupervised-checkpoint.ipynb
new file mode 100644
index 00000000..ca9b7175
--- /dev/null
+++ b/tutorials/.ipynb_checkpoints/Example_15_knot_unsupervised-checkpoint.ipynb
@@ -0,0 +1,163 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "id": "0893a344",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import pandas as pd\n",
+    "import numpy as np\n",
+    "import torch\n",
+    "from kan import *\n",
+    "import copy\n",
+    "\n",
+    "\n",
+    "seed = 2024\n",
+    "torch.manual_seed(seed)\n",
+    "np.random.seed(seed)\n",
+    "\n",
+    "dtype = torch.get_default_dtype()\n",
+    "\n",
+    "# Download data: https://colab.research.google.com/github/deepmind/mathematics_conjectures/blob/main/knot_theory.ipynb#scrollTo=l10N2ZbHu6Ob\n",
+    "df = pd.read_csv(\"./knot_data.csv\")\n",
+    "df.keys()\n",
+    "\n",
+    "X = df[df.keys()[1:]].to_numpy()\n",
+    "mean = np.mean(X, axis=0)\n",
+    "std = np.std(X, axis=0)\n",
+    "X = (X - mean[np.newaxis,:])/std[np.newaxis,:]\n",
+    "\n",
+    "# normalize X\n",
+    "X_mean = np.mean(X, axis=0)\n",
+    "X_std = np.std(X, axis=0)\n",
+    "X = (X - X_mean[np.newaxis,:])/X_std[np.newaxis,:]\n",
+    "input_normalier = [X_mean, X_std]\n",
+    "\n",
+    "dataset = {}\n",
+    "num = X.shape[0]\n",
+    "n_feature = X.shape[1]\n",
+    "train_ratio = 0.8\n",
+    "train_id_ = np.random.choice(num, int(num*train_ratio), replace=False)\n",
+    "test_id_ = np.array(list(set(range(num))-set(train_id_)))\n",
+    "dataset['train_input'] = torch.from_numpy(X[train_id_]).type(dtype)\n",
+    "dataset['test_input'] = torch.from_numpy(X[test_id_]).type(dtype)\n",
+    "\n",
+    "def construct_contrastive_dataset(tensor):\n",
+    "    y = copy.deepcopy(tensor)\n",
+    "    for i in range(y.shape[1]):\n",
+    "        y[:,i] = y[:,i][torch.randperm(y.shape[0])]\n",
+    "    return y\n",
+    "\n",
+    "dataset['contrastive_train_input'] = construct_contrastive_dataset(dataset['train_input'])\n",
+    "dataset['contrastive_test_input'] = construct_contrastive_dataset(dataset['test_input'])\n",
+    "\n",
+    "dataset['train_label'] = torch.cat([torch.ones(dataset['train_input'].shape[0],1), torch.zeros(dataset['contrastive_train_input'].shape[0],1)], dim=0)\n",
+    "dataset['train_input'] = torch.cat([dataset['train_input'], dataset['contrastive_train_input']], dim=0)\n",
+    "\n",
+    "dataset['test_label'] = torch.cat([torch.ones(dataset['test_input'].shape[0],1), torch.zeros(dataset['contrastive_test_input'].shape[0],1)], dim=0)\n",
+    "dataset['test_input'] = torch.cat([dataset['test_input'], dataset['contrastive_test_input']], dim=0)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e262aeca",
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "checkpoint directory created: ./model\n",
+      "saving model version 0.0\n",
+      "saving model version 0.1\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " train_loss: 1.70e-01 | reg: 1.34e+01 | train_acc: 9.68e-01 | test_acc: 9.69e-01 |:  74%|▋| 74/100 ["
+     ]
+    }
+   ],
+   "source": [
+    "def train_acc():\n",
+    "    return torch.mean(((model(dataset['train_input']) > 0.5) == dataset['train_label']).float())\n",
+    "\n",
+    "def test_acc():\n",
+    "    return torch.mean(((model(dataset['test_input']) > 0.5) == dataset['test_label']).float())\n",
+    "\n",
+    "model = KAN(width=[n_feature,1,1], grid=5, k=3, seed=seed)\n",
+    "model.fix_symbolic(1,0,0,'gaussian',fit_params_bool=False)\n",
+    "model.fit(dataset, lamb=0.001, batch=1024, metrics=[train_acc, test_acc], display_metrics=['train_loss', 'reg', 'train_acc', 'test_acc']);"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "1ede24f0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# seed = 2024\n",
+    "model.plot(scale=1.0)\n",
+    "\n",
+    "n = 18\n",
+    "for i in range(n):\n",
+    "    plt.gcf().get_axes()[0].text(1/(2*n)+i/n-0.005,-0.02,df.keys()[1:][i], rotation=270, rotation_mode=\"anchor\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "id": "a3fb6b7a",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1000x800 with 22 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# seed = 0\n",
+    "model.plot(scale=1.0)\n",
+    "\n",
+    "n = 18\n",
+    "for i in range(n):\n",
+    "    plt.gcf().get_axes()[0].text(1/(2*n)+i/n-0.005,-0.02,df.keys()[1:][i], rotation=270, rotation_mode=\"anchor\")"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.7"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/tutorials/Example_14_knot_supervised.ipynb b/tutorials/Example_14_knot_supervised.ipynb
new file mode 100644
index 00000000..2cd85919
--- /dev/null
+++ b/tutorials/Example_14_knot_supervised.ipynb
@@ -0,0 +1,188 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "0893a344",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import pandas as pd\n",
+    "import numpy as np\n",
+    "import torch\n",
+    "from kan import *\n",
+    "import copy\n",
+    "\n",
+    "\n",
+    "seed = 42\n",
+    "torch.manual_seed(seed)\n",
+    "np.random.seed(seed)\n",
+    "\n",
+    "# Download data: https://colab.research.google.com/github/deepmind/mathematics_conjectures/blob/main/knot_theory.ipynb#scrollTo=l10N2ZbHu6Ob\n",
+    "df = pd.read_csv(\"./knot_data.csv\")\n",
+    "df.keys()\n",
+    "\n",
+    "X = df[df.keys()[1:-1]].to_numpy()\n",
+    "Y = df[['signature']].to_numpy()\n",
+    "\n",
+    "# normalize X\n",
+    "X_mean = np.mean(X, axis=0)\n",
+    "X_std = np.std(X, axis=0)\n",
+    "X = (X - X_mean[np.newaxis,:])/X_std[np.newaxis,:]\n",
+    "input_normalier = [X_mean, X_std]\n",
+    "\n",
+    "# normalize Y\n",
+    "max_signature = np.max(Y)\n",
+    "min_signature = np.min(Y)\n",
+    "Y = ((Y-min_signature)/2).astype(int)\n",
+    "n_class = int((max_signature-min_signature)/2+1)\n",
+    "output_normalier = [min_signature, 2]\n",
+    "\n",
+    "dataset = {}\n",
+    "num = X.shape[0]\n",
+    "n_feature = X.shape[1]\n",
+    "train_ratio = 0.8\n",
+    "train_id_ = np.random.choice(num, int(num*train_ratio), replace=False)\n",
+    "test_id_ = np.array(list(set(range(num))-set(train_id_)))\n",
+    "\n",
+    "dtype = torch.get_default_dtype()\n",
+    "dataset['train_input'] = torch.from_numpy(X[train_id_]).type(dtype)\n",
+    "dataset['train_label'] = torch.from_numpy(Y[train_id_][:,0]).type(torch.long)\n",
+    "dataset['test_input'] = torch.from_numpy(X[test_id_]).type(dtype)\n",
+    "dataset['test_label'] = torch.from_numpy(Y[test_id_][:,0]).type(torch.long)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "e262aeca",
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "checkpoint directory created: ./model\n",
+      "saving model version 0.0\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " train_loss: 7.68e-01 | reg: 3.85e+01 | train_acc: 7.62e-01 | test_acc: 7.66e-01 |: 100%|█| 100/100 "
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "saving model version 0.1\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "def train_acc():\n",
+    "    return torch.mean((torch.argmax(model(dataset['train_input']), dim=1) == dataset['train_label']).float())\n",
+    "\n",
+    "def test_acc():\n",
+    "    return torch.mean((torch.argmax(model(dataset['test_input']), dim=1) == dataset['test_label']).float())\n",
+    "\n",
+    "model = KAN(width=[n_feature,1,n_class], grid=5, k=3, seed=seed)\n",
+    "model.fit(dataset, lamb=0.005, batch=1024, loss_fn = nn.CrossEntropyLoss(), metrics=[train_acc, test_acc], display_metrics=['train_loss', 'reg', 'train_acc', 'test_acc']);"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "2254d060",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1000x800 with 47 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "model.plot(scale=1.0, beta=0.2)\n",
+    "\n",
+    "n = 17\n",
+    "for i in range(n):\n",
+    "    plt.gcf().get_axes()[0].text(1/(2*n)+i/n-0.005,-0.02,df.keys()[1:-1][i], rotation=270, rotation_mode=\"anchor\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "54778a24",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Text(0, 0.5, 'feature importance')"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "scores = model.feature_score\n",
+    "features = list(df.keys()[1:-1])\n",
+    "\n",
+    "y_pos = range(len(features))\n",
+    "plt.bar(y_pos, scores)\n",
+    "plt.xticks(y_pos, features, rotation=90);\n",
+    "plt.ylabel('feature importance')"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.7"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/tutorials/Example_15_knot_unsupervised.ipynb b/tutorials/Example_15_knot_unsupervised.ipynb
new file mode 100644
index 00000000..ca9b7175
--- /dev/null
+++ b/tutorials/Example_15_knot_unsupervised.ipynb
@@ -0,0 +1,163 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "id": "0893a344",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import pandas as pd\n",
+    "import numpy as np\n",
+    "import torch\n",
+    "from kan import *\n",
+    "import copy\n",
+    "\n",
+    "\n",
+    "seed = 2024\n",
+    "torch.manual_seed(seed)\n",
+    "np.random.seed(seed)\n",
+    "\n",
+    "dtype = torch.get_default_dtype()\n",
+    "\n",
+    "# Download data: https://colab.research.google.com/github/deepmind/mathematics_conjectures/blob/main/knot_theory.ipynb#scrollTo=l10N2ZbHu6Ob\n",
+    "df = pd.read_csv(\"./knot_data.csv\")\n",
+    "df.keys()\n",
+    "\n",
+    "X = df[df.keys()[1:]].to_numpy()\n",
+    "mean = np.mean(X, axis=0)\n",
+    "std = np.std(X, axis=0)\n",
+    "X = (X - mean[np.newaxis,:])/std[np.newaxis,:]\n",
+    "\n",
+    "# normalize X\n",
+    "X_mean = np.mean(X, axis=0)\n",
+    "X_std = np.std(X, axis=0)\n",
+    "X = (X - X_mean[np.newaxis,:])/X_std[np.newaxis,:]\n",
+    "input_normalier = [X_mean, X_std]\n",
+    "\n",
+    "dataset = {}\n",
+    "num = X.shape[0]\n",
+    "n_feature = X.shape[1]\n",
+    "train_ratio = 0.8\n",
+    "train_id_ = np.random.choice(num, int(num*train_ratio), replace=False)\n",
+    "test_id_ = np.array(list(set(range(num))-set(train_id_)))\n",
+    "dataset['train_input'] = torch.from_numpy(X[train_id_]).type(dtype)\n",
+    "dataset['test_input'] = torch.from_numpy(X[test_id_]).type(dtype)\n",
+    "\n",
+    "def construct_contrastive_dataset(tensor):\n",
+    "    y = copy.deepcopy(tensor)\n",
+    "    for i in range(y.shape[1]):\n",
+    "        y[:,i] = y[:,i][torch.randperm(y.shape[0])]\n",
+    "    return y\n",
+    "\n",
+    "dataset['contrastive_train_input'] = construct_contrastive_dataset(dataset['train_input'])\n",
+    "dataset['contrastive_test_input'] = construct_contrastive_dataset(dataset['test_input'])\n",
+    "\n",
+    "dataset['train_label'] = torch.cat([torch.ones(dataset['train_input'].shape[0],1), torch.zeros(dataset['contrastive_train_input'].shape[0],1)], dim=0)\n",
+    "dataset['train_input'] = torch.cat([dataset['train_input'], dataset['contrastive_train_input']], dim=0)\n",
+    "\n",
+    "dataset['test_label'] = torch.cat([torch.ones(dataset['test_input'].shape[0],1), torch.zeros(dataset['contrastive_test_input'].shape[0],1)], dim=0)\n",
+    "dataset['test_input'] = torch.cat([dataset['test_input'], dataset['contrastive_test_input']], dim=0)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e262aeca",
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "checkpoint directory created: ./model\n",
+      "saving model version 0.0\n",
+      "saving model version 0.1\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " train_loss: 1.70e-01 | reg: 1.34e+01 | train_acc: 9.68e-01 | test_acc: 9.69e-01 |:  74%|▋| 74/100 ["
+     ]
+    }
+   ],
+   "source": [
+    "def train_acc():\n",
+    "    return torch.mean(((model(dataset['train_input']) > 0.5) == dataset['train_label']).float())\n",
+    "\n",
+    "def test_acc():\n",
+    "    return torch.mean(((model(dataset['test_input']) > 0.5) == dataset['test_label']).float())\n",
+    "\n",
+    "model = KAN(width=[n_feature,1,1], grid=5, k=3, seed=seed)\n",
+    "model.fix_symbolic(1,0,0,'gaussian',fit_params_bool=False)\n",
+    "model.fit(dataset, lamb=0.001, batch=1024, metrics=[train_acc, test_acc], display_metrics=['train_loss', 'reg', 'train_acc', 'test_acc']);"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "1ede24f0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# seed = 2024\n",
+    "model.plot(scale=1.0)\n",
+    "\n",
+    "n = 18\n",
+    "for i in range(n):\n",
+    "    plt.gcf().get_axes()[0].text(1/(2*n)+i/n-0.005,-0.02,df.keys()[1:][i], rotation=270, rotation_mode=\"anchor\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "id": "a3fb6b7a",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1000x800 with 22 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# seed = 0\n",
+    "model.plot(scale=1.0)\n",
+    "\n",
+    "n = 18\n",
+    "for i in range(n):\n",
+    "    plt.gcf().get_axes()[0].text(1/(2*n)+i/n-0.005,-0.02,df.keys()[1:][i], rotation=270, rotation_mode=\"anchor\")"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.7"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}