示例#1
0
 def __init__(self, model = "Schaffer"):
   self.evals = 0
   
   if model == "Schaffer":
     self.model = Schaffer()
   elif model == "Osyczka":
     self.model = Osyczka()
   elif model == "Golinski":
     self.model = Golinski()
   elif model == "Kursawe":
     self.model = Kursawe()
示例#2
0
文件: SA.py 项目: nkudige/x9115DMN
 def __init__(self, model = "Schaffer"):
   self.evals = 0
   
   if model == "Schaffer":
     self.model = Schaffer()
   elif model == "Osyczka":
     self.model = Osyczka()
   elif model == "Golinski":
     self.model = Golinski()
   elif model == "Kursawe":
     self.model = Kursawe()
示例#3
0
 def objs(self, x):
     mod = Kursawe()
     min_objs, max_objs = mod.baseline_objs()
     frontier = ga(x[0], x[1], x[2]).run(mod)
     filename = "hyper.out"
     Utility.write_to_file(mod, filename, frontier, min_objs, max_objs)
     output = HyperVolume_wrapper()
     ## Will always
     hve = 0
     for out in output:
         hve = out.hypervolume
     return hve
示例#4
0
 def objs(self, x):
     mod = Kursawe()
     min_objs, max_objs = mod.baseline_objs()
     frontier = ga(x[0], x[1], x[2]).run(mod)
     filename = "hyper.out"
     Utility.write_to_file(mod, filename, frontier, min_objs, max_objs)
     output = HyperVolume_wrapper()
     ## Will always
     hve = 0
     for out in output:
         hve = out.hypervolume
     return hve
示例#5
0
 def __init__(self, model = "Kursawe", probability = 0.5, no_steps = 10, baseline_top = -10**6, baseline_bottom = 10**6):
         self.n = 6
         self.p = probability
         self.evals = 0
         self.steps = no_steps
         self.number_of_evaluations = 0
         self.threshold = - 400
         if model == "Osyczka":
                 self.model = Osyczka()
         elif model == "Golinski":
                 self.model = Golinski()
         elif model == "Kursawe":
                 self.model = Kursawe()
         self.model.resetBaselines()
         self.current_state = self.model.get_random_state()
示例#6
0
 def __init__(self,
              model="Kursawe",
              probability=0.5,
              no_steps=20,
              baseline_top=-10**6,
              baseline_bottom=10**6):
     self.n = 6
     self.p = probability
     self.evals = 0
     self.steps = no_steps
     self.number_of_evaluations = 0
     self.threshold = -400
     if model == "Osyczka":
         self.model = Osyczka()
     elif model == "Golinski":
         self.model = Golinski()
     elif model == "Kursawe":
         self.model = Kursawe()
     elif model == "Schaffer":
         self.model = Schaffer()
     elif model == "DTLZ7":
         self.model = DTLZ7(10, 2)
     self.model.resetBaselines()
     #self.threshold = self.model.baseline_low
     self.current_state = self.model.get_random_state()
示例#7
0
 def __init__(self, model="Osyczka"):
     self.top_bound = [3.6, 0.8, 28.0, 8.3, 8.3, 3.9, 5.5]
     self.bottom_bound = [2.6, 0.7, 17.0, 7.3, 7.3, 2.9, 5]
     self.f2_high = -10**6
     self.f2_low = 10**6
     self.f1_high = -10**6
     self.f1_low = 10**6
     self.evals = 0
     self.median = []
     if model == "Osyczka":
         self.model = Osyczka()
     elif model == "Golinski":
         self.model = Golinski()
     elif model == "Kursawe":
         self.model = Kursawe()
     elif model == "Schaffer":
         self.model = Schaffer()
     self.best_solution = Thing()
     self.best_solution.score = 0
     self.best_solution.energy = 1
     self.best_solution.have = []
