Python random.setstate函数代码示例

	def internal_rng(self):
		# Swap to the internal RNG state if necessary, then return random
		if self.rng_for_agent:
			self.agent_state = random.getstate()
			random.setstate(self.internal_state)
			self.rng_for_agent = False
		return random

    def __makeResistanceToon(self):
        if self.resistanceToon:
            return
        npc = Toon.Toon()
        npc.setName(TTLocalizer.ResistanceToonName)
        npc.setPickable(0)
        npc.setPlayerType(NametagGroup.CCNonPlayer)
        dna = ToonDNA.ToonDNA()
        dna.newToonRandom(11237, 'f', 1)
        dna.head = 'pls'
        npc.setDNAString(dna.makeNetString())
        npc.animFSM.request('neutral')
        self.resistanceToon = npc
        self.resistanceToon.setPosHpr(*ToontownGlobals.CashbotRTBattleOneStartPosHpr)
        state = random.getstate()
        random.seed(self.doId)
        self.resistanceToon.suitType = SuitDNA.getRandomSuitByDept('m')
        random.setstate(state)
        self.fakeGoons = []
        for i in range(self.numFakeGoons):
            goon = DistributedCashbotBossGoon.DistributedCashbotBossGoon(base.cr)
            goon.doId = -1 - i
            goon.setBossCogId(self.doId)
            goon.generate()
            goon.announceGenerate()
            self.fakeGoons.append(goon)

        self.__hideFakeGoons()

def lorem(randseed=None, count=1, method=None):
    u"""
    Creates Lorem Ipsum text.

    Usage format:

        {% lorem [randseed] [count] [method] %}

    ``randseed`` is any hashable object used to initialize the random numbers generator.
    If ``randseed`` is not given the common "Lorem ipsum dolor sit..." text is used.

    ``count`` is a number of paragraphs or sentences to generate (default is 1).

    ``method`` is either ``p`` for HTML paragraphs enclosed in ``<p>`` tags, or ``b`` for
    plain-text paragraph blocks (default is ``b``).

    Notice: This filter is rewrited ``lorem`` filter from ``webdesign`` modul from default Django
    package ``django.contrib.webdesign``. The original ``lorem`` filter does not give stable random
    text, thus its generated paragraphs change on every page refresh. We stabilize the generated
    text by setting a fixed randseed before generating the paragraph.
    """

    state = random.getstate()
    random.seed(randseed)
    res = paragraphs(count, common=(randseed is None))
    random.setstate(state)

    if method == u'p':
        res = [u'<p>{}</p>'.format(p) for p in res]
    return u'\n'.join(res)

def simplified_data(num_train, num_dev, num_test):
    rndstate = random.getstate()
    random.seed(0)
    trees = loadTrees('train') + loadTrees('dev') + loadTrees('test')
    
    #filter extreme trees
    pos_trees = [t for t in trees if t.root.label==4]
    neg_trees = [t for t in trees if t.root.label==0]

    #binarize labels
    binarize_labels(pos_trees)
    binarize_labels(neg_trees)
    
    #split into train, dev, test
    print len(pos_trees), len(neg_trees)
    pos_trees = sorted(pos_trees, key=lambda t: len(t.get_words()))
    neg_trees = sorted(neg_trees, key=lambda t: len(t.get_words()))
    num_train/=2
    num_dev/=2
    num_test/=2
    train = pos_trees[:num_train] + neg_trees[:num_train]
    dev = pos_trees[num_train : num_train+num_dev] + neg_trees[num_train : num_train+num_dev]
    test = pos_trees[num_train+num_dev : num_train+num_dev+num_test] + neg_trees[num_train+num_dev : num_train+num_dev+num_test]
    random.shuffle(train)
    random.shuffle(dev)
    random.shuffle(test)
    random.setstate(rndstate)


    return train, dev, test

def sgd(f, x0, step, iterations, useSaved = False, PRINT_EVERY=10):
  # possibly more arguments for postprocessing, save trained variables,
  # print status lines

  # Anneal learning rate every several iterations
  ANNEAL_EVERY = 20000

  if useSaved:
    start_iter, oldx, state = load_saved_params()
    if start_iter > 0:
      x0 = oldx
      step *= 0.5 ** (start_iter / ANNEAL_EVERY)

    if state:
      random.setstate(state)
  else:
    start_iter = 0

  x = x0

  for iter in xrange(1, iterations + 1):
    cost, grad = f(x)
    x -= step * grad
    if iter % PRINT_EVERY == 0:
      print "iter %d: %f" % (iter, cost)

    if iter % SAVE_PARAMS_EVERY == 0 and useSaved:
      save_params(iter, x)

    if iter % ANNEAL_EVERY == 0:
      step *= 0.5
  return x

def movement_phase(process):
    repeat = process.current_actions
    Action.set_process(process)
    rand_state = random.getstate()
    random.shuffle(repeat)
    random.setstate(rand_state)
    repeat.sort()
    sorted_moves = []
    repeat = [Movement(a, find_shortest_path(process.map, a.pos, a.dest)) for a in repeat]
    occupied, que = set(), []
    while len(repeat) != len(que):
        que, repeat = repeat, []
        for turn in que:
            if turn.path and turn.path[0] not in occupied:
                occupied.add(turn.path[0])
                sorted_moves.append(turn.action)
            else:
                repeat.append(turn)
    for turn in repeat:
        for node in turn.path:
            if node not in occupied:
                occupied.add(node)
                sorted_moves.append(Action(turn.action.pos, node.pos, turn.action.attack))
                break
        else:
            sorted_moves.append(Action(turn.action.pos, turn.action.pos, turn.action.attack))
    return sorted_moves

    def load(self, filename):
        data = Data.load(filename)

        random.setstate(data['random'])
        self.tiles = data['tiles']
        self.initindexes()
        self.popcache = {}

 def use_internal_state(self):
     """Use a specific RNG state."""
     old_state = random.getstate()
     random.setstate(self._random_state)
     yield
     self._random_state = random.getstate()
     random.setstate(old_state)

