pytorch学习笔记

1
2
3
4
5

import torch
x=torch.tensor(2.5)
print(x.dtype)
>>torch.float32#torch默认的数据类型为float32

1
2
3
4

#如何将tensor的数据类型转换？
#在Tensor后加 .long(), .int(), .float(), .double()等即可
x.half()
>>tensor(2.5000, dtype=torch.float16)

1
2
3
4
5
6
7

#将numpy.ndarray转换为tensor:
    a=numpy.array([1,2,3])
    a.dtype
    >>dtype('int32')
    t=torch.from_numpy(a)
    t
    >>tensor([1, 2, 3], dtype=torch.int32)

1
2
3
4
5

#torch.zeros_like(input)->生成一个与input相同size的零矩阵,同理还有torch.ones_like(input);torch.randn_like(input)
input=torch.ones(2,3)
torch.zeros_like(input)
>>tensor([[0., 0., 0.],
        [0., 0., 0.]])

1
2
3
4
5
6

#torch.arange() 和torch.range()的区别
#Note that arange generates values in [start; end), not [start; end].
torch.arange(1,4)
>>tensor([1, 2, 3])
torch.range(1,6)
>>tensor([1., 2., 3., 4., 5., 6.])

1
2
3
4
5
6
7

#torch.full(size,fill_value)
#Returns a tensor of size size filled with fill_value.常用于GAN训练中的真假标签赋值
torch.full((2,3),3.1415)
>>tensor([[3.1415, 3.1415, 3.1415],
        [3.1415, 3.1415, 3.1415]])
torch.full((2,),3.14)#注意size的表达形式（*，*）或者是（*，*，*）；不能使用（*）
>>tensor([3.1400, 3.1400])

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

#torch.cat(tensor,dim)
#将输入的张量在指定的维度上进行叠加
x=torch.ones(2,2,)
torch.cat((x,x),0)
>>tensor([[1., 1.],
        [1., 1.],
        [1., 1.],
        [1., 1.]])
torch.cat((x,x),1)
>>tensor([[1., 1., 1., 1.],
        [1., 1., 1., 1.]])

#torch.split(tensor,split_size,dim)
#将输入张量在指定维度上分为特定的份
a=torch.randn(4,4)
a
>>tensor([[-1.0159,  0.2249, -0.0083,  0.4495],
        [-0.5427,  0.0253,  0.3100, -1.8563],
        [ 0.6721, -0.5261, -0.1104,  1.5312],
        [ 0.4096, -1.4238,  0.5939,  0.2700]])
b=torch.split(a,2,0)
b
>>tensor([[-1.0159,  0.2249, -0.0083,  0.4495],
        [-0.5427,  0.0253,  0.3100, -1.8563],
        [ 0.6721, -0.5261, -0.1104,  1.5312],
        [ 0.4096, -1.4238,  0.5939,  0.2700]])

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

#torch.reshape(input,shape)
#将input重构为shape的形状
a=torch.randn(4,4)
a=torch.reshape(a,(2,8))
a.shape
>>torch.Size([2, 8])

a=torch.reshape(a,(-1,))
#当某一维度为-1时，这一维度的形状不用管，根据input和另一维度计算形状。当另一维度的表达式没有时，就讲input按照“某一维度为-1”的维度排列input
a.shape
>>torch.Size([16])

a=torch.reshape(a,(-1,8))
a.shape
torch.Size([2, 8])

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

#torch.squeeze(input,dim)
#将输入张量维度为1的size去掉
x=torch.randn(2,1,3,1,4)
x.shape
>>torch.Size([2, 1, 3, 1, 4])
y=torch.squeeze(x)#如果不指定维度就会将所有维度为1的size去掉，如果加了维度，只会在指定维度上
y.shape
>>torch.Size([2, 3, 4])
#torch.unsqueeze(input,dim)
#在指定维度插入size=1
x=torch.randn(4)
x.shape
>>torch.Size([4])
torch.unsqueeze(x,0).shape
>>torch.Size([1, 4])
torch.unsqueeze(x,1).shape
>>torch.Size([4, 1])

1
2
3

#autograd 包是 PyTorch 中所有神经网络的核心.该 autograd 软件包为 Tensors 上的所有操作提供自动微分
#####动态计算图（DCG）->由autograd动态生成。这个图的叶节点是输入张量，根节点是输出张量。梯度是通过跟踪从根到叶的图形，并使用链式法则将每个梯度相乘来计算的。

1
2
3
4
5
6
7
8

tensor(data, dtype=None, device=None, requires_grad=False) -> Tensor
 
#参数:
#    data： (array_like): tensor的初始值. 可以是列表，元组，numpy数组，标量等;
#    dtype： tensor元素的数据类型
#    device： 指定CPU或者是GPU设备，默认是None
#    requires_grad：是否可以求导，即求梯度，默认是False，即不可导的
#	注意data必须为浮点数才可导

