深度学习中合作网络

Posted 2021-09-08 Coding With you.....

1.数据预处理，进行深度学习预测

将数据进一步处理成可以输入模型中的数据：先将文本填充成固定长度；将标签转化为one-hot编码表示。

2.合作网络

定义：论文、作者等等的网络，实际上共现网络

存储：节点列表、边列表可以作为G.add_nodes_from()、G.add_edges_from()的输入，带权重的边列表可以作为networkx中G.add_weighted_edges_from()方法的输入。节点列表、合作矩阵（邻接矩阵）、边列表、邻接表还可以作为各种网络绘制软件的输入数据，比如Ucinet、Gephi。

代码  co_list是数据集整个的
（1）生成网络

if __name__ =='__main__' :

    
    # 1.获取节点列表
    author_list = get_nodes(co_list,0) #数据集中第一列表示作者
    # 2.合作矩阵（类似于邻接矩阵）
    get_cooperate_matrix(author_list,0)

（2）获取节点

def get_nodes(co_list,col):
	
    nodes_list = []
    for authors in co_list:
        auths = authors[col].split("，") # 作者之间分隔符，在一篇文章中作者之间
        for auth in auths:
            if auth not in nodes_list: # 去重
                nodes_list.append(auth)
    return nodes_list

（3）合作矩阵，可以理解为邻接表---------可以构造无权网络

def get_cooperate_matrix1(rows,nodes_list,col):
    '''
        rows: 形如co_list的所有用来构建合作网络的数据行
        nodes_list: 节点列表
        col: 节点共现信息所在列数-1
    '''

    length = len(nodes_list)
    cooperate_list = []
    # 遍历作者名,计数和各作者合作数(每次合作对自己也计数)
    for node in nodes_list:
        node_co = []
        node_co.append(node)
    # 合作列表：初始化为长度为节点个数的全零列表[name,0,0,0,...,0,0]
        for i in range(length):
            node_co.append(0) 
    # 遍历所有数据行,对作者字段进行匹配
        for row in rows:
            nodes = row[col].split(" | ") # 分隔符按数据结构选
    # 对包含当前节点的数据项,提取共现关系(合作列表对应位置+1)
            if node in nodes:
                for each_node in nodes:
                # 索引共现的节点编号,确定在合作列表中的位置
                    node_index = nodes_list.index(each_node)+1 
                # 对应位置+1
                    node_co[node_index] = node_co[node_index] + 1 
    # 添加到合作矩阵列表中
        cooperate_list.append(node_co)

    # 1. 生成合作矩阵：cooperate_mat
    cooperate_mat = []
    first_line = ['']
    first_line.extend(nodes_list)
    cooperate_mat.append(first_line) # 第一行,第一列为标题(出现的作者名)
    cooperate_mat.extend(cooperate_list)

    return cooperate_mat

（4）共现矩阵-----和每一个作者共现的次数，对角线为一共有几篇论文数

边列表
# 2. 边列表(输入原始数据行)
def get_edges(co_list,col=0):
    ''' （Newest）co_list: 二维列表/一维列表
        col: 节点所在列数，默认为第一列（仅二维列表用到此参数）
        返回值：边列表,[[企业1,企业2],...]
    '''
    edge_list = []
    num = 1
    for authors in co_list:
        if type(authors)==list: # 输入为二维列表
            auths = authors[col].split(" | ")
        else: # 输入为一维列表
            auths = authors.split(" | ")
            auths = sorted(auths)
        # 边
        length = len(auths)
        for i in range(length-1):
            for j in range(i+1,length):
                edge_list.append([auths[i],auths[j]])
    
    return edge_list




共现矩阵
def get_cooperate_matrix2(nodes_list,edge_list):
    '''
        nodes_list:节点列表
        edge_list: 边列表
    '''
    length = len(nodes_list)
    cooperate_list = []

    for node in nodes_list:
        node_co = []
        node_co.append(node)
    # 合作列表：初始化为长度为节点个数的全零列表[node,0,0,0,...,0,0]
        for i in range(length):
            node_co.append(0) 
    # 遍历所有边,对节点进行匹配
        for edge in edge_list: 
    # 对包含当前节点的边,提取共现关系(合作列表对应位置+1)。对角线上为当前节点总次数。
            if node in edge:
                for each_node in edge:
                # 索引节点编号,确定在合作列表中的位置
                    node_index = nodes_list.index(each_node)+1 
                # 对应位置+1
                    node_co[node_index] = node_co[node_index] + 1 
        cooperate_list.append(node_co)

    # 合并各节点数据，生成合作矩阵。
    cooperate_mat = []
    first_line = ['']
    first_line.extend(nodes_list)
    cooperate_mat.append(first_line)
    cooperate_mat.extend(cooperate_list)

    return cooperate_mat

（5）有权的邻接矩阵：根据节点列表和边权重列表实现

生成边-权重 列表
def get_weighted_links(edges_list):
    ''' edges_list：是包含边列表的矩阵,[[节点1,节点2],...],边可以重复,重复次数记为权重
        返回值：带权重的边列表,[[节点1,节点2,weight],...]
    '''
    weighted_links = []
    exist_links = []
    for link in edges_list:
        if link not in exist_links:
            exist_links.append(link)
            _link = deepcopy(link)  # 深拷贝
            _link.append(1)  
            weighted_links.append(_link)
        else:
            index = exist_links.index(link) 
            weighted_links[index][2] = weighted_links[index][2] + 1 
    return weighted_links

