Інтерактивний великий графік із ~ 20 мільйонами точок вибірки та гігабайтами даних

У мене тут проблема (з моєю оперативною пам’яттю): вона не може зберігати дані, які я хочу побудувати. У мене достатньо місця в HD. Чи є якесь рішення, щоб уникнути "тінізації" мого набору даних?

Конкретно я маю справу з цифровою обробкою сигналів, і мені доводиться використовувати високу частоту дискретизації. Мій фреймворк (GNU Radio) зберігає значення (щоб уникнути використання занадто багато місця на диску) у двійковій формі. Я розпаковую його. Згодом мені потрібно скласти змову. Мені потрібен сюжет, масштабований та інтерактивний. І це питання.

Чи існує якийсь потенціал для оптимізації цього чи іншого програмного забезпечення / мови програмування (наприклад, R або близько того), який може обробляти більші набори даних? Насправді я хочу набагато більше даних у своїх сюжетах. Але я не маю досвіду роботи з іншим програмним забезпеченням. GNUplot не працює, з аналогічним підходом до наступного. Я не знаю R (реактивний).

import matplotlib.pyplot as plt
import matplotlib.cbook as cbook
import struct

"""
plots a cfile

cfile - IEEE single-precision (4-byte) floats, IQ pairs, binary
txt - index,in-phase,quadrature in plaintext

note: directly plotting with numpy results into shadowed functions
"""

# unpacking the cfile dataset
def unpack_set(input_filename, output_filename):
    index = 0   # index of the samples
    output_filename = open(output_filename, 'wb')

    with open(input_filename, "rb") as f:

        byte = f.read(4)    # read 1. column of the vector

        while byte != "":
        # stored Bit Values
            floati = struct.unpack('f', byte)   # write value of 1. column to a variable
            byte = f.read(4)            # read 2. column of the vector
            floatq = struct.unpack('f', byte)   # write value of 2. column to a variable
            byte = f.read(4)            # next row of the vector and read 1. column
            # delimeter format for matplotlib 
            lines = ["%d," % index, format(floati), ",",  format(floatq), "\n"]
            output_filename.writelines(lines)
            index = index + 1
    output_filename.close
    return output_filename.name

# reformats output (precision configuration here)
def format(value):
    return "%.8f" % value            

# start
def main():

    # specify path
    unpacked_file = unpack_set("test01.cfile", "test01.txt")
    # pass file reference to matplotlib
    fname = str(unpacked_file)
    plt.plotfile(fname, cols=(0,1)) # index vs. in-phase

    # optional
    # plt.axes([0, 0.5, 0, 100000]) # for 100k samples
    plt.grid(True)
    plt.title("Signal-Diagram")
    plt.xlabel("Sample")
    plt.ylabel("In-Phase")

    plt.show();

if __name__ == "__main__":
    main()

Щось на зразок plt.swap_on_disk () може кешувати речі на моєму SSD;)

Отже, ваші дані не такі великі, і той факт, що у вас виникають проблеми з їх складанням, вказує на проблеми з інструментами. Matplotlib має безліч варіантів, і вихід є нормальним, але це величезна свиня пам’яті, і вона принципово припускає, що ваших даних мало. Але є й інші варіанти.

Отже, як приклад, я створив 20-мегапіксельний файл даних „bigdata.bin“, використовуючи наступне:

#!/usr/bin/env python
import numpy
import scipy.io.numpyio

npts=20000000
filename='bigdata.bin'

def main():
    data = (numpy.random.uniform(0,1,(npts,3))).astype(numpy.float32)
    data[:,2] = 0.1*data[:,2]+numpy.exp(-((data[:,1]-0.5)**2.)/(0.25**2))
    fd = open(filename,'wb')
    scipy.io.numpyio.fwrite(fd,data.size,data)
    fd.close()

if __name__ == "__main__":
    main()

Це генерує файл розміром ~ 229 Мб, що не так вже й велике; але ви висловили думку, що хочете перейти до ще більших файлів, тож врешті-решт ви досягнете обмежень пам’яті.