1
2
3
4
5
6

#参考：https://blog.csdn.net/qq_27825451/article/details/89393332
###求导的核心函数-torch.autograd.backward
backward(gradient=None, retain_graph=None, create_graph=False)
#在pytorch中，默认是标量对标量求导或者是标量对向量求导
#向量对向量求导->当使用向量对向量求导时需要设置gradient的参数
#一个计算图在进行反向求导之后，为了节省内存，这个计算图就销毁了。 如果你想再次求导，就会报错。那怎么办呢？遇到#这种问题，我们可以通过设置 retain_graph=True 来保留计算图

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

#标量对标量求导
x=torch.tensor(3.0,requires_grad=True)
y=torch.pow(x,2)
 
#判断x,y是否是可以求导的
print(x.requires_grad)
print(y.requires_grad)
 
#求导，通过backward函数来实现
y.backward()  
 
#查看导数，也即所谓的梯度
print(x.grad)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

#标量对向量求导
#在深度学习中，损失函数一般为标量，即将所有项的损失相加。而输入一般为多维张量
#例:1：
#x->(1,3),w->(3,1)
#输出y是一个标量
#创建一个多元函数，即Y=XW+b=Y=x1*w1+x2*w2*x3*w3+b，x不可求导，W,b设置可求导
X=torch.tensor([1.5,2.5,3.5],requires_grad=False)
W=torch.tensor([0.2,0.4,0.6],requires_grad=True)
b=torch.tensor(0.1,requires_grad=True)
Y=torch.add(torch.dot(X,W),b)
 
 
#判断每个tensor是否是可以求导的
print(X.requires_grad)
print(W.requires_grad)
print(b.requires_grad)
print(Y.requires_grad)
 
 
#求导，通过backward函数来实现
Y.backward()  
 
#查看导数，也即所谓的梯度
print(W.grad)
print(b.grad)
 
'''运行结果为：
False
True
True
True
tensor([1.5000, 2.5000, 3.5000])
tensor(1.)
'''
#例子2：
'''
x 是一个（2,3）的矩阵，设置为可导，是叶节点，即leaf variable
y 是中间变量,由于x可导，所以y可导
z 是中间变量,由于x，y可导，所以z可导
f 是一个求和函数，最终得到的是一个标量scaler
'''
 
x = torch.tensor([[1.,2.,3.],[4.,5.,6.]],requires_grad=True)
y = torch.add(x,1)
z = 2*torch.pow(y,2)
f = torch.mean(z)  

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

#这样就可以手动求出f对于x11,x12,x13,x21,x22,x23的导数了
#验证：
print(x.requires_grad)
print(y.requires_grad)
print(z.requires_grad)
print(f.requires_grad)
print('===================================')
f.backward()
print(x.grad)
 
'''运行结果为：
True
True
True
True
===================================
tensor([[1.3333, 2.0000, 2.6667],
        [3.3333, 4.0000, 4.6667]])
'''

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

#向量对向量求导
#例子1：
'''
x 是一个（2,3）的矩阵，设置为可导，是叶节点，即leaf variable
y 也是一个（2,3）的矩阵，即
y=x^2+x (x的平方加x)
实际上，就是要y的各个元素对相对应的x求导
'''
 
x = torch.tensor([[1.,2.,3.],[4.,5.,6.]],requires_grad=True)
y = torch.add(torch.pow(x,2),x)
 
gradient=torch.tensor([[1.0,1.0,1.0],[1.0,1.0,1.0]])#参数都为1
 
y.backward(gradient)
 
print(x.grad)
 
'''运行结果为：
tensor([[ 3.,  5.,  7.],
        [ 9., 11., 13.]])
'''

#例子2：
x = torch.tensor([1.,2.,3.],requires_grad=True)
y = torch.pow(x,2)
 
gradient=torch.tensor([1.0,1.0,1.0])
y.backward(gradient)
print(x.grad)
'''得到的结果：
tensor([2., 4., 6.])   这和我们期望的是一样的
'''  
gradient=torch.tensor([1.0,0.1,0.01])
 
'''输出为：
tensor([2.0000, 0.4000, 0.0600])
'''
#从结果上来看，就是第二个导数缩小了十倍，第三个导数缩小了100倍，这个倍数和gradient里面的数字是息息相关的。
#dy/dx=0.1*dy1/dx+1.0*dy2/dx+0.0001*dy3/dx
#总结：gradient参数的维度与最终的函数y保持一样的形状，每一个元素表示当前这个元素所对应的权

1
2
3
4

import torch
import torch.nn as nn#用于定义神经网络模型
import torch.nn.functional as f#用于激活函数的调用
import torch.optim as optim#用于更新梯度

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

