def experiments(train_loader, test_loader, norm_type, l1_factor, l2_factor,
dropout, epochs):
train_losses = []
test_losses = []
train_accuracy = []
test_accuracy = []
use_cuda = torch.cuda.is_available()
device = torch.device("cuda" if use_cuda else "cpu")
model = m.Net(norm_type, dropout).to(device)
optimizer = optim.SGD(model.parameters(),
lr=0.015,
momentum=0.7,
weight_decay=l2_factor)
scheduler = OneCycleLR(optimizer,
max_lr=0.015,
epochs=epochs,
steps_per_epoch=len(train_loader))
epochs = epochs
for epoch in range(1, epochs + 1):
print(f'Epoch {epoch}:')
trn.train(model, device, train_loader, optimizer, epoch,
train_accuracy, train_losses, l1_factor, scheduler)
tst.test(model, device, test_loader, test_accuracy, test_losses)
return (train_accuracy, train_losses, test_accuracy, test_losses), model
def main(opt):
train_dataset = bAbIDataset(opt.dataroot, opt.question_id, True)
train_dataloader = bAbIDataloader(train_dataset,
batch_size=opt.batchSize,
shuffle=True,
num_workers=2)
test_dataset = bAbIDataset(opt.dataroot, opt.question_id, False)
test_dataloader = bAbIDataloader(test_dataset,
batch_size=opt.batchSize,
shuffle=False,
num_workers=2)
opt.annotation_dim = 1 # for bAbI
opt.n_edge_types = train_dataset.n_edge_types
opt.n_node = train_dataset.n_node
net = GGNN(opt)
print(net)
criterion = nn.CrossEntropyLoss()
if opt.cuda:
net.cuda()
criterion.cuda()
optimizer = optim.Adam(net.parameters(), lr=opt.lr)
for epoch in range(0, opt.niter):
train(epoch, train_dataloader, net, criterion, optimizer, opt)
test(test_dataloader, net, criterion, optimizer, opt)
def main():
exp_path = CHK_DIR + FLAGS.name
build_dir_tree(exp_path)
if FLAGS.train:
print 'Starting training...'
train()
else:
print 'Starting testing...'
test()
def create_app(train_data, my_collection):
#read data, train model and save model once at start
my_collection.insert_many(train_data)
data = readMongo()
df = pd.DataFrame.from_records(data)
checkedData = checkColumns(df)
train(checkedData, encode_cabin, extract_cabin_number ,encode_title, './models')
app = Flask(__name__)
'''heroku specifies a port to run app on as an environemental variable port
when running local thei svariable wont be availabel and so th eapp will
run on port 5000'''
port = int(os.environ.get('PORT', 5000))
@app.route('/')
def index():
return('flask homepage')
# set up API POST endpoint
@app.route('/train', methods=['POST'])
def train_endpoint():
content = request.json
writeToMongo(content)
data = readMongo()
df = pd.DataFrame.from_records(data)
checkedData = checkColumns(df)
train(checkedData, encode_cabin, extract_cabin_number ,encode_title, './models')
flask_train_data = 'flask train data'
return('return from flask train API')
@app.route('/predict', methods = ['POST'])
def predict_endpoint():
passenger = request.json
passenger_df = pd.DataFrame(passenger, index = [0])
checkedData = ensure_correct_order(passenger_df)
checked_df = checkColumns(checkedData)
prediction = predict(checked_df, encode_cabin, extract_cabin_number, encode_title, 'models/model.joblib')
return("{{ 'prediction': {0} }}".format(prediction))
# Bind to PORT if defined, otherwise default to 5000.
app.run(host = '0.0.0.0', port = port, debug = True)
def main(opt):
train_dataset = ABoxDataset(opt.dataroot, True)
train_dataloader = ABoxDataloader(train_dataset, batch_size=opt.batchSize, \
shuffle=True, num_workers=opt.workers)
opt.annotation_dim = train_dataset.annotation_dim
# An example of accessing A using dataloader and dataset
# Very important
# for idx, (annotation, A, target, data_idx) in enumerate(train_dataloader):
# print('index', data_idx)
# A = [train_dataset.all_data[1][i] for i in data_idx]
# print(A)
# print(target)
test_dataset = ABoxDataset(opt.dataroot, False)
test_dataloader = ABoxDataloader(test_dataset, batch_size=opt.batchSize, \
shuffle=False, num_workers=opt.workers)
opt.n_edge_types = train_dataset.n_edge_types
opt.n_node = train_dataset.n_node
net = GGNN(train_dataset.n_node, train_dataset.n_edge_types*2, opt) # times 2 because it's directed
net.double()
# print(net)
criterion = nn.BCELoss()
# print(opt.cuda)
# print(opt.niter)
if opt.cuda:
net.cuda()
criterion.cuda()
optimizer = optim.Adam(net.parameters(), lr=opt.lr)
best_acc = 0.0 # best accuracy has been achieved
num_of_dec = 0 # number of epochs have a decline of accuracy, used for early stop
acc_last_iter = 0.0 # accuracy of the last iteration
for epoch in range(0, opt.niter):
if num_of_dec >= 15:
print("Early stop! The accuracy has been dropped for 15 iterations!")
break
train(epoch, train_dataloader, train_dataset, net, criterion, optimizer, opt)
correct = test(test_dataloader, test_dataset, net, criterion, opt)
acc = float(correct) / float(len(test_dataset))
if acc > best_acc:
best_acc = acc
print("Best accuracy by far: ", best_acc)
torch.save(net, './' + fileName + str(opt.n_steps) + '_model.pth')
if acc >= best_acc:
num_of_dec = 0
else:
num_of_dec += 1
print("The best accuracy achieved by far: ", best_acc)
def train_endpoint():
content = request.json
writeToMongo(content)
data = readMongo()
df = pd.DataFrame.from_records(data)
checkedData = checkColumns(df)
train(checkedData, encode_cabin, extract_cabin_number ,encode_title, './models')
flask_train_data = 'flask train data'
return('return from flask train API')
def train_models(self,
max_epochs=200,
hold_discr=True,
threshold=0.5,
intermediate_results=None):
if self.shift:
return shift_train(self.generator_a2b,
self.generator_b2a,
self.discriminator_a,
self.discriminator_b,
self.gen_optimizer,
self.discr_optimizer,
self.gen_sched,
self.discr_sched,
self.criterion,
self.dataloader1,
self.dataloader2,
max_epochs,
hold_discr,
threshold,
intermediate_results=intermediate_results)
else:
return train(self.generator_a2b, self.generator_b2a,
self.discriminator_a, self.discriminator_b,
self.gen_optimizer, self.discr_optimizer,
self.gen_sched, self.discr_sched, self.criterion,
self.dataloader, max_epochs, hold_discr, threshold,
intermediate_results)
def retrain(session):
'''
Retrains a model using validated samples and original training data if retrain_check() evaluates
to True.
'''
retrain = retrain_check(session)
if retrain:
logger.info("Smartie is retraining a model!")
attachments = fetch_validated_attachments(session)
X, y = train.prepare_samples(attachments)
results, score, best_estimator, params = train.train(
X,
y,
weight_classes=True,
n_iter_search=150,
score='roc_auc',
random_state=123)
logger.info("Smartie is done retraining a model!")
last_score = fetch_last_score(session)
better_model = True if last_score < score else False
if better_model:
train.pickle_model(best_estimator)
logger.info("Smartie has pickled the new model!")
else:
pass
insert_model(session, results, params, score)
else:
logger.info("Smartie decided not to retrain a new model!")
def main():
transform = transforms.Compose(
[
# transforms.Resize(100),
transforms.ToTensor(),
transforms.Normalize([0.5, 0.5, 0.5], [0.5, 0.5, 0.5]),
]
)
train_img, test_img = image_train_test_split(root='../data/Discuz', p=5/6)
train_imageset = ImageDataset(root='../data/Discuz/', imgs=train_img, transform=transform)
train_img_loader = DataLoader(train_imageset, batch_size=128, shuffle=True, pin_memory=True)
test_imageset = ImageDataset(root='../data/Discuz/', imgs=test_img, transform=transform)
test_img_loader = DataLoader(test_imageset, batch_size=128, shuffle=False, pin_memory=True)
model = CNN_model()
train(model=model, train_loader=train_img_loader, test_loader=test_img_loader, step=128,
epochs=1024, lr=0.001, use_cuda=True)
def training():
print(Config.LABELS_TO_CLASSES)
Config.ENTITY_NAME = "animal"
_, status = train()
return status
def main(opt):
train_dataset = BADataset(opt.dataroot, opt.L, True, False, False)
train_dataloader = BADataloader(train_dataset, batch_size=opt.batchSize, \
shuffle=True, num_workers=opt.workers, drop_last=True)
valid_dataset = BADataset(opt.dataroot, opt.L, False, True, False)
valid_dataloader = BADataloader(valid_dataset, batch_size=opt.batchSize, \
shuffle=True, num_workers=opt.workers, drop_last=True)
test_dataset = BADataset(opt.dataroot, opt.L, False, False, True)
test_dataloader = BADataloader(test_dataset, batch_size=opt.batchSize, \
shuffle=True, num_workers=opt.workers, drop_last=True)
all_dataset = BADataset(opt.dataroot, opt.L, False, False, False)
all_dataloader = BADataloader(all_dataset, batch_size=opt.batchSize, \
shuffle=False, num_workers=opt.workers, drop_last=False)
opt.n_edge_types = train_dataset.n_edge_types
opt.n_node = train_dataset.n_node
net = STGGNN(opt, kernel_size=2, n_blocks=1, state_dim_bottleneck=opt.state_dim, annotation_dim_bottleneck=opt.annotation_dim)
net.double()
print(net)
criterion = nn.BCELoss()
if opt.cuda:
net.cuda()
criterion.cuda()
optimizer = optim.Adam(net.parameters(), lr=opt.lr)
early_stopping = EarlyStopping(patience=opt.patience, verbose=True)
os.makedirs(OutputDir, exist_ok=True)
train_loss_ls = []
valid_loss_ls = []
test_loss_ls = []
#net.load_state_dict(torch.load(OutputDir + '/checkpoint_5083.pt'))
for epoch in range(0, opt.niter):
train_loss = train(epoch, train_dataloader, net, criterion, optimizer, opt)
valid_loss = valid(valid_dataloader, net, criterion, opt)
test_loss = test(test_dataloader, net, criterion, opt)
train_loss_ls.append(train_loss)
valid_loss_ls.append(valid_loss)
test_loss_ls.append(test_loss)
early_stopping(valid_loss, net, OutputDir)
if early_stopping.early_stop:
print("Early stopping")
break
df = pd.DataFrame({'epoch':[i for i in range(1, len(train_loss_ls)+1)], 'train_loss': train_loss_ls, 'valid_loss': valid_loss_ls, 'test_loss': test_loss_ls})
df.to_csv(OutputDir + '/loss.csv', index=False)
net.load_state_dict(torch.load(OutputDir + '/checkpoint.pt'))
inference(all_dataloader, net, criterion, opt, OutputDir)
def train_model(args):
model = CrfTagger(vocab, args).cuda(0)
parameters = [p for _, p in model.named_parameters() if p.requires_grad]
optimizer = torch.optim.Adam(parameters, lr=args["learning_rate"])
metrics, model_paths = train(model, optimizer, train_data, train_iterator,
dev_data, dev_iterator, args)
return model, metrics, model_paths
def train_model(args):
model = CrfTagger(vocab, args).cuda(0)
parameters = [p for _, p in model.named_parameters() if p.requires_grad]
optimizer = torch.optim.Adam(parameters, lr=args["learning_rate"])
metrics, model_paths = train(model, optimizer, train_data, train_iterator,
dev_data, dev_iterator, args)
return model, metrics, model_paths
def main():
global_config = dict(lr=[0.001, 0.0001],
schedule=[np.inf],
batch_size=64,
dev_every=1,
seed=0,
model=None,
use_nesterov=False,
gpu_no=0,
cache_size=32768,
momentum=0.9,
weight_decay=0.00001)
builder = ConfigBuilder(default_config(), global_config)
parser = builder.build_argparse()
# parser.add_argument("--no_cuda", type=str2bool, nargs='?', const=True)
config = builder.config_from_argparse(parser)
if config["model_type"] == "EdgeCRNN":
model = EdgeCRNN(width_mult=config["width_mult"])
model = torch.nn.DataParallel(model)
if config["model_type"] == "shuffleNet":
from nets.ShuffleNetV2 import shufflenetv2
model_shuffle = shufflenetv2(width_mult=config["width_mult"])
model = torch.nn.DataParallel(model_shuffle)
elif config["model_type"] == "mobileNet":
from nets.MobileNetV2 import MobileNetV2
model = MobileNetV2(width_mult=config["width_mult"])
elif config["model_type"] == "mobileNetV3-Small":
from nets.MobileNetV3 import MobileNetV3_Small
model = MobileNetV3_Small()
elif config["model_type"] == "mobileNetV3-Large":
from utils.MobileNetV3 import MobileNetV3_Large
model = MobileNetV3_Large()
elif config["model_type"] == "Tpool2":
from nets.Tpool2 import CNN
model = CNN()
else:
pass
config["model"] = model
set_seed(config)
if config["type"] == "train":
train(config)
elif config["type"] == "eval":
evaluate(config)
def main(opt):
train_dataset = BADataset(opt.dataroot, opt.L, True, False, False)
train_dataloader = BADataloader(train_dataset, batch_size=opt.batchSize, \
shuffle=True, num_workers=opt.workers, drop_last=True)
valid_dataset = BADataset(opt.dataroot, opt.L, False, True, False)
valid_dataloader = BADataloader(valid_dataset, batch_size=opt.batchSize, \
shuffle=True, num_workers=opt.workers, drop_last=True)
test_dataset = BADataset(opt.dataroot, opt.L, False, False, True)
test_dataloader = BADataloader(test_dataset, batch_size=opt.batchSize, \
shuffle=True, num_workers=opt.workers, drop_last=True)
all_dataset = BADataset(opt.dataroot, opt.L, False, False, False)
all_dataloader = BADataloader(all_dataset, batch_size=opt.batchSize, \
shuffle=False, num_workers=opt.workers, drop_last=False)
opt.n_edge_types = train_dataset.n_edge_types
opt.n_node = train_dataset.n_node
net = EGCN(gcn_args, activation = torch.nn.RReLU(), device = opt.device)
print(net)
criterion = nn.MSELoss()
#criterion = nn.CosineSimilarity(dim=-1, eps=1e-6)
if opt.cuda:
net.cuda()
criterion.cuda()
optimizer = optim.Adam(net.parameters(), lr=opt.lr)
early_stopping = EarlyStopping(patience=opt.patience, verbose=True)
os.makedirs(OutputDir, exist_ok=True)
train_loss_ls = []
valid_loss_ls = []
test_loss_ls = []
for epoch in range(0, opt.niter):
train_loss = train(epoch, train_dataloader, net, criterion, optimizer, opt)
valid_loss = valid(valid_dataloader, net, criterion, opt)
test_loss = test(test_dataloader, net, criterion, opt)
train_loss_ls.append(train_loss)
valid_loss_ls.append(valid_loss)
test_loss_ls.append(test_loss)
early_stopping(valid_loss, net, OutputDir)
if early_stopping.early_stop:
print("Early stopping")
break
df = pd.DataFrame({'epoch':[i for i in range(1, len(train_loss_ls)+1)], 'train_loss': train_loss_ls, 'valid_loss': valid_loss_ls, 'test_loss': test_loss_ls})
df.to_csv(OutputDir + '/loss.csv', index=False)
#net.load_state_dict(torch.load(OutputDir + '/checkpoint.pt'))
net = torch.load(OutputDir + '/checkpoint.pt')
inference(all_dataloader, net, criterion, opt, OutputDir)
def run_experiment(self):
dropout = self.config['model_params']['dropout']
epochs = self.config['training_params']['epochs']
l2_factor = self.config['training_params']['l2_factor']
l1_factor = self.config['training_params']['l1_factor']
criterion = nn.CrossEntropyLoss(
) if self.config['criterion'] == 'CrossEntropyLoss' else F.nll_loss()
opt_func = optim.Adam if self.config['optimizer'][
'type'] == 'optim.Adam' else optim.SGD
lr = self.config['optimizer']['args']['lr']
grad_clip = 0.1
train_losses = []
test_losses = []
train_accuracy = []
test_accuracy = []
lrs = []
#device = self.set_device()
model = m.Net(dropout).to(self.device)
# optimizer = optim.SGD(model.parameters(), lr=0.02, momentum=0.7,weight_decay=l2_factor)
optimizer = opt_func(model.parameters(), lr=lr, weight_decay=l2_factor)
#scheduler = optim.lr_scheduler.ReduceLROnPlateau(optimizer, patience=3, verbose=True,mode='max')
scheduler = OneCycleLR(optimizer,
max_lr=lr,
epochs=epochs,
steps_per_epoch=len(self.dataset.train_loader))
for epoch in range(1, epochs + 1):
print(f'Epoch {epoch}:')
trn.train(model, self.device, self.dataset.train_loader, optimizer,
epoch, train_accuracy, train_losses, l1_factor,
scheduler, criterion, lrs, grad_clip)
tst.test(model, self.device, self.dataset.test_loader,
test_accuracy, test_losses, criterion)
# if epoch > 20:
# scheduler.step(test_accuracy[-1])
return (train_accuracy, train_losses, test_accuracy,
test_losses), model
def main(opt):
train_dataset = Dataset(opt.dataroot, True)
train_dataloader = Dataloader(train_dataset, batch_size=opt.batchSize, \
shuffle=False, num_workers=2)
test_dataset = Dataset(opt.dataroot, False)
test_dataloader = Dataloader(test_dataset, batch_size=opt.batchSize, \
shuffle=False, num_workers=2)
net = FNN(d=opt.d, n=opt.n)
net.double()
print(net)
criterion = nn.CosineSimilarity(dim=2)
optimizer = optim.Adam(net.parameters(), lr=opt.lr)
with open('train.csv', 'a') as f:
writer = csv.writer(f, lineterminator='\n')
writer.writerow(
["train_loss", "train_gain", "baseline_loss", "baseline_gain"])
with open('test.csv', 'a') as f:
writer = csv.writer(f, lineterminator='\n')
writer.writerow(
["test_loss", "test_gain", "baseline_loss", "baseline_gain"])
start = time.time()
for epoch in range(0, opt.niter):
train(epoch, train_dataloader, net, criterion, optimizer, opt)
test(test_dataloader, net, criterion, optimizer, opt)
elapsed_time = time.time() - start
with open('time.csv', 'a') as f:
writer = csv.writer(f, lineterminator='\n')
writer.writerow(["学習時間", elapsed_time])
def main():
# if han sent_flag=True
toxic_data = data_source.DataSource(EMBED_FILES,
embed_flag='crawl',
sent_flag=False)
print(toxic_data.description())
train_model = model.IndRNNModel(toxic_data)
if train_fold:
result_model = train.train_folds(train_model, 10, log_dir)
else:
result_model = train.train(train_model, log_dir)
print('train finish')
result_file = train_model.description + '.csv'
print(f'result_file: {result_file}')
infer.infer_result(result_model, toxic_data, log_dir, result_file)
def run(opt):
start_time = time.time()
opt.dataroot = 'babi_data/%s/train/%d_graphs.txt' % (opt.processed_path,
opt.task_id)
print(opt)
train_dataset = bAbIDataset(opt.dataroot, opt.question_id, True,
opt.train_size)
train_dataloader = bAbIDataloader(train_dataset, batch_size=opt.batchSize, \
shuffle=True, num_workers=2)
test_dataset = bAbIDataset(opt.dataroot, opt.question_id, False,
opt.train_size)
test_dataloader = bAbIDataloader(test_dataset, batch_size=opt.batchSize, \
shuffle=False, num_workers=2)
opt.annotation_dim = 1 # for bAbI
opt.n_edge_types = train_dataset.n_edge_types
opt.n_node = train_dataset.n_node
if opt.net == 'GGNN':
net = GGNN(opt)
net.double()
else:
net = Graph_OurConvNet(opt)
net.double()
print(net)
criterion = nn.CrossEntropyLoss()
if opt.cuda:
net.cuda()
criterion.cuda()
optimizer = optim.Adam(net.parameters(), lr=opt.lr)
for epoch in range(0, opt.niter):
train_loss = train(epoch, train_dataloader, net, criterion, optimizer,
opt)
test_loss, numerator, denominator = test(test_dataloader, net,
criterion, optimizer, opt)
return train_loss, test_loss, numerator, denominator, time.time(
) - start_time
def test_train(self, param_dist_mock):
param_dist = {
"vectorizer__ngram_range": [(1, 1), (1, 2)],
"vectorizer__min_df":
stats.randint(1, 3),
"vectorizer__max_df":
stats.uniform(.95, .3),
"vectorizer__sublinear_tf": [True, False],
"select__k": ['all'],
"clf__alpha":
log_uniform(-5, 2),
"clf__penalty": ['l2', 'l1', 'elasticnet'],
"clf__loss":
['hinge', 'log', 'modified_huber', 'squared_hinge', 'perceptron'],
}
param_dist_mock.return_value = param_dist
X, y = prepare_samples(self.attachments)
try:
_, _, _, _ = train(X, y, n_iter_search=10, score="accuracy")
except:
self.fail("train() raised an exception!")
def main(args):
torch.manual_seed(args.seed)
np.random.seed(args.seed)
dataset = datasets[args.dataset](DatasetType.TRAIN)
data_loader = DataLoader(dataset,
batch_size=args.batch_size,
collate_fn=dataset.collate_fn,
shuffle=True)
model = models[args.model](dataset.vocabulary_size(),
dataset.sos_token,
dataset.eos_token,
dataset.pad_token,
attention_size=args.attention_size,
embedding_size=args.embedding_size,
hidden_size=args.hidden_size,
num_layers=args.layers)
if args.weights is not None:
model.load_state_dict(torch.load(args.weights, map_location='cpu'))
model.to(device)
optimizer = Adam(model.parameters(), lr=args.learning_rate)
scheduler = CosineAnnealingLR(
optimizer, args.cosine_tmax,
args.cosine_etamin) if args.cosine_tmax else None
criterion = NLLLoss()
losses = train(data_loader,
model,
optimizer,
scheduler,
criterion,
dataset.vocabulary_size(),
args.n_epochs,
args.epoch,
clip_norm=args.clip_norm)
print(losses)
def main(args):
# choose the dataset
dataset = E2E(DatasetType.TRAIN)
# dataset = Hotel(DatasetType.TRAIN)
# dataset = Restaurant(DatasetType.TRAIN)
data_loader = DataLoader(dataset, batch_size=batch_size, collate_fn=dataset.collate_fn, shuffle=True)
# choose the model
model = EDA_C(dataset.vocabulary_size(), dataset.sos_token, dataset.eos_token, dataset.pad_token)
# model = EDA(dataset.vocabulary_size(), dataset.sos_token, dataset.eos_token, dataset.pad_token)
if args.model is not None:
model.load_state_dict(torch.load(args.model, map_location='cpu'))
print(f'continue training model {args.model} starting from the epoch {args.epoch}.')
model.to(device)
optimizer = Adam(model.parameters(), lr=learning_rate)
criterion = NLLLoss()
# training process
losses = train(data_loader, model, optimizer, criterion, dataset.vocabulary_size(), n_epochs, args.epoch, clip_norm=clip_norm)
print(losses)
os.makedirs(pt_dir, exist_ok=True)
os.makedirs(log_dir, exist_ok=True)
logging.basicConfig(level=logging.INFO,
format='%(asctime)s - %(levelname)s - %(message)s',
handlers=[
logging.FileHandler(
os.path.join(
log_dir,
'%s-%d.log' % (args.name, time.time()))),
logging.StreamHandler()
])
logger = logging.getLogger()
writer = MyWriter(hp, log_dir)
assert hp.audio.hop_length == 256, \
'hp.audio.hop_length must be equal to 256, got %d' % hp.audio.hop_length
assert hp.data.train != '' and hp.data.validation != '', \
'hp.data.train and hp.data.validation can\'t be empty: please fix %s' % args.config
trainloader = create_dataloader(hp, args, True)
valloader = create_dataloader(hp, args, False)
train(args, pt_dir, args.checkpoint_path, trainloader, valloader, writer,
logger, hp, hp_str)
def repl_test():
chkpt_path = args.checkpoint_path
logging.basicConfig(
level=logging.INFO,
format='%(asctime)s - %(levelname)s - %(message)s',
handlers=[
logging.FileHandler(os.path.join(log_dir,
'%s-%d.log' % (args.model, time.time()))),
logging.StreamHandler()
]
)
logger = logging.getLogger()
if hp.data.train == '' or hp.data.val == '':
logger.error("hp.data.train, hp.data.val cannot be empty")
raise Exception("Please specify directories of train data.")
if hp.model.graph0 == '' or hp.model.graph1 == '' or hp.model.graph2 == '':
logger.error("hp.model.graph0, graph1, graph2 cannot be empty")
raise Exception("Please specify random DAG architecture.")
graphs = [
read_graph(hp.model.graph0),
read_graph(hp.model.graph1),
read_graph(hp.model.graph2),
]
writer = MyWriter(log_dir)
trainset = KMNIST_dataloader(hp, args, True)
valset = KMNIST_dataloader(hp, args, False)
train(out_dir, chkpt_path, trainset, valset, writer, logger, hp, hp_str, graphs, in_channels=1)
def train_from_data(self,
train_raw_data,
test_raw_data,
W,
word2index,
attr_dict,
args,
Fold=0):
word_embed_dim = W.shape[1]
hidden_size = args.n_hidden
vocab_size = len(W)
output_size = len(attr_dict)
if args.model == 'LSTM':
self.classifier = networks.LSTM(word_embed_dim, output_size,
vocab_size, args)
elif args.model == 'Fasttext':
self.classifier = networks.Fasttext(word_embed_dim, output_size,
vocab_size, args)
elif args.model == 'Average_LSTM2':
self.classifier = networks.Average_LSTM2(word_embed_dim,
output_size, vocab_size,
args)
elif args.model == 'AttA3':
self.classifier = networks.AttA3(word_embed_dim, output_size,
vocab_size, args)
aspect_e_l = []
for a in attr_dict:
# print(a)
if a == '舒适性':
a = '舒适'
a_e = torch.FloatTensor(W[word2index[a]])
aspect_e_l.append(a_e)
aspect_embeds = torch.cat(aspect_e_l, 0)
# print(aspect_embeds)
# print(attr_dict)
self.classifier.AE.weight = torch.nn.Parameter(aspect_embeds)
elif args.model == 'Binary_LSTM':
self.classifier = networks.Binary_LSTM(word_embed_dim, output_size,
vocab_size, args)
elif args.model == 'CNN':
self.classifier = networks.CNN(word_embed_dim, output_size,
vocab_size, args)
elif args.model == 'Attn_LSTM':
self.classifier = networks.Attn_LSTM(word_embed_dim, output_size,
vocab_size, args)
train_elmo, test_elmo = [], []
if args.use_elmo != 0:
import h5py
elmo_dict = h5py.File('../embedding/embeddings_elmo_ly-1.hdf5',
'r')
for s in train_raw_data[0]:
sentence = '\t'.join(s)
sentence = sentence.replace('.', '$period$')
sentence = sentence.replace('/', '$backslash$')
# print(sentence)
embeddings = torch.from_numpy(np.asarray(elmo_dict[sentence]))
train_elmo.append(embeddings)
for s in test_raw_data[0]:
sentence = '\t'.join(s)
sentence = sentence.replace('.', '$period$')
sentence = sentence.replace('/', '$backslash$')
embeddings = torch.from_numpy(np.asarray(elmo_dict[sentence]))
test_elmo.append(embeddings)
elmo_dict.close()
print("finish elmo")
train_data = Data(train_raw_data, word2index, attr_dict, args)
# if args.use_dev:
# dev_data = Data(args, dev_input_s, dev_input_t, dev_y_tensor)
# else:
# dev_data = None
test_data = Data(test_raw_data, word2index, attr_dict, args)
if args.use_elmo != 0:
train_data.add_feature(train_elmo)
test_data.add_feature(test_elmo)
best_dict, max_acc = train.train(self.classifier,
train_data,
test_data,
test_data,
attr_dict,
W,
args=args)
best_model = "%s/checkpoint_%s_%.6f_%d.pt" % (
args.check_dir, args.model, max_acc, Fold)
if args.save != 0:
torch.save(best_dict, best_model)
pass
train_dataset = BADataset(opt.dataroot, opt.L, True, False, False)
train_dataloader = BADataloader(train_dataset, batch_size=opt.batchSize, \
shuffle=True, num_workers=opt.workers, drop_last=True)
# valid_dataset = BADataset(opt.dataroot, opt.L, False, True, False)
# valid_dataloader = BADataloader(valid_dataset, batch_size=opt.batchSize, \
# shuffle=True, num_workers=opt.workers, drop_last=True)
# test_dataset = BADataset(opt.dataroot, opt.L, False, False, True)
# test_dataloader = BADataloader(test_dataset, batch_size=opt.batchSize, \
# shuffle=False, num_workers=opt.workers, drop_last=True)
all_dataset = BADataset(opt.dataroot, opt.L, False, False, False)
all_dataloader = BADataloader(all_dataset, batch_size=opt.batchSize, \
shuffle=False, num_workers=opt.workers, drop_last=False)
device = torch.device('cuda:' + str(opt.cuda) if opt.gpu else 'cpu')
net = DEAL(opt.output_dim, opt.annotation_dim, all_node_num, device, opt, locals()[opt.attr_model])
net.double()
print(net)
if opt.cuda:
net.cuda()
optimizer = torch.optim.Adam(net.parameters(), lr=opt.lr)
os.makedirs(OutputDir, exist_ok=True)
train(train_dataloader, net, optimizer, opt, OutputDir)
net.load_state_dict(torch.load(OutputDir + '/checkpoint.pt'))
inference(all_dataloader, net, opt, OutputDir)
def main(opt):
if not os.path.exists(opt.resume):
os.makedirs(opt.resume)
if not os.path.exists(opt.logroot):
os.makedirs(opt.logroot)
log_dir_name = str(opt.manualSeed) + '/'
log_path = os.path.join(opt.logroot, log_dir_name)
opt.resume = os.path.join(opt.resume, log_dir_name)
if not os.path.exists(log_path):
os.makedirs(log_path)
#log_file_name = log_path + 'ucf_log_st.txt'
#log_file_name = opt.logroot + 'ucf_log_st_'+str(opt.manualSeed)+'.txt'
log_file_name = opt.logroot + 'something_log_v4.1_' + str(
opt.manualSeed) + '.txt'
with open(log_file_name, 'a+') as file:
file.write('manualSeed is %d \n' % opt.manualSeed)
paths = config.Paths()
train_datalist = "/home/mcislab/zhaojw/AAAI/sth_train_list.txt"
val_datalist = "/home/mcislab/zhaojw/AAAI/sth_val_list.txt"
test_datalist = "/home/mcislab/zhaojw/AAAI/sth_test_list.txt"
#test_datalist = '/home/mcislab/wangruiqi/IJCV2019/data/newsomething-check.txt'
#opt.resume = os.path.join(opt.resume,log_dir_name)
train_dataset = dataset(train_datalist, paths.sthv2_final, opt)
train_dataloader = DataLoader(train_dataset,
batch_size=opt.batch_size,
shuffle=True,
num_workers=opt.workers,
drop_last=False)
val_dataset = dataset(val_datalist, paths.sthv2_final, opt)
val_dataloader = DataLoader(val_dataset,
batch_size=opt.batch_size,
shuffle=False,
num_workers=opt.workers,
drop_last=False)
test_dataset = dataset(test_datalist, paths.sthv2_final, opt)
test_dataloader = DataLoader(test_dataset,
batch_size=opt.batch_size,
shuffle=False,
num_workers=opt.workers,
drop_last=False)
model = sthv2_model.Model(opt)
'''
if opt.show:
show(model)
exit()
'''
optimizer = optim.SGD(model.parameters(), lr=opt.lr, momentum=opt.momentum)
scheduler = torch.optim.lr_scheduler.StepLR(optimizer,
step_size=100,
gamma=0.9)
criterion1 = nn.CrossEntropyLoss()
criterion2 = nn.NLLLoss()
if opt.cuda:
model.cuda()
#criterion.cuda(opt.device_id)
criterion1.cuda()
criterion2.cuda()
'''
if opt.epoch != 0:
if os.path.exists('./models/hmdb_split1/'+checkpoint_model_name):
model.load_state_dict(torch.load('./models/hmdb_split1/' + checkpoint_model_name))
else:
print('model not found')
exit()
'''
#Lin commented on Sept. 2nd
#model.double()
writer = SummaryWriter(log_dir=os.path.join(log_path, 'runs/'))
# For training
sum_test_acc = []
best_acc = 0.
#epoch_errors = list()
avg_epoch_error = np.inf
best_epoch_error = np.inf
'''
#haha, output Acc for each class
test_load_dir = opt.resume
#test_load_dir = '/home/mcislab/linhanxi/IJCV19_Experiments/sth_scale/something_scale5_M/ckpnothresh/ours'
model.load_state_dict(torch.load(os.path.join(test_load_dir, 'model_best.pth'))['state_dict'])
if opt.featdir:
model.feat_mode()
test_acc, output = test(0,test_dataloader, model, criterion1, criterion2, opt, writer, test_load_dir, is_test=True)
exit()
'''
print("Test once to get a baseline.")
loaded_checkpoint = utils.load_best_checkpoint(opt, model, optimizer)
if loaded_checkpoint:
opt, model, optimizer = loaded_checkpoint
test_acc, output = test(51,
test_dataloader,
model,
criterion1,
criterion2,
opt,
writer,
log_file_name,
is_test=True)
tmp_test_acc = np.mean(test_acc)
if tmp_test_acc > best_acc:
best_acc = tmp_test_acc
print("Start to train.....")
for epoch_i in range(opt.epoch, opt.niter):
scheduler.step()
train(epoch_i, train_dataloader, model, criterion1, criterion2,
optimizer, opt, writer, log_file_name)
#val_acc, val_out, val_error =test(valid_loader, model, criterion1,criterion2, opt, log_file_name, is_test=False)
# Lin changed according to 'sth_pre_abl1' on Sept. 3rd
test_acc, output = val(epoch_i,
val_dataloader,
model,
criterion1,
criterion2,
opt,
writer,
log_file_name,
is_test=True)
#test_acc,_ = test(test_dataloader, model, criterion1, criterion2, opt, log_file_name, is_test=True)
tmp_test_acc = np.mean(test_acc)
sum_test_acc.append(test_acc)
if tmp_test_acc > best_acc:
is_best = True
best_acc = tmp_test_acc
else:
is_best = False
utils.save_checkpoint(
{
'epoch': epoch_i,
'state_dict': model.state_dict(),
'optimizer': optimizer.state_dict()
},
is_best=is_best,
directory=opt.resume)
print("A training epoch finished!")
#epoch_i =33
# For testing
print("Training finished.Start to test.")
loaded_checkpoint = utils.load_best_checkpoint(opt, model, optimizer)
if loaded_checkpoint:
opt, model, optimizer = loaded_checkpoint
# Lin changed according to 'sth_pre_abl1' on Sept. 3rd
test_acc, output = test(epoch_i,
test_dataloader,
model,
criterion1,
criterion2,
opt,
writer,
log_file_name,
is_test=True)
#test_acc,output = test(test_dataloader, model, criterion1,criterion2, opt, log_file_name, is_test=True)
print("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~")
print("ratio=0.1, test Accuracy: %.2f " % (100. * test_acc[0][0]))
print("ratio=0.2, test Accuracy: %.2f " % (100. * test_acc[0][1]))
print("ratio=0.3, test Accuracy: %.2f " % (100. * test_acc[0][2]))
print("ratio=0.4, test Accuracy: %.2f " % (100. * test_acc[0][3]))
print("ratio=0.5, test Accuracy: %.2f " % (100. * test_acc[0][4]))
print("ratio=0.6, test Accuracy: %.2f " % (100. * test_acc[0][5]))
print("ratio=0.7, test Accuracy: %.2f " % (100. * test_acc[0][6]))
print("ratio=0.8, test Accuracy: %.2f " % (100. * test_acc[0][7]))
print("ratio=0.9, test Accuracy: %.2f " % (100. * test_acc[0][8]))
print("ratio=1.0, test Accuracy: %.2f " % (100. * test_acc[0][9]))
print("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~")
model = torch.nn.DataParallel(model)
model = model.cuda()
optimizer = optim.SGD(model.parameters(), lr=0.001, momentum=0.9, weight_decay=1e-5)
exp_lr_scheduler = lr_scheduler.StepLR(optimizer, step_size=27, gamma=0.1)
save_dir = './saved_models/Resnet50'
logfile = './saved_models/Resnet50/trainlog.log'
trainlog(logfile)
train(model,
epoch_num,
batch_size,
start_epoch,
optimizer,
criterion,
exp_lr_scheduler,
dataset,
data_loader,
usecuda,
save_inter,
save_dir)
elif isPrune:
model = models.resnet50(num_classes=2)
model.load_state_dict(torch.load('./saved_models/Resnet50/weights-1-[0.9898].pth'))
fine_tuner = Res50FilterPruner(model=model,
train_dataloader=data_loader['train'],
test_dataloader=data_loader['val'],
criterion=criterion,
useCuda=True)
from utils.arguments import parse_args
from utils.data import load_dna_data_gan
from utils.gan_model import load_deep_signal_gan_model, load_basic_gan_model, load_dc_gan_model
from utils.train import pre_train, train
import numpy as np
import tensorflow as tf
args = parse_args()
np.random.seed(args.seed)
tf.compat.v1.set_random_seed(args.seed)
x_train, x_test, y_test, x_val, y_val = load_dna_data_gan(args)
generator, discriminator, GAN = load_dc_gan_model(args)
pre_train(args, generator, discriminator, x_train)
results = train(args, generator, discriminator, GAN, x_train, x_test, y_test,
x_val, y_val)
transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
])
if args.imshow == True:
train_dataset = selfData(args.train_img, args.train_lab, transforms)
train_loader = DataLoader(train_dataset, batch_size = 64, shuffle = True, num_workers = 0, drop_last= False)
imgs, labels = train_loader.__iter__().__next__()
imshow(train_loader)
if args.model == 'mAlexNet':
net = mAlexNet().to(device)
elif args.model == 'AlexNet':
net = AlexNet().to(device)
criterion = nn.CrossEntropyLoss()
if args.path == '':
train(args.epochs, args.train_img, args.train_lab, transforms, net, criterion)
PATH = './model.pth'
torch.save(net.state_dict(), PATH)
if args.model == 'mAlexNet':
net = mAlexNet().to(device)
elif args.model == 'AlexNet':
net = AlexNet().to(device)
net.load_state_dict(torch.load(PATH))
else:
PATH = args.path
if args.model == 'mAlexNet':
net = mAlexNet().to(device)
elif args.model == 'AlexNet':
net = AlexNet().to(device)
net.load_state_dict(torch.load(PATH))
accuracy = test(args.test_img, args.test_lab, transforms, net)
net = CIFARNet()
net.load_state_dict(torch.load('ft'))
if use_cuda:
net.cuda()
net = torch.nn.DataParallel(net, device_ids=range(torch.cuda.device_count()))
cudnn.benchmark = True
criterion = nn.CrossEntropyLoss()
# optimizer = optim.SGD(net.parameters(), lr=args.lr, momentum=0.9, weight_decay=5e-4)
optimizer = optim.Adam(net.parameters(), lr=args.lr, weight_decay=5e-4)
break_count = 0
for epoch in range(start_epoch, start_epoch+200):
print('\nEpoch: %d' %epoch)
train(net, source_train_loader, optimizer=optimizer, n_epoch=1)
acc_s = validate(net, source_test_loader)
acc_t = validate(net, target_test_loader)
if acc_s > best_acc:
print('Saving..')
if not os.path.exists('./checkpoint'):
os.makedirs('./checkpoint')
state = {
'net': net.module if use_cuda else net,
'acc': acc_s,
'epoch': epoch,
}
if not os.path.isdir('checkpoint'):
os.mkdir('checkpoint')
