Speed up by not recalculating score

README.md

@@ -274,6 +274,8 @@ pd.DataFrame, Results dataframe, giving complexity, MSE, and equations
 - [x] Put on PyPI
 - [x] Treat baseline as a solution.
 - [x] Print score alongside MSE: \delta \log(MSE)/\delta \log(complexity)
+- [x] Calculating the loss function - there is duplicate calculations happening.
+- [x] Declaration of the weights array every iteration
 - [ ] Add true multi-node processing, with MPI, or just file sharing. Multiple populations per core.
     - Ongoing in cluster branch
 - [ ] Consider allowing multi-threading turned off, for faster testing (cache issue on travis). Or could simply fix the caching issue there.
@@ -296,10 +298,8 @@ pd.DataFrame, Results dataframe, giving complexity, MSE, and equations
 - [ ] Add GPU capability?
      - Not sure if possible, as binary trees are the real bottleneck.
 - [ ] Performance:
-    - [ ] Use an enum for functions instead of storing them?
-    - Current most expensive operations:
-        - [ ] Calculating the loss function - there is duplicate calculations happening.
-        - [x] Declaration of the weights array every iteration
+    - Use an enum for functions instead of storing them?
+    - Threaded recursion?
 - [ ] Idea: use gradient of equation with respect to each operator (perhaps simply add to each operator) to tell which part is the most "sensitive" to changes. Then, perhaps insert/delete/mutate on that part of the tree?
 - [ ] For hierarchical idea: after running some number of iterations, do a search for "most common pattern". Then, turn that subtree into its own operator.
 - [ ] Additional degree operators?

julia/sr.jl

@@ -445,7 +445,7 @@ function deleteRandomOp(tree::Node)::Node
     return tree
 end
 
-# Simplify tree 
+# Simplify tree
 function combineOperators(tree::Node)::Node
     # (const (+*) const) already accounted for
     # ((const + var) + const) => (const + var)
@@ -478,7 +478,7 @@ function combineOperators(tree::Node)::Node
     return tree
 end
 
-# Simplify tree 
+# Simplify tree
 function simplifyTree(tree::Node)::Node
     if tree.degree == 1
         tree.l = simplifyTree(tree.l)
@@ -499,11 +499,23 @@ function simplifyTree(tree::Node)::Node
     return tree
 end
 
+# Define a member of population by equation, score, and age
+mutable struct PopMember
+    tree::Node
+    score::Float32
+    birth::Int32
+
+    PopMember(t::Node) = new(t, scoreFunc(t), getTime())
+    PopMember(t::Node, score::Float32) = new(t, score, getTime())
+
+end
+
 # Go through one simulated annealing mutation cycle
 #  exp(-delta/T) defines probability of accepting a change
-function iterate(tree::Node, T::Float32)::Node
-    prev = tree
-    tree = copyNode(tree)
+function iterate(member::PopMember, T::Float32)::PopMember
+    prev = member.tree
+    tree = copyNode(prev)
+    beforeLoss = member.score
 
     mutationChoice = rand()
     weightAdjustmentMutateConstant = min(8, countConstants(tree))/8.0
@@ -526,25 +538,25 @@ function iterate(tree::Node, T::Float32)::Node
     elseif mutationChoice < cweights[6]
         tree = simplifyTree(tree) # Sometimes we simplify tree
         tree = combineOperators(tree) # See if repeated constants at outer levels
-        return tree
+        return PopMember(tree, beforeLoss)
     elseif mutationChoice < cweights[7]
         tree = genRandomTree(5) # Sometimes we simplify tree
     else
-        return tree
+        return PopMember(tree, beforeLoss)
     end
 
+    afterLoss = scoreFunc(tree)
+
     if annealing
-        beforeLoss = scoreFunc(prev)
-        afterLoss = scoreFunc(tree)
         delta = afterLoss - beforeLoss
         probChange = exp(-delta/(T*alpha))
 
-        if isnan(afterLoss) || probChange < rand()
-            return copyNode(prev)
+        return_unaltered = (isnan(afterLoss) || probChange < rand())
+        if return_unaltered
+            return PopMember(copyNode(prev), beforeLoss)
         end
     end
-
-    return tree
+    return PopMember(tree, afterLoss)
 end
 
 # Create a random equation by appending random operators
@@ -557,17 +569,6 @@ function genRandomTree(length::Integer)::Node
 end
 
 
-# Define a member of population by equation, score, and age
-mutable struct PopMember
-    tree::Node
-    score::Float32
-    birth::Int32
-
-    PopMember(t::Node) = new(t, scoreFunc(t), getTime())
-    PopMember(t::Node, score::Float32) = new(t, score, getTime())
-
-end
-
 # A list of members of the population, with easy constructors,
 #  which allow for random generation of new populations
 mutable struct Population
@@ -602,11 +603,7 @@ end
 # Mutate the best sampled member of the population
 function iterateSample(pop::Population, T::Float32)::PopMember
     allstar = bestOfSample(pop)
-    new = iterate(allstar.tree, T)
-    allstar.tree = new
-    allstar.score = scoreFunc(new)
-    allstar.birth = getTime()
-    return allstar
+    return iterate(allstar, T)
 end
 
 # Pass through the population several times, replacing the oldest
@@ -905,4 +902,3 @@ function fullRun(niterations::Integer;
         end
     end
 end
-