python設置對抗網路

1. 想要學人工智慧需要學些什麼python的知識

Python和人工智慧的關系及應用，以及想要學人工智慧的你，究竟需要學些什麼Python的知識，先來上兩張圖人工智慧和Python的圖。

2. Python的深度學習框架有哪些

中公教育聯合中科院專家打造的深度學習分八個階段進行學習：

第一階段AI概述及前沿應用成果介紹

• 深度學習的最新應用成果

• 單層/深度學習與機器學習

• 人工智慧的關系及發展簡

第二階段神經網路原理及TensorFlow實戰

• 梯度下降優化方法

• 前饋神經網路的基本結構和訓練過程

• 反向傳播演算法

• TensorFlow開發環境安裝

• 「計算圖」編程模型

• 深度學習中圖像識別的操作原理

第三階段循環神經網路原理及項目實戰

• 語言模型及詞嵌入

• 詞嵌入的學習過程

• 循環神經網路的基本結構

• 時間序列反向傳播演算法

• 長短時記憶網路（LSTM）的基本結構

• LSTM實現語言模型

第四階段生成式對抗網路原理及項目實戰

• 生成式對抗網路（GAN）的基本結構和原理

• GAN的訓練過程

• GAN用於圖片生成的實現

第五階段深度學習的分布式處理及項目實戰

• 多GPU並行實現

• 分布式並行的環境搭建

• 分布式並行實現

第六階段深度強化學習及項目實戰

• 強化學習介紹

• 智能體Agent的深度決策機制（上）

• 智能體Agent的深度決策機制（中）

• 智能體Agent的深度決策機制（下）

第七階段車牌識別項目實戰

• 數據集介紹及項目需求分析

• OpenCV庫介紹及車牌定位

• 車牌定位

• 車牌識別

• 學員項目案例評講

第八階段深度學習前沿技術簡介

• 深度學習前沿技術簡介

• 元學習

• 遷移學習等

詳情查看深度學習。

3. python tensorflow GAN對抗神經網路中生成網路部分

python是當下十分火爆的編程語言，尤其在人工智慧應用方面。如果有心從事編程方向的工作，最好到專業機構深入學習、多實踐，更貼近市場，這樣更有利於將來的發展。

4. 使用python對復雜網路進行模擬，其他都挺正常，聚類系數全顯示是0，如何破

復雜網路模擬 具體是做哪方面的呢？

5. 從零開始用Python構建神經網路

從零開始用Python構建神經網路
動機：為了更加深入的理解深度學習，我們將使用 python 語言從頭搭建一個神經網路，而不是使用像 Tensorflow 那樣的封裝好的框架。我認為理解神經網路的內部工作原理，對數據科學家來說至關重要。
這篇文章的內容是我的所學，希望也能對你有所幫助。
神經網路是什麼?
介紹神經網路的文章大多數都會將它和大腦進行類比。如果你沒有深入研究過大腦與神經網路的類比，那麼將神經網路解釋為一種將給定輸入映射為期望輸出的數學關系會更容易理解。
神經網路包括以下組成部分
? 一個輸入層，x
? 任意數量的隱藏層
? 一個輸出層，?
? 每層之間有一組權值和偏置，W and b
? 為隱藏層選擇一種激活函數，σ。在教程中我們使用 Sigmoid 激活函數
下圖展示了 2 層神經網路的結構(注意：我們在計算網路層數時通常排除輸入層)

2 層神經網路的結構
用 Python 可以很容易的構建神經網路類

訓練神經網路
這個網路的輸出 ? 為：

你可能會注意到，在上面的等式中，輸出 ? 是 W 和 b 函數。
因此 W 和 b 的值影響預測的准確率. 所以根據輸入數據對 W 和 b 調優的過程就被成為訓練神經網路。
每步訓練迭代包含以下兩個部分:
? 計算預測結果 ?，這一步稱為前向傳播
? 更新 W 和 b,，這一步成為反向傳播
下面的順序圖展示了這個過程：

前向傳播
正如我們在上圖中看到的，前向傳播只是簡單的計算。對於一個基本的 2 層網路來說，它的輸出是這樣的：

我們在 NeuralNetwork 類中增加一個計算前向傳播的函數。為了簡單起見我們假設偏置 b 為0：