Спершу зосередимось на неінтерактивних сюжетах. Перше, що слід усвідомити, це те, що векторні графіки з гліфами в кожній точці будуть катастрофою - для кожної з 20 M точок, більшість з яких в будь-якому випадку будуть збігатися, намагаючись зробити маленькі хрестики чи кружечки або щось інше бути діастереєм, створюючи величезні файли і забираючи тонни часу. Я думаю, це те, що за замовчуванням тоне matplotlib.

Gnuplot не має проблем із цим:

gnuplot> set term png
gnuplot> set output 'foo.png'
gnuplot> plot 'bigdata.bin' binary format="%3float32" using 2:3 with dots

І навіть Matplotlib можна змусити поводитися з певною обережністю (вибираючи растровий задній кінець та використовуючи пікселі для позначення точок):

#!/usr/bin/env python
import numpy
import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt

datatype=[('index',numpy.float32), ('floati',numpy.float32), 
        ('floatq',numpy.float32)]
filename='bigdata.bin'

def main():
    data = numpy.memmap(filename, datatype, 'r') 
    plt.plot(data['floati'],data['floatq'],'r,')
    plt.grid(True)
    plt.title("Signal-Diagram")
    plt.xlabel("Sample")
    plt.ylabel("In-Phase")
    plt.savefig('foo2.png')

if __name__ == "__main__":
    main()  

Тепер, якщо ви хочете інтерактив, вам доведеться збирати дані для побудови графіку та наближати на льоту. Я не знаю жодного інструменту python, який би допоміг вам це зробити.

З іншого боку, побудова великих даних - це досить поширене завдання, і є інструменти, які підходять для цієї роботи. Paraview - мій особистий фаворит, а VisIt - ще один. Вони в основному призначені для 3D-даних, але Paraview, зокрема, робить також 2d і дуже інтерактивний (і навіть має інтерфейс сценаріїв Python). Єдиною хитрістю буде запис даних у формат файлу, який Paraview може легко прочитати.

Опитування програмного забезпечення для інтерактивного побудови графіків з відкритим кодом з еталоном розсіювання 10 мільйонів точок на Ubuntu

Натхненний випадком використання, описаним за адресою: /stats/376361/how-to-find-the-sample-points-that-have-statistically-meaningful-large-outlier-r, який я порівняв кілька реалізацій з наступними дуже простими та наївними даними прямої лінії 10 мільйонів точок:

i=0;
while [ "$i" -lt 10000000 ]; do
  echo "$i,$((2 * i)),$((4 * i))"; i=$((i + 1));
done > 10m.csv

Перші кілька рядків 10m.csvвиглядають так:

0,0,0
1,2,4
2,4,8
3,6,12
4,8,16

В основному, я хотів:

• зробити XY графік розсіювання багатовимірних даних, сподіваємось, Z буде кольором точки
• інтерактивно виберіть кілька цікавих точок зору
• переглянути всі розміри вибраних точок (включаючи принаймні X, Y та Z), щоб спробувати зрозуміти, чому вони є відхиленнями в XY-розсіювачі

Щоб отримати додаткове задоволення, я також підготував ще більший набір даних на 1 мільярд точок на випадок, якщо якась із програм зможе обробити 10 мільйонів балів! Файли CSV ставали трохи хиткими, тому я перейшов до HDF5:

import h5py
import numpy

size = 1000000000

with h5py.File('1b.hdf5', 'w') as f:
    x = numpy.arange(size + 1)
    x[size] =  size / 2
    f.create_dataset('x', data=x, dtype='int64')
    y = numpy.arange(size + 1) * 2
    y[size] =  3 * size / 2
    f.create_dataset('y', data=y, dtype='int64')
    z = numpy.arange(size + 1) * 4
    z[size] = -1
    f.create_dataset('z', data=z, dtype='int64')

Це створює файл розміром ~ 23 ГБ, що містить:

• 1 мільярд точок по прямій дуже схоже 10m.csv
• одна крапка в центрі верхньої частини графіка