示例#8
0
class SA:
    def __init__(self, model="Schaffer"):
        self.evals = 0
        if model == "Schaffer":
            self.model = Schaffer()
        elif model == "Osyczka":
            self.model = Osyczka()
        elif model == "Golinski":
            self.model = Golinski()
        elif model == "Kursawe":
            self.model = Kursawe()
        elif model == "DTLZ7":
            self.model = DTLZ7(10, 2)

    def __repr__(self):
        return time.strftime(
            "%Y-%m-%d %H:%M:%S"
        ) + "\nSimulated Annealing on the Schaffer model\n"

    def P(self, old_e, new_e, k):
        return math.e**((old_e - new_e) / k)

    def run(self):
        kmax = 1000
        max_e = -0.1
        output = ''

        current_s = self.model.get_random_state()
        best_s = current_s

        current_e = self.model.normalize_energy(self.model.energy(current_s))
        best_e = current_e
        MAX_LIVES = 10
        ERA_LENGTH = 100
        k = 1
        era_List = []
        current_era = []
        lives = MAX_LIVES
        while k < kmax and current_e > max_e:
            neighbor_s = self.model.get_random_state()
            # print 'Neighbor: ' + str(neighbor_s)

            neighbor_e = self.model.normalize_energy(
                self.model.energy(neighbor_s))
            # print current_e, neighbor_e, tmp
            if self.model.type1(best_s, neighbor_s):
                # print "Neighbor better " + str(best_e) + " " + str(neighbor_e)
                best_s, best_e = neighbor_s, neighbor_e
                temp = ' !'

            if self.model.type1(neighbor_s, current_s):
                current_s, current_e = neighbor_s, neighbor_e
                temp = ' +'

            elif self.P(current_e, neighbor_e,
                        (1 - (float(k) / kmax))**5) > random():
                current_s, current_e = neighbor_s, neighbor_e
                temp = ' ?'

            else:
                temp = ' .'

            if temp != ' .':
                current_era.append(neighbor_s)
                if len(current_era) == ERA_LENGTH:
                    #print current_era
                    if len(era_List) > 0:
                        increment = self.model.type2(current_era, era_List[-1])
                        lives += increment
                        if increment <= 0:
                            print "Reducing lives by 1"
                        if lives <= 0:
                            print "Early termination"
                            return best_e
                    era_List.append(current_era)
                    current_era = []

            output += temp
            if k % 25 == 0:
                print output + "Best state: ", best_e
                output = ''

            k += 1

        print 'Best State Found: ' + str(best_s)
        print 'Energy At Best State: ' + str(best_e)

        return best_e
