StackGP 0.0.4__tar.gz → 0.0.6__tar.gz

{stackgp-0.0.4 → stackgp-0.0.6}/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2023 Nathan Haut
+Copyright (c) 2025 Nathan Haut
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

{stackgp-0.0.4 → stackgp-0.0.6}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: StackGP
-Version: 0.0.4
+Version: 0.0.6
 Summary: A stack-based genetic programming system
 Author-email: Nathan Haut <hautnath@msu.edu>
 Project-URL: Homepage, https://github.com/hoolagans/StackGP
@@ -17,6 +17,7 @@ Requires-Dist: matplotlib
 Requires-Dist: scipy
 Requires-Dist: scikit-learn
 Requires-Dist: sympy
+Dynamic: license-file
 
 # StackGP
 A stack-based genetic programming system in Python

{stackgp-0.0.4 → stackgp-0.0.6}/StackGP/StackGP.py

@@ -18,7 +18,12 @@ import dill
 import os
 from sklearn.cluster import KMeans #for clustering in ensemble definition
 from scipy.optimize import minimize #for uncertainty maximization
-from sympy import symbols
+from sympy import symbols, simplify, expand
+import sympy as sym
+
+import signal #for timing out functions
+from contextlib import contextmanager #for timing out functions
+
 warnings.filterwarnings('ignore', '.*invalid value.*' )
 warnings.filterwarnings('ignore', '.*overflow.*' )
 warnings.filterwarnings('ignore', '.*divide by.*' )
@@ -195,6 +200,10 @@ def evModHelper(varStack,opStack,tempStack,data): #Recursive helper function for
         
     return [stack1,stack2,stack3]
 evModHelper.__doc__ = "evModHelper(varStack,opStack,tempStack,data) is a helper function for evaluateGPModel"
+def rmse(model, inputData, response):
+    predictions = evaluateGPModel(model, inputData)
+    return np.sqrt(np.mean((predictions - response) ** 2))
+rmse.__doc__ = "rmse(model, input, response) is a fitness objective that evaluates the root mean squared error"
 def fitness(prog,data,response): # Fitness function using correlation
     predicted=evaluateGPModel(prog,np.array(data))
     if type(predicted)!=list and type(predicted)!=np.ndarray:
@@ -220,8 +229,111 @@ fitness.__doc__ = "fitness(program,data,response) returns the 1-R^2 value of a m
 def stackGPModelComplexity(model,*args):
     return len(model[0])+len(model[1])-model[0].tolist().count("pop")
 stackGPModelComplexity.__doc__ = "stackGPModelComplexity(model) returns the complexity of the model"
