Animation package in Matplotlib makes it very easy to animate plots. Here I will walk you through animating Logit fuction plot

Steps to make an animated chart is straight forward

• Prepare data, for example, list X and list Y
• Decide FPS(Frames Per Second) and Bitrate of animation and initialize an mp4 video writer using ffmpeg. This writer encodes the matplotlib figure to the video file at the set FPS rate.
• Write a function that takes the frame number as the input. Matplotlib animation calls this function. Within the function draw the plot up to what is necessary for the given frame number. For example if there are 100 data points along X axis, and the total frames chosen are 50, then for frame f, draw for X from 0 to f*2. If the FPS chose is 25 and total number of frame chose in 50, The animation would last for 2 seconds.
• Start and record animation by calling save function

Import libraries

[code lang=python]
import numpy as np
import pandas as pd
import seaborn as sns
import matplotlib
import matplotlib.pyplot as plt
import matplotlib.animation as animation
[/code]

Calculate X values and Y values. In Logit, probability P of dependant variable is calculated as P=\frac{1}{1+e^{-(a+bX)}}

Take a=0 and b=1.0
Range of X , -10.0 to +10.0 at 0.1 increments
Calculate Y( or P)

[code lang=python]
Xmin = -10
Xmax = 10
X=np.arange(Xmin, Xmax, 0.02)
a=0
b=1
Y= np.fromiter(( (1/(1+np.exp(-xi))) for xi in X), X.dtype)
[/code]

Initialize ffmpeg video writer with FPS and Bitrate

[code lang=python]
Writer = animation.writers['ffmpeg']
writer = Writer(fps=20, metadata=dict(artist='Me'), bitrate=1800)
[/code]

Initialize figure and plot

[code lang=python]
%matplotlib notebook
fig = plt.figure(figsize=(10,6))
plt.xlim(np.min(X), np.max(X))
plt.ylim(np.min(Y), np.max(Y))
plt.xlabel('X',fontsize=16)
plt.ylabel('Y',fontsize=16)
plt.title('Logit Func',fontsize=20)
[/code]

Define animate function

[code lang=python]
def animate(i):
p = sns.lineplot(x=X[:i*5], y=Y[:i*5], color="r")
p.tick_params(labelsize=16)
plt.setp(p.lines,linewidth=5)
[/code]

Launch animation and write video

[code lang=python]
ani = matplotlib.animation.FuncAnimation(fig, animate, frames=200, repeat=True)
ani.save('Logit-basic.mp4', writer=writer)
[/code]

Logistic regression is one of the first classification techniques that one comes across in machine learning. From its name, it even confuses the beginners as a regression technique though it is a classification technique. However the term 'regression' in its names does mean it is a regression technique. So is it Linear Regression behind the play? What is actually Logistic Regression? I came across few blogs on this topic as mentioned in the References. Here, I will share my notes and a simplified explanation to Logistic Regression.

Logistic regression is used for binary classification, however what works behind is a linear regression. Continuous range of linear regression is mapped to a near binary range of logistic regression, more precisely Logit function. Lets try to understand this

Odds ratio,

\frac{\frac{number of success}{total trials}}{\frac{number of failures}{total trials}}

Range of O:

​ = 0 when no occurrence of success

​ = \infty when all are success

Range of Success outcome:

​ = P = 0 to 1

Consider a linear regression

latex Y=a+b_iX_i -\infty \leq Y \leq +\infty  ~and -\infty \leq X \leq +\infty​

Here the outcome variable Y and feature variables Xs range from -\infty to +\infty. However in classification, outcome label Y cant't range from latex -\infty to +\infty. So we need transform the LHS to match the range in linear regression. Consider these options:

• P=a+b_iX_i 0 \leq P \leq 1 ~and -\infty \leq X \leq +\infty. Here P is the occurrence of outcome variable which is either 0 or 1 or similar in binary classification
• O= \frac{P}{1-P}=a+b_iX_i 0 \leq O \leq +\infty ~and -\infty \leq X \leq +\infty. Here outcome label O is Odds ratio P(yes)/P(no)
• ln(O)= ln(\frac{P}{1-P})=a+b_iX_i -\infty \leq O \leq +\infty ~and -\infty \leq X \leq +\infty. Here outcome label is natural log of O