import torch
import torch.nn
import torch.nn as nn
import torch.optim as optim

class Net(nn.Module):
    def __init__(self,D_in,H,D_out):
        super(Net,self).__init__()
        self.fc1=nn.Linear(D_in,H)
        self.fc2=nn.Linear(H,D_out)

    def forward(self,x):
        h_relu=self.fc1(x)
        y_pred=self.fc2(h_relu)
        return y_pred

N,D_in,H,D_out=64,1000,100,10

x=torch.rand(N,D_in)#定义输入数据
y=torch.rand(N,D_out)#定义labels

#实例化Net
net=Net(D_in,H,D_out)
#定义损失函数
criterion=nn.MSELoss()
#定义更新方式
opt=optim.SGD(net.parameters(),lr=0.001)


#进行前向传播、损失函数计算、梯度清零、梯度计算、梯度更新
for i in range(500):
    y_pred=net(x)#前向传播
    loss=criterion(y_pred,y)#损失函数计算、
    print(i,loss.item())

    opt.zero_grad()#梯度清零
    loss.backward()#梯度计算
    opt.step()#梯度更新

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

import torch
from torchvision import transforms, datasets
#from torch.utils.data.dataloader import DataLoader

#transforms的功能为对输入数据进行预处理，包括了Rescale：缩放图片；RandomCrop:对图片进行随机剪裁；ToTensor:把numpy格式的图片转换为tensor格式的图片
#transforms.Compose表示将这几类转换结合，进行组合转换

#另外transforms.Normalize的工作原理如下例所示：
#    transform.ToTensor(),
#    transform.Normalize((0.5,0.5,0.5),(0.5,0.5,0.5))
#那transform.Normalize()是怎么工作的呢？以上面代码为例，ToTensor()能够把灰度范围从0-255变换到0-1之间，而后面的transform.Normalize()则把0-1变换到#(-1,1).具体地说，对每个通道而言，Normalize执行以下操作：
#image=(image-mean)/std
#其中mean和std分别通过(0.5,0.5,0.5)和(0.5,0.5,0.5)进行指定。原来的0-1最小值0则变成(0-0.5)/0.5=-1，而最大值1则变成(1-0.5)/0.5=1.
#
data_transform = transforms.Compose([
transforms.RandomSizedCrop(224),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
])

#ImageFolder是一个数据集类，它假定数据集是以如下方式构造的：
#root/ants/xxx.png
#root/ants/xxy.jpeg
#root/ants/xxz.png
#.
#.
#.
#root/bees/123.jpg
#root/bees/nsdf3.png
#root/bees/asd932_.png
#

hymenoptera_dataset = datasets.ImageFolder(root='hymenoptera_data/train',
transform=data_transform)

#Dataloader 作为迭代器，每次产生一个 batch 大小的数据
#
dataset_loader = torch.utils.data.DataLoader(hymenoptera_dataset,
batch_size=4, shuffle=True,
num_workers=4)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

#Dataset和DataLoader的区别
#
#
#在pytorch中用一个类来抽象的表示数据集，即数据集类，常用的数据集类为Dataset和ImageFloder
#DataLoader做为一个迭代器，每次产生一个batch大小的数据。

#
#
#举例：
from torchvision import transforms, datasets
from torch.utils.data.dataloader import DataLoader
train_loader = DataLoader(
    datasets.MNIST('../data', train=True, download=True,
                   transform=transforms.Compose([
                       transforms.ToTensor(),
                       transforms.Normalize((0.1307,), (0.3081,))
                   ])),
    batch_size=batch_size, shuffle=True)
#datasets.MNIST()是一个torch.utils.data.Datasets对象，batch_size表示我们定义的batch大小（即每轮训练使用的批大小），shuffle表示是否打乱数据顺序（对于整个datasets里包含的所有数据）
#
#一般如何加载DataLoader中的数据进行训练以及测试？
#
epochs=10#定义epochs次数
for epoch in range(epochs)：
	for batch_idx, (data, label) in enumerate(train_loader):
    #batch_idx表示加载的第几批数据（数据以batch的形式进行加载，每一批中有每次产生一个batch大小的数据）、
    #data表示这一批中的训练数据，label表示相应data的标签
        optimizer.zero_grad()
        .
        .
        .
     
        

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

#自定义数据集类
#torch.utils.data.Dataset 是表示数据集的抽象类，因此自定义数据集应该继承Dataset并覆盖以下方法__len__ 实现len(dataset) 返还数据集尺寸。__getitem__用来获取索引数据

from torch.utils.data import Dataset
from pathlib import Path
import os.path

