Skip to content

Grand graphe interactif avec ~20 millions de points d'échantillonnage et des gigaoctets de données.

C'est la réponse la plus correcte que nous puissions vous donner, mais étudiez-la d'abord attentivement et analysez si elle est compatible avec votre travail.

Solution :

Donc, vos données ne sont pas si grandes, et le fait que vous ayez du mal à les tracer indique des problèmes avec les outils. Matplotlib a beaucoup d'options et la sortie est bien, mais c'est un énorme monstre de mémoire et il suppose fondamentalement que vos données sont petites. Mais il existe d'autres options.

Donc, à titre d'exemple, j'ai généré un fichier de 20M de points de données 'bigdata.bin' en utilisant ce qui suit :

#!/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()

Cela génère un fichier de taille ~229Mo, ce qui n'est pas si grand que ça ; mais vous avez exprimé que vous aimeriez aller vers des fichiers encore plus grands, donc vous finirez par atteindre les limites de la mémoire.

Concentrons-nous d'abord sur les tracés non interactifs. La première chose à réaliser est que les tracés vectoriels avec des glyphes à chaque point vont être un désastre -- pour chacun des 20 M points, dont la plupart vont se chevaucher de toute façon, essayer de rendre des petites croix ou des cercles ou quelque chose de ce genre va être un désastre, générant des fichiers énormes et prenant des tonnes de temps. Ceci, je pense que c'est ce qui coule matplotlib par défaut.

Gnuplot n'a aucun problème pour gérer cela :

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

gnuplot

Et même Matplotlib peut être amené à se comporter avec une certaine prudence (en choisissant un back end raster, et en utilisant des pixels pour marquer les points) :

#!/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()  

matplotlib

Maintenant, si vous voulez de l'interactif, vous allez devoir bin les données à tracer, et zoomer à la volée. Je ne connais pas d'outils python qui vous aideront à faire cela à vue de nez.

D'un autre côté, tracer des big-data est une tâche assez courante, et il y a des outils qui sont à la hauteur de la tâche. Paraview est mon favori personnel, et VisIt en est un autre. Tous deux sont principalement conçus pour les données 3D, mais Paraview, en particulier, peut également traiter les données 2D et est très interactif (il dispose même d'une interface de script Python). La seule astuce sera d'écrire les données dans un format de fichier que Paraview peut facilement lire.

Une enquête sur les logiciels de traçage interactif open source avec un benchmark de 10 millions de points de nuage de points sur Ubuntu.

Inspiré par le cas d'utilisation décrit à l'adresse : https://stats.stackexchange.com/questions/376361/how-to-find-the-sample-points-that-have-statistically-meaningful-large-outlier-r j'ai fait un benchmark de quelques programmes de traçage avec exactement les mêmes fichiers d'entrée.

Fondamentalement, je voulais :

  • faire un nuage de points XY de données multidimensionnelles, si possible avec Z comme couleur de point.
  • sélectionner interactivement quelques points d'apparence intéressante dans le graphe avec ma souris.
  • visualiser toutes les dimensions des points sélectionnés (y compris au moins X, Y et Z) pour essayer de comprendre pourquoi ils sont aberrants dans le nuage de points XY.

Ce problème peut être représenté par les données de test simplifiées suivantes :

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

Les premières lignes de 10m1.csv ressemblent à ceci :

10m1.csv

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

et le tout dernier, le premier des 10 millions, est la valeur aberrante, et ressemble à ceci :

5000000,20000000,-1

donc nous avons en gros :

  • une ligne avec une inclinaison de 2 et 10 millions de points dessus
  • plus un seul point aberrant à l'extérieur de la ligne, au centre supérieur du tracé.

quelque chose comme :

Y

^
|
|
|       +       +
|
|             +
|
|           +
|
|         +
|
|       +
|
|     +
|
|   +
|
| +
|
+-------------------> X

Et le but de ce repère est de trouver le point (5000000,20000000) sur le tracé graphique, et ensuite de déterminer la valeur de la troisième colonne à partir de ce point, soit -1 dans notre test.

Lorsque j'ai écrit cette réponse pour la première fois, j'avais utilisé 10.csv généré avec :

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

sans la valeur aberrante. Bien que cela teste les performances, cela ne teste pas les capacités de sélection, donc l'objectif est de migrer chaque test vers 10m1.csv lorsque je trouve la motivation pour le faire.

