Python Random.setstate方法代码示例

# 需要导入模块: from random import Random [as 别名]
# 或者: from random.Random import setstate [as 别名]
def main(json_tuning_state, display=False):
    """Computes the new tuning state which contains the new population set and prints it in stdout
    so that it can be read by java code
    :param json_tuning_state: Current tuning state
    :param display:
    :return: None
    """
    tuning_state = json.loads(json_tuning_state)
    pseudo_random_number_generator = Random()
    args = {}

    if TUNING_STATE_ARCHIVE_KEY not in tuning_state:
        pseudo_random_number_generator.seed(time.time())
        pso = restartable_pso.restartable_pso(pseudo_random_number_generator)
        pso.observer = inspyred.ec.observers.default_observer
        pso.terminator = inspyred.ec.terminators.evaluation_termination
        pso.topology = inspyred.swarm.topologies.ring_topology
        population = pso.evolve(generator=initial_population_generator, evaluator=dummy_fitness_evaluator,
                                pop_size=POPULATION_SIZE,
                                bounder=bounder,
                                maximize=False, max_evaluations=POPULATION_SIZE, **args)

        tuning_state = generate_tuning_state(pso, pseudo_random_number_generator, population)
        print(tuning_state)

    else:
        archive = json_to_individual_object(tuning_state[TUNING_STATE_ARCHIVE_KEY])
        prev_population = json_to_individual_object(tuning_state[TUNING_STATE_PREV_POPULATION_KEY])
        initial_population = json_to_individual_object(tuning_state[TUNING_STATE_CURRENT_POPULATION_KEY])

        str_rnd_state = tuning_state[TUNING_STATE_RANDOM_STATE_KEY]
        json_rnd_state = json.loads(str_rnd_state)
        json_rnd_state[1] = tuple(json_rnd_state[1])
        rnd_state = tuple(json_rnd_state)

        pseudo_random_number_generator.setstate(rnd_state)

        pso = restartable_pso.restartable_pso(pseudo_random_number_generator, _archive=archive,
                                              _previous_population=prev_population)
        pso.observer = inspyred.ec.observers.default_observer
        pso.terminator = inspyred.ec.terminators.evaluation_termination
        pso.topology = inspyred.swarm.topologies.ring_topology

        population = pso.evolve(seeds=[cs.candidate for cs in initial_population],
                                initial_fit=[cs.fitness for cs in initial_population],
                                generator=None, evaluator=dummy_fitness_evaluator, pop_size=POPULATION_SIZE,
                                bounder=bounder,
                                maximize=False, max_evaluations=2 * POPULATION_SIZE, **args)
        tuning_state = generate_tuning_state(pso, pseudo_random_number_generator, population)
        print(tuning_state)

# 需要导入模块: from random import Random [as 别名]
# 或者: from random.Random import setstate [as 别名]
  def __init_rand_gens(self):
    gennum = 10

    g = Random(time())
    result = [g]

    for i in range(gennum - 1):
      laststate = g.getstate()
      g = Random()
      g.setstate(laststate)
      g.jumpahead(1000000)
      result.append(g)

    return result

# 需要导入模块: from random import Random [as 别名]
# 或者: from random.Random import setstate [as 别名]
def _create_generators(num, delta, firstseed=None):
    """Return list of num distinct generators.
    Each generator has its own unique segment of delta elements
    from Random.random()'s full period.
    Seed the first generator with optional arg firstseed (default
    is None, to seed from current time).
    """

    from random import Random
    g = Random(firstseed)
    result = [g]
    for i in range(num - 1):
        laststate = g.getstate()
        g = Random()
        g.setstate(laststate)
        g.jumpahead(delta)
        result.append(g)
    return result