class FlatFolderDataset(Dataset):
    def __init__(self, root, transform):
        super(FlatFolderDataset, self).__init__()
        self.root = root
        self.paths = list(Path(self.root).glob('*'))#将path路径下的文件以列表的形式存放，在__init__ 中读取文件内容,list存放的是文件的路径
        self.transform = transform

    def __getitem__(self, index):#构造加载一个patch的数据集
        path = self.paths[index]#在__getitem__中按照索引读取图片
        img = Image.open(str(path)).convert('RGB')
        img = self.transform(img)#并进行必要的转换
        return img#返回图像，即训练数据

    def __len__(self):
        return len(self.paths)#可以设置返回的训练集大小

    def name(self):
        return 'FlatFolderDataset'

    
    

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74

import torch
from torch.utils.data import Dataset, DataLoader
from pathlib import Path
from PIL import Image
from tqdm import tqdm
from torchvision import transforms
import os.path
import matplotlib.pyplot as plt


class FlatFolderDataset(Dataset):
    def __init__(self, style_root, content_root, transform=None):
        super(FlatFolderDataset, self).__init__()
        self.style_root = style_root
        self.style_paths = list(Path(self.style_root).glob('*'))  # 将path路径下的文件路径以列表的形式存放,list存放的是文件的路径
        self.transform = transform

        self.content_root = content_root
        self.content_paths = list(Path(self.content_root).glob('*'))  # 将path路径下的文件路径以列表的形式存放,list存放的是文件的路径

    def __getitem__(self, index):
        style_path = self.style_paths[index]  # 通过索引的方式获取图片路径
        style_img = Image.open(str(style_path)).convert('RGB')  # 获取图片
        style_img = self.transform(style_img)  # 对图像进行必要的处理

        content_path = self.content_paths[index]  # 通过索引的方式获取图片路径
        content_img = Image.open(str(content_path)).convert('RGB')  # 获取图片
        content_img = self.transform(content_img)  # 对图像进行必要的处理

        return {'style_img': style_img, 'content_img': content_img}

    def __len__(self):
        return len(self.style_paths)

    def name(self):
        return 'FlatFolderDataset'


def train_transform():
    transform_list = [
        # transforms.Resize(size=(512, 512)),
        # transforms.RandomCrop(256),
        transforms.ToTensor(),
        transforms.Normalize(mean=[0.5, 0.5, 0.5],
                             std=[0.5, 0.5, 0.5])

    ]
    return transforms.Compose(transform_list)


train_transform = train_transform()

style_dir = "/home/wag/ssl/kongfupainter/gan-getting-started" + "/monet_jpg"
# style_dataset = FlatFolderDataset(style_dir)  # 加载训练数据集
# print(len(style_dataset))
content_dir = "/home/wag/ssl/kongfupainter/gan-getting-started" + "/photo_jpg"
# content_dataset = FlatFolderDataset(content_dir)  # 加载训练数据集
# print(len(content_dataset))

data_set = FlatFolderDataset(style_dir, content_dir, train_transform)
print(len(data_set))

data_loader = DataLoader(data_set, batch_size=6, shuffle=True)

for i, data in enumerate(data_loader):
    style = data['style_img']
    content = data['content_img']
    # print(style.shape)
    # print(content.shape)
    # print(i)

# print(len(content))

1
2
3
4
5
6
7
8

import argparse

parser = argparse.ArgumentParser(description="your script description")  # description参数可以用于插入描述脚本用途的信息，可以为空

parser.add_argument('--verbose', required=True, type=int)  #这种模式用于确保某些必需的参数有输入。 required标签就是说--verbose参数是必需的，并且类型为int，输入别的类型会报错。

parser.add_argument('filename', default='text.txt') #一般情况下会设置一些默认参数从而不需要每次输入某些不需要变动的参数，利用default参数即可实现。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

#argparse 是 Python 内置的一个用于命令项选项与参数解析的模块，通过在程序中定义好我们需要的参数，argparse 将会从 sys.argv 中解析出这些参数，并自动生成帮助和使用信息。

#简单示例

#我们先来看一个简单示例。主要有三个步骤：

 #   创建 ArgumentParser() 对象
  #  调用 add_argument() 方法添加参数
   # 使用 parse_args() 解析添加的参数



import argparse
 
parser = argparse.ArgumentParser()
parser.add_argument('--sparse', action='store_true', default=False, help='GAT with sparse version or not.')#action - 命令行遇到参数时的动作，默认值是 False。
parser.add_argument('--seed', type=int, default=72, help='Random seed.')
parser.add_argument('--epochs', type=int, default=10000, help='Number of epochs to train.')
 
args = parser.parse_args()
 
print(args.sparse)
print(args.seed)
print(args.epochs)
>>
False
72
10000

1
2
3
4
5

parser.add_argument('--sparse',action='store_true',help='GAT')#默认为False
args=parser.parse_args()
print(args.sparse)
>>
False

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54

import numpy as np
import pandas as pd

