如何在 Python 中创建类似于以下代码示例的径向集群？

Posted 2023-03-12

【中文标题】如何在 Python 中创建类似于以下代码示例的径向集群？

【英文标题】：How do I create a radial cluster like the following code-example in Python?

【发布时间】：2011-07-02 14:54:21

【问题描述】：

我找到了几个关于如何创建这些精确层次结构（至少我相信它们是）的示例，如下所示***.com/questions/2982929/，它们效果很好，并且几乎可以执行我正在寻找的内容。

[编辑]这是Paul 代码的简化版本，现在应该更容易有人帮助将其放入径向集群而不是当前的集群形状

import scipy
import pylab
import scipy.cluster.hierarchy as sch

def fix_verts(ax, orient=1):
    for coll in ax.collections:
        for pth in coll.get_paths():
            vert = pth.vertices
            vert[1:3,orient] = scipy.average(vert[1:3,orient]) 

# Generate random features and distance matrix.
x = scipy.rand(40)
D = scipy.zeros([40,40])
for i in range(40):
    for j in range(40):
        D[i,j] = abs(x[i] - x[j])

fig = pylab.figure(figsize=(8,8))

# Compute and plot the dendrogram.
ax2 = fig.add_axes([0.3,0.71,0.6,0.2])
Y = sch.linkage(D, method='single')
Z2 = sch.dendrogram(Y)
ax2.set_xticks([])
ax2.set_yticks([])

fix_verts(ax2,0)
fig.savefig('test.png')

但我需要如下图所示的径向集群，而不是树状结构。

【问题讨论】：

您的代码示例为线性轴制作树状图。您的图像示例有一个圆周轴。我不清楚您是想在箱形图的径向图中找到“Y”形分支，还是要重现径向图。

看看这个例子：matplotlib.sourceforge.net/examples/axes_grid/… 必须有一种方法可以对这个直线图应用变换以获得你想要的。今天早上我花了一点时间，但没有成功。

【参考方案1】：

我对这个问题进行了更多研究，现在似乎最好直接从linkage 输出创建一个新函数来绘制radial cluster（而不是破解绘制的函数）。我最终可能会做点什么，但很快就什么都做不了了。

我假设您的数据自然承认这种径向嵌入。你验证了吗？ linkage 中是否存在适合您目的的方法？

似乎对于任何方法linkage 都会返回一个二叉树结构。在您的示例中，您有更通用的树。您需要一些额外的知识来整合树节点。一切就绪，破解原始树状图的想法无效。

更新： 对于您的目的，这个幼稚的示例情节是否足够合理？如果是这样，我将能够发布一些非常简单的代码来实现它。

更新 2：

代码如下：

radial_demo.py：

from numpy import r_, ones, pi, sort
from numpy.random import rand
from radial_grouper import tree, pre_order, post_order
from radial_visualizer import simple_link
from pylab import axis, figure, plot, subplot

# ToDo: create proper documentation
def _s(sp, t, o):
    subplot(sp)
    t.traverse(simple_link, order= o)
    axis('equal')

def demo1(n):
    p= r_[2* pi* rand(1, n)- pi, ones((1, n))]
    t= tree(p)
    f= figure()
    _s(221, t, pre_order)
    _s(222, t, post_order)
    t= tree(p, tols= sort(2e0* rand(9)))
    _s(223, t, pre_order)
    _s(224, t, post_order)
    f.show()
    # f.savefig('test.png')

# ToDO: implement more demos

if __name__ == '__main__':
    demo1(123)

radial_grouper.py：

"""All grouping functionality is collected here."""
from collections import namedtuple
from numpy import r_, arange, argsort, array, ones, pi, where
from numpy import logical_and as land
from radial_support import from_polar

__all__= ['tree', 'pre_order', 'post_order']

Node= namedtuple('Node', 'ndx lnk')

# ToDo: enhance documentation
def _groub_by(p, tol, r):
    g, gm, gp= [], [], p- p[0]
    while True:
        if gp[-1]< 0: break
        ndx= where(land(0.<= gp, gp< tol))[0]
        if 0< len(ndx):
            g.append(ndx)
            gm.append(p[ndx].mean())
        gp-= tol
    return g, array([gm, [r]* len(gm)])

def _leafs(p):
    return argsort(p[0])

def _create_leaf_nodes(ndx):
    nodes= []
    for k in xrange(len(ndx)):
        nodes.append(Node(ndx[k], []))
    return nodes

def _link_and_create_nodes(_n, n_, cn, groups):
    nodes, n0= [], 0
    for k in xrange(len(groups)):
        nodes.append(Node(n_+ n0, [cn[m] for m in groups[k]]))
        n0+= 1
    return n_, n_+ n0, nodes

