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

Timestamp:

01/07/19 06:59:25 (6 years ago)

Author:

hmaislin

Message:

#2929: Updated DLL, result error seems to be fixed, more testing is necessary

Location:

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

Files:

• pge.go (modified) (4 diffs)
• pge_search.go (modified) (29 diffs)

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

@@ -72 +72 @@
 //export AddTrainData
 func AddTrainData(indepNames *C.char, depndNames *C.char, matrix unsafe.Pointer, nEntries int) {
-  trainDatas = make([]*probs.PointSet, 1)
+  trainDatas = make([]*probs.PointSet, 1) //wieso bin i do und ned im initsearch oda so !!
   trainData = new(probs.PointSet)
   
@@ -112 +112 @@
   goName := C.GoString(Name)
   goProblemTypeString := C.GoString(ProblemTypeString)
-  fmt.Printf("1\n")
   
   ep.CreatePS(goName, MaxIter, HitRatio, SearchVar, goProblemTypeString)
   ep.TreeCfg = tp;
   ep.UsableVars = tp.UsableVars
-  fmt.Printf("2\n")
   
   cps.SetMaxIter(MaxIter)
   per_eqns = make([]*probs.ExprReportArray, 1)
-  fmt.Printf("3\n")
   
   ep.Train = trainDatas
   ep.Test = testDatas
-  fmt.Printf("4\n")
   
   initDone := make(chan int)
   rt.GOMAXPROCS(numProcs)
   rand.Seed(rand.Int63())
-  fmt.Printf("5\n")
   
   epcomm = new(probs.ExprProblemComm)
@@ -138 +133 @@
   epcomm.Gen = make(chan [2]int, 64)
   
-  fmt.Printf("6\n")
-  
   cps.SetProb(ep)
-  cps.Init(initDone, ep, "dummy", epcomm)
-  fmt.Printf("7\n")
+  cps.Init(initDone, ep, "", epcomm)
 }
 
@@ -252 +244 @@
   if ok && resu != nil {
     stepResult = *resu
-    nNew = nRes - nLastResults
-    nLastResults = nRes
+    nNew = nRes // - nLastResults
+    nLastResults = 0 //nRes
   }
     

branches/2929_PrioritizedGrammarEnumeration/HeuristicLab.Algorithms.DataAnalysis.PGE/3.3/go-code/go-pge/plug/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() {
-
+
+type PeelResult struct {
+  Es *probs.ExprReport
+
+  Nobestpush bool
+  BestNewMinErr bool
+  
+  Bestlen1 int
+  Bestlen2 int
+  
+  Coeff []float64
+  TestScore int
+  
+  Expre expr.Expr
+  ExpreRe *probs.ExprReport
+}
+
+func (PS *PgeSearch) SingleStep2() {
   loop := 0
   eval_cnt := 0 // for channeled eval
@@ -411 +444 @@
       }
     }
-
+    
+    if doIns {
+      re.SetProcID(PS.id)
+      re.SetIterID(PS.iter)
+      re.SetUnitID(loop)
+      re.SetUniqID(PS.neqns)
+      loop++
+      PS.neqns++
+      
+      //fmt.Printf("SS2Queue.Push(): %v\n%v\n\n", re.Expr(), serial)
+      ////fmt.Printf("INSQueue.Push(): %v\n", re)
+      ////fmt.Printf("INSQueue.Push(): %v\n", re.Expr())
+
+      PS.Queue.Push(re)
+
+    }
+  }
+  // } // for sequential eval
+  PS.Queue.Sort()                                                                                                                                       
+}
+
+//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) Step() int {
+
+  loop := 0
+  eval_cnt := 0 // for channeled eval
+
+  es := PS.peel()
+
+  ex := PS.expandPeeled(es)
+  
+  cnt_ins := 0
+
+  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
+      }
+
+      // check ipre_trie
+      serial := make([]int, 0, 64)
+      serial = e.Serial(serial)
+      ins := PS.Trie.InsertSerial(serial)
+      if !ins {
+        continue
+      }
+
+      // for serial eval
+      // re := RegressExpr(e, PS.prob)
+
+      // start channeled eval
+      PS.eval_in <- e
+      eval_cnt++
+    }
+  }
+  
+  for i := 0; i < eval_cnt; i++ {
+    re := <-PS.eval_out
+    // end channeled eval
+
+    // check for NaN/Inf in re.error  and  if so, skip
+    if math.IsNaN(re.TestError()) || math.IsInf(re.TestError(), 0) {
+      // fmt.Printf("Bad Error\n%v\n", re)
+      continue
+    }
+
+    if re.TestError() < PS.minError {
+      PS.minError = re.TestError()
+    }
+
+    // check for coeff == 0
+    doIns := true
+    for _, c := range re.Coeff() {
+      // i > 0 for free coeff
+      if math.Abs(c) < PS.cnfg.zeroEpsilon {
+        doIns = false
+        break
+      }
+    }
+
+    //fmt.Printf("StepQueue.Push(): %v\n", re)
+    //fmt.Printf("StepQueue.Push(): %v\n", re.Expr())
+    
     if doIns {
       re.SetProcID(PS.id)
@@ -422 +679 @@
       // fmt.Printf("Queue.Push(): %v\n", re)
       // fmt.Printf("Queue.Push(): %v\n", re.Expr())
-
+      cnt_ins++
       PS.Queue.Push(re)
-
     }
   }