data = pd.DataFrame(np.arange(16).reshape(4, 4), index=list('abcd'),
                    columns=list('ABCD'))
print(data)
>>
 A   B   C   D
a   0   1   2   3
b   4   5   6   7
c   8   9  10  11
d  12  13  14  15

print(data.loc['a'])
A    0
B    1
C    2
D    3
Name: a, dtype: int64
        
print(data.iloc[1])
A    4
B    5
C    6
D    7
Name: b, dtype: int64
        
#loc函数：通过行索引 “Index” 中的具体值来取行数据（如取"Index"为"A"的行）
#iloc函数：通过行号来取行数据（如取第二行的数据）

#利用loc、iloc提取列数据
print(data.loc[:,['A']]) # #取'A'列所有行，多取几列格式为 data.loc[:,['A','B']]
>>
    A
a   0
b   4
c   8
d  12
print(data.iloc[:,[0]])
>>
  	A
a   0
b   4
c   8
d  12


for i in range(4):
    print(data.iloc[i]['A'],data.iloc[i]['B'])
>>
0 1
4 5
8 9
12 13

1
2
3
4
5
6
7
8
9

class Fun:
    def __init__(self, x_list):
        pass
    
    def __getitem__(self, idx):
        pass
    
    def __len__(self):
        pass

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

def __init__(self, x_list):
        """ initialize the class instance
        Args:
            x_list: data with list type
        Returns:
            None
        """
        if not isinstance(x_list, list):
            raise ValueError("input x_list is not a list type")
        self.data = x_list
        print("intialize success")

#函数中的self.data是非常重要的实例属性，后面的两个方法的意义实际上就是来获取这个实例属性的信息。

#那么__init__函数是什么时候被调用的呢？其实它是在对象创建时被解释器自动调用的，现在创建一个实例试一试：

fun = Fun(x_list=[1, 2, 3, 4, 5])

#终端会输出下面的字符串，说明__init__()函数被调用了：

>>intialize success

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

class Student{
    private String name;//field
    private int age;//field,相当于python中的self.data
    
    public Student(String name,int age){//java中的构造方法用于实例初始化
        this.name=name;
        this.age=age;
    }
       
}

public class Main{
	public static void main(String[] args){
        Student s1=new Student("xiaohong",18);//构建实例时用于初始化
    }
}

1
2
3

def __getitem__(self, idx):
        print("__getitem__ is called")
        return self.data[idx]

1

print(fun[2])

1
2

__getitem__ is called
3

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

class Student{
    private String name;//field
    private int age;//field,相当于python中的self.data
    
    public Student(String name,int age){//java中的构造方法用于实例初始化
        this.name=name;
        this.age=age;
    }
    
    public String getName(){//读取实例field
        return this.name;
    }
       
}

public class Main{
	public static void main(String[] args){
        Student s1=new Student("xiaohong",18);//构建实例时用于初始化
        System.out.print(s1.getName);
    } 
}

1
2

name = ["Li Hua", "Daming", "Honghong"]
print(len(name))

1
2
3

def __len__(self):
        print("__len__ is called")
        return len(self.data)

1

print(len(fun))

1
2

__len__ is called
5

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

class Fun():
    def __init__(self, x_list):
        if not isinstance(x_list, list):
            raise ValueError("input error")
        self.data = x_list
        print("init success")

    def __getitem__(self, item):
        print("__getitem__ is called")
        return self.data[item]

    def __len__(self):
        print("__len__ is called")
        return len(self.data)


fun = Fun([1, 2, 3])
print(fun[2])
print(len(fun))

#输出为：
#init success
#__getitem__ is called
#3
#__len__ is called
#3

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

m = nn.Sequential(nn.Linear(2,2), 
                  nn.ReLU(),
                 nn.Sequential(nn.Sigmoid(), nn.ReLU()))

m.modules()
>>
[Sequential(
   (0): Linear(in_features=2, out_features=2)
   (1): ReLU()
   (2): Sequential(
     (0): Sigmoid()
     (1): ReLU()
   )
 ), Linear(in_features=2, out_features=2), ReLU(), Sequential(
   (0): Sigmoid()
   (1): ReLU()
 ), Sigmoid(), ReLU()]


#用list举例就是：
a=[1,2,[3,4]]
#modules返回
[1,2,[3,4]], 1, 2, [3,4], 3, 4

1
2

device = torch.device("cuda:0")
model.to(device)#默认只使用一个GPU进行训练

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

# CUDA_VISIBLE_DEVICES设置说明，设置device对程序可见

#CUDA_VISIBLE_DEVICES=1 // 仅使用device1 (即卡一)

#CUDA_VISIBLE_DEVICES=0,1 // 仅使用device 0和 device1

#CUDA_VISIBLE_DEVICES="0,1" // 同上, 仅使用device 0和 device1

