def main():
# Set save path
save_path = args.save_path
if not os.path.exists(save_path):
os.makedirs(save_path)
# Save configuration
with open(save_path+'/configuration.json', 'w') as f:
json.dump(args.__dict__, f, indent=2)
# Load dataset
path = args.data_path
train_df, test_df, train_ng_pool, test_negative, num_user, num_item, feature = D.load_data(path)
train_dataset = D.CustomDataset(train_df, feature, negative=train_ng_pool, num_neg = args.num_neg, istrain=True)
test_dataset = D.CustomDataset(test_df, feature, negative=test_negative, num_neg = None, istrain=False)
# test_dataset = D.CustomDataset(train_df, feature, negative=train_ng_pool, num_neg = None, istrain=False)
train_loader = DataLoader(train_dataset, batch_size=args.batch_size, shuffle=True, num_workers=4, collate_fn=my_collate_trn)
test_loader = DataLoader(test_dataset, batch_size=1, shuffle=False, num_workers=4, collate_fn=my_collate_tst)
# Model
model = MAML(num_user, num_item, args.embed_dim, args.dropout_rate).cuda()
print(model)
if args.load_path is not None:
checkpoint = torch.load(args.load_path)
model.load_state_dict(checkpoint)
print("Pretrained Model Loaded")
# Optimizer
optimizer = torch.optim.Adam(model.parameters(),lr=args.lr)
# Loss
embedding_loss = Embedding_loss(margin=args.margin, num_item = num_item).cuda()
feature_loss = Feature_loss().cuda()
covariance_loss = Covariance_loss().cuda()
# Logger
train_logger = Logger(f'{save_path}/train.log')
test_logger = Logger(f'{save_path}/test.log')
# Train & Eval
for epoch in range(args.epoch):
train_loader.dataset.train_ng_sampling()
train(model, embedding_loss, feature_loss, covariance_loss, optimizer, train_loader, train_logger, epoch)
if (epoch+1) % 100 == 0 or epoch==0:
test(model, test_loader, test_logger, epoch)
# Save Model every 100 epoch
torch.save(model.state_dict(), f"{save_path}/model_{epoch+1}.pth")
def train(model):
"""Train the model."""
epoch_count = 0
# training cross-validation with 5 fold
for i in range(5):
# Training dataset.
print("Training fold", i)
dataset_train = dataset.CustomDataset()
dataset_train.load_custom_K_fold(dataset_path, "train", i)
dataset_train.prepare()
# Validation dataset
dataset_val = dataset.CustomDataset()
dataset_val.load_custom_K_fold(dataset_path, "val", i)
dataset_val.prepare()
augmentation = imgaug.augmenters.Sometimes(0.5, [
imgaug.augmenters.Fliplr(0.5),
imgaug.augmenters.Flipud(0.5)])
model_inference = modellib.MaskRCNN(mode="inference", config=config,model_dir=logs)
mAP_callback = modellib.MeanAveragePrecisionCallback(model, model_inference, dataset_val,
calculate_at_every_X_epoch=25, dataset_limit=500, verbose=1)
# Training - Stage 1
epoch_count += 20
print("Training network heads")
model.train(dataset_train, dataset_val,
learning_rate=config.LEARNING_RATE *2,
epochs= epoch_count,
layers='heads',
custom_callbacks=[mAP_callback])
#augmentation=augmentation)
epoch_count += 10
print("Fine tune Resnet stage 4 and up")
model.train(dataset_train, dataset_val,
learning_rate=config.LEARNING_RATE,
epochs= epoch_count,
layers='4+',
custom_callbacks=[mAP_callback],
augmentation=augmentation)
def train(model):
# Training set.
dataset_train = dataset.CustomDataset()
dataset_train.load_custom(dataset_path, "train")
dataset_train.prepare()
print("Images: {}\nClasses: {}".format(len(dataset_train.image_ids),
dataset_train.class_names))
# Validation set
dataset_val = dataset.CustomDataset()
dataset_val.load_custom(dataset_path, "val")
dataset_val.prepare()
print("Images: {}\nClasses: {}".format(len(dataset_val.image_ids),
dataset_val.class_names))
augmentation = imgaug.augmenters.Sometimes(
0.5, [imgaug.augmenters.Fliplr(0.5),
imgaug.augmenters.Flipud(0.5)])
model_inference = modellib.MaskRCNN(mode="inference",
config=config,
model_dir=logs)
#calculating COCO-mAP after every 5 epoch, limited to the first 1000 images
mAP_callback = modellib.MeanAveragePrecisionCallback(
model,
model_inference,
dataset_val,
calculate_at_every_X_epoch=5,
dataset_limit=1000,
verbose=1)
# Training - Stage 1
print("Training network heads")
model.train(dataset_train,
dataset_val,
learning_rate=config.LEARNING_RATE,
epochs=20,
layers='heads',
custom_callbacks=[mAP_callback],
augmentation=augmentation)
# Run detection on one image at a time
GPU_COUNT = 1
IMAGES_PER_GPU = 1
config = InferenceConfig()
config.display()
# Device to load the neural network on.
# Useful if you're training a model on the same
# machine, in which case use CPU and leave the
# GPU for training.
#DEVICE = "/gpu:0" # /cpu:0 or /gpu:0
# Load validation dataset
dataset = dataset.CustomDataset()
dataset.load_custom(dataset_dir, "val")
dataset.prepare()
print("Images: {}\nClasses: {}".format(len(dataset.image_ids),
dataset.class_names))
model = modellib.MaskRCNN(mode="inference", model_dir=MODEL_DIR, config=config)
print("Loading weights ", weight_path)
model.load_weights(weight_path, by_name=True)
n = 0
count_porn = 0
count_non = 0
'-s',
type=str,
help='source model file')
parser.add_argument('--dst-model',
'-d',
type=str,
help='destination model file')
parser.add_argument('--num-classes',
type=int,
default=1,
help='number of classes')
parser.add_argument('--dataset', type=str, default='', help='dataset path')
args = parser.parse_args()
print(args)
dataset = dataset.CustomDataset(args.dataset, 'train')
num_ids = dataset.max_id + 2
print(num_ids)
if '0.5x' in args.src_model:
model_size = '0.5x'
elif '1.0x' in args.src_model:
model_size = '1.0x'
elif '1.5x' in args.src_model:
model_size = '1.5x'
elif '2.0x' in args.src_model:
model_size = '2.0x'
anchors = np.random.randint(low=10, high=150, size=(12, 2))
model = shufflenetv2.ShuffleNetV2(anchors,
num_classes=args.num_classes,
# Data preprocessing
df = pd.read_csv("../input/data/train.csv")
df['list'] = df[df.columns[3:]].values.tolist()
new_df = df[['TITLE', 'ABSTRACT', 'list']].copy()
# Creating Dataset and Dataloaders
train_size = 0.8
train_dataset = new_df.sample(frac=train_size, random_state=200)
test_dataset = new_df.drop(train_dataset.index).reset_index(drop=True)
train_dataset = train_dataset.reset_index(drop=True)
print("FULL Dataset: {}".format(new_df.shape))
print("TRAIN Dataset: {}".format(train_dataset.shape))
print("TEST Dataset: {}".format(test_dataset.shape))
training_set = dataset.CustomDataset(train_dataset, config.TOKENIZER,
config.MAX_LEN)
testing_set = dataset.CustomDataset(test_dataset, config.TOKENIZER,
config.MAX_LEN)
train_params = {
'batch_size': config.TRAIN_BATCH_SIZE,
'shuffle': True,
'num_workers': 0
}
test_params = {
'batch_size': config.VALID_BATCH_SIZE,
'shuffle': True,
'num_workers': 0
}
def main():
#Hyperparameter
parser = argparse.ArgumentParser(description='PyTorch MNIST Example')
parser.add_argument('--batch-size',
type=int,
default=128,
metavar='N',
help='input batch size for training (default: 64)')
parser.add_argument('--test-batch-size',
type=int,
default=500,
metavar='N',
help='input batch size for testing (default: 1000)')
parser.add_argument('--epochs',
type=int,
default=10,
metavar='N',
help='number of epochs to train (default: 10)')
parser.add_argument('--lr',
type=float,
default=0.0001,
metavar='LR',
help='learning rate (default: 0.01)')
parser.add_argument('--lrlist',
default=[0.001, 0.0001],
help="list for adjust learning rate")
parser.add_argument('--momentum',
type=float,
default=0.5,
metavar='M',
help='SGD momentum (default: 0.5)')
parser.add_argument('--weight-decay',
type=float,
default=0.00000001,
help='weight decay parameter')
#Data sampling method
parser.add_argument(
'--new_version',
default=True,
type=bool,
help=
"True : longer input length, False : input length + prediction length = 31"
)
parser.add_argument(
'--random-length',
default=[False, True],
type=bool,
help="if you want to use randomized sample length, True.")
parser.add_argument('--before_lim',
default=120,
type=int,
help='initialize batchs input length')
parser.add_argument('--after_lim',
default=30,
type=int,
help='initialize batchs prediction length')
# Mode Configure
parser.add_argument('--test',
default=False,
help='use for testing(trained model)')
parser.add_argument(
'--save-model',
action='store_true',
default=True, # False~>True
help='For Saving the current Model')
parser.add_argument('--name', type=str, default='LSTM_20_2')
parser.add_argument('--log-pass', type=int, default=10000)
parser.add_argument('--no-cuda',
action='store_true',
default=False,
help='disables CUDA training')
parser.add_argument('--seed',
type=int,
default=2,
metavar='S',
help='random seed (default: 1)')
parser.add_argument(
'--log-interval',
type=int,
default=500,
metavar='N', # 10~>50
help='how many batches to wait before logging training status')
parser.add_argument('--isweather',
default=False,
help='key of using weather information')
parser.add_argument('--isMSEweighted',
default=False,
help='key for using weighted MSE')
#Path
# parser.add_argument('--resume', default='./model/LSTM_20_1/76001checkpoint_lstm_std.pth.tar', type=str, metavar='PATH',
# help='path to latest checkpoint (default: none)')
parser.add_argument('--resume', default='', type=str)
parser.add_argument("--data-root",
default="./data/03_merge/v06_divide_train_test/")
parser.add_argument("--normalize-factor-path",
type=str,
default='./data/etc/normalize_factor.csv')
parser.add_argument("--usable-idx-path", type=str, default="./data/etc/")
# Cuda Configureration
args = parser.parse_args()
use_cuda = not args.no_cuda and torch.cuda.is_available()
torch.manual_seed(args.seed)
device = torch.device("cuda" if use_cuda else "cpu")
cudnn.benchmark = True
cudnn.deterministic = True
kwargs = {'num_workers': 1, 'pin_memory': True} if use_cuda else {}
# Normalize factor load
fr = open(args.normalize_factor_path, 'r', encoding='cp949', newline='')
normalize_factor = list(csv.reader(fr))
if args.test:
train_loss_dataset = dataset.CustomDataset(args,
args.data_root,
"v05_trainset.csv",
"idx_train_loss.csv",
for_test=True)
train_loss_sampler = sampler.BatchSampler(
sampler.SequentialSampler(train_loss_dataset),
batch_size=2000,
drop_last=False,
random_length=args.random_length,
for_test=True,
before_lim=args.before_lim,
after_lim=args.after_lim,
new_version_sampler=args.new_version)
train_loss_loader = torch.utils.data.DataLoader(
train_loss_dataset, batch_sampler=train_loss_sampler, **kwargs)
test_dataset = dataset.CustomDataset(args,
args.data_root,
"v05_testset.csv",
"idx_test.csv",
for_test=True)
test_sampler = sampler.BatchSampler(
sampler.SequentialSampler(test_dataset),
batch_size=2000,
drop_last=False,
random_length=args.random_length,
for_test=True,
before_lim=args.before_lim,
after_lim=args.after_lim,
new_version_sampler=args.new_version)
test_loader = torch.utils.data.DataLoader(test_dataset,
batch_sampler=test_sampler,
**kwargs)
else:
train_dataset = dataset.CustomDataset(args, args.data_root,
"v05_trainset.csv",
"idx_train.csv")
# BatchSampler Parameter : (sampler, batch_size, drop_last,random_length = False,for_test=False,new_type_sampler=True,before_lim=-1,after_lim=-1)
train_sampler = sampler.BatchSampler(
sampler.RandomSampler(train_dataset),
batch_size=args.batch_size,
drop_last=False,
random_length=args.random_length,
before_lim=args.before_lim,
after_lim=args.after_lim,
new_version_sampler=args.new_version)
train_loader = torch.utils.data.DataLoader(train_dataset,
batch_sampler=train_sampler,
**kwargs)
train_loss_dataset = dataset.CustomDataset(args,
args.data_root,
"v05_trainset.csv",
"idx_train_loss.csv",
for_test=True)
train_loss_sampler = sampler.BatchSampler(
sampler.RandomSampler(train_loss_dataset),
batch_size=args.test_batch_size,
drop_last=False,
random_length=args.random_length,
for_test=True,
before_lim=args.before_lim,
after_lim=args.after_lim,
new_version_sampler=args.new_version)
train_loss_loader = torch.utils.data.DataLoader(
train_loss_dataset, batch_sampler=train_loss_sampler, **kwargs)
test_dataset = dataset.CustomDataset(args,
args.data_root,
"v05_testset.csv",
"idx_test.csv",
for_test=True)
test_sampler = sampler.BatchSampler(
sampler.RandomSampler(test_dataset),
batch_size=args.test_batch_size,
drop_last=False,
random_length=args.random_length,
for_test=True,
before_lim=args.before_lim,
after_lim=args.after_lim,
new_version_sampler=args.new_version)
test_loader = torch.utils.data.DataLoader(test_dataset,
batch_sampler=test_sampler,
**kwargs)
#Training Configuration
writer = SummaryWriter('./log/' + args.name + '/')
print(device)
model = Model.LSTM(args).to(device)
if args.isMSEweighted:
criterion = weighted_mse_loss
else:
criterion = nn.MSELoss().to(device)
optimizer = optim.Adam(model.parameters(), lr=args.lr)
training = Train.Training(model)
steps = 0
best_loss = 1000000
start_epoch = 1
#Load Trained Model
if args.resume:
if os.path.isfile(args.resume):
print("=> loading checkpoint '{}'".format(args.resume))
checkpoint = torch.load(args.resume)
model.load_state_dict(checkpoint['state_dict'])
optimizer.load_state_dict(checkpoint['optimizer'])
print("=> loaded checkpoint '{}' (epoch {})".format(
args.resume, checkpoint['epoch']))
steps = checkpoint['steps']
best_loss = checkpoint['best_loss']
start_epoch = checkpoint['epoch']
else:
print("=> no checkpoint found at '{}'".format(args.resume))
if not args.test:
#학습용
for param_group in optimizer.param_groups:
param_group['lr'] = args.lr
for epoch in range(start_epoch, args.epochs):
print(epoch)
adjust_learning_rate(optimizer, steps, args)
steps, best_loss = training.train(args, model, criterion, device,
train_loader, test_loader,
train_loss_loader, optimizer,
epoch, writer, normalize_factor,
steps, best_loss)
else:
#검증용
print("activate test code!!!!")
args.random_length[0] = False
test_mse, test_mae, test_won_sum_mae, test_won_mae, test_mae_list, test_var = training.eval(
args,
test_loader,
model,
criterion,
device,
normalize_factor,
teacher_forcing=False)
writer.add_scalars('Loss_test', {'test loss': test_mae}, 1)
writer.add_scalars('Won mae_test', {'test_won_mae': test_won_sum_mae},
1)
writer.add_scalars(
'energy_prediction_mae_test', {
'elec': test_won_mae[0],
'water': test_won_mae[1],
'gas': test_won_mae[2]
}, 1)
print("mae_won={}".format(test_won_sum_mae))
for i in range(30):
writer.add_scalars('예측 길이에 따른 오차_test',
{'test won': test_mae_list[i]}, i + 1)
def train(epoch):
global processed_batches
t0 = time.time()
if ngpus > 1:
cur_model = model.module
else:
cur_model = model
train_loader = torch.utils.data.DataLoader(dataset.CustomDataset(),
batch_size=batch_size,
shuffle=False,
**kwargs)
lr = adjust_learning_rate(optimizer, processed_batches)
logging('epoch %d, processed %d samples, lr %f' %
(epoch, epoch * len(train_loader.dataset), lr))
model.train()
t1 = time.time()
avg_time = torch.zeros(9)
for batch_idx, (data, target) in enumerate(train_loader):
t2 = time.time()
adjust_learning_rate(optimizer, processed_batches)
processed_batches = processed_batches + 1
#if (batch_idx+1) % dot_interval == 0:
# sys.stdout.write('.')
if use_cuda:
data = data.cuda()
#target= target.cuda()
t3 = time.time()
data, target = Variable(data), Variable(target)
t4 = time.time()
optimizer.zero_grad()
t5 = time.time()
output = model(data)
t6 = time.time()
region_loss.seen = region_loss.seen + data.data.size(0)
loss = region_loss(output, target)
t7 = time.time()
loss.backward()
t8 = time.time()
optimizer.step()
t9 = time.time()
if False and batch_idx > 1:
avg_time[0] = avg_time[0] + (t2 - t1)
avg_time[1] = avg_time[1] + (t3 - t2)
avg_time[2] = avg_time[2] + (t4 - t3)
avg_time[3] = avg_time[3] + (t5 - t4)
avg_time[4] = avg_time[4] + (t6 - t5)
avg_time[5] = avg_time[5] + (t7 - t6)
avg_time[6] = avg_time[6] + (t8 - t7)
avg_time[7] = avg_time[7] + (t9 - t8)
avg_time[8] = avg_time[8] + (t9 - t1)
print('-------------------------------')
print(' load data : %f' % (avg_time[0] / (batch_idx)))
print(' cpu to cuda : %f' % (avg_time[1] / (batch_idx)))
print('cuda to variable : %f' % (avg_time[2] / (batch_idx)))
print(' zero_grad : %f' % (avg_time[3] / (batch_idx)))
print(' forward feature : %f' % (avg_time[4] / (batch_idx)))
print(' forward loss : %f' % (avg_time[5] / (batch_idx)))
print(' backward : %f' % (avg_time[6] / (batch_idx)))
print(' step : %f' % (avg_time[7] / (batch_idx)))
print(' total : %f' % (avg_time[8] / (batch_idx)))
t1 = time.time()
print('')
t1 = time.time()
logging('training with %f samples/s' % (len(train_loader.dataset) /
(t1 - t0)))
if (epoch + 1) % save_interval == 0:
logging('save weights to %s/%06d.weights' % (backupdir, epoch + 1))
cur_model.seen = (epoch + 1) * len(train_loader.dataset)
cur_model.save_weights('%s/%06d.weights' % (backupdir, epoch + 1))
import options
import dataset
import functions
import train
import network
import save_results
import os
if __name__ == '__main__':
opt = options.Options().parser.parse_args()
ratio_A = opt.ratio_A
dataset_A = dataset.CustomDataset(ratio=ratio_A,
train=True,
dataset=opt.dataset)
dataloader_A = dataset.DataLoader(dataset_A,
batch_size=opt.batch_size_A,
shuffle=True)
ratio_B = opt.ratio_B
dataset_B = dataset.CustomDataset(ratio=ratio_B,
train=True,
dataset=opt.dataset)
dataloader_B = dataset.DataLoader(dataset_B,
batch_size=opt.batch_size_B,
shuffle=True)
sampled_batch_size = opt.sampled_batch_size
testset_A = dataset.CustomDataset(ratio=ratio_A, train=False)
################################################################################
# Dividing Dataset
####################################################################################
train_dataset, valid_dataset = train_test_split(new_df,
test_size=.2,
random_state=42)
print("Shape of train_dataset is :{} Shape of valid_dataset is :{}".format(
train_dataset.shape, valid_dataset.shape))
##############################################################
# Defining Tokenizer
################################################################
tokenizer = config_file.tokenizer
# Creating the Training and Validation dataset for further creation of Dataloader
training_set = dataset.CustomDataset(train_dataset, tokenizer, config.MAX_LEN,
config.SUMMARY_LEN)
val_set = dataset.CustomDataset(valid_dataset, tokenizer, config.MAX_LEN,
config.SUMMARY_LEN)
# Defining the parameters for creation of dataloaders
train_params = {
'batch_size': config.TRAIN_BATCH_SIZE,
'shuffle': True,
'num_workers': 8
}
val_params = {
'batch_size': config.VALID_BATCH_SIZE,
'shuffle': False,
'num_workers': 4
}
# make pixel indexes 0-based
x1 = int(bbox.find('xmin').text) - 1
y1 = int(bbox.find('ymin').text) - 1
x2 = int(bbox.find('xmax').text) - 1
y2 = int(bbox.find('ymax').text) - 1
bboxes.append([x1, y1, x2, y2])
testgt_bboxes_dict[ind] = bboxes
# data loader for training data
# use a custon sampler to load all positive samples and random sample negative samples
# so that number size of negative sample is 10% of positive sample
sampler = dataset.CustomSampler(len(pos_indexes), len(neg_indexes), 0.1)
train_indexes = np.concatenate([pos_indexes, neg_indexes], axis=0)
catdata = dataset.CustomDataset(train_indexes,
H,
W,
data_dir,
gt_bboxes_dict,
aug=True)
trainloader = data.DataLoader(dataset=catdata,
batch_size=32,
sampler=sampler,
num_workers=4)
# data loader for testing data
testdata = dataset.CustomDataset(testimg_indexes,
H,
W,
testdata_dir,
testgt_bboxes_dict,
aug=False)
testloader = data.DataLoader(dataset=testdata,
def train(args):
utils.make_workspace_dirs(args.workspace)
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
anchors = np.loadtxt(os.path.join(args.dataset, 'anchors.txt'))
scale_sampler = utils.TrainScaleSampler(args.in_size, args.scale_step,
args.rescale_freq)
shared_size = torch.IntTensor(args.in_size).share_memory_()
logger = utils.get_logger(path=os.path.join(args.workspace, 'log.txt'))
torch.backends.cudnn.benchmark = True
dataset = ds.CustomDataset(args.dataset, 'train')
collate_fn = partial(ds.collate_fn, in_size=shared_size, train=True)
data_loader = torch.utils.data.DataLoader(dataset,
args.batch_size,
True,
num_workers=args.workers,
collate_fn=collate_fn,
pin_memory=args.pin,
drop_last=True)
num_ids = dataset.max_id + 2
if args.backbone == 'darknet':
model = darknet.DarkNet(anchors,
num_classes=args.num_classes,
num_ids=num_ids).to(device)
elif args.backbone == 'shufflenetv2':
model = shufflenetv2.ShuffleNetV2(anchors,
num_classes=args.num_classes,
num_ids=num_ids,
model_size=args.thin).to(device)
else:
print('unknown backbone architecture!')
sys.exit(0)
if args.checkpoint:
model.load_state_dict(torch.load(args.checkpoint))
params = [p for p in model.parameters() if p.requires_grad]
if args.optim == 'sgd':
optimizer = torch.optim.SGD(params,
lr=args.lr,
momentum=args.momentum,
weight_decay=args.weight_decay)
else:
optimizer = torch.optim.Adam(params,
lr=args.lr,
weight_decay=args.weight_decay)
if args.freeze_bn:
for name, param in model.named_parameters():
if 'norm' in name:
param.requires_grad = False
logger.info('freeze {}'.format(name))
else:
param.requires_grad = True
trainer = f'{args.workspace}/checkpoint/trainer-ckpt.pth'
if args.resume:
trainer_state = torch.load(trainer)
optimizer.load_state_dict(trainer_state['optimizer'])
if -1 in args.milestones:
args.milestones = [int(args.epochs * 0.5), int(args.epochs * 0.75)]
lr_scheduler = torch.optim.lr_scheduler.MultiStepLR(
optimizer, milestones=args.milestones, gamma=args.lr_gamma)
start_epoch = 0
if args.resume:
start_epoch = trainer_state['epoch'] + 1
lr_scheduler.load_state_dict(trainer_state['lr_scheduler'])
logger.info(args)
logger.info('Start training from epoch {}'.format(start_epoch))
model_path = f'{args.workspace}/checkpoint/{args.savename}-ckpt-%03d.pth'
size = shared_size.numpy().tolist()
for epoch in range(start_epoch, args.epochs):
model.train()
logger.info(('%8s%10s%10s' + '%10s' * 8) %
('Epoch', 'Batch', 'SIZE', 'LBOX', 'LCLS', 'LIDE', 'LOSS',
'SB', 'SC', 'SI', 'LR'))
rmetrics = defaultdict(float)
optimizer.zero_grad()
for batch, (images, targets) in enumerate(data_loader):
warmup = min(args.warmup, len(data_loader))
if epoch == 0 and batch <= warmup:
lr = args.lr * (batch / warmup)**4
for g in optimizer.param_groups:
g['lr'] = lr
loss, metrics = model(images.to(device), targets.to(device), size)
loss.backward()
if args.sparsity:
model.correct_bn_grad(args.lamb)
num_batches = epoch * len(data_loader) + batch + 1
if ((batch + 1) % args.accumulated_batches
== 0) or (batch == len(data_loader) - 1):
optimizer.step()
optimizer.zero_grad()
for k, v in metrics.items():
rmetrics[k] = (rmetrics[k] * batch + metrics[k]) / (batch + 1)
fmt = tuple([('%g/%g') % (epoch, args.epochs), ('%g/%g') % (batch,
len(data_loader)), ('%gx%g') % (size[0], size[1])] + \
list(rmetrics.values()) + [optimizer.param_groups[0]['lr']])
if batch % args.print_interval == 0:
logger.info(('%8s%10s%10s' + '%10.3g' *
(len(rmetrics.values()) + 1)) % fmt)
size = scale_sampler(num_batches)
shared_size[0], shared_size[1] = size[0], size[1]
torch.save(model.state_dict(), f"{model_path}" % epoch)
torch.save(
{
'epoch': epoch,
'optimizer': optimizer.state_dict(),
'lr_scheduler': lr_scheduler.state_dict()
}, trainer)
if epoch >= args.eval_epoch:
pass
lr_scheduler.step()
def main():
wandb.init(project="AttCF")
parser = argparse.ArgumentParser()
parser.add_argument('--data_path',
type=str,
default='/daintlab/data/recommend/Amazon-office-raw',
help='path')
parser.add_argument('--top_k', type=int, default=10, help='top_k')
parser.add_argument('--optim', type=str, default='adam', help='optimizer')
parser.add_argument('--epochs', type=int, default=5, help='epoch')
parser.add_argument('--batch_size',
type=int,
default=256,
help='batch size')
parser.add_argument('--dim', type=int, default=128, help='dimension')
parser.add_argument('--lr',
type=float,
default=0.001,
help='learning rate')
parser.add_argument('--gpu', type=str, default='0', help='gpu number')
parser.add_argument('--num_sam',
type=int,
default=4,
help='num of pos sample')
parser.add_argument('--feature_type',
default='all',
type=str,
help='Type of feature to use. [all, img, txt]')
parser.add_argument(
'--eval_type',
default='leave-one-out',
type=str,
help='Evaluation protocol. [ratio-split, leave-one-out]')
global args
global sd
global train_len
global test_len
args = parser.parse_args()
wandb.config.update(args)
args = parser.parse_args()
os.environ['CUDA_VISIBLE_DEVICES'] = args.gpu
# Load dataset
print("Loading Dataset")
data_path = os.path.join(args.data_path, args.eval_type)
train_df, test_df, train_ng_pool, test_negative, num_user, num_item, images = D.load_data(
data_path, args.feature_type)
train_len = len(train_df)
test_len = num_user
train_dataset = D.CustomDataset(train_df,
test_df,
images,
negative=train_ng_pool,
istrain=True,
feature_type=args.feature_type,
num_sam=args.num_sam)
test_dataset = D.CustomDataset(train_df,
test_df,
images,
negative=test_negative,
istrain=False,
feature_type=args.feature_type,
num_sam=args.num_sam)
train_loader = DataLoader(train_dataset,
batch_size=args.batch_size,
shuffle=True,
collate_fn=my_collate,
pin_memory=True)
test_loader = DataLoader(test_dataset,
batch_size=1,
shuffle=False,
collate_fn=my_collate_tst,
pin_memory=True)
# Model
acf = ACF(num_user, num_item, images, args.dim)
acf = torch.nn.DataParallel(acf)
acf = acf.cuda()
print(acf)
# Optimizer
optim = optimizer(optim=args.optim, lr=args.lr, model=acf)
# Train & Eval
for epoch in range(args.epochs):
sd = np.random.randint(2021)
start = time.time()
train(acf, train_loader, epoch, optim)
end = time.time()
print("{}/{} Train Time : {}".format(epoch + 1, args.epochs,
end - start))
if (epoch + 1) == args.epochs:
start = time.time()
test(acf, test_loader, epoch)
end = time.time()
print("{}/{} Evaluate Time : {}".format(epoch + 1, args.epochs,
end - start))
# Data
print('==> Preparing data..')
transform_train = transforms.Compose([
transforms.Resize((320, 160)),
transforms.ToTensor(),
transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)),
])
transform_test = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)),
])
# trainset = torchvision.datasets.CIFAR10(root='./data', train=True, download=True, transform=transform_train)
train_data_path = 'data_training'
trainset = dataset.CustomDataset(train_data_path, transform=transform_train)
trainloader = torch.utils.data.DataLoader(trainset, batch_size=64, shuffle=True)
# testset = torchvision.datasets.CIFAR10(root='./data', train=False, download=True, transform=transform_test)
# testloader = torch.utils.data.DataLoader(testset, batch_size=100, shuffle=False, num_workers=2)
# Model
print('==> Building model..')
# net = VGG('VGG16')
net = skynet.SkyNet()
net = net.to(device)
if args.resume:
# Load checkpoint.
def main(args):
try:
mp.set_start_method('spawn')
except RuntimeError:
pass
utils.make_workspace_dirs(args.workspace)
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
in_size = [int(insz) for insz in args.in_size.split(',')]
scale_step = [int(ss) for ss in args.scale_step.split(',')]
anchors = np.loadtxt(os.path.join(args.dataset, 'anchors.txt'))
scale_sampler = utils.TrainScaleSampler(scale_step, args.rescale_freq)
shared_size = torch.IntTensor(in_size).share_memory_()
dataset_train = ds.CustomDataset(args.dataset, 'train')
data_loader = torch.utils.data.DataLoader(
dataset=dataset_train,
batch_size=args.batch_size,
shuffle=True,
num_workers=args.workers,
collate_fn=partial(ds.collate_fn, in_size=shared_size, train=True),
pin_memory=args.pin)
dataset_valid = ds.CustomDataset(args.dataset, 'test')
data_loader_valid = torch.utils.data.DataLoader(
dataset=dataset_valid,
batch_size=1,
shuffle=False,
num_workers=1,
collate_fn=partial(ds.collate_fn, in_size=torch.IntTensor(in_size), train=False),
pin_memory=args.pin)
if args.checkpoint:
print(f'load {args.checkpoint}')
model = torch.load(args.checkpoint).to(device)
else:
print('please set fine tune model first!')
return
criterion = yolov3.YOLOv3Loss(args.num_classes, anchors)
decoder = yolov3.YOLOv3EvalDecoder(in_size, args.num_classes, anchors)
if args.test_only:
mAP = eval.evaluate(model, data_loader_valid, device, args.num_classes)
print(f'mAP of current model on validation dataset:%.2f%%' % (mAP * 100))
return
params = [p for p in model.parameters() if p.requires_grad]
if args.optim == 'sgd':
optimizer = torch.optim.SGD(params, lr=args.lr, momentum=args.momentum, weight_decay=args.weight_decay)
else:
optimizer = torch.optim.Adam(params, lr=args.lr, weight_decay=args.weight_decay)
if args.resume:
trainer_state = torch.load(f'{args.workspace}/checkpoint/trainer-ckpt.pth')
optimizer.load_state_dict(trainer_state['optimizer'])
milestones = [int(ms) for ms in args.milestones.split(',')]
def lr_lambda(iter):
if iter < args.warmup:
return pow(iter / args.warmup, 4)
factor = 1
for i in milestones:
factor *= pow(args.lr_gamma, int(iter > i))
return factor
lr_scheduler = torch.optim.lr_scheduler.LambdaLR(optimizer, lr_lambda)
if args.resume:
start_epoch = trainer_state['epoch'] + 1
lr_scheduler.load_state_dict(trainer_state['lr_scheduler'])
else:
start_epoch = 0
print(f'Start training from epoch {start_epoch}')
best_mAP = 0
for epoch in range(start_epoch, args.epochs):
msgs = train_one_epoch(model, criterion, optimizer, lr_scheduler, data_loader, epoch, args.interval, shared_size, scale_sampler, device, args.sparsity, args.lamb)
utils.print_training_message(epoch + 1, msgs, args.batch_size)
torch.save(model, f"{args.workspace}/checkpoint/{args.savename}-ckpt-%03d.pth" % epoch)
torch.save({
'epoch' : epoch,
'optimizer' : optimizer.state_dict(),
'lr_scheduler' : lr_scheduler.state_dict()}, f'{args.workspace}/checkpoint/trainer-ckpt.pth')
if epoch >= args.eval_epoch:
mAP = eval.evaluate(model, decoder, data_loader_valid, device, args.num_classes)
with open(f'{args.workspace}/log/mAP.txt', 'a') as file:
file.write(f'{epoch} {mAP}\n')
file.close()
print(f'Current mAP:%.2f%%' % (mAP * 100))
def main(args):
try:
mp.set_start_method('spawn')
except RuntimeError:
pass
utils.make_workspace_dirs(args.workspace)
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
in_size = [int(s) for s in args.in_size.split(',')]
scale_step = [int(ss) for ss in args.scale_step.split(',')]
anchors = np.loadtxt(os.path.join(args.dataset, 'anchors.txt'))
scale_sampler = utils.TrainScaleSampler(scale_step, args.rescale_freq)
shared_size = torch.IntTensor(in_size).share_memory_()
dataset = ds.CustomDataset(args.dataset, 'train')
collate_fn = partial(ds.collate_fn, in_size=shared_size, train=True)
data_loader = torch.utils.data.DataLoader(dataset,
args.batch_size,
True,
num_workers=args.workers,
collate_fn=collate_fn,
pin_memory=args.pin)
model = darknet.DarkNet(anchors, in_size,
num_classes=args.num_classes).to(device)
if args.checkpoint:
print(f'load {args.checkpoint}')
model.load_state_dict(torch.load(args.checkpoint))
if args.sparsity:
model.load_prune_permit('model/prune_permit.json')
criterion = yolov3.YOLOv3Loss(args.num_classes, anchors)
decoder = yolov3.YOLOv3EvalDecoder(in_size, args.num_classes, anchors)
params = [p for p in model.parameters() if p.requires_grad]
if args.optim == 'sgd':
optimizer = torch.optim.SGD(params,
lr=args.lr,
momentum=args.momentum,
weight_decay=args.weight_decay)
else:
optimizer = torch.optim.Adam(params,
lr=args.lr,
weight_decay=args.weight_decay)
trainer = f'{args.workspace}/checkpoint/trainer-ckpt.pth'
if args.resume:
trainer_state = torch.load(trainer)
optimizer.load_state_dict(trainer_state['optimizer'])
milestones = [int(ms) for ms in args.milestones.split(',')]
def lr_lambda(iter):
if iter < args.warmup:
return pow(iter / args.warmup, 4)
factor = 1
for i in milestones:
factor *= pow(args.lr_gamma, int(iter > i))
return factor
lr_scheduler = torch.optim.lr_scheduler.LambdaLR(optimizer, lr_lambda)
if args.resume:
start_epoch = trainer_state['epoch'] + 1
lr_scheduler.load_state_dict(trainer_state['lr_scheduler'])
else:
start_epoch = 0
print(f'Start training from epoch {start_epoch}')
for epoch in range(start_epoch, args.epochs):
msgs = train_one_epoch(model, criterion, optimizer, lr_scheduler,
data_loader, epoch, args.interval, shared_size,
scale_sampler, device, args.sparsity, args.lamb)
utils.print_training_message(args.workspace, epoch + 1, msgs,
args.batch_size)
torch.save(
model.state_dict(),
f"{args.workspace}/checkpoint/{args.savename}-ckpt-%03d.pth" %
epoch)
torch.save(
{
'epoch': epoch,
'optimizer': optimizer.state_dict(),
'lr_scheduler': lr_scheduler.state_dict()
}, trainer)
if epoch >= args.eval_epoch:
pass
