社會網絡分析與挖掘---Python之networkx介紹

最近學習社會媒體挖掘，需要完成幾個實驗，Python的第三方模塊networkx幾乎都囊括了這些實現的接口，Python的好處就是開源，所以它的第三方模塊的源碼都可以看到，我看了實現的源碼做了部分修改，算是完成了實驗。下面對這個庫做一些介紹。

1. introduction

networkX是一款Python的軟件包，用於創造、操作複雜網絡，以及學習複雜網絡的結構、動力學及其功能。
有了networkX你就可以用標準或者不標準的數據格式加載或者存儲網絡，它可以產生許多種類的隨機網絡或經典網絡，也可以分析網絡結構，建立網絡模型，設計新的網絡算法，繪製網絡等等。

2. install

對於已經裝了pip的環境，安裝第三方模塊很簡單，只需要pip install networkx即可。沒有安裝pip環境的機器可以先安裝pip，Python3默認都是安裝了pip的。

3. tutorial

Creating a graph

創建一個空圖，不包含任何結點和邊。

import networkx as nx
G = nx.Graph()

圖是頂點集和確定的頂點之間的邊集組成。在NetworkX中，頂點可以是任何可以哈希的對象，比如文本，圖片，XML對象，其他的圖對象，任意定製的節點對象，等等。（Python中的None對象不可以作爲結點類型。）

Nodes

圖的增長有幾種方式，NetworkX包含了許多圖的產生函數和一些讀寫圖的工具。
一次添加一個頂點。

G.add_node(1)

也可以添加頂點的列表。

G.add_nodes_from([2, 3])

或者從nbunch中添加節點，nbunch是任何可迭代的節點容器（如list、set、graph、file等），nbunch本身不是圖中的一個節點。

H = nx.path_graph(10)
G.add_nodes_from(H)

此時圖G中就包含了圖H中的10個節點。作爲比較，我們可以使圖H作爲圖G的一個節點.

G.add_node(H)

現在圖G就包含了一個節點H,即該節點是一個圖。可以看到這種靈活性是非常強大的，它允許圖的圖，文件的圖，函數的圖等等。因此我們應該好好思考如何構建我們的應用程序才能使我們的節點是有用的實體。當然我們可以在圖中使用一個唯一的標識符或者使用一個不同的字典的鍵來標識節點信息。（如果該hash依賴於它的內容，則我們不應該改變節點對象）

Edges

圖可以通過一次加一條邊來增長。

 G.add_edge(1, 2)
 e = (2, 3)
 G.add_edge(*e)  # unpack edge tuple*

也可以一次加入一組邊(邊的列表)

G.add_edges_from([(1, 2), (1, 3)])

或者通過添加任何ebunch來添加邊，一個ebunch是任何可迭代的邊的元組，一個邊的元組可以是兩個節點之間的一個2元組（無權值的邊）或者3元組（3元組還有一個元素是邊的權值，比如(1,2,{‘weight’:100})）。下面將進一步討論邊的屬性：

G.add_edges_from(H.edges)

我們可以用類似的方法拆除圖：
G.remove_node(),G.remove_nodes_from(),G.remove_edge(),G.remove_edges_from()
比如：

G.remove_node(H)

如果你添加的節點和邊是已經存在的，是不會報錯的。比如，我們先將圖G裏的所有節點和邊刪除：

G.clear()

然後我們新的節點和邊，NetworkX會自動忽略掉已經存在的邊和節點的添加：

G.add_edges_from([(1,2),(1,3)])
G.add_node(1)
G.add_edge(1,2)
G.add_node("spam")       # adds node "spam"
G.add_nodes_from("spam")  # adds 4 nodes: 's', 'p', 'a', 'm'

此時圖G一共有8個節點和2條邊。
我們可以通過如下函數查看：

print G.number_of_nodes()
8
print G.number_of_edges()
3

What to use as nodes and edges

你可能已經注意到在NetworkX中節點和邊並沒有被指定一個對象，因此你就可以自由地指定節點和邊的對象。最常見的對象是數值和字符串，但是一個節點可以是任意hash對象（除了None對象），一條邊也可以關聯任意的對象x，比如：
G.add_edge(a,b,object=x)。
舉個關於邊關聯對象的例子，加入a和b是兩個人，而他們兩個人之間的聯繫（邊），可以是一個概率，即邊的對象是一個概率值，表示這兩個人之間每天通電話的可能性。
可以看到這是十分強大而且有用的，但是如果你濫用該方法將會導致意想不到的後果，除非你對Python真的很熟悉。如果你不是很確定，你可以考慮使用conver_node_label_to_integers()，他可以將一個圖的所有節點按順序轉化爲整數對象賦給另一個圖。