def randomOpening(size, seed):
    oldstate = random.getstate()
    random.seed(seed)
    r = random.randint(0, (size*size - 1))
    random.setstate(oldstate)
    move = str(chr(ord('a') + (r / size))) + str((r % size) + 1)
    return move

def random_seed(seed):
    """Context manager to set random.seed() temporarily
    """
    state = random.getstate()
    random.seed(seed)
    yield
    random.setstate(state)

    async def penis(self, ctx, *users: discord.Member):
        """Detects user's penis length

        This is 100% accurate.
        Enter multiple users for an accurate comparison!"""
        if not users:
            await self.bot.send_cmd_help(ctx)
            return

        dongs = {}
        msg = ""
        state = random.getstate()

        for user in users:
            random.seed(user.id)
            dongs[user] = "8{}D".format("=" * random.randint(0, 30))

        random.setstate(state)
        dongs = sorted(dongs.items(), key=lambda x: x[1])

        for user, dong in dongs:
            msg += "**{}'s size:**\n{}\n".format(user.display_name, dong)

        for page in pagify(msg):
            await self.bot.say(page)

def testAgainstRandom(p):

    state = random.getstate()

    score = 0

    #random.seed(0)

    for iter in range(100):
        population = []
        nIndividuals = 3
        for n in range(nIndividuals):

            newIndividual = {}
            for i in ['PE', 'LB', 'PK', 'OE', 'RD', 'YW', 'GN', 'DB', 'RR', 'UY',
                      'PE_up', 'LB_up', 'PK_up', 'OE_up', 'RD_up', 'YW_up', 'GN_up', 'DB_up', 'RR_up', 'UY_up']:
                #newIndividual[i] = random.random()
                #newIndividual[i] = 1.0

                if random.random() > .5:
                    newIndividual[i] = random.random()
                else:
                    newIndividual[i] = random.random()

            population.append(newIndividual)
        points = playGame(p, population[0], population[1], population[2])
        score += points[0]

    random.setstate(state)
    return score

def _numpy_do_teardown():
    global _old_python_random_state
    global _old_numpy_random_state
    random.setstate(_old_python_random_state)
    numpy.random.set_state(_old_numpy_random_state)
    _old_python_random_state = None
    _old_numpy_random_state = None

def spatial_graph_variable_spatial_scale(cell_positions,
                                         spatial_scale=1.,
                                         connection_probability=connection_probability_vervaeke_2010,
                                         synaptic_weight=synaptic_weight_vervaeke_2010):
    state = random.getstate()
    g_2010 = spatial_graph_2010(cell_positions)
    weights_2010 = [e[2]['weight'] for e in g_2010.edges(data=True)]
    total_weight_2010 = sum(weights_2010)
    # reset RNG to make sure we will rescale strengths fairly
    random.setstate(state)

    # generate spatial network with 2010 rules but scaling all distances
    n_cells = len(cell_positions)
    edges = []
    for i, p in enumerate(cell_positions):
        for j, q in enumerate(cell_positions[i+1:]):
            d = distance(p, q) / spatial_scale
            if random.random() < connection_probability(d):
                edges.append((i, i+1+j, {'weight': synaptic_weight(d)}))

    # rescale weights to keep the same total value across the network
    weights = [e[2]['weight'] for e in edges]
    total_weight = sum(weights)
    for e in edges:
        e[2]['weight'] *= total_weight_2010 / total_weight

    # create graph object
    g = nx.Graph()
    g.add_nodes_from(range(n_cells))
    for node in g.nodes():
        g.node[node]['x'] = cell_positions[node][0]
        g.node[node]['y'] = cell_positions[node][1]
        g.node[node]['z'] = cell_positions[node][2]
    g.add_edges_from(edges)
    return g

def optimize(p, k, distances, mode='clusters', seed=12345, granularity=1.):
    if k == 1:
        return [p]

    random_state = random.getstate()
    try:
        # we want the same output on every call on the same data, so we use
        # a fixed random seed at this point.
        random.seed(seed)

        clusterer = _Clusterer(
            len(p), tuple(range(len(p))), None, [], p, distances.distance)

        if isinstance(k, tuple) and len(k) == 2:
            criterion = k[0](**k[1])
            assert isinstance(criterion, SplitCriterion)
            clusters = clusterer.without_k(criterion)
        elif isinstance(k, int):
            clusters = [c.members for c in clusterer.with_k(k)]
        else:
            raise ValueError('illegal parameter k "%s"' % str(k))

        # sort clusters by order of their first element in the original list.
        clusters = sorted(clusters, key=lambda c: c[0])

        if mode == 'clusters':
            return list(map(lambda c: map(lambda i: p[i], c), clusters))
        elif mode == 'components':
            return _components(clusters, len(p))
        else:
            raise ValueError('illegal mode %s' % mode)
    finally:
        random.setstate(random_state)