def _process_level(nodes, polar, p, tol, scale, _n, n_):
    groups, p= _groub_by(p, tol, scale* polar[1, _n])
    _n, n_, nodes= _link_and_create_nodes(_n, n_, nodes, groups)
    polar[:, _n: n_]= p
    return nodes, polar, _n, n_

def _create_tree(p, r0, scale, tols):
    if None is tols:
        tols= .3* pi/ 2** arange(5)[::-1]
    _n, n_= 0, p.shape[1]
    polar= ones((2, (len(tols)+ 2)* n_))
    polar[0, :n_], polar[1, :n_]= p[0], r0
    # leafs
    nodes= _create_leaf_nodes(_leafs(p))
    nodes, polar, _n, n_= _process_level(
    nodes, polar, polar[0, _leafs(p)], tols[0], scale, _n, n_)
    # links
    for tol in tols[1:]:
        nodes, polar, _n, n_= _process_level(
        nodes, polar, polar[0, _n: n_], tol, scale, _n, n_)
    # root
    polar[:, n_]= [0., 0.]
    return Node(n_, nodes), polar[:, :n_+ 1]

def _simplify(self):
    # ToDo: combine single linkages
    return self._root

def _call(self, node0, node1, f, level):
    f(self, [node0.ndx, node1.ndx], level)

def pre_order(self, node0, f, level= 0):
    for node1 in node0.lnk:
        _call(self, node0, node1, f, level)
        pre_order(self, node1, f, level+ 1)

def post_order(self, node0, f, level= 0):
    for node1 in node0.lnk:
        post_order(self, node1, f, level+ 1)
        _call(self, node0, node1, f, level)

class tree(object):
    def __init__(self, p, r0= pi, scale= .9, tols= None):
        self._n= p.shape[1]
        self._root, self._p= _create_tree(p, r0, scale, tols)

    def traverse(self, f, order= pre_order, cs= 'Cartesian'):
        self.points= self._p
        if cs is 'Cartesian':
            self.points= from_polar(self._p)
        order(self, self._root, f, 0)
        return self

    def simplify(self):
        self._root= _simplify(self)
        return self

    def is_root(self, ndx):
        return ndx== self._p.shape[1]- 1

    def is_leaf(self, ndx):
        return ndx< self._n

if __name__ == '__main__':
    # ToDO: add tests
    from numpy import r_, round
    from numpy.random import rand
    from pylab import plot, show

    def _l(t, n, l):
        # print round(a, 3), n, l, t.is_root(n[0]), t.is_leaf(n[1])
        plot(t.points[0, n], t.points[1, n])
        if 0== l:
            plot(t.points[0, n[0]], t.points[1, n[0]], 's')
        if t.is_leaf(n[1]):
            plot(t.points[0, n[1]], t.points[1, n[1]], 'o')

    n= 123
    p= r_[2* pi* rand(1, n)- pi, ones((1, n))]
    t= tree(p).simplify().traverse(_l)
    # t= tree(p).traverse(_l, cs= 'Polar')
    show()
    # print
    # t.traverse(_l, post_order, cs= 'Polar')

radial_support.py：

"""All supporting functionality is collected here."""
from numpy import r_, arctan2, cos, sin
from numpy import atleast_2d as a2d

# ToDo: create proper documentation strings
def _a(a0, a1):
    return r_[a2d(a0), a2d(a1)]

def from_polar(p):
    """(theta, radius) to (x, y)."""
    return _a(cos(p[0])* p[1], sin(p[0])* p[1])

def to_polar(c):
    """(x, y) to (theta, radius)."""
    return _a(arctan2(c[1], c[0]), (c** 2).sum(0)** .5)

def d_to_polar(D):
    """Distance matrix to (theta, radius)."""
    # this functionality is to adopt for more general situations
    # intended functionality:
    # - embedd distance matrix to 2D
    # - return that embedding in polar coordinates
    pass

if __name__ == '__main__':
    from numpy import allclose
    from numpy.random import randn
    c= randn(2, 5)
    assert(allclose(c, from_polar(to_polar(c))))

    # ToDO: implement more tests

radial_visualizer.py：

"""All visualization functionality is collected here."""
from pylab import plot