#CUDA_VISIBLE_DEVICES=0,2,3 // 仅使用device 0, device2和device3

#CUDA_VISIBLE_DEVICES=2,0,3 // 仅使用device0, device2和device3


#设置临时的环境变量
Linux： export CUDA_VISIBLE_DEVICES=2,3
windows:  set CUDA_VISIBLE_DEVICES=2,3
#或者使用
os.environ["CUDA_VISIBLE_DEVICES"] = "2, 3"
#设置上面两行代码后，那么对这个程序而言可见的只有2和3号卡，和其他的卡没有关系，这是物理上的号卡，逻辑上来说其实是对应0和1号卡，即device_ids[0]对应的就是第2号卡，device_ids[1]对应的就是第3号卡。（当然你要保证上面这两行代码需要定义在以下代码之前）
device_ids = [0, 1]
net = torch.nn.DataParallel(net, device_ids=device_ids)


#device为程序可见的0号开始可用的GPU编号
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")

#Model为用户的网络模型
model = Model()
if torch.cuda.device_count() > 1:
  model = nn.DataParallel(model)#使用多个GPU并行处理       在全部GPU上训练
  #model = nn.DataParallel(model,device_ids=[0,1,2,3])  可以指定在哪个GPU上训练，这里指定在0,1,2,3号GPU上训练（注意是以list的方式传入的）,这个的作用与设置CUDA_VISIBLE_DEVICES=0,1,2,3是一样的

model.to(device)
#model.cuda()与model.to(device)的效果是一样的
#


input = data.to(device)#输入数据也需要放入device中进行处理


官方解释：
# DataParallel splits your data automatically and sends job orders to multiple
# models on several GPUs. After each model finishes their job, DataParallel
# collects and merges the results before returning it to you.




#在跑程序的时候出现了一个bug提示：AttributeError: 'DataParallel' object has no attribute '**'

#这次参考了：https://github.com/jytime/Mask_RCNN_Pytorch/issues/2

#其中提到，因为使用torch.nn.DataParallel而造成了AttributeError: 'DataParallel' object has no attribute '**'，‘**’为用户自定义的模型中的函数，此时因为使用了DataParallel函数对原本用户定义的model进行了包装，原model变为了DataParallel的一个子模块。

#因此想要再次调用原model中的函数，需要将原本的model.load()函数变为model.module.load()形式。其中load()为我在model中自定义的函数，综上，在model与函数中间加入.module即可。

1
2
3
4
5

#并行训练
os.environ["CUDA_VISIBLE_DEVICES"] = "2, 3"#指定程序可见GPU
device_ids = [0, 1]
model = torch.nn.DataParallel(m, device_ids=device_ids)#将数据切分到device上
model.to(device)#或者是model.cuda()

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

    import matplotlib.pyplot as plt
    plt.ion()    # 打开交互模式
    # 同时打开两个窗口显示图片
    plt.figure()  #图片一
    plt.imshow(i1)
    plt.figure()    #图片二
    plt.imshow(i2)
    # 显示前关掉交互模式
    plt.ioff()
    plt.show()

1
2
3
4

x=[1,2,3]
b=[x+1 for x in x]
print(b)
>>[2, 3, 4]

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

x=[1,2,3]
b=iter(x)
next(b)
>>
1

#判断一个对象是否为可迭代对象
from collections import Iterable
isinstance('abc',Iterable)#str是否可迭代
>>True

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

import copy

a=[1,2,[3,4]]
copy1=copy.copy(a)
copy2=copy.deepcopy(a)
copy1==copy2
>>Ture
copy1 is copy2
>>False

#当改变a的值时
a[2][0]=9
a
>>[1, 2, [9, 4]]
copy1
>>[1, 2, [9, 4]]
copy2
>>[1, 2, [3, 4]]

a[1]=5
>>[1, 5, [9, 4]]
copy1
>>[1, 2, [9, 4]]
copy2
>>[1, 2, [3, 4]]

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

import torch
from torch.optim import lr_scheduler

#设置优化器
optimizer_ft = optim.SGD(model_ft.parameters(), lr=0.001, momentum=0.9)

# 学习率衰减
exp_lr_scheduler = lr_scheduler.StepLR(optimizer_ft, step_size=7, gamma=0.1)

optimizer_ft.step()#梯度更新
exp_lr_scheduler.step()  # 学习率调整

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

import torch
import torch.nn as nn
from torch.optim.lr_scheduler import LambdaLR

initial_lr = 0.1

class model(nn.Module):
    def __init__(self):
        super().__init__()
        self.conv1 = nn.Conv2d(in_channels=3, out_channels=3, kernel_size=3)

    def forward(self, x):
        pass

net_1 = model()