示例#9
0
class MaxWalkSat:
        def __init__(self, model = "Kursawe", probability = 0.5, no_steps = 10, baseline_top = -10**6, baseline_bottom = 10**6):
                self.n = 6
                self.p = probability
                self.evals = 0
                self.steps = no_steps
                self.number_of_evaluations = 0
                self.threshold = - 400
                if model == "Osyczka":
                        self.model = Osyczka()
                elif model == "Golinski":
                        self.model = Golinski()
                elif model == "Kursawe":
                        self.model = Kursawe()
                self.model.resetBaselines()
                self.current_state = self.model.get_random_state()

        def modify_to_better_state(self, state, index):
                if(index > len(self.model.top_bound)):
                        return None
                increment = (self.model.top_bound[index] - self.model.bottom_bound[index])/self.steps
                temp_state = list(state)
                best_state = state
                for _ in range(0, self.steps):
                        temp_state[index] += increment
                        self.evals += 1
                        if self.model.energy(temp_state) < self.model.energy(best_state) and self.model.are_constraints_satisfied(temp_state):
                                best_state = list(temp_state)
                state = best_state
                return state

        def retry(self, state):
                index = randint(0, (self.model.getNumberOfDecisions() - 1))
                temp_state = list(state)
                if self.p < random():
                        #print self.model.bottom_bound[index]
                        #print self.model.top_bound[index]
                        temp_state[index] = self.model.bottom_bound[index] + (self.model.top_bound[index] - self.model.bottom_bound[index])*random()
                        if self.model.are_constraints_satisfied(temp_state):
                                return temp_state
                        else:
                                return state
                else:
                        temp_state = self.modify_to_better_state(temp_state, index)
                        if temp_state == state:
                                return temp_state
                        else:
                                return temp_state

        def run(self):
                max_tries = 100
                max_changes = 50
                self.model.resetBaselines()
                best_state = self.model.get_random_state()
                output = str()
                for _ in range(0, max_tries):
                        current_state = self.model.get_random_state()
                        for i in range(0, max_changes):
                                if self.model.energy(current_state) < self.threshold:
                                        return current_state
                                else:
                                        new_state = self.retry(current_state)
                                operation = ""
                                if self.model.energy(new_state) > self.model.energy(best_state):
                                        best_state = new_state
                                        operation = "!"
                                elif self.model.energy(new_state) > self.model.energy(current_state):
                                        operation = "+"        
                                elif self.model.energy(new_state) < self.model.energy(current_state):
                                        operation = "."
                                output += operation
                                if len(output) == 50:
                                        print output + " current best state energy(normalized) = " + str(self.model.energy(best_state)) + " Evaluations: " + str(self.evals)
                                        output = ""
                print output + " current best state energy(normalized) = " + str(self.model.aggregate_energy(best_state)) + " Evaluations: " + str(self.evals)
                return best_state
示例#10
0
文件: SA.py 项目: nkudige/x9115DMN
class SA:
  def __init__(self, model = "Schaffer"):
    self.evals = 0
    
    if model == "Schaffer":
      self.model = Schaffer()
    elif model == "Osyczka":
      self.model = Osyczka()
    elif model == "Golinski":
      self.model = Golinski()
    elif model == "Kursawe":
      self.model = Kursawe()

  def __repr__(self):
    return time.strftime("%Y-%m-%d %H:%M:%S") + "\nSimulated Annealing on the Schaffer model\n"
  
  def P(self, old_e, new_e, k):
    return math.e ** ((old_e - new_e) / k)

  def run(self):
    kmax = 1000
    max_e = -0.1
    output = ''
    
    current_s = self.model.get_random_state()
    best_s = current_s
    
    current_e = self.model.normalize_energy(self.model.energy(current_s), self.model.baseline_low, self.model.baseline_high)
    best_e = current_e
    
    k = 1
    current_era = []
    eras = []
    lives = 5
    ERA_LENGTH = 10
    while k < kmax and current_e > max_e:
      neighbor_s = self.model.get_random_state()
      # print 'Neighbor: ' + str(neighbor_s)
      neighbor_e = self.model.normalize_energy(self.model.energy(neighbor_s), self.model.baseline_low, self.model.baseline_high)
      # print current_e, neighbor_e, tmp
      
      if neighbor_e < best_e:
        best_s, best_e = neighbor_s, neighbor_e
        output += ' !'
      
      if neighbor_e < current_e:
        current_s, current_e = neighbor_s, neighbor_e
        output += ' +'
        
      elif self.P(current_e, neighbor_e, (1-(float(k)/kmax))**5) > random.random():
        current_s, current_e = neighbor_s, neighbor_e
        output += ' ?'
        
      else:
        output += ' .'
      
      current_era.append(self.model.normalize_energy(current_e, self.model.baseline_low, self.model.baseline_high))
      if len(current_era) == ERA_LENGTH and len(eras) > 0:
        if a12(current_era, eras[-1]) < 0.56:
          lives -= 1
          print "Lives:" + str(lives) + " a12 statistic:" + str(a12(current_era, eras[-1])),
        else:
          lives = 5
      if len(current_era) == ERA_LENGTH:
        eras.append(current_era)
        current_era = []
        if lives <= 0:
          print "Early termination"
          break
      if k % 25 == 0:
        print ', %4d, : %d, %25s' % (k, self.model.denormalize_energy(best_e), output)
        output = ''
    
      k += 1
      
    print
    print 'Best State Found: ' + str(best_s)
    print 'Energy At Best State: ' + str(self.model.denormalize_energy(best_e))
    print
    
    return best_e