J'ai également fait un exemple de 10 points + valeur aberrante au cas où je voudrais évaluer l'utilisabilité pour un outil quelconque qui ne pourrait pas gérer le nombre de points 10m :

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

Pour m'amuser encore plus, j'ai également préparé un ensemble de données encore plus grand de 1 milliard de points au cas où l'un des programmes pourrait gérer les 10 millions de points ! Les fichiers CSV devenaient un peu bancals, alors je suis passé à HDF5 :

#!/usr/bin/env python3

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')

Cela produit un ~23GiB analogue à 10m1.csv contenant :

  • 1 milliard de points dans une ligne droite semblable à 10m.csv
  • un point aberrant au centre haut du graphique.

Les tests ont été effectués sous Ubuntu 18.10, sauf mention contraire dans la sous-section a, dans un ordinateur portable ThinkPad P51 avec un processeur Intel Core i7-7820HQ (4 cœurs / 8 threads), 2x Samsung M471A2K43BB1-CRC RAM (2x 16GiB), GPU NVIDIA Quadro M1200 4GB GDDR5.

Résumé des résultats

Voici ce que j'ai observé, compte tenu de mon cas d'utilisation de test très spécifique et du fait que je suis un premier utilisateur de plusieurs des logiciels examinés :

Est-ce qu'il gère 10 millions de points :

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

Est-ce qu'il a beaucoup de fonctionnalités :

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     ?

Est-ce que l'interface graphique se sent bien (sans tenir compte des bonnes performances) :

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

Installer et obtenir un hello world fonctionnant comme indiqué à : Comment faire un zoom interactif de nuage de points 2D / sélection de points dans Vaex ?

J'ai testé vaex avec jusqu'à 1 milliard de points et ça a marché, c'est génial !

C'est "Python-scripted-first", ce qui est génial pour la reproductibilité, et me permet de m'interfacer facilement avec d'autres choses Python.

La configuration de Jupyter a quelques parties mobiles, mais une fois que je l'ai fait fonctionner avec virtualenv, c'était incroyable.

Pour charger notre exécution CSV dans Jupyter :

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

et nous pouvons voir instantanément :

Entrez la description de l'image ici