optimizer_1 = torch.optim.Adam(net_1.parameters(), lr = initial_lr)
scheduler_1 = LambdaLR(optimizer_1, lr_lambda=lambda epoch: 1/(epoch+1))

print("初始化的学习率：", optimizer_1.defaults['lr'])

for epoch in range(1, 11):
    # train

    optimizer_1.zero_grad()
    optimizer_1.step()
    print("第%d个epoch的学习率：%f" % (epoch, optimizer_1.param_groups[0]['lr']))
    scheduler_1.step()

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

from PIL import Image
import numpy as np
import visdom

vis = visdom.Visdom()

img = Image.open('xxx.jpg')
img = np.array(img).transpose([2, 0, 1])

vis.image(img)

1

viz.line([loss.item()], [global_step], win='train_loss', update='append' if global_step > 0 else None,opts=dict(title='train loss'))#第一个参数表示Y，第二个参数表示X

1
2
3

viz.line([[test_loss, correct / len(test_loader.dataset)]],
			 [global_step], win='test', update='append' if global_step > 0 else None,opts=dict(title='test loss&acc.',
												   legend=['loss', 'acc.']))

1
2
3
4

viz.image(
    np.random.rand(3, 512, 256),
    opts=dict(title='Random!', caption='How random.'),
)

1
2
3
4

viz.images(
    np.random.randn(20, 3, 64, 64),
    opts=dict(title='Random images', caption='How random.')
)

1
2

transforms.Normalize(mean=[0.5, 0.5, 0.5],
                     std=[0.5, 0.5, 0.5])

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

Photo_show=(Photo + 1) / 2.0 #0~1，Photo为输入的张量
Monet_show=(Monet + 1) / 2.0 #0~1
fake_photo_show=(fake_photo + 1) / 2.0 #0~1
fake_monet_show=(fake_monet + 1) / 2.0 #0~1
cycle_photo_show=(cycle_photo + 1) / 2.0 #0~1
cycle_monet_show=(cycle_monet + 1) / 2.0 #0~1
# if i==0:
#     print('after',photo_show)
# photo_show=self.tensor2im(Photo)
viz.images(Photo_show, win='Photo', opts=dict(title='Photo'))
viz.images(Monet_show, win='Monet', opts=dict(title='Monet'))
viz.images(fake_photo_show, win='fake_photo', opts=dict(title='fake_photo'))
viz.images(fake_monet_show, win='fake_monet', opts=dict(title='fake_monet(target_image)'))
viz.images(cycle_photo_show, win='cycle_photo', opts=dict(title='cycle_photo'))
viz.images(cycle_monet_show, win='cycle_monet', opts=dict(title='cycle_monet'))

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102

import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
from torchvision import datasets, transforms

from visdom import Visdom

batch_size = 200
learning_rate = 0.01
epochs = 10

train_loader = torch.utils.data.DataLoader(
	datasets.MNIST('../data', train=True, download=True,
				   transform=transforms.Compose([
					   transforms.ToTensor(),
					   # transforms.Normalize((0.1307,), (0.3081,))
				   ])),
	batch_size=batch_size, shuffle=True)
test_loader = torch.utils.data.DataLoader(
	datasets.MNIST('../data', train=False, transform=transforms.Compose([
		transforms.ToTensor(),
		# transforms.Normalize((0.1307,), (0.3081,))
	])),
	batch_size=batch_size, shuffle=True)


class MLP(nn.Module):

	def __init__(self):
		super(MLP, self).__init__()

		self.model = nn.Sequential(
			nn.Linear(784, 200),
			nn.LeakyReLU(inplace=True),
			nn.Linear(200, 200),
			nn.LeakyReLU(inplace=True),
			nn.Linear(200, 10),
			nn.LeakyReLU(inplace=True),
		)

	def forward(self, x):
		x = self.model(x)
		return x


device = torch.device('cuda:0')
net = MLP().to(device)
optimizer = optim.SGD(net.parameters(), lr=learning_rate)
criteon = nn.CrossEntropyLoss().to(device)

viz = Visdom()
#viz.line([0.], [0.], win='train_loss', opts=dict(title='train loss'))
#viz.line([[0.0, 0.0]], [0.], win='test', opts=dict(title='test loss&acc.',
#												   legend=['loss', 'acc.']))
global_step = 0

