Changeset 16230 for branches/2929_PrioritizedGrammarEnumeration/HeuristicLab.Algorithms.DataAnalysis.PGE/3.3/go-code/go-pge/pge

Timestamp:

10/11/18 11:37:54 (6 years ago)

Author:

hmaislin

Message:

#2929: Adapted pge plugin to check for null value

File:

• branches/2929_PrioritizedGrammarEnumeration/HeuristicLab.Algorithms.DataAnalysis.PGE/3.3/go-code/go-pge/pge/pge_search.go (modified) (27 diffs)

branches/2929_PrioritizedGrammarEnumeration/HeuristicLab.Algorithms.DataAnalysis.PGE/3.3/go-code/go-pge/pge/pge_search.go

@@ -17 +17 @@
 )
 
-type pgeConfig struct {
+type PgeConfig struct {
   // search params
   maxGen        int
@@ -40 +40 @@
 func pgeConfigParser(field, value string, config interface{}) (err error) {
 
-  PC := config.(*pgeConfig)
+  PC := config.(*PgeConfig)
 
   switch strings.ToUpper(field) {
@@ -92 +92 @@
 type PgeSearch struct {
   id   int
-  cnfg pgeConfig
+  cnfg PgeConfig
   prob *probs.ExprProblem
   iter int
@@ -151 +151 @@
   return PS.cnfg.maxGen
 }
+func (PS *PgeSearch) GetPeelCount() int {
+  return PS.cnfg.peelCnt
+}
 func (PS *PgeSearch) SetMaxIter(iter int) {
   PS.cnfg.maxGen = iter
@@ -180 +183 @@
 
 func (PS *PgeSearch) Init(done chan int, prob *probs.ExprProblem, logdir string, input interface{}) {
-  fmt.Printf("Init'n PGE\n")
+
+  //fmt.Printf("Init'n PGE\n")
   // setup data
 
   // open logs
   PS.initLogs(logdir)
+  
+  PS.stop = false
 
   // copy in common config options
@@ -195 +201 @@
   PS.cnfg.simprules = srules
 
-  fmt.Println("Roots:   ", PS.cnfg.treecfg.RootsS)
-  fmt.Println("Nodes:   ", PS.cnfg.treecfg.NodesS)
-  fmt.Println("Leafs:   ", PS.cnfg.treecfg.LeafsS)
-  fmt.Println("NonTrig: ", PS.cnfg.treecfg.NonTrigS)
+  //fmt.Println("Roots:   ", PS.cnfg.treecfg.RootsS)
+  //fmt.Println("Nodes:   ", PS.cnfg.treecfg.NodesS)
+  //fmt.Println("Leafs:   ", PS.cnfg.treecfg.LeafsS)
+  //fmt.Println("NonTrig: ", PS.cnfg.treecfg.NonTrigS)
 
   PS.GenRoots = make([]expr.Expr, len(PS.cnfg.treecfg.Roots))
@@ -212 +218 @@
     PS.GenNonTrig[i] = PS.cnfg.treecfg.NonTrig[i].Clone()
   }
+  
+  fmt.Printf("Init1 %v\n", len(PS.cnfg.treecfg.LeafsT))
 
   PS.GenLeafs = make([]expr.Expr, 0)
@@ -220 +228 @@
 
     case expr.VAR:
-      fmt.Println("Use Vars: ", PS.cnfg.treecfg.UsableVars)
+      //fmt.Println("Use Vars: ", PS.cnfg.treecfg.UsableVars)
       for _, i := range PS.cnfg.treecfg.UsableVars {
         PS.GenLeafs = append(PS.GenLeafs, expr.NewVar(i))
@@ -232 +240 @@
     }
   }
+  fmt.Printf("Init2\n")
   /*** FIX ME
   PS.GenLeafs = make([]expr.Expr, len(PS.cnfg.treecfg.Leafs))
@@ -238 +247 @@
   }
   ***/
-
-  fmt.Println("Roots:   ", PS.GenRoots)
-  fmt.Println("Nodes:   ", PS.GenNodes)
-  fmt.Println("Leafs:   ", PS.GenLeafs)
-  fmt.Println("NonTrig: ", PS.GenNonTrig)
+  
+  fmt.Printf("Init3\n")
+
+  //fmt.Println("Roots:   ", PS.GenRoots)
+  //fmt.Println("Nodes:   ", PS.GenNodes)
+  //fmt.Println("Leafs:   ", PS.GenLeafs)
+  //fmt.Println("NonTrig: ", PS.GenNonTrig)
 
   // setup communication struct
@@ -254 +265 @@
   PS.Best = probs.NewReportQueue()
   PS.Best.SetSort(probs.GPSORT_PARETO_TST_ERR)
+  fmt.Printf("Init4\n")
+
   PS.Queue = PS.GenInitExpr()
   PS.Queue.SetSort(probs.PESORT_PARETO_TST_ERR)
@@ -264 +277 @@
   PS.eval_out = make(chan *probs.ExprReport, 4048)
 
+  fmt.Printf("Init5a\n")
   for i := 0; i < PS.cnfg.evalrCount; i++ {
     go PS.Evaluate()
   }
+  fmt.Printf("Init5\n")
 }
 
@@ -276 +291 @@
       continue
     }
-    PS.eval_out <- RegressExpr(e, PS.prob)
+    re := RegressExpr(e, PS.prob)
+    //fmt.Printf("reg: %v\n", re)
+    PS.eval_out <- re
   }
 
@@ -284 +301 @@
   fmt.Printf("Running PGE\n")
 
-  PS.loop()
+  PS.Loop()
 
   fmt.Println("PGE exitting")
@@ -292 +309 @@
 }
 