但是我們還需要一個方法來評估預測結果的好壞(即預測值和真實值的誤差)。這就要用到損失函數。
損失函數
常用的損失函數有很多種，根據模型的需求來選擇。在本教程中，我們使用誤差平方和作為損失函數。
誤差平方和是求每個預測值和真實值之間的誤差再求和，這個誤差是他們的差值求平方以便我們觀察誤差的絕對值。
訓練的目標是找到一組 W 和 b，使得損失函數最好小，也即預測值和真實值之間的距離最小。
反向傳播
我們已經度量出了預測的誤差(損失)，現在需要找到一種方法來傳播誤差，並以此更新權值和偏置。
為了知道如何適當的調整權值和偏置，我們需要知道損失函數對權值 W 和偏置 b 的導數。
回想微積分中的概念，函數的導數就是函數的斜率。

梯度下降法
如果我們已經求出了導數，我們就可以通過增加或減少導數值來更新權值 W 和偏置 b(參考上圖)。這種方式被稱為梯度下降法。
但是我們不能直接計算損失函數對權值和偏置的導數，因為在損失函數的等式中並沒有顯式的包含他們。因此，我們需要運用鏈式求導發在來幫助計算導數。

鏈式法則用於計算損失函數對 W 和 b 的導數。注意，為了簡單起見。我們只展示了假設網路只有 1 層的偏導數。
這雖然很簡陋，但是我們依然能得到想要的結果—損失函數對權值 W 的導數(斜率)，因此我們可以相應的調整權值。
現在我們將反向傳播演算法的函數添加到 Python 代碼中

為了更深入的理解微積分原理和反向傳播中的鏈式求導法則，我強烈推薦 3Blue1Brown 的如下教程：
Youtube：https://youtu.be/tIeHLnjs5U8
整合並完成一個實例
既然我們已經有了包括前向傳播和反向傳播的完整 Python 代碼，那麼就將其應用到一個例子上看看它是如何工作的吧。

神經網路可以通過學習得到函數的權重。而我們僅靠觀察是不太可能得到函數的權重的。
讓我們訓練神經網路進行 1500 次迭代，看看會發生什麼。 注意觀察下面每次迭代的損失函數，我們可以清楚地看到損失函數單調遞減到最小值。這與我們之前介紹的梯度下降法一致。

讓我們看看經過 1500 次迭代後的神經網路的最終預測結果：

經過 1500 次迭代訓練後的預測結果
我們成功了!我們應用前向和方向傳播演算法成功的訓練了神經網路並且預測結果收斂於真實值。
注意預測值和真實值之間存在細微的誤差是允許的。這樣可以防止模型過擬合並且使得神經網路對於未知數據有著更強的泛化能力。
下一步是什麼?
幸運的是我們的學習之旅還沒有結束，仍然有很多關於神經網路和深度學習的內容需要學習。例如：
? 除了 Sigmoid 以外，還可以用哪些激活函數
? 在訓練網路的時候應用學習率
? 在面對圖像分類任務的時候使用卷積神經網路
我很快會寫更多關於這個主題的內容，敬請期待!
最後的想法
我自己也從零開始寫了很多神經網路的代碼
雖然可以使用諸如 Tensorflow 和 Keras 這樣的深度學習框架方便的搭建深層網路而不需要完全理解其內部工作原理。但是我覺得對於有追求的數據科學家來說，理解內部原理是非常有益的。
這種練習對我自己來說已成成為重要的時間投入，希望也能對你有所幫助

6. 如何使用python設置無線網路連接共享屬性

這里必須要手動去設置，用的就是cmd，widows自帶的命令開wifi。

7. 如何用python實現《多社交網路的影響力最大化問題分析》中的演算法

經過一周，現已初步完成，其中多出代碼不夠美觀以及效率不高，還請指點
# _*_ coding:utf-8 _*_
# ==================================================================================
#
# Description: Influence Maximization on Multiple Social Networks
#
# ==================================================================================
import matplotlib.pyplot as plt
import networkx as nx
import heapq

#總圖
G = nx.DiGraph()

def load_graph(file):
'''
載入文件為列表格式,並得到G,畫出圖結構
'''

#將總列表設成全局格式
global gllist

#迭代文件中每個元素
with open(file) as f:
lines = f.readlines()
mylist = [line.strip().split() for line in lines]

gllist = []
#將字元串型轉換為整型
for i in mylist:
gllist.append(i[:-2]+map(lambda x: float(x), i[-2:]))
print '初始全局列表:'
print gllist

