Odpowiednik D3.js w Pythonie

Czy ktoś może polecić bibliotekę Python, która umożliwia interaktywną wizualizację wykresów?

W szczególności chcę czegoś takiego jak d3.js, ale pythonnajlepiej byłoby, gdyby był również 3D.

Spojrzałem na:

• NetworkX - robi tylko Matplotlibwykresy, a te wydają się być 2D. Nie widziałem żadnej interaktywności, takiej jak ta, która d3.jsdaje, na przykład przeciąganie węzłów.
• Graph-tool - wykonuje tylko wykresy 2D i ma bardzo wolne interaktywne wykresy.

Możesz użyć d3py modułu Pythona, który generuje strony xml osadzające skrypt d3.js. Na przykład :

import d3py
import networkx as nx

import logging
logging.basicConfig(level=logging.DEBUG)

G = nx.Graph()
G.add_edge(1,2)
G.add_edge(1,3)
G.add_edge(3,2)
G.add_edge(3,4)
G.add_edge(4,2)

# use 'with' if you are writing a script and want to serve this up forever
with d3py.NetworkXFigure(G, width=500, height=500) as p:
    p += d3py.ForceLayout()
    p.show()

Plotly obsługuje interaktywne wykresy 2D i 3D. Wykresy są renderowane za pomocą D3.js i można je tworzyć za pomocą interfejsu API Pythona , matplotlib , ggplot dla Python , Seaborn , prettyplotlib i pandas . Możesz powiększać, przesuwać, włączać i wyłączać ślady oraz wyświetlać dane po najechaniu kursorem. Wykresy można osadzać w HTML, aplikacjach, pulpitach nawigacyjnych i notatnikach IPython. Poniżej znajduje się wykres temperatury pokazujący interaktywność. Więcej przykładów można znaleźć w galerii samouczków dotyczących notebooków IPython .

W docs zawiera przykłady obsługiwanych typów fabuły i fragmentów kodu.

Specjalnie na twoje pytanie możesz także tworzyć interaktywne wykresy z NetworkX.



W przypadku drukowania 3D w języku Python można tworzyć wykresy punktowe, liniowe i powierzchniowe 3D, które są podobnie interaktywne. Działki są renderowane za pomocą WebGL. Na przykład, zobacz wykres 3D stawek swapów w Wielkiej Brytanii.

Ujawnienie: Jestem w zespole Plotly.

Spojrzałeś na Vincenta? Vincent pobiera obiekty danych Pythona i konwertuje je na gramatykę wizualizacji Vega. Vega to narzędzie do wizualizacji wyższego poziomu zbudowane na bazie D3. W porównaniu do D3py repozytorium Vincent zostało zaktualizowane niedawno. Chociaż wszystkie przykłady są statyczne D3.

więcej informacji:

• https://github.com/wrobstory/vincent

• https://pypi.python.org/pypi/vincent/0.1.6

Wykresy można obejrzeć w Ipythonie, wystarczy dodać ten kod

vincent.core.initialize_notebook()