for epoch in range(epochs):

	for batch_idx, (data, target) in enumerate(train_loader):
		data = data.view(-1, 28 * 28)
		data, target = data.to(device), target.cuda()

		logits = net(data)
		loss = criteon(logits, target)

		optimizer.zero_grad()
		loss.backward()
		# print(w1.grad.norm(), w2.grad.norm())
		optimizer.step()

		global_step += 1
		viz.line([loss.item()], [global_step], win='train_loss', update='append' if global_step > 0 else None,opts=dict(title='train loss'))

		if batch_idx % 100 == 0:
			print('Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}'.format(
				epoch, batch_idx * len(data), len(train_loader.dataset),
					   100. * batch_idx / len(train_loader), loss.item()))

	test_loss = 0
	correct = 0
	for data, target in test_loader:
		data = data.view(-1, 28 * 28)
		data, target = data.to(device), target.cuda()
		logits = net(data)
		test_loss += criteon(logits, target).item()

		pred = logits.argmax(dim=1)
		correct += pred.eq(target).float().sum().item()

	viz.line([[test_loss, correct / len(test_loader.dataset)]],
			 [global_step], win='test', update='append' if global_step > 0 else None,opts=dict(title='test loss&acc.',
												   legend=['loss', 'acc.']))
	viz.images(data.view(-1, 1, 28, 28), win='x')
	viz.text(str(pred.detach().cpu().numpy()), win='pred',
			 opts=dict(title='pred'))

	test_loss /= len(test_loader.dataset)
	print('\nTest set: Average loss: {:.4f}, Accuracy: {}/{} ({:.0f}%)\n'.format(
		test_loss, correct, len(test_loader.dataset),
		100. * correct / len(test_loader.dataset)))

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

#GAN的pytorch实现
    def forward(self):
        self.real_A = Variable(self.input_A)
        self.fake_B = self.netG.forward(self.real_A)
        self.real_B = Variable(self.input_B)
        
    def backward_D(self):
        # Fake
        # stop backprop to the generator by detaching fake_B
        fake_AB = self.fake_B
        # fake_AB = self.fake_AB_pool.query(torch.cat((self.real_A, self.fake_B), 1))
        self.pred_fake = self.netD.forward(fake_AB.detach())
        self.loss_D_fake = self.criterionGAN(self.pred_fake, False)

        # Real
        real_AB = self.real_B # GroundTruth
        # real_AB = torch.cat((self.real_A, self.real_B), 1)
        self.pred_real = self.netD.forward(real_AB)
        self.loss_D_real = self.criterionGAN(self.pred_real, True)

        # Combined loss
        self.loss_D = (self.loss_D_fake + self.loss_D_real) * 0.5

        self.loss_D.backward()

    def backward_G(self):
        # First, G(A) should fake the discriminator
        fake_AB = self.fake_B
        pred_fake = self.netD.forward(fake_AB)
        self.loss_G_GAN = self.criterionGAN(pred_fake, True)

        # Second, G(A) = B
        self.loss_G_L1 = self.criterionL1(self.fake_B, self.real_B) * self.opt.lambda_A

        self.loss_G = self.loss_G_GAN + self.loss_G_L1

        self.loss_G.backward()

    # 先调用 forward, 再 D backward， 更新D之后； 再G backward， 再更新G
    def optimize_parameters(self):
        self.forward()

        self.optimizer_D.zero_grad()
        self.backward_D()
        self.optimizer_D.step()

        self.optimizer_G.zero_grad()
        self.backward_G()
        self.optimizer_G.step()

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

#.data的使用
import torch
 
a = torch.tensor([1,2,3.], requires_grad = True)
out = a.sigmoid()
c = out.data  # 需要注意的是，通过.data “分离”得到的的变量会和原来的变量共用同样的数据，而且新分离得到的张量是不可求导的，c发生了变化，原来的张量也会发生变化
c.zero_()     # 改变c的值，原来的out也会改变
print(c.requires_grad)
print(c)
print(out.requires_grad)
print(out)
print("----------------------------------------------")
 
out.sum().backward() # 对原来的out求导，
print(a.grad)  # 不会报错，但是结果却并不正确
'''运行结果为：
False
tensor([0., 0., 0.])
True
tensor([0., 0., 0.], grad_fn=<SigmoidBackward>)
----------------------------------------------
tensor([0., 0., 0.])
'''

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

#detach()的使用
import torch
 
a = torch.tensor([1,2,3.], requires_grad = True)
out = a.sigmoid()
c = out.detach()  # 需要走注意的是，通过.detach() “分离”得到的的变量会和原来的变量共用同样的数据，而且新分离得到的张量是不可求导的，c发生了变化，原来的张量也会发生变化
c.zero_()     # 改变c的值，原来的out也会改变
print(c.requires_grad)
print(c)
print(out.requires_grad)
print(out)
print("----------------------------------------------")
 
out.sum().backward() # 对原来的out求导，
print(a.grad)  # 此时会报错，错误结果参考下面,显示梯度计算所需要的张量已经被“原位操作inplace”所更改了。
'''
False
tensor([0., 0., 0.])
True
tensor([0., 0., 0.], grad_fn=<SigmoidBackward>)
----------------------------------------------
RuntimeError: one of the variables needed for gradient computation has been modified by an inplace operation
'''