python相關系數設置閾值

『壹』 python相關性分析如何生成兩個相關性最強的兩門

方法/步驟

• 第一步我們首先需要知道相關性主要有兩個方向，一個是正方向一個是負方向，相關性系數是衡量兩個變數之間影響程度，如下圖所示：

  

『貳』 python 使用餘弦相似度計算之後如何設置一個閾值呢

找一個驗證集合，遍歷可能的閾值，計算評價指標，確定最佳閾值

『叄』 Python拾遺系列：numpy 如何將大於或小於閾值的值替換為給定的閾值

構造50個人的語文與數學的成績，平均成績為65分，標准差為20

『肆』 如何用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

『伍』 python非極大值抑制演算法的閾值越大越好還是越小越好，怎麼設

非極大值抑制（NMS），可理解為局部最大搜索，即搜索鄰域范圍內的最大值。行人檢測後期，對檢測出的窗口要執行非極大值抑制進行窗口的融合，從而過濾掉一些內部窗口等，達到窗口融合效果，從而使檢測的准確率更高！

『陸』 利用Python處理Excel數據

如果數據沒有標題行，可用pandas添加默認的列名

不讀取哪裡數據，可用skiprows=[i]，跳過文件的第i行不讀取

第一次出現的保留，其餘刪除

最後一次出現的保留，其餘刪除

** 對客戶聊天記錄進行分組 **

** 對符合多個條件進行分組**

需要對每一行進行權重設置，列錶行數少可行，過多不可行
假設有4行數據，設置采樣權重

自動生成數據的數量，均值，標准差等數據

相關系數在-1到1之間，接近1為正相關，接近-1為負相關，0為不相關

參考書籍：
《利用pythonj進行數據分析》
《從Excel到Python——數據分析進階指南》

『柒』 python里dataframe怎麼設置刻度

人工智慧原理與實踐 全面涵蓋人工智慧和數據科學各個重要體系經典
數據科學家最常用的數據表格工具當屬 pandas; 通過pandas表格，可以方便的展示表格（dataframe）和分析表格。而表格的格式設置不好，會影響分析效率。

所謂磨刀不誤砍柴工，工欲善其事必先利其器， 下面大家了解一下常用的幾種設置方法：

顯示更多行
顯示更多列
改變列寬
設置float列的精度
數字格式化顯示
更改繪圖方法
配置info()的輸出
列印出當前設置並重置所有選項
1. 顯示更多行
默認設置，pandas 是不超出屏幕的顯示範圍的，如果表的行數很多，它會截斷中間的行只顯示一部分。有些時候，如果需要查看的數據的總行數不多，可以通過設置display.max_rows來控制顯示的最大行數，比如設置顯示200行數據，從而一次性查看數據：

import pandas as pd
pd.set_option('display.max_rows', 200)
# 或者這樣設置
# pd.options.display.max_rows = 200
登錄後復制
但當數據的行數超過了display.max_rows，那麼display.min_rows將確定顯示的部分有多少行。因為display.min_rows的默認行數為10，因此數據一般顯示為前5行數據，和後5行數據。

同理，也可根據自己的習慣顯示可顯示的行數，比如20

pd.set_option('display.min_rows', 20)
# pd.options.display.min_rows = 20
登錄後復制
如果需要恢復默認的設置，可以這樣重置為默認情況：

# 重置
pd.reset_option('display.max_rows')
登錄後復制
2. 顯示更多列
行可以設置，同樣的列也可以設置，display.max_columns控制著可顯示的列數，默認值為20。

pd.get_option('display.max_columns')
# pd.options.display.max_columns
20
登錄後復制
3. 改變列寬
pandas對列中顯示的字元數有一些限制，默認值為50字元。所以，有的值字元過長就會顯示省略號。如果想全部顯示，可以設置display.max_colwidth，比如設置成500。

pd.set_option ('display.max_colwidth',500)
# pd.options.display.max_colwidth = 500
登錄後復制
4. 設置float列的精度
對於float浮點型數據，pandas默認情況下只顯示小數點後6位。我們可以通過預先設置display.precision讓其只顯示2位，避免後面重復操作。

pd.set_option( 'display.precision',2)
# pd.options.display.precision = 2
登錄後復制
這個設置不影響底層數據，它隻影響浮動列的顯示。

5. 數字格式化顯示
pandas中有一個選項display.float_formatoption可以用來格式化任何浮點列。這個僅適用於浮點列，對於其他數據類型，必須將它們轉換為浮點數才可以。

用逗號格式化大值數字
例如 1200000 這樣的大數字看起來很不方便，所以我們用逗號進行分隔。

pd.set_option('display.float_format','{:,}'.format)
登錄後復制
設置數字精度
和上面display.precision有點類似，假如我們只關心小數點後的2位數字，我們可以這樣設置格式化：

pd.set_option('display.float_format', '{:,.2f}'.format)
登錄後復制
百分號格式化
如果我們要顯示一個百分比的列，可以這樣設置。

pd.set_option('display.float_format', '{:.2f}%'.format)
登錄後復制
6. 更改繪圖方法
默認情況下，pandas使用matplotlib作為繪圖後端。從 0.25 版本開始，pandas提供了使用不同後端選擇，比如plotly，bokeh等第三方庫，但前提是你需要先安裝起來。