Accessing edges and neighbors

除了上面提到的那些訪問節點和邊的方法以外（ eg:Graph.nodes(), Graph.edges(), Graph.neighbors()…），也可以利用下標表示來獲取邊和鄰居結點。

>>> G[1]  # same as G.adj[1]
AtlasView({2: {}})
>>> G[1][2]
{}
>>> G.edges[1, 2]
{}

如果邊已經存在時，也可以利用下標表示來設置邊的屬性。

>>> G.add_edge(1, 3)
>>> G[1][3]['color'] = "blue"
>>> G.edges[1, 2]['color'] = "red"

可以使用G.adjacency()或者G.adj.items()來快速訪問每一條邊，注意在無向圖中adjacency迭代器可以看到邊出現了2次。

>>> FG = nx.Graph()
>>> FG.add_weighted_edges_from([(1, 2, 0.125), (1, 3, 0.75), (2, 4, 1.2), (3, 4, 0.375)])
>>> for n, nbrs in FG.adj.items():
...    for nbr, eattr in nbrs.items():
...        wt = eattr['weight']
...        if wt < 0.5: print('(%d, %d, %.3f)' % (n, nbr, wt))
(1, 2, 0.125)
(2, 1, 0.125)
(3, 4, 0.375)
(4, 3, 0.375)

可以通過邊的屬性方便的訪問所有的邊。

