init

Author: chenyuntc

PyTorch实战指南.md

@@ -0,0 +1,43 @@
+# PyTorch 实践指南 
+
+本文是文章[PyTorch实践指南](https://zhuanlan.zhihu.com/p/29024978)配套代码，请参照[知乎专栏原文](https://zhuanlan.zhihu.com/p/29024978)或者[对应的markdown文件](PyTorch实战指南.md)更好的了解而文件组织和代码细节。
+
+
+## 数据下载
+- 从[kaggle比赛官网](https://www.kaggle.com/c/dogs-vs-cats/data) 下载所需的数据
+- 解压并把训练集和测试集分别放在一个文件夹中
+
+
+## 安装
+- PyTorch : 可按照[PyTorch官网](http://pytorch.org)的指南，根据自己的平台安装指定的版本
+- 安装指定依赖：
+
+```
+pip install -r requirements.txt
+```
+
+## 训练
+必须首先启动visdom：
+
+```
+python -m visdom.server
+```
+
+然后使用如下命令启动训练：
+
+```
+# 在gpu0上训练,并把可视化结果保存在visdom 的classifier env上
+python main.py train --data-root=./data/train --use-gpu=True --env=classifier
+```
+
+
+详细的使用命令 可使用
+```
+python main.py help
+```
+
+## 测试
+
+```
+python main.py --data-root=./data/test --use-gpu=False --batch-size=256
+```

README.md

@@ -0,0 +1,43 @@
+#coding:utf8
+import warnings
+class DefaultConfig(object):
+    env = 'default' # visdom 环境
+    model = 'AlexNet' # 使用的模型，名字必须与models/__init__.py中的名字一致
+    
+    train_data_root = './data/train/' # 训练集存放路径
+    test_data_root = './data/test1' # 测试集存放路径
+    load_model_path = 'checkpoints/model.pth' # 加载预训练的模型的路径，为None代表不加载
+
+    batch_size = 128 # batch size
+    use_gpu = True # user GPU or not
+    num_workers = 4 # how many workers for loading data
+    print_freq = 20 # print info every N batch
+
+    debug_file = '/tmp/debug' # if os.path.exists(debug_file): enter ipdb
+    result_file = 'result.csv'
+      
+    max_epoch = 10
+    lr = 0.1 # initial learning rate
+    lr_decay = 0.95 # when val_loss increase, lr = lr*lr_decay
+    weight_decay = 1e-4 # 损失函数
+
+
+
+def parse(self,kwargs):
+        '''
+        根据字典kwargs 更新 config参数
+        '''
+        for k,v in kwargs.iteritems():
+            if not hasattr(self,k):
+                warnings.warn("Warning: opt has not attribut %s" %k)
+            setattr(self,k,v)
+
+        print('user config:')
+        for k,v in self.__class__.__dict__.iteritems():
+            if not k.startswith('__'):
+                print(k,getattr(self,k))
+
+
+DefaultConfig.parse = parse
+opt =DefaultConfig()
+# opt.parse = parse

config.py

@@ -0,0 +1,68 @@
+#coding:utf8
+import os
+from PIL import  Image
+from torch.utils import data
+import numpy as np
+from torchvision import  transforms as T
+
+
+class DogCat(data.Dataset):
+    
+    def __init__(self,root,transforms=None,train=True,test=False):
+        '''
+        主要目标： 获取所有图片的地址，并根据训练，验证，测试划分数据
+        '''
+        self.test = test
+        imgs = [os.path.join(root,img) for img in os.listdir(root)] 
+
+        # test1: data/test1/8973.jpg
+        # train: data/train/cat.10004.jpg 
+        if self.test:
+            imgs = sorted(imgs,key=lambda x:int(x.split('.')[-2].split('/')[-1]))
+        else:
+            imgs = sorted(imgs,key=lambda x:int(x.split('.')[-2]))
+            
+        imgs_num = len(imgs)
+
+        if self.test:
+            self.imgs = imgs
+        elif train:
+            self.imgs = imgs[:int(0.7*imgs_num)]
+        else :
+            self.imgs = imgs[int(0.7*imgs_num):]
+            
+    
+        if transforms is None:
+            normalize = T.Normalize(mean = [0.485, 0.456, 0.406], 
+                                     std = [0.229, 0.224, 0.225])
+
+            if self.test or not train: 
+                self.transforms = T.Compose([
+                    T.Scale(224),
+                    T.CenterCrop(224),
+                    T.ToTensor(),
+                    normalize
+                    ]) 
+            else :
+                self.transforms = T.Compose([
+                    T.Scale(256),
+                    T.RandomSizedCrop(224),
+                    T.RandomHorizontalFlip(),
+                    T.ToTensor(),
+                    normalize
+                    ]) 
+                
+        
+    def __getitem__(self,index):
+        '''
+        一次返回一张图片的数据
+        '''
+        img_path = self.imgs[index]
+        if self.test: label = int(self.imgs[index].split('.')[-2].split('/')[-1])
+        else: label = 1 if 'dog' in img_path.split('/')[-1] else 0
+        data = Image.open(img_path)
+        data = self.transforms(data)
+        return data, label
+    
+    def __len__(self):
+        return len(self.imgs)

data/__init__.py

@@ -0,0 +1,170 @@
+#coding:utf8
+from config import opt
+import os
+import torch as t
+import models
+from data.dataset import DogCat
+from torch.utils.data import DataLoader
+from torch.autograd import Variable
+from torchnet import meter
+from utils.visualize import Visualizer
+
+def test(**kwargs):
+    opt.parse(kwargs)
+    import ipdb;
+    ipdb.set_trace()
+    # configure model
+    model = getattr(models, opt.model)().eval()
+    if opt.load_model_path:
+        model.load(opt.load_model_path)
+    if opt.use_gpu: model.cuda()
+
+    # data
+    train_data = DogCat(opt.test_data_root,test=True)
+    test_dataloader = DataLoader(train_data,batch_size=opt.batch_size,shuffle=False,num_workers=opt.num_workers)
+    results = []
+    for ii,(data,path) in enumerate(test_dataloader):
+        input = t.autograd.Variable(data,volatile = True)
+        if opt.use_gpu: input = input.cuda()
+        score = model(input)
+        probability = t.nn.functional.softmax(score)[:,0].data.tolist()
+        # label = score.max(dim = 1)[1].data.tolist()
+        
+        batch_results = [(path_,probability_) for path_,probability_ in zip(path,probability) ]
+
+        results += batch_results
+    write_csv(results,opt.result_file)
+
+    return results
+
+def write_csv(results,file_name):
+    import csv
+    with open(file_name,'w') as f:
+        writer = csv.writer(f)
+        writer.writerow(['id','label'])
+        writer.writerows(results)
+    
+def train(**kwargs):
+    opt.parse(kwargs)
+    vis = Visualizer(opt.env)
+
+    # step1: configure model
+    model = getattr(models, opt.model)()
+    if opt.load_model_path:
+        model.load(opt.load_model_path)
+    if opt.use_gpu: model.cuda()
+
+    # step2: data
+    train_data = DogCat(opt.train_data_root,train=True)
+    val_data = DogCat(opt.train_data_root,train=False)
+    train_dataloader = DataLoader(train_data,opt.batch_size,
+                        shuffle=True,num_workers=opt.num_workers)
+    val_dataloader = DataLoader(val_data,opt.batch_size,
+                        shuffle=False,num_workers=opt.num_workers)
+    
+    # step3: criterion and optimizer
+    criterion = t.nn.CrossEntropyLoss()
+    lr = opt.lr
+    optimizer = t.optim.Adam(model.parameters(),lr = lr,weight_decay = opt.weight_decay)
+        
+    # step4: meters
+    loss_meter = meter.AverageValueMeter()
+    confusion_matrix = meter.ConfusionMeter(2)
+    previous_loss = 1e100
+
+    # train
+    for epoch in range(opt.max_epoch):
+        
+        loss_meter.reset()
+        confusion_matrix.reset()
+
+        for ii,(data,label) in enumerate(train_dataloader):
+
+            # train model 
+            input = Variable(data)
+            target = Variable(label)
+            if opt.use_gpu:
+                input = input.cuda()
+                target = target.cuda()
+
+            optimizer.zero_grad()
+            score = model(input)
+            loss = criterion(score,target)
+            loss.backward()
+            optimizer.step()
+            
+            
+            # meters update and visualize
+            loss_meter.add(loss.data[0])
+            confusion_matrix.add(score.data, target.data)
+
+            if ii%opt.print_freq==opt.print_freq-1:
+                vis.plot('loss', loss_meter.value()[0])
+                
+                # 进入debug模式
+                if os.path.exists(opt.debug_file):
+                    import ipdb;
+                    ipdb.set_trace()
+
+
+        model.save()
+
+        # validate and visualize
+        val_cm,val_accuracy = val(model,val_dataloader)
+
+        vis.plot('val_accuracy',val_accuracy)
+        vis.log("epoch:{epoch},lr:{lr},loss:{loss},train_cm:{train_cm},val_cm:{val_cm}".format(
+                    epoch = epoch,loss = loss_meter.value()[0],val_cm = str(val_cm.value()),train_cm=str(confusion_matrix.value()),lr=lr))
+        
+        # update learning rate
+        if loss_meter.value()[0] > previous_loss:          
+            lr = lr * opt.lr_decay
+            # 第二种降低学习率的方法:不会有moment等信息的丢失
+            for param_group in optimizer.param_groups:
+                param_group['lr'] = lr
+        
+
+        previous_loss = loss_meter.value()[0]
+
+def val(model,dataloader):
+    '''
+    计算模型在验证集上的准确率等信息
+    '''
+    model.eval()
+    confusion_matrix = meter.ConfusionMeter(2)
+    for ii, data in enumerate(dataloader):
+        input, label = data
+        val_input = Variable(input, volatile=True)
+        val_label = Variable(label.type(t.LongTensor), volatile=True)
+        if opt.use_gpu:
+            val_input = val_input.cuda()
+            val_label = val_label.cuda()
+        score = model(val_input)
+        confusion_matrix.add(score.data.squeeze(), label.type(t.LongTensor))
+
+    model.train()
+    cm_value = confusion_matrix.value()
+    accuracy = 100. * (cm_value[0][0] + cm_value[1][1]) / (cm_value.sum())
+    return confusion_matrix, accuracy
+
+def help():
+    '''
+    打印帮助的信息： python file.py help
+    '''
+    
+    print('''
+    usage : python file.py <function> [--args=value]
+    <function> := train | test | help
+    example: 
+            python {0} train --env='env0701' --lr=0.01
+            python {0} test --dataset='path/to/dataset/root/'
+            python {0} help
+    avaiable args:'''.format(__file__))
+
+    from inspect import getsource
+    source = (getsource(opt.__class__))
+    print(source)
+
+if __name__=='__main__':
+    import fire
+    fire.Fire()

data/dataset.py

@@ -0,0 +1,45 @@
+#coding:utf8
+from torch import nn
+from .BasicModule import BasicModule
+
+class AlexNet(BasicModule):
+    '''
+    code from torchvision/models/alexnet.py
+    结构参考 <https://arxiv.org/abs/1404.5997>
+    '''
+    def __init__(self, num_classes=2):
+        
+        super(AlexNet, self).__init__()
+        
+        self.model_name = 'alexnet'
+
+        self.features = nn.Sequential(
+            nn.Conv2d(3, 64, kernel_size=11, stride=4, padding=2),
+            nn.ReLU(inplace=True),
+            nn.MaxPool2d(kernel_size=3, stride=2),
+            nn.Conv2d(64, 192, kernel_size=5, padding=2),
+            nn.ReLU(inplace=True),
+            nn.MaxPool2d(kernel_size=3, stride=2),
+            nn.Conv2d(192, 384, kernel_size=3, padding=1),
+            nn.ReLU(inplace=True),
+            nn.Conv2d(384, 256, kernel_size=3, padding=1),
+            nn.ReLU(inplace=True),
+            nn.Conv2d(256, 256, kernel_size=3, padding=1),
+            nn.ReLU(inplace=True),
+            nn.MaxPool2d(kernel_size=3, stride=2),
+        )
+        self.classifier = nn.Sequential(
+            nn.Dropout(),
+            nn.Linear(256 * 6 * 6, 4096),
+            nn.ReLU(inplace=True),
+            nn.Dropout(),
+            nn.Linear(4096, 4096),
+            nn.ReLU(inplace=True),
+            nn.Linear(4096, num_classes),
+        )
+
+    def forward(self, x):
+        x = self.features(x)
+        x = x.view(x.size(0), 256 * 6 * 6)
+        x = self.classifier(x)
+        return x