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

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

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

Поскольку другие указали, никакая потребность изобрести велосипед. Длительное размышление было помещено в оптимальные методы кластеризации. Здесь одна известная программа кластеризации.

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

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)

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

Неоднократно выполнение M' = MM не будет эффективен для крупных заказов M. Полное умножение матриц для матриц порядка N, будет стоить умножения N и N-1 дополнений на элемент, которого существуют N <глоток> 2 , который является O (N <глоток> 3 ) операции. Если бы Вы масштабируете это к "миллионам узлов", которые были бы O (10 <глоток> 18 ) операции на матричное умножение матриц, которого Вы хотите сделать несколько.

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

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