示例#11
0
class SA:
  def __init__(self, model = "Schaffer"):
    self.evals = 0
    
    if model == "Schaffer":
      self.model = Schaffer()
    elif model == "Osyczka":
      self.model = Osyczka()
    elif model == "Golinski":
      self.model = Golinski()
    elif model == "Kursawe":
      self.model = Kursawe()

  def __repr__(self):
    return time.strftime("%Y-%m-%d %H:%M:%S") + "\nSimulated Annealing on the Schaffer model\n"
  
  def P(self, old_e, new_e, k):
    return math.e ** ((old_e - new_e) / k)

  def run(self):
    kmax = 1000
    max_e = -0.1
    output = ''
    
    current_s = self.model.get_random_state()
    best_s = current_s
    
    current_e = self.model.normalize_energy(self.model.energy(current_s), self.model.baseline_low, self.model.baseline_high)
    best_e = current_e
    
    k = 1
    
    while k < kmax and current_e > max_e:
      neighbor_s = self.model.get_random_state()
      # print 'Neighbor: ' + str(neighbor_s)
      neighbor_e = self.model.normalize_energy(self.model.energy(neighbor_s), self.model.baseline_low, self.model.baseline_high)
      # print current_e, neighbor_e, tmp
      
      if neighbor_e < best_e:
        best_s, best_e = neighbor_s, neighbor_e
        output += ' !'
      
      if neighbor_e < current_e:
        current_s, current_e = neighbor_s, neighbor_e
        output += ' +'
        
      elif self.P(current_e, neighbor_e, (1-(float(k)/kmax))**5) > random.random():
        current_s, current_e = neighbor_s, neighbor_e
        output += ' ?'
        
      else:
        output += ' .'
       
      if k % 25 == 0:
        print ', %4d, : %d, %25s' % (k, self.model.denormalize_energy(best_e), output)
        output = ''
    
      k += 1
      
    print
    print 'Best State Found: ' + str(best_s)
    print 'Energy At Best State: ' + str(self.model.denormalize_energy(best_e))
    print
    
    return best_e
示例#12
0
文件: code8.py 项目: nkudige/x9115DMN
class SA:
  def __init__(self, model = "Schaffer"):
    self.evals = 0
    if model == "Schaffer":
      self.model = Schaffer()
    elif model == "Osyczka":
      self.model = Osyczka()
    elif model == "Golinski":
      self.model = Golinski()
    elif model == "Kursawe":
      self.model = Kursawe()
    elif model == "DTLZ7":
      self.model = DTLZ7(10, 2)

  def __repr__(self):
    return time.strftime("%Y-%m-%d %H:%M:%S") + "\nSimulated Annealing on the Schaffer model\n"
  
  def P(self, old_e, new_e, k):
    return math.e ** ((old_e - new_e) / k)

  def run(self):
    kmax = 1000
    max_e = -0.1
    output = ''
    
    current_s = self.model.get_random_state()
    best_s = current_s
    
    current_e = self.model.normalize_energy(self.model.energy(current_s))
    best_e = current_e
    MAX_LIVES = 10
    ERA_LENGTH = 100
    k = 1
    era_List = []
    current_era = []
    lives = MAX_LIVES
    while k < kmax and current_e > max_e:
      neighbor_s = self.model.get_random_state()
      # print 'Neighbor: ' + str(neighbor_s)
      
      neighbor_e = self.model.normalize_energy(self.model.energy(neighbor_s))
      # print current_e, neighbor_e, tmp
      if self.model.type1(best_s, neighbor_s):
        # print "Neighbor better " + str(best_e) + " " + str(neighbor_e)
        best_s, best_e = neighbor_s, neighbor_e
        temp = ' !'
      
      if self.model.type1(neighbor_s, current_s):
        current_s, current_e = neighbor_s, neighbor_e
        temp = ' +'
        
      elif self.P(current_e, neighbor_e, (1-(float(k)/kmax))**5) > random():
        current_s, current_e = neighbor_s, neighbor_e
        temp = ' ?'
        
      else:
        temp = ' .'
      
      if temp != ' .':
        current_era.append(neighbor_s)
        if len(current_era) == ERA_LENGTH:
          #print current_era
          if len(era_List) > 0:
            increment = self.model.type2(current_era, era_List[-1])
            lives += increment
            if increment <= 0:
                    print "Reducing lives by 1"
            if lives <= 0:
                print "Early termination"
                return best_e
          era_List.append(current_era)
          current_era = []
      
      output += temp
      if k % 25 == 0:
        print output + "Best state: ", best_e
        output = ''
    
      k += 1

    print 'Best State Found: ' + str(best_s)
    print 'Energy At Best State: ' + str(best_e)
    
    return best_e