矩阵
def get_adjacency_matrix(node_list,weighted_links):
    '''
        nodes_list:节点列表(sorted)
        edge_list: 边-权重列表
    '''
     # 初始化adjacency_mat为全零矩阵
    adjacency_mat = [[0 for val in range(len(node_list))] for val in range(len(node_list))]

    for x, y, val in weighted_links:
        i = node_list.index(x) + 1
        j = node_list.index(y) + 1
        adjacency_mat[i][j] = adjacency_mat[j][i] =  val
    return adjacency_mat

3.前20个度最大的节点构成的网络。每条数据对应一个id,id为节点，度为权重---节点名称为数据中的名字这列

# 这段代码需要满足以下两个要求：
# 1.计算每个节点的度数，输出度数最大的前20个节点及其度数（允许并列存在）
# 2.计算节点度数的分布并作出一个线性图表：其中x轴代表了度数（合作过的次数），y轴代表了节点数（演员数）


edge = {"actor1": None, "actor2": None, "num_movies": None}
# 将边edge表示成字典型，其有三个键值对，分别代表边的三个属性

node = {"id": None, "name": None, "movies_95_04": None, "main_genre": None, "genres": None}
# 将节点node表示成字典型，其有五个键值对，分别代表节点（演员）的五个属性

node_xy = {"degree": None, "node_number": None}
# 将节点度数和节点数表示成字典型，其中degree在图像中为x轴，node_number在图像中为y轴


# 定义一个将边edge的数据储存在数组中的函数read_edge，实现读取录入的操作
def read_edge(file):
    edge_list = list()
    with open(file, 'r', encoding='utf-8') as f:  # 以只读模式，用utf-8编码方式打开文件
        line = f.readline()
        while line:
            line = f.readline()
            if line:
                a = line.split('\\t')
                edge_list.append({"actor1": a[0], "actor2": a[1], "num_movies": a[2]})
    return edge_list


# 定义一个将节点node的数据储存在集合中的函数read_node，实现读取录入的操作
def read_node(file):
    nodes = dict()
    with open(file, 'r', encoding='utf-8') as f:  # 以只读模式、用utf-8编码方式打开文件
        line = f.readline()
        while line:
            line = f.readline()
            if line:
                a = line.split('\\t')
                nodes[a[0]] = {"name": a[1], "movies_95_04": a[2], "main_genre": a[3], "genres": a[4], "degree": 0}
        return nodes


# 定义将所得度数进行排序的函数sort
def sort(nodes: dict):
    node_degree = list()
    for node_id, value in nodes.items():
        node_degree.append({'ID': node_id, 'degree': value['degree']})
    node_degree.sort(key=lambda node : node['degree'], reverse=True)
    t = list()
    num = 0
    for n in node_degree:  # 筛选出度数最大的20个节点
        if num < 20:
            t.append(n)
        else:
            if n['degree'] == t[19]['degree'] :
                t.append(n)
        num = num + 1
    return t

# 计算单个点度数的函数degree
def degree(e, n):
    for edge in e:
        actor1 = edge['actor1']
        actor2 = edge['actor2']
        n[actor1]['degree'] = n[actor1]['degree'] + 1
        n[actor2]['degree'] = n[actor2]['degree'] + 1
    return n


# 定义计算所有点度数的函数count
def count(file: dict):
    t = dict()
    for node_id, value in file.items():
        degree = value['degree']
        t[degree] = 0
    for node_id, value in file.items():
        degree = value['degree']
        t[degree] = t[degree] + 1
    return t


# 执行脚本
if __name__ == "__main__":

    Edge = read_edge(r"C:\\Users\\86188\\Desktop\\project\\imdb_actor_edges.tsv")
    # 用read_edge函数读取相应路径的文件并将数据存储在Edge中，具体路径可以灵活变更
    Node = read_node(r"C:\\Users\\86188\\Desktop\\project\\imdb_actors_key.tsv")
    # 用read_node函数读取相应路径的文件并将数据存储在Node中，具体路径可以灵活变更
    temp = degree(Edge, Node)
    # 用count_degree函数计算每个节点的度数，并储存在temp中
    MAX = sort(temp)
    # 用sort函数给所得度数temp进行排序，并计算出拥有最大度数的20个节点，并储存在MAX中
    degree_number = count(Node)
    # 用count_degree_numbers函数计算每个节点的度数，并储存在degree_number中

    print("\\n度数最大的前20个节点的ID及其度数为：")
    print(MAX)  # 输出度数最大的前20个节点的相应数据
    x=list()
    y=list()
    for node_degree, i in degree_number.items():
        x.append(node_degree)
        y.append(i)

# 至此，我们已经得到了度数最大的前20个节点的ID以及它们对应的度数
# 它们将按照[{'node_id':'id-number', 'degree':degree-number},{...},{...}.......{...}]的格式输出


# 开始图像绘制，这里需要用到matplotlib库（已预先导入)
# 需要注意的是matplotlib库对中文不太支持，容易出现显示不出来的情况，所以此图表里的文字一律使用英文

import matplotlib.pyplot as plt  # 引入matplotlib库，用于绘制图像

plt.figure(figsize=(10, 6), facecolor='pink')           # 定义图表属性，长10英寸，宽6英寸，背景颜色为粉色
plt.plot(x, y, color='c', linestyle='-.', marker='*')   # 定义线条属性，颜色为青色，线条风格为点划线，标记点风格为星型
plt.xlabel('degree number (co-star-movie-number)')      # 显示x轴的表示含义——度数（合作次数）
plt.ylabel('nodes number (actors)')                     # 显示y轴的表示含义——节点数（演员数）
plt.title('Node Degree Distribution Diagram')           # 显示图表的标题
plt.show()                                              # 将图表show出来