drawlist=[]
#提取二維列表mylist每行前三個元素,賦給新的列表drawlist
for i in range(len(mylist)):
drawlist.append([])
for j in range(3):
drawlist[i].append(mylist[i][j])
#將列表drawlist載入為有向加權圖
G.add_weighted_edges_from(drawlist)
nx.draw(G, with_labels=True, width=1, node_color='y', edge_color='b')
plt.show()
print 'G圖中所有節點:',G.nodes()
print 'G圖中所有邊:',G.edges()
print '\n'

def get_self_node(gllist, target=None):
'''
獲取目標節點的自傳播節點,返回selflist並包含目標節點
'''
#初始化自傳播節點列表
selflist = [target]

#存放已傳播節點列表
haslist = []

flag = 0

while (flag != 0):
flag = 0
for target in selflist:
if target not in haslist:
for i in range(len(gllist)):
#判斷二維列表中,每行第三個元素是否為1,若為1，則為自傳播節點
if ((gllist[i][0] == target)or(gllist[i][1]==target))and(gllist[i][3]==1.0):
if gllist[i][0] == target:
if gllist[i][1] not in haslist:
selflist.append(gllist[i][1])
haslist.append(gllist[i][1])
flag += 1
else:
if gllist[i][0] not in haslist:
selflist.append(gllist[i][0])
haslist.append(gllist[i][0])
flag += 1
#去除重復元素
haslist = set(haslist)
selflist = set(selflist)

#去除重復元素
selflist = set(selflist)
return selflist

def longest_path(gllist,source=None,target=None):
'''
獲取起始點到實體的最大路徑集合,返回為longestpath列表
'''
longestpath = []
newlist = []
for i in range(len(gllist)):
newlist.append([])
for j in range(3):
newlist[i].append(gllist[i][j])
#構建圖結構
G1 = nx.DiGraph()
#添加帶權有向邊
G1.add_weighted_edges_from(newlist)
#獲取目標節點的所有自傳播街邊,並存入selflist中
selflist = get_self_node(gllist, target)
max_path = 0
val_path = 1
#獲取初始節點到目標節點及目標節點的自傳播節點的最大路徑
for v in selflist:
if v != source:
#遍歷兩點之間所有路徑,並進行比對
for path in nx.all_simple_paths(G1,source=source,target=v):
#判斷路徑後兩個元素是否為相同實體（如：b1->b2）
if is_self_transmit_node(path[-2], v) == 0:
for i in range(0, len(path)-1):
val_path *= G1.get_edge_data(path[i], path[i+1])['weight']
if max_path < val_path:
max_path = val_path
val_path = 1
#若目標節點為起始節點則直接跳出
else: continue ############ 有待商榷 ##############
longestpath.append(max_path)
#返回初始節點到實體的最大路徑
return longestpath

def is_self_transmit_node(u, v):
'''
判斷目標節點不為起始節點的自傳播點
'''
flag = 0
#獲得起始節點的所有自傳播點
selflist = get_self_node(gllist, v)
for x in selflist:
if u == x:
flag = 1
return flag

def single_strong_infl(longestpath):
'''
計算起始點到實體的傳播概率（影響強度）,返回影響強度stronginfl
'''
temp = 1
for x in longestpath:
temp *= 1-x
stronginfl = 1-temp
return stronginfl

def all_strong_infl(G):
'''
獲得每個節點對實體的影響概率
'''
allstrong = [] #初始化所有節點的加權影響范圍列表
gnodes = [] #初始化節點列表
tempnodes = [] #初始化臨時節點列表

gnodes = G.nodes()

for u in gnodes:
strong = 0 #存儲初始節點對每個實體的影響范圍加權，初始化為0
#重置臨時節點列表
tempnodes = G.nodes()
for v in tempnodes:
#非自身節點
if u != v:
#判斷目標節點不為起始節點的自傳播點
if is_self_transmit_node(v, u) == 0:
#獲取起始節點到實體間最大加權路徑，並存入longestpath
longestpath = longest_path(gllist, u, v)

#去除已遍歷目標節點的所有自傳播節點
renode = get_self_node(gllist, v)
for x in renode:
if x != v:
tempnodes.remove(x)

#計算起始節點到實體間傳播概率（影響強度）
stronginfl = single_strong_infl(longestpath)
strong += stronginfl

#添加單個節點到所有實體的加權影響范圍
allstrong.append([u, round(strong, 2)])

#返回每個節點到所有實體的加權影響范圍
return allstrong
#output allstrong : [['a1', 2.48], ['a2', 1.6880000000000002], ['b1', 0.7], ['b2', 0], ['c1', 0], ['d2', 0.6]]

def uS_e_uppergain(u, ev, S):
'''
獲取節點u在集合S的基礎上對實體ev的影響增益, 傳入候選節點,上界gain(u|S, ev)
'''

