def generate_random_points_in_polygon(poly, num_points, seed=None): """ Create a list of randomly generated points within a polygon. Parameters ---------- poly : Polygon num_points : int The number of random points to create within the polygon seed : int, optional A random seed Returns ------- List """ min_x, min_y, max_x, max_y = poly.bounds points = [] i = 0 while len(points) < num_points: s = RandomState(seed + i) if seed else RandomState(seed) random_point = Point([s.uniform(min_x, max_x), s.uniform(min_y, max_y)]) if random_point.within(poly): points.append(random_point) i += 1 return points
def randomRotations(D, rng=None): from math import pi, sin, cos, sqrt from numpy.random import RandomState from itertools import product as cartesian, repeat from .util import frange if not isinstance(rng, RandomState): rng = RandomState(rng) if D == 2: while True: yield (rng.uniform(-pi, pi),) elif D == 3: # Ken Shoemake # Graphics Gems III, pp 124-132 from .quaternion import Quaternion while True: X = rng.uniform(0, 1) theta = rng.uniform(0, 2*pi), rng.uniform(0, 2*pi) R = (sqrt(1-X), sqrt(X)) yield Quaternion(sin(theta[0]) * R[0], cos(theta[0]) * R[0], sin(theta[1]) * R[1], cos(theta[1]) * R[1]).axis_angle else: raise NotImplementedError("Only defined for D in [2..3], not {}" .format(D))
class TestHandModel(unittest.TestCase): """Test kinematics module.""" def setUp(self): self.random = RandomState(7) def test_constructor(self): model_type_list = [(HandModel20, 20), (HandModel45, 45)] for model_type, dofs_number in model_type_list: hand_model = model_type() self.assertEqual(hand_model.dofs_number, dofs_number) self.assertEqual(len(hand_model.dofs_limits[0]), dofs_number) self.assertEqual(len(hand_model.dofs_limits[1]), dofs_number) self.assertEqual(len(hand_model.joints), len(hand_model.origins())) def test_conversions(self): """Test mano pose <-> joint angles conversion.""" model_type_list = [HandModel20, HandModel45] for model_type, left_hand in itertools.product(model_type_list, (False, True)): with self.subTest(f"{model_type.__name__}(left_hand={left_hand})"): hand_model = model_type(left_hand) ang1 = self.random.uniform(*hand_model.dofs_limits) mat1 = quat2mat(self.random.uniform(-1, 1, size=(4, ))) pose1 = hand_model.angles_to_mano(ang1, mat1) ang2, mat2 = hand_model.mano_to_angles(pose1) np.testing.assert_almost_equal(mat1, mat2) np.testing.assert_almost_equal(ang1, ang2) pose2 = hand_model.angles_to_mano(ang2, mat2) np.testing.assert_almost_equal(pose1, pose2)
def test_coupled_oscillators(num_experiments): from dyadic_interaction.dynamical_systems import spring_mass_system transfer_entropy = [] norm_entropy = [] rs = RandomState(0) for _ in range(num_experiments): spring_data = spring_mass_system(masses=rs.uniform(1.0, 10.0, 2), constants=rs.uniform(1.0, 50.0, 2), lengths=rs.uniform(0.1, 5.0, 2)) pos = np.column_stack((spring_data[:, 0], spring_data[:, 2])) # transfer_entropy, local_te = get_transfer_entropy(pos, local=True) norm_entropy.append( get_shannon_entropy_2d(pos, min_v=pos.min(), max_v=pos.max())) transfer_entropy.append( get_transfer_entropy(pos, min_v=pos.min(), max_v=pos.max())) print("Transfer Entropy of spring positions: {}".format( transfer_entropy)) print("Shannon Entropy of spring positions: {}".format(norm_entropy)) # plt.plot(pos) # plt.show() # vel = np.column_stack((spring_data[:, 1], spring_data[:, 3])) # transfer_entropy = get_transfer_entropy(vel, log=True) # norm_entropy = get_shannon_entropy_2d(vel) # print("Transfer Entropy of spring velocities: {}".format(transfer_entropy)) # print("Shannon Entropy of spring velocities: {}".format(norm_entropy)) # plt.plot(vel) # plt.show() # plt.plot(local_te[0]) # plt.plot(local_te[1]) # plt.show() return norm_entropy, transfer_entropy
def randomRotations(D, rng=None): from math import pi, sin, cos, sqrt from numpy.random import RandomState if not isinstance(rng, RandomState): rng = RandomState(rng) if D == 2: while True: yield (rng.uniform(-pi, pi), ) elif D == 3: # Ken Shoemake # Graphics Gems III, pp 124-132 from .quaternion import Quaternion while True: X = rng.uniform(0, 1) theta = rng.uniform(0, 2 * pi), rng.uniform(0, 2 * pi) R = (sqrt(1 - X), sqrt(X)) yield Quaternion( sin(theta[0]) * R[0], cos(theta[0]) * R[0], sin(theta[1]) * R[1], cos(theta[1]) * R[1]).axis_angle else: raise NotImplementedError( "Only defined for D in [2..3], not {}".format(D))
class WeightGenerationRegime: def __init__(self, nStates, nBivariateFeat, prng=None, seed=None, stationaryWeights=None, bivariateWeights=None): self.nStates = nStates self.nBivariateFeat = nBivariateFeat if prng is not None: self.prng = prng else: if seed is not None: self.prng = RandomState(seed) else: self.defaultRandomSeed = defaultSeed prng = RandomState(1234567890) if prng is not None and seed is not None: warnings.warn("both prng and seed are provided but we use the provided prng", DeprecationWarning) self.stationaryWeights = stationaryWeights self.bivariateWeights = bivariateWeights def generateStationaryWeightsFromNormal(self): self.stationaryWeights = self.prng.normal(0, 1, self.nStates) return self.stationaryWeights def generateBivariateWeightsFromNormal(self): self.bivariateWeights = self.prng.normal(0, 1, self.nBivariateFeat) return self.bivariateWeights def generateStationaryWeightsFromUniform(self): self.stationaryWeights = self.prng.uniform(0, 1, self.nStates) return self.stationaryWeights def generateBivariateWeightsFromUniform(self): self.bivariateWeights = self.prng.uniform(0, 1, self.nBivariateFeat) return self.bivariateWeights
def __call__(self, shape, dtype=None): if self.nb_filters is not None: kernel_shape = tuple(self.kernel_size) + (int(self.input_dim), self.nb_filters) else: kernel_shape = (int(self.input_dim), self.kernel_size[-1]) fan_in, fan_out = initializers._compute_fans( tuple(self.kernel_size) + (self.input_dim, self.nb_filters) ) if self.criterion == 'glorot': s = 1. / (fan_in + fan_out) elif self.criterion == 'he': s = 1. / fan_in else: raise ValueError('Invalid criterion: ' + self.criterion) rng = RandomState(1337) modulus = rng.uniform(low=-np.sqrt(s)*np.sqrt(3), high=np.sqrt(s)*np.sqrt(3), size=kernel_shape) phase = rng.uniform(low=-np.pi/2, high=np.pi/2, size=kernel_shape) wm = modulus wp = phase weight = np.concatenate([wp, wm], axis=-1) return weight
def quaternion_init(in_features, out_features, rng, criterion='glorot'): if criterion == 'glorot': s = 1. / np.sqrt(2 * (in_features + out_features)) elif criterion == 'he': s = 1. / np.sqrt(2 * in_features) else: raise ValueError('Invalid criterion: ' + criterion) rng = RandomState(123) #Generating randoms and purely imaginary quaternions : kernel_shape = (in_features, out_features) number_of_weights = np.prod(kernel_shape) v_i = np.random.uniform(0.0, 1.0, number_of_weights) v_j = np.random.uniform(0.0, 1.0, number_of_weights) v_k = np.random.uniform(0.0, 1.0, number_of_weights) #Make these purely imaginary quaternions unitary for i in range(0, number_of_weights): norm = np.sqrt(v_i[i]**2 + v_j[i]**2 + v_k[i]**2) + 0.0001 v_i[i] /= norm v_j[i] /= norm v_k[i] /= norm v_i = v_i.reshape(kernel_shape) v_j = v_j.reshape(kernel_shape) v_k = v_k.reshape(kernel_shape) modulus = rng.uniform(low=-s, high=s, size=kernel_shape) phase = rng.uniform(low=-np.pi, high=np.pi, size=kernel_shape) weight_r = modulus * np.cos(phase) weight_i = modulus * v_i * np.sin(phase) weight_j = modulus * v_j * np.sin(phase) weight_k = modulus * v_k * np.sin(phase) return (weight_r, weight_i, weight_j, weight_k)
def quaternion_init(in_features, out_features, rng, kernel_size=None, criterion='glorot'): if kernel_size is not None: receptive_field = np.prod(kernel_size) fan_in = in_features * receptive_field fan_out = out_features * receptive_field else: fan_in = in_features fan_out = out_features if criterion == 'glorot': s = 1. / np.sqrt(2 * (fan_in + fan_out)) elif criterion == 'he': s = 1. / np.sqrt(2 * fan_in) else: raise ValueError('Invalid criterion: ' + criterion) rng = RandomState(123) # Generating randoms and purely imaginary quaternions : if kernel_size is None: kernel_shape = (in_features, out_features) else: if type(kernel_size) is int: kernel_shape = (out_features, in_features) + tuple((kernel_size, )) else: kernel_shape = (out_features, in_features) + (*kernel_size, ) number_of_weights = np.prod(kernel_shape) v_i = np.random.uniform(0.0, 1.0, number_of_weights) v_j = np.random.uniform(0.0, 1.0, number_of_weights) v_k = np.random.uniform(0.0, 1.0, number_of_weights) # Purely imaginary quaternions unitary for i in range(0, number_of_weights): norm = np.sqrt(v_i[i]**2 + v_j[i]**2 + v_k[i]**2) + 0.0001 v_i[i] /= norm v_j[i] /= norm v_k[i] /= norm v_i = v_i.reshape(kernel_shape) v_j = v_j.reshape(kernel_shape) v_k = v_k.reshape(kernel_shape) modulus = rng.uniform(low=-s, high=s, size=kernel_shape) phase = rng.uniform(low=-np.pi, high=np.pi, size=kernel_shape) weight_r = modulus * np.cos(phase) weight_i = modulus * v_i * np.sin(phase) weight_j = modulus * v_j * np.sin(phase) weight_k = modulus * v_k * np.sin(phase) return (weight_r, weight_i, weight_j, weight_k)
class FitRNNv2(RNNv2, FitModel): def run(self): self.random = RandomState(self.random_seed) # Split the orders into training and validation sets and write them to separate files orders_path = self.requires()['orders'].output().path training_fd = tempfile.NamedTemporaryFile(mode='w+', delete=True) validation_fd = tempfile.NamedTemporaryFile(mode='w+', delete=True) with open(orders_path) as input_fd: for line in input_fd: if self.global_orders_ratio >= 1 or self.random.uniform( ) <= self.global_orders_ratio: if self.random.uniform() <= self.validation_orders_ratio: validation_fd.write(line) else: training_fd.write(line) validation_fd.flush() training_fd.flush() _, validation_inputs, validation_predictions = self._load_data( validation_fd.name) training_generator, training_steps_per_epoch = \ self._create_data_generator(training_fd.name, self.users_per_batch, max_prior_orders=self.max_prior_orders) model = self._build_model() model.summary() callbacks = [ EarlyStopping(monitor='val_loss', patience=10), ModelCheckpoint(os.path.abspath(self.output().path), verbose=1, save_weights_only=True, save_best_only=True), ] if self.mode == 'evaluation': log_dir = os.path.join(OUTPUT_DIR, 'tensorboard', self.mode, self.model_name) callbacks.append( TensorBoard(log_dir=log_dir, histogram_freq=5, write_graph=False)) model.fit_generator(training_generator, training_steps_per_epoch, validation_data=(validation_inputs, validation_predictions), epochs=self.epochs, verbose=2, callbacks=callbacks) validation_fd.close() training_fd.close()
def __init__(self, knapsack_capacity, total_posible_elements, seed, max_cost, max_value, elements=None): self.knapsack_capacity = knapsack_capacity if elements is not None and type(elements) == type([]): self.elements = elements self.total_posible_elements = len(elements) else: self.total_posible_elements = total_posible_elements rnd = RandomState(seed) #list of tuples with value and cost self.elements = [] #fill elements for _ in range(total_posible_elements): self.elements.append((rnd.uniform(0, max_value), rnd.uniform(0, max_cost)))
class ParticleBetaModelSource(object): def __init__(self): self.prng = RandomState(24) self.kT = kT self.Z = Z num_particles = 1000000 rr = np.linspace(0.0, R, 10000) # This formula assumes beta = 2/3 M_r = 4 * np.pi * rho_c * r_c * r_c * (rr - r_c * np.arctan(rr / r_c)) M_r *= cm_per_mpc**3 pmass = M_r[-1] * np.ones(num_particles) / num_particles M_r /= M_r[-1] u = self.prng.uniform(size=num_particles) radius = np.interp(u, M_r, rr, left=0.0, right=1.0) dens = rho_c * (1. + (radius / r_c)**2)**(-1.5 * beta) radius /= (2. * R) theta = np.arccos( self.prng.uniform(low=-1., high=1., size=num_particles)) phi = 2. * np.pi * self.prng.uniform(size=num_particles) temp = self.kT * K_per_keV * np.ones(num_particles) velz = self.prng.normal(loc=v_shift, scale=v_width, size=num_particles) bbox = np.array([[-0.5, 0.5], [-0.5, 0.5], [-0.5, 0.5]]) data = {} data["io", "density"] = (dens, "g/cm**3") data["io", "temperature"] = (temp, "K") data["io", "particle_position_x"] = (radius * np.sin(theta) * np.cos(phi), "code_length") data["io", "particle_position_y"] = (radius * np.sin(theta) * np.sin(phi), "code_length") data["io", "particle_position_z"] = (radius * np.cos(theta), "code_length") data["io", "particle_velocity_x"] = (np.zeros(num_particles), "cm/s") data["io", "particle_velocity_y"] = (np.zeros(num_particles), "cm/s") data["io", "particle_velocity_z"] = (velz, "cm/s") data["io", "particle_mass"] = (pmass, "g") data["io", "smoothing_length"] = (0.02 / (2. * R) * np.ones(num_particles), "code_length") self.ds = load_particles(data, length_unit=(2 * R, "Mpc"), bbox=bbox)
def solve(self, optimization_function): rand = RandomState(self.seed) X = optimization_function.X n_dim = X.shape[1] - 1 candidates = {} no_improvements = 0 best_value = np.inf f = 1 while no_improvements < 50: if len(candidates) == 0: # first run for i in range(self.n_scan): candidate = rand.uniform(0, 1, n_dim) value = optimization_function.compute(candidate) candidates[value] = candidate else: # evolution vectors = list(candidates.values()) ranges = [ np.max([v[i] for v in vectors]) - np.min([v[i] for v in vectors]) for i in range(n_dim) ] values_sorted = sorted(candidates.keys()) best_value = values_sorted[0] for i in range(self.n_keep): i_candidate = i * len(values_sorted) // self.n_keep candidate = candidates[values_sorted[i_candidate]] # perturbation = ranges * rand.uniform(-1, 1, len(ranges)) perturbation = f * rand.uniform(-1, 1, len(ranges)) new_candidate = candidate + perturbation new_candidate = np.clip(new_candidate, 0, 1) value = optimization_function.compute(new_candidate) candidates[value] = new_candidate f *= self.spread_factor # only keep the best candidates values_sorted = sorted(candidates.keys()) values_sorted = values_sorted[:self.n_keep] if values_sorted[0] < best_value: no_improvements = 0 else: no_improvements += 1 candidates = {v: candidates[v] for v in values_sorted}
def gen_random_points_poly(poly, num_points, seed = None): """ Returns a list of N randomly generated points within a polygon. """ min_x, min_y, max_x, max_y = poly.bounds points = [] i=0 while len(points) < num_points: s=RandomState(seed+i) if seed else RandomState(seed) random_point = Point([s.uniform(min_x, max_x), s.uniform(min_y, max_y)]) if random_point.within(poly): points.append(random_point) i+=1 return points
def sample_group_counts( random_state: RandomState, total: int, lam_low: float = 1.0, lam_high: float = 8.0 ) -> List[int]: """ Sample a list of integers which sum up to `total`. The probability of sampling an integer follows exponential decay, k ~ np.exp(-k * lam), where lam is a hyperparam sampled from a range [lam_low, lam_high). :param random_state: numpy random state :param total: the expected sum of sampled numbers. :param lam_low: lower bound for lambda in exponential decay. :param lam_high: higher bound for lambda in exponential decay. :return: """ current_max = total counts = [] while current_max > 0: candidates = range(1, current_max + 1) lam = random_state.uniform(lam_low, lam_high) probs = np.array([np.exp(-i * lam) for i in candidates]) probs /= sum(probs) selected = random_state.choice(candidates, p=probs) counts.append(selected) current_max -= selected assert sum(counts) == total return counts
def transpose_characters(token, index_to_char, n=1, char_pool=None, seed=17): if isinstance(seed, RandomState): rng = seed else: rng = RandomState(seed) chars = set(token) if len(chars) == 1: return token new_token = token for i in six.moves.range(n): idx = max(1, rng.randint(len(new_token))) neighbor = 0 if idx == 0: neighbor == 1 elif idx == len(new_token) - 1: neighbor = len(new_token) - 2 else: if rng.uniform() > 0.5: neighbor = idx + 1 else: neighbor = idx - 1 left = min(idx, neighbor) right = max(idx, neighbor) new_token = unicode(new_token[0:left] + new_token[right] + new_token[left] + new_token[right+1:]) return new_token
def get_weight(self, date_time, how, error_magnitude=0., error_type=None): if self.tv_type == 'day:hour': if how == 'linear': day = date_time.date() m = (self.data[day][date_time.hour + 1] - self.data[day][date_time.hour]) w = self.data[day][date_time.hour] + m * (date_time.minutes / 60) elif how == 'last': w = self.data[date_time.day()][date_time.hour] elif how == 'next': w = self.data[date_time.day()][date_time.hour + 1] else: raise AttributeError("Invalid input for argument 'how'.") elif self.tv_type == 'day:schedule': w = min([ t - date_time.time() for t in self.data[date_time.isoweekday()] if t > date_time.time() ]) elif self.tv_type is None: w = self.data else: raise TypeError("Time variance type corrupted.") if error_type.lower() in ['normal', 'gaussian']: w += RandomState.normal(loc=error_magnitude[0], scale=error_magnitude[1]) elif error_type.lower() == 'uniform': w += RandomState.uniform(low=error_magnitude[0], high=error_magnitude[1]) else: pass return w
def transform(X_input): """Calculate the random fourier features for an Gaussian kernel Keyword arguments: X_input - the input matrix X_input which will be transformed """ # Parameters m = 3000 gamma = 60 # Copy X = X_input # Get the dimensions d = 0 if len(X.shape)<=1: d = len(X) else: d = X.shape[1] # Draw iid m samples omega from p and b from [0,2pi] random_state = RandomState(124) omega = np.sqrt(2.0 * gamma) * random_state.normal(size=(d, m)) b = random_state.uniform(0, 2 * np.pi, size=m) # Transform the input projection = np.dot(X, omega) + b Z = np.sqrt(2.0/m) * np.cos(projection) return Z
def test_mutual_information(seed): num_data_points = 500 rs = RandomState(seed) mi_random_uniform = compute_mutual_information( rs.uniform(-1, 1, size=(2, num_data_points))) rs = RandomState(seed) mi_random_gaussian = compute_mutual_information( rs.normal(size=(2, num_data_points))) rs = RandomState(seed) mi_random_gaussian = compute_mutual_information( rs.normal(size=(2, num_data_points))) rs = RandomState(seed) mi_constant = compute_mutual_information( np.ones((2, num_data_points)) + rs.normal(0, 1e-15, size=(2, num_data_points))) rs = RandomState(seed) mi_correlated = compute_mutual_information( generate_correlated_data(num_data_points, cov=0.9, rs=rs)) print('MI random uniform:', mi_random_uniform) print('MI random gaussian:', mi_random_gaussian) print('MI constant:', mi_constant) print('MI correlated:', mi_correlated)
def __call__(self, shape, dtype = None): if self.flattened is True: # Dense num_rows = np.prod(shape) num_cols = 1 fan_in = np.prod(shape[:-1]) else: # Conv num_rows = np.prod(shape[-2:]) num_cols = np.prod(shape[:-2]) fan_in = shape[-2] fan_out = shape[-1] flat_shape = (num_rows, num_cols) rng = RandomState(self.seed) x = rng.uniform(size = flat_shape) u, _, v = np.linalg.svd(x) orthogonal_x = np.dot(u, np.dot(np.eye(flat_shape), v.T)) independent_filters = np.reshape(orthogonal_x, shape) if self.criterion == 'glorot': desired_var = 2. / (fan_in + fan_out) elif self.criterion == 'he': desired_var = 2. / fan_in else: raise ValueError('Invalid criterion: ' + self.criterion) multip_constant = np.sqrt(desired_var / np.var(independent_filters)) weight = multip_constant * independent_filters return weight
class RandomGenerator(object): def __init__(self, seed=None): self._random = RandomState(seed=seed) def seed(self, seed): self._random.seed(seed) def random(self): return self._random.rand() def randint(self, a, b=None): if b is None: b = a a = 0 r = self._random.randint(a, high=b, size=1) return r[0] def sample(self, population, k): if k == 0: return [] return list(self._random.choice(population, size=k, replace=False)) def __getattr__(self, attr): return getattr(self._random, attr) def __getstate__(self): return {'_random': self._random} def __setstate__(self, d): self._random = d['_random'] def uniform(self, low=0.0, high=1.0, size=None): return self._random.uniform(low, high, size)
class FitRNNv1(RNNv1, FitModel): def _build_model(self): product = Input(shape=(1, )) product_embedded = Embedding(input_dim=self.num_products + 1, output_dim=self.embedding_dim, input_length=1)(product) product_embedded = Reshape(target_shape=(self.embedding_dim, ))(product_embedded) product_embedding = Model(inputs=product, outputs=product_embedded, name='product_embedding') user_input = Input(shape=(self.max_products_per_user, 1), name='user_input') user_embedded = Masking(name='masking')(user_input) user_embedded = TimeDistributed(product_embedding, name='user_embedded')(user_embedded) user_embedded = Bidirectional(LSTM(self.embedding_dim), merge_mode='concat', name='lstm')(user_embedded) user_embedded = Dense(self.embedding_dim, activation='relu', name='hidden')(user_embedded) product_input = Input(shape=(1, ), name='product_input') product_embedded = product_embedding(product_input) score = dot([user_embedded, product_embedded], axes=[-1, -1], name='score') model = Model(inputs=[product_input, user_input], outputs=score) model.compile(loss=hinge_loss, optimizer='adam') return model def run(self): self.random = RandomState(self.random_seed) orders_path = self.requires()['orders'].output().path with tempfile.NamedTemporaryFile(mode='w+', delete=True) as training_fd: with tempfile.NamedTemporaryFile(mode='w+', delete=True) as validation_fd: # Split the orders file into training and validation with open(orders_path) as input_fd: for line in input_fd: if self.random.uniform() <= 0.1: validation_fd.write(line) else: training_fd.write(line) validation_fd.flush() training_fd.flush() # Fit the model training_generator, training_steps_per_epoch = \ self.create_generator(training_fd.name, users_per_batch=self.users_per_batch, shuffle=True, include_prior_orders=True) validation_generator, validation_steps_per_epoch = \ self.create_generator(validation_fd.name, users_per_batch=self.users_per_batch, shuffle=False, include_prior_orders=False) model = self._build_model() model.summary() callbacks = [ EarlyStopping(monitor='val_loss', patience=10), ModelCheckpoint(self.output().path, verbose=1, save_best_only=True), TensorBoard(log_dir=os.path.join(OUTPUT_DIR, 'tensorboard', self.model_name), write_graph=False), ] model.fit_generator(training_generator, training_steps_per_epoch, validation_data=validation_generator, validation_steps=validation_steps_per_epoch, epochs=1000, verbose=1, callbacks=callbacks)
def edge_grab( two_qubit_gate_prob: float, connectivity_graph: nx.Graph, random_state: random.RandomState, ) -> nx.Graph: """Returns a set of edges for which two qubit gates are to be applied given a two qubit gate density and the connectivity graph that must be satisfied. Args: two_qubit_gate_prob: Probability of an edge being chosen from the set of candidate edges. connectivity_graph: The connectivity graph for the backend on which the circuit will be run. random_state: Random state to select edges (uniformly at random). """ connectivity_graph = connectivity_graph.copy() candidate_edges = nx.Graph() final_edges = nx.Graph() final_edges.add_nodes_from(connectivity_graph) while connectivity_graph.edges: num = random_state.randint(connectivity_graph.size()) edges = list(connectivity_graph.edges) curr_edge = edges[num] candidate_edges.add_edge(*curr_edge) connectivity_graph.remove_nodes_from(curr_edge) for edge in candidate_edges.edges: if random_state.uniform(0.0, 1.0) < two_qubit_gate_prob: final_edges.add_edge(*edge) return final_edges
def generate_rand_obs(nExp, nObs, domainBounds, sigvar=None, rng=None): # create random sets of observations for each experiment if not sigvar: sigvar = 1. if not rng: rng = RandomState() domainBounds = npa(domainBounds) dimX = domainBounds.shape[0] minX = domainBounds[:, 0] maxX = domainBounds[:, 1] rangeX = maxX - minX xObs = rng.uniform(size=(nExp, nObs, dimX)) xObs *= rangeX xObs += minX yObs = empty(shape=(nExp, nObs)) for iexp in xrange(nExp): good = False while not good: yObs0 = rng.normal(size=(nObs)) if yObs0.max() > 0: good = True yObs[iexp, :] = yObs0 # yObs = rng.normal(size=(nExp, nObs, 1)) yObs *= sigvar return {'x': xObs, 'y': yObs}
def update_metropolis(field: np.ndarray, states: States, free_energy: float, interaction: Interaction, interaction_coefficient: float, magnetization_coefficient: float, temperature: float, random_state: RandomState) -> (np.ndarray, float): assert states assert field.shape[0] == field.shape[1] size = field.shape[0] min_x = 0 if FIX_LEFT is None else 1 max_x = size if FIX_RIGHT is None else size - 1 min_y = 0 if FIX_BOTTOM is None else 1 max_y = size if FIX_TOP is None else size - 1 random_x = random_state.randint(min_x, max_x) # dim random_y = random_state.randint(min_y, max_y) new_spin = field[random_x, random_y] # spin flip always needs to lead to a change of spin while new_spin == field[random_x, random_y]: new_spin = random_state.choice(states) energy_delta, field_updated = calculate_energy_difference(field, random_x, random_y, new_spin, interaction, interaction_coefficient, magnetization_coefficient) random_number = random_state.uniform() acceptance_probability = np.exp(-1. / temperature * energy_delta) print_if_verbose(f'Energy delta: {energy_delta}, random number: {random_number}, ' f'acceptance_probability: {acceptance_probability}') if energy_delta <= 0 or random_number < acceptance_probability: # free_energy_updated = free_energy - energy_delta print_if_verbose('Change accepted') return field_updated, free_energy - energy_delta else: print_if_verbose('Not accepted') return field, free_energy
def _run(self, op): rng = RandomState(self.random_seed) with self.output().open('w') as output_fd: with self.input().open('r') as input_fd: for line in input_fd: if op(rng.uniform(), self.test_size): output_fd.write(line)
def rws_test(): size = 10000 selection = 1000 random_state = RandomState() probs = random_state.uniform(size=size) probs /= sum(probs) random_state.seed(5) def standard_method(): t.tic() result = [] cum_probs = np.cumsum(probs) for _ in range(selection): r = random_state.random() for i in range(size): if r <= cum_probs[i]: result.append(i) break return result def numpy_method(): return random_state.choice(size, size=selection, replace=True, p=probs) t = TicToc() t.tic() result_standard_method = standard_method() elp_std = t.tocvalue(restart=True) result_numpy_method = numpy_method() elp_np = t.tocvalue() print('standard: {}'.format(elp_std)) print('numpy: {}'.format(elp_np)) print(result_numpy_method) print(result_standard_method)
class RandomGenerator(object): def __init__(self, seed=None): self._random = RandomState(seed=seed) def seed(self, seed): self._random = RandomState(seed=seed) def random(self): return self._random.rand() def randint(self, a, b=None): if b is None: b = a a = 0 r = self._random.randint(a, high=b, size=1) return r[0] def sample(self, population, k): if k == 0: return [] return list(self._random.choice(population, size=k, replace=False)) def __getattr__(self, attr): return getattr(self._random, attr) def __getstate__(self): return {'_random': self._random} def __setstate__(self, d): self._random = d['_random'] def uniform(self, low=0.0, high=1.0, size=None): return self._random.uniform(low, high, size)
def __call__(self, shape, dtype=None): if self.nb_filters is not None: kernel_shape = shape # kernel_shape = tuple(self.kernel_size) + (int(self.input_dim), # self.nb_filters) else: kernel_shape = (int(self.input_dim), self.kernel_size[-1]) fan_in, fan_out = _compute_fans( # tuple(self.kernel_size) + (self.input_dim, self.nb_filters) kernel_shape ) # fix for ValueError: The initial value's shape (...) is not compatible with the explicitly supplied `shape` argument reim_shape = list(kernel_shape) reim_shape[-1] //= 2 reim_shape = tuple(reim_shape) if self.criterion == 'glorot': s = 1. / (fan_in + fan_out) elif self.criterion == 'he': s = 1. / fan_in else: raise ValueError('Invalid criterion: ' + self.criterion) rng = RandomState(self.seed) modulus = rng.rayleigh(scale=s, size=reim_shape) phase = rng.uniform(low=-np.pi, high=np.pi, size=reim_shape) weight_real = modulus * np.cos(phase) weight_imag = modulus * np.sin(phase) weight = np.concatenate([weight_real, weight_imag], axis=-1) return weight
def __call__(self, shape, dtype=None): if self.nb_filters is not None: kernel_shape = tuple(self.kernel_size) + (int(self.input_dim), self.nb_filters) else: kernel_shape = (int(self.input_dim), self.kernel_size[-1]) fan_in, fan_out = initializers._compute_fans( tuple(self.kernel_size) + (self.input_dim, self.nb_filters) ) if self.criterion == 'glorot': s = 1. / (fan_in + fan_out) elif self.criterion == 'he': s = 1. / fan_in else: raise ValueError('Invalid criterion: ' + self.criterion) rng = RandomState(self.seed) modulus = rng.rayleigh(scale=s, size=kernel_shape) phase = rng.uniform(low=-np.pi, high=np.pi, size=kernel_shape) weight_real = modulus * np.cos(phase) weight_imag = modulus * np.sin(phase) weight = np.concatenate([weight_real, weight_imag], axis=-1) return weight
def test_minp_one_pvalue(): prng = RandomState(55) pvalues = np.array([1]) distr = prng.uniform(low=0, high=10, size=20).reshape(20, 1) npc(pvalues, distr, "fisher", "greater") # TODO: more fwer_minp tests
def convolution(self): #initialize my conv kernel self.kernels_real = [] self.kernels_imag = [] for i, filter_size in enumerate(self.filter_sizes): with tf.name_scope('conv-pool-%s' % filter_size): filter_shape = [filter_size, filter_size, 1, self.num_filters] input_dim = 2 fan_in = np.prod(filter_shape[:-1]) fan_out = (filter_shape[-1] * np.prod(filter_shape[:2])) s = 1. / fan_in rng = RandomState(23455) modulus = rng.rayleigh(scale=s, size=filter_shape) phase = rng.uniform(low=-np.pi, high=np.pi, size=filter_shape) W_real = modulus * np.cos(phase) W_imag = modulus * np.sin(phase) W_real = tf.Variable(W_real, dtype='float32') W_imag = tf.Variable(W_imag, dtype='float32') self.kernels_real.append(W_real) self.kernels_imag.append(W_imag) # self.para.append(W_real) # self.para.append(W_imag) self.num_filters_total = self.num_filters * len(self.filter_sizes) self.qa_real = self.narrow_convolution( tf.expand_dims(self.M_qa_real, -1), self.kernels_real) - self.narrow_convolution( tf.expand_dims(self.M_qa_imag, -1), self.kernels_imag) print(self.qa_real) self.qa_imag = self.narrow_convolution( tf.expand_dims(self.M_qa_imag, -1), self.kernels_real) + self.narrow_convolution( tf.expand_dims(self.M_qa_real, -1), self.kernels_imag) print(self.qa_imag)
def test_npc_callable_combine(): prng = RandomState(55) pvalues = np.linspace(0.05, 0.9, num=5) distr = prng.uniform(low=0, high=10, size=500).reshape(100, 5) size = np.array([2, 4, 6, 4, 2]) combine = lambda p: inverse_n_weight(p, size) res = npc(pvalues, distr, combine, "greater") np.testing.assert_equal(res, 0.39)
def test_npc_callable_combine(): prng = RandomState(55) pvalues = np.linspace(0.05, 0.9, num=5) distr = prng.uniform(low=0, high=10, size=500).reshape(100, 5) size = np.array([2, 4, 6, 4, 2]) combine = lambda p: inverse_n_weight(p, size) res = npc(pvalues, distr, combine, "greater", plus1=False) np.testing.assert_equal(res, 0.39)
def test_pixel_to_cel(): prng = RandomState(24) n_evt = 100000 sky_center = YTArray([30.0, 45.0], "deg") rr = YTQuantity(100.0, "kpc")*prng.uniform(size=n_evt) theta = 2.0*np.pi*prng.uniform(size=n_evt) xx = rr*np.cos(theta) yy = rr*np.sin(theta) D_A = YTQuantity(100.0, "Mpc") d_a = D_A.to("kpc").v xx = xx.d / d_a yy = yy.d / d_a xsky1 = xx.copy() ysky1 = yy.copy() pixel_to_cel(xsky1, ysky1, sky_center.d) xx = np.rad2deg(xx) * 3600.0 # to arcsec yy = np.rad2deg(yy) * 3600.0 # to arcsec # We set a dummy pixel size of 1 arcsec just to compute a WCS dtheta = 1.0 / 3600.0 wcs = pywcs.WCS(naxis=2) wcs.wcs.crpix = [0.0, 0.0] wcs.wcs.crval = list(sky_center) wcs.wcs.cdelt = [-dtheta, dtheta] wcs.wcs.ctype = ["RA---TAN", "DEC--TAN"] wcs.wcs.cunit = ["deg"]*2 xsky2, ysky2 = wcs.wcs_pix2world(xx, yy, 1) assert_allclose(xsky1, xsky2) assert_allclose(ysky1, ysky2)
class ParticleBetaModelSource(object): def __init__(self): self.prng = RandomState(35) self.kT = kT self.Z = Z num_particles = 1000000 rr = np.linspace(0.0, R, 10000) # This formula assumes beta = 2/3 M_r = 4*np.pi*rho_c*r_c*r_c*(rr-r_c*np.arctan(rr/r_c)) M_r *= cm_per_mpc**3 pmass = M_r[-1]*np.ones(num_particles)/num_particles M_r /= M_r[-1] u = self.prng.uniform(size=num_particles) radius = np.interp(u, M_r, rr, left=0.0, right=1.0) dens = rho_c*(1.+(radius/r_c)**2)**(-1.5*beta) radius /= (2.*R) theta = np.arccos(self.prng.uniform(low=-1.,high=1.,size=num_particles)) phi = 2.*np.pi*self.prng.uniform(size=num_particles) temp = self.kT*K_per_keV*np.ones(num_particles) velz = self.prng.normal(loc=v_shift,scale=v_width,size=num_particles) bbox = np.array([[-0.5,0.5],[-0.5,0.5],[-0.5,0.5]]) data = {} data["io", "density"] = (dens, "g/cm**3") data["io", "temperature"] = (temp, "K") data["io", "particle_position_x"] = (radius*np.sin(theta)*np.cos(phi), "code_length") data["io", "particle_position_y"] = (radius*np.sin(theta)*np.sin(phi), "code_length") data["io", "particle_position_z"] = (radius*np.cos(theta), "code_length") data["io", "particle_velocity_x"] = (np.zeros(num_particles), "cm/s") data["io", "particle_velocity_y"] = (np.zeros(num_particles), "cm/s") data["io", "particle_velocity_z"] = (velz, "cm/s") data["io", "particle_mass"] = (pmass, "g") self.ds = load_particles(data, length_unit=(2*R, "Mpc"), bbox=bbox)
def _initializeWeights(self, size, fanIn, fanOut, randomNumGen) : '''Initialize the weights according to the activation type selected. Distributions : sigmoid : (-sqrt(6/(fanIn+fanOut))*4, sqrt(6/(fanIn+fanOut))*4) tanh : (-sqrt(6/(fanIn+fanOut)), sqrt(6/(fanIn+fanOut))) relu : (-rand()*sqrt(2/fanIn), rand()*sqrt(2/fanIn)) size : Shape of the weight buffer fanIn : Number of neurons in the previous layer fanOut : Number of neurons in the this layer randomNumGen : generator for the initial weight values - type is numpy.random.RandomState ''' import numpy as np import theano.tensor as t from theano import shared, config # create a rng if its needed if randomNumGen is None : from numpy.random import RandomState from time import time randomNumGen = RandomState(int(time())) if self._activation == t.nnet.relu : scaleFactor = np.sqrt(2. / fanIn) initialWeights = np.resize(np.asarray( randomNumGen.randn(np.prod(np.array(size))) * scaleFactor, dtype=config.floatX), size) elif self._activation == t.nnet.sigmoid or \ self._activation == t.tanh or \ self._activation == None : scaleFactor = np.sqrt(6. / (fanIn + fanOut)) # re-adjust for sigmoid if self._activation == t.nnet.sigmoid : scaleFactor *= 4. initialWeights = np.asarray(randomNumGen.uniform( low=-scaleFactor, high=scaleFactor, size=size), dtype=config.floatX) else : raise ValueError('Unsupported activation encountered. Add weight-'\ 'initialization support for this activation type') # load the weights into shared variables self._weights = shared(value=initialWeights, borrow=True) initialThresholds = np.zeros((fanOut,), dtype=config.floatX) self._thresholds = shared(value=initialThresholds, borrow=True)
def add_timecourse(topo_view,y, fixed_points=8, change_magnitude=0.5): # topo view shd be bc01 rng = RandomState(np.uint64(hash('decreasetimecourse'))) trials = topo_view.shape[0] samples = topo_view.shape[2] fixed_points_x = np.linspace(0,samples,fixed_points) fixed_points_y = [rng.uniform(1-change_magnitude,1+change_magnitude, fixed_points) for _ in xrange(trials)] interp_fun = interp1d(fixed_points_x, fixed_points_y, 'linear') timecourses = interp_fun(np.arange(600)) # now has shape trialsxsamples timecourses = timecourses[:,np.newaxis,:,np.newaxis] topo_view = topo_view * timecourses return topo_view
def dowork(self, work_index): ''' This can return anything, but note that it will be binary serialized (pickleable), and you don't want to have more than is required there for reduce ''' import scipy as sp from numpy.random import RandomState # seed the global random number generator with work_index xor'd with an arbitrary constant randomstate = RandomState(work_index ^ 284882) sum = 0.0 for i in xrange(self.dart_count): x = randomstate.uniform(2) y = randomstate.uniform(2) is_in_circle = sp.sqrt((x-1)**2+(y-1)**2) < 1 if is_in_circle: sum += 1 fraction_in_circle = sum / self.dart_count return fraction_in_circle
def test_npc(): prng = RandomState(55) pvalues = np.linspace(0.05, 0.9, num=5) distr = prng.uniform(low=0, high=10, size=500).reshape(100, 5) res = npc(pvalues, distr, "fisher", "greater") np.testing.assert_almost_equal(res, 0.33) res = npc(pvalues, distr, "fisher", "less") np.testing.assert_almost_equal(res, 0.33) res = npc(pvalues, distr, "fisher", "two-sided") np.testing.assert_almost_equal(res, 0.31) res = npc(pvalues, distr, "liptak", "greater") np.testing.assert_almost_equal(res, 0.35) res = npc(pvalues, distr, "tippett", "greater") np.testing.assert_almost_equal(res, 0.25) res = npc(pvalues, distr, "fisher", alternatives=np.array(["less", "greater", "less", "greater", "two-sided"])) np.testing.assert_almost_equal(res, 0.38)
def perform_optimization(self, training_strategy): OutputLog().write('----------------------------------------------------------') OutputLog().write('layer_sizes correlations cca_correlations time') hyper_parameters = self.hyper_parameters.copy() random_rng = RandomState() best_correlation = 0 for layer_number in xrange(int(self.layer_number_start), int(self.layer_number_end + 1)): for iteration in xrange(int(self.rounds_number)): hyper_parameters.layer_sizes = random_rng.uniform(self.start_value, self.end_value, layer_number) hyper_parameters.layer_sizes = [int(round(layer_size)) for layer_size in hyper_parameters.layer_sizes] if self.symmetric_layers: for i in xrange(layer_number): hyper_parameters.layer_sizes[(layer_number - 1) - i] = hyper_parameters.layer_sizes[i] correlation, execution_time = self.train(training_strategy=training_strategy, hyper_parameters=hyper_parameters) if correlation > best_correlation: best_correlation = correlation self.hyper_parameters.layer_sizes = hyper_parameters.layer_sizes OutputLog().write('%s, %f, %f\n' % (print_list(hyper_parameters.layer_sizes), correlation, execution_time)) OutputLog().write('----------------------------------------------------------') return True
def generateDegradation(args, seed): from numpy.random import RandomState from numpy.linalg import norm rs = RandomState(seed) if args.D == 2: rotation = (rs.uniform(*args.rotate),) if args.D == 3: angle = rs.uniform(*args.rotate) axis = rs.uniform(size=3) axis = axis/norm(axis) rotation = angle, axis translation = rs.uniform(*args.translate, size=args.D) scale = rs.uniform(*args.scale) if args.drop[0] == args.drop[1]: ndrops = args.drop[0] else: ndrops = rs.randint(*sorted(args.drop)) drops = rs.choice(range(args.N), size=ndrops, replace=False) duplications = rs.choice(range(args.duplicate[0], args.duplicate[1] + 1), size=args.N - ndrops) noise = rs.uniform(*args.noise) * rs.randn(sum(duplications), args.D) return rotation, translation, scale, drops, duplications, noise
os.makedirs(directory) SAVEDIR = SAVEDIR + RUNID + '/' WDIR = SAVEDIR + 'W/' mkdir(SAVEDIR) mkdir(WDIR) PRINTTO = SAVEDIR + 'generated_output.txt' SEQLEN = rng.randint(20, 150) SHUF_DATA = rng.randint(2) NLAYER = rng.randint(1, 4) NHID = [rng.randint(50, 500) for _ in xrange(NLAYER)] PDROP = [rng.rand() for _ in xrange(NLAYER)] BATCHSIZE = rng.randint(50, 200) LRINIT = rng.uniform(0.001, 0.1) RNGSEED = rng.randint(4525348) rng = RandomState(RNGSEED) runparams = {'SEQLEN': SEQLEN, 'SHUF_DATA': SHUF_DATA, 'NLAYER': NLAYER, 'NHID': NHID, 'PDROP': PDROP, 'BATCHSIZE': BATCHSIZE, 'LRINIT': LRINIT, 'RNGSEED': RNGSEED} pickle(runparams, SAVEDIR+'runparams.pkl')
def __init__ (self, layerID, input, inputSize, kernelSize, downsampleFactor, learningRate=0.001, momentumRate=0.9, dropout=None, initialWeights=None, initialThresholds=None, activation=tanh, randomNumGen=None) : Layer.__init__(self, layerID, learningRate, momentumRate, dropout) # TODO: this check is likely unnecessary if inputSize[2] == kernelSize[2] or inputSize[3] == kernelSize[3] : raise ValueError('ConvolutionalLayer Error: ' + 'inputSize cannot equal kernelSize') if inputSize[1] != kernelSize[1] : raise ValueError('ConvolutionalLayer Error: ' + 'Number of Channels must match in ' + 'inputSize and kernelSize') from theano.tensor.nnet.conv import conv2d from theano.tensor.signal.downsample import max_pool_2d # theano variables don't actually preserve buffer sizing self.input = input if isinstance(input, tuple) else (input, input) self._inputSize = inputSize self._kernelSize = kernelSize self._downsampleFactor = downsampleFactor # setup initial values for the weights -- if necessary if initialWeights is None : # create a rng if its needed if randomNumGen is None : from numpy.random import RandomState from time import time randomNumGen = RandomState(int(time())) # this creates optimal initial weights by randomizing them # to an appropriate range around zero, which leads to better # convergence. downRate = np.prod(self._downsampleFactor) fanIn = np.prod(self._kernelSize[1:]) fanOut = self._kernelSize[0] * \ np.prod(self._kernelSize[2:]) / downRate scaleFactor = np.sqrt(6. / (fanIn + fanOut)) initialWeights = np.asarray(randomNumGen.uniform( low=-scaleFactor, high=scaleFactor, size=self._kernelSize), dtype=config.floatX) self._weights = shared(value=initialWeights, borrow=True) # setup initial values for the thresholds -- if necessary if initialThresholds is None : initialThresholds = np.zeros((self._kernelSize[0],), dtype=config.floatX) self._thresholds = shared(value=initialThresholds, borrow=True) def findLogits(input, weights, inputSize, kernelSize, downsampleFactor, thresholds) : # create a function to perform the convolution convolve = conv2d(input, weights, inputSize, kernelSize) # create a function to perform the max pooling pooling = max_pool_2d(convolve, downsampleFactor, True) # the output buffer is now connected to a sequence of operations return pooling + thresholds.dimshuffle('x', 0, 'x', 'x') outClass = findLogits(self.input[0], self._weights, self._inputSize, self._kernelSize, self._downsampleFactor, self._thresholds) outTrain = findLogits(self.input[1], self._weights, self._inputSize, self._kernelSize, self._downsampleFactor, self._thresholds) # determine dropout if requested if self._dropout is not None : # here there are two possible paths -- # outClass : path of execution intended for classification. Here # all neurons are present and weights must be scaled by # the dropout factor. This ensures resultant # probabilities fall within intended bounds when all # neurons are present. # outTrain : path of execution for training with dropout. Here each # neuron's output goes through a Bernoulli Trial. This # retains a neuron with the probability specified by the # dropout factor. outClass = outClass / self._dropout outTrain = switch(self._randStream.binomial( size=self.getOutputSize()[1:], p=self._dropout), outTrain, 0) # activate the layer -- # output is a tuple to represent two possible paths through the # computation graph. self.output = (outClass, outTrain) if activation is None else \ (activation(outClass), activation(outTrain)) # we can call this method to activate the layer self.activate = function([self.input[0]], self.output[0])
def __init__ (self, layerID, input, inputSize, numNeurons, learningRate=0.001, momentumRate=0.9, dropout=None, initialWeights=None, initialThresholds=None, activation=tanh, randomNumGen=None) : Layer.__init__(self, layerID, learningRate, momentumRate, dropout) # adjust the input for the correct number of dimensions if isinstance(input, tuple) : if input[1].ndim > 2 : input = input[0].flatten(2), \ input[1].flatten(2) else : if input.ndim > 2 : input = input.flatten(2) # store the input buffer -- this can either be a tuple or scalar # The input layer will only have a scalar so its duplicated here self.input = input if isinstance(input, tuple) else (input, input) self._inputSize = inputSize if isinstance(self._inputSize, six.integer_types) or \ len(self._inputSize) is not 2 : self._inputSize = (1, inputSize) self._numNeurons = numNeurons # setup initial values for the weights if initialWeights is None : # create a rng if its needed if randomNumGen is None : from numpy.random import RandomState from time import time randomNumGen = RandomState(int(time())) initialWeights = np.asarray(randomNumGen.uniform( low=-np.sqrt(6. / (self._inputSize[1] + self._numNeurons)), high=np.sqrt(6. / (self._inputSize[1] + self._numNeurons)), size=(self._inputSize[1], self._numNeurons)), dtype=config.floatX) if activation == sigmoid : initialWeights *= 4. self._weights = shared(value=initialWeights, borrow=True) # setup initial values for the thresholds if initialThresholds is None : initialThresholds = np.zeros((self._numNeurons,), dtype=config.floatX) self._thresholds = shared(value=initialThresholds, borrow=True) # create the logits def findLogit(input, weights, thresholds) : return dot(input, weights) + thresholds outClass = findLogit(self.input[0], self._weights, self._thresholds) outTrain = findLogit(self.input[1], self._weights, self._thresholds) # determine dropout if requested if self._dropout is not None : # here there are two possible paths -- # outClass : path of execution intended for classification. Here # all neurons are present and weights must be scaled by # the dropout factor. This ensures resultant # probabilities fall within intended bounds when all # neurons are present. # outTrain : path of execution for training with dropout. Here each # neuron's output goes through a Bernoulli Trial. This # retains a neuron with the probability specified by the # dropout factor. outClass = outClass / self._dropout outTrain = switch(self._randStream.binomial( size=(self._numNeurons,), p=self._dropout), outTrain, 0) # activate the layer -- # output is a tuple to represent two possible paths through the # computation graph. self.output = (outClass, outTrain) if activation is None else \ (activation(outClass), activation(outTrain)) # create a convenience function self.activate = function([self.input[0]], self.output[0])
def test_npc_bad_distr(): prng = RandomState(55) pvalues = np.linspace(0.05, 0.9, num=5) distr = prng.uniform(low=0, high=10, size=20).reshape(10, 2) npc(pvalues, distr, "fisher", "greater")
def test_npc_bad_alternative(): prng = RandomState(55) pvalues = np.linspace(0.05, 0.9, num=5) distr = prng.uniform(low=0, high=10, size=50).reshape(10, 5) npc(pvalues, distr, "fisher", np.array(["greater", "less"]))
from numpy.random import RandomState import matplotlib.pyplot as plt random_generator = RandomState(seed=55) r = random_generator.uniform(0., 1., size=2000000)
def test_mono_checker_in_npc(): prng = RandomState(55) pvalues = np.linspace(0.05, 0.9, num=5) distr = prng.uniform(low=0, high=10, size=500).reshape(100, 5) bad_comb_function = lambda p: -1*fisher(p) npc(pvalues, distr, bad_comb_function)
def randomu(seed, di=None, binomial=None, double=False, gamma=False, normal=False, poisson=False): """ Replicates the randomu function avaiable within IDL (Interactive Data Language, EXELISvis). Returns an array of uniformly distributed random numbers of the specified dimensions. The randomu function returns one or more pseudo-random numbers with one or more of the following distributions: Uniform (default) Gaussian binomial gamma poisson :param seed: If seed is not of type mtrand.RandomState, then a new state is initialised. Othersise seed will be used to generate the random values. :param di: A list specifying the dimensions of the resulting array. If di is a scalar then randomu returns a scalar. Dimensions are D1, D2, D3...D8 (x,y,z,lambda...). The list will be inverted to suit Python's inverted dimensions i.e. (D3,D2,D1). :param binomial: Set this keyword to a list of length 2, [n,p], to generate random deviates from a binomial distribution. If an event occurs with probablility p, with n trials, then the number of times it occurs has a binomial distribution. :param double: If set to True, then randomu will return a double precision random numbers. :param gamma: Set this keyword to an integer order i > 0 to generate random deviates from a gamm distribution. :param Long: If set to True, then randomu will return integer uniform random deviates in the range [0...2^31-1], using the Mersenne Twister algorithm. All other keywords will be ignored. :param normal: If set to True, then random deviates will be generated from a normal distribution. :param poisson: Set this keyword to the mean number of events occurring during a unit of time. The poisson keword returns a random deviate drawn from a poisson distribution with that mean. :param ULong: If set to True, then randomu will return unsigned integer uniform deviates in the range [0..2^32-1], using the Mersenne Twister algorithm. All other keywords will be ignored. :return: A NumPy array of uniformly distributed random numbers of the specified dimensions. Example: >>> seed = None >>> x, sd = randomu(seed, [10,10]) >>> x, sd = randomu(seed, [100,100], binomial=[10,0.5]) >>> x, sd = randomu(seed, [100,100], gamma=2) >>> # 200x by 100y array of normally distributed values >>> x, sd = randomu(seed, [200,100], normal=True) >>> # 1000 deviates from a poisson distribution with a mean of 1.5 >>> x, sd = randomu(seed, [1000], poisson=1.5) >>> # Return a scalar from a uniform distribution >>> x, sd = randomu(seed) :author: Josh Sixsmith, [email protected], [email protected] :copyright: Copyright (c) 2014, Josh Sixsmith All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. The views and conclusions contained in the software and documentation are those of the authors and should not be interpreted as representing official policies, either expressed or implied, of the FreeBSD Project. """ # Initialise the data type if double: dtype = 'float64' else: dtype = 'float32' # Check the seed # http://stackoverflow.com/questions/5836335/consistenly-create-same-random-numpy-array if type(seed) != mtrand.RandomState: seed = RandomState() if di is not None: if type(di) is not list: raise TypeError("Dimensions must be a list or None.") if len(di) > 8: raise ValueError("Error. More than 8 dimensions specified.") # Invert the dimensions list dims = di[::-1] else: dims = 1 # Python has issues with overflow: # OverflowError: Python int too large to convert to C long # Occurs with Long and ULong #if Long: # res = seed.random_integers(0, 2**31-1, dims) # if di is None: # res = res[0] # return res, seed #if ULong: # res = seed.random_integers(0, 2**32-1, dims) # if di is None: # res = res[0] # return res, seed # Check for other keywords distributions = 0 kwds = [binomial, gamma, normal, poisson] for kwd in kwds: if kwd: distributions += 1 if distributions > 1: print("Conflicting keywords.") return if binomial: if len(binomial) != 2: msg = "Error. binomial must contain [n,p] trials & probability." raise ValueError(msg) n = binomial[0] p = binomial[1] res = seed.binomial(n, p, dims) elif gamma: res = seed.gamma(gamma, size=dims) elif normal: res = seed.normal(0, 1, dims) elif poisson: res = seed.poisson(poisson, dims) else: res = seed.uniform(size=dims) res = res.astype(dtype) if di is None: res = res[0] return res, seed