def main():
print(args)
N_EPOCHS = args.n_epochs
N_TRAIN = args.n_train
N_VALID = args.n_valid
BATCH_SIZE = args.batch_size
EMB_DIM = args.emb_dim
HID_DIM = args.hid_dim
MAXOUT_DIM = args.maxout_dim
TRAIN_X = 'PART_I.article'
TRAIN_Y = 'PART_I.summary'
VALID_X = 'PART_III.article'
VALID_Y = 'PART_III.summary'
trainX = utils.getDataLoader(TRAIN_X,
max_len=100,
n_data=N_TRAIN,
batch_size=BATCH_SIZE)
trainY = utils.getDataLoader(TRAIN_Y,
max_len=25,
n_data=N_TRAIN,
batch_size=BATCH_SIZE)
validX = utils.getDataLoader(VALID_X,
max_len=100,
n_data=N_VALID,
batch_size=BATCH_SIZE)
validY = utils.getDataLoader(VALID_Y,
max_len=25,
n_data=N_VALID,
batch_size=BATCH_SIZE)
vocab = json.load(open('data/vocab.json'))
model = Seq2SeqAttention(len(vocab),
EMB_DIM,
HID_DIM,
BATCH_SIZE,
vocab,
device,
max_trg_len=25).cuda(device)
model_file = args.model_file
if os.path.exists(model_file):
file = os.path.join(model_dir, os.listdir(model_dir)[-1])
model.load_state_dict(torch.load(model_file))
print('Load model parameters from %s' % model_file)
optimizer = torch.optim.SGD(model.parameters(), lr=1e-2)
scheduler = torch.optim.lr_scheduler.StepLR(optimizer,
step_size=20000,
gamma=0.3)
train(trainX, trainY, validX, validY, model, optimizer, scheduler,
N_EPOCHS)
def test(model, dataset, batch_size):
model.eval()
gallery_dataloader = utils.getDataLoader(dataset,
batch_size,
'gallery',
shuffle=False,
augment=False)
query_dataloader = utils.getDataLoader(dataset,
batch_size,
'query',
shuffle=False,
augment=False)
gallery_cams, gallery_labels = get_cam_label(
gallery_dataloader.dataset.imgs)
query_cams, query_labels = get_cam_label(query_dataloader.dataset.imgs)
# Extract feature
gallery_features = []
query_features = []
for inputs, _ in gallery_dataloader:
gallery_features.append(
extract_feature(model, inputs, requires_norm=True,
vectorize=True).cpu().data)
gallery_features = torch.cat(gallery_features, dim=0).numpy()
for inputs, _ in query_dataloader:
query_features.append(
extract_feature(model, inputs, requires_norm=True,
vectorize=True).cpu().data)
query_features = torch.cat(query_features, dim=0).numpy()
CMC, mAP, (sorted_index_list, sorted_y_true_list,
junk_index_list) = evaluate(query_features, query_labels,
query_cams, gallery_features,
gallery_labels, gallery_cams)
rank_list_fig = utils.save_rank_list_img(query_dataloader,
gallery_dataloader,
sorted_index_list,
sorted_y_true_list,
junk_index_list)
return CMC, mAP, rank_list_fig
def main():
N_VALID = args.n_valid
BATCH_SIZE = args.batch_size
EMB_DIM = args.emb_dim
HID_DIM = args.hid_dim
VALID_X = 'PART_III.article'
VALID_Y = 'PART_III.summary'
validX = utils.getDataLoader(VALID_X, max_len=100, n_data=N_VALID, batch_size=BATCH_SIZE)
validY = utils.getDataLoader(VALID_Y, max_len=25, n_data=N_VALID, batch_size=BATCH_SIZE)
vocab = json.load(open('data/vocab.json'))
model = Seq2SeqAttention(len(vocab), EMB_DIM, HID_DIM, BATCH_SIZE, vocab, device, max_trg_len=25).cuda(device)
file = args.model_file
if os.path.exists(file):
model.load_state_dict(torch.load(file))
print('Load model parameters from %s' % file)
mytest(validX, validY, model)
def test(model, dataset, batch_size):
model.eval()
gallery_dataloader = utils.getDataLoader(dataset,
batch_size,
'gallery',
shuffle=False,
augment=False)
query_dataloader = utils.getDataLoader(dataset,
batch_size,
'query',
shuffle=False,
augment=False)
gallery_cams, gallery_labels = get_cam_label(
gallery_dataloader.dataset.imgs)
query_cams, query_labels = get_cam_label(query_dataloader.dataset.imgs)
# Extract feature
gallery_features = []
query_features = []
for inputs, _ in gallery_dataloader:
gallery_features.append(
extract_feature(model, inputs, requires_norm=True,
vectorize=True).cpu().data)
gallery_features = torch.cat(gallery_features, dim=0).numpy()
for inputs, _ in query_dataloader:
query_features.append(
extract_feature(model, inputs, requires_norm=True,
vectorize=True).cpu().data)
query_features = torch.cat(query_features, dim=0).numpy()
return evaluate(query_features, query_labels, query_cams, gallery_features,
gallery_labels,
gallery_cams), gallery_features, query_features
def __init__(self, args):
self.params = args
(self.trainLoader, self.testLoader, self.D_in, self.D_out) = getDataLoader(
trainRatio=self.params.trainRatio,
batchSize=self.params.batchSize,
accidentType=self.params.accidentType,
)
self.model = Network(self.D_in, self.D_out).to(DEVICE)
self.opt = optim.Adam(
self.model.parameters(), lr=self.params.learningRate, weight_decay=1e-5
)
self._criterion = torch.nn.CrossEntropyLoss()
def main():
N_VALID = args.n_valid
BATCH_SIZE = args.batch_size
EMB_DIM = args.emb_dim
HID_DIM = args.hid_dim
VALID_X = 'sumdata/Giga/input.txt'
VALID_Y = 'sumdata/Giga/task1_ref0.txt'
vocab = json.load(open('sumdata/vocab.json'))
validX = utils.getDataLoader(VALID_X,
vocab,
n_data=N_VALID,
batch_size=BATCH_SIZE)
validY = utils.getDataLoader(VALID_Y,
vocab,
n_data=N_VALID,
batch_size=BATCH_SIZE)
model = Seq2SeqAttention(len(vocab),
EMB_DIM,
HID_DIM,
BATCH_SIZE,
vocab,
device,
max_trg_len=25)
if args.gpu != -1:
model = model.cuda(device)
file = args.model_file
if os.path.exists(file):
model.load_state_dict(torch.load(file))
print('Load model parameters from %s' % file)
mytest(validX, validY, model)
def __init__(self,
batch_size,
image_size,
latent_dim,
epochs,
discriminator_filters,
generator_filters,
device,
mixed_probability=0.9,
pl_beta=0.9):
self.StyleGan = StyleGan(batch_size, image_size, latent_dim,
discriminator_filters, generator_filters,
device).to(device)
self.image_size = image_size
self.num_layers = np.log2(image_size)
self.latent_dim = latent_dim
self.batch_size = batch_size
assert image_size in [2**x for x in range(5, 11)]
self.discriminator_loss = torch.tensor(0.).to(device)
self.generator_loss = torch.tensor(0.).to(device)
self.dataLoader = utils.getDataLoader(batch_size, image_size)
self.mixed_probability = mixed_probability
self.epochs = epochs
self.loss_fn = nn.BCEWithLogitsLoss()
self.average_pl_length = None
self.pl_beta = pl_beta
self.device = device
self.tensorboard_summary = SummaryWriter('runs7/stylegan2')
self.checkpoint = 0
self.apex_available = apex_available
self.constant_style = utils.createStyleMixedNoiseList(
self.batch_size, self.latent_dim, self.num_layers,
self.StyleGan.styleNetwork, self.device)
self.constant_noise = utils.create_image_noise(self.batch_size,
self.image_size,
self.device)
choices=['market1501', 'cuhk03', 'duke'])
parser.add_argument('--batch_size',
default=512,
type=int,
help='batchsize')
parser.add_argument('--share_conv', action='store_true')
arg = parser.parse_args()
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
save_dir_path = os.path.join(arg.save_path, arg.dataset)
logger = utils.Logger(save_dir_path)
logger.info(vars(arg))
# Just to get the correct num_classes of classifier fc
train_dataloader = utils.getDataLoader(arg.dataset, arg.batch_size,
'train')
model = utils.load_network(
PCBModel(num_classes=len(train_dataloader.dataset.classes),
share_conv=arg.share_conv,
return_features=True), save_dir_path, arg.which_epoch)
model = model.to(device)
CMC, mAP, rank_list_fig = test(model, arg.dataset, arg.batch_size)
logger.info('Testing: top1:%.2f top5:%.2f top10:%.2f mAP:%.2f' %
(CMC[0], CMC[4], CMC[9], mAP))
logger.save_img(rank_list_fig)
torch.cuda.empty_cache()
image_size = args.img_size
batch_size = args.batch_size
epochs = args.epochs
quiet = args.quiet == True
verbose = not quiet
latent_dim = 256
mixed_probability = 0.9
discriminator_filters = 8
generator_filters = 8
pl_beta = 0.99
if __name__ == '__main__':
device = torch.device("cuda:0") if torch.cuda.is_available() else torch.device("cpu")
print("Using device: ", device)
#model = StyleGan2Model()
dataLoader = utils.getDataLoader(batch_size, image_size)
# print(len(dataLoader) / 10)
Trainer = models.Trainer(batch_size, image_size, latent_dim, epochs, discriminator_filters, generator_filters, device, mixed_probability, pl_beta)
# print(Trainer.StyleGan)
# print(Trainer.StyleGan.generator.state_dict())
# print(sum(p.numel() for p in Trainer.StyleGan.parameters()))
# print(Trainer.StyleGan.discriminator.state_dict())
print(Trainer.StyleGan.generator.state_dict()['generatorBlocks.2.style_to_input_channels.weight'][0][0].item())
# print(Trainer.StyleGan.discriminator.state_dict()[])
print("Apex available: ", Trainer.apex_available)
# Trainer.resetSaves()
# x, y = next(enumerate(dataLoader))
x, y = next(enumerate(dataLoader))
# print(y[0])
# utils.showImage(y[0][0].expand(3, -1, -1))
def main(args):
# Setting
warnings.simplefilter("ignore", UserWarning)
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
# Args Parser
hj_method = args.hj_method
kr_method = args.kr_method
batch_size = args.batch_size
beam_size = args.beam_size
hidden_size = args.hidden_size
embed_size = args.embed_size
vocab_size = args.vocab_size
max_len = args.max_len
padding_index = args.pad_id
n_layers = args.n_layers
stop_ix = args.stop_ix
# Load saved model & Word2vec
save_path = 'save_{}_{}_{}_maxlen_{}'.format(vocab_size, hj_method,
kr_method, max_len)
save_list = sorted(glob.glob(f'./save/{save_path}/*.*'))
save_pt = save_list[-1]
print('Will load {} pt file...'.format(save_pt))
word2vec_hj = Word2Vec.load('./w2v/word2vec_hj_{}_{}.model'.format(
vocab_size, hj_method))
# SentencePiece model load
spm_kr = spm.SentencePieceProcessor()
spm_kr.Load("./spm/m_korean_{}.model".format(vocab_size))
# Test data load
with open('./test_dat.pkl', 'rb') as f:
test_dat = pickle.load(f)
test_dataset = CustomDataset(test_dat['test_hanja'],
test_dat['test_korean'])
test_loader = getDataLoader(test_dataset,
pad_index=padding_index,
shuffle=False,
batch_size=batch_size)
# Model load
print('Model loading...')
encoder = Encoder(vocab_size,
embed_size,
hidden_size,
word2vec_hj,
n_layers=n_layers,
padding_index=padding_index)
decoder = Decoder(embed_size,
hidden_size,
vocab_size,
n_layers=n_layers,
padding_index=padding_index)
seq2seq = Seq2Seq(encoder, decoder, beam_size).cuda()
#optimizer = optim.Adam(seq2seq.parameters(), lr=lr, weight_decay=w_decay)
#scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=scheduler_step_size, gamma=lr_decay)
print(seq2seq)
print('Testing...')
start_time = time.time()
results = test(seq2seq,
test_loader,
vocab_size,
load_pt=save_pt,
stop_ix=stop_ix)
print(time.time() - start_time)
print('Done!')
print("Decoding...")
pred_list = list()
for result_text in tqdm(results):
text = torch.Tensor(result_text).squeeze().tolist()
text = [int(x) for x in text]
prediction_sentence = spm_kr.decode_ids(
text).strip() # Decode with strip
pred_list.append(prediction_sentence)
ref_list = list()
for ref_text in tqdm(test_dat['test_korean'][:stop_ix]):
ref_list.append(spm_kr.decode_ids(ref_text).strip())
print('Done!')
with open(f'./save/{save_path}/test_result.pkl', 'wb') as f:
pickle.dump({
'pred': pred_list,
'reference': ref_list,
}, f)
print('Save file; /test_dat.pkl')
# Calculate BLEU Score
print('Calculate BLEU4, METEOR, Rogue-L...')
chencherry = SmoothingFunction()
bleu4 = corpus_bleu(test_dat['reference'],
test_dat['pred'],
smoothing_function=chencherry.method4)
print('BLEU Score is {}'.format(bleu4))
# Calculate METEOR Score
meteor = meteor_score(test_dat['reference'], test_dat['pred'])
print('METEOR Score is {}'.format(meteor))
# Calculate Rouge-L Score
r = Rouge()
total_test_length = len(test_dat['reference'])
precision_all = 0
recall_all = 0
f_score_all = 0
for i in range(total_test_length):
[precision, recall, f_score] = r.rouge_l([test_dat['reference'][i]],
[test_dat['pred'][i]])
precision_all += precision
recall_all += recall
f_score_all += f_score
print('Precision : {}'.foramt(round(precision_all / total_test_length, 4)))
print('Recall : {}'.foramt(round(recall_all / total_test_length, 4)))
print('F Score : {}'.foramt(round(f_score_all / total_test_length, 4)))
time_elapsed = time.time() - start_time
logger.info('Training complete in {:.0f}m {:.0f}s'.format(
time_elapsed // 60, time_elapsed % 60))
# Save final model weights
utils.save_network(model, save_dir_path, 'final')
# For debugging
# inputs, classes = next(iter(dataloaders['train']))
# ---------------------- Training settings ----------------------
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
train_dataloader = utils.getDataLoader(arg.dataset,
arg.batch_size,
'train',
shuffle=True,
augment=True)
model = PCBModel(num_classes=len(train_dataloader.dataset.classes),
num_stripes=arg.stripes,
share_conv=arg.share_conv,
return_features=False)
criterion = nn.CrossEntropyLoss()
# Finetune the net
optimizer = optim.SGD([{
'params': model.backbone.parameters(),
'lr': arg.learning_rate / 10
}, {
'params':
def main():
print(args)
N_EPOCHS = args.n_epochs
N_TRAIN = args.n_train
N_VALID = args.n_valid
BATCH_SIZE = args.batch_size
EMB_DIM = args.emb_dim
HID_DIM = args.hid_dim
MAXOUT_DIM = args.maxout_dim
data_dir = 'sumdata/'
TRAIN_X = 'sumdata/train/train.article.txt'
TRAIN_Y = 'sumdata/train/train.title.txt'
VALID_X = 'sumdata/train/valid.article.filter.txt'
VALID_Y = 'sumdata/train/valid.title.filter.txt'
vocab_file = os.path.join(data_dir, "vocab.json")
if not os.path.exists(vocab_file):
utils.build_vocab([TRAIN_X, TRAIN_Y], vocab_file)
vocab = json.load(open(vocab_file))
trainX = utils.getDataLoader(TRAIN_X,
vocab,
n_data=N_TRAIN,
batch_size=BATCH_SIZE)
trainY = utils.getDataLoader(TRAIN_Y,
vocab,
n_data=N_TRAIN,
batch_size=BATCH_SIZE)
validX = utils.getDataLoader(VALID_X,
vocab,
n_data=N_VALID,
batch_size=BATCH_SIZE)
validY = utils.getDataLoader(VALID_Y,
vocab,
n_data=N_VALID,
batch_size=BATCH_SIZE)
model = Seq2SeqAttention(len(vocab),
EMB_DIM,
HID_DIM,
BATCH_SIZE,
vocab,
device,
max_trg_len=25,
dropout=0.5)
if args.gpu != -1:
model = model.cuda(device)
model_file = args.model_file
if os.path.exists(model_file):
model.load_state_dict(torch.load(model_file))
logging.info('Load model parameters from %s' % model_file)
# print('Load model parameters from %s' % model_file)
optimizer = torch.optim.Adam(model.parameters(), lr=0.0003)
scheduler = torch.optim.lr_scheduler.StepLR(optimizer,
step_size=20000,
gamma=0.3)
train(trainX, trainY, validX, validY, model, optimizer, scheduler,
N_EPOCHS)