Тести проводились в Ubuntu 18.10, якщо в підрозділі не зазначено інше, в ноутбуці ThinkPad P51 з процесором Intel Core i7-7820HQ (4 ядра / 8 потоків), 2 оперативній пам'яті Samsung M471A2K43BB1-CRC (2x 16 ГБ), NVIDIA Quadro M1200 Графічний процесор 4 ГБ GDDR5.

Підсумок результатів

Це те, що я спостерігав, беручи до уваги мій конкретний тестовий випадок використання та те, що я вперше користуюсь багатьма з переглянутого програмного забезпечення:

Чи обробляє він 10 мільйонів балів:

Vaex        Yes, tested up to 1 Billion!
VisIt       Yes, but not 100m
Paraview    Barely
Mayavi      Yes
gnuplot     Barely on non-interactive mode.
matplotlib  No
Bokeh       No, up to 1m
PyViz       ?
seaborn     ?

Чи має він багато можливостей:

Vaex        Yes.
VisIt       Yes, 2D and 3D, focus on interactive.
Paraview    Same as above, a bit less 2D features maybe.
Mayavi      3D only, good interactive and scripting support, but more limited features.
gnuplot     Lots of features, but limited in interactive mode.
matplotlib  Same as above.
Bokeh       Yes, easy to script.
PyViz       ?
seaborn     ?

Чи добре почувається графічний інтерфейс (не враховуючи хорошу продуктивність):

Vaex        Yes, Jupyter widget
VisIt       No
Paraview    Very
Mayavi      OK
gnuplot     OK
matplotlib  OK
Bokeh       Very, Jupyter widget
PyViz       ?
seaborn     ?

Vaex 2.0.2

https://github.com/vaexio/vaex

Встановіть і отримайте привітний світ, що працює, як показано на: Як зробити інтерактивний вибір масштабу / точки двовимірного розсіювання в Vaex?

Я протестував vaex з до 1 мільярда балів, і він працював, це чудово!

Це "Python-scripted-first", який чудово підходить для відтворюваності і дозволяє мені легко взаємодіяти з іншими речами Python.

Налаштування Jupyter містить кілька рухомих частин, але коли я запустив його за допомогою virtualenv, це було приголомшливо.

Щоб завантажити наш запуск CSV у Jupyter:

import vaex
df = vaex.from_csv('10m.csv', names=['x', 'y', 'z'],)
df.plot_widget(df.x, df.y, backend='bqplot')

і ми можемо миттєво побачити:

Тепер ми можемо масштабувати, панорамувати та вибирати точки за допомогою миші, і оновлення відбувається дуже швидко, все менше ніж за 10 секунд. Тут я збільшив зображення, щоб побачити деякі окремі точки, і вибрав декілька з них (слабкіший світлий прямокутник на зображенні):

Після вибору за допомогою миші це має точно такий же ефект, як використання df.select()методу. Отже, ми можемо витягнути вибрані точки, запустивши в Jupyter:

df.to_pandas_df(selection=True)

який виводить дані у форматі:

        x       y        z   index
0 4525460 9050920 18101840 4525460
1 4525461 9050922 18101844 4525461
2 4525462 9050924 18101848 4525462
3 4525463 9050926 18101852 4525463
4 4525464 9050928 18101856 4525464
5 4525465 9050930 18101860 4525465
6 4525466 9050932 18101864 4525466

Оскільки 10 мільйонів балів працювали нормально, я вирішив спробувати 1 бал ... і це теж спрацювало!

import vaex
df = vaex.open('1b.hdf5')
df.plot_widget(df.x, df.y, backend='bqplot')

Щоб спостерігати відхилення, яке було невидимим на початковому сюжеті, ми можемо простежити, як змінити стиль точки у vaex-інтерактивному Jupyter bqplot plot_widget, щоб зробити окремі точки більшими та видимими? і використовувати:

df.plot_widget(df.x, df.y, f='log', shape=128, backend='bqplot')

який виробляє:

і після вибору точки:

