def main_test():
parser = argparse.ArgumentParser(description='Detector')
parser.add_argument('--batch-size', type=int, default=50, metavar='N',
help='input batch size for training (default: 64)')
parser.add_argument('--test-batch-size', type=int, default=50, metavar='N',
help='input batch size for testing (default: 64)')
parser.add_argument('--epochs', type=int, default=100, metavar='N',
help='number of epochs to train (default: 100)')
parser.add_argument('--lr', type=float, default=0.001, metavar='LR',
help='learning rate (default: 0.001)')
parser.add_argument('--momentum', type=float, default=0.05, metavar='M',
help='SGD momentum (default: 0.5)')
parser.add_argument('--no-cuda', action='store_true', default=True,
help='disables CUDA training')
parser.add_argument('--seed', type=int, default=1, metavar='S',
help='random seed (default: 1)')
parser.add_argument('--log-interval', type=int, default=20, metavar='N',
help='how many batches to wait before logging training status')
parser.add_argument('--save-model', action='store_true', default=True,
help='save the current Model')
parser.add_argument('--save-directory', type=str, default='trained_models',
help='learnt models are saving here')
parser.add_argument('--phase', type=str, default='Train',
help='training, test or predict')
parser.add_argument('--pre_mode', type=str, default='',
help='training, predicting or finetuning')
args = parser.parse_args()
###################################################################################
torch.manual_seed(args.seed)
use_cuda = not args.no_cuda and torch.cuda.is_available()
device = torch.device("cuda" if use_cuda else "cpu") # cuda:0
print('===> Loading Datasets')
train_set, test_set = get_train_test_set()
train_loader = torch.utils.data.DataLoader(train_set, batch_size=args.batch_size, shuffle=True)
valid_loader = torch.utils.data.DataLoader(test_set, batch_size=args.test_batch_size)
print('===> Building Model')
model = Net().to(device)
####################################################################
criterion_pts = nn.MSELoss()
# optimizer = optim.SGD(model.parameters(), lr=args.lr, momentum=args.momentum)
optimizer = torch.optim.Adam(model.parameters(), lr = 0.0001)
####################################################################
if args.phase == 'Train' or args.phase == 'train':
if args.pre_mode.endswith(".pt"):
model.load_state_dict(torch.load(args.pre_mode))
print('===> Start Training')
train_losses, valid_losses = \
train(args, train_loader, valid_loader, model, criterion_pts, optimizer, device)
print('====================================================')
elif args.phase == 'Test' or args.phase == 'test':
print('===> Test')
validPredict(args, "detector_epoch.pt", Net(), valid_loader)
elif args.phase == 'Predict' or args.phase == 'predict':
print('===> Predict')
videoPredict(args, "detector_epoch.pt", Net())
def main_test():
parser = argparse.ArgumentParser(description='Detector')
parser.add_argument('--batch-size', type=int, default=64, metavar='N',
help='input batch size for training (default: 64)')
parser.add_argument('--test-batch-size', type=int, default=64, metavar='N',
help='input batch size for testing (default: 64)')
parser.add_argument('--epochs', type=int, default=100, metavar='N',
help='number of epochs to train (default: 100)')
parser.add_argument('--lr', type=float, default=0.001, metavar='LR',
help='learning rate (default: 0.001)')
parser.add_argument('--momentum', type=float, default=0.5, metavar='M',
help='SGD momentum (default: 0.5)')
parser.add_argument('--no-cuda', action='store_true', default=False,
help='disables CUDA training')
parser.add_argument('--seed', type=int, default=1, metavar='S',
help='random seed (default: 1)')
parser.add_argument('--log-interval', type=int, default=20, metavar='N',
help='how many batches to wait before logging training status')
parser.add_argument('--save-model', action='store_true', default=True,
help='save the current Model')
parser.add_argument('--save-directory', type=str, default='trained_models',
help='learnt models are saving here')
parser.add_argument('--phase', type=str, default='Train', # Train/train, Predict/predict, Finetune/finetune
help='training, predicting or finetuning')
args = parser.parse_args()
###################################################################################
torch.manual_seed(args.seed)
# For single GPU
use_cuda = not args.no_cuda and torch.cuda.is_available()
device = torch.device("cuda" if use_cuda else "cpu") # cuda:0
# For multi GPUs, nothing need to change here
kwargs = {'num_workers': 1, 'pin_memory': True} if use_cuda else {}
print('===> Loading Datasets')
train_set, test_set = get_train_test_set()
train_loader = torch.utils.data.DataLoader(train_set, batch_size=args.batch_size, shuffle=True)
valid_loader = torch.utils.data.DataLoader(test_set, batch_size=args.test_batch_size)
print('===> Building Model')
# For single GPU
model = Net().to(device)
####################################################################
criterion_pts = nn.MSELoss()
optimizer = optim.SGD(model.parameters(), lr=args.lr, momentum=args.momentum)
####################################################################
if args.phase == 'Train' or args.phase == 'train':
print('===> Start Training')
train_losses, valid_losses = \
train(args, train_loader, valid_loader, model, criterion_pts, optimizer, device)
print('====================================================')
elif args.phase == 'Test' or args.phase == 'test'
print('===> Test')
def train_and_save_model():
trainset, testset = data.get_train_test_set()
trainloader = torch.utils.data.DataLoader(trainset,
batch_size=BATCH_SIZE,
shuffle=True)
testloader = torch.utils.data.DataLoader(testset,
batch_size=BATCH_SIZE,
shuffle=False)
net = resnet.resnet(in_channel=3, num_classes=1)
optimizer = torch.optim.Adam(net.parameters(), lr=LR)
criterion = nn.BCELoss()
utils.train(
net,
trainloader,
testloader,
20,
optimizer,
criterion,
debug=DEBUG,
)
def main_test():
###################################################################################
torch.manual_seed(1)
print('===> Loading Datasets')
train_set, test_set = get_train_test_set()
train_loader = torch.utils.data.DataLoader(train_set,
batch_size=config.BATCH_TRAIN,
shuffle=True)
valid_loader = torch.utils.data.DataLoader(test_set,
batch_size=config.BATCH_VAL)
data_loaders = {'train': train_loader, 'val': valid_loader}
print('===> Building Model')
# For single GPU
model = Net()
####################################################################
criterion_pts = nn.MSELoss()
weights = [1, 3]
class_weights = torch.FloatTensor(weights)
criterion_cls = nn.CrossEntropyLoss()
####################################################################
if config.PHASE == 'Train' or config.PHASE == 'train':
print('===> Start Training')
_ = train(data_loaders, model, (criterion_pts, criterion_cls))
print('====================================================')
elif config.PHASE == 'Test' or config.PHASE == 'test':
print('===> Test')
# how to do test?
elif config.PHASE == 'Finetune' or config.PHASE == 'finetune':
print('===> Finetune')
# how to do finetune?
elif config.PHASE == 'Predict' or config.PHASE == 'predict':
print('===> Predict')
# how to do predict?
test_img_name = 'test01.jpg'
predict(model, test_img_name)
def main_test():
parser = argparse.ArgumentParser(description='Detector')
parser.add_argument('--batch-size',
type=int,
default=64,
metavar='N',
help='input batch size for training (default: 64)')
parser.add_argument('--test-batch-size',
type=int,
default=64,
metavar='N',
help='input batch size for testing (default: 64)')
parser.add_argument('--epochs',
type=int,
default=100,
metavar='N',
help='number of epochs to train (default: 100)')
parser.add_argument('--start-epoch',
type=int,
default=0,
metavar='N',
help='epoch number starts from (default: 0)')
parser.add_argument('--lr',
type=float,
default=0.01,
metavar='LR',
help='learning rate (default: 0.01)')
parser.add_argument('--alg',
type=str,
default='adam',
help='select optimzer SGD, adam, or other')
parser.add_argument('--loss', type=str, default='CE', help='loss function')
parser.add_argument('--no-cuda',
action='store_true',
default=False,
help='disables CUDA training')
parser.add_argument('--seed',
type=int,
default=1,
metavar='S',
help='random seed (default: 1)')
parser.add_argument(
'--log-interval',
type=int,
default=20,
metavar='N',
help='how many batches to wait before logging training status')
parser.add_argument('--save-model',
action='store_true',
default=True,
help='save the current Model')
parser.add_argument('--save-directory',
type=str,
default='trained_models',
help='learnt models are saving here')
parser.add_argument(
'--phase',
type=str,
default='Train', # Train/train, Predict/predict, Finetune/finetune
help='training, predicting or finetuning')
parser.add_argument(
'--net',
type=str,
default='resnet101',
help='DefaultNet, ResNet***[18,34,50,101,152], MobileNet or GoogLeNet')
parser.add_argument(
'--angle',
type=float,
default=30,
help='max (30) angle range to rotate original image on both side')
parser.add_argument('--save-interval',
type=int,
default=20,
help='after # of epoch, save the current Model')
parser.add_argument(
'--checkpoint',
type=str,
default='',
help='continuing the training from specified checkpoint')
args = parser.parse_args()
###################################################################################
torch.manual_seed(args.seed)
# For single GPU
use_cuda = not args.no_cuda and torch.cuda.is_available()
device = torch.device("cuda" if use_cuda else "cpu") # cuda:0
# For multi GPUs, nothing need to change here
kwargs = {'num_workers': 1, 'pin_memory': True} if use_cuda else {}
print('===> Loading Datasets')
train_set, test_set = get_train_test_set(args.net, args.angle)
train_loader = torch.utils.data.DataLoader(train_set,
batch_size=args.batch_size,
shuffle=True)
valid_loader = torch.utils.data.DataLoader(test_set,
batch_size=args.test_batch_size)
# 输出类别定义
categories = 62
print('===> Building Model')
# For single GPU
if args.net == 'ResNet18' or args.net == 'resnet18':
model = resnet18()
in_features = model.fc.in_features
model.fc = nn.Linear(in_features, categories)
model = model.to(device)
elif args.net == 'ResNet34' or args.net == 'resnet34':
model = resnet34()
in_features = model.fc.in_features
model.fc = nn.Linear(in_features, categories)
model = model.to(device)
elif args.net == 'ResNet50' or args.net == 'resnet50':
model = resnet50()
in_features = model.fc.in_features
model.fc = nn.Linear(in_features, categories)
model = model.to(device)
elif args.net == 'ResNet101' or args.net == 'resnet101':
model = resnet101()
in_features = model.fc.in_features
model.fc = nn.Linear(in_features, categories)
model = model.to(device)
elif args.net == 'ResNet152' or args.net == 'resnet152':
model = resnet152()
in_features = model.fc.in_features
model.fc = nn.Linear(in_features, categories)
model = model.to(device)
elif args.net == 'GoogLeNet' or args.net == 'googlenet':
model = GoogLeNet(num_classes=categories).to(device)
else:
model = resnet50()
in_features = model.fc.in_features
model.fc = nn.Linear(in_features, categories)
model = model.to(device)
'''elif args.net == 'FPN':
model = FPN101(args.batch_size).to(device)
else:
model = Net(args.use_bn).to(device)'''
####################################################################
def load_data_t(phase):
data_file = phase + '.csv'
data_file = os.path.join('traffic-sign', data_file)
with open(data_file) as f:
lines = f.readlines()[1:]
return lines
train_set_t = load_data_t('train_label')
cate_tr = [i[2] for i in [my_parse_line(i) for i in train_set_t]]
w = Counter(cate_tr)
total = sum(w.values())
weight = torch.FloatTensor([w[str(i)] / total
for i in range(len(w))]).to(device)
if args.loss == 'CE':
criterion = nn.CrossEntropyLoss(weight=weight)
else:
criterion = nn.CrossEntropyLoss()
####################################################################
# Freeze all layer except ip3, if current mode is finetune
if args.phase == 'Finetune':
start, end = (args.layer_lockdown.split(':'))
for param in list(model.parameters())[start:end]:
param.requires_grad = False
if args.alg == 'SGD':
optimizer = optim.SGD(model.parameters(),
lr=args.lr,
momentum=args.momentum)
elif args.alg == 'adam' or args.alg == 'Adam':
optimizer = optim.Adam(model.parameters(), lr=args.lr)
else:
optimizer = optim.Adam(model.parameters(), lr=args.lr)
####################################################################
if args.phase == 'Train' or args.phase == 'train':
print('===> Start Training')
train(args,
train_loader,
valid_loader,
model,
criterion,
optimizer,
device,
cuda=use_cuda)
print('====================================================')
elif args.phase == 'Test' or args.phase == 'test':
print('===> Test')
# how to do test?
elif args.phase == 'Finetune' or args.phase == 'finetune':
print('===> Finetune')
# how to do finetune?
elif args.phase == 'Predict' or args.phase == 'predict':
print('===> Predict')
# how to do predict?
else:
print('===> Verify')
def main():
parser = argparse.ArgumentParser(description='Detector')
parser.add_argument('--batch_size',
type=int,
default=64,
metavar='N',
help='input batch size for training (default: 256)')
parser.add_argument('--test_batch_size',
type=int,
default=256,
metavar='N',
help='input batch size for testing (default: 256)')
parser.add_argument('--predict_batch_size',
type=int,
default=1,
metavar='N',
help='input batch size for predict (default: 1)')
parser.add_argument('--epochs',
type=int,
default=50,
metavar='N',
help='number of epochs to train (default: 100)')
parser.add_argument('--lr',
type=float,
default=0.001,
metavar='LR',
help='learning rate (default: 0.001)')
parser.add_argument('--momentum',
type=float,
default=0.5,
metavar='M',
help='SGD momentum (default: 0.5)')
parser.add_argument('--cuda',
action='store_true',
default=False,
help='enables CUDA training')
parser.add_argument('--seed',
type=int,
default=10,
metavar='S',
help='random seed (default: 10)')
parser.add_argument(
'--log_interval',
type=int,
default=10,
metavar='N',
help='how many batches to wait before logging training status')
parser.add_argument('--save_model',
action='store_true',
default=False,
help='save the current Model')
parser.add_argument('--save_directory',
type=str,
default='trained_models',
help='learnt models are saving here')
parser.add_argument(
'--phase',
type=str,
default='Train', # Train/train, Predict/predict, Finetune/finetune
help='training, predicting or finetuning')
args = parser.parse_args([
'--batch_size=64', '--test_batch_size=64', '--predict_batch_size=1',
'--epochs=101', '--lr=0.001', '--momentum=0.5', '--seed=1',
'--log_interval=10', '--save_model', '--save_directory=trained_models',
'--phase=train'
])
##############################################################################################################
#设置随机种子
torch.manual_seed(args.seed)
torch.cuda.manual_seed(args.seed)
#设置CPU/GPU
use_cuda = args.cuda and torch.cuda.is_available()
device = torch.device('cuda' if use_cuda else 'cpu')
#For multi GPUs, nothing need to change here
kwargs = {'num_workers': 1, 'pin_memory': True} if use_cuda else {}
###############################################################################################################
print('===> Loading Datasets')
train_set, test_set = get_train_test_set()
train_loader = torch.utils.data.DataLoader(train_set,
batch_size=args.batch_size,
shuffle=True)
valid_loader = torch.utils.data.DataLoader(test_set,
batch_size=args.test_batch_size)
predict_loader = torch.utils.data.DataLoader(
test_set, batch_size=args.predict_batch_size)
###############################################################################################################
print('===> Building Model')
# For single GPU
print('===> runing on {}'.format(device))
###############################################################################################################
print('===> init model')
model = Net_Bn()
model = model_parameters_init(model)
###############################################################################################################
model.to(device)
criterion_pts = nn.MSELoss()
# optimizer = optim.Adam(model.parameters(), lr= args.lr)
optimizer = optim.SGD(model.parameters(),
lr=args.lr,
momentum=args.momentum)
#学习率衰减
scheduler = optim.lr_scheduler.StepLR(optimizer, 10, 0.9)
###############################################################################################################
if args.phase == 'Train' or args.phase == 'train':
print('===> Start Training')
train_losses, valid_losses = train(args, train_loader, valid_loader,
model, criterion_pts, optimizer,
scheduler, device)
print('===> Done!')
return train_losses, valid_losses
elif args.phase == 'Test' or args.phase == 'test':
print('===> Test')
path_model = os.path.join(args.save_directory,
'detector_epoch' + '_' + str(85) + '.pt')
model.load_state_dict(torch.load(path_model))
model = model.to(device)
model.eval()
with torch.no_grad():
valid_batch_cnt = 0
valid_loss = 0
for valid_batch_idx, batch in enumerate(valid_loader):
valid_batch_cnt += 1
valid_img = batch['image']
landmarks = batch['landmarks']
input_img = valid_img.to(device)
target_pts = landmarks.to(device)
# print(input_img.shape)
output_pts = model(input_img)
# print(type(output_pts))
valid_loss_batch = criterion_pts(output_pts, target_pts)
valid_loss += valid_loss_batch.item()
valid_loss /= valid_batch_cnt * 1.0
print('Valid: pts_loss: {:.6f}'.format(valid_loss))
print('===> Done!')
return None, None
elif args.phase == 'Finetune' or args.phase == 'finetune':
print('===> Finetune')
path_model = os.path.join(args.save_directory,
'detector_epoch' + '_' + str(50) + '.pt')
model.load_state_dict(torch.load(path_model))
model = model.to(device)
train_losses, valid_losses = train(args, train_loader, valid_loader,
model, criterion_pts, optimizer,
scheduler, device)
print('===> Done!')
return train_losses, valid_losses
elif args.phase == 'Predict' or args.phase == 'predict':
print('===> Predict')
path_model = os.path.join(args.save_directory,
'detector_epoch' + '_' + str(50) + '.pt')
model.load_state_dict(torch.load(path_model))
model = model.to(device)
model.eval()
idx = 99
with torch.no_grad():
for i, data in enumerate(predict_loader):
if i == idx:
img = data['image'].to(device)
output_pts = model(img)
landmarks = output_pts[0].numpy()
xs = landmarks[::2]
ys = landmarks[1::2]
img = transforms.ToPILImage()(img[0].type(torch.uint8))
draw = ImageDraw.Draw(img)
draw.point(list(zip(xs, ys)), fill=(0))
img.show()
elif i > idx:
break
print('===> Done!')
return None, None
def main_test(phase):
parser = argparse.ArgumentParser(description='Detector')
# 当参数名称中间带'-'时，提取变量要变成’_‘
parser.add_argument('--batch-size',
type=int,
default=64,
metavar='N',
help='input batch size for training (default: 64)')
parser.add_argument('--test-batch-size',
type=int,
default=64,
metavar='N',
help='input batch size for testing (default: 64)')
parser.add_argument('--epochs',
type=int,
default=100,
metavar='N',
help='number of epochs to train (default: 100)')
parser.add_argument('--lr',
type=float,
default=0.001,
metavar='LR',
help='learning rate (default: 0.001)')
parser.add_argument('--momentum',
type=float,
default=0.3,
metavar='M',
help='SGD momentum (default: 0.5)')
parser.add_argument('--no-cuda',
action='store_true',
default=False,
help='disables CUDA training')
parser.add_argument('--seed',
type=int,
default=1,
metavar='S',
help='random seed (default: 1)')
parser.add_argument(
'--log-interval',
type=int,
default=20,
metavar='N',
help='how many batches to wait before logging training status')
parser.add_argument('--save-model',
action='store_true',
default=True,
help='save the current Model')
parser.add_argument('--save-directory',
type=str,
default='trained_models',
help='learnt models are saving here')
parser.add_argument(
'--phase',
type=str,
default='Train', # Train/train, Predict/predict, Finetune/finetune
help='training, predicting or finetuning')
args = parser.parse_args()
# # 以下定义以下通用的参数
torch.manual_seed(args.seed)
# For single GPU
use_cuda = not args.no_cuda and torch.cuda.is_available()
device = torch.device("cuda" if use_cuda else "cpu") # cuda:0
# For multi GPUs, nothing need to change here
# kwargs = {'num_workers': 1, 'pin_memory': True} if use_cuda else {}
print('===> Loading Datasets')
train_set, test_set = get_train_test_set()
train_loader = torch.utils.data.DataLoader(train_set,
batch_size=args.batch_size,
shuffle=True)
valid_loader = torch.utils.data.DataLoader(test_set,
batch_size=args.test_batch_size,
shuffle=True)
args.phase = phase
# # 训练
if args.phase == 'Train' or args.phase == 'train':
print('===> Building Model')
model = Model().to(device)
# # 均方误差
# criterion_pts = torch.nn.MSELoss()
criterion_pts = torch.nn.SmoothL1Loss()
# # 二分类最后可以只输出1维，然后使用BCELoss()或BCEWithLogitsLoss()
criterion_label = torch.nn.CrossEntropyLoss()
criterion = [criterion_label, criterion_pts]
# # SGD优化，总是出现loss为NAN，因为计算值与真实值差距太大了，约为100倍，
# # optimizer = optim.SGD(model.parameters(), lr=args.lr, momentum=args.momentum)
# # 采用Adam时可以不用缩小真实值，能够快速收敛
optimizer = optim.Adam(model.parameters(), lr=0.001)
# # RMSprop和SGD一样，不缩放容易爆表
# # optimizer = optim.RMSprop(model.parameters())
# # 新建一个文件夹，命名方式为损失函数+优化器+学习率+当前日期
args.save_directory = 'trained_models_' + criterion_pts.__class__.__name__ + '_' \
+ optimizer.__class__.__name__ + '_' + str(args.lr)+'_'\
+time.strftime('%Y-%m-%d-%H-%M-%S')
print('===> Start Training')
train_losses, valid_losses = \
train(args, train_loader, valid_loader, model, criterion, optimizer, device)
print(train_losses, valid_losses)
print('====================================================')
# # 测试
elif args.phase == 'Test' or args.phase == 'test':
print('===> Building Model')
model_path = 'trained_models_SmoothL1Loss_Adam_0.001_2020-03-28-15-11-28'
args.save_directory = model_path
# # 使用模型
trained_model = 'detector_epoch_99.pt'
# # model.eval()在predict函数中进行
model = Model()
print('===> Test')
predict(args, trained_model, model, valid_loader)
# # 微调
elif args.phase == 'Finetune' or args.phase == 'finetune':
print('===> Building Model')
# # 首先加载需要微调的模型
path = 'trained_models_SmoothL1Loss_Adam_0.001_2020-03-28-15-11-28'
# # 使用模型
file = 'detector_epoch_99.pt'
model_path = os.path.join(path, file)
model = Model()
model.load_state_dict(torch.load(model_path))
# # 首先对冻结之前训练的参数
for param in model.parameters():
param.requires_grad = False
# # 对于需要调整的网络层重新定义，默认参数需要更新
model.FullConnection = torch.nn.Sequential(
torch.nn.Linear(4 * 4 * 80, 128), torch.nn.ReLU(),
torch.nn.Linear(128, 128), torch.nn.ReLU(),
torch.nn.Linear(128, 42))
model.to(device)
print('===> Finetune')
criterion_pts = torch.nn.MSELoss()
criterion_label = torch.nn.CrossEntropyLoss()
criterion = [criterion_label, criterion_pts]
optimizer = optim.SGD(model.parameters(),
lr=args.lr,
momentum=args.momentum)
# 新建一个文件夹，命名方式为损失函数+优化器+学习率+Finetune
args.save_directory = 'trained_models_' + criterion_pts.__class__.__name__ + '_' \
+ optimizer.__class__.__name__ + '_' + str(args.lr)+'_'+'Finetune'
train_losses, valid_losses = \
train(args, train_loader, valid_loader, model, criterion, optimizer, device)
print(train_losses, valid_losses)
print('====================================================')
# # 预测
elif args.phase == 'Predict' or args.phase == 'predict':
print('===> Building Model')
img_path = '.\\test_img'
path = 'trained_models_SmoothL1Loss_Adam_0.001_2020-03-28-15-11-28'
file = 'detector_epoch_99.pt'
model_path = os.path.join(path, file)
model = Model()
model.load_state_dict(torch.load(model_path))
# # 如果模型是finetune的，那么相关的层需要改变，或者直接加载整个模型
# file='trained_models_MSELoss_SGD_0.001_Finetune.pth'
# model.load(file)
model.eval()
print('===> Predict')
# # my_predict是针对文件夹中的图片直接拿来预测的
my_predict(img_path, model)
from utils import train
import data
from resnet import resnet
import torch
from torch import nn
DEBUG = False
BATCH_SIZE = 64
LR = 1e-3
if __name__ == "__main__":
trainset, testset = data.get_train_test_set()
trainloader = torch.utils.data.DataLoader(trainset,
batch_size=BATCH_SIZE,
shuffle=True)
testloader = torch.utils.data.DataLoader(testset,
batch_size=BATCH_SIZE,
shuffle=False)
net = resnet(in_channel=3, num_classes=1)
optimizer = torch.optim.Adam(net.parameters(), lr=LR)
criterion = nn.BCELoss()
train(
net,
trainloader,
testloader,
20,
optimizer,
criterion,
debug=DEBUG,
)
def main_test():
parser = argparse.ArgumentParser(description='Detector')
parser.add_argument('--batch-size',
type=int,
default=64,
metavar='N',
help='input batch size for training (default: 64)')
parser.add_argument('--test-batch-size',
type=int,
default=64,
metavar='N',
help='input batch size for testing (default: 64)')
parser.add_argument('--epochs',
type=int,
default=50,
metavar='N',
help='number of epochs to train (default: 100)')
parser.add_argument('--lr',
type=float,
default=0.001,
metavar='LR',
help='learning rate (default: 0.001)')
parser.add_argument('--momentum',
type=float,
default=0.5,
metavar='M',
help='SGD momentum (default: 0.5)')
parser.add_argument('--no-cuda',
action='store_true',
default=False,
help='disables CUDA training')
parser.add_argument('--seed',
type=int,
default=1,
metavar='S',
help='random seed (default: 1)')
parser.add_argument(
'--log-interval',
type=int,
default=20,
metavar='N',
help='how many batches to wait before logging training status')
parser.add_argument('--save-model',
action='store_true',
default=True,
help='save the current Model')
parser.add_argument('--save-directory',
type=str,
default='trained_models',
help='learnt models are saving here')
parser.add_argument(
'--phase',
type=str,
default='Train', # Train/train, Predict/predict, Finetune/finetune
help='train, predict or finetune')
parser.add_argument('--save-log',
type=str,
default='log.txt',
help='save the log of training')
parser.add_argument('--rotation_type',
type=str,
default='none',
help='choose from: allangle,none,flip')
parser.add_argument('--no-bn',
action='store_true',
default=False,
help='without batch normalization')
args = parser.parse_args()
###################################################################################
torch.manual_seed(args.seed)
# For single GPU
use_cuda = not args.no_cuda and torch.cuda.is_available()
device = torch.device("cuda" if use_cuda else "cpu") # cuda:0
# For multi GPUs, nothing need to change here
kwargs = {'num_workers': 1, 'pin_memory': True} if use_cuda else {}
print('===> Loading Datasets')
args.rotation_type = args.rotation_type.lower()
if (args.rotation_type == 'flip'):
rotation_class = Rotation_flip
elif (args.rotation_type == 'allangle'):
rotation_class = Rotation_allangle
else:
rotation_class = Rotation_none
train_set, test_set = get_train_test_set(rotation_class)
train_loader = torch.utils.data.DataLoader(train_set,
batch_size=args.batch_size,
shuffle=True)
valid_loader = torch.utils.data.DataLoader(test_set,
batch_size=args.test_batch_size,
shuffle=True)
print('===> Building Model')
# For single GPU
model = Net(args.no_bn).to(device)
####################################################################
#criterion_pts = nn.MSELoss()
criterion_pts = mymse_withlabel
criterion_classes = nn.CrossEntropyLoss()
#optimizer = optim.SGD(model.parameters(), lr=args.lr, momentum=args.momentum)
optimizer = optim.Adam(model.parameters(), lr=args.lr)
####################################################################
if args.phase == 'Train' or args.phase == 'train':
print('===> Start Training')
train_losses, valid_losses = \
train(args, train_loader, valid_loader, model, criterion_pts, criterion_classes, optimizer, device)
print('====================================================')
elif args.phase == 'Test' or args.phase == 'test':
print('===> Test')
# how to do test?
elif args.phase == 'Finetune' or args.phase == 'finetune':
print('===> Finetune')
# how to do finetune?
model_name = input('enter model name: ')
model_loaded = torch.load(model_name)
model.load_state_dict(model_loaded['model_state_dict'], strict=False)
model.no_bn = model_loaded['no_bn']
for para in model.parameters():
para.requires_grad = False
model.bn1.track_running_stats = False
model.bn2.track_running_stats = False
model.bn3.track_running_stats = False
model.ic1.weight.requires_grad = True
model.ic1.bias.requires_grad = True
model.ic2.weight.requires_grad = True
model.ic2.bias.requires_grad = True
model.ic3.weight.requires_grad = True
model.ic3.bias.requires_grad = True
model.preluic1.weight.requires_grad = True
model.preluic2.weight.requires_grad = True
model.finetune = True
train_losses, valid_losses = \
train(args, train_loader, valid_loader, model, criterion_pts, criterion_classes, optimizer, device)
print('====================================================')
elif args.phase == 'Predict' or args.phase == 'predict':
print('===> Predict')
# how to do predict?
model_name = input('enter model name: ')
valid_loader = torch.utils.data.DataLoader(test_set,
batch_size=1,
shuffle=True)
model_loaded = torch.load(model_name)
model.load_state_dict(model_loaded['model_state_dict'])
model.no_bn = model_loaded['no_bn']
model.eval()
print('enter bn:', model.no_bn)
model.bn1.track_running_stats = False
model.bn2.track_running_stats = False
model.bn3.track_running_stats = False
predict(model, valid_loader)