如何用python实现《多社交网络的影响力最大化问题分析》中的算法

经过一周，现已初步完成，其中多出代码不够美观以及效率不高，还请指点

# __ coding:utf-8 __

# ==================================================================================

#

# Description: Influence Maximization on Multiple Social Networks

#

# ==================================================================================

import matplotlibpyplot as plt

import networkx as nx

import heapq

#总图

G = nxDiGraph()

def load_graph(file):

'''

加载文件为列表格式,并得到G,画出图结构

'''

#将总列表设成全局格式

global gllist

#迭代文件中每个元素

with open(file) as f:

lines = freadlines()

mylist = [linestrip()split() for line in lines]

gllist = []

#将字符串型转换为整型

for i in mylist:

gllistappend(i[:-2]+map(lambda x: float(x), i[-2:]))

print '初始全局列表:'

print gllist

drawlist=[]

#提取二维列表mylist每行前三个元素,赋给新的列表drawlist

for i in range(len(mylist)):

drawlistappend([])

for j in range(3):

drawlist[i]append(mylist[i][j])

#将列表drawlist加载为有向加权图

Gadd_weighted_edges_from(drawlist)

nxdraw(G, with_labels=True, width=1, node_color='y', edge_color='b')

pltshow()

print 'G图中所有节点:',Gnodes()

print 'G图中所有边:',Gedges()

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]==10):

if gllist[i][0] == target:

if gllist[i][1] not in haslist:

selflistappend(gllist[i][1])

haslistappend(gllist[i][1])

flag += 1

else:

if gllist[i][0] not in haslist:

selflistappend(gllist[i][0])

haslistappend(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)):

newlistappend([])

for j in range(3):

newlist[i]append(gllist[i][j])

#构建图结构

G1 = nxDiGraph()

#添加带权有向边

G1add_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 nxall_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 = G1get_edge_data(path[i], path[i+1])['weight']

if max_path < val_path:

max_path = val_path

val_path = 1

#若目标节点为起始节点则直接跳出

else: continue ############ 有待商榷 ##############