In the third case above, range of LHS matches the range of linear regression's RHS. This LHS is the logit function, ln(O). So we can use linear regression on RHS to estimate ln(O) which is what logistic regression is doing. To get the classification outcome label P, rearrange equation for ln(O)

• ln(O)= ln(\frac{P}{1-P})=a+b_iX_i

• \frac{P}{1-P} = e^{(a+b_iX_i)}

• P=\frac{1}{1+e^{-(a+b_iX_i)}}

Plotting P vs. X with a=0, b=1

References

https://towardsdatascience.com/logit-of-logistic-regression-understanding-the-fundamentals-f384152a33d1

Player starts from a marked start position(denoted 2 in matrix) and traverses possible open doors(0s) and try to reach the treasure position(4). Player will have to retreat if the door is closed(1) in the path and seek another path through an open door(0).

Positions, start(2), treasure(4), open(0) doors and closed(1) doors are chosen at random in the NxN labyrinth matrix. Choose a value of N and ratio of open to closed doors to start the simulation

import numpy as np
from matplotlib import pyplot as plt
import matplotlib.animation as animation
from IPython.display import HTML

#Initial values for simulation

N=15 #size of the labyrinth (N x N matrix)
ratio= 0.7 #Ration of open doors vs closed doors

Build Labyrinth

P=2 #value denoting start position in matrix
D=4 #value denoting treasure position in matrix

#create labyrith matrix
#start with all open doors (value 0)
ar =np.zeros((1,N*N -2), dtype=int)
# add closed positions(value 1)
ar[0,int((N*N)  * ratio):] = 1
# Add start and treasure positions
ar=np.append(ar, [P,D])

#Shuffle all positions
np.random.shuffle(ar)

#Make as N x N matrix
ar = ar.reshape(N,N)
print(f"Labyrinth:\n\n {ar}")

Labyrinth:

 [[1 0 0 1 0 1 0 0 0 1 0 0 0 0 1]
 [1 1 0 0 1 1 1 0 0 0 1 0 0 0 0]
 [0 0 1 0 0 0 1 0 0 0 0 0 0 0 0]
 [0 0 0 0 1 1 1 1 1 0 0 0 0 1 0]
 [1 0 1 0 1 0 0 1 0 0 0 0 0 0 0]
 [0 0 1 0 0 0 0 0 0 0 1 1 0 1 0]
 [0 0 1 0 0 0 1 0 0 0 0 1 0 0 0]
 [1 2 1 1 0 1 0 0 0 0 0 1 0 1 0]
 [0 0 1 0 1 0 0 0 1 0 0 0 0 0 4]
 [0 0 0 1 0 0 0 0 0 1 0 0 0 0 1]
 [0 0 1 0 0 0 0 0 1 1 0 0 0 0 0]
 [0 0 1 0 0 0 1 0 1 0 0 0 1 0 0]
 [1 0 1 0 0 1 0 0 1 0 1 0 0 0 1]
 [1 0 0 0 1 0 0 0 0 1 0 0 0 1 0]
 [1 1 0 1 1 0 0 0 1 0 0 1 0 1 0]]

# Find the start position by looking up the position of P
Ppos=(0,0)
Dpos=(0,0)
for i in range(0, ar.shape[0]):
    for j in range(0, ar.shape[1]):
        if ar[i,j] ==P:
            Ppos=(i,j)
            break

print(f"Start position: {Ppos}")

Start position: (7, 1)

#Define function to traverse path

#Find possible next positions around current pos
#Checks boundaries. Looks around in clockwise direction
def find_pos_around(pos):
    r,c=pos[0],pos[1]
    apos=[]
    if c+1 < N:
        apos.append((r,c+1))
    if r+1 < N:
        apos.append((r+1,c))
    if c-1 > -1:
        apos.append((r,c-1))
    if r-1 > -1:
        apos.append((r-1,c))
    return apos

#Is the position already visited
def is_visited(pos):
    return pos in visit_index

