Как я могу скопировать граф в Python?

Ответ 1

Почему бы не использовать настоящую библиотеку графа, например Python-Graph? Он имеет функцию для определения подключенных компонентов (хотя пример не указан). Я бы предположил, что выделенная библиотека будет быстрее, чем любой готовый графический код.

EDIT: NetworkX кажется, что это лучший выбор, чем python-graph; его документация (здесь для функции подключенных компонентов), безусловно, есть.

Ответ 2

В SciPy вы можете использовать разреженные матрицы. Также обратите внимание, что существуют более эффективные способы умножения матрицы. Во всяком случае, то, что вы пытаетесь сделать, может быть выполнено путем разложения SVD.

Введение с полезными ссылками.

Ответ 3

Там также graph_tool и networkit, которые имеют эффективные подпрограммы для подключенных компонентов, и оба эффективно сохраняют сеть. Если вы собираетесь работать с миллионами узлов, networkx, скорее всего, не будет достаточным (это чистый python afaik). Оба этих инструмента написаны на С++, поэтому могут обрабатывать анализ больших графиков с разумным временем выполнения.

Как указывает Фил, ваш метод будет иметь ужасно длительные времена вычислений для больших графиков (мы говорим дни, недели, месяцы...), и ваше представление для графика из миллиона узлов потребует чего-то вроде миллиона гигабайт памяти!

Ответ 4

Вот некоторая наивная реализация, которая находит связанные компоненты, используя глубину первого поиска, я написал некоторое время назад. Хотя он очень прост, он хорошо масштабируется до десяти тысяч вершин и краев...

import sys
from operator import gt, lt

class Graph(object):
    def __init__(self):
        self.nodes = set()
        self.edges = {}
        self.cluster_lookup = {}
        self.no_link = {}

    def add_edge(self, n1, n2, w):
        self.nodes.add(n1)
        self.nodes.add(n2)
        self.edges.setdefault(n1, {}).update({n2: w})
        self.edges.setdefault(n2, {}).update({n1: w})

    def connected_components(self, threshold=0.9, op=lt):
        nodes = set(self.nodes)
        components, visited = [], set()
        while len(nodes) > 0:
            connected, visited = self.dfs(nodes.pop(), visited, threshold, op)
            connected = set(connected)
            for node in connected:
                if node in nodes:
                    nodes.remove(node)

            subgraph = Graph()
            subgraph.nodes = connected
            subgraph.no_link = self.no_link
            for s in subgraph.nodes:
                for k, v in self.edges.get(s, {}).iteritems():
                    if k in subgraph.nodes:
                        subgraph.edges.setdefault(s, {}).update({k: v})
                if s in self.cluster_lookup:
                    subgraph.cluster_lookup[s] = self.cluster_lookup[s]

            components.append(subgraph)
        return components

    def dfs(self, v, visited, threshold, op=lt, first=None):
        aux = [v]
        visited.add(v)
        if first is None:
            first = v
        for i in (n for n, w in self.edges.get(v, {}).iteritems()
                  if op(w, threshold) and n not in visited):
            x, y = self.dfs(i, visited, threshold, op, first)
            aux.extend(x)
            visited = visited.union(y)
        return aux, visited

def main(args):
    graph = Graph()
    # first component
    graph.add_edge(0, 1, 1.0)
    graph.add_edge(1, 2, 1.0)
    graph.add_edge(2, 0, 1.0)

    # second component
    graph.add_edge(3, 4, 1.0)
    graph.add_edge(4, 5, 1.0)
    graph.add_edge(5, 3, 1.0)

    first, second = graph.connected_components(op=gt)
    print first.nodes
    print second.nodes

if __name__ == '__main__':
    main(sys.argv)

Ответ 5

Как указывали другие, нет необходимости изобретать велосипед. Многие мысли были приведены в оптимальные методы кластеризации. Здесь - одна известная программа кластеризации.

Ответ 6

Поиск оптимального разбиения графа является NP-трудной задачей, поэтому, независимо от алгоритма, это будет приближение или эвристика. Неудивительно, что различные алгоритмы кластеризации дают (дико) разные результаты.

Выполнение Python алгоритма модульности Ньюмена: модульность

Также: MCL, MCODE, CFinder, NeMo, clusterONE

Ответ 7

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

Многократное выполнение M '= MM не будет эффективным для больших порядков M. Полное умножение матрицы для матриц порядка N будет стоить N умножений и N-1 добавок на элемент, из которых N ² то есть операции O (N ³). Если вы масштабируете это значение до "миллионов узлов", это будет операция O (10 ¹⁸) для умножения матрицы-матрицы, из которых вы хотите сделать несколько.

Короче говоря, вы не хотите этого делать. Предложение SVD от Vartec было бы единственным подходящим выбором. Ваш лучший вариант - просто использовать PyMetis, а не пытаться изобрести графовое разбиение.

Ответ 8

Алгоритм SVD здесь не применим, но в противном случае Phil H является правильным.