# 需要导入模块: from random import Random [as 别名]
# 或者: from random.Random import setstate [as 别名]
class SelfGeneratedMessage:
    """SelfGeneratedMessage"""
   
    def asJson(self):
        #nowStr=self.now.strftime("%Y-%m-%d %H:%M:%S.%f")
        nowStr=self.formatTime(self.now)
        publisherIdStr = "publisher-{0}".format(self.publisherId)
        
        info = dict()
        info["publisher"]=publisherIdStr
        info["time"]=nowStr
        info["readings"]=self.readings
        
        res = json.dumps(info)
        return res
    
    def formatTime(self, t):        
        s = t.strftime('%Y-%m-%d %H:%M:%S.%f')
        tail = s[-7:]
        f = round(float(tail), 3)
        temp = "%.3f" % f
        return "%s%s" % (s[:-7], temp[1:])
        
    def __init__(self):
        self.now = datetime.utcnow()
        self.publisherId=randint(0, 5)
        self.r1 = Random()
        self.r2 = Random()
        self.r2.setstate(self.r1.getstate())
        self.r2.jumpahead(1024)
        numReadingsAdditional=randint(0, 5)
        totalReadings = 10+numReadingsAdditional
        self.readings=[]
        for x in xrange(1, totalReadings):
            mean = 2
            reading = mean + randint(0, 5) + self.r1.randint(0,1)*self.r2.randint(0,1)*100  
            self.readings.append(reading)

# 需要导入模块: from random import Random [as 别名]
# 或者: from random.Random import setstate [as 别名]
def main(prng=None, display=False):
    if prng is None:
        prng = Random()
    max_gens = 500

    if os.path.exists('ec0.pkl'):
        with open('ec0.pkl','rb') as pickle_file:
            population = pickle.load(pickle_file)
            archive = pickle.load(pickle_file)
            random_state = pickle.load(pickle_file)
            num_generations = pickle.load(pickle_file)
            num_evaluations = pickle.load(pickle_file)
            prng.setstate(random_state)

            stat_file = open('ga_statistics.csv','w')
            ind_file = open('ga_individuals.csv','w')
            ea = ec.emo.NSGA2(prng)
            ea.variator = [inspyred.ec.variators.blend_crossover,
                           inspyred.ec.variators.gaussian_mutation]
            ea.observer = [inspyred.ec.observers.file_observer,
                           inspyred.ec.observers.archive_observer,
                           inspyred.ec.observers.stats_observer]
            ea.terminator = [inspyred.ec.terminators.generation_termination,
                             my_terminator]
            ea.num_evaluations = num_evaluations
            ea.num_generations = num_generations
            ea.archive = archive

            final_pop = ea.evolve(seeds=[p.candidate for p in population],
                                  generator=generator,
                                  evaluator=evaluator,
                                  pop_size=30,
                                  maximize=True,
                                  bounder=bounder,
                                  max_generations= max_gens-num_generations,
                                  num_elites=2,
                                  statistics_file=stat_file,
                                  individuals_file=ind_file)
            stat_file.close()
            ind_file.close()
    else:
        prng.seed(1234)
        stat_file = open('ga_statistics.csv', 'w')
        ind_file = open('ga_individuals.csv', 'w')
        ea = ec.emo.NSGA2(prng)
        ea.variator = [inspyred.ec.variators.blend_crossover,
                       inspyred.ec.variators.gaussian_mutation]
        ea.observer = [inspyred.ec.observers.file_observer,
                       inspyred.ec.observers.archive_observer,
                       inspyred.ec.observers.stats_observer]
        ea.terminator = [inspyred.ec.terminators.generation_termination,
                         my_terminator]

        final_pop = ea.evolve(generator=generator,
                              evaluator=evaluator,
                              pop_size=30,
                              maximize=True,
                              bounder=bounder,
                              max_generations=max_gens,
                              num_elites=2,
                              statistics_file=stat_file,
                              individuals_file=ind_file)
        stat_file.close()
        ind_file.close()

    if display:
        # Sort and print the best individual, who will be at index 0.
        final_pop.sort(reverse=True)
        print('Terminated due to %s.' % ea.termination_cause)
        print(final_pop[0])
    return ea

# 需要导入模块: from random import Random [as 别名]
# 或者: from random.Random import setstate [as 别名]
 def gen_result():
     r = Random(0)
     r.setstate(state)
     return self.produce(r)

