动手学深度学习笔记

发表于 | 分类于 | 阅读次数：

动手学深度学习

1
2
3
4
5
#搭建环境
nvidia-smi查看cuda版本
conda create -n myenv python=3.8
#官网安装torch
pip install nb_conda(可以在jupyter中切换虚拟环境)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
a = torch.arange(12).reshape(3,4)
a = torch.tensor([1,2,3],dtype=torch.float32)
torch.cat((a,b),dim=1) #连接a, b
#创建3*4正态分布tensor
a = torch.normal(0,0.01,(3,4))
x.numel() #查看tensor x中元素的个数
#解压缩
def get(a,b):
    print(b)
data_array=(1,2)
get(*data_array)
#压缩 
a = [1,2]
b = [3,4]
for i in zip(a,b):
    print(i)
# (1,3),(2,4)
#迭代器
list = [1,2,3]
for i in iter(list):
	print(i)
#查看第一个batch
X,y = next(iter(train_dataloader))
1
2
3
4
5
#tensor转numpy
X = X.numpy()
#numpy转tensor
tensor = torch.from_numpy(numpy)
tensor = torch.tensor(numpy)
1
2
3
4
5
6
7
#如果已经存在这个文件夹 也不报错
#创建../data文件夹
os.makedirs(os.path.join('..','data'),exist_ok=True)
#读取csv
import pandas as pd
data = pd.read_csv('.csv')
input,output  = data.iloc[:,0:2],data.iloc[:,2]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
#查看网络的参数
net = nn.Sequential(nn.Linear(4,8), nn.ReLU(), nn.Linear(8,1))
for para in net.parameters():
    para.shape
for name, para in net.named_parameters():
    print(name)

net[2].weight.data  #tensor
net[2].bias.data.device
next(iter(net.parameters())).shape

##定义一个大型网络， 查看每层的输出维度
net = torch.nn.Sequential(Reshape(), nn.Conv2d(1, 6, kernel_size=5,
                                               padding=2), nn.Sigmoid(),
                          nn.AvgPool2d(kernel_size=2, stride=2),
                          nn.Conv2d(6, 16, kernel_size=5), nn.Sigmoid(),
                          nn.AvgPool2d(kernel_size=2, stride=2), nn.Flatten(),
                          nn.Linear(16 * 5 * 5, 120), nn.Sigmoid(),
                          nn.Linear(120, 84), nn.Sigmoid(), nn.Linear(84, 10))
X = torch.rand((1,1,28,28), dtype=torch.float32)
for layer in net:
    X = layer(X)
    print(layer.__class__.__name__.ljust(20), 'outshape: ' ,X.shape)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
#数据增广
trans = torvision.transforms.Compose([
    transforms.RandomHorizontalFlip(p=0.5)
    #裁剪之后为200*200 , 选择的区域最少是0.1,最多是1,  裁剪之前高宽比最低0.5 
    transforms.RandomResizedCrop((200, 200), scale=(0.1, 1), ratio=(0.5, 2))
    #亮度，饱和度之类的,允许上下变动50%
    torchvision.transforms.ColorJitter(brightness=0.5, contrast=0.5, saturation=0.5,
                                       hue=0.5)
    transforms.Resize(256)
    transforms.CenterCrop(224)
    transforms.ToTensor()
])
#可以将PILImage 直接转换为tensor
img = trans(img)

#语义分割随机裁剪
def voc_rand_crop(feature, label, height, width):
    """随机裁剪特征和标签图像。"""
    rect = torchvision.transforms.RandomCrop.get_params(
        feature, (height, width))
    feature = torchvision.transforms.functional.crop(feature, *rect)
    label = torchvision.transforms.functional.crop(label, *rect)
    return feature, label
1
2
3
#学习率衰减,每个epoch scheduler.step()
lr_period = 2 , lr_decay = 0.9
scheduler = torch.optim.lr_scheduler.StepLR(optimizer, lr_period, lr_decay)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
#读入图片
from PIL import Image
import matplotlib.pyplot as plt
image = Image.open('catdog.jpg')
#image.show()
plt.imshow(image)

#
image = plt.imread('catdog.jpg')
plt.imshow(image)

#
image = torchvision.io.read_image('catdog.jpg')
image.shape
1
2
3
4
#在图中画框
img = Image.open('catdog.jpg')
fig=plt.imshow(img)
fig.axes.add_patch(plt.Rectangle(xy=(10,10),width=200, height=200,linewidth=1, color='r', fill=False))
1
2
3
4
5
6
7
#设置dataframe某一列为索引
csv_data = pd.read_csv('.csv')
csv_data = csv_data.set_index('img_name')

for img_name, target in csv_data.iterrows():
	#target为series类型
	list(series)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
## net = nn.Sequential(*list(pretrained_net.children())[:-2])
pretrained_net = torchvision.models.resnet18(pretrained=True)
net = nn.Sequential(*list(pretrained_net.children())[:-2])
X = torch.rand(size=(1, 3, 320, 480))
net(X).shape

#假设input = (32,3,320,480),经过上面网络变为(32, 512, 10, 15),经过如下网络变为(32,num_class, 320, 480)
net.add_module('final_conv', nn.Conv2d(512, num_classes, kernel_size=1))
net.add_module(
    'transpose_conv',
    nn.ConvTranspose2d(num_classes, num_classes, kernel_size=64, padding=16,
                       stride=32))
#损失函数, inputs(32,21,320,480)  targets(32,320,480) , F.cross_entropy返回维度(32,320,480)
def loss(inputs, targets):
    return F.cross_entropy(inputs, targets, reduction='none').mean(1).mean(1)