#Is the position a closed door
def is_obstacle(pos):
    return ar[pos[0], pos[1]] ==1

def is_treasure(pos):
    return ar[pos[0], pos[1]] ==D

#update new position
def at_new_pos(pos):
    global counter
    visit_index[pos] =counter
    counter += 1
    hotpath.append(pos)

#capture traversed path
def log_trail(pos):
    trackX.append(pos[0])
    trackY.append(pos[1])
    hX=[]
    hY=[]
    for p in hotpath:
        hX.append(p[0])
        hY.append(p[1])
    hotTrack.append([hX,hY])

#retreat from a position
def pop_pos(pos):
    hotpath.pop()

#Move to next position
def moveto_next_pos(pos,opos):
    #print(f"Now:{pos}")
    log_trail(pos)
    at_new_pos(pos)
    found =False
    if is_treasure(pos):
        found =True
    else:
        around_pos = find_pos_around(pos)
        for npos in around_pos:
            if is_visited(npos) or is_obstacle(npos):
                continue
            else:
                found=moveto_next_pos(npos, pos)
                log_trail(pos) ##back from child
                if found:
                    break
    if not found:
        pop_pos(pos)
    return found

Traverse the labyrinth

#
counter =0
visit_index={} #tracks if a position previously visited
hotpath=[] #tracks the last traversed path
trackX=[] #x coordinates of traversed positions including retreated ones; for plotting
trackY=[] #y coordinates of traversed positions including retreated ones; for plotting
hotTrack=[] #coordinates of hotpath; for plotting

#Move to start position P from None and start traversing
found=moveto_next_pos(Ppos, None)
if found:
    print(f"Voila!\n\nFound Path:\n{hotpath}")
else:
    print(f"No Way!\n\n Last Path:\n{hotpath}")

Voila!

Found Path:
[(7, 1), (8, 1), (9, 1), (10, 1), (11, 1), (12, 1), (13, 1), (13, 2), (13, 3), (12, 3), (12, 4), (11, 4), (11, 5), (10, 5), (10, 6), (10, 7), (9, 7), (9, 6), (9, 5), (8, 5), (8, 6), (8, 7), (7, 7), (7, 8), (7, 9), (7, 10), (8, 10), (8, 11), (8, 12), (8, 13), (8, 14)]

Animate the paths

# X coordinates of labyrith
X= np.zeros((N*N,),dtype=int) 
# Y coordinates of labyrith
Y= np.zeros((N*N,),dtype=int) 
# Pos values in the labyrith, line open, closed, start and treasuree)
T= np.zeros((N*N,),dtype=int) 

#Build X, Y and T from labyrith matrix
pos=0
for i in range(0,ar.shape[0]):
    for j in range(0,ar.shape[1]):
        X[pos]=i
        Y[pos]=j
        T[pos]=ar[i,j]
        pos += 1

%%capture
#Plot the labyrinth as scatter
#Animate the traversed paths in yellow lines
#Animate the hot path in green line

#plt.rcParams['animation.ffmpeg_path'] = '/usr/bin/ffmpeg'

colormap = np.array([ 'g','r', 'b','c','m','c']) #color map of positions
sizemap = np.array([150,150,600,600,800]) #Size indicative of positions

def update_plot(frame):
    trailP.set_data(trackX[0:frame], trackY[0:frame])
    hotP.set_data(hotTrack[frame][0],hotTrack[frame][1])
    return trailP

fig = plt.figure(figsize=(10,10))
fig.suptitle("Treasure Hunt")
plt.scatter(X,Y, c=colormap[T], s=sizemap[T])

trailP =plt.plot([], [], color='y')[0]
hotP=plt.plot([], [], color='g', lw=3)[0]

anim=animation.FuncAnimation(fig, update_plot, 
                             frames=len(trackX), interval=500, repeat=False)

Writer = animation.writers['ffmpeg']
writer = Writer(fps=20, metadata=dict(artist='Me'), bitrate=1800)
anim.save("treasure_hunt.mp4", writer=writer)

HTML(anim.to_html5_video())

You can reach me at seegler@gmail.com

Welcome to WordPress. This is your first post. Edit or delete it, then start writing!