Maintenant, nous pouvons zoomer, faire un panoramique et sélectionner des points avec la souris, et les mises à jour sont vraiment rapides, le tout en moins de 10 secondes. Ici, j'ai zoomé pour voir certains points individuels et j'en ai sélectionné quelques-uns (rectangle clair et léger sur l'image) :

Entrez la description de l'image ici

Après que la sélection ait été faite avec la souris, cela a exactement le même effet que d'utiliser la commande df.select() . Nous pouvons donc extraire les points sélectionnés en les exécutant dans Jupyter :

df.to_pandas_df(selection=True)

qui sort des données avec le format :

        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

Puisque 10M points ont bien fonctionné, j'ai décidé d'essayer 1B points... et cela a aussi bien fonctionné !

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

Pour observer la valeur aberrante, qui était invisible sur le tracé original, nous pouvons suivre Comment modifier le style de point dans un bqplot interactif Jupyter vaex plot_widget pour rendre les points individuels plus grands et visibles ? et utiliser :

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

qui produit :

Entrez la description de l'image ici

et après avoir sélectionné le point :

Entrez la description de l'image ici

on obtient les données complètes de l'aberration :

   x          y           z
0  500000000  1500000000  -1

Voici une démo réalisée par les créateurs avec un jeu de données plus intéressant et plus de fonctionnalités : https://www.youtube.com/watch?v=2Tt0i823-ec&t=770

Testé sous Ubuntu 19.04.

VisIt 2.13.3

Site web : https://wci.llnl.gov/simulation/computer-codes/visit

Licence : BSD

Développé par le Lawrence Livermore National Laboratory, qui est un laboratoire de la National Nuclear Security Administration, donc vous pouvez imaginer que 10m de points ne seront rien pour lui si j'arrivais à le faire fonctionner.

Installation : il n'y a pas de paquet Debian, il suffit de télécharger les binaires Linux depuis le site web. Fonctionne sans installation. Voir aussi : https://askubuntu.com/questions/966901/installing-visit

Basé sur VTK qui est la bibliothèque dorsale que beaucoup de logiciels de graphisme à haute performance utilisent. Écrit en C.

Après 3 heures de jeu avec l'interface utilisateur, j'ai réussi à la faire fonctionner, et elle a résolu mon cas d'utilisation comme détaillé à : https://stats.stackexchange.com/questions/376361/how-to-find-the-sample-points-that-have-statistically-meaningful-large-outlier-r.

Voici à quoi cela ressemble sur les données de test de ce post :

Entrez la description de l'image ici

et un zoom avec quelques picks :

Entrez la description de l'image ici

et voici la fenêtre des picks :

Entrez la description de l'image ici

Sur le plan des performances, VisIt était très bon : chaque opération graphique ne prenait que peu de temps ou était immédiate. Lorsque j'ai dû attendre, il affiche un message de "traitement" avec le pourcentage de travail restant, et l'interface graphique n'a pas gelé.

Puisque 10m points ont si bien fonctionné, j'ai également essayé 100m points (un fichier CSV de 2,7G) mais il s'est écrasé / est entré dans un état bizarre malheureusement, je l'ai regardé dans.... htop alors que les 4 threads VisIt ont pris toute ma RAM de 16GiB et sont morts probablement à cause d'un malloc raté.

La mise en route initiale a été un peu douloureuse :

  • beaucoup des valeurs par défaut semblent atroces si vous n'êtes pas un ingénieur de la bombe nucléaire ? Ex :
    • taille de point par défaut 1px (se confond avec la poussière sur mon moniteur).
    • échelle des axes de 0.0 à 1.0 : Comment afficher les valeurs réelles des numéros d'axes sur le programme de traçage Visit au lieu des fractions de 0.0 à 1.0 ?
    • configuration multi-fenêtres, popups multi désagréables quand on choisit des points de données.
    • affiche votre nom d'utilisateur et la date du tracé (à supprimer avec "Contrôles" > "Annotation" > "Informations utilisateur")
    • les défauts de positionnement automatique sont mauvais : la légende entre en conflit avec les axes, on n'a pas pu trouver l'automatisation du titre donc on a dû ajouter une étiquette et tout repositionner à la main.
  • il y a juste beaucoup de fonctionnalités, donc il peut être difficile de trouver ce que vous voulez.
  • le manuel a été très utile, mais c'est un mammouth PDF de 386 pages, sinistrement daté "Octobre 2005 Version 1.5". Je me demande s'ils ont utilisé cela pour développer Trinity ! et c'est un joli Sphinx HTML créé juste après que j'ai répondu à cette question à l'origine.
  • pas de paquetage Ubuntu. Mais les binaires préconstruits ont juste fonctionné.

J'attribue ces problèmes à :

  • il existe depuis si longtemps et utilise certaines idées d'interface graphique dépassées.
  • vous ne pouvez pas simplement cliquer sur les éléments du tracé pour les modifier (par exemple, les axes, le titre, etc.), et il y a beaucoup de fonctionnalités, il est donc un peu difficile de trouver celle que vous cherchez...

J'aime aussi beaucoup la façon dont un peu d'infrastructure LLNL fuit dans ce repo. Voir par exemple docs/OfficeHours.txt et d'autres fichiers dans ce répertoire ! Je suis désolé pour Brad qui est le "Monday Morning guy" ! Oh, et le mot de passe pour le répondeur est "Kill Ed", ne l'oubliez pas.

Paraview 5.9.0

Site web : https://www.paraview.org/

Licence : BSD

Testé sur : Ubuntu 20.10.

Installation :

sudo apt install paraview

ou obtenir la dernière version en téléchargeant les prébuilts depuis le site web. C'est ce que j'ai fait pour cette revue, puisque l'apt n'en était qu'à 5.7.0. J'ai téléchargé ParaView-5.9.0-MPI-Linux-Python3.8-64bit.tar.gz.

Développé par Kitware et Los Alamos National Laboratory, et plus tard Sandia National Laboratories (donc les deux autres laboratoires de la NNSA), donc une fois de plus nous nous attendons à ce qu'il gère facilement les données. Également basé sur VTK et écrit en C++, ce qui était encore plus prometteur.

Cependant, j'ai été déçu : pour une raison quelconque, 10m points a rendu l'interface graphique très lente et peu réactive, la rendant inutilisable. Chaque fois que je cliquais sur quelque chose, comme pour cacher les lignes, cela prenait plusieurs dizaines de secondes. Je pense qu'à un moment donné, il a juste glitché et a cessé de répondre du tout.

Je suis d'accord avec un moment contrôlé bien annoncé "Je travaille maintenant, attendez un peu", mais l'interface graphique se figeant pendant que cela se produit ? Pas acceptable.

htop a montré que Paraview utilisait 8 threads et 3 Go de RAM, donc ni le CPU ni la mémoire n'étaient au maximum.

Du point de vue de l'interface graphique, Paraview est très agréable et moderne, bien mieux que VisIt quand il ne bégaie pas.

Depuis 10m1.csv l'a tué, j'ai testé avec 11.csv pour voir si j'aurais pu résoudre mon problème, sauf pour les performances, et la réponse est oui :

  • paraview 11.csv
  • sélectionner le lecteur CSV dans la popup
  • propriétés propriétés Appliquer sur la gauche
  • clic droit sur le CSV sur Pipeline Browser
  • Ajouter un filtre > Alphabétique > Tracer les données. Pourquoi le traçage est un filtre ? Pas très intuitif pour les premiers utilisateurs, lié : paraview : tracer des données à partir d'un fichier csv Je suis sûr que c'est l'une de ces choses qui ont un sens une fois que vous comprenez des généralisations supplémentaires de ce que les filtres peuvent faire, mais quand même.
  • propriétés > Appliquer
  • désélectionner "Utiliser l'index pour l'axe des x".
  • Nom du tableau X : Champ 0
  • Les paramètres de la série suppriment le champ 0 et le champ 2
  • sélectionner le champ 1 et :
    • Style de ligne : Aucun
    • Style de marqueur : croix
    • Taille du marqueur : augmenter ou diminuer selon les besoins.
  • Icône "sélection de rectangle(s)" au-dessus du tracé.
  • Sélection de la valeur aberrante (le point est mis en évidence)
  • Ajouter un autre filtre au filtre du tracé : "Extraire la sélection"
  • Appliquer

Et enfin ! !! J'obtiens un tableau ne contenant que la valeur aberrante sélectionnée, et montrant la valeur du "champ 2" comme étant -1 :

Entrez la description de l'image ici

Alors oui, pas vraiment une promenade de santé, mais j'ai fini par y arriver.

Un autre inconvénient est que Paraview se sentait manquer de fonctionnalités par rapport à VisIt, par exemple :

  • Je n'ai pas trouvé comment définir la couleur de mon scatter en fonction d'une troisième colonne : Comment colorer les points d'un scatter plot par la valeur d'une troisième colonne dans Paraview comme la palette gnuplot ?

Mayavi 4.6.2

Site web : https://github.com/enthought/mayavi

Développé par : Enthought

Installer :

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

Le VTK Python un.

Mayavi semble être très axé sur la 3D, je n'ai pas trouvé comment faire des tracés 2D dedans, donc il ne coupe pas pour mon cas d'utilisation malheureusement.

Juste pour vérifier les performances cependant, j'ai adapté l'exemple de : https://docs.enthought.com/mayavi/mayavi/auto/example_scatter_plot.html pour 10 millions de points, et il a couru juste bien sans lagging :

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()

Sortie :

Entrez la description de l'image ici

Je ne pouvais cependant pas zoomer suffisamment pour voir les points indivituels, le plan 3D proche était trop loin. Peut-être y a-t-il un moyen ?

Une chose cool à propos de Mayavi est que les devs ont mis beaucoup d'efforts pour vous permettre de lancer et de configurer l'interface graphique à partir d'un script Python joliment, un peu comme Matplotlib et gnuplot. Il semble que cela soit également possible dans Paraview, mais les docs ne sont pas aussi bons au moins.

En général, il ne semble pas aussi complet que VisIt / Paraview. Par exemple, je ne pouvais pas charger directement un CSV depuis l'interface graphique : Comment charger un fichier CSV à partir de l'interface graphique de Mayavi ?

Gnuplot 5.2.2

Site internet : http://www.gnuplot.info/

gnuplot est vraiment pratique quand j'ai besoin d'aller vite et sale, et c'est toujours la première chose que j'essaie.

Installation :

sudo apt-get install gnuplot

Pour une utilisation non interactive, il peut gérer 10m points raisonnablement bien :

#!/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

qui s'est terminé en 7 secondes :

Entrez la description de l'image ici

Mais si j'essaie de devenir interactif avec

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

et :

gnuplot -persist main.gnuplot

alors le rendu initial et les zooms semblent trop lents. Je ne peux même pas voir la ligne de sélection du rectangle !

Notez également que pour mon cas d'utilisation, j'avais besoin d'utiliser des étiquettes hypertextes comme dans :

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

mais il y avait un bug de performance avec la fonctionnalité des étiquettes, y compris pour le rendu non interactif. Mais je l'ai signalé, et Ethan l'a résolu en un jour : https://groups.google.com/forum/#!topic/comp.graphics.apps.gnuplot/qpL8aJIi9ZE.

Je dois dire cependant qu'il existe une solution de contournement raisonnable pour la sélection des valeurs aberrantes : il suffit d'ajouter des étiquettes avec l'ID de la ligne à tous les points ! S'il y a beaucoup de points à proximité, vous ne serez pas en mesure de lire les étiquettes. Mais pour les points aberrants qui vous intéressent, c'est possible ! Par exemple, si j'ajoute une valeur aberrante à nos données originales :

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

et que je modifie la commande plot en :

#!/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

Cela a ralenti le traçage de manière significative (40 mins après la correction mentionnée ci-dessus ! !!), mais produit une sortie raisonnable :

Entrez la description de l'image ici

donc, avec un peu de filtrage des données, nous y arriverons, éventuellement.

Matplotlib 1.5.1, numpy 1.11.1, Python 3.6.7.

Site web : https://matplotlib.org/

Matplotlib est ce que j'essaie généralement lorsque mon script gnuplot commence à devenir trop fou.

numpy.loadtxt seul a pris environ 10 secondes, donc je savais que cela n'allait pas bien se passer :

#!/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()

D'abord la tentative non-interactive a donné de bons résultats, mais a pris 3 minutes et 55 secondes...

Ensuite, l'interactive a pris beaucoup de temps sur le rendu initial et sur les zooms. Non utilisable :

Entrez la description de l'image ici

Remarquez sur cette capture d'écran comment la sélection du zoom, qui devrait immédiatement zoomer et disparaître est restée à l'écran pendant un long moment en attendant que le zoom soit calculé !

J'ai dû commenter plt.figure(figsize=(8, 8), dpi=128) pour que la version interactive fonctionne pour une raison quelconque, sinon elle explosait avec :

RuntimeError: In set_size: Could not set the fontsize

Bokeh 1.3.1

https://github.com/bokeh/bokeh

Installation d'Ubuntu 19.04 :

python3 -m pip install bokeh

Lancez ensuite Jupyter :

jupyter notebook

Maintenant si je trace 1m de points, tout fonctionne parfaitement, l'interface est géniale et rapide, y compris le zoom et les informations au survol :

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)

