"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 (binjacobcao@gmail.com) 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"