最開始入坑的時候使用的是caffe，前一段時間換了使用主流框架的keras（Tensorflow as backward），但是keras確實封裝得太好了，一個高階的API對於我這種程式設計渣渣來說反而上手有些不習慣，在寫了一段時間的程式碼以後開始使用pytorch（反正老闆要求了兩個框架都要熟練那就都學啦），對於原始碼部分確實友好了很多，儘管需要自己定義前向過程但是也很簡單啦~

**

一、訓練torchvision自帶資料集：

**

搭建網路、訓練torchvision裡面自帶的資料集都是easy stuff，這個tutorials儘量記錄我在實際程式碼中遇到的稍微要費點兒精力的事情。

首先是如何訓練資料集，如果訓練torchvision裡自帶的資料集非常簡單，只需要使用torchvision.datasets直接進行讀取，再例項化torch.utils.data.DataLoader（規定好batch_size以及是否進行shuffle），在訓練時使用enumerate列舉函式匯入資料，也可以用以下程式碼檢視是否匯入資料成功顯示圖片：

for i, data in enumerate(dataLoader, 0):  
    print(data[i][0])  
    # PIL  
    img = transforms.ToPILImage()(data[i][0])  
 

    img.show()  
    break  

完整的程式碼如下：

import torch
from torch import nn, optim
import torch.nn.functional as F
from torch.autograd import Variable
from torch.utils.data import DataLoader
from torchvision import transforms
from torchvision import datasets
from logger import Logger

# 定義超引數
batch_size = 128
 

learning_rate = 1e-2
num_epoches = 20


def to_np(x):
    return x.cpu().data.numpy()


# download datasets
train_dataset = datasets.CIFAR10(
    root='./cifar_data', train=True, transform=transforms.ToTensor(), download=True)

test_dataset = datasets.CIFAR10(
    root='./cifar_data', train=False, transform=transforms.ToTensor())

train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)
test_loader = DataLoader(test_dataset, batch_size=batch_size, shuffle=False)


#define model
class slice_ssc(nn.Module):
    def __init__(self,in_channel,n_class):
        super(slice_ssc,self).__init__()
        self.conv1 = nn.Sequential(
            nn.Conv2d(in_channel,32,3,1,1),
            nn.ReLU(True),
            nn.MaxPool2d(2))
        self.conv2 = nn.Sequential(
            nn.Conv2d(32,64,3,1,1),
            nn.ReLU(True),
            nn.MaxPool2d(2))
        self.fc = nn.Sequential(
            nn.Linear(64*8*8,128),
            nn.Linear(128,64),
            nn.Linear(64,n_class))

    def forward(self,x):
        conv1_out = self.conv1(x)
        conv2_out = self.conv2(conv1_out)
        conv2_out = conv2_out.view(conv2_out.size(0),-1)
        out = self.fc(conv2_out)
        return out

model = slice_ssc(1,10)
print model

use_gpu = torch.cuda.is_available()  # 判斷是否有GPU加速
if use_gpu:
    model = model.cuda()
# 定義loss和optimizer
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=learning_rate)
logger = Logger('./logs')
#training
for epoch in range(num_epoches):
    print 'epoch {}'.format(epoch+1)
    train_loss=0.0
    train_acc=0.0

    #==========training============
    for i,data in enumerate(train_loader,1):
        img,label=data
        img=img.view(img.size(0)*3,1,32,32)
        label = torch.cat((label,label,label),0)
        #print img.size()
        #print label.size()
        if use_gpu:
            img = img.cuda()
            label = label.cuda()
        img = Variable(img)
        label = Variable(label)      

        #forward
        out = model(img)
        loss = criterion(out,label)
        train_loss += loss.data[0] #*label.size(0)
        _, pred = torch.max(out,1)
        train_correct = (pred == label).sum()
        accuracy = (pred == label).float().mean()
        train_acc += train_correct.data[0]
        #backward
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

        #=============log===============
        step = epoch*len(train_loader)+i
        info = {'loss':loss.data[0],'accuracy':accuracy.data[0]}   
        for tag, value in info.items():
            logger.scalar_summary(tag, value, step)

        for tag, value in model.named_parameters():
            tag = tag.replace('.', '/')
            logger.histo_summary(tag, to_np(value), step)
            logger.histo_summary(tag + '/grad', to_np(value.grad), step)

        info = {'images': to_np(img.view(-1, 32, 32)[:10])}
        for tag, images in info.items():
            logger.image_summary(tag, images, step)
        if i % 300 == 0:
            print '[{}/{}] Loss: {:.6f}, Acc: {:.6f}'.format(
                epoch + 1, num_epoches, train_loss / (batch_size * i),
                train_acc / (batch_size * i))

    print 'Finish {} epoch, Loss: {:.6f}, Acc: {:.6f}'.format(
        epoch + 1, train_loss / (len(train_dataset)), train_acc / (len(
            train_dataset)))

    #============testing=============
    model.eval()
    eval_loss = 0.0
    eval_acc = 0.0
    for data in test_loader:
        img,label = data
        img=img.view(img.size(0)*3,1,32,32)
        label = torch.cat((label,label,label),0)
        if use_gpu:
            img = Variable(img,volatile=True).cuda()
            label = Variable(label,volatile=True).cuda()
        else:
            img = Variable(img, volatile=True)
            label = Variable(label, volatile=True)
        out = model(img)
        loss = criterion(out, label)
        eval_loss += loss.data[0] * label.size(0)
        _, pred = torch.max(out, 1)
        num_correct = (pred == label).sum()
        eval_acc += num_correct.data[0]
    print 'Test Loss: {:.6f}, Acc: {:.6f}'.format(eval_loss / (len(
        test_dataset)), eval_acc / (len(test_dataset)))