longestpathappend(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 = Gnodes()

for u in gnodes:

strong = 0 #存储初始节点对每个实体的影响范围加权，初始化为0

#重置临时节点列表

tempnodes = Gnodes()

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:

tempnodesremove(x)

#计算起始节点到实体间传播概率（影响强度）

stronginfl = single_strong_infl(longestpath)

strong += stronginfl

#添加单个节点到所有实体的加权影响范围

allstrongappend([u, round(strong, 2)])

#返回每个节点到所有实体的加权影响范围

return allstrong

#output allstrong : [['a1', 248], ['a2', 16880000000000002], ['b1', 07], ['b2', 0], ['c1', 0], ['d2', 06]]

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 nxall_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 = Gget_edge_data(path[i], path[i+1])['weight']

if max_path < val_path:

max_path = val_path

#重置路径权值为1

val_path = 1

#将最大加权路径存入longestpath列表

longestpathappend(max_path)

#得到上界pp(S,v)的影响概率,上界pp(S,v)

ppSv = single_strong_infl(longestpath)

stronglistappend(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',248],['a2',1688]],S则为['a1','a2']

'''

uSgain = 00

#遍历emu得到列表形式,得到如['a1',248]形式

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',248],['a2',1688]],得到如['a1',248]形式

for x in Htemp:

#逐个获取二维列表中每一行，形式为['a1',248,0]

Happend([x[0],x[1],0])

emu = []

emu = all_strong_infl(G)

ems = []

S = []

for i in range(k):

#提取堆顶元素,tnode的形式为['a1',248,0]

tnode = heapqnlargest(1, H, key=lambda x: x[1])

#将[['b2', 31, 0]]格式改为['b2', 31, 0]格式

tnode = sum(tnode, [])

while (tnode[2] != i):

gain = 00

#获取节点u的影响增益上界

gain = uppergain(tnode, emu, ems, S)

#赋值影响范围

tnode[1] = gain

#修改status

tnode[2] = i

#对堆进行排序

H = heapqnlargest(len(H), H, key=lambda x: x[1])

#获取堆顶元素

tnode = heapqnlargest(1, H, key=lambda x: x[1])

tnode = sum(tnode, [])

#添加node到种子集合

Sappend([tnode[0]])

#更新ems,添加新节点及节点对每个实体的影响范围加权

emsappend([tnode[0], tnode[1]])

#删除堆顶元素

Hremove(tnode)

print ems

return sum(S, [])

if __name__=='__main__':

#大小为k的种子集合S

k = 60

#加载文件数据,得到图G和初始列表gllist

load_graph('testtxt')

#完全使用影响增益上界值的计算过程函数,打印种子集合S

print '种子集合:',bound_base_imms(G, k)

testtxt

a1 b1 02 0

a1 c1 08 0

a2 b2 04 0

a2 d2 1 0

b1 c1 07 0

c2 a2 08 0

d2 b2 06 0

a1 a2 1 1

a2 a1 01 1

a1 l1 05 0

a1 m1 05 0

a1 q1 05 0

a1 v1 05 0

a1 z1 05 0

a1 s1 05 0

a1 w1 05 0

a1 u1 05 0

其中前两列为传播实体，第三列为实体间传播概率，最后一列为0代表同一网络传播，为1代表网络间自传播。

下来要进行优化：

1采用独立级联模型，设置阈值

2将最大路径改为最短路径，利用log

观察图像的TE和TR值可区分，TE短可为20ms，长可为80ms，TR短可为600ms，长可为3000ms。

短TE,短TR为T1加权像

TE,TR均长的T2加权像，

短TE,长TR者为质子密度加权像。

了解水和脂肪的信号特征有助于区分T1加权像和T2加权像，特别是在图像没有显示特征性的TE和TR值时更有价值。

观察液体结构如脑室、膀腕或脑脊液，若液体是亮的，很可能为T2加权像，若液体是暗的，则可能为T1加权像。若液体

是亮的，而其他结构不像是T2加权像，且TR和TE均短，则可能是梯度回波图像。

#include "stdioh" //库包含，不用说吧

#include "mathh"

void sstf(int current,int queue,int len)

{

int i=0,j=0,count=0,sum=0,min=0; //i记录数组位置，j用在下边的比较中,用queue[j]和当前位置current计算路径长度

//sum表示总路径长度,min用来记录步最小路径

while(1){

if(count ==len )break;

i=0;

while(queue[i]==-1){i++;} //若为-1就跳过，在下边有，是为了做到不重复

min = abs(current-queue[i]); //当前位置到数组中i位置的路径的绝对长度

for(j=i+1;j<len;j++){ //从i的下一个位置开始找出这一步的最短路径

if(queue[j]==-1)continue; //这个不用看了，若为-1就跳过，在下边有，是为了做到不重复

if(abs(current-queue[j])<min){ //用穷举比较的方法找到最短路径

min =abs(current-queue[j]);

i=j;

}//if end

} //for end

printf("%d\n",queue[i]); //屏显第i个位置

sum=sum+abs(current-queue[i]); //这一步的长度加到总长度中

current=queue[i]; //改写当前位置

queue[i]= -1; //把当前值赋为-1，下一次比较重跳过

count++;

}//while end

printf("sum=%d\n",sum); //屏显最短路径总长

printf("average=%f\n",sum10/len); //屏显平均长度

}

main()

{

int current=100; //设定初始的当前位置

int queue[9]={55,58,39,18,90,160,150,38,184};//磁盘位置

sstf(current,queue,9); //调用函数计算最短路径

}

以上就是关于如何用python实现《多社交网络的影响力最大化问题分析》中的算法全部的内容，包括:如何用python实现《多社交网络的影响力最大化问题分析》中的算法、如何区分T1加权图像和T2加权图像、C语言编程，求解非加权无向图（简单图）的平均路径长度等相关内容解答，如果想了解更多相关内容，可以关注我们，你们的支持是我们更新的动力！