設置很簡單，只要安裝好三方庫後，同樣只需要一行。

import pandas as pd
import numpy as np
pd.set_option('plotting.backend', 'altair')
data = pd.Series(np.random.randn(100).cumsum())
data.plot()
登錄後復制
7. 配置info()的輸出
pandas中我們經常要使用info()來快速查看DataFrame的數據情況。但是，info這個方法對要分析的最大列數是有默認限制的，並且如果數據集中有null，那麼在大數據集計數統計時會非常慢。

pandas提供了兩種選擇：

display.max_info_columns: 設置要分析的最大列數，默認為100。
display.max_info_rows: 設置計數null時的閾值，默認為1690785。
登錄後復制
比如，在分析有 150 個特徵的數據集時，我們可以設置display.max_info_columns為涵蓋所有列的值，比如將其設置為 200：

pd.set_option('display.max_info_columns', 200)
登錄後復制
在分析大型數據集時，df.info()由於要計算所有null，導致速度很慢。因此我們可以簡單地設置display.max_info_rows為一個小的值來避免計數，例如只在行數不超過5時才計數null：

pd.set_option('display.max_info_rows', 5)
登錄後復制
8. 列印出當前設置並重置所有選項
pd.describe_option()將列印出設置的描述及其當前值。

pd.describe_option()
登錄後復制
還可以列印特定的選項，例如，行顯示。

# 具體的搜索
pd.describe_option('rows')
登錄後復制
最後，我們還可以直接全部重置。

pd.reset_option('all')
登錄後復制
總結
以上就是常用set_option的使用，大家可以一次性設置如下：

pd.set_option('display.max_rows',xxx) # 最大行數
pd.set_option('display.min_rows',xxx) # 最小顯示行數
pd.set_option('display.max_columns',xxx) # 最大顯示列數
pd.set_option ('display.max_colwidth',xxx) #最大列字元數
pd.set_option( 'display.precision',2) # 浮點型精度
pd.set_option('display.float_format','{:,}'.format) #逗號分隔數字
pd.set_option('display.float_format', '{:,.2f}'.format) #設置浮點精度
pd.set_option('display.float_format', '{:.2f}%'.format) #百分號格式化
pd.set_option('plotting.backend', 'altair') # 更改後端繪圖方式
pd.set_option('display.max_info_columns', 200) # info輸出最大列數
pd.set_option('display.max_info_rows', 5) # info計數null時的閾值
pd.describe_option() #展示所有設置和描述
pd.reset_option('all') #重置所有設置選項
登錄後復制

『捌』 3種python3的canny邊緣檢測之靜態，可調節和自適應

先看高級版的python3的canny的自適應邊緣檢測：

內容：

1 canny的邊緣檢測的介紹。

2 三種方法的canny的邊緣檢測，由淺入深地介紹：固定值的靜態，可自調節的，自適應的。

說明：

1 環境：python3.8、opencv4.5.3和matplotlib3.4.3。

2 圖片：來自品閱網正版免費圖庫。

3 實現自適應閾值的canny邊緣檢測的參考代碼和文章：

上述的代碼，本機均有報錯，故對代碼進行修改，注釋和運行。

初級canny：

1 介紹：opencv中給出了canny邊緣檢測的介面，直接調用：

即可得到邊緣檢測的結果ret，其中，t1，t2是需要人為設置的閾值。

2 python的opencv的一行代碼即可實現邊緣檢測。

3 Canny函數及使用：

4 Canny邊緣檢測流程：

去噪 --> 梯度 --> 非極大值抑制 --> 滯後閾值

5 代碼：

6 操作和過程：

7 原圖：

8 疑問：

ret = cv2.canny(img,t1,t2)，其中，t1，t2是需要人為設置的閾值，一般人怎麼知道具體數值是多少，才是最佳的呀？所以，這是它的缺點。

中級canny：

1 中級canny，就是可調節的閾值，找到最佳的canny邊緣檢測效果。

2 採用cv2.createTrackbar來調節閾值。

3 代碼：

4 操作和效果：

5 原圖：

高級canny：

1 自適應canny的演算法：

ret = cv2.canny(img,t1,t2)

即演算法在運行過程中能夠自適應地找到較佳的分割閾值t1，t2。

2 文件結構：

3 main.py代碼：

4 dog.py代碼：

5 bilateralfilt.py代碼：

6 原圖：

7 效果圖：本文第一個gif圖，此處省略。

小結：

1 本文由淺入深，總結的很好，適合收藏。

2 對於理解python的opencv的canny的邊緣檢測，很有幫助。

3 本文高級版canny自適應的演算法參考2篇文章，雖然我進行代碼的刪除，注釋，修改，優化等操作，故我不標注原創，對原作者表達敬意。

4 自己總結和整理，分享出來，希望對大家有幫助。

『玖』 python struct pack使用閾值問題

你不用在意。因為你pack的時候，應該不會使用這么大數的。大數到了C語言或者是其它語言里不會被識別 ，所以這種形情你不會用到。通常pack的時候，只會pack規定類型的整數。64位最大數大約是9223372036854775807。實際上大約超出14位左右的10進制數後，pack出來的結果就不對了。python對32位的處理很好。64位還有些問題。