精华内容
下载资源
问答
  • 获取VGG中间层的输出结果 VGG结构 VGG的结构根据其网络层数的深度,分为四种,分别为11,13,16,19.这四种对应的网络结构的配置的声明见下。 defaultcfg = { 11 : [64, 'M', 128, 'M', 256, 256, 'M', 512, 512, ...

    获取VGG中间层的输出结果

    VGG结构

    VGG的结构根据其网络层数的深度,分为四种,分别为11,13,16,19.这四种对应的网络结构的配置的声明见下。

    
    defaultcfg = {
        11 : [64, 'M', 128, 'M', 256, 256, 'M', 512, 512, 'M', 512, 512],
        13 : [64, 64, 'M', 128, 128, 'M', 256, 256, 'M', 512, 512, 'M', 512, 512],
        16 : [64, 64, 'M', 128, 128, 'M', 256, 256, 256, 'M', 512, 512, 512, 'M', 512, 512, 512],
        19 : [64, 64, 'M', 128, 128, 'M', 256, 256, 256, 256, 'M', 512, 512, 512, 512, 'M', 512, 512, 512, 512],
    }
    

    其具体的结构见下图。配置里面主要储存本层的对应的in_channels.
    在这里插入图片描述

    代码

    因为VGG网络可以训练很多数据集,一般数据集的label的种类是不同的,这个时候我们需要做的就是改变最后一层的fc的weight的输出维度。也就是通过这句来声明最后的输出结果。其中num_classes代表的是这个数据集对应的label的种类数。

    self.classifier = nn.Linear(cfg[-1], num_classes)
    

    总体的代码思路是,先配置4种VGG对应的结构信息,然后通过make_layers进行构建网络。代码如下。

    import math
    import torch
    import torch.nn as nn
    from torch.autograd import Variable
    __all__ = ['vgg']
    defaultcfg = {
        11 : [64, 'M', 128, 'M', 256, 256, 'M', 512, 512, 'M', 512, 512],
        13 : [64, 64, 'M', 128, 128, 'M', 256, 256, 'M', 512, 512, 'M', 512, 512],
        16 : [64, 64, 'M', 128, 128, 'M', 256, 256, 256, 'M', 512, 512, 512, 'M', 512, 512, 512],
        19 : [64, 64, 'M', 128, 128, 'M', 256, 256, 256, 256, 'M', 512, 512, 512, 512, 'M', 512, 512, 512, 512],
    }
    class vgg(nn.Module):  
        def __init__(self, dataset='cifar10', depth=16, init_weights=True, cfg=None):
            super(vgg, self).__init__()
            if cfg is None:
                cfg = defaultcfg[depth]
    
            self.feature = self.make_layers(cfg, True)
    
            if dataset == 'cifar10':
                num_classes = 10
            elif dataset == 'cifar100':
                num_classes = 100
            elif dataset == 'imagenet':
                num_classes = 1000
            self.classifier = nn.Linear(cfg[-1], num_classes)
            if init_weights:
                self._initialize_weights()
    
        def make_layers(self, cfg, batch_norm=False):
            layers = []
            in_channels = 3
            for v in cfg:
                if v == 'M':
                    layers += [nn.MaxPool2d(kernel_size=2, stride=2)]
                else:
                    conv2d = nn.Conv2d(in_channels, v, kernel_size=3, padding=1, bias=False)
                    if batch_norm:
                        layers += [conv2d, nn.BatchNorm2d(v), nn.ReLU(inplace=True)]
                    else:
                        layers += [conv2d, nn.ReLU(inplace=True)]
                    in_channels = v
            return nn.Sequential(*layers)
    
        def forward(self, x):
            x = self.feature(x)
            x = nn.AvgPool2d(2)(x)
            x = x.view(x.size(0), -1)
            y = self.classifier(x)
            return y
    
        def _initialize_weights(self):
            for m in self.modules():
                if isinstance(m, nn.Conv2d):
                    n = m.kernel_size[0] * m.kernel_size[1] * m.out_channels
                    m.weight.data.normal_(0, math.sqrt(2. / n))
                    if m.bias is not None:
                        m.bias.data.zero_()
                elif isinstance(m, nn.BatchNorm2d):
                    m.weight.data.fill_(0.5)
                    m.bias.data.zero_()
                elif isinstance(m, nn.Linear):
                    m.weight.data.normal_(0, 0.01)
                    m.bias.data.zero_()
    

    获取每层的输出

    首先网络的结构如下所示。我们可以通过前面的标志来访问每一层。
    在这里插入图片描述
    例如,当我们通过net.feature来访问:
    在这里插入图片描述
    所以在得到中间每层的输出的时候,我们可以通过hook的方式来获取中间的输出。

    hook

    class LayerActivations:
        features = None
    
        def __init__(self, model, layer_num):
            self.hook = model[layer_num].register_forward_hook(self.hook_fn)
    
        def hook_fn(self, module, input, output):
            self.features = output.cpu()
    
        def remove(self):
            self.hook.remove()
    
    

    其中hook_fn四个参数中,module代表的是本层的结构,也就是上面的conv2d,relu等(通过前面的下标进行访问),input代表的是本层的输入,output代表的是本层的输出,也就是本层运算完的feature_map的结果。
    具体的访问如下所示:

    for i in range(10):
            i = i + 1
            net = vgg()
            x = Variable(torch.FloatTensor(1, 3, 32, 32))
            print(net)
            print(net.feature)
            feature_map = 0
            for j in range(len(net.feature)):
                conv_out = LayerActivations(net.feature, j)
                # print(conv_out)
                o = net(x)
                conv_out.remove()
                act = conv_out.features
                # print(j," ",act.shape)
                feature_map += act.shape[0] * act.shape[1] * act.shape[2] * act.shape[3] 
            params = net.state_dict()
         
            total_params = sum(p.numel() for p in net.parameters()) * 4 / 1024
            print(f'{round(total_params,2):,} kB total parameters.')
            total_trainable_params = sum(p.numel() for p in net.parameters() if p.requires_grad) * 4 / 1024
            print(f'{round(total_trainable_params,2):,} kB training parameters.')
            feature_map = feature_map / 1024
            print(f'{round(feature_map,2):,} kB feature map.')
    

    全部代码

    import math
    
    import torch
    import torch.nn as nn
    from torch.autograd import Variable
    
    
    __all__ = ['vgg']
    
    defaultcfg = {
        11 : [64, 'M', 128, 'M', 256, 256, 'M', 512, 512, 'M', 512, 512],
        13 : [64, 64, 'M', 128, 128, 'M', 256, 256, 'M', 512, 512, 'M', 512, 512],
        16 : [64, 64, 'M', 128, 128, 'M', 256, 256, 256, 'M', 512, 512, 512, 'M', 512, 512, 512],
        19 : [64, 64, 'M', 128, 128, 'M', 256, 256, 256, 256, 'M', 512, 512, 512, 512, 'M', 512, 512, 512, 512],
    }
    
    class vgg(nn.Module):  
        def __init__(self, dataset='cifar10', depth=16, init_weights=True, cfg=None):
            super(vgg, self).__init__()
            if cfg is None:
                cfg = defaultcfg[depth]
    
            self.feature = self.make_layers(cfg, True)
    
            if dataset == 'cifar10':
                num_classes = 10
            elif dataset == 'cifar100':
                num_classes = 100
            elif dataset == 'imagenet':
                num_classes = 1000
            self.classifier = nn.Linear(cfg[-1], num_classes)
            if init_weights:
                self._initialize_weights()
    
        def make_layers(self, cfg, batch_norm=False):
            layers = []
            in_channels = 3
            for v in cfg:
                if v == 'M':
                    layers += [nn.MaxPool2d(kernel_size=2, stride=2)]
                else:
                    conv2d = nn.Conv2d(in_channels, v, kernel_size=3, padding=1, bias=False)
                    if batch_norm:
                        layers += [conv2d, nn.BatchNorm2d(v), nn.ReLU(inplace=True)]
                    else:
                        layers += [conv2d, nn.ReLU(inplace=True)]
                    in_channels = v
            return nn.Sequential(*layers)
    
        def forward(self, x):
            x = self.feature(x)
            x = nn.AvgPool2d(2)(x)
            x = x.view(x.size(0), -1)
            y = self.classifier(x)
            return y
    
        def _initialize_weights(self):
            for m in self.modules():
                if isinstance(m, nn.Conv2d):
                    n = m.kernel_size[0] * m.kernel_size[1] * m.out_channels
                    m.weight.data.normal_(0, math.sqrt(2. / n))
                    if m.bias is not None:
                        m.bias.data.zero_()
                elif isinstance(m, nn.BatchNorm2d):
                    m.weight.data.fill_(0.5)
                    m.bias.data.zero_()
                elif isinstance(m, nn.Linear):
                    m.weight.data.normal_(0, 0.01)
                    m.bias.data.zero_()
    class LayerActivations:
        features = None
    
        def __init__(self, model, layer_num):
            self.hook = model[layer_num].register_forward_hook(self.hook_fn)
    
        def hook_fn(self, module, input, output):
            self.features = output.cpu()
    
        def remove(self):
            self.hook.remove()
    
    if __name__ == '__main__':
        
      
        for i in range(10):
            i = i + 1
            net = vgg()
            x = Variable(torch.FloatTensor(1, 3, 32, 32))
            print(net)
            print(net.feature)
            feature_map = 0
            for j in range(len(net.feature)):
                conv_out = LayerActivations(net.feature, j)
                # print(conv_out)
                o = net(x)
                conv_out.remove()
                act = conv_out.features
                # print(j," ",act.shape)
                feature_map += act.shape[0] * act.shape[1] * act.shape[2] * act.shape[3] 
            params = net.state_dict()
         
            total_params = sum(p.numel() for p in net.parameters()) * 4 / 1024
            print(f'{round(total_params,2):,} kB total parameters.')
            total_trainable_params = sum(p.numel() for p in net.parameters() if p.requires_grad) * 4 / 1024
            print(f'{round(total_trainable_params,2):,} kB training parameters.')
            feature_map = feature_map / 1024
            print(f'{round(feature_map,2):,} kB feature map.')
    
            print("###################################")
    
    
    
    展开全文
  • 导入数据 # 以RGB格式打开图像 # Pytorch DataLoader就是使用PIL所读取的图像格式 # 建议就用这种方法读取图像,当读入灰度图像时convert('') def get_image_info(image_dir): image_info = Image.open(image_dir)....

    使用方法

    1 加载 Model
    2 选择图片 image_dir
    3 调试model_layers 选择需要的模块
    4 显示并保存

    layers

    在这里插入图片描述

    Code

    import torch
    from torchvision import models, transforms
    from PIL import Image
    import matplotlib.pyplot as plt
    import numpy as np
    import imageio
    import torchvision.models as models
    plt.rcParams['font.sans-serif']=['STSong']
    
    model = models.resnet18(pretrained=True)
    
    # #1.1.模型查看
    # print(model)
    # model_features = list(model.children())
    # print(model_features[4][0]) #取第4层Sequential()中的第0个blk
    
    
    # #1.2 模型查看
    # from torchsummary import summary
    # summary(model.cuda(), input_size=(3, 224, 224), batch_size=-1)
    
    
    #2. 导入数据
    # 以RGB格式打开图像
    # Pytorch DataLoader就是使用PIL所读取的图像格式
    # 建议就用这种方法读取图像,当读入灰度图像时convert('')
    def get_image_info(image_dir):
        image_info = Image.open(image_dir).convert('RGB')#是一幅图片
        # 数据预处理方法
        image_transform = transforms.Compose([
            transforms.Resize(256),
            transforms.CenterCrop(224),
            transforms.ToTensor(),
            transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
        ])
        image_info = image_transform(image_info)#torch.Size([3, 224, 224])
        image_info = image_info.unsqueeze(0)#torch.Size([1, 3, 224, 224])因为model的输入要求是4维,所以变成4维
        return image_info #变成tensor数据
    
    
    
    # 获取第k层的特征图
    '''
    args:
    k:定义提取第几层的feature map
    x:图片的tensor
    model_layer:是一个Sequential()特征层
    '''
    def get_k_layer_feature_map(model_layer, k, x):
        with torch.no_grad():
            for index, layer in enumerate(model_layer):# model的第一个Sequential()是有多层,所以遍历
                x = layer(x)                           # torch.Size([1, 64, W, H])生成了64个通道
                if k == index:
                    return x
    
    
    def run_layer(model_layer, x):
        with torch.no_grad():
            x = model_layer(x)
            # [1, 64, 112, 112]
    
        return x
    
    
    
    #  可视化特征图
    def show_feature_map(feature_map, is_save=False, save_path='maps', cmap='gray', map_size:tuple=None, mpa_k:int=-1):
        '''
        :param feature_map: [1, dims, H, W]
        :return: None
        '''
    
        # 是否对其尺寸
        if map_size:
            feature_map = torch.nn.Upsample(size=map_size, mode='nearest')(feature_map)
    
        feature_map = feature_map.squeeze(0)         # [1, 64, 112, 112] -> [64, 112, 112]
    
        feature_map_num = feature_map.shape[0]       #返回通道数
        row_num = np.ceil(np.sqrt(feature_map_num))  # 8
        plt.figure()
        for index in range(feature_map_num):         #通过遍历的方式,将64个通道的tensor拿出
            single_dim = feature_map[index] # shape[112, 112]
    
            plt.subplot(row_num, row_num, index+1) # idx [1...64]
            plt.imshow(single_dim, cmap=cmap)
            # plt.imshow(single_dim, cmap='viridis')
            plt.axis('off')
    
            if is_save:
                imageio.imwrite( f"./{save_path}/{mpa_k}_" + str(index+1) + ".jpg", single_dim)
        plt.show()
    
    
    
    if __name__ ==  '__main__':
        # ------------------------------
        # 定义提取第the_maps_k层的feature map
        image_dir = "111.png"
        the_maps_k = 0
    
        image_info = get_image_info(image_dir)
        # get model
        model = models.resnet18(pretrained=True)
    
        # @ 调试这里配合 K
        model_layers= list(model.children())
        # model_layer=model_layers[0] # 这里选择model的第一个模块
    
    
        # [1] show single
        feature_map = get_k_layer_feature_map(model_layers, the_maps_k, image_info)
        show_feature_map(feature_map, is_save=False, cmap='hot', map_size=None)
    
    
        # # [2] show muti
        # for the_maps_k in [0, 4, 5, 6, 7]:
        #     feature_map = get_k_layer_feature_map(model_layers, the_maps_k, image_info)
        #     show_feature_map(feature_map, is_save=True, cmap='hot', map_size=(200, 200), mpa_k=the_maps_k)
        #     print(f"Show  Map idx : {the_maps_k}")
    
    
    

    效果

    src_img

    在这里插入图片描述

    layer-0

    在这里插入图片描述

    layer-4

    在这里插入图片描述

    layer-5

    在这里插入图片描述

    layer-6

    在这里插入图片描述

    layer-7

    在这里插入图片描述

    展开全文
  • 对应着输入特征矩阵的深度 # kernel_height 卷积核的高度 # kernel_width 卷积核的宽度 weight_t = model.state_dict()[key].numpy() # read a kernel information # k = weight_t[0, :, :, :] # ...
  • Pytorch获取中间层信息-hook函数

    千次阅读 多人点赞 2019-09-10 12:38:20
    由于pytorch会自动舍弃图计算的中间结果,所以想要获取这些数值就需要使用hook函数。hook函数包括tensor的hook和nn.Module的hook,用法相似。hook函数在使用后应及时删除,以避免每次都运行钩子增加运行负载。hook...

    参考链接:https://www.cnblogs.com/hellcat/p/8512090.html
    由于pytorch会自动舍弃图计算的中间结果,所以想要获取这些数值就需要使用hook函数。hook函数包括tensor的hook和nn.Module的hook,用法相似。hook函数在使用后应及时删除,以避免每次都运行钩子增加运行负载。hook函数主要用在获取某些中间结果的情景,如中间某一层的输出或某一层的梯度。这些结果本应写在forward函数中,但如果在forward函数中专门加上这些处理,可能会使处理逻辑比较复杂,这时候使用hook技术就更合适一些

    Tensor对象

    参考:https://pytorch.org/docs/stable/tensors.html
    有如下的register_hook(hook)方法,为Tensor注册一个backward hook,用来获取变量的梯度。
    hook必须遵循如下的格式:hook(grad) -> Tensor or None,其中grad为获取的梯度
    具体的实例如下:

    import torch
    
    grad_list = []
    def print_grad(grad):
        grad = grad * 2
        grad_list.append(grad)
    
    x = torch.tensor([[1., -1.], [1., 1.]], requires_grad=True)
    h = x.register_hook(print_grad)    # double the gradient
    out = x.pow(2).sum()
    out.backward()
    print(grad_list)
    '''
    [tensor([[ 4., -4.],
            [ 4.,  4.]])]
    '''
    # 删除hook函数
    h.remove()
    

    Module对象

    register_forward_hook(hook)register_backward_hook(hook)两种方法,分别对应前向传播和反向传播的hook函数。

    register_forward_hook(hook)

    在网络执行forward()之后,执行hook函数,需要具有如下的形式:

    hook(module, input, output) -> None or modified output
    

    hook可以修改input和output,但是不会影响forward的结果。最常用的场景是需要提取模型的某一层(不是最后一层)的输出特征,但又不希望修改其原有的模型定义文件,这时就可以利用forward_hook函数。

    import torch
    import torch.nn as nn
    import torch.nn.functional as F
    
    
    class LeNet(nn.Module):
        def __init__(self):
            super(LeNet, self).__init__()
            self.conv1 = nn.Conv2d(3, 6, 5)
            self.conv2 = nn.Conv2d(6, 16, 5)
            self.fc1 = nn.Linear(16*5*5, 120)
            self.fc2 = nn.Linear(120, 84)
            self.fc3 = nn.Linear(84, 10)
    
        def forward(self, x):
            out = F.relu(self.conv1(x))
            out = F.max_pool2d(out, 2)
            out = F.relu(self.conv2(out))
            out = F.max_pool2d(out, 2)
            out = out.view(out.size(0), -1)
            out = F.relu(self.fc1(out))
            out = F.relu(self.fc2(out))
            out = self.fc3(out)
            return out
    
    features = []
    def hook(module, input, output):
        features.append(output.clone().detach())
    
    
    net = LeNet()
    x = torch.randn(2, 3, 32, 32)
    handle = net.conv2.register_forward_hook(hook)
    y = net(x)
    
    print(features[0].size())
    handle.remove()
    

    register_backward_hook(hook)

    每一次module的inputs的梯度被计算后调用hook,hook必须具有如下的签名:

    hook(module, grad_input, grad_output) -> Tensor or None
    

    grad_inputgrad_output参数分别表示输入的梯度和输出的梯度,是不能修改的,但是可以通过return一个梯度元组tuple来替代grad_input
    展示一个实例来解析grad_inputgrad_output参数:

    import torch
    import torch.nn as nn
    
    
    def hook(module, grad_input, grad_output):
        print('grad_input: ', grad_input)
        print('grad_output: ', grad_output)
    
    
    x = torch.tensor([[1., 2., 10.]], requires_grad=True)
    module = nn.Linear(3, 1)
    handle = module.register_backward_hook(hook)
    y = module(x)
    y.backward()
    print('module_weight: ', module.weight.grad)
    
    handle.remove()
    

    输出:

    grad_input:  (tensor([1.]), tensor([[ 0.1236, -0.0232, -0.5687]]), tensor([[ 1.],
            [ 2.],
            [10.]]))
    grad_output:  (tensor([[1.]]),)
    module_weight:  tensor([[ 1.,  2., 10.]])
    

    可以看出,grad_input元组包含(bias的梯度输入x的梯度权重weight的梯度),grad_output元组包含输出y的梯度。
    可以在hook函数中通过return来修改grad_input

    import torch
    import torch.nn as nn
    
    
    def hook(module, grad_input, grad_output):
        print('grad_input: ', grad_input)
        print('grad_output: ', grad_output)
        return grad_input[0] * 0, grad_input[1] * 0, grad_input[2] * 0,
    
    
    x = torch.tensor([[1., 2., 10.]], requires_grad=True)
    module = nn.Linear(3, 1)
    handle = module.register_backward_hook(hook)
    y = module(x)
    y.backward()
    print('module_bias: ', module.bias.grad)
    print('x: ', x.grad)
    print('module_weight: ', module.weight.grad)
    
    handle.remove()
    

    输出:

    grad_input:  (tensor([1.]), tensor([[ 0.1518,  0.0798, -0.3170]]), tensor([[ 1.],
            [ 2.],
            [10.]]))
    grad_output:  (tensor([[1.]]),)
    module_bias:  tensor([0.])
    x:  tensor([[0., 0., -0.]])
    module_weight:  tensor([[0., 0., 0.]])
    

    对于没有参数的Module,比如nn.ReLU来说,grad_input元组包含(输入x的梯度),grad_output元组包含(输出y的梯度)。

    def hook(module, grad_input, grad_output):
        print('grad_input: ', grad_input)
        print('grad_output: ', grad_output)
        return (grad_input[0] / 4, )
    
    
    x = torch.tensor([-1., 2., 10.], requires_grad=True)
    module = nn.ReLU()
    handle = module.register_backward_hook(hook)
    y = module(x).sum()
    z = y * y
    z.backward()
    
    print(x.grad)  # tensor([0., 6., 6.])
    handle.remove()
    

    输出:

    grad_input:  (tensor([ 0., 24., 24.]),)
    grad_output:  (tensor([24., 24., 24.]),)
    tensor([0., 6., 6.])
    

    y = R e L U ( x 1 ) + R e L U ( x 2 ) + R e L U ( x 3 ) y=ReLU(x_{1})+ReLU(x_{2})+ReLU(x_{3}) y=ReLU(x1)+ReLU(x2)+ReLU(x3)
    z = y 2 z=y^{2} z=y2
    grad_output是传到ReLU模块的输出值的梯度,即 ∂ z ∂ y = 2 y = 24 \frac{\partial z}{\partial y}=2y=24 yz=2y=24
    grad_input是进入ReLU模块的输入值的梯度,由 ∂ y ∂ x 1 = 0 , ∂ y ∂ x 2 = 1 , ∂ y ∂ x 3 = 1 \frac{\partial y}{\partial x_{1}}=0,\frac{\partial y}{\partial x_{2}}=1,\frac{\partial y}{\partial x_{3}}=1 x1y=0,x2y=1,x3y=1,可得:
    ∂ z ∂ y ∂ y ∂ x 1 = 0 , ∂ z ∂ y ∂ y ∂ x 2 = 24 , ∂ z ∂ y ∂ y ∂ x 3 = 24 \frac{\partial z}{\partial y}\frac{\partial y}{\partial x_{1}}=0,\frac{\partial z}{\partial y}\frac{\partial y}{\partial x_{2}}=24,\frac{\partial z}{\partial y}\frac{\partial y}{\partial x_{3}}=24 yzx1y=0,yzx2y=24,yzx3y=24
    在hook函数中可以对输入值 x x x的梯度进行缩放:
    [ 0 , 24 , 24 ] / 4 = [ 0 , 6 , 6 ] [0,24,24]/4=[0,6,6] [0,24,24]/4=[0,6,6]

    展开全文
  • Pytorch获取中间层表示

    千次阅读 2019-04-26 16:44:45
    这里先只是搬运过来,https://github.com/zergtant/pytorch-handbook/blob/master/chapter4/4.1-fine-tuning.ipynb,还没测试,但觉得以后会...in_list= [] #存放待输出中间层内容 def hook(module, input, output...

    这里先只是搬运过来,https://github.com/zergtant/pytorch-handbook/blob/master/chapter4/4.1-fine-tuning.ipynb,还没测试,但觉得以后会用到。

    根据提供的方法,需要经过如下步骤:

    1)定义hook函数

    in_list= [] #存放待输出中间层内容
    def hook(module, input, output): #需要三元组输入
        for i in range(input[0].size(0)):
            in_list.append(input[0][i].cpu().numpy())

    2)待输出中间层注册hook,比如原始例子注册了avgpool层

    model.avgpool.register_forward_hook(hook)

    3)前向跑起来并保存

    with torch.no_grad():
        for batch_idx, data in enumerate(dataloader):
            x,y= data
            y_ = model(x)
    
    features=np.array(in_list)
    np.save("features",features)

     

    展开全文
  • pytorch模型中间层特征的提取

    万次阅读 热门讨论 2018-04-28 14:14:24
    参考pytorch论坛:How to extract features of an image from a trained model 定义一个特征提取的类: #中间特征提取 class FeatureExtractor(nn.Module): def __init__(self, submodule, extracted_layers): ...
  • Pytorch获取中间变量的梯度

    千次阅读 2021-01-31 00:29:14
    为了节省显存,pytorch在反向传播的过程中只保留了计算图中的叶子结点的梯度值,而未保留中间节点的梯度,如下例所示: import torch x = torch.tensor(3., requires_grad=True) y = x ** 2 z = 4 * y z....
  • Pytorch 可视化CNN中间层的输出

    万次阅读 多人点赞 2019-08-20 13:09:28
    可视化中间层的输出有助于理解输入图像如何在不同层之间进行转换。 PyTorch 提供了一个名为register_forward_hook的方法,它允许传入一个可以提取特定层输出的函数。 以下例子,使用VGG-16网络和猫狗图像分类,...
  • PyTorch保存中间变量的导数值

    千次阅读 2018-12-02 22:10:06
    在利用autograd机制时,一般只会保存函数值对输入的导数值,而中间变量的导数值都没有保留。例如: x=torch.tensor(3., requires_grad=True) x1=x**2 y=4*x1 y.backward() 查看导数值: x.grad # 输出24 x1....
  • 深度学习之图像分类(二)-- pytorch查看中间层特征矩阵以及卷积核参数深度学习之图像分类(二)pytorch查看中间层特征矩阵以及卷积核参数1. 可视化 feature maps2. 可视化 kernel weights 深度学习之图像分类(二)...
  • pytorch从基础实战

    2021-05-08 16:12:08
    1、前言 受博士学长推荐,入手了pytorch,用过都说好 ...实战部分:pytorch拟合log函数曲线,代码逐句解释,让你真正明白pytorch的运行原理 要求:提前安装好pytorch库,官方文档入口 2、基础部分 1.pytorch优势 ...
  • 1. 输入要梯度,输出必须要梯度 我们只能指定计算图的leaf节点的requires_grad变量来决定改变量是否记录梯度,而不能指定它们运算产生的节点的requires_grad,它们是否要梯度取决于它们的输入节点,它们的输入节点...
  • 处理单张图片作为网络输入。 根据给定的layer层,获取该层的输出结果features。 考虑features的形状为:[batch_size, filter_nums, H, W] 提取其中的第一个过滤器得到的结果feature。 以一张图片作为输入的情况下...
  • pytorch入门

    万次阅读 2017-06-08 17:31:16
    pytorch的入手博文,介绍了pytorch的一些语法规范,和搭建一些常用的神经网络内容,以及和tensorflow的一些比较
  • 小鱼的Pytorch撞墙撞墙墙撞墙墙墙的精通之路一:TensorTensorTensor的常用操作Torch.emptyTorch.zeroTorch.tensor功能快捷键合理的创建标题,有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮...
  • 本章主要介绍Pytorch在这几方面的工具模块,合理使用这些工具能够极大地提高编码效率。 目录 1. 数据处理 2. 计算机视觉工具包:torchvision 3. 可视化工具 4. 使用GPU加速:cuda 5. 持久化 1. 数据处理 在...
  • 搭建网络时有时需要使用VGG网络的部分结构(如图1所示),这时需要在VGG网络的中间层输出。图1所示的鉴别器网络就分别需要从Relu3_1和Relu5_1层进行输出。 图1 鉴别器网络 参考博文VGG的Pytorch实现代码,修改...
  • 将TVM集成到PyTorch

    2021-05-26 05:32:13
    将TVM集成到PyTorch 随着TVM不断展示出对深度学习执行效率的改进,很明显PyTorch将从直接利用编译器堆栈中受益。PyTorch的主要宗旨是提供无缝且强大的集成,而这不会妨碍用户。PyTorch现在具有基于TVM的官方后端...
  • Pytorch资料

    2020-11-23 15:30:15
    Pytorch知识点 知识点 Pytorch和Tensorflow的区别: 动态图还是静态图的计算。...Pytorch是动态图,可以在中间步骤调试。 Tensorflow是静态图。先定义好公式,然后给输入之后,直接进行计算。不方便调试。 ...
  • Pytorch1

    2019-05-05 15:08:48
    Pytorch安装及使用Pytorch安装Pytorch使用【注】 Pytorch安装 在Pytorch官网上[https://pytorch.org/]点击Get Started,之后选择自己电脑的配置,...选择完成后在Anaconda Prompt 中输入上图中绿色框的命令,中间会...
  • Pytorch CookBook

    2021-02-02 20:12:16
    检查 PyTorch 版本: torch.__version__ # PyTorch version torch.version.cuda # Corresponding CUDA version torch.backends.cudnn.version() # Corresponding cuDNN version torch.cuda.get_device_name(0) # GPU...
  • 有段时间一直在纠结怎么不改变原有网络结构, 直接得到网络中间层值 然后发现pytorch有这种方法_ register_forward_hook() 下面简单的介绍其用法 def get_feature(data, model, output): avgpool_layer = model...
  • 今天看了pytorch官方的tutorial,好美的教程哦,按规定是60min分钟的闪电战,结果运行完代码,花了一整天,是我不配,网站官方地址是:https://pytorch.org/tutorials/beginner/deep_learning_60min_blitz.html ...
  • Pytorch中LSTM总共有7个参数,前面3个是必须输入的 input_size– The number of expected features in the inputx hidden_size– The number of features in the hidden stateh num_layers– Number...
  • pytorch第五弹

    2019-09-25 14:45:50
    前面第四节讲了关于如何定义pytorch输入的问题,学会了简单的数据输入,下面就可以直接进行卷积神经网络了,也就是深度学习里面重要的一环,网络结构的搭建–构建前向传播的过程。 卷积操作 深度学习中最为基础的...
  • 将TVM集成到PyTorch

    2021-03-04 05:38:39
    将TVM集成到PyTorch上 随着TVM不断展示出对深度学习执行效率的改进,很明显PyTorch将从直接利用编译器堆栈中受益。PyTorch的主要宗旨是提供无缝且强大的集成,而这不会妨碍用户。为此,PyTorch现在具有基于TVM的官方...
  • pytorch笔记

    2019-03-08 10:15:34
    (1)tensor是pytorch中的高维数组,与numpy的ndarrays类似(二者之间可相互转化),可使用gpu加速。 (2)函数名后带_,会修改tensor本身的值。(例如x.add(y)与x.add_(y)不一样。前者会加tensor x上,后者会返回...
  • 文章目录背景准备工作简单案例Pytorch->ONNXONNX->TensorRT复杂案例编译自定义算子并运行demo转换为onnx准备步骤转换代码异常解析自定义算子转换为Tensorrt转换...在实际工作当中,训练的模型实际使用还需要有
  • PyTorch简介

    2020-04-03 12:29:37
    代码实例理解PyTorch 介绍 PyTorch是增长最快的深度学习框架。PyTorch也非常具有Python风格,注重简洁和实用。 此外,也有一些使用者说,使用PyTorch甚至可以改善健康。 动机 网上有许多PyTorch教程,它的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 7,839
精华内容 3,135
关键字:

pytorch输入到中间