Как использовать аргумент `pos` в` networkx` для создания графа в виде потоковой диаграммы?(Python 3)



matplotlib plot (1)

Я пытаюсь создать линейный сетевой график с использованием Python (желательно с matplotlib и networkx хотя и был бы заинтересован в bokeh ), схожий по концепции с приведенным ниже.

Как можно эффективно построить этот график ( pos ?) В Python, используя networkx ? Я хочу использовать это для более сложных примеров, поэтому я чувствую, что жесткое кодирование позиций для этого простого примера не будет полезным :(. Есть ли у networkx решение для этого?

pos (словарь, необязательно) - словарь с узлами в качестве ключей и позициями в качестве значений. Если не указано иное, будет рассчитано расположение пружины. Смотрите networkx.layout для функций, которые вычисляют позиции узлов.

Я не видел никаких учебных пособий о том, как этого можно достичь в сети networkx поэтому я считаю, что этот вопрос станет надежным ресурсом для сообщества. Я подробно networkx уроки по networkx и ничего подобного там нет. networkx для networkx бы такой тип сети невозможным для интерпретации без осторожного использования аргумента pos ... который я считаю единственным вариантом. Ни одна из предварительно вычисленных компоновок в https://networkx.github.io/documentation/networkx-1.9/reference/drawing.html документации, похоже, не справляется с этим типом структуры сети.

Простой пример:

(A) каждый внешний ключ - это итерация в графе, перемещающемся слева направо (например, итерация 0 представляет выборки, итерация 1 имеет группы 1–3, то же самое с итерацией 2, итерация 3 имеет группы 1–2 и т. Д.). (B) Внутренний словарь содержит текущую группировку на этой конкретной итерации и весовые коэффициенты для объединения предыдущих групп, которые представляют текущую группу (например, iteration 3 имеет Group 1 и Group 2 а для iteration 4 все Group 2 iteration 3's прошли в Group 2 iteration 4's но Group 1 iteration 3's была разделена. Веса всегда составляют 1.

Мой код для соединений с весами для участка выше:

D_iter_current_previous =    {
        1: {
            "Group 1":{"sample_0":0.5, "sample_1":0.5, "sample_2":0, "sample_3":0, "sample_4":0},
            "Group 2":{"sample_0":0, "sample_1":0, "sample_2":1, "sample_3":0, "sample_4":0},
            "Group 3":{"sample_0":0, "sample_1":0, "sample_2":0, "sample_3":0.5, "sample_4":0.5}
            },
        2: {
            "Group 1":{"Group 1":1, "Group 2":0, "Group 3":0},
            "Group 2":{"Group 1":0, "Group 2":1, "Group 3":0},
            "Group 3":{"Group 1":0, "Group 2":0, "Group 3":1}
            },
        3: {
            "Group 1":{"Group 1":0.25, "Group 2":0, "Group 3":0.75},
            "Group 2":{"Group 1":0.25, "Group 2":0.75, "Group 3":0}
            },
        4: {
            "Group 1":{"Group 1":1, "Group 2":0},
            "Group 2":{"Group 1":0.25, "Group 2":0.75}
            }
        }

Вот что случилось, когда я сделал График в сети networkx :

import networkx
import matplotlib.pyplot as plt

# Create Directed Graph
G = nx.DiGraph()

# Iterate through all connections
for iter_n, D_current_previous in D_iter_current_previous.items():
    for current_group, D_previous_weights in D_current_previous.items():
        for previous_group, weight in D_previous_weights.items():
            if weight > 0:
                # Define connections using `|__|` as a delimiter for the names
                previous_node = "%d|__|%s"%(iter_n - 1, previous_group)
                current_node = "%d|__|%s"%(iter_n, current_group)
                connection = (previous_node, current_node)
                G.add_edge(*connection, weight=weight)

# Draw Graph with labels and width thickness
nx.draw(G, with_labels=True, width=[G[u][v]['weight'] for u,v in G.edges()])

Примечание. Единственный другой способ, которым я мог бы заняться, это сделать в matplotlib создание matplotlib диаграммы с каждым тиком, представляющим итерацию (5, включая начальные выборки), а затем matplotlib точек друг с другом с разными весами. Это был бы довольно грязный код, особенно пытаясь networkx края маркеров с соединениями ... Однако я не уверен, что это и networkx - лучший способ сделать это или есть инструмент (например, bokeh или plotly ), который предназначен для этого типа plotly .


У Networkx есть приличные средства построения графиков для аналитического анализа данных, это не инструмент для составления показателей качества публикаций, по разным причинам, которые я не хочу вдаваться в подробности. Поэтому я переписал эту часть кода с нуля и создал автономный модуль рисования под названием netgraph, который можно найти here (как и оригинал, основанный исключительно на matplotlib). API очень, очень похож и хорошо документирован, поэтому он не должен быть слишком сложным для ваших целей.

Опираясь на это, я получаю следующий результат:

Я выбрал цвет, чтобы обозначить прочность края, как вы можете
1) указать отрицательные значения и
2) лучше различать маленькие значения.
Однако вместо этого вы также можете передать ширину ребра в netgraph (см. netgraph.draw_edges() ).

Различный порядок ветвей является результатом вашей структуры данных (dict), которая не указывает на свойственный порядок. Вам придется изменить структуру данных и функцию _parse_input() ниже, чтобы исправить эту проблему.

Код:

import itertools
import numpy as np
import matplotlib.pyplot as plt
import netgraph; reload(netgraph)

