def __init__(self):
opt = TrainOptions().parse()
os.system('rm -rf ./logs_' + opt.problem)
dataset = load_data(opt.num)
print('Dataset loaded!')
model = Model(opt)
if opt.mode == 'train':
self.train(opt, dataset, model)
self.test(opt, dataset, model)
else:
self.test(opt, dataset, model)
def train():
############## initialization ################
### load csv files of annotations, initialize options
dataroot = './data'
train_list = np.array(
pd.read_csv(os.path.join(dataroot, 'labels/training_set_anno.csv')))
val_list = np.array(
pd.read_csv(os.path.join(dataroot, 'labels/validation_set_anno.csv')))
opt_mask = TrainOptions().parse()
opt = copy.deepcopy(opt_mask)
opt.global_transform = opt.global_transform[1:]
opt.global_transform_para = opt.global_transform_para[1:]
train_dataroot = os.path.join(dataroot, 'dataset/train')
val_dataroot = os.path.join(dataroot, 'dataset/val')
# define dataset and dataloader
train_dataset = LXD_dataset.LXD_dataset(opt, train_dataroot, train_list,
'train')
train_dataset_mask = LXD_dataset.LXD_dataset(opt_mask, train_dataroot,
train_list, 'train')
con_dataset_train = LXD_dataset.con_dataset(train_dataset,
train_dataset_mask)
val_dataset = LXD_dataset.LXD_dataset(opt, val_dataroot, val_list, 'val')
val_dataset_mask = LXD_dataset.LXD_dataset(opt_mask, val_dataroot,
val_list, 'val')
con_dataset_val = LXD_dataset.con_dataset(val_dataset, val_dataset_mask)
train_loader = torch.utils.data.DataLoader(con_dataset_train,
batch_size=opt.batch_size,
shuffle=True)
val_loader = torch.utils.data.DataLoader(con_dataset_val,
batch_size=4,
shuffle=False)
# define model and trainer
os.environ['CUDA_VISIBLE_DEVICES'] = opt.gpu_ids
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
opt.device = device
model1 = models.vgg16_bn(pretrained=False)
model2 = models.vgg16_bn(pretrained=False)
model = mVGG16.CSRA_VGG16_2branch(model1, model2, opt, device)
if opt.use_gpu:
model.to(device=device)
trainer = CSRA_trainer.CSRA_Trainer(opt, model)
# training and validation
for epoch in range(opt.epochs):
acc = trainer.train(train_loader)
with torch.no_grad():
trainer.eval(val_loader)
if acc > 0.98:
break
if epoch == 10:
trainer.adjust_learning_rate(0.1)
import time
from train_options import TrainOptions
from data import create_dataset
from models import create_model
from visualizer import Visualizer
if __name__ == '__main__':
opt = TrainOptions().parse() # get training options
dataset = create_dataset(opt) # create a dataset given opt.dataset_mode and other options
dataset_size = len(dataset) # get the number of images in the dataset.
print('The number of training images = %d' % dataset_size)
model = create_model(opt) # create a model given opt.model and other options
model.setup(opt) # regular setup: load and print networks; create schedulers
visualizer = Visualizer(opt) # create a visualizer that display/save images and plots
total_iters = 0 # the total number of training iterations
for epoch in range(opt.epoch_count, opt.n_epochs + opt.n_epochs_decay + 1): # outer loop for different epochs; we save the model by <epoch_count>, <epoch_count>+<save_latest_freq>
epoch_start_time = time.time() # timer for entire epoch
iter_data_time = time.time() # timer for data loading per iteration
epoch_iter = 0 # the number of training iterations in current epoch, reset to 0 every epoch
visualizer.reset() # reset the visualizer: make sure it saves the results to HTML at least once every epoch
model.update_learning_rate() # update learning rates in the beginning of every epoch.
for i, data in enumerate(dataset): # inner loop within one epoch
iter_start_time = time.time() # timer for computation per iteration
if total_iters % opt.print_freq == 0:
t_data = iter_start_time - iter_data_time
total_iters += opt.batch_size
epoch_iter += opt.batch_size
model.set_input(data) # unpack data from dataset and apply preprocessing
import time
import sys
import tensorflow as tf
sys.path.append('/home/zhangjunhao/options')
from train_options import TrainOptions
sys.path.append('/home/zhangjunhao/data')
from data_loader import CreateDataLoader
sys.path.append('/home/zhangjunhao/model')
from model_Loader import CreateModel
sys.path.append('/home/zhangjunhao/util')
from utils import error as err
opt = TrainOptions().parse()
data_loader = CreateDataLoader(opt)
model = CreateModel(opt)
sess = tf.Session()
loss_g = tf.placeholder(tf.float32)
loss_d = tf.placeholder(tf.float32)
me1 = tf.summary.scalar('loss_g', loss_g)
me2 = tf.summary.scalar('loss_d', loss_d)
merged = tf.summary.merge([me1, me2])
writer = tf.summary.FileWriter("/home/zhangjunhao/logs", sess.graph)
err = err(model.save_dir)
for epoch in range(opt.count_epoch + 1, opt.epochs + 1):
epoch_start_time = time.time()
err.initialize()
for i, data in enumerate(data_loader):
model.forward(data)
""" Entry point for training
"""
from train_options import TrainOptions
from trainer import Trainer
if __name__ == '__main__':
options = TrainOptions().parse_args()
trainer = Trainer(options)
trainer.train()