ми отримуємо повні дані випуску:

   x          y           z
0  500000000  1500000000  -1

Ось демонстрація авторів із більш цікавим набором даних та іншими можливостями: https://www.youtube.com/watch?v=2Tt0i823-ec&t=770

Перевірено в Ubuntu 19.04.

VisIt 2.13.3

Веб-сайт: https://wci.llnl.gov/simulation/computer-codes/visit

Ліцензія: BSD

Розроблена Національною лабораторією Лоуренса Лівермора , яка є лабораторією Національної адміністрації з ядерної безпеки , тому ви можете собі уявити, що 10 мільйонів пунктів для цього не будуть нічим, якби я міг змусити це працювати.

Встановлення: пакета Debian немає, просто завантажте двійкові файли Linux з веб-сайту. Працює без встановлення. Див. Також: /ubuntu/966901/installing-visit

Заснований на VTK, який є серверною бібліотекою, яку використовують багато програмного забезпечення для графічного графіку високої продуктивності. Написано C.

Після 3 годин гри з користувальницьким інтерфейсом я дійсно змусив його працювати, і це вирішило мій випадок використання, як описано на: /stats/376361/how-to-find-the-sample- точки-що-мають-статистично-значущий-великий-вибійник-р

Ось як це виглядає на тестових даних цього допису:

та масштабування з деякими виборами:

і ось вікно вибору:

З точки зору продуктивності VisIt був дуже хорошим: кожна графічна операція забирала лише невеликий проміжок часу або була негайною. Коли мені довелося чекати, на екрані з'являється повідомлення "обробка" із відсотком залишку роботи, і графічний інтерфейс не зависає.

Оскільки 10 мільйонів точок працювали так добре, я також спробував 100 мільйонів точок (файл 2.7G CSV), але він, на жаль, вийшов з ладу / перейшов у дивний стан, я спостерігав це, htopколи 4 потоки VisIt зайняли всю мою 16 ГБ оперативної пам'яті і, ймовірно, загинули до невдалого malloc.

Початковий початок був трохи болючим:

• багато хто за замовчуванням почувається жорстоко, якщо ви не інженер ядерних бомб? Наприклад:
  • розмір точки за замовчуванням 1 піксель (на моніторі плутається з пилом)
  • шкала осей від 0,0 до 1,0: Як показати фактичні значення кількості осей у програмі побудови графіків "Візит" замість дробів від 0,0 до 1,0?
  • налаштування декількох вікон, неприємні спливаючі вікна при виборі точок даних
  • показує ваше ім’я користувача та дату сюжету (видаліть за допомогою "Елементи керування"> "Анотація"> "Інформація про користувача")
  • автоматичні позиціонування за замовчуванням погані: легенда конфліктує з осями, не вдалося знайти автоматизацію заголовків, тому довелося додати мітку та змінити розташування всього вручну
• функцій просто багато, тому важко знайти те, що ви хочете
• керівництво було дуже корисним, але це 386-сторінковий PDF мамонт, зловісно датований "жовтнем 2005 року, версія 1.5". Цікаво, чи використовували вони це для розвитку Трійці ! і це приємний HTML-код Sphinx, створений відразу після того, як я спочатку відповів на це запитання
• відсутність пакету Ubuntu. Але попередньо побудовані двійкові файли просто працювали.

Я пов’язую ці проблеми з:

• він існує вже так давно і використовує деякі застарілі ідеї графічного інтерфейсу
• ви не можете просто натиснути на елементи сюжету, щоб змінити їх (наприклад, осі, заголовок тощо), і є багато можливостей, тому знайти той, кого шукаєте, трохи важко

Мені також подобається, як трохи інфраструктури LLNL просочується в це репо. Див., Наприклад, docs / OfficeHours.txt та інші файли в цьому каталозі! Мені шкода Бреда, який є "хлопцем у понеділок вранці"! О, і пароль автовідповідача - "Убити Еда", не забувайте про це.

Парагляд 5.4.1

Веб-сайт: https://www.paraview.org/

Ліцензія: BSD