示例#13
0
class SA:
    def __init__(self, model="Schaffer"):
        self.evals = 0

        if model == "Schaffer":
            self.model = Schaffer()
        elif model == "Osyczka":
            self.model = Osyczka()
        elif model == "Golinski":
            self.model = Golinski()
        elif model == "Kursawe":
            self.model = Kursawe()

    def __repr__(self):
        return time.strftime(
            "%Y-%m-%d %H:%M:%S"
        ) + "\nSimulated Annealing on the Schaffer model\n"

    def P(self, old_e, new_e, k):
        return math.e**((old_e - new_e) / k)

    def run(self):
        kmax = 1000
        max_e = -0.1
        output = ''

        current_s = self.model.get_random_state()
        best_s = current_s

        current_e = self.model.normalize_energy(self.model.energy(current_s),
                                                self.model.baseline_low,
                                                self.model.baseline_high)
        best_e = current_e

        k = 1
        current_era = []
        eras = []
        lives = 5
        ERA_LENGTH = 10
        while k < kmax and current_e > max_e:
            neighbor_s = self.model.get_random_state()
            # print 'Neighbor: ' + str(neighbor_s)
            neighbor_e = self.model.normalize_energy(
                self.model.energy(neighbor_s), self.model.baseline_low,
                self.model.baseline_high)
            # print current_e, neighbor_e, tmp

            if neighbor_e < best_e:
                best_s, best_e = neighbor_s, neighbor_e
                output += ' !'

            if neighbor_e < current_e:
                current_s, current_e = neighbor_s, neighbor_e
                output += ' +'

            elif self.P(current_e, neighbor_e,
                        (1 - (float(k) / kmax))**5) > random.random():
                current_s, current_e = neighbor_s, neighbor_e
                output += ' ?'

            else:
                output += ' .'

            current_era.append(
                self.model.normalize_energy(current_e, self.model.baseline_low,
                                            self.model.baseline_high))
            if len(current_era) == ERA_LENGTH and len(eras) > 0:
                if a12(current_era, eras[-1]) < 0.56:
                    lives -= 1
                    print "Lives:" + str(lives) + " a12 statistic:" + str(
                        a12(current_era, eras[-1])),
                else:
                    lives = 5
            if len(current_era) == ERA_LENGTH:
                eras.append(current_era)
                current_era = []
                if lives <= 0:
                    print "Early termination"
                    break
            if k % 25 == 0:
                print ', %4d, : %d, %25s' % (
                    k, self.model.denormalize_energy(best_e), output)
                output = ''

            k += 1

        print
        print 'Best State Found: ' + str(best_s)
        print 'Energy At Best State: ' + str(
            self.model.denormalize_energy(best_e))
        print

        return best_e