>>> for (u, v, wt) in FG.edges.data('weight'):
...     if wt < 0.5: print('(%d, %d, %.3f)' % (u, v, wt))
(1, 2, 0.125)
(3, 4, 0.375)
``
#### Adding attributes to graphs, nodes, and edges
`屬性諸如weight,labels,colors,或者任何對象，你都可以附加到圖、節點或邊上。 
對於每一個圖、節點和邊都可以在關聯的屬性字典中保存一個（多個）鍵-值對。默認情況下這些是一個空的字典，但是我們可以增加或者是改變這些屬性通過使用add\_edge,add\_node或者字典操作這些屬性字典，比如G.graph,G.node或者G.edge。
##### Graph attributes
在創建新圖時指派圖的屬性
``
>>> G = nx.Graph(day="Friday")
>>> G.graph
{'day': 'Friday'}

隨後也可以修改屬性

>>> G.graph['day'] = "Monday"
>>> G.graph
{'day': 'Monday'}

Node attributes

使用add_nodes(), add_nodes_from(), 或者G.nodes來添加頂點屬性。

>>> G.add_node(1, time='5pm')
>>> G.add_nodes_from([3], time='2pm')
>>> G.nodes[1]
{'time': '5pm'}
>>> G.nodes[1]['room'] = 714
>>> G.nodes.data()
NodeDataView({1: {'room': 714, 'time': '5pm'}, 3: {'time': '2pm'}})

注意添加一個節點是G.add_node而不是G.node。

Edge Attributes

使用add_edges()， add_edges_from()或者下標表示上來增加/改變邊的屬性.

>>> G.add_edge(1, 2, weight=4.7 )
>>> G.add_edges_from([(3, 4), (4, 5)], color='red')
>>> G.add_edges_from([(1, 2, {'color': 'blue'}), (2, 3, {'weight': 8})])
>>> G[1][2]['weight'] = 4.7
>>> G.edges[3, 4]['weight'] = 4.2

特殊屬性weight應該是一個數值型的，並且在算法需要使用weight時保存該數值。

Directed graphs

DiGraph類提供了許多有向圖中的額外算法，比如DiGraph.out_edges(),DiGraph.in_degree(),DiGraph.predecessors(),DiGraph.successors()等。爲了讓算法可以在兩類圖中都可以工作，無向圖中的neighbors()和degree()分別等價於有向圖中的successors()和有向圖中的in_degree()和out_degree()的和。雖然這樣有時候會讓我們感覺不太一致。

>>> DG = nx.DiGraph()
>>> DG.add_weighted_edges_from([(1, 2, 0.5), (3, 1, 0.75)])
>>> DG.out_degree(1, weight='weight')
0.5
>>> DG.degree(1, weight='weight')
1.25
>>> list(DG.successors(1))
[2]
>>> list(DG.neighbors(1))
[2]

有些算法只能在有向圖中使用，而有些圖並沒有爲有向圖定義。確實將有向圖和無向圖混在在一起是很危險的一件事情，所以，如果有些實驗你想把一個有向圖看做一個無向圖，你可以將有向圖轉化爲無向圖，通過：

H=DG.to_undirected()
#或者
H=nx.Graph(DG)

Multigraphs

NetworkX提供了一個類，它可以允許任何一對節點之間有多條邊。類MultiGraph和類MultiDiGraph允許添加相同的邊兩次，這兩條邊可能附帶不同的權值。對於有些應用程序這是非常有用的類，但是許多算法不能夠很好的在這樣的圖中定義，比如最短路徑算法，但是像MultiGraph.degree這種算法又可以很好的被定義。否則你應該爲了很好的定義測量，而將圖轉化爲標準的圖。

>>> MG = nx.MultiGraph()
>>> MG.add_weighted_edges_from([(1, 2, 0.5), (1, 2, 0.75), (2, 3, 0.5)])
>>> dict(MG.degree(weight='weight'))
{1: 1.25, 2: 1.75, 3: 0.5}
>>> GG = nx.Graph()
>>> for n, nbrs in MG.adjacency():
...    for nbr, edict in nbrs.items():
...        minvalue = min([d['weight'] for d in edict.values()])
...        GG.add_edge(n, nbr, weight = minvalue)
...
>>> nx.shortest_path(GG, 1, 3)
[1, 2, 3]

Graph generators and graph operations

除了通過節點和邊生成圖，也可以通過以下方法產生：

使用典型的圖形操作：
subgraph(G, nbunch) - 產生nbunch節點的子圖
union(G1,G2) - 結合圖
disjoint_union(G1,G2) - 假設所有節點都不同，然後結合圖
cartesian_product(G1,G2) - 返回笛卡爾乘積圖
compose(G1,G2) - 結合兩個圖並表示兩者共同的節點
complement(G) - 圖G的補圖
create_empty_copy(G) - 返回同一類圖的無邊副本
convert_to_undirected(G) - 返回G的無向圖
convert_to_directed(G) - 返回G的有向圖

調用經典的小圖

>>> petersen = nx.petersen_graph()
>>> tutte = nx.tutte_graph()
>>> maze = nx.sedgewick_maze_graph()
>>> tet = nx.tetrahedral_graph()

使用生成器來構造一些典型的圖

>>> K_5 = nx.complete_graph(5)
>>> K_3_5 = nx.complete_bipartite_graph(3, 5)
>>> barbell = nx.barbell_graph(10, 10)
>>> lollipop = nx.lollipop_graph(10, 20)

使用隨機圖發生器

>>> er = nx.erdos_renyi_graph(100, 0.15)
>>> ws = nx.watts_strogatz_graph(30, 3, 0.1)
>>> ba = nx.barabasi_albert_graph(100, 5)
>>> red = nx.random_lobster(100, 0.9, 0.9)

通過讀取存儲在文件中的一些標準圖形格式，例如邊表，鄰接表，GML，GraphML，pickle，LEAD或者其他的一些格式：

>>> nx.write_gml(red, "path.to.file")
>>> mygraph = nx.read_gml("path.to.file")

Analyzing graphs

圖G的結構可以通過各種圖論的函數來分析，例如：

>>> G = nx.Graph()
>>> G.add_edges_from([(1, 2), (1, 3)])
>>> G.add_node("spam")       # adds node "spam"
>>> list(nx.connected_components(G))
[set([1, 2, 3]), set(['spam'])]
>>> sorted(d for n, d in G.degree())
[0, 1, 1, 2]
>>> nx.clustering(G)
{1: 0, 2: 0, 3: 0, 'spam': 0}

返回節點屬性的函數是通過返回一個以節點爲鍵的字典來實現的

>>> sp = dict(nx.all_pairs_shortest_path(G))
>>> sp[3]
{1: [3, 1], 2: [3, 1, 2], 3: [3]}

Drawing graphs

NetworkX並不是專門用來繪圖的包，但是Matplotlib以及一些接口卻提供了很好的繪圖功能。
首先我們導入Matplotlib的plot接口（pylab也可以）

>>> import matplotlib.pyplot as plt

你可能會發現使用“ipthon -pylab”q去交互測試代碼是很有用的，它提供了強大的ipython和matplotlib，也提供了一個方便的交互模式。
測試networkx.drawing是是否導入成功，可以通過：

>>> G = nx.petersen_graph()
>>> plt.subplot(121)
<matplotlib.axes._subplots.AxesSubplot object at ...>
>>> nx.draw(G, with_labels=True, font_weight='bold')
>>> plt.subplot(122)
<matplotlib.axes._subplots.AxesSubplot object at ...>
>>> nx.draw_shell(G, nlist=[range(5, 10), range(5)], with_labels=True, font_weight='bold')

你要將這個圖形繪製到屏幕，你可能需要Matplotlib:

>>> plt.show()

沒有在交互模式下使用matplotlib的一些命令

>>> options = {
...     'node_color': 'black',
...     'node_size': 100,
...     'width': 3,
... }
>>> plt.subplot(221)
<matplotlib.axes._subplots.AxesSubplot object at ...>
>>> nx.draw_random(G, **options)
>>> plt.subplot(222)
<matplotlib.axes._subplots.AxesSubplot object at ...>
>>> nx.draw_circular(G, **options)
>>> plt.subplot(223)
<matplotlib.axes._subplots.AxesSubplot object at ...>
>>> nx.draw_spectral(G, **options)
>>> plt.subplot(224)
<matplotlib.axes._subplots.AxesSubplot object at ...>
>>> nx.draw_shell(G, nlist=[range(5,10), range(5)], **options)

可以通過draw_networkx(）進行其他的操作或者layout進行佈局。可以使用draw_shell（）使用多重的shells。

>>> G = nx.dodecahedral_graph()
>>> shells = [[2, 3, 4, 5, 6], [8, 1, 0, 19, 18, 17, 16, 15, 14, 7], [9, 10, 11, 12, 13]]
>>> nx.draw_shell(G, nlist=shells, **options)

通過下面的方式可以將圖保存到文件

>>> nx.draw(G)
>>> plt.savefig("path.png")

4. Reference

Introduction

NetworkX源碼可以在網上看到，這個包提供的類涉及到了圖對象，創建標準圖的生成器，讀取已經存在的數據集的IO例程，分析結果網絡的算法，以及基本的繪圖工具。
大部分的NetworkX接口需要一個圖對象作爲參數，圖對象的方法被限制於基本的操作和輸出。
類的名字採用駱駝式命名法（每個單詞的首字母大寫）。函數，方法，和變量的名字採用小寫字母加下劃線分開。

NetworkX Basics

打開Python後，用下面推薦的方式導入networkx模塊。

>>> import networkx as nx

如果導入networkx失敗，表示Python沒有找到這個已經安裝的模塊，在Python的路徑下面檢查你的安裝。（如果安裝了pip，並且設置了環境變量，可以直接在CMD控制檯中執行指令pip install networkx）。
圖的內部的數據結構是基於鄰接表來表示，實現利用了Python的字典。

Graphs

使用networkx時首先需要選擇使用什麼類型的圖。一個圖(網絡)是結點集和邊集的集合。屬性可以和頂點或者邊連續在一起。

Nodes and Edges

接下來需要具體化一個圖，來決定你需要使用的結點和邊。

Graphs Creation

networkx圖對象可以用下面的三種方式來創造。
A. 圖生成器-利用標準的算法來創建網絡的拓撲。
B. 從已經存在的文件中導入數據
C. 顯示的添加邊和結點。
顯示添加/移除邊和頂點是最容易的方法，每一個圖對象都會提供方法來

>>> import networkx as nx
>>> G = nx.Graph()
>>> G.add_edge(1, 2)  # default edge data=1
>>> G.add_edge(2, 3, weight=0.9)  # specify edge data屬性可以是任意值。

邊的屬性可以是任意值

>>> import math
>>> G.add_edge('y', 'x', function=math.cos)
>>> G.add_node(math.cos)  # any hashable can be a node

一次可以添加多條表.

>>> elist = [(1, 2), (2, 3), (1, 4), (4, 2)]
>>> G.add_edges_from(elist)
>>> elist = [('a', 'b', 5.0), ('b', 'c', 3.0), ('a', 'c', 1.0), ('c', 'd', 7.3)]
>>> G.add_weighted_edges_from(elist)

Graph Reporting

主要是通過迭代器來遍歷邊或者頂點。直接給出官方說明。

Class views provide basic reporting of nodes, neighbors, edges and degree. These views provide iteration over the properties as well as membership queries and data attribute lookup. The views refer to the graph data structure so changes to the graph are reflected in the views. This is analogous to dictionary views in Python 3. If you want to change the graph while iterating you will need to use e.g. for e in list(G.edges):. The views provide set-like operations, e.g. union and intersection, as well as dict-like lookup and iteration of the data attributes using G.edges[u, v][‘color’] and for e, datadict in G.edges.items():. Methods G.edges.items() and G.edges.values() are familiar from python dicts. In addition G.edges.data() provides specific attribute iteration e.g. for e, e_color in G.edges.data(‘color’):.
The basic graph relationship of an edge can be obtained in two ways. One can look for neighbors of a node or one can look for edges. We jokingly refer to people who focus on nodes/neighbors as node-centric and people who focus on edges as edge-centric. The designers of NetworkX tend to be node-centric and view edges as a relationship between nodes. You can see this by our choice of lookup notation like G[u] providing neighbors (adjacency) while edge lookup is G.edges[u, v]. Most data structures for sparse graphs are essentially adjacency lists and so fit this perspective. In the end, of course, it doesn’t really matter which way you examine the graph. G.edges removes duplicate representations of undirected edges while neighbor reporting across all nodes will naturally report both directions.
Any properties that are more complicated than edges, neighbors and degree are provided by functions. For example nx.triangles(G, n) gives the number of triangles which include node n as a vertex. These functions are grouped in the code and documentation under the term algorithms.

Algorithms

networkx提供了很多圖算法，包括最短路徑，廣度優先搜索，聚類，同構算法已經其他一些算法。下面給出Dijkstra算法來求解最短路徑。

>>> G = nx.Graph()
>>> e = [('a', 'b', 0.3), ('b', 'c', 0.9), ('a', 'c', 0.5), ('c', 'd', 1.2)]
>>> G.add_weighted_edges_from(e)
>>> print(nx.dijkstra_path(G, 'a', 'd'))
['a', 'c', 'd']

Drawing

networkx並不是一個繪圖工具，他只提供了一個簡單的繪圖包的接口和一些簡單的佈局算法。需要畫圖時可以採用外部的程序或者導入Matplotlib包。

>>> import matplotlib.pyplot as plt
>>> G = nx.cubical_graph()
>>> plt.subplot(121)
<matplotlib.axes._subplots.AxesSubplot object at ...>
>>> nx.draw(G)   # default spring_layout
>>> plt.subplot(122)
<matplotlib.axes._subplots.AxesSubplot object at ...>
>>> nx.draw(G, pos=nx.circular_layout(G), nodecolor='r', edge_color='b')

Data Structure

NetworkX 使用字典詞典作爲基本的數據結構。

>>> G = nx.Graph()
>>> G.add_edge('A', 'B')
>>> G.add_edge('B', 'C')
>>> print(G.adj)
{'A': {'B': {}}, 'C': {'B': {}}, 'B': {'A': {}, 'C': {}}}

>>> G = nx.Graph()
>>> G.add_edge(1, 2, color='red', weight=0.84, size=300)
>>> print(G[1][2]['size'])
300
>>> print(G.edges[1, 2]['color'])
red

下面介紹實驗內容及其原理，實現參見github。

5. Centrality

1). 度中心性
在社會網絡中，對於具有更多連接關係的結點，度中心性度量方法認爲他們具有更高的中心性。可以利用結點的度來衡量連接關係。在無向圖中，結點vi的度中心性Cd是：
Cd(vi) = di。
其中di是結點vi的度（鄰接邊的數量）。在有向圖中，既可以利用入度或者初度，也可以將2者相結合起來作爲度中心性值：
Cd(vi) = diin(聲望)
Cd(vi) = diout(合羣性)
Cd(vi) = diin + diout
度中心性的歸一化

2). 特徵向量中心性
在度中心性度量中，我們認爲具有較多連接的結點更重要。然而在現實中，擁有更多朋友並不能確保這個人就是重要的，擁有更多重要的朋友才能提供更有力的信息。
因此，我們試圖用鄰居結點的重要性來概括本結點的重要性。設ce(vi)表示結點vi的特徵向量中心性，則其求解公式如下：

3). Katz中心性
在特徵向量中心性度量中，會有這麼一個問題：某個點被大量的關注，但是關注該點的點的中心性很低（甚至爲0），這樣會導致網絡中存在被大量關注但中心值卻爲0的點。因此，我們需要在特徵向量中心性度量的基礎上加入一個偏差項（或者說是中心值下限），來解決這個問題。

寫成矩陣形式爲：

4).PageRank
Katz在某些情況下存在一些與特徵向量中心性相似的問題。在有向圖中，一旦一個結點成爲一個權威結點（高中心值結點），它將向它所有的外連接傳遞其中心性，導致其它結點中心性變的很高。但這是不可取的，因爲不是每一個被名人所知的人都是有名的。
因此我們在katz中心性的基礎上，累加時讓每一個鄰居的中心性除以該鄰居結點的出度，這種度量稱爲PageRank：

5). betweenness
另一種中心性度量方法是考慮結點在連接其他結點時所表現出的重要性。其中一種方法是計算其他結點間通過結點vi的最短路徑的數目：

其中，segma st 是從結點s到結點t的最短路徑數目，segma st (vi) 是從s到t經過vi的最短路徑數目。也就是說，我們在度量結點vi在連接結點s和結點t時所表現的重要性。這種度量方法稱爲中間中心性（betweenness centrality）

6). closeness
接近中心性的思想是結點越趨於中心，它們越能快速地到達其他的結點。更形式化的描述，這些結點滿足與其他結點之間有最小的平均最短路徑。
接近中心性被定義爲：

6. Network Models

1). 隨機圖模型
隨機網絡（如ER模型），連接是隨機設置的，但大部分節點的連接數目會大致相同，即節點的分佈方式遵循鐘形的泊松分佈，有一個特徵性的“平均數”。連接數目比平均數高許多或低許多的節點都極少，隨着連接數的增大，其概率呈指數式迅速遞減。故隨機網絡亦稱指數網絡。

2). 小世界模型
在網絡理論中，小世界網絡是一類特殊的複雜網絡結構，在這種網絡中大部份的節點彼此並不相連，但絕大部份節點之間經過少數幾布就可到達。
在日常生活中，有時你會發現，某些你覺得與你隔得很“遙遠”的人，其實與你“很近”。小世界網絡就是對這種現象（也稱爲小世界現象）的數學描述。用數學中圖論的語言來說，小世界網絡就是一個由大量頂點構成的圖，其中任意兩點之間的平均路徑長度比頂點數量小得多。除了社會人際網絡以外，小世界網絡的例子在生物學、物理學、計算機科學等領域也有出現。
二十世紀60年代，美國哈佛大學社會心理學家斯坦利·米爾格倫（Stanley Milgram）做了一個連鎖信實驗。他將一些信件交給自願的參加者，要求他們通過自己的熟人將信傳到信封上指明的收信人手裏，他發現，20%的信件最終送到了目標人物手中。而在成功傳遞的信件中，平均只需要6.5次轉發，就能夠到達目標。也就是說，在社會網絡中，任意兩個人之間的“距離”是6。這就是所謂的“六度分隔”理論。
全局集聚係數(Global Clustering Coefficient)
全局集聚係數基於節點的三點組。一個三點組由三個節點組成，其中可以兩邊連接(爲閉三點組)或三邊連接(開三點組)，統稱連通三點組。
全局集聚係數是閉三點組個數(或三倍三角形個數)除以全部連通三點組個數。
該方法首次由Luce和Perry使用 (1949)。該指標指示了整個網絡的集聚程度，可被用於無方向和有向網絡。
定義：

局部集聚係數(Local Clustering Coefficient, Watts&Strogatz 1998)
對於每個節點i，ni是節點i的鄰居節點個數。

3). 優先鏈接模型
Albert-László Barabási 和Réka Albert爲了解釋冪律的產生機制，提出了無標度網絡模型（BA模型）。BA模型具有兩個特性，其一是增長性，所謂增長性是指網絡規模是在不斷的增大的，在研究的網絡當中，網絡的節點是不斷的增加的；其二就是優先連接機制，這個特性是指網絡當中不斷產生的新的節點更傾向於和那些連接度較大的節點相連接。BA模型對很多的現象都是可以解釋的，例如研究生對導師的選擇，在這個網絡當中，研究生和導師都是不斷增加的，而研究生總是傾向於選擇已經帶過很多研究生的導師。
這個模型基於兩個假設：
增長模式：不少現實網絡是不斷擴大不斷增長而來的，例如互聯網中新網頁的誕生，人際網絡中新朋友的加入，新的論文的發表，航空網絡中新機場的建造等等。
優先連接模式：新的節點在加入時會傾向於與有更多連接的節點相連，例如新網頁一般會有到知名的網絡站點的連接，新加入社羣的人會想與社羣中的知名人士結識，新的論文傾向於引用已被廣泛引用的著名文獻，新機場會優先考慮建立與大機場之間的航線等等。

7. SupervisedLearing

所有的源碼見github: 源碼