代码整理

￡神魔★判官ぃ 2022-11-10 05:27 265阅读 0赞

**1.python中开辟数组：**

dataset = [None]*3
    dataset[0] = 1
    dataset[1] = 2
    print(dataset)
    print(len(dataset))

dataset = [None]*3 #开辟一个长度为3的空数组

**2.enumerate函数的用法**

enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，

![20210316144227978.png][]

![20210316144253328.png][]

**3.np.empty()函数用法：**

创建一个以为或者多维数组。

np.empty(shape(,dtype,oreder))

**4.isinstance()**

判断数据是否是一个已知的数据类型。

isinstance(a,int)  #判断a是否是int类型，返回值为True ，Flase

**5.nn.Squential介绍：**

**Sequential似乎是一个容器，可以作为一个容器包装几个层。**

**Squential三个用法**

**（1）最简单的序贯模型**

import torch.nn as nn
    model = nn.Sequential(
                      nn.Conv2d(1,20,5),
                      nn.ReLU(),
                      nn.Conv2d(20,64,5),
                      nn.ReLU()
                    )
     
    print(model)
    print(model[2]) # 通过索引获取第几个层
    '''运行结果为：
    Sequential(
      (0): Conv2d(1, 20, kernel_size=(5, 5), stride=(1, 1))
      (1): ReLU()
      (2): Conv2d(20, 64, kernel_size=(5, 5), stride=(1, 1))
      (3): ReLU()
    )
    Conv2d(20, 64, kernel_size=(5, 5), stride=(1, 1))
    '''

这样做的问题是每一个层是没有名称，默认的是0，1，2，3来命名的。

（2）给每一个层添加一个名称

import torch.nn as nn
    from collections import OrderedDict
    model = nn.Sequential(OrderedDict([
                      ('conv1', nn.Conv2d(1,20,5)),
                      ('relu1', nn.ReLU()),
                      ('conv2', nn.Conv2d(20,64,5)),
                      ('relu2', nn.ReLU())
                    ]))
     
    print(model)
    print(model[2]) # 通过索引获取第几个层
    '''运行结果为：
    Sequential(
      (conv1): Conv2d(1, 20, kernel_size=(5, 5), stride=(1, 1))
      (relu1): ReLU()
      (conv2): Conv2d(20, 64, kernel_size=(5, 5), stride=(1, 1))
      (relu2): ReLU()
    )
    Conv2d(20, 64, kernel_size=(5, 5), stride=(1, 1))
    '''

从结果可以看出，此时每一层都有了自己的名称，但是并不能通过名称直接获取层，只能通过索引index。

model\[2\] 是正确的

model\["conv2"\] 是**错误**的

这其实是由它的定义实现的，看上面的Sequenrial定义可知，只支持index访问。

（3）

import torch.nn as nn
    from collections import OrderedDict
    model = nn.Sequential()
    model.add_module("conv1",nn.Conv2d(1,20,5))
    model.add_module('relu1', nn.ReLU())
    model.add_module('conv2', nn.Conv2d(20,64,5))
    model.add_module('relu2', nn.ReLU())
     
    print(model)
    print(model[2]) # 通过索引获取第几个层

5.nn.ReLU()激活函数

nn.ReLU(inplace=True)  #inplace=True将会改变输入的数据，否则只会改变原输入，只会产生新的输出。

6.nn.Squential()与nn.ModuleList()区别

