-
Notifications
You must be signed in to change notification settings - Fork 0
/
main.py
185 lines (137 loc) · 6.35 KB
/
main.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
import argparse
import gc
import logging
import os
from tqdm import tqdm
import torch
import torch.nn as nn
from data import load_data
from eval_ppl import *
from eval_prompt_rank import prompt_accuracy
from model import FullModel
from utils import set_all_seeds, sample_sequence
from optimizers import AdamW
from beam_search import *
logger = logging.getLogger()
logger.setLevel(level=logging.ERROR)
########## CMDLINE ARGS ##########
parser = argparse.ArgumentParser('Train Model')
parser.add_argument('-d', '--device', type=int, default=0)
parser.add_argument('-e', '--epochs', type=int, default=100)
parser.add_argument('-lr', '--learning_rate', type=float, default=0.001)
parser.add_argument('-bs', '--batch_size', type=int, default=8)
parser.add_argument('-pl', '--prompt_len', type=int, default=128)
parser.add_argument('-mc', '--max_context', type=int, default=64)
parser.add_argument('-wd', '--weight_decay', type=float, default=0)
parser.add_argument('-nw', '--num_workers', type=int, default=0)
parser.add_argument('-ms', '--max_samples', type=int, default=-1)
parser.add_argument('-dir', '--dataset_dir', type=str, default='../writingPrompts/')
parser.add_argument('-gc', '--gpt2_config', type=str, default='gpt2')
args = parser.parse_args()
device = torch.device('cuda:%d' % args.device if torch.cuda.is_available() else 'cpu')
set_all_seeds(123)
########## Parameters ##########
DATASET_DIR = args.dataset_dir
EPOCHS = args.epochs
PROMPT_LEN = args.prompt_len
MAX_CONTEXT = args.max_context
NUM_WORKERS = args.num_workers
MAX_SAMPLES = args.max_samples if args.max_samples > 0 else None
model_save_path = 'saved_model.pt'
########## Hyperparameters ##########
GPT2_CONFIG = args.gpt2_config
LEARNING_RATE = args.learning_rate
BATCH_SIZE = args.batch_size
WEIGHT_DECAY = args.weight_decay
train_dataset, val_dataset, test_dataset = load_data(DATASET_DIR, True, MAX_SAMPLES)
_, val_dataset_raw, test_dataset_raw = load_data(DATASET_DIR, False, MAX_SAMPLES)
train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=BATCH_SIZE, shuffle=True, num_workers=NUM_WORKERS)
print('Creating Model...')
model = FullModel(gpt2_config=GPT2_CONFIG).to(device)
all_params = [p for p in model.parameters() if p.requires_grad]
optimizer = AdamW(all_params, lr=LEARNING_RATE, weight_decay=WEIGHT_DECAY)
scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=1, gamma=0.9)
start_epoch = 0
best_val_ppl = float('inf')
if os.path.exists(model_save_path):
print('Restoring trained model from %s' % model_save_path)
checkpoint = torch.load(model_save_path)
model.load_state_dict(checkpoint['model'], strict=False)
#scheduler.load_state_dict(checkpoint['scheduler'])
#optimizer.load_state_dict(checkpoint['optimizer'])
#start_epoch = checkpoint['epoch']+1
#best_val_ppl = checkpoint['val_ppl']
del checkpoint
gc.collect()
########## for debugging ##########
a, b = prompt_accuracy(model, val_dataset, PROMPT_LEN, MAX_CONTEXT, device, BATCH_SIZE)
print(a, b)
bpe_ppl = evaluate_ppl(model, val_dataset, val_dataset_raw, PROMPT_LEN, MAX_CONTEXT, device, BATCH_SIZE)
########## for debugging ##########
print('Training Model for %d epochs...' % EPOCHS)
ce_loss_fn = nn.CrossEntropyLoss(reduction='none')
model.train()
for ep in range(start_epoch, start_epoch + EPOCHS):
# print("Epoch", ep, "start")
# prompt = ["Reddit buys the moon"]
# prompt = model.process_prompt(prompt, prompt_len=PROMPT_LEN).to(device)
# encoded_prompt, _ = model.encoder(prompt, token_type_ids=None, attention_mask=prompt > 0)
# out, logprobs = sample_sequence(model.decoder, 100, encoder_hidden=encoded_prompt, batch_size=BATCH_SIZE, context=[model.decoder_tokenizer.encoder['<|endoftext|>']], eos_token=model.decoder_tokenizer.encoder['<|endoftext|>'],
# sample=True, top_p=0.95, device=device)
# for i in out:
# print(model.decoder_tokenizer.decode(i))
# print()
"""
#beam search
prompt = "trump government"
prompt_ids = torch.tensor(model.encoder_tokenizer.encode(prompt)).unsqueeze(0)
beam_search_story = model.decoder.generate(prompt_ids,
max_length = 100,
num_beams = 5,
num_return_sequences = 1,
no_repeat_ngram_size = 2,
early_stopping = True)
# print(out)
# s = beam_search_decoder(out, 3)
# print(s)
# print(out.shape) #([batch_size, length])
# print(logprobs.shape) #([batch_size])
for i in beam_search_story:
print(model.decoder_tokenizer.decode(i, skip_special_tokens=True))
print()
input()
"""
# beam search with model params passed correctly
# print("Epoch", ep, "start")
# prompt = ["trump government"]
# prompt = model.process_prompt(prompt, prompt_len=PROMPT_LEN).to(device)
# encoded_prompt, _ = model.encoder(prompt, token_type_ids=None, attention_mask=prompt > 0)
# out = beam_decode(model.decoder, BATCH_SIZE, None, device, encoded_prompt, context=[model.decoder_tokenizer.encoder['<|endoftext|>']])
# for i in out:
# print(model.decoder_tokenizer.decode(i))
epoch_loss = 0
for prompt, story in tqdm(train_loader):
optimizer.zero_grad()
prompt = model.process_prompt(prompt, prompt_len=PROMPT_LEN).to(device)
story, story_target, story_mask = model.process_story(story, max_context=MAX_CONTEXT)
story = story.to(device)
story_target = story_target.to(device)
story_mask = story_mask.to(device)
logits = model(story, prompt)
num_logits = logits.size(-1)
ce_loss = ce_loss_fn(logits.view(-1, num_logits), story_target.view(-1)).mean()
epoch_loss += ce_loss.item()
ce_loss.backward()
nn.utils.clip_grad_norm_(model.parameters(), 0.01)
optimizer.step()
del story, story_target, story_mask, prompt
gc.collect()
scheduler.step()
val_word_ppl, bpe_ppl, token_diffs = evaluate_ppl(model, val_dataset, val_dataset_raw, PROMPT_LEN, MAX_CONTEXT, device, BATCH_SIZE)
model.train()
if val_word_ppl < best_val_ppl:
best_val_ppl = val_word_ppl
checkpoint = {'model': model.state_dict(), 'optimizer' : optimizer.state_dict(), 'scheduler': scheduler.state_dict(),
'epoch': ep, 'val_ppl': val_word_ppl}
torch.save(checkpoint, model_save_path)
print('EPOCH: %3d/%d\t Loss: %.4f' % (ep, EPOCHS, epoch_loss/len(train_loader)))