def get_neighbors(self, value: int, rs: np.random.RandomState, number: Union[int, float] = np.inf, transform: bool = False) -> \ List[Union[float, int, str]]: neighbors = [] # type: List[Union[float, int, str]] if number < len(self.choices): while len(neighbors) < number: rejected = True index = int(value) while rejected: neighbor_idx = rs.randint(0, self._num_choices) if neighbor_idx != index: rejected = False if transform: candidate = self._transform(neighbor_idx) else: candidate = float(neighbor_idx) if candidate in neighbors: continue else: neighbors.append(candidate) else: for candidate_idx, candidate_value in enumerate(self.choices): if int(value) == candidate_idx: continue else: if transform: candidate = self._transform(candidate_idx) else: candidate = float(candidate_idx) neighbors.append(candidate) return neighbors
def get_neighbors(self, value: Any, rs: np.random.RandomState, number: int = 4, transform: bool = False) -> List[float]: neighbors = [] # type: List[float] while len(neighbors) < number: neighbor = rs.normal(value, 0.2) if neighbor < 0 or neighbor > 1: continue if transform: neighbors.append(self._transform(neighbor)) else: neighbors.append(neighbor) return neighbors
def mutate_weights(genome: Genome, rnd: np.random.RandomState, config: NeatConfig) -> Genome: """ Mutate the connection weights, using the given random generator and the config :param genome: the genome which weights should be mutated :param rnd: a random generator to determine, which weights and how much they will be changed :param config: a config that specifies the probability and magnitude of the changes :return: the mutated genome """ for connection in genome.connections: # Should mutate weights? if rnd.uniform(0, 1) <= config.probability_weight_mutation: # Assign random weight or perturb existing weight? if rnd.uniform(0, 1) <= config.probability_random_weight_mutation: connection.weight = rnd.uniform( low=config.connection_initial_min_weight, high=config.connection_initial_max_weight) else: # Check how the connection weight should be mutated mutation_type = config.weight_mutation_type if mutation_type == "uniform": connection.weight += rnd.uniform( -config.weight_mutation_uniform_max_change, config.weight_mutation_uniform_max_change) elif mutation_type == "normal": connection.weight += rnd.normal( loc=0, scale=config.weight_mutation_normal_sigma) else: raise AssertionError( "Unknown type of mutation type. Must be 'uniform' or 'normal'" ) connection.weight = np.clip(connection.weight, a_min=config.connection_min_weight, a_max=config.connection_max_weight) return genome
def set_new_genome_bias(genome: Genome, rnd: np.random.RandomState, config: NeatConfig) -> Genome: """ Set a new bias values in all nodes (except Input nodes) with the given random generator :param genome: the genome, where the bias value should be modified :param rnd: the random generator :param config: a neat config that specifies min and max values :return: the modified genome """ for node in genome.nodes: if node.node_type == NodeType.INPUT: continue node.bias = rnd.uniform(low=config.bias_initial_min, high=config.bias_initial_max) return genome
def _gen_soln(Z: np.ndarray, rng: np.random.RandomState): """ Generates feasible integer solutions using a probabilistic sampling heuristic """ Z_int = np.zeros(shape=Z.shape, dtype=np.int32) C, L = Z.shape # Go through each label, and sample proportional the "probability # distribution" defined by each row for i in range(C): group = rng.choice(a=np.arange(L), size=1, p=Z[i, :]) Z_int[i, group] = 1 return Z_int
def move_one_object_to_the_air( current_placement: np.ndarray, height_range: Tuple[float, float], random_state: np.random.RandomState, ) -> np.ndarray: """ Modify current_placement to move one object to the air. :param current_placement: np.ndarray of size (num_objects, 3) where columns are x, y, z coordinates of objects relative to the world frame. :param height_range: One object is moved along z direction to have height from table in a range (min_height, max_height). Height is randomly sampled. :param random_state: numpy RandomState to use for sampling :return: modified object placement. np.ndarray of (num_objects, 3) where columns are x, y, z coordinates of objects relative to the world frame. """ n_objects = current_placement.shape[0] min_h, max_h = height_range height = random_state.uniform(low=min_h, high=max_h) target_i = random_state.randint(n_objects) current_placement[target_i, -1] += height return current_placement
def _generate_mini_batches( self, id_list: List[str], batches: Dict[str, List[torch.Tensor]], shuffle: bool, state: np.random.RandomState, ): if shuffle: indices = np.arange(0, len(id_list)) state.shuffle(indices) batches = {k: [v[i] for i in indices] for k, v in batches.items()} id_list = [id_list[i] for i in indices] bs = self.batch_size while len(id_list) >= bs: # Make mini-batch and yield yield ( id_list[:bs], {k: torch.stack(v[:bs], 0) for k, v in batches.items()}, ) id_list = id_list[bs:] batches = {k: v[bs:] for k, v in batches.items()} return id_list, batches
def random_reward(n_states: int, n_actions: int, rng: np.random.RandomState = np.random) -> np.ndarray: """Generates a random reward matrix. Args: n_states: The number of states. n_actions: The number of actions. rng: Random number generator. Returns: A three-dimensional array R, where R[s,a,s'] is the reward starting at state s, taking action a, and transitioning to state s'. """ return rng.rand(n_states, n_actions, n_states)
def _measure(self, q, prng: np.random.RandomState) -> int: """Measures the q'th qubit. Reference: Section 4.1 "Simulating measurements" Returns: Computational basis measurement as 0 or 1. """ w = self.s.copy() for i, v_i in enumerate(self.v): if v_i == 1: w[i] = bool(prng.randint(2)) x_i = sum(w & self.G[q, :]) % 2 # Project the state to the above measurement outcome. self.project_Z(q, x_i) return x_i
def set_new_genome_weights(genome: Genome, rnd: np.random.RandomState, config: NeatConfig) -> Genome: """ Set new weights for the connections and the genome with the given random generator. :param genome: the genome, which weights should be randomized :param rnd: random generator to receive the new weights :param config: the neat config that specifies max and min weight :return: the modified genome """ for connection in genome.connections: connection.weight = rnd.uniform( low=config.connection_initial_min_weight, high=config.connection_initial_max_weight) return genome
def test_rmatvec( linop: pn.linops.LinearOperator, matrix: np.ndarray, random_state: np.random.RandomState, ): vec = random_state.normal(size=linop.shape[0]) linop_matvec = vec @ linop matrix_matvec = vec @ matrix assert linop_matvec.ndim == 1 assert linop_matvec.shape == matrix_matvec.shape assert linop_matvec.dtype == matrix_matvec.dtype np.testing.assert_allclose(linop_matvec, matrix_matvec)
def default_format_fn( sample: Dict[str, Any], input_prefix: str, output_prefix: str, choice_prefix: str, rng: np.random.RandomState, append_choices_to_input: bool = True, ) -> Dict[str, Any]: """Default format for tasks. Args: sample: Dictionary with an 'input' entry and a 'target' or 'target_scores entry (or both), describing a single example. input_prefix: input prefix, prepended to all inputs. output_prefix: output prefix, prepended to outputs and choices (if present). choice_prefix: prefix prepended to each choice in a multiple-choice question. rng: random number generator append_choices_to_input: append choices to input for multiple choice. Returns: sample: Formatted dictionary, with 'choice' key added if present in input. Raises: Exception: If output not in choices. """ def input_format(text): return input_prefix + text if "target_scores" in sample: choice_dic = sample["target_scores"] if append_choices_to_input: permuted_choices = rng.permutation(sorted(list(choice_dic.keys()))) sample["input"] = ( sample["input"] + choice_prefix + choice_prefix.join(permuted_choices) ) if "target" not in sample: max_score = max(choice_dic.values()) # type: ignore # Target corresponds to maximum score. # If multiple choices have same score it will chose the first one. sample["target"] = [k for k, v in choice_dic.items() if v == max_score][ 0 ] # type: ignore sample["choice"] = list(sample["target_scores"].keys()) sample["input"] = input_format(sample["input"]) + output_prefix if not isinstance(sample["target"], list): sample["target"] = [sample["target"]] return sample
def perform_measurement( self, qubits: Sequence[ops.Qid], prng: np.random.RandomState, collapse_state_vector=True ) -> List[int]: """Performs a measurement over one or more qubits. Args: qubits: The sequence of qids to measure, in that order. prng: A random number generator, used to simulate measurements. collapse_state_vector: A Boolean specifying whether we should mutate the state after the measurement. """ results: List[int] = [] if collapse_state_vector: state = self else: state = self.copy() for qubit in qubits: n = state.qubit_map[qubit] # Trace out other qubits M = state.partial_trace(keep_qubits={qubit}) probs = np.diag(M).real sum_probs = sum(probs) # Because the computation is approximate, the probabilities do not # necessarily add up to 1.0, and thus we re-normalize them. if abs(sum_probs - 1.0) > self.simulation_options.sum_prob_atol: raise ValueError(f'Sum of probabilities exceeds tolerance: {sum_probs}') norm_probs = [x / sum_probs for x in probs] d = qubit.dimension result: int = int(prng.choice(d, p=norm_probs)) collapser = np.zeros((d, d)) collapser[result][result] = 1.0 / math.sqrt(probs[result]) old_n = state.i_str(n) new_n = 'new_' + old_n collapser = qtn.Tensor(collapser, inds=(new_n, old_n)) state.M[n] = (collapser @ state.M[n]).reindex({new_n: old_n}) results.append(result) return results
def _select_parent( study: Study, parent_population: Sequence[FrozenTrial], rng: np.random.RandomState, dominates: Callable[[FrozenTrial, FrozenTrial, Sequence[StudyDirection]], bool], ) -> FrozenTrial: population_size = len(parent_population) candidate0 = parent_population[rng.choice(population_size)] candidate1 = parent_population[rng.choice(population_size)] # TODO(ohta): Consider crowding distance. if dominates(candidate0, candidate1, study.directions): return candidate0 else: return candidate1
def _uniform_random_bias( hidden_layer_size: int, random_state: np.random.RandomState) \ -> np.ndarray: """ Return uniform random bias in range [-1, 1]. Parameters ---------- hidden_layer_size : int random_state : numpy.random.RandomState Returns ------- uniform_random_bias : ndarray of shape (hidden_layer_size, ) """ return random_state.uniform(low=-1., high=1., size=hidden_layer_size)
def findposteriorfrequencies(x: int, tempdata: np.ndarray, maxMOI: int, frequencies_RR, rand: np.random.RandomState): nalleles = frequencies_RR.lengths[x] # hard coded table() function from R data = tempdata[:, x * maxMOI:(x + 1) * maxMOI].astype(int) data_1d_array = data.flatten() data_1d_array = data_1d_array[data_1d_array != 0] data_1d_array = data_1d_array[data_1d_array <= nalleles] data_unique, data_counts = np.unique(data_1d_array, return_counts=True) # Start as ones for the frequency prior counts_table = np.ones(nalleles) counts_table[data_unique - 1] += data_counts frequencies_RR.matrix[x, :nalleles] = rand.dirichlet(counts_table, 1)
def _replace_invalid_address_alleles(self, dna: List[int], rng: np.random.RandomState) -> None: """Replace invalid alleles for unused address genes of all nodes by random permissible values. WARNING: Works only if self.n_rows==1. """ assert self._n_rows == 1 for gene_idx, gene_value in enumerate(dna): region_idx = self._get_region_idx(gene_idx) if self._is_hidden_address_gene( gene_idx, region_idx) and gene_value > region_idx: permissible_values = self.determine_permissible_values_per_gene( gene_idx) gene_value = rng.choice(permissible_values) dna[gene_idx] = gene_value
def random_max(x:np.ndarray, rng:np.random.RandomState=None): """ Returns a randomly selected index from a 1D array where that index's value equals the array maximum Args: x (np.ndarray): 1D array rng (np.random.RandomState): RNG instance Returns: [type]: [description] """ if rng is None: rng = np.random return rng.choice(np.where(x == x.max())[0])
def crossover( self, parents_params: np.ndarray, rng: np.random.RandomState, study: Study, search_space_bounds: np.ndarray, ) -> np.ndarray: # https://www.researchgate.net/publication/201976488_Uniform_Crossover_in_Genetic_Algorithms # Section 1 Introduction n_params = len(search_space_bounds) masks = (rng.rand(n_params) >= self._swapping_prob).astype(int) child_params = parents_params[masks, range(n_params)] return child_params
def barabasi_albert(n_nodes: int, affinity: int, rng: np.random.RandomState): """Generate a Barabási-Albert random graph. This method is used to generate a Barabási-Albert graph based on the specified affinity. Parameters ---------- n_nodes: The number of nodes in the graph. affinity: The number of nodes each new node will be attached to, in the sampling scheme. This parameter must be an integer >= 1. rng: A random number generator. Returns ------- Graph: The generated graph. """ assert affinity >= 1 and affinity < n_nodes edges = set() degrees = np.zeros(n_nodes, dtype=int) neighbors = {node: set() for node in range(n_nodes)} for new_node in range(affinity, n_nodes): # first node is connected to all previous ones (star-shape) if new_node == affinity: neighborhood = np.arange(new_node) # remaining nodes are picked stochastically else: neighbor_prob = degrees[:new_node] / (2 * len(edges)) neighborhood = rng.choice(new_node, affinity, replace=False, p=neighbor_prob) for node in neighborhood: edges.add((node, new_node)) degrees[node] += 1 degrees[new_node] += 1 neighbors[node].add(new_node) neighbors[new_node].add(node) graph = Graph(n_nodes, edges, degrees, neighbors) return graph
def sample(self, rng: np.random.RandomState, size: int) -> Dict[str, np.ndarray]: multivariate_samples = {} active = rng.choice(len(self._weights), size, p=self._weights) for param_name, dist in self._search_space.items(): if isinstance(dist, distributions.CategoricalDistribution): categorical_weights = self._categorical_weights[param_name] assert categorical_weights is not None weights = categorical_weights[active, :] samples = _MultivariateParzenEstimator._sample_from_categorical_dist( rng, weights) else: # We restore parameters of parzen estimators. low = self._low[param_name] high = self._high[param_name] mus = self._mus[param_name] sigmas = self._sigmas[param_name] assert low is not None assert high is not None assert mus is not None assert sigmas is not None # We sample from truncnorm. trunc_low = (low - mus[active]) / sigmas[active] trunc_high = (high - mus[active]) / sigmas[active] samples = np.full((), fill_value=high + 1.0, dtype=np.float64) while (samples >= high).any(): samples = np.where( samples < high, samples, truncnorm.rvs( trunc_low, trunc_high, size=size, loc=mus[active], scale=sigmas[active], random_state=rng, ), ) multivariate_samples[param_name] = samples multivariate_samples = self._transform_from_uniform( multivariate_samples) return multivariate_samples
def random_month_img(dataset: Dict[str, torch.Tensor], writer: Union[int, None] = None, rand: np.random.RandomState = np.random.RandomState( seed=1234), leading_zero: bool = True, **kwargs) -> Tuple[torch.Tensor, int]: """Compose an image of a valid month.""" value = rand.choice(list(range(1, 13)), size=1, replace=False).item() if leading_zero: s = f'{value:02d}' # prepend a zero if the value is less than 10 else: s = str(value) return (value_to_img(s, dataset=dataset, writer=writer, rand=rand, **kwargs), value)
def random_state_only_reward( n_states: int, n_actions: int, rng: np.random.RandomState = np.random) -> np.ndarray: """Generates a random reward matrix, differing only in first axis. Args: n_states: The number of states. n_actions: The number of actions. rng: Random number generator. Returns: A three-dimensional array R, where R[s,a,s'] is the reward starting at state s, taking action a, and transitioning to state s'. """ rew = rng.rand(n_states, 1, 1) return np.tile(rew, (1, n_actions, n_states))
def shuffle_participants(self, data: np.ndarray, random_state: np.random.RandomState) -> np.ndarray: shuffled_data = np.ndarray(data.shape, data.dtype) shuffled_data[:, :] = data for tid in (0, 1): for cont_member_id, rand_member_id in enumerate(list(random_state.permutation(5))): if cont_member_id == rand_member_id: continue cont_pid = tid * 5 + cont_member_id rand_pid = tid * 5 + rand_member_id cont_key_part = "participants.{pid:d}.".format(pid=cont_pid) cont_ban_key_part = "teams.{tid:d}.bans.{mid:d}.".format(tid=tid, mid=cont_member_id) rand_key_part = "participants.{pid:d}.".format(pid=rand_pid) rand_ban_key_part = "teams.{tid:d}.bans.{mid:d}.".format(tid=tid, mid=rand_member_id) cont_cids = np.where([col.name.startswith(cont_key_part) or col.name.startswith(cont_ban_key_part) for col in self.specs])[0] rand_cids = np.where([col.name.startswith(rand_key_part) or col.name.startswith(rand_ban_key_part) for col in self.specs])[0] shuffled_data[:, cont_cids] = data[:, rand_cids] return shuffled_data
def _blxalpha(x1: np.ndarray, x2: np.ndarray, rng: np.random.RandomState, alpha: float) -> np.ndarray: # http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.465.6900&rep=rep1&type=pdf # Section 2 Crossover Operators for RCGA 2.1 Blend Crossover assert x1.shape == x2.shape assert x1.ndim == 1 xs = np.stack([x1, x2]) x_min = xs.min(axis=0) x_max = xs.max(axis=0) diff = alpha * (x_max - x_min) # Equation (1). low = x_min - diff # Equation (1). high = x_max + diff # Equation (1). r = rng.uniform(0, 1, size=len(diff)) child_params_array = (high - low) * r + low return child_params_array
def test_matmat( linop: pn.linops.LinearOperator, matrix: np.ndarray, random_state: np.random.RandomState, ncols: int, order: str, ): mat = np.asarray(random_state.normal(size=(linop.shape[1], ncols)), order=order) linop_matmat = linop @ mat matrix_matmat = matrix @ mat assert linop_matmat.ndim == 2 assert linop_matmat.shape == matrix_matmat.shape assert linop_matmat.dtype == matrix_matmat.dtype np.testing.assert_allclose(linop_matmat, matrix_matmat)
def generate_fake_risk(rs: np.random.RandomState, start_date: str, end_date: str, p0: float = 0.5) -> pd.DataFrame: """ Generate fake risk data that goes between 0 and 1 with a random walk :param rs: a Numpy random state :param start_date: start date string formatted 'YY-mm' :param end_date: end date string formatted 'YY-mm' :param p0: the probability of step size 0. The probability of step size -1 / 1 will then be (1-p0)/2 :return: dataframe with month and risk columns """ # Make dataframe with dates df_risk = pd.DataFrame({'date': pd.date_range(start=start_date, end=end_date, freq='M').to_period('M')}) # Create the steps steps = rs.choice(a=[-1, 0, 1], size=len(df_risk)-1, p=[(1 - p0) / 2, p0, (1 - p0) / 2]) # Compute the path values based on the steps path = np.concatenate([[0], steps]).cumsum(0) # Normalize between 0 and 1 df_risk['risk'] = (path - min(path)) / (max(path) - min(path)) return df_risk
def integrate( self, dimensions: int, market_ids: Iterable[str], state: np.random.RandomState) -> Tuple[Vector, Matrix, Vector]: """Build concatenated IDs, nodes, and weights for each market ID.""" ids_list: List[Vector] = [] nodes_list: List[Matrix] = [] weights_list: List[Vector] = [] for market_id in market_ids: nodes, weights = state.normal(size=(self._ns, dimensions)), np.repeat( 1 / self._ns, self._ns) ids_list.append(np.repeat(market_id, len(nodes))) nodes_list.append(nodes) weights_list.append(weights) return np.concatenate(ids_list), np.vstack(nodes_list), np.concatenate( weights_list)
def next_lane(self, current_index: LaneIndex, route: Route = None, position: np.ndarray = None, np_random: np.random.RandomState = np.random) -> LaneIndex: """ Get the index of the next lane that should be followed after finishing the current lane. - If a plan is available and matches with current lane, follow it. - Else, pick next road randomly. - If it has the same number of lanes as current road, stay in the same lane. - Else, pick next road's closest lane. :param current_index: the index of the current lane. :param route: the planned route, if any. :param position: the vehicle position. :param np_random: a source of randomness. :return: the index of the next lane to be followed when current lane is finished. """ _from, _to, _id = current_index next_to = next_id = None # Pick next road according to planned route if route: if route[0][:2] == current_index[:2]: # We just finished the first step of the route, drop it. route.pop(0) if route and route[0][0] == _to: # Next road in route is starting at the end of current road. _, next_to, next_id = route[0] elif route: logger.warning("Route {} does not start after current road {}.".format(route[0], current_index)) # Randomly pick next road if not next_to: try: next_to = list(self.graph[_to].keys())[np_random.randint(len(self.graph[_to]))] except KeyError: # logger.warning("End of lane reached.") return current_index # If next road has same number of lane, stay on the same lane if len(self.graph[_from][_to]) == len(self.graph[_to][next_to]): if next_id is None: next_id = _id # Else, pick closest lane else: lanes = range(len(self.graph[_to][next_to])) next_id = min(lanes, key=lambda l: self.get_lane((_to, next_to, l)).distance(position)) return _to, next_to, next_id
def sample_tailpoint_goal(self, environment: Dict, rng: np.random.RandomState, planner_params: Dict): # add more inflating to reduce the number of truly unacheivable gols env_inflated = inflate_tf_3d( env=environment['env'], radius_m=2 * planner_params['goal_params']['threshold'], res=environment['res']) goal_extent = planner_params['goal_params']['extent'] while True: extent = np.array(goal_extent).reshape(3, 2) p = rng.uniform(extent[:, 0], extent[:, 1]) goal = {'tail': p} row, col, channel = point_to_idx_3d_in_env(p[0], p[1], p[2], environment) collision = env_inflated[row, col, channel] > 0.5 if not collision: return goal
def slice_sampler_step_out(log_pivot: float, scale: float, sliced_log_density: Callable[[float], float], random_state: np.random.RandomState) -> Tuple[float, float]: r = random_state.rand() lower_bound = -r * scale upper_bound = lower_bound + scale def bound_step_out(bound, direction): """direction -1 for lower bound, +1 for upper bound""" for _ in range(MAX_STEP_OUT): if sliced_log_density(bound) <= log_pivot: return bound else: bound += direction * scale raise SliceException("Reach maximum iteration ({}) while stepping out for bound ({})".format(MAX_STEP_OUT, direction)) lower_bound = bound_step_out(lower_bound, -1.) upper_bound = bound_step_out(upper_bound, 1.) return lower_bound, upper_bound
def get_neighbors(self, value: Union[int, float], rs: np.random.RandomState, number: int = 4, transform: bool = False) -> \ List[Union[np.ndarray, float, int]]: neighbors = [] # type: List[Union[np.ndarray, float, int]] while len(neighbors) < number: rejected = True iteration = 0 while rejected: iteration += 1 new_value = rs.normal(value, self.sigma) int_value = self._transform(value) new_int_value = self._transform(new_value) if int_value != new_int_value: rejected = False elif iteration > 100000: raise ValueError('Probably caught in an infinite loop.') if transform: neighbors.append(self._transform(new_value)) else: neighbors.append(new_value) return neighbors
def get_neighbors(self, value: Union[int, float], rs: np.random.RandomState, number: int = 4, transform: bool = False) -> List[ int]: neighbors = [] # type: List[int] while len(neighbors) < number: rejected = True iteration = 0 while rejected: new_min_value = np.min([1, rs.normal(loc=value, scale=0.2)]) new_value = np.max((0, new_min_value)) int_value = self._transform(value) new_int_value = self._transform(new_value) if int_value != new_int_value: rejected = False elif iteration > 100000: raise ValueError('Probably caught in an infinite loop.') if transform: neighbors.append(self._transform(new_value)) else: new_value = self._transform(new_value) new_value = self._inverse_transform(new_value) neighbors.append(new_value) return neighbors
def _sample(self, rs: np.random.RandomState, size: Union[int, None] = None) -> int: """ returns a random sample from our sequence as order/position index """ return rs.randint(0, self._num_elements, size=size)
def _sample(self, rs: np.random.RandomState, size: Union[None, int] = None) -> np.ndarray: mu = self.mu sigma = self.sigma return rs.normal(mu, sigma, size=size)
def _sample(self, rs: np.random.RandomState, size: int = None) -> Union[int, np.ndarray]: return rs.randint(0, self._num_choices, size=size)
def get_neighbors(self, value: float, rs: np.random.RandomState, number: int = 4, transform: bool = False) -> List[float]: neighbors = [] for i in range(number): neighbors.append(rs.normal(value, self.sigma)) return neighbors