python - это - matplotlib inline




Построить динамически изменяющийся граф с помощью matplotlib в Jupyter Notebook (4)

У меня есть M x N 2D массив: i-я строка представляет это значение N точек в момент времени i.

Я хочу визуализировать точки [1 ряд массива] в виде графика, где значения обновляются через небольшой промежуток времени. Таким образом, график показывает 1 строку за раз, затем обновляет значения до следующей строки, и так далее, и так далее.

Я хочу сделать это в блокноте Jupyter. Ищем справочные коды.

Я пробовал следующие вещи, но безуспешно:


В дополнение к @ 0aslam0 я использовал here код. Я только что изменил функцию анимации, чтобы получить следующий ряд каждый раз. Он рисует анимированную эволюцию (M шагов) всех N точек.

from IPython.display import HTML
import numpy as np
from matplotlib import animation
N = 5
M = 100
points_evo_array = np.random.rand(M,N)

# First set up the figure, the axis, and the plot element we want to animate
fig = plt.figure()
ax = plt.axes(xlim=(0, M), ylim=(0, np.max(points_evo_array)))
lines = []

lines = [ax.plot([], [])[0] for _ in range(N)]

def init():    
    for line in lines:
        line.set_data([], [])
    return lines

def animate(i):
    for j,line in enumerate(lines):
        line.set_data(range(i), [points_evo_array[:i,j]])
    return lines

# call the animator.  blit=True means only re-draw the parts that have changed.
anim = animation.FuncAnimation(fig, animate,np.arange(1, M), init_func=init, interval=10, blit=True)

HTML(anim.to_html5_video())

Надеюсь, это будет полезно


Вот альтернативное, возможно более простое решение:

%matplotlib notebook
import numpy as np
import matplotlib.pyplot as plt

m = 100
n = 100
matrix = np.random.normal(0,1,m*n).reshape(m,n)

fig = plt.figure()
ax = fig.add_subplot(111)
plt.ion()

fig.show()
fig.canvas.draw()

for i in range(0,100):
    ax.clear()
    ax.plot(matrix[i,:])
    fig.canvas.draw()

Я не знаю много о matplotlib или jupyter. Однако графики меня интересуют. Я просто немного погуглил и наткнулся на этот post . Похоже, вы должны визуализировать график в виде HTML-видео, чтобы увидеть динамический график.

Я попробовал этот пост. This ноутбук, если вы хотите попробовать. Обратите внимание, что ядру (python 2) требуется время для сборки видео. Вы можете прочитать больше об этом here .

Теперь вы хотите отобразить график строки в строку. Я попробовал this . В этой записной книжке у меня есть dump_data с 10 строками. Я случайным образом беру один, строю их и показываю как видео.

Было интересно узнать о Юпитере. Надеюсь это поможет.


Я особенно искал хороший ответ для сценария, когда один поток перекачивает данные, и мы хотим, чтобы блокнот Jupyter продолжал обновлять график, ничего не блокируя. Посмотрев около десятка или около того связанных ответов, вот некоторые из выводов:

предосторожность

Не используйте ниже магию, если вы хотите живой график. Обновление графика не работает, если ноутбук использует ниже:

%load_ext autoreload
%autoreload 2

Перед тем, как импортировать matplotlib, вам нужно немного магии в своем блокноте

%matplotlib notebook

Способ 1: использование FuncAnimation

Недостатком является то, что обновление графика происходит, даже если ваши данные еще не были обновлены. В следующем примере показан другой поток, обновляющий данные, в то время как график обновления блокнота FuncAnimation через FuncAnimation .

%matplotlib notebook

from matplotlib import pyplot as plt
from matplotlib.animation import FuncAnimation
from random import randrange
from threading import Thread
import time

class LiveGraph:
    def __init__(self):
        self.x_data, self.y_data = [], []
        self.figure = plt.figure()
        self.line, = plt.plot(self.x_data, self.y_data)
        self.animation = FuncAnimation(self.figure, self.update, interval=1000)
        self.th = Thread(target=self.thread_f, daemon=True)
        self.th.start()

    def update(self, frame):
        self.line.set_data(self.x_data, self.y_data)
        self.figure.gca().relim()
        self.figure.gca().autoscale_view()
        return self.line,

    def show(self):
        plt.show()

    def thread_f(self):
        x = 0
        while True:
            self.x_data.append(x)
            x += 1
            self.y_data.append(randrange(0, 100))   
            time.sleep(1)  

g = LiveGraph()
g.show()

Способ 2: прямое обновление

Второй способ - обновить график, когда данные поступают из другого потока . Это рискованно, потому что matplotlib не является потокобезопасным, но, похоже, работает, пока только один поток выполняет обновления.

%matplotlib notebook

from matplotlib import pyplot as plt
from matplotlib.animation import FuncAnimation
from random import randrange
from threading import Thread
import time

class LiveGraph:
    def __init__(self):
        self.x_data, self.y_data = [], []
        self.figure = plt.figure()
        self.line, = plt.plot(self.x_data, self.y_data)

        self.th = Thread(target=self.thread_f, daemon=True)
        self.th.start()

    def update_graph(self):
        self.line.set_data(self.x_data, self.y_data)
        self.figure.gca().relim()
        self.figure.gca().autoscale_view()

    def show(self):
        plt.show()

    def thread_f(self):
        x = 0
        while True:
            self.x_data.append(x)
            x += 1
            self.y_data.append(randrange(0, 100))  

            self.update_graph()

            time.sleep(1)  


from live_graph import LiveGraph

g = LiveGraph()
g.show()




jupyter-notebook