# 儲存模型
torch.save(model.state_dict(), './cnn.pth')

其中儲存log日誌的logger.py程式碼為：

import tensorflow as tf
import numpy as np
import scipy.misc
try:
    from StringIO import StringIO  # Python 2.7
except ImportError:
    from io import BytesIO         # Python 3.x


class Logger(object):

    def __init__(self, log_dir):
        """Create a summary writer logging to log_dir."""
        self.writer = tf.summary.FileWriter(log_dir)

    def scalar_summary(self, tag, value, step):
        """Log a scalar variable."""
        summary = tf.Summary(value=[tf.Summary.Value(tag=tag,
                                                     simple_value=value)])
        self.writer.add_summary(summary, step)

    def image_summary(self, tag, images, step):
        """Log a list of images."""

        img_summaries = []
        for i, img in enumerate(images):
            # Write the image to a string
            try:
                s = StringIO()
            except:
                s = BytesIO()
            scipy.misc.toimage(img).save(s, format="png")

            # Create an Image object
            img_sum = tf.Summary.Image(encoded_image_string=s.getvalue(),
                                       height=img.shape[0],
                                       width=img.shape[1])
            # Create a Summary value
            img_summaries.append(
                tf.Summary.Value(tag='%s/%d' % (tag, i), image=img_sum))

        # Create and write Summary
        summary = tf.Summary(value=img_summaries)
        self.writer.add_summary(summary, step)

    def histo_summary(self, tag, values, step, bins=1000):
        """Log a histogram of the tensor of values."""

        # Create a histogram using numpy
        counts, bin_edges = np.histogram(values, bins=bins)

        # Fill the fields of the histogram proto
        hist = tf.HistogramProto()
        hist.min = float(np.min(values))
        hist.max = float(np.max(values))
        hist.num = int(np.prod(values.shape))
        hist.sum = float(np.sum(values))
        hist.sum_squares = float(np.sum(values**2))

        # Drop the start of the first bin
        bin_edges = bin_edges[1:]

        # Add bin edges and counts
        for edge in bin_edges:
            hist.bucket_limit.append(edge)
        for c in counts:
            hist.bucket.append(c)

        # Create and write Summary
        summary = tf.Summary(value=[tf.Summary.Value(tag=tag, histo=hist)])
        self.writer.add_summary(summary, step)
        self.writer.flush()

**

二、訓練自己的資料集：

**

1、Dataset class：

**
torch.utils.data.Dataset : 是一個表達dataset的抽象類，需要繼承Dataset類，並進行override，最重要的複寫類中的幾個函式如下：

(1) __init__ : 讀各種格式的資料集、路徑等，控制傳入引數
(2) __getitem__ : 使dataset[i]能夠獲得第i個樣本資料，即匯入具體資料
(3) __len__ : len(dataset) returns the size of the dataset

完整程式碼例項如下：

def default_loader(path):
    return Image.open(path).convert('RGB')

############# Dataset ############
class myImageFloder(data.Dataset):
    def __init__(self,root,image_path,label_path,transform = None,target_transform = None,loader = default_loader):
        f_img = open(image_path)
        f_label = open(label_path)

        #c = 0
        imgs = []
        img_names = []
        label_names = []

        for line in f_img.readlines():
            cls = line.split()
            img_name = cls.pop(1)
            img_names.append(img_name)

            #read image
            if os.path.isfile(os.path.join(root,img_name)):
                imgs.append((img_name,tuple([float(v) for v in cls])))

        for line in f_label.readlines():
            cls = line.split()
            label_name = cls.pop(1)
            label_names.append(label_name)     

        self.root = root
        self.imgs = imgs
        self.img_names = img_names
        self.lable_names = label_names
        self.transform = transform
        self.target_transform = target_transform
        self.loader = loader

    def __getitem__(self,index):
        img_name,label_name = self.imgs[index]
        img = self.loader(os.path.join(self.root,img_name))
        if self.transform is not None:
            img = self.transform(img)
        return img,torch.Tensor(label)

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

**

2.Transform：

**
需要用一些轉化函式對輸入的影象對做轉換變化，常用函式如下：

rescale：scale the image
randomcrop：crop from image randomly，for data augmentation
ToTensor：convert the numpy image to torch image

例如如下完整程式碼定義：

########### Transform ############
mytransform = transforms.Compose([
    transforms.ToTensor()
    ]
)

**

3.例項化DataLoader：

**
這一步是為了將上面得到的資料做處理：Batch the data、Shuffle the data、load the data in parallel using multiprocessing workers.並且對trainloader、testloader單獨進行例項化。
完整程式碼例項如下：

########## Dataloader ############
trainloader = torch.utils.data.DataLoader(
    myFloder.myImageFloder(root = '/home/zzq/Distillation/Datasets/bird_classification-master/data/images',
                           image_path = '/home/zzq/Distillation/Datasets/bird_classification-master/data/images_train.txt',
                           label_path = '/home/zzq/Distillation/Datasets/bird_classification-master/data/image_class_labels_train.txt',
                           transform = mytransform),
    batch_size = 24,shuffle = True,num_workers = 2)
print("TrainLoader success...")

testloader = torch.utils.data.DataLoader(
    myFloder.myImageFloder(root = '/home/zzq/Distillation/Datasets/bird_classification-master/data/images',
                          image_path = '/home/zzq/Distillation/Datasets/bird_classification-master/data/images_test.txt',
                          label_path = '/home/zzq/Distillation/Datasets/bird_classification-master/data/image_class_labels_test.txt',
                          transform = mytransform),
    batch_size = 24,shuffle = False,num_workers = 2)

print("TestLoader success...")