@@ -430 +686 @@
   PS.Queue.Sort()
 
+  PS.iter++
+  PS.reportExpr() //new
+  return 3
 }
 
 func (PS *PgeSearch) peel() []*probs.ExprReport {
   es := make([]*probs.ExprReport, PS.cnfg.peelCnt)
+  
+  rpt := make(probs.ExprReportArray, 0)
+  
   for p := 0; p < PS.cnfg.peelCnt && PS.Queue.Len() > 0; p++ {
 
@@ -440 +702 @@
     bPush := true
     if len(e.Coeff()) == 1 && math.Abs(e.Coeff()[0]) < PS.cnfg.zeroEpsilon {
-      fmt.Println("No Best Push")
+      ////fmt.Println("No Best Push")
       p--
       continue
@@ -446 +708 @@
 
     if bPush {
-      fmt.Printf("pop/push(%d,%d): %v\n", p, PS.Best.Len(), e.Expr())
+      fmt.Printf("BEST PUSH/push(%d,%d): %v\n", p, PS.Best.Len(), e.Expr())
       PS.Best.Push(e)
+      rpt = append(rpt, e)
     }
 
@@ -457 +720 @@
     if e.TestError() < PS.minError {
       PS.minError = e.TestError()
-      fmt.Printf("Best New Min Error:  %v\n", e)
+      ////fmt.Printf("Best New Min Error:  %v\n", e)
     }
     if e.Size() > PS.maxSize {
       PS.maxSize = e.Size()
     }
-
-  }
+    
+  }
+  PS.commup.Rpts <- &rpt
   return es
 }
@@ -491 +755 @@
 }
 
-func (PS *PgeSearch) reportExpr() {
-
+//Hier ist das pgeRpt problem, liefert immer die besten pgerpt cnt ergebnisse zurck und ich schneide aus arrazy, werden auch unsortiert
+// //*
+func (PS *PgeSearch) reportExpr() int {
+  //PS.cnfg.pgeRptCount++
   cnt := PS.cnfg.pgeRptCount
-  PS.Best.Sort()
+  //*PS.Best.Sort()
 
   // repot best equations
   rpt := make(probs.ExprReportArray, cnt)
-  if PS.Best.Len() < cnt {
-    cnt = PS.Best.Len()
-  }
+  //*if PS.Best.Len() < cnt {
+  //* cnt = PS.Best.Len()
+  //*}
   copy(rpt, PS.Best.GetQueue()[:cnt])
 
@@ -513 +779 @@
   }
 
-  PS.mainLog.Printf("Iter: %d  %f  %f\n", PS.iter, errSum/float64(errCnt), PS.minError)
+  ////fmt.Printf("Iter: %d  %f  %f\n", PS.iter, errSum/float64(errCnt), PS.minError)
 
   PS.ipreLog.Println(PS.iter, PS.neqns, PS.Trie.cnt, PS.Trie.vst)
   PS.fitnessLog.Println(PS.iter, PS.neqns, PS.Trie.cnt, PS.Trie.vst, errSum/float64(errCnt), PS.minError)
 
-  PS.commup.Rpts <- &rpt
-
+  //PS.commup.Rpts <- &rpt
+  
+  return errCnt
 }
 
 func (PS *PgeSearch) Clean() {
-  // fmt.Printf("Cleaning PGE\n")
-
   PS.errLogBuf.Flush()
   PS.mainLogBuf.Flush()
@@ -530 +795 @@
   PS.fitnessLogBuf.Flush()
   PS.ipreLogBuf.Flush()
-
 }
 
@@ -605 +869 @@
   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 +911 @@
   R = new(probs.ExprReport)
   R.SetExpr(eqn) /*.ConvertToConstantFs(coeff)*/
+
   R.SetCoeff(coeff)
   R.Expr().CalcExprStats()
@@ -707 +978 @@
   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.Stop = false is in init
+  PS.iter = 0
+}
+
+func (PS *PgeSearch) SetProb(ep *probs.ExprProblem) {
+  PS.prob = ep
+}
+func (PS *PgeSearch) GetIter() int {
+  return PS.iter
+}