Random walks in Python
Random Walks in Python using Matplotlib
In this blog,
we’ll use Python to generate data for a random walk, and then use Matplotlib to
create a visual representation of that data. A random walk is a path that has no
clear direction but is determined by a series of random decisions, each of
which is left entirely to chance. Take for example the path a confused ant
would take if it took every step in a random direction. Random walk models are
used in many real-world situations. Here is a real-world application of random walks.
Importing the modules
For this, we
require two modules; Matplotlib and Random
import matplotlib.pyplot as plt
from random import choice
To make random decisions, we’ll store possible moves
in a list and use the choice() function, from the random module, to decide
which move to make each time a step is taken. Hence the random module.
The
RandomWalk() Function
def RandomWalk(num_points):
x_values = [0]
y_values = [0]
When calling the function, we will require to pass in
the number of points that the random walk will make. Then,
we make two lists to hold the x- and y-values, and we start each walk at the
point (0, 0).
def RandomWalk(num_points):
x_values = [0]
y_values = [0]
"""Keep taking steps until the walk reaches
the desired length."""
while len(x_values) < num_points:
"""Decide which direction to go and how far
to go in that direction."""
x_direction = choice([1, -1])
x_distance = choice([0, 1, 2, 3, 4])
x_step = x_direction * x_distance
y_direction = choice([1, -1])
y_distance = choice([0,1,2,3,4])
y_step = y_direction * y_distance
"""Reject a move that goes no-where"""
if x_step == 0 and y_step == 0:
continue
x = x_values[-1] + x_step
y = y_values[-1] + y_step
x_values.append(x)
y_values.append(y)
Next, we
set up a loop that runs until the walk is filled with the correct number of
points. The main part of the loop tells Python how to simulate four random
decisions: will the walk go right or left? How far will it go in that
direction? Will it go up or down? How far will it go in that direction? We use
choice([1, -1]) to choose a value for x_direction, which returns either 1 for
right movement or −1 for left. Next, choice([0, 1, 2, 3, 4]) tells Python how
far to move in that direction (x_distance) by randomly selecting an integer
between 0 and 4. (The inclusion of a 0 allows us to take steps along the y-axis
as well as steps that have moved along both axes.). We need to determine the
length of each step in the x and y directions by multiplying the direction of
movement by the distance chosen. A positive result for x_step means move right,
a negative result means move left, and 0 means move vertically. A positive
result for y_step means move up, negative means move down, and 0 means move
horizontally. If the value of both x_step and y_step is 0, the walk doesn’t go
anywhere, so we continue the loop to ignore this move. To get the next x-value for the walk, we add the value in x_step to the
last value stored in x_values and do the same for the y-values. When we
have these values, we append them to x_values and y_values.
x_values.append(x)
y_values.append(y)
"""plot the points in the walk"""
plt.style.use("classic")
fig, ax = plt.subplots(figsize=(15,9))
point_numbers = range(num_points)
ax.scatter(x_values, y_values, c=point_numbers,
cmap=plt.cm.Blues, edgecolors ='none', s=15)
"""Emphasize the first and last points"""
ax.scatter(0,0, c='green', edgecolors='none', s=100)
ax.scatter(x_values[-1], y_values[-1], c='red',
edgecolors='none', s=100)
ax.get_xaxis().set_visible(False)
ax.get_yaxis().set_visible(False)
plt.show()
We proceed to create a scatter plot using Matplotlib.
First, is to specify the style that we will use. The variable fig represents the entire figure or
collection of plots that are generated. The variable ax represents a single
plot in the figure and is the variable used most of the time. In the ax.scatter
function we pass the x and y values to be plotted. We also pass the color maps.
Pyplot
module includes a set of built-in color maps. To use one of these cmaps, you
need to specify how Pyplot should assign a color to each point in the data set.
Here is how to assign each point a color based on its y-value.
ax.scatter(x_values, y_values, c=point_numbers,
cmap=plt.cm.Blues, edgecolors='none', s=15)
Pass a list of y-values to c, and then tell pyplot which
color map to use using the color map argument. This code colors the points with
lower y-values light blue and colors the points with higher y-values dark blue.
We also emphasize the starting points and ending points of our plot. Using green for beginning and red for the end of the walk.
RandomWalk(5000)
Finally, we call the function with the number of points
we desire to be scattered on our random walk.
Labels: Artificial Intelligence, Big Data, Coding, Companies, Data analysts, data mining, Data Science, Developers, Game development, Ideas, Machine learning, Mathematics, Programming, Python, Random walks, Technology, Web
posted by Stephen @ September 30, 2021
0 Comments