Встановлення:

sudo apt-get install paraview

Розроблена Національною лабораторією Sandia, яка є ще однією лабораторією NNSA, тому ще раз сподіваємось, що вона буде легко обробляти дані. Також VTK заснований і написаний на C ++, що було ще більш перспективним.

Однак я був розчарований: чомусь 10 мільйонів балів зробили графічний інтерфейс дуже повільним і не реагував.

У мене добре з контрольованим добре рекламованим моментом "Я зараз працюю, почекай трохи", але графічний інтерфейс застигає, поки це відбувається? Не прийнятний.

htop показав, що Paraview використовував 4 потоки, але ні CPU, ні пам'ять не були максимально використані.

З погляду графічного інтерфейсу Paraview дуже приємний і сучасний, набагато кращий за VisIt, коли він не заїкається. Ось це з меншим числом балів для довідки:

і ось подання електронної таблиці з ручним вибором точки:

Ще одним мінусом є те, що Paraview відчував відсутність функцій порівняно з VisIt, наприклад:

• Я не міг знайти, як встановити колір мого розсіювання на основі третього стовпця: Як розфарбувати точки розсипу за значенням третього стовпця в Paraview, як палітра gnuplot?
• неможливо змінити розмір маркерів !!! https://gitlab.kitware.com/paraview/paraview/issues/14169

Маяві 4.6.2

Веб-сайт: https://github.com/enthought/mayavi

Розроблено : Enthought

Встановити:

sudo apt-get install libvtk6-dev
python3 -m pip install -u mayavi PyQt5

VTK Python.

Mayavi, здається, дуже зосереджений на 3D, я не міг знайти, як робити 2D-графіки в ньому, тому, на жаль, це не вирізає для мого випадку використання.

Однак, щоб перевірити ефективність, я адаптував приклад за адресою : https://docs.enthought.com/mayavi/mayavi/auto/example_scatter_plot.html для 10 мільйонів балів, і він працює нормально, не відстаючи:

import numpy as np
from tvtk.api import tvtk
from mayavi.scripts import mayavi2

n = 10000000
pd = tvtk.PolyData()
pd.points = np.linspace((1,1,1),(n,n,n),n)
pd.verts = np.arange(n).reshape((-1, 1))
pd.point_data.scalars = np.arange(n)

@mayavi2.standalone
def main():
   from mayavi.sources.vtk_data_source import VTKDataSource
   from mayavi.modules.outline import Outline
   from mayavi.modules.surface import Surface
   mayavi.new_scene()
   d = VTKDataSource()
   d.data = pd
   mayavi.add_source(d)
   mayavi.add_module(Outline())
   s = Surface()
   mayavi.add_module(s)
   s.actor.property.trait_set(representation='p', point_size=1)
main()

Вихід:

Однак я не міг наблизити, щоб побачити окремі точки, близький 3D літак був занадто далеко. Може, є спосіб?

Одне цікаве, що стосується Mayavi, полягає в тому, що розробники докладають багато зусиль, щоб дозволити вам добре запускати та налаштовувати графічний інтерфейс із сценарію Python, подібно до Matplotlib та gnuplot. Здається, це також можливо у Paraview, але документи принаймні не такі хороші.

Як правило, це відчувається не повною мірою, як VisIt / Paraview. Наприклад, я не міг безпосередньо завантажити CSV з графічного інтерфейсу: Як завантажити файл CSV з графічного інтерфейсу Mayavi?

Gnuplot 5.2.2

Веб-сайт: http://www.gnuplot.info/

gnuplot дійсно зручний, коли мені потрібно швидко і брудно, і це завжди перше, що я намагаюся.

Встановлення:

sudo apt-get install gnuplot

Для неінтерактивного використання він може досить добре обробляти 10 метрів:

#!/usr/bin/env gnuplot
set terminal png size 1024,1024
set output "gnuplot.png"
set key off
set datafile separator ","
plot "10m1.csv" using 1:2:3:3 with labels point

який закінчився за 7 секунд:

Але якщо я спробую перейти до інтерактивної роботи

#!/usr/bin/env gnuplot
set terminal wxt size 1024,1024
set key off
set datafile separator ","
plot "10m.csv" using 1:2:3 palette

і:

gnuplot -persist main.gnuplot

тоді початковий візуалізація та масштабування здаються занадто млявими. Я навіть не бачу лінії виділення прямокутника!

Також зверніть увагу, що для мого випадку використання мені потрібно було використовувати мітки гіпертексту, як у:

plot "10m.csv" using 1:2:3 with labels hypertext

але виникла помилка продуктивності з функцією міток, в тому числі для неінтерактивного візуалізації. Але я повідомив про це, і Ітан вирішив це за день: https://groups.google.com/forum/#!topic/comp.graphics.apps.gnuplot/qpL8aJIi9ZE

Потрібно сказати, що є одне обґрунтоване обхідне рішення для вибору сторонніх: просто додайте мітки з ідентифікатором рядка до всіх точок! Якщо поруч багато точок, ви не зможете прочитати ярлики. Але для тих, хто вас турбує, ви просто можете! Наприклад, якщо я додаю до вихідних даних одне відхилення:

cp 10m.csv 10m1.csv
printf '2500000,10000000,40000000\n' >> 10m1.csv

та змініть команду plot, щоб:

#!/usr/bin/env gnuplot
set terminal png size 1024,1024
set output "gnuplot.png"
set key off
set datafile separator ","
plot "10.csv" using 1:2:3:3 palette with labels

Це значно уповільнило побудову графіку (40 хвилин після виправлення, згаданого вище), але дає розумний результат:

отже, з деякою фільтрацією даних, ми врешті-решт потрапимо туди.

Matplotlib 1.5.1, numpy 1.11.1, Python 3.6.7

Веб-сайт: https://matplotlib.org/

Matplotlib - це те, що я зазвичай намагаюся, коли мій скрипт gnuplot починає ставати занадто божевільним.

numpy.loadtxt поодинці зайняло близько 10 секунд, тому я знав, що це не піде добре:

#!/usr/bin/env python3

import numpy
import matplotlib.pyplot as plt

x, y, z = numpy.loadtxt('10m.csv', delimiter=',', unpack=True)
plt.figure(figsize=(8, 8), dpi=128)
plt.scatter(x, y, c=z)
# Non-interactive.
#plt.savefig('matplotlib.png')
# Interactive.
plt.show()

Спочатку неінтерактивна спроба дала хороший результат, але зайняла 3 хвилини 55 секунд ...

Потім інтерактивний зайняв багато часу на початковий рендер та на масштабування. Не використовується:

Зверніть увагу на цьому скріншоті, як вибір масштабу, який повинен негайно масштабуватися та зникати, залишався на екрані довгий час, поки він чекав обчислення масштабу!

Мені довелося закоментувати, plt.figure(figsize=(8, 8), dpi=128)щоб інтерактивна версія з якихось причин працювала, інакше вона підірвалась:

RuntimeError: In set_size: Could not set the fontsize

Боке 1.3.1

https://github.com/bokeh/bokeh

Встановлення Ubuntu 19.04:

python3 -m pip install bokeh

Потім запустіть Jupyter:

jupyter notebook

Тепер, якщо я намічаю 1м точок, все працює ідеально, інтерфейс чудовий і швидкий, включаючи масштабування та інформацію про наведення:

from bokeh.io import output_notebook, show
from bokeh.models import HoverTool
from bokeh.transform import linear_cmap
from bokeh.plotting import figure
from bokeh.models import ColumnDataSource
import numpy as np

N = 1000000
source = ColumnDataSource(data=dict(
    x=np.random.random(size=N) * N,
    y=np.random.random(size=N) * N,
    z=np.random.random(size=N)
))
hover = HoverTool(tooltips=[("z", "@z")])
p = figure()
p.add_tools(hover)
p.circle(
    'x',
    'y',
    source=source,
    color=linear_cmap('z', 'Viridis256', 0, 1.0),
    size=5
)
show(p)