Lub wyślij do formatu JSON, gdzie możesz wyświetlić wykres wyjściowy JSON w edytorze online Vega ( http://trifacta.github.io/vega/editor/ ) lub wyświetlić je lokalnie na serwerze Python. Więcej informacji na temat oglądania można znaleźć w powyższym linku pypi.

Nie jestem pewien kiedy, ale pakiet Pandas powinien w pewnym momencie mieć integrację z D3. http://pandas.pydata.org/developers.html

Bokeh to biblioteka wizualizacji w języku Python, która obsługuje wizualizację interaktywną. Jego głównym zapleczem wyjściowym jest HTML5 Canvas i używa modelu klient / serwer.

przykłady: http://continuumio.github.io/bokehjs/

Jeden przepis, którego użyłem (opisany tutaj: Co-Director Network Data Files w GEXF i JSON from OpenCorporates Data via Scraperwiki i networkx ) działa następująco:

• wygenerować reprezentację sieci za pomocą networkx
• wyeksportuj sieć jako plik JSON
• import że JSON się do d3.js . ( networkx może eksportować zarówno reprezentacje drzewa, jak i wykresy / sieci, które d3.js może importować).

NetworkX JSON eksporter ma postać:

from networkx.readwrite import json_graph
import json
print json.dumps(json_graph.node_link_data(G))

Alternatywnie możesz wyeksportować sieć jako plik GEXF XML, a następnie zaimportować tę reprezentację do biblioteki wizualizacji Javascript sigma.js .

from xml.etree.cElementTree import tostring
writer=gf.GEXFWriter(encoding='utf-8',prettyprint=True,version='1.1draft')
writer.add_graph(G)
print tostring(writer.xml)

Inną opcją jest bokeh, który właśnie trafił do wersji 0.3.

Dla tych, którzy zalecili pyd3 , nie jest już w fazie aktywnego rozwoju i wskazuje na vincent . vincent również nie jest już w trakcie aktywnego rozwoju i zaleca stosowanie altair .

Więc jeśli chcesz pythonowego d3, użyj altair.

Wypróbuj https://altair-viz.github.io/ - następcę d3py i vincent. Zobacz też

• https://altair-viz.github.io/gallery/index.html
• https://speakerdeck.com/jakevdp/bespoke-visualizations-with-a-declarative-twist

Sprawdź python-nvd3 . Jest to opakowanie Pythona dla nvd3. Wygląda fajniej niż d3.py, a także ma więcej opcji wykresów.

Sugerowałbym użycie mpld3, który łączy wizualizacje javascript D3js z matplotlib języka Python.

Instalacja i użytkowanie są naprawdę proste i ma kilka fajnych wtyczek i interaktywnych elementów.

http://mpld3.github.io/

Plotly może zrobić dla Ciebie fajne rzeczy

https://plot.ly/

Tworzy wysoce interaktywne wykresy, które można łatwo osadzić na stronach HTML dla Twojego prywatnego serwera lub witryny internetowej przy użyciu jego off-line API.

Aktualizacja: Jestem pewien co do możliwości kreślenia 3D, dla wykresów 2D jest niesamowita Dzięki

Możesz także serializować swoje dane, a następnie wizualizować je w D3.js, tak jak to zrobiono tutaj: Użyj Python i Pandas, aby utworzyć diagram sieciowy D3 Force Directed (jest również wyposażony w notebook jupyter !)

Oto sedno. Możesz serializować dane wykresu w tym formacie:

import json
json_data = {
  "nodes":[
    {"name":"Myriel","group":1},
    {"name":"Napoleon","group":1},
    {"name":"Mlle.Baptistine","group":1},
    {"name":"Mme.Magloire","group":1},
    {"name":"CountessdeLo","group":1},
  ],
  "links":[
    {"source":1,"target":0,"value":1},
    {"source":2,"target":0,"value":8},
    {"source":3,"target":0,"value":10},
    {"source":3,"target":2,"value":6},
    {"source":4,"target":0,"value":1},
    {"source":5,"target":0,"value":1},
  ]
}
filename_out = 'graph_data.json'
json_out = open(filename_out,'w')
json_out.write(json_data)
json_out.close()

Następnie ładujesz dane za pomocą d3.js:

d3.json("pcap_export.json", drawGraph);

W przypadku rutyny drawGraphodsyłam jednak do linku.

Istnieje interesujący port NetworkX na Javascript, który może robić to, co chcesz. Zobacz http://felix-kling.de/JSNetworkX/

Widzieć:

Czy istnieje dobra biblioteka interaktywnych wykresów 3D?

Przyjęta odpowiedź sugeruje następujący program, który najwyraźniej ma powiązania z Pythonem: http://ubietylab.net/ubigraph/

Edytować

Nie jestem pewien co do interaktywności NetworkX, ale zdecydowanie możesz tworzyć wykresy 3D. W galerii jest co najmniej jeden przykład:

http://networkx.lanl.gov/examples/drawing/edge_colormap.html

I kolejny przykład w „przykładach”. Ten jednak wymaga posiadania Mayavi.

http://networkx.lanl.gov/examples/3d_drawing/mayavi2_spring.html

Mam dobry przykład automatycznego generowania diagramów sieci D3.js za pomocą Pythona tutaj: http://brandonrose.org/ner2sna

Fajne jest to, że kończysz z automatycznie generowanym kodem HTML i JS i możesz osadzić interaktywny wykres D3 w notatniku z ramką iFrame

Biblioteka d3graphzbuduje z poziomu Pythona wykres d3 sterowany siłą. Możesz "rozbić" sieć na podstawie wagi krawędzi i najechać kursorem na węzły, aby uzyskać więcej informacji. Dwukrotne kliknięcie węzła spowoduje skupienie się na węźle i połączonych z nim krawędziach.

pip install d3graph

Przykład:

source = ['node A','node F','node B','node B','node B','node A','node C','node Z']
target = ['node F','node B','node J','node F','node F','node M','node M','node A']
weight = [5.56, 0.5, 0.64, 0.23, 0.9,3.28,0.5,0.45]

# Import library
from d3graph import d3graph, vec2adjmat

# Convert to adjacency matrix
adjmat = vec2adjmat(source, target, weight=weight)
print(adjmat)
# target  node A  node B  node F  node J  node M  node C  node Z
# source                                                        
# node A    0.00     0.0    5.56    0.00    3.28     0.0     0.0
# node B    0.00     0.0    1.13    0.64    0.00     0.0     0.0
# node F    0.00     0.5    0.00    0.00    0.00     0.0     0.0
# node J    0.00     0.0    0.00    0.00    0.00     0.0     0.0
# node M    0.00     0.0    0.00    0.00    0.00     0.0     0.0
# node C    0.00     0.0    0.00    0.00    0.50     0.0     0.0
# node Z    0.45     0.0    0.00    0.00    0.00     0.0     0.0

# Example A: simple interactive network
out = d3graph(adjmat)

# Example B: Color nodes
out = d3graph(adjmat, node_color=adjmat.columns.values)

# Example C: include node size
node_size = [10,20,10,10,15,10,5]
out = d3graph(adjmat, node_color=adjmat.columns.values, node_size=node_size)

# Example D: include node-edge-size
out = d3graph(adjmat, node_color=adjmat.columns.values, node_size=node_size, node_size_edge=node_size[::-1], cmap='Set2')

# Example E: include node-edge color
out = d3graph(adjmat, node_color=adjmat.columns.values, node_size=node_size, node_size_edge=node_size[::-1], node_color_edge='#00FFFF')

# Example F: Change colormap
out = d3graph(adjmat, node_color=adjmat.columns.values, node_size=node_size, node_size_edge=node_size[::-1], node_color_edge='#00FFFF', cmap='Set2')

# Example H: Include directed links. Arrows are set from source -> target
out = d3graph(adjmat, node_color=adjmat.columns.values, node_size=node_size, node_size_edge=node_size[::-1], node_color_edge='#00FFFF', cmap='Set2', directed=True)

Interaktywny przykład z titanic-case można znaleźć tutaj: https://erdogant.github.io/docs/d3graph/titanic_example/index.html https://erdogant.github.io/hnet/pages/html/Use%20Cases .html