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位还有些问题。