Upload data/dataset_Biochemistry.csv with huggingface_hub

data/dataset_Biochemistry.csv

@@ -0,0 +1,968 @@
+"keyword","repo_name","file_path","file_extension","file_size","line_count","content","language"
+"Biochemistry","Bin-Cao/TCLRmodel","Template/Execution template/template.py",".py","5138","104","#coding=utf-8
+from TCLR import TCLRalgorithm as model
+
+
+""""""
+    :param correlation : {'PearsonR(+)','PearsonR(-)',''MIC','R2'}，default PearsonR(+).
+            Methods:
+            * PearsonR: (+)(-). for linear relationship.
+            * MIC for no-linear relationship.
+            * R2 for no-linear relationship.
+
+    :param tolerance_list: constraints imposed on features, default is null
+            list shape in two dimensions, viz., [[constraint_1,tol_1],[constraint_2,tol_2]...]
+            constraint_1, constraint_2 （string） are the feature name ; 
+            tol_1, tol_2 （float）are feature's tolerance ratios;
+            relative variation range of features must be within the tolerance;
+            example: tolerance_list = [['feature_name1',0.2],['feature_name2',0.1]].
+    
+    :param gpl_dummyfea: dummy features in gpleran regression, default is null
+            list shape in one dimension, viz., ['feature_name1','feature_name2',...]
+            dummy features : 'feature_name1','feature_name2',... are not used anymore in gpleran regression     
+            
+    :param minsize : a int number (default=3), minimum unique values for linear features of data on each leaf.
+    
+    :param threshold : a float (default=0.9), less than or equal to 1, default 0.95 for PearsonR.
+            In the process of dividing the dataset, the smallest relevant index allowed in the you research.
+            To avoid overfitting, threshold = 0.5 is suggested for MIC 0.5.
+    
+    :param mininc : Minimum expected gain of objective function (default=0.01)
+    
+    :param split_tol : a float (default=0.8), constrained features value shound be narrowed in a minmimu ratio of split_tol on split path
+
+    :param gplearn : Whether to call the embedded gplearn package of TCLR to regress formula (default=False).
+    
+    :param population_size : integer, optional (default=500), the number of programs in each generation.
+    
+    :param generations : integer, optional (default=100),the number of generations to evolve.
+
+    :param verbose : int, optional (default=0). Controls the verbosity of the evolution building process.
+    
+    :param metric : str, optional (default='mean absolute error')
+            The name of the raw fitness metric. Available options include:
+            - 'mean absolute error'.
+            - 'mse' for mean squared error.
+            - 'rmse' for root mean squared error.
+            - 'pearson', for Pearson's product-moment correlation coefficient.
+            - 'spearman' for Spearman's rank-order correlation coefficient.
+    
+    :param function_set : iterable, optional (default=['add', 'sub', 'mul', 'div', 'log', 'sqrt', 
+                                               'abs', 'neg','inv','sin','cos','tan', 'max', 'min'])
+            The functions to use when building and evolving programs. This iterable can include strings 
+            to indicate either individual functions as outlined below.
+            Available individual functions are:
+            - 'add' : addition, arity=2.
+            - 'sub' : subtraction, arity=2.
+            - 'mul' : multiplication, arity=2.
+            - 'div' : protected division where a denominator near-zero returns 1.,
+                arity=2.
+            - 'sqrt' : protected square root where the absolute value of the
+                argument is used, arity=1.
+            - 'log' : protected log where the absolute value of the argument is
+                used and a near-zero argument returns 0., arity=1.
+            - 'abs' : absolute value, arity=1.
+            - 'neg' : negative, arity=1.
+            - 'inv' : protected inverse where a near-zero argument returns 0.,
+                arity=1.
+            - 'max' : maximum, arity=2.
+            - 'min' : minimum, arity=2.
+            - 'sin' : sine (radians), arity=1.
+            - 'cos' : cosine (radians), arity=1.
+            - 'tan' : tangent (radians), arity=1.
+
+    Algorithm Patent No. : 2021SR1951267, China
+    Reference : Domain knowledge guided interpretive machine learning ——  Formula discovery for the oxidation behavior of Ferritic-Martensitic steels in supercritical water. Bin Cao et al., 2022, JMI, journal paper.
+    DOI : 10.20517/jmi.2022.04
+""""""
+
+
+dataSet = ""testdata.csv""
+correlation = 'PearsonR(+)'
+tolerance_list = [
+    ['E_Cr_split_feature_1',0.001],
+]
+
+gpl_dummyfea = ['ln(t)_split_feature_4',]
+minsize = 3
+threshold = 0.9
+mininc = 0.01
+split_tol = 0.8
+gplearn = True
+population_size = 500
+generations = 100
+verbose = 1 
+metric = 'mean absolute error'
+function_set = ['add', 'sub', 'mul', 'div', 'log', 'sqrt', 'abs', 'neg','inv','sin','cos','tan', 'max', 'min']
+
+
+model.start(filePath = dataSet, correlation = correlation, tolerance_list = tolerance_list, gpl_dummyfea = gpl_dummyfea, minsize = minsize, threshold = threshold,
+            mininc = mininc ,split_tol = split_tol, gplearn = gplearn,  population_size = population_size,
+            generations = generations,verbose = verbose, metric =metric, function_set =function_set)
+
+
+
+","Python"
+"Biochemistry","Bin-Cao/TCLRmodel","TCLR/TCLRalgorithm.py",".py","38792","861","""""""
+    Tree Classifier for Linear Regression (TCLR) 
+    Author : Bin CAO ([email protected]) 
+
+    TCLR is a new tree model proposed by Professor T-Y Zhang and Mr. Bin Cao et al. for capturing the functional relationships 
+    between features and target variables. The model partitions the feature space into a set of rectangles, with each partition
+    embodying a specific function. This approach is conceptually simple, yet powerful for distinguishing mechanisms. The entire
+    feature space is divided into disjointed unit intervals by hyperplanes parallel to the coordinate axes. Within each partition,
+    the target variable y is modeled as a linear function of a feature xj (j = 1,⋯,m), which is the linear function used in our studied problem.
+    
+    Patent No. : 2021SR1951267, China
+    Reference : Domain knowledge guided interpretive machine learning ——  Formula discovery for the oxidation behavior of Ferritic-Martensitic steels in supercritical water. Bin Cao et al., 2022, JMI, journal paper.
+    DOI : 10.20517/jmi.2022.04
+""""""
+
+import math
+import re
+from tabnanny import check
+from textwrap import indent
+import time
+import copy
+import os
+import warnings
+import random
+from typing import List
+import numpy as np
+import pandas as pd
+from graphviz import Digraph
+from scipy import stats
+from gplearn import genetic
+from minepy import MINE
+
+
+# Define the basic structure of a Tree Model - Node
+class Node:
+    def __init__(self, data):
+        self.data = data
+        self.lc = None
+        self.rc = None
+        self.slope = None
+        self.intercept = None
+        self.size = data.shape[0]
+        self.R = 0
+        self.bestFeature = 0
+        self.bestValue = 0
+        self.leaf_no = -1
+
+
+def start(filePath, correlation='PearsonR(+)', minsize=3, threshold=0.95, mininc=0.01, split_tol = 0.8, epochs = 5,random_seed=42, Generate_Features = True, tolerance_list = None , weight=True,
+         gplearn = False, gpl_dummyfea = None, population_size = 500, generations = 100, verbose = 1, 
+         metric = 'mean absolute error',
+         function_set = ['add', 'sub', 'mul', 'div', 'log', 'sqrt', 'abs', 'neg','inv','sin','cos','tan',]):
+    
+    """"""
+    Tree Classifier for Linear Regression (TCLR) 
+
+    TCLR is a new tree model proposed by Professor T-Y Zhang and Mr. Bin Cao et al. for capturing the functional relationships 
+    between features and target variables. The model partitions the feature space into a set of rectangles, with each partition
+    embodying a specific function. This approach is conceptually simple, yet powerful for distinguishing mechanisms. The entire
+    feature space is divided into disjointed unit intervals by hyperplanes parallel to the coordinate axes. Within each partition,
+    the target variable y is modeled as a linear function of a feature xj (j = 1,⋯,m), which is the linear function used in our studied problem.
+    
+    Patent No. : 2021SR1951267, China
+    Reference : Domain knowledge guided interpretive machine learning ——  Formula discovery for the oxidation behavior of Ferritic-Martensitic steels in supercritical water. Bin Cao et al., 2022, JMI, journal paper.
+    DOI : 10.20517/jmi.2022.04
+
+    :param correlation : {'PearsonR(+)','PearsonR(-)',''MIC','R2'}, default PearsonR(+).
+            Methods:
+            * PearsonR: (+)(-). for linear relationship.
+            * MIC for no-linear relationship.
+            * R2 for no-linear relationship.
+
+            The evaluation factor for capture the functional relationship between feature and response
+            1>
+            PearsonR:
+            Pearson correlation coefficient, also known as Pearson's r, the Pearson product-moment correlation coefficient.
+            PearsonR is a measure of linear correlation between two sets of data. 
+            PearsonR = Cov(X,Y) / (sigmaX * sigmaY)
+        
+            2>
+            MIC:
+            The maximal information coefficient (MIC). MIC captures a wide range of associations both functional and not, 
+            and for functional relationships provides a score that roughly equals the coefficient of determination (R2) of 
+            the data relative to the regression function.  MIC belongs to a larger class of maximal information-based 
+            nonparametric exploration (MINE) statistics for identifying and classifying relationship.  
+            Reference : Reshef, D. N., Reshef, Y. A., Finucane, H. K., Grossman, S. R., McVean, G., Turnbaugh, P. J., ... 
+            and Sabeti, P. C. (2011). Detecting novel associations in large data sets. science, 334(6062), 1518-1524.
+            
+            3>
+            R2:
+            In statistics, the coefficient of determination, denoted R2 or r2 and pronounced ""R squared"", 
+            is the proportion of the variation in the dependent variable that is predictable from the independent variable(s).
+            t is a statistic used in the context of statistical models whose main purpose is either the prediction of future 
+            outcomes or the testing of hypotheses, on the basis of other related information. It provides a measure of how well
+            observed outcomes are replicated by the model, based on the proportion of total variation of outcomes explained by the model.
+            Definition from Wikipedia : https://en.wikipedia.org/wiki/Coefficient_of_determination
+            R2 = 1 - SSres / SStot. Its value may be a negative one for poor correlation.
+ 
+  
+    :param minsize : 
+            a int number (default=3), minimum unique values for linear features of data on each leaf.
+    
+    :param threshold : 
+            a float (default=0.9), less than or equal to 1, default 0.95 for PearsonR.
+            In the process of dividing the dataset, the smallest relevant index allowed in the you research.
+            To avoid overfitting, threshold = 0.5 is suggested for MIC 0.5.
+    
+    :param mininc : Minimum expected gain of objective function (default=0.01)
+
+    :param split_tol : a float (default=0.8), constrained features value shound be narrowed in a minmimu ratio of split_tol on split path
+
+    :param epochs : an integer (default=5), see parameter Generate_Features (below)
+
+    :param random_seed :  an integer (default=42), see parameter Generate_Features (below)
+
+    :param Generate_Features : boole (default=True). When Generate_Features = True, TCLR will generate new features by operating  
+        the ['+','-','*'] on original features. Iterating [param : epoachs] times, and each time generating 3 new features.  [param : random_seed]
+        is used to control the randomness.
+        When Generate_Features = False, TCLR will apply the original features
+
+    :param tolerance_list: 
+            constraints imposed on features, default is null
+            list shape in two dimensions, viz., [['feature_name1',tol_1],['feature_name2',tol_2]...]
+            'feature_name1', 'feature_name2' (string) are names of input features;
+            tol_1, tol_2 (float, between 0 to 1) are feature's tolerance ratios;
+            the variations of feature values on each leaf must be in the tolerance;
+            if tol_1 = 0, the value of feature 'feature_name1' must be a constant on each leaf,
+            if tol_1 = 1, there is no constraints on value of feature 'feature_name1';
+            example: tolerance_list = [['feature_name1',0.2],['feature_name2',0.1]].
+
+    :param weight:
+            The weight of the gain function, default is True.
+            When weight is True: linear_gain = R(father node) - ( W_l * R(left child node) + W_r * R(right child node)) / 2
+            Where W_l is the ratio of the number of samples in the left child node to the total number of samples ;
+                  W_r is the ratio of the number of samples in the right child node to the total number of samples.
+            When weight is False: linear_gain = R(father node) - ( R(left child node) + R(right child node)) / 2
+
+    :param gplearn : Whether to call the embedded gplearn package of TCLR to regress formula (default=False).
+    
+    :param gpl_dummyfea: 
+            dummy features in gpleran regression, default is null
+            list shape in one dimension, viz., ['feature_name1','feature_name2',...]
+            dummy features : 'feature_name1','feature_name2',... are not used anymore in gpleran regression 
+
+    :param population_size : integer, optional (default=500), the number of programs in each generation.
+    
+    :param generations : integer, optional (default=100),the number of generations to evolve.
+
+    :param verbose : int, optional (default=0). Controls the verbosity of the evolution building process.
+    
+    :param metric : 
+            str, optional (default='mean absolute error')
+            The name of the raw fitness metric. Available options include:
+            - 'mean absolute error'.
+            - 'mse' for mean squared error.
+            - 'rmse' for root mean squared error.
+            - 'pearson', for Pearson's product-moment correlation coefficient.
+            - 'spearman' for Spearman's rank-order correlation coefficient.
+    
+    :param function_set : 
+            iterable, optional (default=['add', 'sub', 'mul', 'div', 'log', 'sqrt', 
+                                               'abs', 'neg','inv','sin','cos','tan', 'max', 'min'])
+            The functions to use when building and evolving programs. This iterable can include strings 
+            to indicate either individual functions as outlined below.
+            Available individual functions are:
+            - 'add' : addition, arity=2.
+            - 'sub' : subtraction, arity=2.
+            - 'mul' : multiplication, arity=2.
+            - 'div' : protected division where a denominator near-zero returns 1.,
+                arity=2.
+            - 'sqrt' : protected square root where the absolute value of the
+                argument is used, arity=1.
+            - 'log' : protected log where the absolute value of the argument is
+                used and a near-zero argument returns 0., arity=1.
+            - 'abs' : absolute value, arity=1.
+            - 'neg' : negative, arity=1.
+            - 'inv' : protected inverse where a near-zero argument returns 0.,
+                arity=1.
+            - 'max' : maximum, arity=2.
+            - 'min' : minimum, arity=2.
+            - 'sin' : sine (radians), arity=1.
+            - 'cos' : cosine (radians), arity=1.
+            - 'tan' : tangent (radians), arity=1.
+    
+    Exampel :
+    #coding=utf-8
+    from TCLR import TCLRalgorithm as model
+
+    dataSet = ""testdata.csv""
+    correlation = 'PearsonR(+)'
+    minsize = 3
+    threshold = 0.9
+    mininc = 0.01
+    split_tol = 0.8
+
+    model.start(filePath = dataSet, correlation = correlation, minsize = minsize, threshold = threshold,
+                mininc = mininc ,split_tol = split_tol,)
+    """"""
+
+    os.makedirs('Segmented', exist_ok=True)
+    # global var. for statisticaling  results
+    global record
+    record = 0
+    timename = time.localtime(time.time())
+    namey, nameM, named, nameh, namem = timename.tm_year, timename.tm_mon, timename.tm_mday, timename.tm_hour, timename.tm_min
+
+    read_csvData = pd.read_csv(filePath)
+
+    input_csvData = read_csvData.iloc[:,:-2]
+    if Generate_Features == True:
+        # cal an appropriate value of batch
+        if len(input_csvData) - 1 <= 3:
+            batch = 1
+        else:
+            batch = 3
+        # generate new dataset
+        for epoch in range(epochs):
+            # for increasing the randomness
+            random_seed += 1
+            input_csvData = generate_random_features(input_csvData,[column for column in input_csvData],batch,random_seed)
+           
+        input_csvData = input_csvData.assign(linear_X=read_csvData.iloc[:,-2])
+        csvData = input_csvData.assign(linear_Y=read_csvData.iloc[:,-1])
+
+    else:
+        csvData = read_csvData
+    
+    
+    copy_csvData = copy.deepcopy(csvData)
+    copy_csvData['slope'] = None
+    copy_csvData['intercept'] = None
+    copy_csvData[correlation] = None
+    copy_csvData.to_csv('Segmented/all_dataset.csv', index=False)
+
+    feats = [column for column in csvData]
+    csvData = np.array(csvData)
+    root, _ = createTree(csvData, csvData, feats, 0, correlation,tolerance_list, minsize, threshold, mininc, split_tol,weight)
+    
+    print('All non-image results have been successfully saved!')
+    print('#'*80,'\n')
+   
+    # excute gplearn 
+    if gplearn == True :
+        if correlation == 'MIC' or correlation == 'R2':
+            print('{name} is a non-linear correlation metrics'.format(name = correlation ))
+            print('This is illegal, linear slopes are only allowed to generate when PearsonR is chosen')
+        elif correlation == 'PearsonR(+)' or correlation == 'PearsonR(-)':
+            sr_data = pd.read_csv('Segmented/all_dataset.csv')
+            sr_featurname = sr_data.columns
+            sr_data = np.array(sr_data)
+
+            if gpl_dummyfea == None: 
+
+                gpmodel = genetic.SymbolicRegressor(
+                    population_size = population_size, generations = generations, 
+                    verbose = verbose,feature_names = sr_featurname[:-4],function_set = function_set,
+                    metric = metric
+                    )
+                formula = gpmodel.fit(sr_data[:,:-4], sr_data[:,-3])
+                score = gpmodel.score(sr_data[:,:-4], sr_data[:,-3])
+                print( 'slope = ' + str(formula))
+
+            else:
+                # fea_num --> fea_loc
+                dummyfea = []
+                for i in range(len(gpl_dummyfea)):
+                    index = feats.index(gpl_dummyfea[i])
+                    dummyfea.append(index)
+                # remove fea_loc
+                index_array = [i for i in range(len(sr_featurname)-4)]
+                for i in range(len(gpl_dummyfea)):
+                    index_array.remove(dummyfea[i])
+                
+                gpmodel = genetic.SymbolicRegressor(
+                    population_size = population_size, generations = generations, 
+                    verbose = verbose,feature_names = sr_featurname[index_array],function_set = function_set,
+                    metric = metric
+                    )
+                formula = gpmodel.fit(sr_data[:,index_array], sr_data[:,-3])
+                score = gpmodel.score(sr_data[:,index_array], sr_data[:,-3])
+                print( 'slope = ' + str(formula))
+
+          
+            with open(os.path.join('Segmented', 'A_formula derived by gplearn.txt'), 'w') as wfid:
+                    print('Formula : ', file=wfid)
+                    print(str(formula), file=wfid)
+                    print('Fitness : ', file=wfid)
+                    print(str(metric) + ' = ' + str(score), file=wfid)
+                    print('\n', file=wfid)
+                    print('#'*80, file=wfid)
+                    print('Symbols annotation:', file=wfid)
+                    print('- add : addition, arity=2.', file=wfid)
+                    print('- sub : subtraction, arity=2.', file=wfid) 
+                    print('- mul : multiplication, arity=2.', file=wfid) 
+                    print('- div : protected division where a denominator near-zero returns 1.', file=wfid) 
+                    print('- sqrt : protected square root where the absolute value of the argument is used.', file=wfid) 
+                    print('- log : protected log where the absolute value of the argument is used.', file=wfid) 
+                    print('- abs : absolute value, arity=1.', file=wfid) 
+                    print('- neg : negative, arity=1.', file=wfid) 
+                    print('- inv : protected inverse where a near-zero argument returns 0.', file=wfid)  
+                    print('- max : maximum, arity=2.', file=wfid) 
+                    print('- sin : sine (radians), arity=1.', file=wfid) 
+                    print('- cos : cosine (radians), arity=1.', file=wfid)
+                    print('- tan : tangent (radians), arity=1.', file=wfid)  
+                 
+                        
+            
+    elif gplearn == False:
+        pass
+    
+
+    try:
+        # generate figure in pdf
+        warnings.filterwarnings('ignore')
+        dot = Digraph(comment='Result of TCLR')
+        render('A', root, dot, feats)
+        dot.render(
+            'Result of TCLR {year}.{month}.{day}-{hour}.{minute}'.format(year=namey, month=nameM, day=named, hour=nameh,
+                                                                        minute=namem))
+        return True
+    except :
+        print('Can not generate the Tree plot !')
+        print('Please ensure that the executable files of Graphviz are present on your system.')
+        print('See : https://github.com/Bin-Cao/TCLRmodel/tree/main/User%20Guide')
+        return True 
+  
+
+
+# Capture the functional relationships between features and target
+# Partitions the feature space into a set of rectangles,
+def createTree(dataSet, ori_dataset,feats, leaf_no, correlation,tolerance_list, minsize, threshold, mininc,split_tol,weight):
+    # It is a  positive linear relationship
+    if correlation == 'PearsonR(+)':
+        node = Node(dataSet)
+        # Initial R0
+        bestR = PearsonR(dataSet[:, -2], dataSet[:, -1])
+        node.R = bestR
+        __slope = stats.linregress(dataSet[:, -2], dataSet[:, -1])[0]
+        node.slope = __slope
+        node.intercept = stats.linregress(dataSet[:, -2], dataSet[:, -1])[1]
+        if bestR >= threshold and fea_tol(dataSet,ori_dataset,feats,tolerance_list) == True:
+            node.leaf_no = leaf_no
+            leaf_no += 1
+            write_csv(node, feats, True, correlation)
+            return node, leaf_no
+        # Leave the last two columns of DataSet, a feature of interest and a response
+        numFeatures = len(dataSet[0]) - 2
+        splitSuccess = False
+        bestFeature = -1
+        bestValue = 0
+
+        check_valve = False
+        for i in range(numFeatures):
+            featList = [example[i] for example in dataSet]
+            uniqueVals = sorted(list(set(featList)))
+            for value in range(len(uniqueVals) - 1):
+                # constraints imposed on features  (greater tolerance in split process)
+                if not fea_tol_split(dataSet,ori_dataset,feats,tolerance_list,split_tol):
+                    continue
+                subDataSetA, subDataSetB = splitDataSet(dataSet, i, uniqueVals[value])
+                
+                if np.unique(subDataSetA[:, -2]).size <= minsize - 1 or np.unique(
+                        subDataSetB[:, -2]).size <= minsize - 1:
+                    continue
+                
+                R = weight_gain(subDataSetA,subDataSetB,weight,0)
+
+                if R - bestR >= mininc:
+                    check_valve = True
+                    splitSuccess = True
+                    bestR = R
+                    lc = subDataSetA
+                    rc = subDataSetB
+                    bestFeature = i
+                    bestValue = uniqueVals[value]
+                
+        if check_valve == False:
+            for i in range(numFeatures):
+                featList = [example[i] for example in dataSet]
+                uniqueVals = sorted(list(set(featList)))
+                for value in range(len(uniqueVals) - 1):
+                    subDataSetA, subDataSetB = splitDataSet(dataSet, i, uniqueVals[value])
+                    
+                    if np.unique(subDataSetA[:, -2]).size <= minsize - 1 or np.unique(
+                            subDataSetB[:, -2]).size <= minsize - 1:
+                        continue
+
+                    R = weight_gain(subDataSetA,subDataSetB,weight,0)
+
+                    if R - bestR >= mininc:
+                        splitSuccess = True
+                        bestR = R
+                        lc = subDataSetA
+                        rc = subDataSetB
+                        bestFeature = i
+                        bestValue = uniqueVals[value]
+            else:
+                pass
+                        
+
+        # The recursive boundary is unable to find a division node that can increase factor(R, MIC, R2) by mininc or more.
+        if splitSuccess:
+            node.lc, leaf_no = createTree(lc, ori_dataset,feats, leaf_no, correlation, tolerance_list,minsize, threshold, mininc,split_tol,weight)
+            node.rc, leaf_no = createTree(rc, ori_dataset,feats, leaf_no, correlation,tolerance_list, minsize, threshold, mininc,split_tol,weight)
+            node.bestFeature, node.bestValue = bestFeature, bestValue
+
+        # This node is leaf
+        if node.lc is None:
+            node.leaf_no = leaf_no
+            leaf_no += 1
+            # determine if this node is to save in all_dataset.csv
+            save_in_all = False
+            if node.R >= threshold and fea_tol(node.data,ori_dataset,feats,tolerance_list) == True:
+                save_in_all = True 
+            write_csv(node, feats, save_in_all, correlation)
+
+        return node, leaf_no
+
+    # It is a negative linear relationship
+    elif correlation == 'PearsonR(-)':
+        node = Node(dataSet)
+        bestR = PearsonR(dataSet[:, -2], dataSet[:, -1])
+        node.R = bestR
+        __slope = stats.linregress(dataSet[:, -2], dataSet[:, -1])[0]
+        node.slope = __slope
+        node.intercept = stats.linregress(dataSet[:, -2], dataSet[:, -1])[1]
+        if bestR <= -threshold and fea_tol(dataSet,ori_dataset,feats,tolerance_list) == True:
+            node.leaf_no = leaf_no
+            leaf_no += 1
+            write_csv(node, feats, True, correlation)
+            return node, leaf_no
+
+        numFeatures = len(dataSet[0]) - 2
+        splitSuccess = False
+        bestFeature = -1
+        bestValue = 0
+
+        check_valve = False
+        for i in range(numFeatures):
+            featList = [example[i] for example in dataSet]
+            uniqueVals = sorted(list(set(featList)))
+            for value in range(len(uniqueVals) - 1):
+                # constraints imposed on features  (greater tolerance in split process)
+                if not fea_tol_split(dataSet,ori_dataset,feats,tolerance_list,split_tol):
+                    continue
+                subDataSetA, subDataSetB = splitDataSet(dataSet, i, uniqueVals[value])
+
+                if np.unique(subDataSetA[:, -2]).size <= minsize - 1 or np.unique(
+                        subDataSetB[:, -2]).size <= minsize - 1:
+                    continue
+
+                
+                R = weight_gain(subDataSetA,subDataSetB,weight,0)
+
+                if R - bestR <= - mininc:
+                    check_valve = True
+                    splitSuccess = True
+                    bestR = R
+                    lc = subDataSetA
+                    rc = subDataSetB
+                    bestFeature = i
+                    bestValue = uniqueVals[value]
+
+        if check_valve == False:
+            for i in range(numFeatures):
+                featList = [example[i] for example in dataSet]
+                uniqueVals = sorted(list(set(featList)))
+                for value in range(len(uniqueVals) - 1):
+                    subDataSetA, subDataSetB = splitDataSet(dataSet, i, uniqueVals[value])
+
+                    if np.unique(subDataSetA[:, -2]).size <= minsize - 1 or np.unique(
+                            subDataSetB[:, -2]).size <= minsize - 1:
+                        continue
+                    
+                    R = weight_gain(subDataSetA,subDataSetB,weight,0)
+
+                    if R - bestR <= - mininc:
+                        splitSuccess = True
+                        bestR = R
+                        lc = subDataSetA
+                        rc = subDataSetB
+                        bestFeature = i
+                        bestValue = uniqueVals[value]
+        else: pass
+
+        if splitSuccess:
+            node.lc, leaf_no = createTree(lc, ori_dataset,feats, leaf_no, correlation,tolerance_list, minsize, threshold, mininc,split_tol,weight)
+            node.rc, leaf_no = createTree(rc, ori_dataset,feats, leaf_no, correlation,tolerance_list, minsize, threshold, mininc,split_tol,weight)
+            node.bestFeature, node.bestValue = bestFeature, bestValue
+
+        if node.lc is None:
+            node.leaf_no = leaf_no
+            leaf_no += 1
+            # determine if this node is to save in all_dataset.csv
+            save_in_all = False
+            if node.R >= threshold and fea_tol(node.data,ori_dataset,feats,tolerance_list) == True:
+                save_in_all = True 
+            write_csv(node, feats, save_in_all, correlation)
+
+        return node, leaf_no
+
+    elif correlation == 'MIC':
+        node = Node(dataSet)
+        bestR = MIC(dataSet[:, -2], dataSet[:, -1])
+        node.R = bestR
+        node.slope == None
+        if bestR >= threshold and fea_tol(dataSet,ori_dataset,feats,tolerance_list) == True:
+            node.leaf_no = leaf_no
+            leaf_no += 1
+            write_csv(node, feats, True, correlation)
+            return node, leaf_no
+
+        numFeatures = len(dataSet[0]) - 2
+        splitSuccess = False
+        bestFeature = -1
+        bestValue = 0
+
+        check_valve = False
+        for i in range(numFeatures):
+            featList = [example[i] for example in dataSet]
+            uniqueVals = sorted(list(set(featList)))
+            for value in range(len(uniqueVals) - 1):
+                # constraints imposed on features  (greater tolerance in split process)
+                if not fea_tol_split(dataSet,ori_dataset,feats,tolerance_list,split_tol):
+                    continue
+                subDataSetA, subDataSetB = splitDataSet(dataSet, i, uniqueVals[value])
+                if np.unique(subDataSetA[:, -2]).size <= minsize - 1 or np.unique(
+                        subDataSetB[:, -2]).size <= minsize - 1:
+                    continue
+                
+                R = weight_gain(subDataSetA,subDataSetB,weight,1)
+
+                if R - bestR >= mininc:
+                    check_valve = True
+                    splitSuccess = True
+                    bestR = R
+                    lc = subDataSetA
+                    rc = subDataSetB
+                    bestFeature = i
+                    bestValue = uniqueVals[value]
+
+        if check_valve == False:
+            for i in range(numFeatures):
+                featList = [example[i] for example in dataSet]
+                uniqueVals = sorted(list(set(featList)))
+                for value in range(len(uniqueVals) - 1):
+                    subDataSetA, subDataSetB = splitDataSet(dataSet, i, uniqueVals[value])
+                    if np.unique(subDataSetA[:, -2]).size <= minsize - 1 or np.unique(
+                            subDataSetB[:, -2]).size <= minsize - 1:
+                        continue
+    
+                    R = weight_gain(subDataSetA,subDataSetB,weight,1)
+
+                    if R - bestR >= mininc:
+                        splitSuccess = True
+                        bestR = R
+                        lc = subDataSetA
+                        rc = subDataSetB
+                        bestFeature = i
+                        bestValue = uniqueVals[value]
+        else: pass
+
+        if splitSuccess:
+            node.lc, leaf_no = createTree(lc, ori_dataset,feats, leaf_no, correlation,tolerance_list, minsize, threshold, mininc,split_tol,weight)
+            node.rc, leaf_no = createTree(rc,ori_dataset, feats, leaf_no, correlation,tolerance_list, minsize, threshold, mininc,split_tol,weight)
+            node.bestFeature, node.bestValue = bestFeature, bestValue
+
+        if node.lc is None:
+            node.leaf_no = leaf_no
+            leaf_no += 1
+            # determine if this node is to save in all_dataset.csv
+            save_in_all = False
+            if node.R >= threshold and fea_tol(node.data,ori_dataset,feats,tolerance_list) == True:
+                save_in_all = True 
+            write_csv(node, feats, save_in_all, correlation)
+
+        return node, leaf_no
+
+    elif correlation == 'R2':
+        node = Node(dataSet)
+        bestR = R2(dataSet[:, -2], dataSet[:, -1])
+        node.R = bestR
+        node.slope == None
+        if bestR >= threshold and fea_tol(dataSet,ori_dataset,feats,tolerance_list) == True:
+            node.leaf_no = leaf_no
+            leaf_no += 1
+            write_csv(node, feats, True, correlation)
+            return node, leaf_no
+
+        numFeatures = len(dataSet[0]) - 2
+        splitSuccess = False
+        bestFeature = -1
+        bestValue = 0
+
+        check_valve = False
+        for i in range(numFeatures):
+            featList = [example[i] for example in dataSet]
+            uniqueVals = sorted(list(set(featList)))
+            for value in range(len(uniqueVals) - 1):
+                # constraints imposed on features  (greater tolerance in split process)
+                if not fea_tol_split(dataSet,ori_dataset,feats,tolerance_list,split_tol):
+                    continue
+
+                subDataSetA, subDataSetB = splitDataSet(dataSet, i, uniqueVals[value])
+
+                if np.unique(subDataSetA[:, -2]).size <= minsize - 1 or np.unique(
+                        subDataSetB[:, -2]).size <= minsize - 1:
+                    continue
+
+                R = weight_gain(subDataSetA,subDataSetB,weight,2)
+
+                if R - bestR >= mininc:
+                    check_valve = True
+                    splitSuccess = True
+                    bestR = R
+                    lc = subDataSetA
+                    rc = subDataSetB
+                    bestFeature = i
+                    bestValue = uniqueVals[value]
+
+        if check_valve == False:
+            for i in range(numFeatures):
+                featList = [example[i] for example in dataSet]
+                uniqueVals = sorted(list(set(featList)))
+
+                for value in range(len(uniqueVals) - 1):
+                    if np.unique(subDataSetA[:, -2]).size <= minsize - 1 or np.unique(
+                            subDataSetB[:, -2]).size <= minsize - 1:
+                        continue
+
+                    R = weight_gain(subDataSetA,subDataSetB,weight,2)
+
+                    if R - bestR >= mininc:
+                        splitSuccess = True
+                        bestR = R
+                        lc = subDataSetA
+                        rc = subDataSetB
+                        bestFeature = i
+                        bestValue = uniqueVals[value]
+        else: pass
+        
+        if splitSuccess:
+            node.lc, leaf_no = createTree(lc, ori_dataset,feats, leaf_no, correlation, tolerance_list,minsize, threshold, mininc,split_tol)
+            node.rc, leaf_no = createTree(rc, ori_dataset,feats, leaf_no, correlation,tolerance_list, minsize, threshold, mininc,split_tol)
+            node.bestFeature, node.bestValue = bestFeature, bestValue
+
+        if node.lc is None:
+            node.leaf_no = leaf_no
+            leaf_no += 1
+            # determine if this node is to save in all_dataset.csv
+            save_in_all = False
+            if node.R >= threshold and fea_tol(node.data,feats,tolerance_list) == True:
+                save_in_all = True 
+            write_csv(node, feats, save_in_all, correlation)
+
+        return node, leaf_no
+
+
+def PearsonR(X, Y):
+    xBar = np.mean(X)
+    yBar = np.mean(Y)
+    SSR = 0
+    varX = 0
+    varY = 0
+    if len(X) > 1:
+        for i in range(0, len(X)):
+            diffXXBar = X[i] - xBar
+            diffYYBar = Y[i] - yBar
+            SSR += (diffXXBar * diffYYBar)
+            varX += diffXXBar ** 2
+            varY += diffYYBar ** 2
+        SST = math.sqrt(varX * varY)
+    else:
+        SST = 1
+        SSR = 0
+    if SST == 0:
+        return 0
+    return SSR / SST
+
+
+def MIC(X, Y):
+    if len(X) > 0:
+        mine = MINE(alpha=0.6, c=15)
+        mine.compute_score(X, Y)
+        return mine.mic()
+    else:
+        MICs = 0
+        return MICs
+
+
+def R2(X, Y):
+    X = np.array(X)
+    Y = np.array(Y)
+    if len(X) > 0:
+        a = (X - np.mean(Y)) ** 2
+        SStot = np.sum(a)
+        b = (X - Y) ** 2
+        SSres = np.sum(b)
+        r2 = 1 - SSres / SStot
+        return r2
+    else:
+        r2 = -10
+        return r2
+
+
+# Split the DataSet in a specific node
+def splitDataSet(dataSet, axis, value):
+    retDataSetA = []
+    retDataSetB = []
+    for featVec in dataSet:
+        if featVec[axis] <= value:
+            retDataSetA.append(featVec)
+        else:
+            retDataSetB.append(featVec)
+    return np.array(retDataSetA), np.array(retDataSetB)
+
+def fea_tol(dataSet,ori_dataSet,feats,tolerance_list):
+    if tolerance_list == None: return True
+    else:
+        record = 0
+        for i in range(len(tolerance_list)):
+            __feaname = tolerance_list[i][0]
+            __tolratio = float(tolerance_list[i][1])
+            index = feats.index(__feaname)
+            if (dataSet[:,index].max() - dataSet[:,index].min()) / (ori_dataSet[:,index].max()- ori_dataSet[:,index].min()) <= __tolratio:
+                record += 1
+        if record == len(tolerance_list):
+            return True
+
+def fea_tol_split(dataSet,ori_dataSet,feats,tolerance_list,split_tol):
+    if tolerance_list == None: return True
+    else:
+        record = 0
+        for i in range(len(tolerance_list)):
+            __feaname = tolerance_list[i][0]
+            __tolratio = float(tolerance_list[i][1])
+            criter = max(split_tol,__tolratio)
+            index = feats.index(__feaname)
+            if (dataSet[:,index].max() - dataSet[:,index].min()) / (ori_dataSet[:,index].max()- ori_dataSet[:,index].min()) <= criter:
+                record += 1
+        if record > int(0.5*len(tolerance_list)):
+            return True
+
+
+# Use graphviz to visualize the TCLR
+def render(label, node, dot, feats):
+    mark = ''
+    if node.slope == None:
+        mark = ""#="" + str(node.size) + "" , ρ="" + str(round(node.R, 3))
+    else:
+        mark = ""#="" + str(node.size) + "" , ρ="" + str(round(node.R, 3)) + ' , slope=' + str(
+            round(node.slope, 3)) + ' , intercept=' + str(round(node.intercept, 3))
+
+    if node.lc is None:
+        mark = 'No_{}, '.format(node.leaf_no) + mark
+    dot.node(label, mark)
+
+    if node.lc is not None:
+        render(label + 'A', node.lc, dot, feats)
+        render(label + 'B', node.rc, dot, feats)
+        dot.edge(label, label + 'A', feats[node.bestFeature] + ""≤"" + str(node.bestValue))
+        dot.edge(label, label + 'B', feats[node.bestFeature] + "">"" + str(node.bestValue))
+
+
+def write_csv(node, feats, save_in_all, correlation):
+    global record
+
+    frame = {}
+    for i in range(len(feats)):
+        frame[feats[i]] = node.data[:, i]
+    frame = pd.DataFrame(frame)
+
+    if node.slope == None:
+        frame['slope'] = None
+        frame['intercept'] = None
+        frame[correlation] = np.repeat(node.R, node.size)
+        frame.to_csv('Segmented/subdataset_{}.csv'.format(str(node.leaf_no)))
+    else:
+        frame['slope'] = node.slope
+        frame['intercept'] = node.intercept
+        frame[correlation] = np.repeat(node.R, node.size)
+        frame.to_csv('Segmented/subdataset_{}.csv'.format(str(node.leaf_no)))
+
+    frame.to_csv('Segmented/subdataset_{}.csv'.format(str(node.leaf_no)))
+
+    if not save_in_all:  # do not save in the all_dataset.csv
+        _all_dataset = pd.read_csv('./Segmented/all_dataset.csv')
+        _all_dataset.drop(index=range(record, record+node.size), axis=0, inplace=True)
+        _all_dataset.to_csv('Segmented/all_dataset.csv', index=False)
+        return
+
+    _all_dataset = pd.read_csv('./Segmented/all_dataset.csv')
+    for item in range(len(frame.iloc[:, 0])):
+        _all_dataset.iloc[item + record, :] = frame.iloc[item, :]
+    record += len(frame.iloc[:, 0])
+    _all_dataset.to_csv('Segmented/all_dataset.csv', index=False)
+
+def weight_gain(subDataSetA,subDataSetB,weight,matrix):
+    if matrix == 0:
+        newRa = PearsonR(subDataSetA[:, -2], subDataSetA[:, -1])
+        newRb = PearsonR(subDataSetB[:, -2], subDataSetB[:, -1])
+    elif matrix == 1:
+        newRa = MIC(subDataSetA[:, -2], subDataSetA[:, -1])
+        newRb = MIC(subDataSetB[:, -2], subDataSetB[:, -1])
+    elif matrix == 2:
+        newRa = R2(subDataSetA[:, -2], subDataSetA[:, -1])
+        newRb = R2(subDataSetB[:, -2], subDataSetB[:, -1])
+  
+
+    if weight == False:
+        R = (newRa + newRb) / 2
+        return R
+    elif weight == True:
+        weightRa = len(subDataSetA[:, -1]) / (len(subDataSetA[:, -1]) + len(subDataSetB[:, -1]))
+        weightRb = len(subDataSetB[:, -1]) / (len(subDataSetA[:, -1]) + len(subDataSetB[:, -1]))
+        R = weightRa * newRa + weightRb * newRb
+        return R
+    else:
+        print('Parameter error | weight')
+
+
+# code on 2023 May 9, Bin Cao
+def generate_random_features(df: pd.DataFrame, 
+                            feature_list: List[str],
+                            num_combinations: int,
+                             random_seed:int) -> pd.DataFrame:
+    """"""
+    randomly generates new feature combinations.
+
+    :param df: DataFrame containing the original features.
+    :param feature_list: List of original features.
+    :param num_combinations: Number of combination features to generate.
+    :return: DataFrame containing the new features.
+    """"""
+    new_features = []
+    random.seed(random_seed)
+    # randomly generates combination features
+    for i in range(num_combinations):
+        # randomly chooses two features
+        f1 = random.choice(feature_list)
+        f2 = random.choice(feature_list)
+        
+        # choose a operator
+        op = random.choice(['+', '-', '*',])
+
+        self_op1 = random.choice(['*1', '*2', '*3','*4','**2','**3'])
+        self_op2 = random.choice(['*1', '*2', '*3','*4','**2','**3'])
+        
+        new_f1 = f'{f1} {self_op1}'
+        new_f2 = f'{f2} {self_op2}'
+
+        # new feature name
+        new_feature = f'({new_f1} {op} {new_f2})'
+        
+        new_features.append(new_feature)
+        
+        # cal new features
+        df[new_feature] = eval(f'(df[""{f1}""] {self_op1}) {op} (df[""{f2}""] {self_op2})')
+    
+    # reture DataFrame 
+    return df","Python"
+"Biochemistry","Bin-Cao/TCLRmodel","Researches/Note.md",".md","38","2","# Relevant researches applied of TCLR
+","Markdown"