Esempio n. 1
0
 def __init__(self):
     super().__init__()
     self.mutations = util.Distribution()
     self.mutations.add(connect_mutation_weight,
                        ann_mutations.ConnectMutation(6.0))
     #self.mutations.add(1, ann_mutations.DisconnectMutation())
     self.mutations.add(split_mutation_weight,
                        ann_mutations.SplitMutation(6.0))
     self.mutations.add(perturb_mutation_weight,
                        ann_mutations.PerturbMutation(3.0))
     if pivot_mutation_weights is not None:
         self.pivot_mutations_distribution = util.Distribution()
         self.pivot_mutations_distribution.add(
             pivot_mutation_weights[0],
             ann_mutations.ConnectMutation(6.0))
         self.pivot_mutations_distribution.add(
             pivot_mutation_weights[1],
             ann_mutations.SplitMutation(6.0))
         self.pivot_mutations_distribution.add(
             pivot_mutation_weights[2],
             ann_mutations.PerturbMutation(3.0))
     if seed is not None:
         self.random.seed(seed)
     if out_file_name is not None:
         self.out = open(out_file_name, "w")
     if orgs_file_name is not None:
         self.orgs_file_name = orgs_file_name
     for k, v in kwargs.items():
         setattr(self, k, v)
Esempio n. 2
0
def pagerank(conditional_distribution, N_samples, jumps_between_samples):
    """
    Computes the steady-state distribution by simulating running the Markov
    chain. Collects samples at regular intervals and returns the empirical
    distribution of the samples.

    Inputs
    ------
    conditional_distribution : A dictionary in which each key is an state,
                               and each value is a Distribution over other
                               states.

    N_samples : the desired number of samples for the approximate empirical
                distribution
    jumps_between_samples : how many jumps to perform between each collected
                            sample

    Returns
    -------
    An empirical Distribution over the states that should approximate the
    steady-state distribution.
    """
    ### YOUR CODE HERE
    empirical_distribution = util.Distribution()
    return empirical_distribution
Esempio n. 3
0
def compute_distributions(actor_to_movies, movie_to_actors):
    """
    Computes conditional distributions for transitioning
    between actors (states).

    Inputs
    ------
    actor_to_movies : a dictionary in which each key is an actor name and each
                      value is a list of movies that actor starred in

    movie_to_actors : a dictionary in which each key is a movie and each
                      value is a list of actors in that movie

    Returns
    -------
    A dictionary in which each key is an actor, and each value is a
    Distribution over other actors. The probability of transitioning
    from actor i to actor j should be proportional to the number of
    movies they starred in together.
    """
    out = {}
    counts = []
    lengths = []
    for actor in actor_to_movies:
        conditional_distribution = util.Distribution()
        for movie in actor_to_movies[actor]:
            lengths.append(len(movie_to_actors[movie]))
            for co_star in movie_to_actors[movie]:
                conditional_distribution[co_star] += 1
        counts.extend(conditional_distribution.values())
        conditional_distribution.renormalize()
        out[actor] = conditional_distribution
    return out
Esempio n. 4
0
def approx_markov_chain_steady_state(conditional_distribution,
                                     N_samples,
                                     iterations_between_samples,
                                     debug=True):
    """
    Computes the steady-state distribution by simulating running the Markov
    chain. Collects samples at regular intervals and returns the empirical
    distribution of the samples.

    Inputs
    ------
    conditional_distribution : A dictionary in which each key is an state,
                               and each value is a Distribution over other
                               states.

    N_samples : the desired number of samples for the approximate empirical
                distribution

    iterations_between_samples : how many jumps to perform between each collected
                                 sample

    Returns
    -------
    An empirical Distribution over the states that should approximate the
    steady-state distribution.
    """
    t0 = time.time()

    empirical_distribution = util.Distribution()

    # Collect all valid states.
    states = list(conditional_distribution.keys())

    # Parallelize sampling. Here I make the assumption that each sample can be
    # generated independently from a uniformly sampled initial state.
    with Pool(processes=2 * cpu_count()) as pool:
        results = [
            pool.apply_async(generate_sample,
                             (states, conditional_distribution,
                              iterations_between_samples, i))
            for i in range(N_samples)
        ]
        samples = [r.get(timeout=0.5) for r in results]

    for s in samples:
        empirical_distribution[s] += 1.0

    # Normalize before returning.
    empirical_distribution.renormalize()

    if debug: print('Finished simulation in %f sec.' % (time.time() - t0))
    return empirical_distribution
Esempio n. 5
0
def pagerank(conditional_distribution, N_samples, jumps_between_samples):
    """
    Computes the steady-state distribution by simulating running the Markov
    chain. Collects samples at regular intervals and returns the empirical
    distribution of the samples.

    Inputs
    ------
    conditional_distribution : A dictionary in which each key is an state,
                               and each value is a Distribution over other
                               states.

    N_samples : the desired number of samples for the approximate empirical
                distribution
    jumps_between_samples : how many jumps to perform between each collected
                            sample

    Returns
    -------
    An empirical Distribution over the states that should approximate the
    steady-state distribution.
    """
    states = conditional_distribution.keys()
    state = random.choice(states)
    samples = []
    i = 0
    while True:
        i += 1
        if random.random() < .1:
            state = random.choice(states)
        else:
            state = conditional_distribution[state].sample()
        if (i % jumps_between_samples) == 0:
            samples.append(state)
            if len(samples) >= N_samples:
                break

    # Construct empirical distribution from samples
    empirical_distribution = util.Distribution()
    for s in samples:
        empirical_distribution[s] += 1
    empirical_distribution.renormalize()
    return empirical_distribution