#獲取目前實體的所有自傳播節點
selflist = get_self_node(gllist, ev)
stronglist = []
#遍歷自傳遍節點
for v in selflist:
'''
判斷節點v是否存在種子集合S中
其中v為單個節點,如v(ev, Gi)
S為種子節點集合,如['a1','a2','b1','b2','c1','d2']
'''
if v in S:
ppSv = 1
else:
longestpath = []
#遍歷種子集合
for s in S:

#初始化路徑權值與最大路徑權值
val_path = 1
max_path = 0

#遍歷兩點之間所有路徑，並進行比對
for path in nx.all_simple_paths(G,source=s,target=v):
#判斷路徑後兩個元素是否為相同實體（如：b1->b2）
if is_self_transmit_node(path[-2], v) == 0:
for i in range(0, len(path)-1):
val_path *= G.get_edge_data(path[i], path[i+1])['weight']
if max_path < val_path:
max_path = val_path
#重置路徑權值為1
val_path = 1
#將最大加權路徑存入longestpath列表
longestpath.append(max_path)
#得到上界pp(S,v)的影響概率,上界pp(S,v)
ppSv = single_strong_infl(longestpath)

stronglist.append(ppSv)
#得到上界pp(S,ev)的影響概率,上界pp(S,ev)
ppSev = single_strong_infl(stronglist)

#獲取pp(u,ev)
ppuev = single_strong_infl(longest_path(gllist, u, ev))

#計算上界gain(u|S，ev)
uSevgain = (1 - ppSev) * ppuev
return uSevgain

def uppergain(u, emu, ems, S):
'''
在已有種子集合S的基礎上,求得節點u的影響增益上界,
其中傳進參數ems為二維列表,如[['a1',2.48],['a2',1.688]],S則為['a1','a2']
'''
uSgain = 0.0
#遍歷emu得到列表形式,得到如['a1',2.48]形式
for ev in emu:
#判斷節點是否存在種子集合中
if ev[0] in S:
uSgain += uS_e_uppergain(u, ev[0], S)
else:
uSgain += ev[1]

#返回上界gain(u|S)
return uSgain

def bound_base_imms(G, k):
'''
完全使用影響增益上界的方式選擇top-k個種子節點的過程
'''
#初始化emu,H,初始化ems=空集,S=空集

Htemp = []
Htemp = all_strong_infl(G)
H = []
#遍歷Htemp=[['a1',2.48],['a2',1.688]],得到如['a1',2.48]形式
for x in Htemp:
#逐個獲取二維列表中每一行，形式為['a1',2.48,0]
H.append([x[0],x[1],0])

emu = []
emu = all_strong_infl(G)

ems = []
S = []

for i in range(k):

#提取堆頂元素,tnode的形式為['a1',2.48,0]
tnode = heapq.nlargest(1, H, key=lambda x: x[1])
#將[['b2', 3.1, 0]]格式改為['b2', 3.1, 0]格式
tnode = sum(tnode, [])

while (tnode[2] != i):
gain = 0.0
#獲取節點u的影響增益上界
gain = uppergain(tnode, emu, ems, S)
#賦值影響范圍
tnode[1] = gain
#修改status
tnode[2] = i

#對堆進行排序
H = heapq.nlargest(len(H), H, key=lambda x: x[1])

#獲取堆頂元素
tnode = heapq.nlargest(1, H, key=lambda x: x[1])
tnode = sum(tnode, [])

#添加node到種子集合
S.append([tnode[0]])
#更新ems,添加新節點及節點對每個實體的影響范圍加權
ems.append([tnode[0], tnode[1]])

#刪除堆頂元素
H.remove(tnode)
print ems
return sum(S, [])

if __name__=='__main__':

#大小為k的種子集合S
k = 60

#載入文件數據,得到圖G和初始列表gllist
load_graph('test.txt')

#完全使用影響增益上界值的計算過程函數,列印種子集合S
print '種子集合:',bound_base_imms(G, k)

test.txt
a1 b1 0.2 0
a1 c1 0.8 0
a2 b2 0.4 0
a2 d2 1 0
b1 c1 0.7 0
c2 a2 0.8 0
d2 b2 0.6 0
a1 a2 1 1
a2 a1 0.1 1
....
a1 l1 0.5 0
a1 m1 0.5 0
a1 q1 0.5 0
a1 v1 0.5 0
a1 z1 0.5 0
a1 s1 0.5 0
a1 w1 0.5 0
a1 u1 0.5 0
其中前兩列為傳播實體，第三列為實體間傳播概率，最後一列為0代表同一網路傳播，為1代表網路間自傳播。
下來要進行優化：
1.採用獨立級聯模型，設置閾值
2.將最大路徑改為最短路徑，利用log

