精华内容
下载资源
问答
  • 深度学习常用网络pytorch代码整理合集 包括 AlexNet , LeNet, NiNet, ResNet, VGGNet
  • 之前记录了一下,常见的四种网络模型——ER、BA、WS、规则图,以及如何使用python实现,具体请移步: https://blog.csdn.net/un357951/article/details/103514682 当时因为对轮盘赌算法还不熟悉,所以没有把轮盘赌...

    之前记录了一下,常见的四种网络模型——ER、BA、WS、规则图,以及如何使用python实现,具体请移步:

    https://blog.csdn.net/un357951/article/details/103514682

    当时因为对轮盘赌算法还不熟悉,所以没有把轮盘赌算法和 BA无标度网络结合,现在记录一下,轮盘赌算法的学习笔记,以及应用到BA网络中去。

    轮盘赌算法:

    其基本思想是:个体被选中的概率与其适应度函数值成正比;

    设群体大小为 n, 个体 i 的适应度为 Fi,则个体被选中遗传到下一代群体的概率为:

                                                                                   

    设想群体全部个体的适当性分数使用一个饼图来表示,

    群体中每一个染色块指定饼图中的一个小块;块的大小与染色块的适应性分数成比例,适应性分数越高,其相应在饼图中对应的小块所占面积也越大。为了选取饼图中的一个染色块,可以旋转这个轮子,直到轮盘停止时,看指针停止的位置。指针停止在那一块,就选择与之对应的那个染色块

    具体操作如下:

    1、计算出群体中每个个体的适应度 fi,(i= 1,2,3,...,M),M是群体大小;

    2、计算出每一个个体被遗传到下一代群体中的概率:

     3、计算出每个个体的累积概率:

    4、在[0,1]区间内产生一个均匀分布的伪随机数 r;

    5、若 r<qi,则选择个体 i;否则,选择个体 k,使得 q[k-1]<r≤q[k] 成立;

    6、重复(4)、(5)共M次

    当这个轮盘赌算法应用到BA网络中时,也是比较简单的。

        for i in range(t):
            m_0_t = m_0 + i       # t 时刻的节点数
            m_0_1 = m_0 + i - 1   # t-1 时刻的节点数
            G_BA.add_node(m_0_t)
            add_edge = 1
            while(add_edge<=m):
                sumFits = sum(p_k)
                rndPoint = random.uniform(0, sumFits)
                accumulator = 0.0
                for ind, val in enumerate(p_k):
                    accumulator += val
                    if accumulator >= rndPoint:
                        k_j = k[ind]
                        p_k_j = p_k[ind]
                        G_BA.add_edge(m_0_t, ind)
                        adjacentMatrix[m_0_t][ind] = 1
                        adjacentMatrix[ind][m_0_t] = 1
                        k[ind] = k_j + 1
                        k_all += 2  # 增加一条边,度增加 2
                        p_k[ind] = (k_j + 1) / k_all
                        add_edge += 1
            k.append(2)
            p = 2 / k_all
            p_k.append(p)

    与未使用轮盘赌的BA网络相比,仅仅是优先连接部分发生改变,其他还是一样的。

    不过,现在看来,构造BA的算法还是有一点问题,就是出现重复的边时,无法再增加一个连边,保证每个节点增加的边数一样。这时,可以在判断条件中增加一个条件:被选择点与新增加的点之间不可以存在连边,这样就完美实现了BA网络。

    展开全文
  • 常见网络模型——ER随机图、规则图、BA、WS小世界

    千次阅读 多人点赞 2019-12-14 14:37:17
    (2)随机化重连:以概率 p 随机地重新连接网络中原有的每条边,即把每条边的一个端点保持不变,另一个端点改取为网络中随机选择的一个节点,其中规定不得有重边和自环 (在上述模型中,p=0 对应于完全规则网络,p=...

    ER随机图:(没有重边和自环的简单图)

    定义一:具有固定边数的ER随机图 G(N,M)

    构造算法:

    (1)初始化:给定 N 个节点和待添加的边数 M

    (2)随机连边:

    1. 随机选取一对没有边相连的不同节点,并在这对节点之间添加一条边
    2. 重复步骤1,直到在 M 对不同节点对之间各添加了一条边

    定义二:具有固定连边概率的ER随机图 G(N,p)

    构造算法:

    (1)初始化:给定 N 个节点以及连边概率 p∈[0,1]

    (2)随机连边:

    1. 选择一对没有边相连的不同节点
    2. 生成一个随机数 r ∈(0,1)
    3. 如果 r < p,那么在这对节点之间添加一条边;否则就不添加边
    4. 重复步骤1、2、3,直到所有节点对都被选择过一次

    不使用已有库函数,自己编写模型如下:

    import networkx as nx
    import numpy as np
    
    '''ER model :generate a ER graph'''
    
    def ERmodel(NodeNum, ER_P):
        Node_num = NodeNum
        N = list(range(Node_num))
        G_ER = nx.Graph()
        G_ER.add_nodes_from(N)
        p = ER_P
        AdjMatrix = np.random.randint(0, 10, (Node_num, Node_num))
    
        # ER 无权无向
        AdjMatrix[0][0] = 0
        for i in range(1, Node_num):
            AdjMatrix[i][i] = 0
            for j in range(i):
                if i > j and AdjMatrix[i][j] < p:
                    G_ER.add_edge(i, j)
                    AdjMatrix[i][j] = 1
                    AdjMatrix[j][i] = 1
                else:
                    AdjMatrix[i][j] = 0
                    AdjMatrix[j][i] = 0

    规则图之最近邻耦合网络:具有周期边界条件,每个节点与最近邻 2k 个点连线

    import networkx as nx
    
    if __name__ == '__main__':
        NUM1 = 500
        K = 15          #  最近邻 2K 个点连线
        K1 = K + 1
        g = nx.Graph()
        N = list(range(NUM1))
        g.add_nodes_from(N)   #  增加 NUM1 个点
    
        for i in range(NUM1):
            for j in range(1, K1):
                K_add = NUM1 - K
                i_add_j = i + j + 1
                if i >= K_add and i_add_j > NUM1:  # 大数标签节点 加数邻边 加边判断
                    i_add = i + j - NUM1
                    g.add_edge(i, i_add)
                else:
                    i_add = i + j
                    g.add_edge(i, i_add)
    

    BA无标度网络:

    考虑网络的增长特性和优先连接(好像更多的人使用轮盘赌算法,以后再加好了)

    增长特性:网络的规模是不断扩大的

    优先连接:新的节点更倾向于与那些具有较高连接度的 hub 节点连接

    构造算法:

    (1)增长:从一个具有 m0 个节点的连通网络开始,每次引入一个新的节点并且连到 m 个已存在的节点上,这里 m≤m0

    (2)优先连接:一个新节点与一个已经存在的节点 i 相连接的概率 P_i 与节点 i 的度 k_i 之间满足关系:

    P_i = k_i / ∑k_j

    import networkx as nx
    import numpy as np
    import random
    import math
    
    if __name__ == '__main__':
        m_0 = 4
        m = 2
        t = 496
        NUM = m_0 + t
        g = nx.Graph()
        N = list(range(m_0))
        g.add_nodes_from(N)
        k = []                   #   保存各节点的度
        k_0 = m-1
        p_k = []                 #   保存各节点的优先概率
        p_0 = 1/m_0
        k_all = 0
        for i in range(m_0):          #   初始的完全图    
            p_k.append(p_0)
            k.append(k_0)
            k_all += k_0
            for j in range(i,m_0):
                g.add_edge(i,j)
    
        for i in range(t):
            m_0_t = m_0 + i               #   t 时刻的节点数
            m_0_1 = m_0 + i - 1         #   t-1 时刻的节点数
            g.add_node(m_0_t)
            # k_all = 0
            # for j in range(m_0_t_1):
            #     k_all += k[j]
            add_edge = 1
            while(add_edge<=m):
                for j in range(m_0_1):       #   按照节点顺序比较,人为使得标签小的节点度偏大
                    p_random = random.random()       #   是否应该从概率最大的开始比较
                    if p_random <= p_k[j] and add_edge <= m:
                        k_j = k[j]
                        p_k_j = p_k[j]
                        g.add_edge(m_0_t,j)
                        add_edge += 1
                        k[j] = k_j + 1
                        k_all += 2                 #   增加一条边,度增加 2
                        p_k[j] = (k_j + 1)/k_all
    
            k.append(2)
            p = 2/k_all
            p_k.append(p)

    WS小世界模型:

    作为从完全规则网络向完全随机网络的过渡,在规则网络中引入少许的随机性

    构造算法:

    (1)从规则图开始:给定一个含有 N 个点的环状最近邻耦合网络,其中每个节点都与它左右相邻的各 K/2 个节点相连,K是偶数;

    (2)随机化重连:以概率 p 随机地重新连接网络中原有的每条边,即把每条边的一个端点保持不变,另一个端点改取为网络中随机选择的一个节点,其中规定不得有重边和自环

    (在上述模型中,p=0 对应于完全规则网络,p=1 对应于完全随机网络)

      在具体算法实现时,可以把网络中所有节点编号为 1, 2, ..., N ;对于每个节点 i,顺时针选取与节点 i 相连的 K/2 条边中的每一条边,边的一个端点仍然固定为节点 i, 以概率 p 随机选取网络中的任一个节点作为该条边的另一个端点。因此,严格来说,即使在 p=1 的情况下,通过这种算法得到的WS小世界模型与相同节点,相同变数的ER随机图模型还是有区别的:毕竟,在WS小世界中每个节点的度至少是 K/2, 而在ER随机图中则无此限制

    import networkx as nx
    import numpy as np
    import random
    
    if __name__ == '__main__':
        NUM1 = 500
        NUM2 = NUM1 - 1
        K = 15          #  最近邻 2K 个点连线
        K1 = K + 1
        p = 0.3
        g = nx.Graph()
        N = list(range(NUM1))
        g.add_nodes_from(N)   #  增加 N 个点
    
        for i in range(NUM1):
            for j in range(1, K1):
                K_add = NUM1 - K
                i_add_j = i + j + 1
                if i >= K_add and i_add_j > NUM1:  #   大数标签节点 加数邻边 加边判断
                    i_add = i + j - NUM1
                    g.add_edge(i, i_add)
                else:
                    i_add = i + j
                    g.add_edge(i, i_add)
    
        #  按照概率 p = 0.3 重连
        for i in range(NUM1):
            for e_del in range(i + 1, i + K1):
                if e_del >= NUM1:     #   找到的节点标签大于实际中的标签,标签更正
                    e_del = e_del - NUM1
                P_random = random.randint(0, 9)
                if P_random <= 2:
                    g.remove_edge(i, e_del)
                    e_add = random.randint(0, NUM2)    #   0 - NUM2 都可能
                    while e_add == i or g.has_edge(i, e_add) == True:
                        e_add = random.randint(0, NUM2)
                    g.add_edge(i, e_add)
    

    展开全文
  • 所以当我们导入一个预训练的模型时,网络结构需要与预训练的网络结构相同,然后再针对特定的场景和任务进行训练。 衍生 了解了一般的迁移学习玩法后, 我们看看前辈们还有哪些新玩法. 多任务学习, 或者强化学习中的 ...

    前言

    你会发现聪明人都喜欢”偷懒”, 因为这样的偷懒能帮我们节省大量的时间, 提高效率. 还有一种偷懒是 “站在巨人的肩膀上”. 不仅能看得更远, 还能看到更多. 这也用来表达我们要善于学习先辈的经验, 一个人的成功往往还取决于先辈们累积的知识. 这句话, 放在机器学习中, 这就是今天要说的迁移学习了, transfer learning.

    什么是迁移学习?

    迁移学习通俗来讲,就是运用已有的知识来学习新的知识,核心是找到已有知识和新知识之间的相似性,用成语来说就是举一反三。由于直接对目标域从头开始学习成本太高,我们故而转向运用已有的相关知识来辅助尽快地学习新知识。比如,已经会下中国象棋,就可以类比着来学习国际象棋;已经会编写Java程序,就可以类比着来学习C#;已经学会英语,就可以类比着来学习法语;等等。世间万事万物皆有共性,如何合理地找寻它们之间的相似性,进而利用这个桥梁来帮助学习新知识,是迁移学习的核心问题。

    为什么需要迁移学习?

    在这里插入图片描述
    现在的机器人视觉已经非常先进了, 有些甚至超过了人类. 99.99%的识别准确率都不在话下. 这样的成功, 依赖于强大的机器学习技术, 其中, 神经网络成为了领军人物. 而 CNN 等, 像人一样拥有千千万万个神经联结的结构, 为这种成功贡献了巨大力量. 但是为了更厉害的 CNN, 我们的神经网络设计, 也从简单的几层网络, 变得越来越多, 越来越多, 越来越多… 为什么会越来越多?

    因为计算机硬件, 比如 GPU 变得越来越强大, 能够更快速地处理庞大的信息. 在同样的时间内, 机器能学到更多东西. 可是, 不是所有人都拥有这么庞大的计算能力. 而且有时候面对类似的任务时, 我们希望能够借鉴已有的资源.

    如何做迁移学习?

    在这里插入图片描述这就好比, Google 和百度的关系, facebook 和人人的关系, KFC 和 麦当劳的关系, 同一类型的事业, 不用自己完全从头做, 借鉴对方的经验, 往往能节省很多时间. 有这样的思路, 我们也能偷偷懒, 不用花时间重新训练一个无比庞大的神经网络, 借鉴借鉴一个已经训练好的神经网络就行.

    在这里插入图片描述比如这样的一个神经网络, 我花了两天训练完之后, 它已经能正确区分图片中具体描述的是男人, 女人还是眼镜. 说明这个神经网络已经具备对图片信息一定的理解能力. 这些理解能力就以参数的形式存放在每一个神经节点中. 不巧, 领导下达了一个紧急任务,
    在这里插入图片描述要求今天之内训练出来一个预测图片里实物价值的模型. 我想这可完蛋了, 上一个图片模型都要花两天, 如果要再搭个模型重新训练, 今天肯定出不来呀.

    这时, 迁移学习来拯救我了. 因为这个训练好的模型中已经有了一些对图片的理解能力, 而模型最后输出层的作用是分类之前的图片, 对于现在计算价值的任务是用不到的, #所以我将最后一层替换掉, 变为服务于现在这个任务的输出层. #接着只训练新加的输出层, 让理解力保持始终不变. 前面的神经层庞大的参数不用再训练, 节省了我很多时间, 我也在一天时间内, 将这个任务顺利完成.

    在这里插入图片描述
    但并不是所有时候我们都需要迁移学习. 比如神经网络很简单, 相比起计算机视觉中庞大的 CNN 或者语音识别的 RNN, 训练小的神经网络并不需要特别多的时间, 我们完全可以直接重头开始训练. 从头开始训练也是有好处的.

    在这里插入图片描述如果固定住之前的理解力, 或者使用更小的学习率来更新借鉴来的模型, 就变得有点像认识一个人时的第一印象, 如果迁移前的数据和迁移后的数据差距很大, 或者说我对于这个人的第一印象和后续印象差距很大, 我还不如不要管我的第一印象, 同理, 这时, 迁移来的模型并不会起多大作用, 还可能干扰我后续的决策.

    迁移学习的限制

    比如说,我们不能随意移除预训练网络中的卷积层。但由于参数共享的关系,我们可以很轻松地在不同空间尺寸的图像上运行一个预训练网络。这在卷积层和池化层和情况下是显而易见的,因为它们的前向函数(forward function)独立于输入内容的空间尺寸。在全连接层(FC)的情形中,这仍然成立,因为全连接层可被转化成一个卷积层。所以当我们导入一个预训练的模型时,网络结构需要与预训练的网络结构相同,然后再针对特定的场景和任务进行训练。

    常见的迁移学习方式:

    1. 载权重后训练所有参数
    2. 载入权重后只训练最后几层参数
    3. 载入权重后在原网络基础上再添加一层全链接层,仅训练最后一个全链接层

    衍生

    在这里插入图片描述了解了一般的迁移学习玩法后, 我们看看前辈们还有哪些新玩法. 多任务学习, 或者强化学习中的 learning to learn, 迁移机器人对运作形式的理解, 解决不同的任务. 炒个蔬菜, 红烧肉, 番茄蛋花汤虽然菜色不同, 但是做菜的原则是类似的.
    在这里插入图片描述
    又或者 google 的翻译模型, 在某些语言上训练, 产生出对语言的理解模型, 将这个理解模型当做迁移模型在另外的语言上训练. 其实说白了, 那个迁移的模型就能看成机器自己发明的一种只有它自己才能看懂的语言. 然后用自己的这个语言模型当成翻译中转站, 将某种语言转成自己的语言, 然后再翻译成另外的语言. 迁移学习的脑洞还有很多, 相信这种站在巨人肩膀上继续学习的方法, 还会带来更多有趣的应用.

    使用图像数据进行迁移学习

    • 牛津 VGG 模型(http://www.robots.ox.ac.uk/~vgg/research/very_deep/)
    • 谷歌 Inception模型(https://github.com/tensorflow/models/tree/master/inception)
    • 微软 ResNet 模型(https://github.com/KaimingHe/deep-residual-networks)

    可以在 Caffe Model Zoo(https://github.com/BVLC/caffe/wiki/Model-Zoo)中找到更多的例子,那里分享了很多预训练的模型。

    实例:

    注:如何获取官方的.pth文件,以resnet为例子

    import torchvision.models.resnet
    

    在脚本中输入以上代码,将鼠标对住resnet并按ctrl键,发现改变颜色,点击进入resnet.py脚本,在最开始有url,如下图所示
    在这里插入图片描述选择你要下载的模型,copy到浏览器即可,若是觉得慢可以用迅雷等等。

    ResNet
    详细讲解在这篇博文里:ResNet——CNN经典网络模型详解(pytorch实现)

    #train.py
    
    import torch
    import torch.nn as nn
    from torchvision import transforms, datasets
    import json
    import matplotlib.pyplot as plt
    import os
    import torch.optim as optim
    from model import resnet34, resnet101
    import torchvision.models.resnet
    
    
    device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
    print(device)
    
    data_transform = {
        "train": transforms.Compose([transforms.RandomResizedCrop(224),
                                     transforms.RandomHorizontalFlip(),
                                     transforms.ToTensor(),
                                     transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])]),#来自官网参数
        "val": transforms.Compose([transforms.Resize(256),#将最小边长缩放到256
                                   transforms.CenterCrop(224),
                                   transforms.ToTensor(),
                                   transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])])}
    
    
    data_root = os.getcwd()
    image_path = data_root + "/flower_data/"  # flower data set path
    
    train_dataset = datasets.ImageFolder(root=image_path + "train",
                                         transform=data_transform["train"])
    train_num = len(train_dataset)
    
    # {'daisy':0, 'dandelion':1, 'roses':2, 'sunflower':3, 'tulips':4}
    flower_list = train_dataset.class_to_idx
    cla_dict = dict((val, key) for key, val in flower_list.items())
    # write dict into json file
    json_str = json.dumps(cla_dict, indent=4)
    with open('class_indices.json', 'w') as json_file:
        json_file.write(json_str)
    
    batch_size = 16
    train_loader = torch.utils.data.DataLoader(train_dataset,
                                               batch_size=batch_size, shuffle=True,
                                               num_workers=0)
    
    validate_dataset = datasets.ImageFolder(root=image_path + "/val",
                                            transform=data_transform["val"])
    val_num = len(validate_dataset)
    validate_loader = torch.utils.data.DataLoader(validate_dataset,
                                                  batch_size=batch_size, shuffle=False,
                                                  num_workers=0)
    net = resnet34()
    # net = resnet34(num_classes=5)
    # load pretrain weights
    
    model_weight_path = "./resnet34-pre.pth"
    missing_keys, unexpected_keys = net.load_state_dict(torch.load(model_weight_path), strict=False)#载入模型参数
    
    # for param in net.parameters():
    #     param.requires_grad = False
    # change fc layer structure
    
    inchannel = net.fc.in_features
    net.fc = nn.Linear(inchannel, 5)
    
    
    net.to(device)
    
    loss_function = nn.CrossEntropyLoss()
    optimizer = optim.Adam(net.parameters(), lr=0.0001)
    
    best_acc = 0.0
    save_path = './resNet34.pth'
    for epoch in range(3):
        # train
        net.train()
        running_loss = 0.0
        for step, data in enumerate(train_loader, start=0):
            images, labels = data
            optimizer.zero_grad()
            logits = net(images.to(device))
            loss = loss_function(logits, labels.to(device))
            loss.backward()
            optimizer.step()
    
            # print statistics
            running_loss += loss.item()
            # print train process
            rate = (step+1)/len(train_loader)
            a = "*" * int(rate * 50)
            b = "." * int((1 - rate) * 50)
            print("\rtrain loss: {:^3.0f}%[{}->{}]{:.4f}".format(int(rate*100), a, b, loss), end="")
        print()
    
        # validate
        net.eval()
        acc = 0.0  # accumulate accurate number / epoch
        with torch.no_grad():
            for val_data in validate_loader:
                val_images, val_labels = val_data
                outputs = net(val_images.to(device))  # eval model only have last output layer
                # loss = loss_function(outputs, test_labels)
                predict_y = torch.max(outputs, dim=1)[1]
                acc += (predict_y == val_labels.to(device)).sum().item()
            val_accurate = acc / val_num
            if val_accurate > best_acc:
                best_acc = val_accurate
                torch.save(net.state_dict(), save_path)
            print('[epoch %d] train_loss: %.3f  test_accuracy: %.3f' %
                  (epoch + 1, running_loss / step, val_accurate))
    
    print('Finished Training')
    

    在这里插入图片描述未使用迁移学习
    在这里插入图片描述VGG16

    #train.py
    
    import torch.nn as nn
    from torchvision import transforms, datasets
    import json
    import os
    import torch.optim as optim
    from model import vgg
    import torch
    import time
    import torchvision.models.vgg
    from torchvision import models
    
    device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
    print(device)
    
    #数据预处理,从头
    
    data_transform = {
        "train": transforms.Compose([transforms.RandomResizedCrop(224),
                                     transforms.RandomHorizontalFlip(),
                                     transforms.ToTensor(),
                                     transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))]),
    
    
        "val": transforms.Compose([transforms.Resize((224, 224)),
                                   transforms.ToTensor(),
                                   transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])}
    
    
    data_root = os.path.abspath(os.path.join(os.getcwd(), "../../.."))  # get data root path
    image_path = data_root + "/data_set/flower_data/"  # flower data set pathh
    
    train_dataset = datasets.ImageFolder(root=image_path + "/train",
                                         transform=data_transform["train"])
    train_num = len(train_dataset)
    
    
    # {'daisy':0, 'dandelion':1, 'roses':2, 'sunflower':3, 'tulips':4}
    flower_list = train_dataset.class_to_idx
    cla_dict = dict((val, key) for key, val in flower_list.items())
    # write dict into json file
    json_str = json.dumps(cla_dict, indent=4)
    with open('class_indices.json', 'w') as json_file:
        json_file.write(json_str)
    
    
    batch_size = 20
    train_loader = torch.utils.data.DataLoader(train_dataset,
                                               batch_size=batch_size, shuffle=True,
                                               num_workers=0)
    
    validate_dataset = datasets.ImageFolder(root=image_path + "val",
                                            transform=data_transform["val"])
    val_num = len(validate_dataset)
    validate_loader = torch.utils.data.DataLoader(validate_dataset,
                                                  batch_size=batch_size, shuffle=False,
                                                  num_workers=0)
    
    # test_data_iter = iter(validate_loader)
    # test_image, test_label = test_data_iter.next()
    
    # model
    # = models.vgg16(pretrained=True)
    
    #
    # model_name = "vgg16"
    # net = vgg(model_name=model_name, init_weights=True)
    
    
    # load pretrain weights
    net = models.vgg16(pretrained=False)
    pre = torch.load("./vgg16.pth")
    net.load_state_dict(pre)
    
    for parma in net.parameters():
        parma.requires_grad = False
    
    
    net.classifier = torch.nn.Sequential(torch.nn.Linear(25088, 4096),
                                           torch.nn.ReLU(),
                                           torch.nn.Dropout(p=0.5),
                                           torch.nn.Linear(4096, 4096),
                                           torch.nn.ReLU(),
                                           torch.nn.Dropout(p=0.5),
                                           torch.nn.Linear(4096, 5))
    
    # model_weight_path = "./vgg16.pth"
    # missing_keys, unexpected_keys = net.load_state_dict(torch.load(model_weight_path), strict=False)#载入模型参数
    
    # # for param in net.parameters():
    # #     param.requires_grad = False
    # # change fc layer structure
    #
    # inchannel = 512
    # net.classifier = nn.Linear(inchannel, 5)
    
    loss_function = torch.nn.CrossEntropyLoss()
    optimizer = optim.Adam(net.classifier.parameters(), lr=0.001)
    
    # loss_function = nn.CrossEntropyLoss()
    # optimizer = optim.Adam(net.parameters(), lr=0.0001) #learn rate
    net.to(device)
    
    best_acc = 0.0
    #save_path = './{}Net.pth'.format(model_name)
    save_path = './vgg16Net.pth'
    for epoch in range(15):
        # train
        net.train()
        running_loss = 0.0 #统计训练过程中的平均损失
    
        t1 = time.perf_counter()
        for step, data in enumerate(train_loader, start=0):
            images, labels = data
            optimizer.zero_grad()
            #with torch.no_grad(): #用来消除验证阶段的loss,由于梯度在验证阶段不能传回,造成梯度的累计
            outputs = net(images.to(device))
            loss = loss_function(outputs, labels.to(device))  #得到预测值与真实值的一个损失
    
            loss.backward()
            optimizer.step()#更新结点参数
    
            # print statistics
            running_loss += loss.item()
            # print train process
            rate = (step + 1) / len(train_loader)
            a = "*" * int(rate * 50)
            b = "." * int((1 - rate) * 50)
            print("\rtrain loss: {:^3.0f}%[{}->{}]{:.3f}".format(int(rate * 100), a, b, loss), end="")
        print()
        print(time.perf_counter() - t1)
    
        # validate
        net.eval()
        acc = 0.0  # accumulate accurate number / epoch
        with torch.no_grad():#不去跟踪损失梯度
            for val_data in validate_loader:
                val_images, val_labels = val_data
                #optimizer.zero_grad()
                outputs = net(val_images.to(device))
                predict_y = torch.max(outputs, dim=1)[1]
                acc += (predict_y == val_labels.to(device)).sum().item()
            val_accurate = acc / val_num
            if val_accurate > best_acc:
                best_acc = val_accurate
                torch.save(net.state_dict(), save_path)
            print('[epoch %d] train_loss: %.3f  test_accuracy: %.3f' %
                  (epoch + 1, running_loss / step, val_accurate))
    
    print('Finished Training')
    

    densenet121

    #train.py
    
    import torch
    import torch.nn as nn
    from torchvision import transforms, datasets
    import json
    import matplotlib.pyplot as plt
    from model import densenet121
    import os
    import torch.optim as optim
    import torchvision.models.densenet
    import torchvision.models as models
    
    device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
    print(device)
    
    data_transform = {
        "train": transforms.Compose([transforms.RandomResizedCrop(224),
                                     transforms.RandomHorizontalFlip(),
                                     transforms.ToTensor(),
                                     transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])]),#来自官网参数
        "val": transforms.Compose([transforms.Resize(256),#将最小边长缩放到256
                                   transforms.CenterCrop(224),
                                   transforms.ToTensor(),
                                   transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])])}
    
    
    data_root = os.path.abspath(os.path.join(os.getcwd(), "../../.."))  # get data root path
    image_path = data_root + "/data_set/flower_data/"  # flower data set path
    
    train_dataset = datasets.ImageFolder(root=image_path + "train",
                                         transform=data_transform["train"])
    train_num = len(train_dataset)
    
    # {'daisy':0, 'dandelion':1, 'roses':2, 'sunflower':3, 'tulips':4}
    flower_list = train_dataset.class_to_idx
    cla_dict = dict((val, key) for key, val in flower_list.items())
    # write dict into json file
    json_str = json.dumps(cla_dict, indent=4)
    with open('class_indices.json', 'w') as json_file:
        json_file.write(json_str)
    
    batch_size = 16
    train_loader = torch.utils.data.DataLoader(train_dataset,
                                               batch_size=batch_size, shuffle=True,
                                               num_workers=0)
    
    validate_dataset = datasets.ImageFolder(root=image_path + "/val",
                                            transform=data_transform["val"])
    val_num = len(validate_dataset)
    validate_loader = torch.utils.data.DataLoader(validate_dataset,
                                                  batch_size=batch_size, shuffle=False,
                                                  num_workers=0)
    
    #迁移学习
    net = models.densenet121(pretrained=False)
    model_weight_path="./densenet121-a.pth"
    missing_keys, unexpected_keys = net.load_state_dict(torch.load(model_weight_path), strict= False)
    
    inchannel = net.classifier.in_features
    net.classifier = nn.Linear(inchannel, 5)
    net.to(device)
    
    loss_function = nn.CrossEntropyLoss()
    optimizer = optim.Adam(net.parameters(), lr=0.0001)
    
    #普通
    
    # model_name = "densenet121"
    # net = densenet121(model_name=model_name, num_classes=5)
    
    best_acc = 0.0
    save_path = './densenet121.pth'
    for epoch in range(12):
        # train
        net.train()
        running_loss = 0.0
        for step, data in enumerate(train_loader, start=0):
            images, labels = data
            optimizer.zero_grad()
            logits = net(images.to(device))
            loss = loss_function(logits, labels.to(device))
            loss.backward()
            optimizer.step()
    
            # print statistics
            running_loss += loss.item()
            # print train process
            rate = (step+1)/len(train_loader)
            a = "*" * int(rate * 50)
            b = "." * int((1 - rate) * 50)
            print("\rtrain loss: {:^3.0f}%[{}->{}]{:.4f}".format(int(rate*100), a, b, loss), end="")
        print()
    
        # validate
        net.eval()
        acc = 0.0  # accumulate accurate number / epoch
        with torch.no_grad():
            for val_data in validate_loader:
                val_images, val_labels = val_data
                outputs = net(val_images.to(device))  # eval model only have last output layer
                # loss = loss_function(outputs, test_labels)
                predict_y = torch.max(outputs, dim=1)[1]
                acc += (predict_y == val_labels.to(device)).sum().item()
            val_accurate = acc / val_num
            if val_accurate > best_acc:
                best_acc = val_accurate
                torch.save(net.state_dict(), save_path)
            print('[epoch %d] train_loss: %.3f  test_accuracy: %.3f' %
                  (epoch + 1, running_loss / step, val_accurate))
    
    print('Finished Training')
    

    使用
    在这里插入图片描述
    参考自:莫烦

    展开全文
  • NetworkX提供了4种常见网络建模方法,分别是:规则图,ER随机图,WS小世界网络和BA无标度网络。 一. Networkx的下载安装 画图之前先将NetworkX装好,直接pip install Networkx的话会特别慢,而且通常会失败,所以...


    NetworkX提供了4种常见网络的建模方法,分别是:规则图,ER随机图,WS小世界网络和BA无标度网络。

    一. Networkx的下载安装

    画图之前先将NetworkX装好,直接pip install Networkx的话会特别慢,而且通常会失败,所以我一般都是先把库下载下来,再在本地安装。

    1、下载传送门:https://pypi.org/project/networkx/#files
    我下载的这个:
    在这里插入图片描述2、放到自己指定的文件夹(随意)
    3、本地安装
    在这里插入图片描述

    二. 规则图

    规则图差不多是最没有复杂性的一类图,random_graphs.random_regular_graph(d, n)方法可以生成一个含有n个节点,每个节点有d个邻居节点的规则图。
    下面一段示例代码,生成了包含20个节点、每个节点有3个邻居的规则图:

    import networkx as nx
    import matplotlib.pyplot as plt
    #生成了包含20个节点、每个节点有3个邻居的规则图
    RG = nx.random_graphs.random_regular_graph(3, 20)
    #spectral布局
    pos = nx.spectral_layout(RG)
    
    nx.draw(RG, pos, with_labels = False, node_size = 30)
    plt.show()
    

    在这里插入图片描述

    三、ER随机图

    ER随机图是早期研究得比较多的一类“复杂”网络,模型的基本思想是以概率p连接N个节点中的每一对节点。
    用random_graphs.erdos_renyi_graph(n,p)方法生成一个含有n个节点、以概率p连接的ER随机图:

    import networkx as nx
    import matplotlib.pyplot as plt
    #生成一个含有20个节点、以概率p = 0.2连接的ER随机图:
    ER = nx.random_graphs.erdos_renyi_graph(20, 0.2)
    #shell布局
    pos = nx.shell_layout(ER)
    nx.draw(ER, pos, with_labels = False, node_size = 30)
    plt.show()
    

    在这里插入图片描述

    四、WS小世界网络

    用random_graphs.watts_strogatz_graph(n, k, p)方法生成一个含有n个节点、每个节点有k个邻居、以概率p随机化重连边的WS小世界网络。

    import networkx as nx
    import matplotlib.pyplot as plt
    #生成一个含有20个节点、每个节点有4个邻居、以概率p=0.3随机化重连边的WS小世界网络
    WS = nx.random_graphs.watts_strogatz_graph(20, 4, 0.3)
    # circular 布局
    pos = nx.circular_layout(WS)
    nx.draw(WS, pos, with_labels = False, node_size = 30)
    plt.show()
    

    在这里插入图片描述

    五、BA无标度网络

    用random_graphs.barabasi_albert_graph(n, m)方法生成一个含有n个节点、每次加入m条边的BA无标度网络。

    import networkx as nx
    import matplotlib.pyplot as plt
    #生成一个含有20个节点、每次加入1条边的BA无标度网络。
    BA = nx.random_graphs.barabasi_albert_graph(20, 1)
    # spring 布局
    pos = nx.spring_layout(BA)
    nx.draw(BA, pos, with_labels = False, node_size = 30)
    plt.show()
    

    在这里插入图片描述

    六. 总结

    (1)基本绘图流程:
    在NetworkX中,绘制一个网络使用nx.draw()方法,它至少接受一个参数:即你希望绘制的网络G。实际上这个方法非常复杂,它可以指定20多个关键字参数,后边会介绍一些常用的参数,我们先从最简单的情况入手,看看下边的例子:

    import networkx as nx               #导入networkx包
    import matplotlib.pyplot as plt     #导入绘图包matplotlib(需要安装,方法见第一篇笔记)
    G =nx.random_graphs.barabasi_albert_graph(100,1)   #生成一个BA无标度网络G
    nx.draw(G)                      #绘制网络G
    #plt.savefig("ba.png")          #输出方式1: 将图像存为一个png格式的图片文件
    plt.savefig("ba_svg.svg")       #svg矢量图通常放入自己的论文中
    plt.show()                      #输出方式2: 在窗口中显示这幅图像
    

    在这里插入图片描述
    在这里插入图片描述

    (2)运用样式
    上边的代码虽然简单,但生成的图形略显单调。NetworkX提供了一系列样式参数,可以用来修饰和美化图形,达到我们想要的效果。常用的参数包括:
    - node_size: 指定节点的尺寸大小(默认是300,单位未知,就是上图中那么大的点)
    - node_color: 指定节点的颜色 (默认是红色,可以用字符串简单标识颜色,例如’r’为红色,'b’为绿色等,具体可查看手册)
    - node_shape: 节点的形状(默认是圆形,用字符串’o’标识,具体可查看手册)
    - alpha: 透明度 (默认是1.0,不透明,0为完全透明)
    - width: 边的宽度 (默认为1.0)
    - edge_color: 边的颜色(默认为黑色)
    - style: 边的样式(默认为实现,可选: solid|dashed|dotted,dashdot)
    - with_labels: 节点是否带标签(默认为True)
    - font_size: 节点标签字体大小 (默认为12)
    - font_color: 节点标签字体颜色(默认为黑色)
    灵活运用上述参数,可以绘制不同样式的网络图形,例如:nx.draw(G,node_size = 30,with_labels = False) 是绘制节点尺寸为30、不带标签的网络图。

    (3)运用布局
    NetworkX在绘制网络图形方面提供了布局的功能,可以指定节点排列的形式。这些布局包括:
    circular_layout:节点在一个圆环上均匀分布
    random_layout:节点随机分布
    shell_layout:节点在同心圆上分布
    spring_layout: 用Fruchterman-Reingold算法排列节点(这个算法我不了解,样子类似多中心放射状)
    spectral_layout:根据图的拉普拉斯特征向量排列节点?我也不是太明白
    布局用pos参数指定,例如:nx.draw(G,pos = nx.circular_layout(G))。

    我的第二篇博客,部分参考了他人的,参考链接在底部。初学者,欢迎交流!
    参考:https://www.cnblogs.com/forstudy/archive/2012/03/20/2407954.html
    https://www.cnblogs.com/gispathfinder/p/5790949.html

    展开全文
  • 首先提供这些模型定义文件和权重文件下载的地址:百度网盘 将深度模型当作特征提取器来使用,总是... 网络名字 层名字 vgg16/vgg19/alexnet fc8 googlenet loss3/classifier resnet50/101/152 fc1000
  • keras+VGG19
  • 计算机网络常见模型分析

    千次阅读 2019-02-19 21:44:54
    常见网络模型 OIS模型: 开放通信系统互联参考模型(Open System Interconnection), 是国际标准提出一个试图解决全世界计算机互联的标准框架 OSI模型按照不同的功能可以划分为七层 应用层 处理网络应用 ...
  • 神经网络模型简述 实例:交通运输能力预测设计 MATLAB程序及仿真结果 由于货物运输、地方经济及企业发展的紧密联系,因此作为反映货物运输需求的一项重要指标, 货运量预测研究和分析具有较强的实际意义。 常用的...
  • 四种常见网络IO模型

    2020-08-09 18:34:26
    网络IO模型一共有五种,同步阻塞IO、同步非阻塞IO、IO多路复用、信号驱动IO和异步IO。其中信号驱动IO并不常用,我们只要介绍其他四种。 首先我们需要了解一下网络IO的基本原理和一些基本的概念。 IO读写的基本原理 ...
  • 转载链接:https://blog.csdn.net/qq_24690701/article/details/81868048
  • 数学建模常用模型21:BP神经网络(三层)

    千次阅读 多人点赞 2018-08-21 11:53:13
    在拥有一些数据的前提下,预测接下来的数据,在模型检验的时候用。 步骤: 1. 准备训练网络的样本。 2. 确定网络的初始参数,包括最大训练次数,隐含层神经元数量,网络学习速率,训练的目标误差,是否添加动量因子 ...
  • 神经网络模型用于数学建模

    万次阅读 多人点赞 2019-04-26 16:01:52
    1 神经网络简介 目录 1 神经网络简介 1.1 人工神经元结构 激活函数 ϕ(⋅ ) Matlab 中的激活(传递)函数 1.2 网络结构及工作方式 2 蠓虫分类问题与多层前馈网络 2.1 蠓虫分类问题 2.2 多层前馈网络 2.3 后...
  • 常见的神经网络模型大总结

    万次阅读 多人点赞 2018-08-20 11:12:24
    下表包含了大部分常用模型(大部分是神经网络还有一些其他的模型)。虽然这些架构都是新奇独特的,但当我开始把它们的结果画下来的时候,每种架构的底层关系就会清晰。 显然这些节点图并不能显示各个模型的内部...
  • 常见的神经网络模型

    2020-08-12 14:08:35
    LeNet-5(1998) AlexNet(2012) VGG-16(2014) Inception-v1 (2014) ResNet-50 (2015) 来源Datawhale组队学习中的街景字符编码识别。
  • 本文总结了常用的数学模型方法和它们的主要用途,主要包括数学和统计上的建模方法,关于在数学建模中也挺常用的机器学习算法暂时不作补充,以后有时间就补。至于究竟哪个模型更好,需要用数据来验证,还有求解方法也...
  • P2P网络——网络模型概述

    千次阅读 2019-09-17 01:44:03
    一、常见网络模型 1.随机网络:随机网络的研究是基于随机图理论的。 2.规则网络:常见的规则网络有最近邻耦合网络和星形耦合网络。 3.小世界网络 二、集中目录式P2P网络模型 概念:采用中央目录服务器管理P2P网络各...
  • select --跨平台(windows ,linux都支持) --每次都要从用户空间拷贝到内核空间 --遍历整个fd_set,O(n) --最大可监听的fd数量不能超过FD_SETSIZE ...--基本类似于select,无FD_SETSIZE限制 ...
  • 常用神经网络模型及其应用评述

    千次阅读 2017-05-23 20:04:08
    神经网络是由大量处理单元(神经元)互相连接而成的...神经网络的信息处理通过神经元的相互作用来实现,知识与信息的存贮表现在网络元件互连的分布式结构与联系,神经网络的学习和识别各神经元连接权系数的动态演化
  • 1、增加(减少)隐藏层的复杂度,如增加隐藏层数,调整隐藏层的神经元个数,或者在隐藏层使用更加复杂的网络结构,如CNN、RNN、LSTM、GRU或者增加Attention...4、增加迭代次数,一般为了快速检验模型效果训练次数比...
  • 复杂网络常用的ER网络、BA网络、WS网络常用网络的,Matlab代码
  • networkx库中常用网络演化模型

    千次阅读 2017-04-06 15:47:16
    networkx在绘制网络图形提供了如何布局的方法,常用的有以下几种pos = nx.spectral_layout(G) pos = nx.shell_layout(G) pos = nx.circular_layout(G) pos = nx.spring_layout(G) pos = nx.random_layout(G) #...
  • from 《tensorflow learn in one day》 by Krishna Rungta
  • 上一篇文章:【Linux】Linux网络编程(含常见服务器模型,上篇)。   高级嵌套字函数 前面介绍的一些函数(read、write等)都是网络程序里最基本的函数,也是最原始的通信函数。下面介绍一下几个网络编程的高级...
  • 几种常见神经网络模型

    千次阅读 2020-02-26 11:42:44
    class Flatten(torch.nn.Module): #展平操作 def forward(self, x): return x.view(x.shape[0], -1) class Reshape(torch.nn.Module): #将图像大小重定型 def forward(self, x): return x.view(...
  • 常见的预训练网络模型 在imageNet上预训练过的用于图像分类的模型: VGG16 VGG19 ResNet50 InceptionV3 InceptionResNetV2 Xception MobileNet MobileNetV2 DenseNet NASNet 具体查看 ...
  • 在完成上篇自定义层设计后,下面我们把多层自定义神经网络嵌套成为一个完整的计算网络模型,代码示例如下: #自定义层设计Mydense Class Mydense(layer): def _init_(self,units): super(Mydense,self)._init_...
  • 3.1 常用的神经网络模型 1.卷积神经网络(Convolutional Neural Network, CNN) 是一种前馈神经网络,它包括卷积层(convolutional layer)和池化层(pooling player)。 2.循环神经网络(Recurrent Neural ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 443,841
精华内容 177,536
关键字:

常用网络模型