2

1. Background

I draw a quadratic function curve (ax^2+bx+c, a>0) which has a minimum value, and I use an iterable method to search this value. After every step, there generates a point. What I want to do is draw this point dynamically.

2. Pseudocode

f(x)=ax^2+bx+c, a>0
g(t) is the mentioned method which is used to search the minimum value

plot f(x)
plot initial point (x0,y0)

for t in range(10000):
  new_x,new_y = g(t)

  move (x0,y0) to new position (new_x,new_y)

3. Solution

3.1 interactive plot

3.1.1 Example
import matplotlib
import matplotlib.pyplot as plt
import numpy as np

matplotlib.use("TkAgg")

plt.figure()
plt.grid(True)
plt.ion()

ft = np.linspace(0, 100, 1000)
plt.plot(ft, ft ** 2 + 1, c='r')
for t in range(100):
    plt.scatter(t, t ** 2 + 1, marker='.', c='b')

    plt.pause(1e-6)

plt.ioff()
plt.show()
3.1.2 Note
  1. It works, but it runs slowly.
  2. This method generates a track, which is redundant.

3.2 Animation

3.2.1 Example

import numpy as np
import matplotlib
import matplotlib.pyplot as plt
import matplotlib.animation as animation

matplotlib.use("TkAgg")
def update_points(num):

    point_ani.set_data(x[num], y[num])
    return point_ani,


x = np.linspace(0, 100, 1000)
y = x**2+1

fig = plt.figure(tight_layout=True)
plt.plot(x, y)
point_ani, = plt.plot(x[0], y[0], "ro")
plt.grid(ls="--")
ani = animation.FuncAnimation(fig,
                              update_points,
                              interval=1,
                              blit=True)
plt.show()

print('finish')

3.2.2 Note

This method works without any track, but the entire moving path of point has to be known before drawing.

So, suppose there is an artist, it draws every time it receives a new point; it waits if no point is received. How to implement?

1 Answer 1

1

Using the Gradient descent method described in this Wikipedia link, here is the Python implementation, and the animation indicating the new "minima" at each step.

import numpy as np
import matplotlib.pyplot as plt
###initializing the parameters##################
next_x = -5  # We start the search at x=-5
gamma = 0.01  # Step size multiplier
precision = 0.000001  # Desired precision of result
max_iters = 10000  # Maximum number of iterations
########setup the plot################
fig, ax = plt.subplots()
ax.set_ylabel('y')
ax.set_xlabel('x')
ft = np.linspace(-50, 50, 1000)
line, = ax.plot(ft, ft**2 + 1,c='r',linestyle='-')
ax.set_title('Gradient descent showing the minima at each step')
plt.ion()   # set interactive mode
plt.show()
#################################
a=1
b=0
c=1
# Derivative function
def df(a,b,c,x):
    return 2*a*x + b
# function
def f(a,b,c,x):
    return a*x**2+b*x+c
for _ in range(max_iters):
    current_x = next_x
    next_x = next_x - gamma * df(a,b,c,current_x)
    step = next_x - current_x
    #do the plotting after setting up canvas
    plt.gcf().canvas.draw()
    #show the new minima as a '.'
    line, = ax.plot(next_x,f(a,b,c,next_x),'.',c='black')
    plt.pause(0.1)
    #remove the track
    line.remove()
    del line
    if abs(step) <= precision:
        break
print ("Minima at :{}".format(next_x))

animated

Sign up to request clarification or add additional context in comments.

3 Comments

yeah, it works. However, is it possible to remove point's track? i just want to see a single moving point, which is much clearer.
Happy to help. If you feel that the solution help resolved your problem you want to check the green mark, this will keep the focus on unresolved questions. See the edited version of the code that will remove the point tracks.
just for the sake of discussion, have you ever tried to use multithread? while an artist is drawing, a worker is generating some points feeding to him. I think the command plt.pause which updates the figure makes drawing point slowly.

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.