Vue initiale :

Entrez la description de l'image ici

Après un zoom :

Entrez la description de l'image ici

Si je monte à 10m, ça s'étouffe, htop montre que chrome a 8 threads prenant toute ma mémoire en état d'IO ininterrompu.

Cette question concerne le référencement des points : Comment référencer les points de données bokeh sélectionnés.

PyViz

https://pyviz.org/

TODO évaluer.

Intègre Bokeh + datashader + autres outils.

Vidéo de démonstration de 1B datapoints : https://www.youtube.com/watch?v=k27MJJLJNT4 "PyViz : Tableaux de bord pour la visualisation de 1 milliard de points de données en 30 lignes de Python" par "Anaconda, Inc." publié le 2018-04-17.

seaborn

https://seaborn.pydata.org/

TODO évaluer.

Il y a déjà une QA sur la façon d'utiliser seaborn pour visualiser au moins 50 millions de lignes.

Un projet plus récent a un fort potentiel pour les grands ensembles de données : Bokeh, qui a été créé exactement dans cet esprit.

En fait, seules les données pertinentes à l'échelle du tracé sont envoyées au backend d'affichage. Cette approche est beaucoup plus rapide que celle de Matplotlib.

Avis et notes

Nous vous invitons à ajouter de la valeur à nos informations en ajoutant votre expérience dans les explications.



Utilisez notre moteur de recherche

Ricerca
Generic filters

Laisser un commentaire

Votre adresse e-mail ne sera pas publiée.