[https://zhuanlan.zhihu.com/p/75206669][https_zhuanlan.zhihu.com_p_75206669]

（1）nn.ModuleList中的层无联系，其联系是通过forward函数来确定的。而Squential中的模块，是有顺序的，则后一层的输入必须是前一层的输出。

（2）nn.Squential()内部实现了forward函数，而nn.ModuleList()内部没有实现forword函数

7.x.view(x.size(0),-1)\#将多维的Tensor展平成一维。

其实，左边规定行数，右边规定列数。

import torch
    
    a = torch.arange(1,17)#一维张量,16个数
    print(a)
    print(a.size())
    a = a.view(1,a.size(0))#一行，16列，如果是a = a.view(a.size(0),-1)就是16行一列
    print(a)
    print(a.size())
    
    '''
    tensor([ 1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16])
    torch.Size([16])
    tensor([[ 1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16]])
    torch.Size([1, 16])
    '''

x.size(0)\#x的大小 与x.size()的区别

import torch
    a = torch.arange(1,17)
    print(a)
    print(a.size(0))
    print(a.size())
    '''
    tensor([ 1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16])
    16
    torch.Size([16])
    '''

博客上说的很详细。[https://nickhuang1996.blog.csdn.net/article/details/86569501][https_nickhuang1996.blog.csdn.net_article_details_86569501]

注意：调用view前最好先用contiguous，x.contiguous().view()因为view需要tensor的内存是整块的。

8.pytorch的contiguous的使用

[https://zhuanlan.zhihu.com/p/64376950][https_zhuanlan.zhihu.com_p_64376950]

返回一个内存连续的有相同数据的tensor，如果原tensor内存连续，则返回原tensor

contiguous 一般与transpose，permute，view搭配使用；使用transpose或permute进行维度变化后，调用contiguous，然后方可使用view对维度进行变形。

x = torch.Tensor(2,3)
    y = x.permute(1,0)         # permute：二维tensor的维度变换，此处功能相当于转置transpose
    y.view(-1)                 # 报错，view使用前需调用contiguous()函数
    y = x.permute(1,0).contiguous()
    y.view(-1)                 # OK

9.pytorch中named\_children（）和named\_modules（）的区别

[https://blog.csdn.net/watermelon1123/article/details/98036360][https_blog.csdn.net_watermelon1123_article_details_98036360]

（1）从定义上讲：

named\_children（）

> 返回包含子模块的迭代器，同时产生模块的名称以及模块本身。

named\_modules()

> 返回网络中所有模块的迭代器，同时产生模块的名称以及模块本身。

for name, module in self.layers.named_children():#获取layers的子模型，两个变量，一个获取层的模型的名字，一个获取模型。
                if name == in_layer:
                    run = True
                if run:
                    x = module(x)#分别执行每一层的模型。
                    if name == 'conv3':#前三层为卷积，后面为全连接，因为要对张量进行维度的转换，所以执行完第三次的卷积以后，要对张量进行维度的转换。
                        x = x.contiguous().view(x.size(0), -1)
                    if name == out_layer:#执行完最后一层后，要返回模型。
                        return x

10。softmax（）

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h1YW45NzExMzA_size_16_color_FFFFFF_t_70][]

pos_loss = -F.log_softmax(pos_score, dim=1)[:, 1]#相比softmax多了一个log操作。dim=1对行做softmax操作，dim = 0，对列做softmax操作
     neg_loss = -F.log_softmax(neg_score, dim=1)[:, 0]

11.torch.cat()

torch.cat是将两个张量（tensor）拼接在一起,

torch.cat((A,B),0)#0是按照拼接，1是按照列拼接。

[20210316144227978.png]: /images/20221023/633f90b8e12e47cb9aebf32f846e4c3b.png
[20210316144253328.png]: /images/20221023/adb289fdd26147d488d53b5ef7015247.png
[https_zhuanlan.zhihu.com_p_75206669]: https://zhuanlan.zhihu.com/p/75206669
[https_nickhuang1996.blog.csdn.net_article_details_86569501]: https://nickhuang1996.blog.csdn.net/article/details/86569501
[https_zhuanlan.zhihu.com_p_64376950]: https://zhuanlan.zhihu.com/p/64376950
[https_blog.csdn.net_watermelon1123_article_details_98036360]: https://blog.csdn.net/watermelon1123/article/details/98036360
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h1YW45NzExMzA_size_16_color_FFFFFF_t_70]: /images/20221023/e0f1719375364bbb855a5c0fe5d0cf5e.png