diff --git a/notebooks/walker/Step_1_classes/Step_1_classes_exercise.ipynb b/notebooks/walker/Step_1_classes/Step_1_classes_exercise.ipynb index e802412..abcfc78 100644 --- a/notebooks/walker/Step_1_classes/Step_1_classes_exercise.ipynb +++ b/notebooks/walker/Step_1_classes/Step_1_classes_exercise.ipynb @@ -174,7 +174,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.11" + "version": "3.11.3" }, "nteract": { "version": "0.28.0" diff --git a/notebooks/walker/Step_1_classes/walker.py b/notebooks/walker/Step_1_classes/walker.py index 07433f8..dcf3fec 100644 --- a/notebooks/walker/Step_1_classes/walker.py +++ b/notebooks/walker/Step_1_classes/walker.py @@ -1,81 +1,88 @@ import numpy as np import matplotlib.pyplot as plt +class Walker: -def sample_next_step(current_i, current_j, sigma_i, sigma_j, context_map, - random_state=np.random): - """ Sample a new position for the walker. """ + def __init__(self,current_i, current_j, sigma_i, sigma_j, size, context_map): + self.current_i = current_i + self.current_j = current_j + self.sigma_i = sigma_i + self.sigma_j = sigma_j + self.size = size + self.context_map = context_map - # Combine the next-step proposal with the context map to get a next-step - # probability map - size = context_map.shape[0] - next_step_map = next_step_proposal(current_i, current_j, sigma_i, sigma_j, - size) - next_step_probability = compute_next_step_probability(next_step_map, - context_map) + # Methods + def sample_next_step(self, random_state=np.random): + """ Sample a new position for the walker. """ - # Draw a new position from the next-step probability map - r = random_state.rand() - cumulative_map = np.cumsum(next_step_probability) - cumulative_map = cumulative_map.reshape(next_step_probability.shape) - i_next, j_next = np.argwhere(cumulative_map >= r)[0] + # Combine the next-step proposal with the context map to get a next-step + # probability map + self.size = self.context_map.shape[0] + self.next_step_map = self.next_step_proposal() + self.next_step_probability = self.compute_next_step_probability() - return i_next, j_next + # Draw a new position from the next-step probability map + r = random_state.rand() + cumulative_map = np.cumsum(self.next_step_probability) + cumulative_map = cumulative_map.reshape(self.next_step_probability.shape) + self.i_next, self.j_next = np.argwhere(cumulative_map >= r)[0] + return self.i_next, self.j_next -def next_step_proposal(current_i, current_j, sigma_i, sigma_j, size): - """ Create the 2D proposal map for the next step of the walker. """ - # 2D Gaussian distribution , centered at current position, - # and with different standard deviations for i and j - grid_ii, grid_jj = np.mgrid[0:size, 0:size] - rad = ( - (((grid_ii - current_i) ** 2) / (sigma_i ** 2)) - + (((grid_jj - current_j) ** 2) / (sigma_j ** 2)) - ) - p_next_step = np.exp(-(rad / 2.0)) / (2.0 * np.pi * sigma_i * sigma_j) - return p_next_step / p_next_step.sum() + def next_step_proposal(self): + """ Create the 2D proposal map for the next step of the walker. """ + # 2D Gaussian distribution , centered at current position, + # and with different standard deviations for i and j + grid_ii, grid_jj = np.mgrid[0:self.size, 0:self.size] + rad = ( + (((grid_ii - self.current_i) ** 2) / (self.sigma_i ** 2)) + + (((grid_jj - self.current_j) ** 2) / (self.sigma_j ** 2)) + ) + p_next_step = np.exp(-(rad / 2.0)) / (2.0 * np.pi * self.sigma_i * self.sigma_j) + return p_next_step / p_next_step.sum() -def compute_next_step_probability(next_step_map, context_map): - """ Compute the next step probability map from next step proposal and - context map. """ - next_step_probability = next_step_map * context_map - next_step_probability /= next_step_probability.sum() - return next_step_probability + def compute_next_step_probability(self): + """ Compute the next step probability map from next step proposal and + context map. """ + self.next_step_probability = self.next_step_map * self.context_map + self.next_step_probability /= self.next_step_probability.sum() + return self.next_step_probability -def create_context_map(size, map_type='flat'): - """ Create a fixed context map. """ - if map_type == 'flat': - context_map = np.ones((size, size)) - elif map_type == 'hills': - grid_ii, grid_jj = np.mgrid[0:size, 0:size] - i_waves = np.sin(grid_ii / 130) + np.sin(grid_ii / 10) - i_waves /= i_waves.max() - j_waves = np.sin(grid_jj / 100) + np.sin(grid_jj / 50) + \ - np.sin(grid_jj / 10) - j_waves /= j_waves.max() - context_map = j_waves + i_waves - elif map_type == 'labyrinth': - context_map = np.ones((size, size)) - context_map[50:100, 50:60] = 0 - context_map[20:89, 80:90] = 0 - context_map[90:120, 0:10] = 0 - context_map[120:size, 30:40] = 0 - context_map[180:190, 50:60] = 0 - context_map[50:60, 50:200] = 0 - context_map[179:189, 80:130] = 0 - context_map[110:120, 0:190] = 0 - context_map[120:size, 30:40] = 0 - context_map[180:190, 50:60] = 0 - context_map /= context_map.sum() - return context_map + def create_context_map(self, map_type='flat'): + """ Create a fixed context map. """ + if map_type == 'flat': + self.context_map = np.ones((self.size, self.size)) + elif map_type == 'hills': + grid_ii, grid_jj = np.mgrid[0:self.size, 0:self.size] + i_waves = np.sin(grid_ii / 130) + np.sin(grid_ii / 10) + i_waves /= i_waves.max() + j_waves = np.sin(grid_jj / 100) + np.sin(grid_jj / 50) + \ + np.sin(grid_jj / 10) + j_waves /= j_waves.max() + self.context_map = j_waves + i_waves + elif map_type == 'labyrinth': + self.context_map = np.ones((self.size, self.size)) + self.context_map[50:100, 50:60] = 0 + self.context_map[20:89, 80:90] = 0 + self.context_map[90:120, 0:10] = 0 + self.context_map[120:self.size, 30:40] = 0 + self.context_map[180:190, 50:60] = 0 + self.context_map[50:60, 50:200] = 0 + self.context_map[179:189, 80:130] = 0 + self.context_map[110:120, 0:190] = 0 + self.context_map[120:self.size, 30:40] = 0 + self.context_map[180:190, 50:60] = 0 + self.context_map /= self.context_map.sum() + return self.context_map -def plot_trajectory(trajectory, context_map): - """ Plot a trajectory over a context map. """ - trajectory = np.asarray(trajectory) - plt.matshow(context_map) - plt.plot(trajectory[:, 1], trajectory[:, 0], color='r') - plt.show() + + def plot_trajectory(self, trajectory): + """ Plot a trajectory over a context map. """ + trajectory = np.asarray(trajectory) + plt.matshow(self.context_map) + plt.plot(trajectory[:, 1], trajectory[:, 0], color='r') + plt.show()