# ToDo: create proper documentation
def simple_link(t, ndx, level):
    """Simple_link is just a minimal example to demonstrate what can be
    achieved when it's called from _grouper.tree.traverse for each link.
    - t, tree instance
    - ndx, a pair of (from, to) indicies
    - level, of from, i.e. root is in level 0
    """
    plot(t.points[0, ndx], t.points[1, ndx])
    if 0== level:
        plot(t.points[0, ndx[0]], t.points[1, ndx[0]], 's')
    if t.is_leaf(ndx[1]):
        plot(t.points[0, ndx[1]], t.points[1, ndx[1]], 'o')

# ToDO: implement more suitable link visualizers
# No doubt, this will the part to burn most of the dev. resources

if __name__ == '__main__':
    # ToDO: implement tests
    pass

您可以找到源代码here。请随意修改它，但请保持未来的修改与要点同步。

【讨论】：

我想我不清楚为什么不应该只使用networkx 解决方案，除非他们真的想重新发明***并且有一种不需要额外依赖的方法. GraphViz 是专门为此目的而设计的强大工具。

networkx 解决方案很好，如果您可以使用其术语描述如何从它所描述的“平衡树”G=nx.balanced_tree(3,5) 变为不平衡树。我的示例图片很好地展示了这一点，并非所有叶节点的计数都相同〜

@Morvern -- 有关如何在 networkx 中创建 unbalanced_tree 的详细信息，请参阅我的原始答案所附的评论

@Morvern：用源代码的位置更新了我的答案。谢谢

【参考方案2】：

我相信您可以将networkx 包与matplotlib 结合使用。从networkx 库中查看以下示例：

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

总的来说networkx 有很多非常好的图表分析和绘图方法

【讨论】：

不幸的是，代码在 pos=nx.graphviz_layout(G,prog='twopi',args='') 行上完全出错。然而，进口似乎工作得很好。按版本进行，我得到了版本 nx.__version__ 1.0rc1（networkx 版本 1.0rc1）

我认为问题在于您需要单独安装 GraphViz，因为我在运行示例代码时得到的具体错误是：InvocationException: GraphViz's executables not found，但理论上如果您拥有所有必要的组件，那么这段代码应该可以满足您的需求。请参阅networkx.lanl.gov/install.html 以获取包括 GraphViz 在内的可选包的链接

就是这样，需要单独安装它〜创造了上面的例子的魅力，但我不是在寻找平衡树，我的例子显示了一个不平衡的树，随机节点之间的连接为好吧。第一个就是最好的例子。关于networkx是否支持这个的任何指针？

balanced_tree 只是在示例中用于演示 networkx 的绘图能力，特别是圆形图布局。这里有许多经典的图生成器：networkx.lanl.gov/reference/generators.html，包括随机图。您可以使用其中之一或使用包图原语创建自己的自定义网络/图。

这里是另一个链接：networkx.github.io/documentation/networkx-1.9/examples/drawing/…

【参考方案3】：

我添加了一个函数fix_verts，它合并了树状图中每个“U”底部的顶点。

试试这个：

import scipy
import pylab
import scipy.cluster.hierarchy as sch

def fix_verts(ax, orient=1):
    for coll in ax.collections:
        for pth in coll.get_paths():
            vert = pth.vertices
            vert[1:3,orient] = scipy.average(vert[1:3,orient]) 

# Generate random features and distance matrix.
x = scipy.rand(40)
D = scipy.zeros([40,40])
for i in range(40):
    for j in range(40):
        D[i,j] = abs(x[i] - x[j])


fig = pylab.figure(figsize=(8,8))

# Compute and plot first dendrogram.
ax1 = fig.add_axes([0.09,0.1,0.2,0.6])
Y = sch.linkage(D, method='centroid')
Z1 = sch.dendrogram(Y, orientation='right')
ax1.set_xticks([])
ax1.set_yticks([])

# Compute and plot second dendrogram.
ax2 = fig.add_axes([0.3,0.71,0.6,0.2])
Y = sch.linkage(D, method='single')
Z2 = sch.dendrogram(Y)
ax2.set_xticks([])
ax2.set_yticks([])

# Plot distance matrix.
axmatrix = fig.add_axes([0.3,0.1,0.6,0.6])
idx1 = Z1['leaves']
idx2 = Z2['leaves']
D = D[idx1,:]
D = D[:,idx2]
im = axmatrix.matshow(D, aspect='auto', origin='lower', cmap=pylab.cm.YlGnBu)
axmatrix.set_xticks([])
fix_verts(ax1,1)
fix_verts(ax2,0)
fig.savefig('test.png')

结果是这样的：

我希望这就是你所追求的。

【讨论】：

很有趣，但它看起来不像OP提供的任何一张图片......

【参考方案4】：

Vega 有一个 example 与您的第一个图表非常相似。

您可以在他们的在线编辑器上使用它。超级酷且易于使用。