8. 如和用python構建異構網路

異構網路(Heterogeneous Network）是一種類型的網路，其是由不同製造商生產的計算機，網路設備和系統組成的，大部分情況下運行在不同的協議上支持不同的功能或應用。

所謂異構是指兩個或以上的無線通信系統採用了不同的接入技術，或者是採用相同的無線接入技術但屬於不同的無線運營商。利用現有的多種無線通信系統，通過系統間融合的方式，使多系統之間取長補短是滿足未來移動通信業務需求一種有效手段，能夠綜合發揮各自的優勢。

python其實是一種開發語言，他可以開發運行在這些異構網路硬體上的軟體。爬蟲什麼的就是現成的例子。

9. python最佳入門教程(1): python的安裝

本教程基於python3.x, 是針對初學者的一系列python入門教程，在知乎上常有人問我計算機該怎麼學，如何自學編程，筆者也是通過自學編程而進入IT這一行業的，回顧入行的這幾年，從音視頻流媒體輾轉到人工智慧深度學習，機器視覺，我是下了不少苦心的，對於如何學習有自己的一套理論和實踐方法，很多人自言學編程不得其門，把學不會歸咎於天分，其實芸芸眾生，智力無別，你現在所看到的是技術大牛們一個個超凡絕頂(然知此絕頂非彼絕頂)，看不到的是曾經的他們，也在每個晝夜裡用心苦學。再者學一門技術，需要勤學刻苦，是需要講究方法和基礎的，方法對了就事半功倍，所謂的天才也無不是建立在扎實的基礎之上。
在windows中安裝python
首先打開python官網https://www.python.org/，點擊頁面downloads導航按鈕，下載windows最新的基於web安裝的安裝器，右鍵以管理員身份運行 安裝包，會出現如下界面：
將Add Python 3.7 to PATH 進行勾選，勾選此項的目的在於將python解釋器加入系統環境變數，則在後續的python開發中可直接在windows 命令行中執行python腳本。所謂的環境變數是系統運行環境的一系列參數，比如這里的系統環境變數是PATH，PATH保存了與路徑相關的參數，系統在路徑查找中，會對PATH保存的路徑進行搜索。
點擊install Now按鈕執行python的安裝
打開windows命令行界面(按windows鍵輸入cmd命令),輸入python -V，出現python版本的相關輸出，即表示安裝成功。
在Linux系統中安裝python
筆者的系統是CentOS, Linux系統默認有安裝python,但是其版本是2.x,在這里筆者以源碼安裝的形式來安裝python 3.X。首先進入python源碼包頁面 點擊下載最新的gzip格式的python源碼包，上傳到伺服器然後進行解壓，解壓後的目錄結構如下圖所示：
Linux中的configure與make
configure是Linux中的腳本配置工具，用來對源碼的當前安裝環境進行檢測，若檢測無誤，會在當前目錄生成一個供源碼編譯的Makefile腳本文件。
make是Linux系統下的編譯安裝工具，用來解釋執行makefile文件中的腳本命令，編譯命令。
現在我們開始編譯安裝python
(1) 在當前目錄執行./configure(2) 輸入 make && sudo make install
若無指定安裝目錄，python會被默認安裝在/usr/local目錄中, 讀者可以執行./configure --prefix=「你自定義的安裝目錄」來配置安裝路徑。安裝完畢以後進入/usr/local/bin目錄，輸入 「python3.x -V」 (這里的python3.x為你所安裝的python版本)，若出現與python版本的相關輸出，即表示安裝成功。
為安裝的python設置軟鏈接
安裝的python可以以絕對路徑的方式來執行，每次敲一大段路徑來執行python未免麻煩，通常我們會給安裝的python設置軟鏈接，這里的軟鏈接類似於windows的快捷方式。
輸入以下命令來給python設置軟鏈接,筆者安裝的版本是python3.7, pip是python的包管理工具，會在教程的後續章節中進行詳細講解。
ln -s /usr/bin/python3 /usr/local/bin/python3.7 # 表示設置python3 為 /usr/local/bin/python3.7的快捷方式ln -s /usr/bin/pip3 /usr/local/bin/pip3.7 # 表示設置pip3 為 /usr/local/bin/pip3.7的快捷方式