代码整理

1.python中开辟数组：

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

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

2.enumerate函数的用法

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

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

（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

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

8.pytorch的contiguous的使用

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

（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（）

 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是按照列拼接。