Початковий вигляд:

Після масштабування:

Якщо я піднімаюся на 10 м, хоча він задихається, htopпоказує, що хром має 8 потоків, які забирають усю мою пам'ять у стані безперебійного вводу-виводу.

Це запитує про посилання на точки: Як посилатися на вибрані точки даних боке

PyViz

https://pyviz.org/

TODO оцінити.

Інтегрує Bokeh + datashader + інші інструменти.

Відео демонізація точок даних 1B: https://www.youtube.com/watch?v=k27MJJLJNT4 "PyViz: Інформаційні панелі для візуалізації 1 мільярда точок даних у 30 рядках Python" від "Anaconda, Inc." опубліковано 17.04.2018.

морський народжений

https://seaborn.pydata.org/

TODO оцінити.

Уже є QA те, як використовувати seaborn для візуалізації принаймні 50 мільйонів рядків .

Більш недавній проект має великий потенціал для великих наборів даних: Bokeh , який був створений саме з огляду на це .

Фактично, лише ті дані, які мають значення в масштабі графіку, надсилаються на серверну панель дисплея. Цей підхід набагато швидший, ніж підхід Matplotlib.

Ви, звичайно, можете оптимізувати читання вашого файлу: ви можете безпосередньо прочитати його в масиві NumPy, щоб використати вихідну швидкість NumPy. У вас є кілька варіантів. Якщо оперативна пам’ять є проблемою, ви можете використовувати memmap , який зберігає більшу частину файлу на диску (замість оперативної пам’яті):

# Each data point is a sequence of three 32-bit floats:
data = np.memmap(filename, mode='r', dtype=[('index', 'float32'), ('floati','float32'), ('floatq', 'float32')])

Якщо оперативна пам'ять не є проблемою, ви можете помістити весь масив в оперативну пам'ять за допомогою fromfile :

data = np.fromfile(filename, dtype=[('index', 'float32'), ('floati','float32'), ('floatq', 'float32')])

Потім графік можна виконати за допомогою звичайної plot(*data)функції Matplotlib , можливо, за допомогою методу "збільшення", запропонованого в іншому рішенні.

Я б запропонував щось дещо складне, але це мало би працювати: будуйте графік з різною роздільною здатністю для різних діапазонів.

Подумайте, наприклад, про Google Earth. Якщо ви знімаєте масштаб на максимальному рівні, щоб охопити всю планету, роздільна здатність найнижча. Під час масштабування зображення змінюються на більш деталізовані, але лише в регіоні, на який ви збільшуєте масштаб.

Отже, в основному для вашого сюжету (це 2D? 3D? Я припускаю, що це 2D), я пропоную вам створити один великий графік, який охоплює весь діапазон [0, n] з низькою роздільною здатністю, 2 менших графіки, які охоплюють [0, n / 2] та [n / 2 + 1, n] з подвійною роздільною здатністю великого, 4 менші графіки, що охоплюють [0, n / 4] ... [3 * n / 4 + 1, n] з подвійним роздільна здатність вищезазначених 2 тощо.

Не впевнений, моє пояснення справді ясне. Крім того, я не знаю, чи обробляє такий різновид графіку з багатьма роздільною здатністю будь-яка існуюча програма сюжету.

Цікаво, чи можна виграти, пришвидшивши пошук ваших очок? (Мене якийсь час заінтригували дерева R * (r-зірка).)

Цікаво, якщо використання чогось на зразок r * дерева в цьому випадку може бути правильним шляхом. (при зменшенні масштабу верхні вузли в дереві можуть містити інформацію про більш грубе, зменшене зображення, вузли далі до листя містять окремі зразки)

можливо, навіть пам'ять відображає дерево (або будь-яку структуру, яку ви в кінцевому підсумку використовуєте) в пам'ять, щоб зберегти вашу продуктивність і низьке використання оперативної пам'яті. (ви вивантажуєте завдання управління пам'яттю в ядро)

сподівання, що має сенс .. трохи блукати. вже пізно!