+
+###################### Timeout function for model complexity ######################
+class TimeoutException(Exception): pass
+
+@contextmanager
+def time_limit(seconds):
+    def signal_handler(signum, frame):
+        raise TimeoutException("Timed out!")
+    signal.signal(signal.SIGALRM, signal_handler)
+    signal.alarm(seconds)
+    try:
+        yield
+    finally:
+        signal.alarm(0)
+####################################################################################
+
+# Compute Hess
+def ComputeSymbolicHess(model,vars):
+    printedModel=sym.simplify(printGPModel(model))
+    if type(printedModel)==float:
+        return sym.matrices.dense.MutableDenseMatrix(np.zeros((vars,vars)))
+    hess=sym.hessian(printedModel, [symbols('x'+str(i)) for i in range(vars)])
+    return hess
+
+def EvaluateHess(hess,vars,values):
+    numHess=hess.subs({symbols('x'+str(j)):values[j] for j in range(vars)})
+    hessN = np.array(numHess).astype(float)
+    rankN=np.linalg.matrix_rank(hessN,tol=0.0001*0.0001*10)
+    return rankN
+
+def Approx2Deriv(model,values,diff1,diff2,positions): #maybe diff should be relative to the variation of each feature
+    term1=[values[i]+diff1 if i == positions[0] else values[i] for i in range(len(values))]
+    term1=[term1[i]+diff2 if i == positions[1] else term1[i] for i in range(len(term1))]
+    term2=[values[i]-diff1 if i == positions[0] else values[i] for i in range(len(values))]
+    term2=[term2[i]+diff2 if i == positions[1] else term2[i] for i in range(len(term2))]
+    term3=[values[i]+diff1 if i == positions[0] else values[i] for i in range(len(values))]
+    term3=[term3[i]-diff2 if i == positions[1] else term3[i] for i in range(len(term3))]
+    term4=[values[i]-diff1 if i == positions[0] else values[i] for i in range(len(values))]
+    term4=[term4[i]-diff2 if i == positions[1] else term4[i] for i in range(len(term4))]
+    return ((evaluateGPModel(model,term1)-evaluateGPModel(model,term2))/((2*diff1))
+            -(evaluateGPModel(model,term3)-evaluateGPModel(model,term4))/((2*diff1)))/(2*diff2)
+
+def ApproxHessRank(model,vars,values,diff1=0.001,diff2=0.001):
+    hess=[[Approx2Deriv(model,values,diff1,diff2,[i,j]) for i in range(vars)] for j in range(vars)]
+    hessN = np.array(hess).astype(float)
+    rankN=np.linalg.matrix_rank(hessN,tol=0.0001*0.0001*10)
+    return rankN
+
+#def HessRank(model,vars,values):
+#    try: 
+#        with time_limit(.01):
+#            hess=ComputeSymbolicHess(model,vars)
+#            hess = EvaluateHess(hess,vars,values)
+#            #print(hess)
+#            return hess
+#    except TimeoutException as e:
+#        hess=ApproxHessRank(model,vars,values)
+        #print(hess)
+#        return hess
+
+def HessRank(model,vars,values):
+    hess=ApproxHessRank(model,vars,values)
+    return hess
+
+
+
+
+
+# Counts basis terms in a model
+def count_basis_terms(equation, expand=False):
+    try:
+        with time_limit(2):
+
+
+            if expand:
+                # Simplify the equation to standardize the expression
+                simplified_eq = simplify(equation)
+                # Expand the expression to identify additive terms clearly
+                expanded_eq = expand(simplified_eq)
+            
+                # Separate the terms of the expression
+                terms = expanded_eq.as_ordered_terms()
+            else:
+                terms = equation.as_ordered_terms()
+            #print(terms)
+            
+    except TimeoutException as e:
+        return 1000
+    return len(terms)
+
+# Determines the number of basis functions in a model by counting +s and -s
+def basisFunctionComplexity(model,vars, values,*args):
+    try: # values should be max, min, and median with respect to response variable
+        return HessRank(model,vars,values)#count_basis_terms(printGPModel(model))
+    except:
+        return 1000
+
+# Creates a lambda function to be used as a complexity metric when given a target dimensionality and deviation
+def basisFunctionComplexityDiff(target, deviation, vars, low, mid, high):
+    return lambda model,*args: max(np.mean([abs(basisFunctionComplexity(model,vars,low)-target),abs(basisFunctionComplexity(model,vars,mid)-target) ,abs(basisFunctionComplexity(model,vars,high)-target)] ),(deviation))-deviation
+
+
 def setModelQuality(model,inputData,response,modelEvaluationMetrics=[fitness,stackGPModelComplexity]):
     model[2]=[i(model,inputData,response) for i in modelEvaluationMetrics]
+
     
 setModelQuality.__doc__ = "setModelQuality(model, inputdata, response, metrics=[r2,size]) is an inplace operator that sets a models quality"
 def stackPass(model,pt):
@@ -493,7 +605,7 @@ def alignGPModel(model, data, response): #Aligns a model
     if np.isnan(np.array(prediction)).any() or np.isnan(np.array(response)).any() or not np.isfinite(np.array(prediction,dtype=np.float32)).all():
         return model
     try:
-        align=np.round(np.polyfit(prediction,response,1,rcond=1e-16),decimals=14)
+        align=np.polyfit(prediction,response,1,rcond=1e-16)#np.round(np.polyfit(prediction,response,1,rcond=1e-16),decimals=14)
     except np.linalg.LinAlgError:
         #print("Alignment failed for: ", model, " with prediction: ", prediction, "and reference data: ", response)
         return model
@@ -503,8 +615,10 @@ def alignGPModel(model, data, response): #Aligns a model
     setModelQuality(newModel,data,response)
     return newModel
 alignGPModel.__doc__ = "alignGPModel(model, input, response) aligns a model such that response-a*f(x)+b are minimized over a and b"