def plot_layered_network(weight_matrices,
                         distance_between_layers=2,
                         distance_between_nodes=1,
                         layer_labels=None,
                         **kwargs):
    """
    Convenience function to plot layered network.

    Arguments:
    ----------
        weight_matrices: [w1, w2, ..., wn]
            list of weight matrices defining the connectivity between layers;
            each weight matrix is a 2-D ndarray with rows indexing source and columns indexing targets;
            the number of sources has to match the number of targets in the last layer

        distance_between_layers: int

        distance_between_nodes: int

        layer_labels: [str1, str2, ..., strn+1]
            labels of layers

        **kwargs: passed to netgraph.draw()

    Returns:
    --------
        ax: matplotlib axis instance

    """
    nodes_per_layer = _get_nodes_per_layer(weight_matrices)

    node_positions = _get_node_positions(nodes_per_layer,
                                         distance_between_layers,
                                         distance_between_nodes)

    w = _combine_weight_matrices(weight_matrices, nodes_per_layer)

    ax = netgraph.draw(w, node_positions, **kwargs)

    if not layer_labels is None:
        ax.set_xticks(distance_between_layers*np.arange(len(weight_matrices)+1))
        ax.set_xticklabels(layer_labels)
        ax.xaxis.set_ticks_position('bottom')

    return ax

def _get_nodes_per_layer(weight_matrices):
    nodes_per_layer = []
    for w in weight_matrices:
        sources, targets = w.shape
        nodes_per_layer.append(sources)
    nodes_per_layer.append(targets)
    return nodes_per_layer

def _get_node_positions(nodes_per_layer,
                        distance_between_layers,
                        distance_between_nodes):
    x = []
    y = []
    for ii, n in enumerate(nodes_per_layer):
        x.append(distance_between_nodes * np.arange(0., n))
        y.append(ii * distance_between_layers * np.ones((n)))
    x = np.concatenate(x)
    y = np.concatenate(y)
    return np.c_[y,x]

def _combine_weight_matrices(weight_matrices, nodes_per_layer):
    total_nodes = np.sum(nodes_per_layer)
    w = np.full((total_nodes, total_nodes), np.nan, np.float)

    a = 0
    b = nodes_per_layer[0]
    for ii, ww in enumerate(weight_matrices):
        w[a:a+ww.shape[0], b:b+ww.shape[1]] = ww
        a += nodes_per_layer[ii]
        b += nodes_per_layer[ii+1]

    return w

def test():
    w1 = np.random.rand(4,5) #< 0.50
    w2 = np.random.rand(5,6) #< 0.25
    w3 = np.random.rand(6,3) #< 0.75

    import string
    node_labels = dict(zip(range(18), list(string.ascii_lowercase)))

    fig, ax = plt.subplots(1,1)
    plot_layered_network([w1,w2,w3],
                         layer_labels=['start', 'step 1', 'step 2', 'finish'],
                         ax=ax,
                         node_size=20,
                         node_edge_width=2,
                         node_labels=node_labels,
                         edge_width=5,
    )
    plt.show()
    return

def test_example(input_dict):
    weight_matrices, node_labels = _parse_input(input_dict)
    fig, ax = plt.subplots(1,1)
    plot_layered_network(weight_matrices,
                         layer_labels=['', '1', '2', '3', '4'],
                         distance_between_layers=10,
                         distance_between_nodes=8,
                         ax=ax,
                         node_size=300,
                         node_edge_width=10,
                         node_labels=node_labels,
                         edge_width=50,
    )
    plt.show()
    return

def _parse_input(input_dict):
    weight_matrices = []
    node_labels = []

    # initialise sources
    sources = set()
    for v in input_dict[1].values():
        for s in v.keys():
            sources.add(s)
    sources = list(sources)

    for ii in range(len(input_dict)):
        inner_dict = input_dict[ii+1]
        targets = inner_dict.keys()

        w = np.full((len(sources), len(targets)), np.nan, np.float)
        for ii, s in enumerate(sources):
            for jj, t in enumerate(targets):
                try:
                    w[ii,jj] = inner_dict[t][s]
                except KeyError:
                    pass

        weight_matrices.append(w)
        node_labels.append(sources)
        sources = targets

    node_labels.append(targets)
    node_labels = list(itertools.chain.from_iterable(node_labels))
    node_labels = dict(enumerate(node_labels))

    return weight_matrices, node_labels

# --------------------------------------------------------------------------------
# script
# --------------------------------------------------------------------------------

if __name__ == "__main__":

    # test()

    input_dict =   {
        1: {
            "Group 1":{"sample_0":0.5, "sample_1":0.5, "sample_2":0, "sample_3":0, "sample_4":0},
            "Group 2":{"sample_0":0, "sample_1":0, "sample_2":1, "sample_3":0, "sample_4":0},
            "Group 3":{"sample_0":0, "sample_1":0, "sample_2":0, "sample_3":0.5, "sample_4":0.5}
            },
        2: {
            "Group 1":{"Group 1":1, "Group 2":0, "Group 3":0},
            "Group 2":{"Group 1":0, "Group 2":1, "Group 3":0},
            "Group 3":{"Group 1":0, "Group 2":0, "Group 3":1}
            },
        3: {
            "Group 1":{"Group 1":0.25, "Group 2":0, "Group 3":0.75},
            "Group 2":{"Group 1":0.25, "Group 2":0.75, "Group 3":0}
            },
        4: {
            "Group 1":{"Group 1":1, "Group 2":0},
            "Group 2":{"Group 1":0.25, "Group 2":0.75}
            }
        }

    test_example(input_dict)

    pass




networkx