精华内容
下载资源
问答
  • python复杂网络分析库NetworkX阅读目录无向图有向图加权图经典图论算法计算强连通、弱连通子图条件过滤pred,succNetworkX是一个用Python语言开发的图论与复杂网络建模工具,内置了常用的图与复杂网络分析算法,可以...

    python

    复杂网络分析库

    NetworkX

    阅读目录

    无向图

    有向图

    加权图

    经典图论算法计算

    强连通、弱连通

    子图

    条件过滤

    pred

    succ

    NetworkX

    是一个用

    Python

    语言开发的图论与复杂网络建模工具,内置了常用的图与复

    杂网络

    分析算

    ,可以方便的进行复杂网络数据分析、

    仿真建模等工作。

    networkx

    支持创

    建简单无向图、有向图和多

    重图

    (

    multigraph

    )

    ;内置许多标准的图论算法,节点可为任

    意数据;支持任意的边值维度,功能丰富,简

    单易用。

    引入模块

    import networkx as nx

    print nx

    回到顶部

    无向图

    1

    #!-*- coding:utf8-*-

    import networkx as nx import matplotlib.pyplot as plt

    print "number of edges:" , G.number_of_edges()

    #

    输出边的数量:

    1

    nx.draw(G) plt.savefig( "wuxiangtu.png" )

    plt.show()

    G = nx.Graph()

    G.add_node(1)

    G.add_edge(2,3)

    #

    建立一个空的无向图

    G

    #

    添加一个节点

    1

    #

    添加一条边

    2-3

    (

    隐含着添加了两个节

    3

    )

    G.add_edge(3,2)

    print "nodes:" , G.nodes()

    print "edges:" , G.edges()

    #

    对于无向图,边

    3-2

    与边

    2-3

    被认为

    #

    输出全部的节点:

    [1, 2, 3]

    #

    输出全部的边:

    [(2, 3)]

    2

    输出

    展开全文
  • Networks算法Algorithms最短路径Shortest Paths简单路径Simple Pathsall_simple_paths(G, source, target[, cutoff])Generate all simple paths in the graph G from source to target.shortest_simple_paths(G, ...

    Networks算法Algorithms

    最短路径Shortest Paths

    简单路径Simple Paths

    all_simple_paths(G, source, target[, cutoff])

    Generate all simple paths in the graph G from source to target.

    shortest_simple_paths(G, source, target[, ...])

    Generate all simple paths in the graph G from source to target, starting from shortest ones.

    Note:nx.all_simple_paths只能迭代一次。

    链接分析Link Analysis

    PageRank Hits

    链接预测Link Prediction

    链接预测算法

    Compute the resource allocation index of all node pairs in ebunch.

    Compute the Jaccard coefficient of all node pairs in ebunch.

    Compute the Adamic-Adar index of all node pairs in ebunch.

    Compute the preferential attachment score of all node pairs in ebunch.

    cn_soundarajan_hopcroft(G[, ebunch, community])

    Count the number of common neighbors of all node pairs in ebunch using community information.

    Compute the resource allocation index of all node pairs in ebunch using community information.

    within_inter_cluster(G[, ebunch, delta, ...])

    Compute the ratio of within- and inter-cluster common neighbors of all node pairs in ebunch.

    Note: 返回的基本都是iterator of 3-tuples in the form (u, v, p)。iterator只能迭代一次,否则为空了。

    不指定ebunch的话就是计算所有没有边的点。If ebunchis None then all non-existent edges in the graph will be used.

    单纯cn个数的计算

    defcommonNeighbor(G, ebunch=None):'''compute num of common neighbor'''importnetworkx asnx

    ifebunchis None:ebunch =nx.non_edges(G)

    defpredict(u, v):cnbors =list(nx.common_neighbors(G, u, v))

    returnlen(cnbors)

    return((u, v, predict(u, v)) foru, v inebunch)

    组件Components

    connectivity连通性

    连通子图Connected components

    Return True if the graph is connected, false otherwise.

    Return the number of connected components.

    Generate connected components.

    Generate connected components as subgraphs.

    Return the nodes in the component of graph containing node n.

    连通子图计算示例

    fromnetworkx.algorithms importtraversal, components

    weighted_edges =pd.read_csv(os.path.join(CWD, 'middlewares/network_reid.txt'), sep=',',

    header=None).values.tolist()

    g =nx.Graph()

    g.add_weighted_edges_from(weighted_edges)# print('#connected_components of g: {}'.format(nx.number_connected_components(g)))component_subgs =components.connected_component_subgraphs(g)

    forcomponent_subg incomponent_subgs:print(component_subg.nodes_list()[:5])

    Strong connectivity

    Weak connectivity

    Attracting components

    Biconnected components

    Semiconnectedness

    Connectivity

    Connectivity and cut algorithms[

    Connectivity]

    遍历Traversal

    深度优先遍历

    广度优先遍历

    边的深度优先遍历

    networkx算法示例

    使用networkx计算所有路径及路径距离

    社区发现

    展开全文
  • 最近开始认真的学习发现一个 python 好玩的模块以下内容为网上的文章整合networkx在02年5月产生,是用python语言编写的软件包,便于用户对复杂网络进行创建、操作和学习。利用networkx可以以标准化和非标准化的数据...

    最近开始认真的学习发现一个 python 好玩的模块

    以下内容为网上的文章整合

    networkx在02年5月产生,是用python语言编写的软件包,便于用户对复杂网络进行创建、操作和学习。利用networkx可以以标准化和非标准化的数据格式存储网络、生成多种随机网络和经典网络、分析网络结构、建立网络模型、设计新的网络算法、进行网络绘制等。

    NetworkX提供了4种常见网络的建模方法,分别是:规则图,ER随机图,WS小世界网络和BA无标度网络。

    一. 规则图

    规则图差不多是最没有复杂性的一类图,random_graphs.random_regular_graph(d, n)方法可以生成一个含有n个节点,每个节点有d个邻居节点的规则图。

    下面一段示例代码,生成了包含20个节点、每个节点有3个邻居的规则图:import networkx as nx

    import matplotlib.pyplot as plt

    # regular graphy

    # generate a regular graph which has 20 nodes & each node has 3 neghbour nodes.

    RG = nx.random_graphs.random_regular_graph(3, 20)

    # the spectral layout

    pos = nx.spectral_layout(RG)

    # draw the regular graphy

    nx.draw(RG, pos, with_labels = False, node_size = 30)

    plt.show()

    二、ER随机图

    ER随机图是早期研究得比较多的一类“复杂”网络,模型的基本思想是以概率p连接N个节点中的每一对节点。用random_graphs.erdos_renyi_graph(n,p)方法生成一个含有n个节点、以概率p连接的ER随机图:import networkx as nx

    import matplotlib.pyplot as plt

    # erdos renyi graph

    # generate a graph which has n=20 nodes, probablity p = 0.2.

    ER = nx.random_graphs.erdos_renyi_graph(20, 0.2)

    # the shell layout

    pos = nx.shell_layout(ER)

    nx.draw(ER, pos, with_labels = False, node_size = 30)

    plt.show()

    三、WS小世界网络

    用random_graphs.watts_strogatz_graph(n, k, p)方法生成一个含有n个节点、每个节点有k个邻居、以概率p随机化重连边的WS小世界网络。

    下面是一个例子:import networkx as nx

    import matplotlib.pyplot as plt

    # WS network

    # generate a WS network which has 20 nodes,

    # each node has 4 neighbour nodes,

    # random reconnection probability was 0.3.

    WS = nx.random_graphs.watts_strogatz_graph(20, 4, 0.3)

    # circular layout

    pos = nx.circular_layout(WS)

    nx.draw(WS, pos, with_labels = False, node_size = 30)

    plt.show()

    四、BA无标度网络

    用random_graphs.barabasi_albert_graph(n, m)方法生成一个含有n个节点、每次加入m条边的BA无标度网络。

    下面是一个例子:import networkx as nx

    import matplotlib.pyplot as plt

    # BA scale-free degree network

    # generalize BA network which has 20 nodes, m = 1

    BA = nx.random_graphs.barabasi_albert_graph(20, 1)

    # spring layout

    pos = nx.spring_layout(BA)

    nx.draw(BA, pos, with_labels = False, node_size = 30)

    plt.show()

    展开全文
  • 摘要: Python复杂网络结构可视化——matplotlib+networkx 什么是networkx? networkx在02年5月产生,是用python语言编写的软件包,便于用户对复杂网络进行创建、操作和学习。利用networkx可以以标准化和非标准化...

    原文链接

    摘要: Python复杂网络结构可视化——matplotlib+networkx

    什么是networkx?

    networkx在02年5月产生,是用python语言编写的软件包,便于用户对复杂网络进行创建、操作和学习。利用networkx可以以标准化和非标准化的数据格式存储网络、生成多种随机网络和经典网络、分析网络结构、建立网络模型、设计新的网络算法、进行网络绘制等。 ——百度百科

    我们可以用networkx做什么?

    https://networkx.github.io/documentation/stable/auto_examples/index.html

    1.画图

     

    image

    2.有向图,无向图,网络图……

     

    image

    3.总之各种图

     

    image

     

    image

    看到这你是不是心动了呢?今天的教程就是要教会你画出封面上的三层感知机模型图!

    Let's get started!

    首先导入networkx和matplotlib模块
    import networkx as nx
    import matplotlib.pyplot as plt 
    >>> import networkx as nx
    >>> G = nx.Graph() 定义了一个空图
    >>> G.add_node(1) 这个图中增加了1节点
    >>> G.add_node('A') 增加'A'节点
    >>> G.add_nodes_from([2, 3]) 同时加2和3两个节点
    >>> G.add_edges_from([(1,2),(1,3),(2,4),(2,5),(3,6),(4,8),(5,8),(3,7)]) 
    # 增加这么多条边,在下面有举例
    >>> H = nx.path_graph(10) 
    >>> G.add_nodes_from(H)
    >>> G.add_node(H)
    G.add_node('a')#添加点a
    G.add_node(1,1)#用坐标来添加点
    G.add_edge('x','y')#添加边,起点为x,终点为y
    G.add_weight_edges_from([('x','y',1.0)])#第三个输入量为权值
    #也可以
    list = [[('a','b',5.0),('b','c',3.0),('a','c',1.0)]
    G.add_weight_edges_from([(list)])
    

    我们来看看上面最后一句是什么意思

    import matplotlib.pyplot as plt
    import networkx as nx
    H = nx.path_graph(10) 
    G.add_nodes_from(H)
    nx.draw(G, with_labels=True)
    plt.show()
    

     

    image

    生成了标号为0到9的十个点!别急,丑是丑了点,一会我们再给他化妆。

    再举个栗子

    G=nx.Graph()
    #导入所有边,每条边分别用tuple表示
    G.add_edges_from([(1,2),(1,3),(2,4),(2,5),(3,6),(4,8),(5,8),(3,7)]) 
    nx.draw(G, with_labels=True, edge_color='b', node_color='g', node_size=1000)
    plt.show()
    #plt.savefig('./generated_image.png') 如果你想保存图片,去除这句的注释
    

     

    image

    好了,你现在已经知道如何给图添加边和节点了,接下来是构造环:

    画个圈圈

    import matplotlib.pyplot as plt
    import networkx as nx
    # H = nx.path_graph(10) 
    # G.add_nodes_from(H)
    G = nx.Graph()
    G.add_cycle([0,1,2,3,4])
    nx.draw(G, with_labels=True)
    plt.show()
    

     

    image

    画个五角星

    import networkx as nx
    import matplotlib.pyplot as plt 
    #画图!
    G=nx.Graph()
    G.add_node(1)
    G.add_nodes_from([2,3,4,5])
    for i in range(5):
        for j in range(i):
            if (abs(i-j) not in (1,4)):    
                G.add_edge(i+1, j+1)
    nx.draw(G, 
            with_labels=True, #这个选项让节点有名称
            edge_color='b', # b stands for blue! 
            pos=nx.circular_layout(G), # 这个是选项选择点的排列方式,具体可以用 help(nx.drawing.layout) 查看
         # 主要有spring_layout  (default), random_layout, circle_layout, shell_layout   
         # 这里是环形排布,还有随机排列等其他方式  
            node_color='r', # r = red
            node_size=1000, # 节点大小
            width=3, # 边的宽度
           )
    plt.show()
    

     

    image

    import random
    G = nx.gnp_random_graph(10,0.3)
    for u,v,d in G.edges(data=True):
        d['weight'] = random.random()
    
    edges,weights = zip(*nx.get_edge_attributes(G,'weight').items())
    
    pos = nx.spring_layout(G)
    nx.draw(G, pos, node_color='b', edgelist=edges, edge_color=weights, width=10.0, edge_cmap=plt.cm.Blues)
    # plt.savefig('edges.png')
    plt.show()
    

     

    image

    加入权重

    import matplotlib.pyplot as plt
    import networkx as nx
    
    G = nx.Graph()
    
    G.add_edge('a', 'b', weight=0.6)
    G.add_edge('a', 'c', weight=0.2)
    G.add_edge('c', 'd', weight=0.1)
    G.add_edge('c', 'e', weight=0.7)
    G.add_edge('c', 'f', weight=0.9)
    G.add_edge('a', 'd', weight=0.3)
    
    elarge = [(u, v) for (u, v, d) in G.edges(data=True) if d['weight'] > 0.5]
    esmall = [(u, v) for (u, v, d) in G.edges(data=True) if d['weight'] <= 0.5]
    
    pos = nx.spring_layout(G)  # positions for all nodes
    
    # nodes
    nx.draw_networkx_nodes(G, pos, node_size=700)
    
    # edges
    nx.draw_networkx_edges(G, pos, edgelist=elarge,
                           width=6)
    nx.draw_networkx_edges(G, pos, edgelist=esmall,
                           width=6, alpha=0.5, edge_color='b', style='dashed')
    
    # labels
    nx.draw_networkx_labels(G, pos, font_size=20, font_family='sans-serif')
    
    plt.axis('off')
    plt.show()
    

     

    image

    有向图

    from __future__ import division
    import matplotlib.pyplot as plt
    import networkx as nx
    
    G = nx.generators.directed.random_k_out_graph(10, 3, 0.5)
    pos = nx.layout.spring_layout(G)
    
    node_sizes = [3 + 10 * i for i in range(len(G))]
    M = G.number_of_edges()
    edge_colors = range(2, M + 2)
    edge_alphas = [(5 + i) / (M + 4) for i in range(M)]
    
    nodes = nx.draw_networkx_nodes(G, pos, node_size=node_sizes, node_color='blue')
    edges = nx.draw_networkx_edges(G, pos, node_size=node_sizes, arrowstyle='->',
                                   arrowsize=10, edge_color=edge_colors,
                                   edge_cmap=plt.cm.Blues, width=2)
    # set alpha value for each edge
    for i in range(M):
        edges[i].set_alpha(edge_alphas[i])
    
    ax = plt.gca()
    ax.set_axis_off()
    plt.show()
    

     

    image

    颜色渐变的节点

    import matplotlib.pyplot as plt
    import networkx as nx
    
    G = nx.cycle_graph(24)
    pos = nx.spring_layout(G, iterations=200)
    nx.draw(G, pos, node_color=range(24), node_size=800, cmap=plt.cm.Blues)
    plt.show()
    

     

    image

    颜色渐变的边

    import matplotlib.pyplot as plt
    import networkx as nx
    
    G = nx.star_graph(20)
    pos = nx.spring_layout(G)
    colors = range(20)
    nx.draw(G, pos, node_color='#A0CBE2', edge_color=colors,
            width=4, edge_cmap=plt.cm.Blues, with_labels=False)
    plt.show()
    

     

    image

    如何画一个多层感知机?

    import matplotlib.pyplot as plt
    import networkx as nx 
    left, right, bottom, top, layer_sizes = .1, .9, .1, .9, [4, 7, 7, 2]
    # 网络离上下左右的距离
    # layter_sizes可以自己调整
    import random
    G = nx.Graph()
    v_spacing = (top - bottom)/float(max(layer_sizes))
    h_spacing = (right - left)/float(len(layer_sizes) - 1)
    node_count = 0
    for i, v in enumerate(layer_sizes):
        layer_top = v_spacing*(v-1)/2. + (top + bottom)/2.
        for j in range(v):
            G.add_node(node_count, pos=(left + i*h_spacing, layer_top - j*v_spacing))
            node_count += 1
    # 这上面的数字调整我想了好半天,汗
    for x, (left_nodes, right_nodes) in enumerate(zip(layer_sizes[:-1], layer_sizes[1:])):
        for i in range(left_nodes):
            for j in range(right_nodes):
                G.add_edge(i+sum(layer_sizes[:x]), j+sum(layer_sizes[:x+1]))    
    # 慢慢研究吧
    pos=nx.get_node_attributes(G,'pos')
    # 把每个节点中的位置pos信息导出来
    nx.draw(G, pos, 
            node_color=range(node_count), 
            with_labels=True,
            node_size=200, 
            edge_color=[random.random() for i in range(len(G.edges))], 
            width=3, 
            cmap=plt.cm.Dark2, # matplotlib的调色板,可以搜搜,很多颜色呢
            edge_cmap=plt.cm.Blues
           )
    plt.show()
    

     

    image

    差不多就是这个效果了。

    后续我会封装为一个类,加入动态演示,比如通过颜色深浅,显示神经网络在优化的时候权重变化。应该会很好玩,嘿嘿。

    上面你也可以改变layer_sizes

    比如改为233333

     

    image

    调皮了

     

    image

    layter_sizes = [2, 3, 4, 5, 5, 4, 3, ] 贼丑了

    完。

    原文发布时间为:2018-08-06
    本文作者:DeepWeaver
    本文来自云栖社区合作伙伴“ Python爱好者社区”,了解相关信息可以关注“ Python爱好者社区

    展开全文
  • python写的复杂网络工具networkx的使用介绍以及安装说明
  • python 复杂网络NetworkX如何突出或高亮显示某一节点的所有连接
  • python复杂网络分析库networkx

    千次阅读 多人点赞 2019-10-13 23:00:35
    文章目录1 简介安装支持四种图绘制网络图基本流程2...networkx是一个用Python语言开发的图论与复杂网络建模工具,内置了常用的图与复杂网络分析算法,可以方便的进行复杂网络数据分析、仿真建模等工作。 利用networ...
  • python 复杂网络中的 SIR 模型

    千次阅读 2020-11-26 00:58:19
    python 实现 复杂网络(小世界网络)中的 SIR 传染病模型
  • 最近开始认真的学习发现一个 python 好玩的模块以下内容为网上的文章整合networkx在02年5月产生,是用python语言编写的软件包,便于用户对复杂网络进行创建、操作和学习。利用networkx可以以标准化和非标准化的数据...
  • 1 要安装的包12345678# 不要单独安装networkx和community ,会导致Graph没有best_parition属性# 安装与networkx 2.x 版本对应的python-louvain(它内部包含了community)pip install -U git+...安装...
  • python复杂网络库networkx:基础

    万次阅读 2015-11-14 21:17:34
    http://blog.csdn.net/pipisorry/article/details/49839251其它复杂网络绘图库[SNAP for python][ArcGIS,Python,网络数据集中查询两点最短路径]Networkx数据类型Graph typesNetworkX provides data structures and ...
  • NetworkX是一个用Python语言开发的图论与复杂网络建模工具,内置了常用的图与复杂网络分析算法,可以方便的进行复杂网络数据分析、仿真建模等工作。networkx支持创建简单无向图、有向图和多重图(multigraph);内置...
  • 摘要:现实生活中,复杂系统俯首即是,和人们的生活息息相关,遍及...因此,研究复杂网络对于了解复杂系统的拓扑结构和各种动力学行为起着非常重要的作用,如何通过对复杂网络的研究来认识复杂系统中个体间的相互作用以及...
  • 基于复杂网络理论的时间序列分析赵丽丽1,唐镇1,王建勇2,王建波1,杨会杰1【摘要】摘要:综述了复杂网络理论应用于时间序列分析的研究进展.报道了对这些问题开展的一些探索性的工作,包括混合序列中不同成分的竞争、二维...
  • 联系人),男,教授....2.邢台学院物理系,邢台054001)摘要:综述了复杂网络理论应用于时间序列分析的研究进展.报道了对这些问题开展的一些探索性的工作,包括混合序列中不同成分的竞争、二维地貌的复杂网...
  • 最近开始认真的学习发现一个 python 好玩的模块以下内容为网上的文章整合networkx在02年5月产生,是用python语言编写的软件包,便于用户对复杂网络进行创建、操作和学习。利用networkx可以以标准化和非标准化的数据...
  • Python复杂网络分析库networkx 看这一篇就够了

    千次阅读 多人点赞 2020-01-26 01:47:30
    networkx在2002年5月产生,是一个用Python语言开发的图论与复杂网络建模工具,内置了常用的图与复杂网络分析算法,可以方便的进行复杂网络数据分析、仿真建模等工作。 networkx支持创建简单无向图、有向图和多重图...
  • python复杂网络库networkx:算法

    万次阅读 2017-01-04 16:22:54
    复杂网络社区结构发现算法-基于python networkx clique渗透算法 ] 皮皮blog from: http://blog.csdn.net/pipisorry/article/details/54020333 ref: [ Algorithms ] [ Networkx Reference ]*[ NetworkX ...
  • python复杂网络库networkx:绘图draw

    万次阅读 2017-01-09 19:14:13
    http://blog.csdn.net/pipisorry/article/details/54291831networkx使用matplotlib绘制函数draw(G[, pos, ax, hold])Draw the graph G with Matplotlib.draw_networkx(G[, pos, arrows, with_labels])Draw the...
  • 这篇文章实现的算法来源于PNAS杂志:代码参考:# coding: utf-8import networkx as nximport matplotlib.pyplot as pltfrom itertools import combinationsdef visibility_graph(series):visibility_graph_edges=[]#...
  • NetworkX是一个用Python语言开发的图论与复杂网络建模工具,内置了常用的图与复杂网络分析算法,可以方便的进行复杂网络数据分析、仿真建模等工作。networkx支持创建简单无向图、有向图和多重图(multigraph);内置...
  • Networks算法Algorithms最短路径Shortest Paths简单路径Simple Pathsall_simple_paths(G,source,target[,cutoff])Generate all simple paths in the graph G from source to target.shortest_simple_paths(G,source,...
  • 本发明属于复杂网络链接预测技术领域:,特别涉及一种基于时间序列的复杂网络链接预测方法。背景技术::复杂网络模型是对各种真实存在网络的抽象,比如社交网络、科研合作网络、生物代谢网络等。链接预测,是根据...
  • 本文首先介绍在NetworkX生成这些网络模型的方法,然后以BA无标度网络的建模为例,分析利用NetworkX进行复杂网络演化模型设计的基本思路,以便将来开发出我们自己的模型。同时这篇文章里还涉及到一点复杂网络可视化的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,393
精华内容 957
关键字:

python复杂网络

python 订阅