MachineLP的部落格目錄：小鵬的部落格目錄

本小節介紹torch的基礎操作和流程：

（1）計算表示式的梯度值。

（2）陣列與tensor。

（3）構建輸入管道。

（4）載入預訓練的模型。

（5）儲存和載入權重。

---------------------------------我是可愛的分割線---------------------------------

程式碼部分：

（0）import

# coding=utf-8
import torch
import torchvision
import torch.nn as nn
import numpy as np 
import torchvision.transforms as transforms

print (torch.__version__)
 

（1）計算梯度值

# 建立tensor
x = torch.tensor(1, requires_grad=True)
w = torch.tensor(2, requires_grad=True)
b = torch.tensor(3, requires_grad=True)

# 構建模型， 建立計算圖
y = w * x + b

# 計算梯度
y.backward()

# 輸出計算後的梯度值
print ('x:grad', x.grad)
print ('w:grad', w.grad)
print ('b:grad', b.grad)

# 建立兩個tensor
x = torch.randn(10, 3)
y = torch.randn(10, 2)

# 搭建全連線層
linear = nn.Linear(3,2)

# 列印模型權重值
print ('w', linear.weight)
print ('b', linear.bias)

# 構建你需要的損失函式和優化演算法
criterion = nn.MSELoss()
optimizer = torch.optim.SGD(linear.parameters(), lr=0.01)

# 前向計算
pred = linear(x)


# 計算loss
loss = criterion(pred, y)
print('loss: ', loss.item())

loss.backward()
# 列印輸出梯度
print ('dL/dw: ', linear.weight.grad) 
print ('dL/db: ', linear.bias.grad)

# 梯度下降
optimizer.step()

# 梯度下降後，再列印權重值就會減小。
print ('w', linear.weight)
print ('b', linear.bias)


# 梯度下降後的預測值和loss
pred = linear(x)
loss = criterion(pred, y)
print('loss after 1 step optimization: ', loss.item())
 

（2）陣列與tensor。

# 建立陣列， 轉陣列為tensor
x = np.array([[1, 2], [3, 4]])
y = torch.from_numpy(x)
# 轉tensor為陣列
z = y.numpy()

（3）構建輸入管道。

# 下載 CIFAR-10 資料
train_dataset = torchvision.datasets.CIFAR10(root='../../data/',
                                             train=True, 
                                             transform=transforms.ToTensor(),
                                             download=True)

# 樣本和標籤
image, label = train_dataset[0]
print (image.size())
print (label)

# 通過佇列的形式載入資料
train_loader = torch.utils.data.DataLoader(dataset=train_dataset,
                                           batch_size=64, 
                                           shuffle=True)

# 建立迭代器，為每次訓練提供訓練資料
data_iter = iter(train_loader)

# Mini-batch 樣本和標籤
images, labels = data_iter.next()

# 另外一種方式
for images, labels in train_loader:
    # 訓練的程式碼
    pass
 

# 在你自己的資料上構建高效資料載入的方式
class CustomDataset(torch.utils.data.Dataset):
    def __init__(self):
        # TODO
        # 1. Initialize file paths or a list of file names. 
        pass
    def __getitem__(self, index):
        # TODO
        # 1. Read one data from file (e.g. using numpy.fromfile, PIL.Image.open).
        # 2. Preprocess the data (e.g. torchvision.Transform).
        # 3. Return a data pair (e.g. image and label).
        pass
    def __len__(self):
        # You should change 0 to the total size of your dataset.
        return 0 

# 
custom_dataset = CustomDataset()
train_loader = torch.utils.data.DataLoader(dataset=custom_dataset,
                                           batch_size=64, 
                                           shuffle=True)

（4）載入預訓練的模型。

# 下載和載入預訓練的模型ResNet-18.
resnet = torchvision.models.resnet18(pretrained=True)

# 只進行fine-tune top層：
for param in resnet.parameters():
    param.requires_grad = False

# Replace the top layer for finetuning.
resnet.fc = nn.Linear(resnet.fc.in_features, 100)  # 100 is an example.

# Forward pass.
images = torch.randn(64, 3, 224, 224)
outputs = resnet(images)
print (outputs.size())     # (64, 100)

（5）儲存和載入權重。

# 儲存和載入模型
torch.save(resnet, 'model.ckpt')
model = torch.load('model.ckpt')

# 只儲存和載入模型引數
torch.save(resnet.state_dict(), 'params.ckpt')
resnet.load_state_dict(torch.load('params.ckpt'))

---------------------------------我是可愛的分割線---------------------------------

總結：

加餐：

在資料上進行載入資料：

其中，train.txt中的資料格式：

gender/0male/0(2).jpg 1
gender/0male/0(3).jpeg 1
gender/0male/0(1).jpg 0

# coding = utf-8
import torch
from torch.utils.data import Dataset, DataLoader
from torchvision import transforms, utils
import matplotlib.pyplot as plt
from PIL import Image


def default_loader(path):
    # 注意要保證每個batch的tensor大小時候一樣的。
    return Image.open(path).convert('RGB')


class MyDataset(Dataset):
    def __init__(self, txt, transform=None, target_transform=None, loader=default_loader):
        fh = open(txt, 'r')
        imgs = []
        for line in fh:
            line = line.strip('\n')
            # line = line.rstrip()
            words = line.split(' ')
            imgs.append((words[0],int(words[1])))
        self.imgs = imgs
        self.transform = transform
        self.target_transform = target_transform
        self.loader = loader
    
    def __getitem__(self, index):
        fn, label = self.imgs[index]
        img = self.loader(fn)
        if self.transform is not None:
            img = self.transform(img)
        return img,label
    
    def __len__(self):
        return len(self.imgs)

def get_loader(dataset='train.txt', crop_size=178, image_size=128, batch_size=2, mode='train', num_workers=1):
    """Build and return a data loader."""
    transform = []
    if mode == 'train':
        transform.append(transforms.RandomHorizontalFlip())
    transform.append(transforms.CenterCrop(crop_size))
    transform.append(transforms.Resize(image_size))
    transform.append(transforms.ToTensor())
    transform.append(transforms.Normalize(mean=(0.5, 0.5, 0.5), std=(0.5, 0.5, 0.5)))
    transform = transforms.Compose(transform)
    train_data=MyDataset(txt=dataset, transform=transform)
    data_loader = DataLoader(dataset=train_data,
                                  batch_size=batch_size,
                                  shuffle=(mode=='train'),
                                  num_workers=num_workers)
    return data_loader
# 注意要保證每個batch的tensor大小時候一樣的。
# data_loader = DataLoader(train_data, batch_size=2,shuffle=True)
data_loader = get_loader('train.txt')
print(len(data_loader))

def show_batch(imgs):
    grid = utils.make_grid(imgs)
    plt.imshow(grid.numpy().transpose((1, 2, 0)))
    plt.title('Batch from dataloader')


for i, (batch_x, batch_y) in enumerate(data_loader):
    if(i<4):
        print(i, batch_x.size(),batch_y.size())
        show_batch(batch_x)
        plt.axis('off')
        plt.show()

以上是torch的基礎部分，總體的流程已經有了，上手就很快了。