-def evolve(inputData, responseData, generations=100, ops=defaultOps(), const=defaultConst(), variableNames=[], mutationRate=79, crossoverRate=11, spawnRate=10, extinction=False,extinctionRate=10,elitismRate=50,popSize=300,maxComplexity=100,align=True,initialPop=[],timeLimit=300,capTime=False,tourneySize=5,tracking=False,modelEvaluationMetrics=[fitness,stackGPModelComplexity],dataSubsample=False,samplingMethod=randomSubsample):
+def evolve(inputData, responseData, generations=100, ops=defaultOps(), const=defaultConst(), variableNames=[], mutationRate=79, crossoverRate=11, spawnRate=10, extinction=False,extinctionRate=10,elitismRate=50,popSize=300,maxComplexity=100,align=True,initialPop=[],timeLimit=300,capTime=False,tourneySize=5,tracking=False,modelEvaluationMetrics=[fitness,stackGPModelComplexity],dataSubsample=False,samplingMethod=randomSubsample,alternateObjectives=[],alternateObjFrequency=10,allowEarlyTermination=False,earlyTerminationThreshold=0):
     
+    metrics=modelEvaluationMetrics
+
     fullInput,fullResponse=copy.deepcopy(inputData),copy.deepcopy(responseData)
     inData=copy.deepcopy(fullInput)
     resData=copy.deepcopy(fullResponse)
@@ -516,11 +630,18 @@ def evolve(inputData, responseData, generations=100, ops=defaultOps(), const=def
     for i in range(generations):
         if capTime and time.perf_counter()-startTime>timeLimit:
             break
+        if len(alternateObjectives)>0 and (i+1)%alternateObjFrequency==0:
+            metrics=modelEvaluationMetrics[:1]+alternateObjectives
+        else:
+            metrics=modelEvaluationMetrics
         if dataSubsample:
             inData,resData=samplingMethod(fullInput,fullResponse)
         for mods in models:
-            setModelQuality(mods,inData,resData,modelEvaluationMetrics=modelEvaluationMetrics)
+            setModelQuality(mods,inData,resData,modelEvaluationMetrics=metrics)
         models=removeIndeterminateModels(models)
+        if allowEarlyTermination and min([mods[2][0] for mods in models])<=earlyTerminationThreshold:
+            print("Early termination at generation ", i)
+            break
         if tracking:
             bestFits.append(min([mods[2][0] for mods in paretoTournament(models)]))
 
@@ -529,7 +650,7 @@ def evolve(inputData, responseData, generations=100, ops=defaultOps(), const=def
         if extinction and i%extinctionRate:
             models=initializeGPModels(variableCount,ops,const,popSize)
             for mods in models:
-                setModelQuality(mods,inData,resData,modelEvaluationMetrics=modelEvaluationMetrics)
+                setModelQuality(mods,inData,resData,modelEvaluationMetrics=metrics)
         
         models=tournamentModelSelection(models,popSize,tourneySize)
         
@@ -560,7 +681,7 @@ def evolve(inputData, responseData, generations=100, ops=defaultOps(), const=def
         
     
     for mods in models:
-        setModelQuality(mods,fullInput,fullResponse,modelEvaluationMetrics=modelEvaluationMetrics)
+        setModelQuality(mods,fullInput,fullResponse,modelEvaluationMetrics=modelEvaluationMetrics+alternateObjectives)
     models=[trimModel(mod) for mod in models]
     models=deleteDuplicateModels(models)
     models=removeIndeterminateModels(models)
@@ -995,4 +1116,4 @@ def runEpochs(x,y,epochs=5,**kwargs):
     for i in range(epochs):
         models+=evolve(x,y,**kwargs)
 
-    return sortModels(models)
+    return sortModels(models)

{stackgp-0.0.4 → stackgp-0.0.6}/StackGP.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: StackGP
-Version: 0.0.4
+Version: 0.0.6
 Summary: A stack-based genetic programming system
 Author-email: Nathan Haut <hautnath@msu.edu>
 Project-URL: Homepage, https://github.com/hoolagans/StackGP
@@ -17,6 +17,7 @@ Requires-Dist: matplotlib
 Requires-Dist: scipy
 Requires-Dist: scikit-learn
 Requires-Dist: sympy
+Dynamic: license-file
 
 # StackGP
 A stack-based genetic programming system in Python

{stackgp-0.0.4 → stackgp-0.0.6}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "StackGP"
-version = "0.0.4"
+version = "0.0.6"
 authors = [
   { name="Nathan Haut", email="hautnath@msu.edu" },
 ]