def load_model_baseline(lr: float, num_classes: int):
"""Load baseline model"""
model_baseline = models.Baseline(num_classes)
loss_func = torch.nn.MSELoss()
optimizer = torch.optim.SGD(model_baseline.parameters(), lr)
return model_baseline, loss_func, optimizer
def main():
model = None
if config.model == 'Baseline':
model = models.Baseline()
if config.train:
# Can train with existing weights (if config.restart = True, will use most recent by default)
weights_path = None
if not config.restart:
weights_path = os.path.join(
config.model_save_dir,
get_recent_weights_path(config.model_save_dir))
model.build(weights_path)
# train(model)
simple_train(model)
if config.save_model:
save_model(model,
config.model_save_path,
config.model_weights_save_path,
ext=".h5")
else:
# If we only care about predicting!
# Make sure there are trained weights (most recent will be used by default)
weights_path = os.path.join(
config.model_save_dir,
get_recent_weights_path(config.model_save_dir))
model.build(weights_path)
# pred(model)
simple_pred(model)
def baselines_predict(gold_test,
ids_test,
data_dir=DATA_DIR,
results_dir=RESULTS_DIR):
with open(os.path.join(data_dir, "mlb.pkl"), "rb") as rf:
mlb = pkl.load(rf)
for lang in ("en", "de"):
model_name = "baseline-" + lang
print("______________________________________")
print(" {} ".format(model_name))
print("______________________________________")
bsm = models.Baseline(os.path.join(data_dir, "train_data.pkl"),
os.path.join(data_dir, "dev_data.pkl"),
use_data=lang)
bsm.train()
test_data = load_pkl_datafile(os.path.join(data_dir, "test_data.pkl"),
use_data=lang,
as_sents=False)
test_docs = [d[0] for d in test_data]
Xtest = bsm.vectorizer.transform(test_docs)
tmp1 = []
tmp2 = []
for idx in range(Xtest.shape[0]):
tmp1.append(idx)
tmp2.append(test_data[idx][-1])
Xtest = Xtest[tmp1]
ypred = bsm.predict(Xtest)
id2preds = {i: j for i, j in zip(tmp2, ypred)}
id2preds = {
k: mlb.classes_[v.astype(bool)].tolist()
for k, v in id2preds.items()
}
# "Original" evaluation
test_preds_official = {
k: id2preds[k] if k in id2preds else []
for k in ids_test
}
preds_file = os.path.join(results_dir, model_name + "_preds_test.txt")
generate_preds(preds_file, test_preds_official)
out_file = os.path.join(results_dir,
model_name + "_preds_test_eval.txt")
results = challenge_eval("test", preds_file, out_file, data_dir)
print("***** Test results (Original) *****")
print(results)
# "Modified" evaluation
test_preds_fixed = {
k: id2preds[k] if k in id2preds else []
for k in set(id2preds.keys()).intersection(set(gold_test.keys()))
}
preds_file = os.path.join(results_dir,
model_name + "_preds_test_fixed.txt")
generate_preds(preds_file, test_preds_fixed)
out_file = os.path.join(results_dir,
model_name + "_preds_test_fixed_eval.txt")
results = challenge_eval("test", preds_file, out_file, data_dir)
print("***** Test results (Modified) *****")
print(results)
def main():
model = None
if config.model == 'Baseline':
model = models.Baseline()
if config.model == 'SuperBaseline':
model = super_baseline.SuperBaseline()
if config.train:
model.build_graph()
train(model)
else: #If we only care about predicting!
model.build_graph()
pred(model)
def __init__(self, hparams):
self.model = models.Baseline(hparams)
self.criterion = torch.nn.CrossEntropyLoss()
self.optimizer = torch.optim.SGD(self.model.parameters(), lr=hparams.learning_rate, momentum=hparams.momentum)
self.scheduler = ReduceLROnPlateau(self.optimizer, mode='min', factor=hparams.factor, patience=hparams.patience, verbose=True)
self.learning_rate = hparams.learning_rate
self.stopping_rate = hparams.stopping_rate
self.device = torch.device("cpu")
if hparams.device > 0:
torch.cuda.set_device(hparams.device - 1)
self.model.cuda(hparams.device - 1)
self.criterion.cuda(hparams.device - 1)
self.device = torch.device("cuda:" + str(hparams.device - 1))
def main(args):
######
# 3.2 Processing of the data
TEXT = data.Field(sequential=True, include_lengths=True, tokenize='spacy')
LABEL = data.Field(sequential=False, use_vocab=False)
train, val, test = data.TabularDataset.splits(
path=
"/Users/RobertAdragna/Documents/Third Year/Fall Term/MIE 324 - Introduction to Machine Intelligence/mie324/a4",
train='train.tsv',
validation='validation.tsv',
test='test.tsv',
format='tsv',
skip_header=True,
fields=[('text', TEXT), ('label', LABEL)])
# train_itr = data.BucketIterator(train, 64, sort_key=lambda x: len(x.TEXT), sort_within_batch=True, repeat=False)
# val_itr = data.BucketIterator(val, 64, sort_key=lambda x: len(x.TEXT), sort_within_batch=True, repeat=False)
# test_itr = data.BucketIterator(test, 64, sort_key=lambda x: len(x.TEXT), sort_within_batch=True, repeat=False)
######
train_iter, val_iter, test_iter = data.Iterator.splits(
(train, val, test),
sort_key=lambda x: len(x.text),
sort_within_batch=True,
repeat=False,
batch_sizes=(64, 64, 64),
device=-1)
# train_iter, val_iter, test_iter = data.BucketIterator.splits(
# (train, val, test), sort_key=lambda x: len(x.text), sort_within_batch=True, repeat=False,
# batch_sizes=(64, 64, 64), device=-1)
TEXT.build_vocab(train)
vocab = TEXT.vocab
vocab.load_vectors(torchtext.vocab.GloVe(name='6B', dim=100))
######
# 5 Training and Evaluation
base_model = models.Baseline(100, vocab)
rnn_model = models.RNN(100, vocab, 100)
cnn_model = models.CNN(100, vocab, 50, (2, 4))
train_func(rnn_model, train_iter, val_iter, test_iter, 20, "rnn")
def __init__(self, hparams):
# __init__에 model 을 올려줍시다
self.model = models.Baseline(hparams)
# Loss function은 CrossEntropyLoss()를 호출해줍시다.
self.criterion = torch.nn.CrossEntropyLoss()
# Stocastic Gradient Descent입니다
self.optimizer = torch.optim.SGD(self.model.parameters(), lr=hparams.learning_rate)
# Learning_rate도 저장해줍시다
self.learning_rate = hparams.learning_rate
# 기본 디바이스는 이번에는 cpu!
self.device = torch.device("cpu")
# 혹시라도 GPU를 가지고 계신분들을 위해서
if hparams.device > 0:
torch.cuda.set_device(hparams.device - 1)
# model.cuda
self.model.cuda(hparams.device - 1)
# criterion.cuda
self.criterion.cuda(hparams.device - 1)
# device.cuda를 지정해줍시다
self.device = torch.device("cuda:" + str(hparams.device - 1))
def main():
model = None
if config.model == 'Baseline':
model = models.Baseline()
elif config.model == "Muzip":
model = models.Muzip()
elif config.model == "Muzip2":
model = models.Muzip2()
elif config.model == "Muzip3":
model = models.Muzip3()
else:
model = models.Muzip3()
if config.train:
# Can train with existing weights (if config.restart = True, will use most recent by default)
weights_path = None
if not config.restart:
weights_path = os.path.join(
config.model_save_dir,
get_recent_weights_path(config.model_save_dir))
model.build(weights_path)
train(model)
#simple_train(model)
if config.save_model:
save_model(model,
config.model_save_path,
config.model_weights_save_path,
ext=".h5")
if config.pred:
# If we only care about predicting!
# Make sure there are trained weights (most recent will be used by default)
weights_path = config.model_save_dir + '/' + get_recent_weights_path(
config.model_save_dir)
model.build(weights_path)
# pred(model)
pred(model)
if config.evaluate:
weights_path = config.model_save_dir + '/' + get_recent_weights_path(
config.model_save_dir)
model.build(weights_path)
evaluate_model(model, "test/")
def main():
global args, best_error, n_iter
n_iter = 0
best_error = 0
args = parser.parse_args()
'''
args = ['--name', 'deemo', '--FCCMnet', 'PatchWiseNetwork',
'--dataset_dir', '/notebooks/FCCM/pre-process/pre-process', '--label_dir', '/notebooks/FCCM',
'--batch-size', '4', '--epochs','100', '--lr', '1e-4' ]
'''
save_path = Path(args.name)
args.save_path = 'checkpoints'/save_path
print('=> will save everything to {}'.format(args.save_path))
args.save_path.makedirs_p()
train_writer = SummaryWriter(args.save_path)
torch.manual_seed(args.seed)
train_transform = custom_transforms.Compose([
custom_transforms.RandomRotate(),
custom_transforms.RandomHorizontalFlip(),
custom_transforms.RandomScaleCrop(),
custom_transforms.ArrayToTensor() ])
train_set = Generate_train_set(
root = args.dataset_dir,
label_root = args.label_dir,
transform=train_transform,
seed=args.seed,
train=True
)
val_set = Generate_val_set(
root = args.dataset_dir,
label_root = args.label_dir,
seed=args.seed
)
print('{} samples found in {} train scenes'.format(len(train_set), len(train_set.scenes)))
print('{} samples found in {} val scenes'.format(len(val_set), len(val_set.scenes)))
train_loader = torch.utils.data.DataLoader(
train_set, batch_size=args.batch_size, shuffle=True,
num_workers=args.workers, pin_memory=True, drop_last=True)
val_loader = torch.utils.data.DataLoader(
val_set, batch_size=args.batch_size, shuffle=True,
num_workers=args.workers, pin_memory=True, drop_last=True)
print("=> creating model")
if args.FCCMnet == 'VGG':
FCCM_net = models_inpytorch.vgg16(num_classes=19)
FCCM_net.features[0]=nn.Conv2d(1, 64, kernel_size=3, padding=1)
if args.FCCMnet == 'ResNet':
FCCM_net = models.resnet18(num_classes=19)
if args.FCCMnet == 'CatNet':
FCCM_net = models.catnet18(num_classes=19)
if args.FCCMnet == 'CatNet_FCCM':
FCCM_net = models.catnet1(num_classes=19)
if args.FCCMnet == 'ResNet_FCCM':
FCCM_net = models.resnet1(num_classes=19)
if args.FCCMnet == 'ImageWise':
FCCM_net = models.ImageWiseNetwork()
if args.FCCMnet == 'PatchWise':
FCCM_net = models.PatchWiseNetwork()
if args.FCCMnet == 'Baseline':
FCCM_net = models.Baseline()
FCCM_net = FCCM_net.cuda()
if args.pretrained_model:
print("=> using pre-trained weights for net")
weights = torch.load(args.pretrained_model)
FCCM_net.load_state_dict(weights['state_dict'])
cudnn.benchmark = True
FCCM_net = torch.nn.DataParallel(FCCM_net)
print('=> setting adam solver')
parameters = chain(FCCM_net.parameters())
optimizer = torch.optim.Adam(parameters, args.lr,
betas=(args.momentum, args.beta),
weight_decay=args.weight_decay)
is_best = False
best_error = float("inf")
FCCM_net.train()
loss = 0
for epoch in tqdm(range(args.epochs)):
is_best = loss <= best_error
best_error = min(best_error, loss)
save_checkpoint(
args.save_path, {
'epoch': epoch + 1,
'state_dict': FCCM_net.state_dict()
}, {
'epoch': epoch + 1,
'state_dict': optimizer.state_dict()
}, is_best)
validation(val_loader, FCCM_net, epoch, train_writer)
loss = train(train_loader, FCCM_net, optimizer, args.epoch_size, train_writer)
nf=args.nf,
device=device,
n_layers=args.n_layers,
reg=args.reg,
act_fn=nn.SiLU(),
clamp=args.clamp)
elif args.model == 'ae_egnn':
model = models.AE_EGNN(hidden_nf=args.nf,
K=args.K,
act_fn=nn.SiLU(),
device=device,
n_layers=args.n_layers,
reg=args.reg,
clamp=args.clamp)
elif args.model == 'baseline':
model = models.Baseline(device=device)
else:
raise Exception('Wrong model %s' % args.model)
print(model)
optimizer = optim.Adam(model.parameters(),
lr=args.lr,
weight_decay=args.weight_decay)
lr_scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(
optimizer, args.epochs)
pr = eval.ProgressReporter(path=args.outf + '/' + args.exp_name,
file_name='/output.json')
vocab = datatools.init_vocab()
X, Y = datatools.load_train_data_char(vocab)
Xd, Yd = datatools.load_dev_data_char(vocab)
Xt = datatools.load_test_data()
data, labels = X, Y
#data, labels = X[:200], Y[:200]
print(len(vocab))
def save_path(x):
return "../net" + str(x) + ".pt"
def sub_path(x):
return "../sub" + str(x) + ".csv"
net = models.Baseline(nLabels=len(vocab))
net = routine.load_net("../net0.pt").cuda()
net.max_sentence = 275
net.train()
routine.training(net, data, labels, Xd, Yd, 20, 16, 0.00001, vocab)
print("Writing submission")
net.eval()
routine.write_sub(net, Xt, sub_path(""), vocab, random=True, random_number=100)