def test_call_within_randomstate(self): # Check that custom RandomState does not call into global state m = Generator(MT19937()) # mt19937.RandomState() res = np.array([0, 8, 7, 2, 1, 9, 4, 7, 0, 3]) for i in range(3): mt19937.bit_generator.seed(i) m.bit_generator.seed(4321) # If m.state is not honored, the result will change assert_array_equal(m.choice(10, size=10, p=np.ones(10)/10.), res)
def setup_class(cls): # Overridden in test classes. Place holder to silence IDE noise cls.bit_generator = PCG64 cls.advance = None cls.seed = [12345] cls.rg = Generator(cls.bit_generator(*cls.seed)) cls.initial_state = cls.rg.bit_generator.state cls.seed_vector_bits = 64 cls._extra_setup()
def test_pickle(self): import pickle bit_generator = self.bit_generator(*self.data1["seed"]) state = bit_generator.state bitgen_pkl = pickle.dumps(bit_generator) reloaded = pickle.loads(bitgen_pkl) reloaded_state = reloaded.state assert_array_equal( Generator(bit_generator).standard_normal(1000), Generator(reloaded).standard_normal(1000), ) assert bit_generator is not reloaded assert_state_equal(reloaded_state, state) ss = SeedSequence(100) aa = pickle.loads(pickle.dumps(ss)) assert_equal(ss.state, aa.state)
def _retry(minimizer): sg = SeedSequence() rgs = [Generator(MT19937(s)) for s in sg.spawn(minimizer.workers)] procs = [ Process(target=_retry_loop, args=(pid, rgs, minimizer)) for pid in range(minimizer.workers) ] [p.start() for p in procs] return procs
def setup_class(cls): cls.bit_generator = MT19937 cls.advance = None cls.seed = [2**21 + 2**16 + 2**5 + 1] cls.rg = Generator(cls.bit_generator(*cls.seed)) cls.initial_state = cls.rg.bit_generator.state cls.seed_vector_bits = 32 cls._extra_setup() cls.seed_error = ValueError
def gen_dd_samples(self, replications, n_samples, dimensions, scramble=True): """ Generate r nxd Lattice samples Args: replications (int): Number of nxd matrices to generate (sample.size()[0]) n_samples (int): Number of observations (sample.size()[1]) dimensions (int): Number of dimensions (sample.size()[2]) scramble (bool): If true, random numbers are in unit cube, otherwise they are non-negative integers Returns: replications x n_samples x dimensions (numpy array) """ m = log2(n_samples) if m % 1 != 0: raise DistributionGenerationError("n_samples must be a power of 2") m = int(m) r = int(replications) d = int(dimensions) if not hasattr(self, 'lattice_rng'): # initialize lattice rng and shifts self.d = d self.r = r self.rng = Generator(PCG64(self.rng_seed)) self.lattice_rng = LatticeSeq(s=self.d) self.shifts = self.rng.uniform(0, 1, (self.r, self.d)) else: if d != self.d or r != self.r: warnings.warn( ''' Using dimensions = %d and replications = %d as previously set for this generator.''' % (self.d, self.r), DistributionGenerationWarnings) if self.n_min == 0: # generate first 2^m points x = vstack([self.lattice_rng.calc_block(i) for i in range(m + 1)]) self.n_min = 2**m elif n_samples != self.n_min: raise DistributionGenerationError(''' This Lattice generator has returned a total of %d samples. n_samples is expected to be %d ''' % (int(self.n_min), int(self.n_min))) else: # generate self.n_min more samples x = self.lattice_rng.calc_block(m + 1) self.n_min = 2**(m + 1) if scramble: x = array([(x + shift_r) % 1 for shift_r in self.shifts]) # random shift else: x = repeat(x[None, :, :], self.r, axis=0) # duplicate unshifted samples return x
def __init__(self, H, graph_shape=(4, 4), allow_cuda=False): """ :param H: A Hamiltonian designed for spacetime graphs. :param graph_shape: The dimension of spacetime grpahs to be used in the simulator. :param allow_cuda: Can we do computations on the GPU? Currently ignored (2021-06-03). """ super(RejectionSimulator, self).__init__(H, graph_shape, allow_cuda) self.rng = Generator(PCG64())
def setup(self, bitgen): if bitgen == 'numpy': self.rg = np.random.RandomState() else: self.rg = Generator(getattr(np.random, bitgen)()) self.rg.random() self.int32info = np.iinfo(np.int32) self.uint32info = np.iinfo(np.uint32) self.uint64info = np.iinfo(np.uint64)
def test_shuffle_mixed_dimension(self): # Test for trac ticket #2074 for t in [[1, 2, 3, None], [(1, 1), (2, 2), (3, 3), None], [1, (2, 2), (3, 3), None], [(1, 1), 2, 3, None]]: mt19937 = Generator(MT19937(12345)) shuffled = np.array(t, dtype=object) mt19937.shuffle(shuffled) expected = np.array([t[2], t[0], t[3], t[1]], dtype=object) assert_array_equal(np.array(shuffled, dtype=object), expected)
def test_shuffle_mixed_dimension(self): # Test for trac ticket #2074 for t in [[1, 2, 3, None], [(1, 1), (2, 2), (3, 3), None], [1, (2, 2), (3, 3), None], [(1, 1), 2, 3, None]]: mt19937 = Generator(MT19937(12345)) shuffled = list(t) mt19937.shuffle(shuffled) assert_array_equal(shuffled, [t[2], t[0], t[3], t[1]])
def _make_irregular_tripole_grid_data(shape: Tuple[int, int], seed: int) -> np.ndarray: rng = Generator(PCG64(seed)) # avoid large-amplitude variation, ensure positive values, mean of 1 grid_data = 0.9 + 0.2 * rng.random(shape) assert np.all(grid_data > 0) # make northern edge grid data fold onto itself nx = shape[-1] half_northern_edge = grid_data[-1, : (nx // 2)] grid_data[-1, (nx // 2) :] = half_northern_edge[::-1] return grid_data
def __init__(self, fname): self.vars = Variables(fname) self.seed = SeedSequence() self.rand_gen = Generator(PCG64(self.seed)) self.vector_initial = Normalise(self.rand_gen.uniform(-1,1,3)) self.pos_initial = np.array([0, 0, 0]) self.time = np.full(self.vars.sample_total, self.vars.base_time) self.time = np.append([0], self.time) self.time = np.cumsum(self.time) self.time = np.reshape(self.time, (self.time.size, 1))
def spawn_generators(n): """ Spawn n random generators Generators are insured independent if you spawn less than 2^64 of them and you pull less than 2^64 variates for each generators :return: a list of n generators """ return [Generator(SFC64(stream)) for stream in seed_seq.spawn(n)]
def test_advange_large(self): rs = Generator(self.bit_generator(38219308213743)) pcg = rs.bit_generator state = pcg.state initial_state = 287608843259529770491897792873167516365 assert state["state"]["state"] == initial_state pcg.advance(sum(2**i for i in (96, 64, 32, 16, 8, 4, 2, 1))) state = pcg.state["state"] advanced_state = 277778083536782149546677086420637664879 assert state["state"] == advanced_state
def minimize(self, fun, bounds, guess=None, sdevs=None, rg=Generator(MT19937()), store=None): choice = rg.integers(0, len(self.optimizers)) opt = self.optimizers[choice] return opt.minimize(fun, bounds, guess, sdevs, rg, store)
def test_advange_large(self): rs = Generator(self.bit_generator(38219308213743)) pcg = rs.bit_generator state = pcg.state["state"] initial_state = 287608843259529770491897792873167516365 assert state["state"] == initial_state pcg.advance(sum(2**i for i in (96, 64, 32, 16, 8, 4, 2, 1))) state = pcg.state["state"] advanced_state = 135275564607035429730177404003164635391 assert state["state"] == advanced_state
def test_seed_float_array(self): # GH #82 rs = Generator(self.bit_generator(*self.data1['seed'])) assert_raises(TypeError, rs.bit_generator.seed, np.array([np.pi])) assert_raises(TypeError, rs.bit_generator.seed, np.array([-np.pi])) assert_raises(TypeError, rs.bit_generator.seed, np.array([np.pi, -np.pi])) assert_raises(TypeError, rs.bit_generator.seed, np.array([0, np.pi])) assert_raises(TypeError, rs.bit_generator.seed, [np.pi]) assert_raises(TypeError, rs.bit_generator.seed, [0, np.pi])
def __init__(self, Nx, Ny, p=0.593): self.Nx = Nx self.Ny = Ny self.Nsites = Nx * Ny self.p = p self.trials = 0 self.cluster_iterations = 0 self.rng = Generator(PCG64()) self.compute_neighbor_sites() self.trial()
def minimize(self, fun, bounds, guess=None, sdevs=None, rg=Generator(MT19937()), store=None): ret = shgo(fun, bounds=list(zip(bounds.lb, bounds.ub)), options={'maxfev': self.max_eval_num(store)}) return ret.x, ret.fun, ret.nfev
def minimize(self, fun, bounds, guess=None, sdevs=None, rg=Generator(MT19937()), store=None): if guess is None: guess = rg.uniform(bounds.lb, bounds.ub) ret = minimize(fun, x0=guess, bounds=bounds) return ret.x, ret.fun, ret.nfev
def set_idx(self, new_idx): ''' Skip the sequence to new_idx ''' if self.idx > new_idx: self.pcg_instance = PCG64(self.seed) self.generator = Generator(self.pcg_instance) self.idx = 0 self.pcg_instance.advance(new_idx - self.idx) self.idx = new_idx
def _day_setup(self): h = self._hash.copy() h.update(self._skt) self._skt = h.finalize() prf = hmac.HMAC(self._skt, hashes.SHA256(), backend=default_backend()) prf.update(b"broadcast key") prf_out = prf.copy().finalize() bit_gen = AESCounter(key=int.from_bytes(prf_out[16:], "big")) self._gen = Generator(bit_gen) self._ephid = self._gen.bytes(16)
def __init__(self): global sigma_angle, sigma_position, sigma_angleD, sigma_positionD SEED = int( (datetime.now() - datetime(1970, 1, 1)).total_seconds() * 77.0) self.rng_noise_adder = Generator(SFC64(SEED)) self.noise_mode = NOISE_MODE self.sigma_Q = sigma_Q
def create_pulsed_events(nevents, freq, t0=0, t1=1000, nback=0): from numpy.random import Generator, PCG64 rg = Generator(PCG64()) events = rg.normal(0.5, 0.1, nevents - nback) events = events - np.floor(events) if nback > 0: events = np.concatenate((events, rg.uniform(0, 1, nback))) pulse_no = rg.integers(0, np.rint((t1 - t0) * freq), nevents) events = np.sort(events + pulse_no) return t1 + events / freq
def mo_retry(fun, weight_bounds, ncon, y_exp, store, optimize, num_retries, value_limits, workers=mp.cpu_count()): sg = SeedSequence() rgs = [Generator(MT19937(s)) for s in sg.spawn(workers)] proc=[Process(target=_retry_loop, args=(pid, rgs, fun, weight_bounds, ncon, y_exp, store, optimize, num_retries, value_limits)) for pid in range(workers)] [p.start() for p in proc] [p.join() for p in proc] store.sort() store.dump() return store.get_xs()
def __init__(self, text_file): with Path(text_file).open('r+', encoding="utf-8") as f: self.text_list = [s.rstrip() for s in f.readlines()] with (Path(text_file).parent / 'short_replics.txt').open( 'r+', encoding="utf-8") as f: self.short_text_list = [s.rstrip() for s in f.readlines()] self.font_files = [] self.min_font_size = 14 self.max_font_size = 60 self.rg = Generator(PCG64()) self.fancy_fonts = list((config.fonts_dir / 'fancy_fonts').iterdir()) self.plain_fonts = list((config.fonts_dir / 'fancy_fonts').iterdir())
def retry(fun, store, optimize, num_retries, value_limit = math.inf, workers=mp.cpu_count(), stop_fitness = -math.inf): sg = SeedSequence() rgs = [Generator(MT19937(s)) for s in sg.spawn(workers)] proc=[Process(target=_retry_loop, args=(pid, rgs, fun, store, optimize, num_retries, value_limit, stop_fitness)) for pid in range(workers)] [p.start() for p in proc] [p.join() for p in proc] store.sort() store.dump() return OptimizeResult(x=store.get_x_best(), fun=store.get_y_best(), nfev=store.get_count_evals(), success=True)
def test_permutation_subclass(self): class N(np.ndarray): pass mt19937 = Generator(MT19937(1)) orig = np.arange(3).view(N) perm = mt19937.permutation(orig) assert_array_equal(perm, np.array([2, 0, 1])) assert_array_equal(orig, np.arange(3).view(N)) class M: a = np.arange(5) def __array__(self): return self.a mt19937 = Generator(MT19937(1)) m = M() perm = mt19937.permutation(m) assert_array_equal(perm, np.array([4, 1, 3, 0, 2])) assert_array_equal(m.__array__(), np.arange(5))
def test_seed_float_array(self): rs = Generator(self.bit_generator(*self.data1['seed'])) assert_raises(self.seed_error_type, rs.bit_generator.seed, np.array([np.pi])) assert_raises(self.seed_error_type, rs.bit_generator.seed, np.array([-np.pi])) assert_raises(self.seed_error_type, rs.bit_generator.seed, np.array([np.pi, -np.pi])) assert_raises(self.seed_error_type, rs.bit_generator.seed, np.array([0, np.pi])) assert_raises(self.seed_error_type, rs.bit_generator.seed, [np.pi]) assert_raises(self.seed_error_type, rs.bit_generator.seed, [0, np.pi])
def underopt_edges(quantiles: Dict, method: str, model: Architecture, model_init: Architecture): limit_val: Dict[int, torch.Tensor] = dict() underoptimized_edges = dict() for layer_idx, layer in enumerate(model.layers): weight_keys = [ key for key in layer.func.state_dict() if "weight" in key ] if len(weight_keys) > 0: param = layer.func.state_dict()[weight_keys[0]] if method == ThresholdStrategy.UnderoptimizedMagnitudeIncrease: param_init = model_init.layers[layer_idx].func.state_dict()[ weight_keys[0]] limit_val[layer_idx] = torch.abs(param) - torch.abs(param_init) elif method == ThresholdStrategy.UnderoptimizedLargeFinal: limit_val[layer_idx] = torch.abs(param) elif method == ThresholdStrategy.UnderoptimizedRandom: n = reduce(lambda x, y: x * y, param.shape, 1) # Ensuring we select different edges each time gen = Generator(PCG64(int(time.time() + os.getpid()))) limit_val[layer_idx] = ( torch.abs(param).reshape(-1)[gen.permutation(n)].reshape( param.shape)) limit_val[layer_idx] = limit_val[layer_idx].cpu() if layer_idx not in quantiles: underoptimized_edges[layer_idx] = list() else: low_quantile, up_quantile = quantiles[layer_idx] logger.info( f"[{layer_idx}] Quantiles are {low_quantile}-{up_quantile}" ) if low_quantile <= 0.0: lower_bound = -np.infty else: lower_bound = np.quantile(limit_val[layer_idx], low_quantile) if up_quantile >= 1.0: upper_bound = np.infty else: upper_bound = np.quantile(limit_val[layer_idx], up_quantile) underoptimized_edges[layer_idx] = (torch.logical_and( limit_val[layer_idx] < upper_bound, limit_val[layer_idx] >= lower_bound, ).nonzero().cpu().numpy().tolist()) return underoptimized_edges