-func (PS *PgeSearch) loop() {
+func (PS *PgeSearch) Loop() {
 
   PS.checkMessages()
@@ -298 +315 @@
 
     fmt.Println("in: PS.step() ", PS.iter)
-    PS.step()
+    PS.Step()
 
     // if PS.iter%PS.cnfg.pgeRptEpoch == 0 {
@@ -348 +365 @@
 }
 
-func (PS *PgeSearch) step() {
-
+func (PS *PgeSearch) Step() {
   loop := 0
   eval_cnt := 0 // for channeled eval
@@ -429 +445 @@
   // } // for sequential eval
   PS.Queue.Sort()
-
 }
 
@@ -435 +450 @@
   es := make([]*probs.ExprReport, PS.cnfg.peelCnt)
   for p := 0; p < PS.cnfg.peelCnt && PS.Queue.Len() > 0; p++ {
-
     e := PS.Queue.Pop().(*probs.ExprReport)
-
     bPush := true
     if len(e.Coeff()) == 1 && math.Abs(e.Coeff()[0]) < PS.cnfg.zeroEpsilon {
@@ -446 +459 @@
 
     if bPush {
-      fmt.Printf("pop/push(%d,%d): %v\n", p, PS.Best.Len(), e.Expr())
+      fmt.Printf("pop/push DO(%d,%d): %v\n", p, PS.Best.Len(), e.Expr())
       PS.Best.Push(e)
     }
@@ -466 +479 @@
   return es
 }
+
+
+type PeelResult struct {
+  Es *probs.ExprReport
+
+  Nobestpush bool
+  BestNewMinErr bool
+  
+  Bestlen1 int
+  Bestlen2 int
+  
+  Coeff []float64
+  TestScore int
+  
+  Expre expr.Expr
+  ExpreRe *probs.ExprReport
+}
+
+//Problem
+func (PS *PgeSearch) SingleStep() []*PeelResult {
+  if os.Getenv("PGEDEBUG") == "1" {
+    fmt.Printf("Init PgeSearch: %#v \n", PS)
+    fmt.Printf("Init PgeProblem: %#v \n", PS.prob)
+  }
+
+
+  loop := 0
+  eval_cnt := 0
+  PR := PS.peelRes()
+  
+  es := make([]*probs.ExprReport, len(PR))
+  
+  for i, elem := range PR {
+    if(elem != nil) {
+      es[i] = elem.ExpreRe
+    //} else {
+    //  es[i] = new(probs.ExprReport)
+    }
+  }
+  
+  ex := PS.expandPeeled(es)
+
+  for cnt := range ex {
+    E := ex[cnt]
+    if E == nil {
+      continue
+    }
+    for _, e := range E {
+      if e == nil {
+        continue
+      }
+      if !PS.cnfg.treecfg.CheckExpr(e) {
+        continue
+      }
+      serial := make([]int, 0, 64)
+      serial = e.Serial(serial)
+      ins := PS.Trie.InsertSerial(serial)
+      
+      if !ins {
+        continue
+      }
+      PS.eval_in <- e
+      eval_cnt++
+    }
+  }
+  for i := 0; i < eval_cnt; i++ {
+    re := <-PS.eval_out
+    if math.IsNaN(re.TestError()) || math.IsInf(re.TestError(), 0) {
+      continue
+    }
+    if re.TestError() < PS.minError {
+      PS.minError = re.TestError()
+    }
+    doIns := true
+    for _, c := range re.Coeff() {
+      if math.Abs(c) < PS.cnfg.zeroEpsilon {
+        doIns = false
+        break
+      }
+    }
+    if doIns {
+      re.SetProcID(PS.id)
+      re.SetIterID(PS.iter)
+      re.SetUnitID(loop)
+      re.SetUniqID(PS.neqns)
+      loop++
+      PS.neqns++
+      PS.Queue.Push(re)
+    }
+  }
+  PS.Queue.Sort()
+
+  PS.reportExpr() 
+  PS.iter++
+  
+  return PR
+}
+
+//Problem
+func (PS *PgeSearch) peelRes() []*PeelResult {
+  //es := make([]*probs.ExprReport, PS.cnfg.peelCnt)
+  PRes := make([]*PeelResult, PS.cnfg.peelCnt)
+  
+  for p := 0; p < PS.cnfg.peelCnt && PS.Queue.Len() > 0; p++ {
+    PR := new(PeelResult)
+      
+    PR.BestNewMinErr = false
+    PR.Nobestpush = false
+    
+    e := PS.Queue.Pop().(*probs.ExprReport)
+    
+    bPush := true
+    if len(e.Coeff()) == 1 && math.Abs(e.Coeff()[0]) < PS.cnfg.zeroEpsilon {
+      //fmt.Println("No Best Push")
+      PR.Nobestpush = true
+      p--
+      continue
+    }
+
+    if bPush {
+      //fmt.Printf("pop/push (%d,%d): %v\n", p, PS.Best.Len(), e.Expr())
+      PS.Best.Push(e)
+    }
+
+    //es[p] = e
+    PR.Bestlen1 = p
+    PR.Bestlen2 = PS.Best.Len()
+    PR.Expre = e.Expr()
+    PR.ExpreRe = e
+    PR.Es = e
+    PR.Coeff = e.Coeff()
+    PR.TestScore = e.TestScore()
+    
+    
+    if e.TestScore() > PS.maxScore {
+      PS.maxScore = e.TestScore()
+    }
+    if e.TestError() < PS.minError {
+      PS.minError = e.TestError()
+      PR.BestNewMinErr = true
+      //fmt.Printf("Best New Min Error:  %v\n", e)
+    }
+    if e.Size() > PS.maxSize {
+      PS.maxSize = e.Size()
+    }
+    
+    PRes[p] = PR
+  }
+  
+  return PRes
+}
+
 
 func (PS *PgeSearch) expandPeeled(es []*probs.ExprReport) [][]expr.Expr {
@@ -487 +652 @@
     // fmt.Println()
   }
-  fmt.Println("\n")
   return eqns
 }
@@ -523 +687 @@
 
 func (PS *PgeSearch) Clean() {
-  // fmt.Printf("Cleaning PGE\n")
-
   PS.errLogBuf.Flush()
   PS.mainLogBuf.Flush()
@@ -530 +692 @@
   PS.fitnessLogBuf.Flush()
   PS.ipreLogBuf.Flush()
-
 }
 
@@ -605 +766 @@
   if len(guess) > 0 {
 
-    // fmt.Printf("x_dims:  %d  %d\n", x_dim, x_dim2)
+    //fmt.Printf("IMREGEXP %v %v\n", P.SearchType, P.SearchVar)
+    //fmt.Printf("REGPTrain %T | %#v | %v\n", P.Train, P.Train, P.Train)
+    //fmt.Printf("eqn %T | %#v | %v\n", eqn, eqn, eqn)
+    //fmt.Printf("guess %T | %#v | %v\n", guess, guess, guess)
 
     // Callback version
+    
+    
     coeff = levmar.LevmarExpr(eqn, P.SearchVar, P.SearchType, guess, P.Train, P.Test)
+    
 
     // Stack version
@@ -641 +808 @@
   R = new(probs.ExprReport)
   R.SetExpr(eqn) /*.ConvertToConstantFs(coeff)*/
+
   R.SetCoeff(coeff)
   R.Expr().CalcExprStats()
@@ -707 +875 @@
   return
 }
+
+func (PS *PgeSearch) CreateDS(maxGen int, pgeRptEpoch int, pgeRptCount int, pgeArchiveCap int, peelCnt int, evalrCount int, zeroEpsilon float64, initMethod string, growMethod string, sortType int) {
+  PS.id = 0 //maxGen
+  
+  var PC PgeConfig
+  
+  PC.pgeRptEpoch = pgeRptEpoch
+  PC.pgeRptCount = pgeRptCount
+  PC.pgeArchiveCap = pgeArchiveCap
+  PC.peelCnt = peelCnt
+  PC.evalrCount = evalrCount
+  PC.zeroEpsilon = zeroEpsilon
+  PC.initMethod = initMethod
+  PC.growMethod = growMethod
+
+  if sortType == 1 {
+    PC.sortType = probs.PESORT_PARETO_TRN_ERR
+  } else {  
+    PC.sortType = probs.PESORT_PARETO_TST_ERR
+  }
+
+  PC.maxGen = maxGen
+  PS.cnfg = PC
+    
+  PS.iter = 0
+}
+
+func (PS *PgeSearch) SetProb(ep *probs.ExprProblem) {
+  PS.prob = ep
+}
+func (PS *PgeSearch) GetIter() int {
+  return PS.iter
+}