# 需要导入模块: from random import Random [as 别名]
# 或者: from random.Random import setstate [as 别名]
class Cyana:
    """
    Front-end for CYANA. Provides methods needed to run CYANA.

    Current implementation includes only methods needed to run CYANA in batch 
    mode using macros. TODO: more features, control of screen output, support
    for a session mode CYANA, i.e. a true API to CYANA/INCLAN.
    """
    def __init__(self, input, output=None, fixed_angles=None, rg_limits=None, 
            use_limits=True, seed=None, state=None, jump=None, tally=0, 
            tally_digits=3, name=None, verbose=False, debug=False):
        # store and/or process inputs
        self.input = str(input)
        self.rg_limits = rg_limits
        self.use_limits = bool(use_limits)
        self.tally = int(tally)
        self.tally_digits = int(tally_digits)
        if output != None:
            self.output = str(output)
        else:
            self.output = self.input + '-'
        self.fixed_angles = fixed_angles
        if fixed_angles != None:
            if type(fixed_angles) != list:
                if type(fixed_angles) == tuple:
                    self.fixed_angles = list(fixed_angles)
                else:
                    self.fixed_angles = [fixed_angles]
            for i in range(len(self.fixed_angles)):
                if type(self.fixed_angles[i]) in [list, tuple]:
                    lo, hi = str(self.fixed_angles[i][0]), \
                            str(self.fixed_angles[i][1])
                elif re.search('([0-9]+).+([0-9]+)', str(self.fixed_angles[i])):
                    lo, hi = re.search('([0-9]+).+([0-9]+)', \
                            str(self.fixed_angles[i])).groups()
                else:
                    lo = hi = str(self.fixed_angles[i])
                self.fixed_angles[i] = '%s..%s'%(lo,hi)
        if name is None:
            self.name = 'temp-%d'%os.getpid()
        else:
            self.name = str(name)
        if debug: loki.setLevel(logging.DEBUG)
        elif verbose: loki.setLevel(logging.INFO)
        # check that required input files exist
        if not os.path.isfile(self.input+'.seq'):
            raise ArgumentError, ('No sequence file found.', 'Cyana')
        if self.fixed_angles and not os.path.isfile(self.input + '.pdb'):
            raise ArgumentError, ('No model PDB file found for angle fixes.', 
                    'Cyana')
        # setup temporary files
        os.system('cp -f %s.seq %s.seq'%(self.input, self.name))
        loki.info('Readied the sequence file for further use.')
        if self.use_limits:
            for suffix in ['lol', 'upl', 'aco', 'xplor']:
                if os.path.isfile(self.input + '.' + suffix):
                    os.system('cp -f %s.%s %s.%s'%(self.input, suffix, 
                        self.name, suffix))
                    loki.info("Readied a '%s' file for further use."%suffix)
        if self.fixed_angles:
            os.system('cp -f %s.pdb %s.pdb'%(self.input, self.name))
        # initialise the random generator
        self.randgen = Random(seed)
        if state == None:
            if jump != None:
                if sys.version < '2.2':
                    loki.warn('Python older than 2.2. Problems may arise.')
                elif sys.version > '2.2' and sys.version < '2.3':
                    # this should provide enough room for each run to be in 
                    # unique state space
                    self.randgen.jumpahead(jump*self.amount*1.1)
                else:
                    self.randgen.jumpahead(jump)
        else:
            self.randgen.setstate(state)
        self.__last_macro_size__ = None

    def anneal(self, amount, snippets=None, max_temp=4.0, min_temp=0.9, 
        steps=5000):
        """
        Anneal.
        """
        amount = int(amount)
        if snippets is None:
            snippets = amount
        else:
            snippets = int(snippets)
        max_temp = float(max_temp)
        min_temp = float(min_temp)
        steps = int(steps)
        if snippets > amount:
            loki.warn('Snippet size larger than total amount. '
                    'Running in one go.')
            snippets = amount
# Current version of Cyana (2.1?) seems to be broken as tend is not
# supported by anneal. FIXME when corrected.
#        self.__calc_end__ = 'anneal thigh=%1.3f tend=%1.3f steps=%d'%( \
#                max_temp, min_temp, steps)
        self.__calc_end__ = 'anneal thigh=%1.3f steps=%d'%( \
                max_temp, steps)
#.........这里部分代码省略.........