train_files = [str(x) for x in train_files]
valid_files = [str(x) for x in valid_files]
valid_data = Dataset(valid_files, args.node_weights)
valid_data = torch.utils.data.DataLoader(valid_data,
batch_size=valid_batch_size,
shuffle=False,
num_workers=num_workers,
collate_fn=load_batch)
### MODEL LOADING ###
sys.path.insert(0, os.path.abspath(f'models/mlp'))
import model
importlib.reload(model)
model = model.Policy()
del sys.path[0]
model.to(device)
### TRAINING LOOP ###
optimizer = torch.optim.Adam(model.parameters(), lr=lr)
scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer,
mode='min',
factor=0.2,
patience=patience,
verbose=True)
best_loss, best_acc = np.inf, -1
for epoch in range(max_epochs + 1):
log(f"EPOCH {epoch}...", logfile)
num_workers=num_workers,
collate_fn=load_batch)
pretrain_files = [f for i, f in enumerate(train_files) if i % 10 == 0]
pretrain_data = Dataset(pretrain_files, args.data_path)
pretrain_data = torch.utils.data.DataLoader(pretrain_data,
batch_size=pretrain_batch_size,
shuffle=False,
num_workers=num_workers,
collate_fn=load_batch)
### MODEL LOADING ###
sys.path.insert(0, os.path.abspath(f'models/{args.model}'))
import model
importlib.reload(model)
distilled_model = model.Policy()
del sys.path[0]
distilled_model.to(device)
### TEACHER MODEL LOADING ###
teacher = None
if (args.distilled or args.no_e2e):
sys.path.insert(0, os.path.abspath(f'models/{teacher_model}'))
import model
importlib.reload(model)
teacher = model.GCNPolicy()
del sys.path[0]
teacher.restore_state(
f"trained_models/{args.problem}/{teacher_model}/{args.seed}/best_params.pkl"
)
teacher.to(device)
for model_type, model_path in evaluated_policies:
print(f"{model_type}:{model_path.name}...")
for seed in seeds:
rng = np.random.RandomState(seed)
policy = {}
policy['name'] = model_path.name
policy['type'] = model_type
# load model
best_params = str(model_path / f"{seed}/best_params.pkl")
sys.path.insert(0, os.path.abspath(f"models/mlp"))
import model
importlib.reload(model)
del sys.path[0]
policy['model'] = model.Policy()
policy['model'].restore_state(best_params)
policy['model'].to(device)
test_kacc = process(policy['model'], test_data, top_k)
print(f" {seed} " + " ".join([
f"acc@{k}: {100*acc:4.1f}"
for k, acc in zip(top_k, test_kacc)
]))
writer.writerow({
**{
'problem': args.problem,
'policy': f"{policy['type']}:{policy['name']}",
'seed': seed,
},
# Load vocabulary
input_w2i = json.load(open('data/input_lang.word2index.json'))
output_w2i = json.load(open('data/output_lang.word2index.json'))
input_i2w = json.load(open('data/input_lang.index2word.json'))
output_i2w = json.load(open('data/output_lang.index2word.json'))
dial_act_dict, dial_acts_data = get_dial_acts('data/dialogue_act_feats.json')
# Create models
encoder = model.Encoder(vocab_size=len(input_w2i),
emb_size=args.emb_size,
hid_size=args.hid_size)
policy = model.Policy(hidden_size=args.hid_size,
db_size=args.db_size,
bs_size=args.bs_size,
da_size=args.da_size)
decoder = model.Decoder(emb_size=args.emb_size,
hid_size=args.hid_size,
vocab_size=len(output_w2i),
use_attn=args.use_attn)
if args.shallow_fusion or args.deep_fusion:
s2s = model.Model(encoder=encoder,
policy=policy,
decoder=decoder,
input_w2i=input_w2i,
output_w2i=output_w2i,
args=args)
lm_decoder = model.Decoder(emb_size=args.emb_size,
### NUMPY / TORCH SETUP ###
if args.gpu == -1:
os.environ['CUDA_VISIBLE_DEVICES'] = ''
device = torch.device("cpu")
else:
os.environ['CUDA_VISIBLE_DEVICES'] = f'{args.gpu}'
device = torch.device(f"cuda" if torch.cuda.is_available() else "cpu")
# load and assign tensorflow models to policies (share models and update parameters)
loaded_models = {}
for policy in branching_policies:
if policy['type'] not in loaded_models:
sys.path.insert(0, os.path.abspath(f"models/{policy['type']}"))
import model
importlib.reload(model)
loaded_models[policy['type']] = model.Policy()
del sys.path[0]
loaded_models[policy['type']].to(device)
loaded_models[policy['type']].eval()
policy['model'] = loaded_models[policy['type']]
print("running SCIP...")
fieldnames = [
'problem',
'device',
'policy',
'seed',
'type',
'instance',
'nnodes',
