def train_single_model(params):
# use GPU if available
params['cuda'] = torch.cuda.is_available()
# log into the appropriate directory
utils.set_logger(os.path.join('train.log'))
# Set the random seed for reproducible experiments
torch.manual_seed(1337)
if params.cuda: torch.cuda.manual_seed(1337)
# dynamic import of net
net = import_module('model.{}'.format(params.model_name))
model = net.Net(params).cuda() if params.cuda else net.Net(params)
if params.cuda and params.multi_gpu == 1 and torch.cuda.device_count() > 1:
print('Using', torch.cuda.device_count(), 'GPUs.')
model = nn.DataParallel(model)
# Create the input data pipeline
logging.info("Loading the datasets...")
dataloaders = data_loader.fetch_dataloader(['train', 'test'], data_dir,
params)
train_dl = dataloaders['train']
val_dl = dataloaders['test']
optimizer = optim.Adam(model.parameters(), lr=params.learning_rate)
# fetch loss function and metrics
loss_fn = net.loss_fn
metrics = net.metrics
# Train the model
logging.info("Starting training for {} epoch(s)".format(params.num_epochs))
train_and_evaluate(model, train_dl, val_dl, optimizer, loss_fn, metrics,
params, 'experiments/' + params.exp_name, restore_file)
def main(data_dir, model_dir, restore_file):
"""
Evaluate the model on the test set.
"""
# Load the parameters
json_path = Path(model_dir) / 'hyper_params.json'
assert json_path.is_file(
), "No json configuration file found at {}".format(json_path)
hyper_params = utils.HyperParams(json_path)
# use GPU if available
#hyper_params.cuda = torch.cuda.is_available() # use GPU is available
hyper_params.cuda = torch.device(
'cuda:0') if torch.cuda.is_available() else -1
# Set the random seed for reproducible experiments
torch.manual_seed(230)
if hyper_params.cuda is not -1:
with torch.cuda.device(str(hyper_params.cuda)[-1]):
torch.cuda.manual_seed(230)
# Get the logger
utils.set_logger(Path(model_dir) / 'evaluate.log')
# Create the input data pipeline
logging.info("Creating the dataset...")
# fetch dataloaders
dataloaders = data_loader.fetch_dataloader(
['test'], data_dir + hyper_params.augmentation, hyper_params)
test_dl = dataloaders['test']
logging.info("- done.")
# Define the model
model = getattr(net, hyper_params.model, None)
assert model is not None, "Model {} couldn't be found!".format(
hyper_params.model)
model = model(hyper_params).to(
device=hyper_params.cuda) if hyper_params.cuda is not -1 else model(
hyper_params)
loss_fn = getattr(loss, hyper_params.loss, None)
assert loss_fn is not None, "Loss Fn {} couldn't be found!".format(
hyper_params.loss)
metrics_dict = metric.metrics_dict
logging.info("Starting evaluation")
# Reload weights from the saved file
utils.load_checkpoint(str(Path(model_dir) / (restore_file + '.pth.tar')),
model)
# Evaluate
test_metrics = evaluate(model, loss_fn, test_dl, metrics_dict, model_dir,
hyper_params)
save_path = str(
Path(model_dir) / "metrics_test_{}.json".format(restore_file))
utils.save_dict_to_json(test_metrics, save_path)
def train(self, data_dir = 'data/GTSDB/', model_dir = 'experiment/', restore = None):
print("Loading the datasets...")
data = data_loader.fetch_dataloader(['train', 'val'], data_dir, self.params)
train_data = data['train']
val_data = data['val']
print("- done.")
optimizer = optim.Adam(self.model.parameters(), lr=self.params.learning_rate)
loss_fn = net.yolo_v1_loss
print("Starting training for {} epoch(s)".format(self.params.num_epochs))
train_fn.train_and_evaluate(self.model, train_data, val_data, optimizer, loss_fn, params, model_dir, restore)
def plot_validation(model):
"""Plots predictions for whole validation set"""
test_loader = data_loader.fetch_dataloader('data/val', batch_size=8)
with torch.no_grad():
for images, y, _, fname in tqdm(test_loader):
images = images.to(device)
outputs = model(images)
_, preds = torch.max(outputs.data, 1)
preds, y = preds.cpu().numpy(), y.numpy()
for b in range(preds.shape[0]):
image = plot_fast(preds[b], y[b])
imageio.imwrite('preds/' + fname[b], image.astype(np.uint8))
def runEvaluate(model_dir, data_dir, restore_file):
"""
Evaluate the model on the test set.
"""
# Load the parameters
json_path = os.path.join(args.model_dir, 'params.json')
assert os.path.isfile(
json_path), "No json configuration file found at {}".format(json_path)
params = utils.Params(json_path)
# use GPU if available
params.cuda = torch.cuda.is_available() # use GPU is available
# Set the random seed for reproducible experiments
torch.manual_seed(231)
if params.cuda: torch.cuda.manual_seed(231)
# Get the logger
# utils.set_logger(os.path.join(args.model_dir, 'evaluate.log'))
# Create the input data pipeline
logging.info("Creating the dataset...")
# fetch dataloaders
dataloaders = data_loader.fetch_dataloader(['train'], args.data_dir,
params)
test_dl = dataloaders['train']
logging.info("- done.")
# Define the model
model = net.Net(params).cuda() if params.cuda else net.Net(params)
loss_fn = net.loss_fn
metrics = net.metrics
logging.info("Starting evaluation")
# Reload weights from the saved file
utils.load_checkpoint(
os.path.join(args.model_dir, args.restore_file + '.pth.tar'), model)
# Evaluate
test_metrics = evaluate(model, loss_fn, test_dl, metrics, params)
save_path = os.path.join(
args.model_dir, "metrics_training_{}.json".format(args.restore_file))
utils.save_dict_to_json(test_metrics, save_path)
# pdb.set_trace()
# use GPU if available
params.cuda = torch.cuda.is_available()
# Set the random seed for reproducible experiments
torch.manual_seed(230)
if params.cuda: torch.cuda.manual_seed(230)
# Set the logger
utils.set_logger(os.path.join(args.model_dir, 'train.log'))
# Create the input data pipeline
logging.info("Loading the datasets...")
# fetch dataloaders
dataloaders = data_loader.fetch_dataloader(['train', 'val'], args.data_dir,
params)
train_dl = dataloaders['train']
val_dl = dataloaders['val']
logging.info("- done.")
# Define the model and optimizer
model = net.Net(params).cuda() if params.cuda else net.Net(params)
optimizer = optim.Adam(model.parameters(), lr=params.learning_rate)
# fetch loss function and metrics
loss_fn = net.loss_fn
metrics = net.metrics
# Train the model
logging.info("Starting training for {} epoch(s)".format(params.num_epochs))
# Set the random seed for reproducible experiments
random.seed(230)
torch.manual_seed(230)
if params.cuda: torch.cuda.manual_seed(230)
# Set the logger
utils.set_logger(os.path.join(args.model_dir, 'train.log'))
# Create the input data pipeline
logging.info("Loading the datasets...")
# fetch dataloaders, considering full-set vs. sub-set scenarios
if params.subset_percent < 1.0:
train_dl = data_loader.fetch_subset_dataloader('train', params)
else:
train_dl, _ = data_loader.fetch_dataloader('train', params)
dev_dl, _ = data_loader.fetch_dataloader('dev', params)
logging.info("- done.")
"""Based on the model_version, determine model/optimizer and KD training mode
WideResNet and DenseNet were trained on multi-GPU; need to specify a dummy
nn.DataParallel module to correctly load the model parameters
"""
if "distill" in params.model_version:
student_model_load_start = time.time()
# train a 5-layer CNN or a 18-layer ResNet with knowledge distillation
if params.model_version == "cnn_distill":
model = net.Net(params).cuda() if params.cuda else net.Net(params)
optimizer = optim.Adam(model.parameters(), lr=params.learning_rate)
os.makedirs(logdir)
# copy params as backupt to logdir
shutil.copy(json_path, os.path.join(logdir, "params.json"))
# utils.set_logger(os.path.join(args.model_dir, 'train.log'))
utils.set_logger(os.path.join(logdir, 'train.log'))
# Create the input data pipeline
logging.info("Loading the datasets...")
# fetch dataloaders
# dataloaders = data_loader.fetch_dataloader(['train', 'val'], args.data_dir, params)
# dataloaders = data_loader.fetch_dataloader(['train', 'val'], "data", params)
# dataloaders = data_loader.fetch_dataloader(types = ["train", "valid"])
dataloaders = data_loader.fetch_dataloader(args, params, setting, ["train", "valid"])
train_dl = dataloaders['train']
valid_dl = dataloaders['valid']
if setting.num_classes > 1 and params.balance_classes:
train_labels = train_dl.dataset.df[setting.outcome[0]].values
class_weights = compute_class_weight('balanced', np.unique(train_labels), train_labels)
# valid_dl = train_dl
logging.info("- done.")
# print("allocated mem after dataloaders %s" % (torch.cuda.max_memory_allocated(0)))
# Define the model and optimizer
# if covar_mode:
# model = net.TNet(params).cuda() if params.cuda else net.TNet(params)
# use GPU if available
params.cuda = torch.cuda.is_available()
# Set the random seed for reproducible experiments
torch.manual_seed(230)
if params.cuda: torch.cuda.manual_seed(230)
# Set the logger
utils.set_logger(os.path.join(args.model_dir, 'train.log'))
# Create the input data pipeline
logging.info("Loading the datasets...")
# fetch dataloaders
dataloaders = data_loader.fetch_dataloader(os.getcwd(), params)
train_dl = dataloaders['train']
#mini_train_dl = dataloaders['mini-train']
val_dl = dataloaders['val']
#mini_val_dl = dataloaders['mini-val']
logging.info("- done.")
if args.model_id == 'resnet50':
model = models.resnet50(pretrained=True)
elif args.model_id == 'resnet101':
model = models.resnet101(pretrained=True)
#Freeze First 5 Layers
lt = 6
cntr = 0
for child in model.children():
# Set the random seed for reproducible experiments
random.seed(230)
torch.manual_seed(230)
if params.cuda: torch.cuda.manual_seed(230)
# Set the logger
utils.set_logger(os.path.join(args.model_dir, 'train.log'))
# Create the input data pipeline
logging.info("Loading the datasets...")
# fetch dataloaders, considering full-set vs. sub-set scenarios
if params.subset_percent < 1.0:
train_dl = data_loader.fetch_subset_dataloader('train', params)
else:
train_dl = data_loader.fetch_dataloader('train', params)
dev_dl = data_loader.fetch_dataloader('dev', params)
logging.info("- done.")
"""Based on the model_version, determine model/optimizer and KD training mode
WideResNet and DenseNet were trained on multi-GPU; need to specify a dummy
nn.DataParallel module to correctly load the model parameters
"""
if "distill" in params.model_version:
# train a 5-layer CNN or a 18-layer ResNet with knowledge distillation
if params.model_version == "cnn_distill":
model = net.Net(params).cuda() if params.cuda else net.Net(params)
optimizer = optim.Adam(model.parameters(), lr=params.learning_rate)
def fetch_data(datadir, params):
""" fetch the dataset dataloaders """
dl = data_loader.fetch_dataloader(['train', 'test'], datadir, params)
return dl
#G_optimizer = optim.Adam(paramsG, lr=lr, betas=(0.5, 0.999))
#paramsD = list(D_model.conv4.parameters()) + list(D_model.conv4_bn.parameters()) + list(D_model.conv5.parameters())
#D_optimizer = optim.Adam(paramsD, lr=lr, betas=(0.5, 0.999))
'''
# fetch loss function
loss_fn = net.loss_fn
# Set the logger
utils.set_logger(os.path.join(model_dir, 'train.log'))
# Create the input data pipeline
logging.info("Loading the datasets...")
# data_loader
train_loader = data_loader.fetch_dataloader(data_dir, batch_size, dataset)
print('dataset length ' + str(len(train_loader.dataset)))
# Train the model
logging.info("Starting training for {} epoch(s)".format(train_epoch))
train_and_evaluate(param_cuda,
dataset,
G_model,
D_model,
G_optimizer,
D_optimizer,
loss_fn,
train_loader,
train_epoch,
model_dir,
restore_file=restore_file)
parameters = utils.Params(json_path)
# Record whether GPU is available
parameters.cuda = torch.cuda.is_available()
# Set random seed for reproducible experiments
torch.manual_seed(230)
if parameters.cuda: torch.cuda.manual_seed(230)
# Configure logger
utils.set_logger(os.path.join(arguments.model_dir, 'train.log'))
# Create data loaders for training and validation data
logging.info('Loading train and validation datasets...')
data_loaders = data_loader.fetch_dataloader(['train', 'val'],
arguments.data_dir, parameters,
arguments.small,
arguments.use_tencrop)
train_data_loader = data_loaders['train']
validation_data_loader = data_loaders['val']
logging.info('...done.')
# Configure model and optimizer
model = net.DenseNet169(
parameters).cuda() if parameters.cuda else net.DenseNet169(parameters)
optimizer = optim.Adam(model.parameters(),
lr=parameters.learning_rate,
weight_decay=parameters.L2_penalty)
# Configure schedule for decaying learning rate
scheduler = optim.lr_scheduler.ReduceLROnPlateau(
optimizer,
params.cuda = torch.cuda.is_available()
# Set the random seed for reproducible experiments
torch.manual_seed(230)
if params.cuda: torch.cuda.manual_seed(230)
# Set the logger
utils.set_logger(os.path.join(args.model_dir, 'train.log'))
# Create the input data pipeline
logging.info("Loading the datasets...")
# fetch dataloaders
# dataloaders = data_loader.fetch_dataloader(['train', 'val'], args.data_dir, params)
# dataloaders = data_loader.fetch_dataloader(['train', 'val'], "data", params)
dataloaders = data_loader.fetch_dataloader(types = ["train", "valid"])
# dataloaders = data_loader.fetch_dataloader(types = ["train"])
train_dl = dataloaders['train']
valid_dl = dataloaders['valid']
logging.info("- done.")
# Define the model and optimizer
model = net.Net(params).cuda() if params.cuda else net.Net(params)
optimizer = optim.Adam(model.parameters(), lr=params.learning_rate)
# fetch loss function and metrics
loss_fn = net.loss_fn
metrics = net.metrics
# Record whether GPU is available
parameters.cuda = torch.cuda.is_available()
# Set random seed for reproducible experiments
torch.manual_seed(230)
if parameters.cuda: torch.cuda.manual_seed(230)
# Configure logger
utils.set_logger(os.path.join(arguments.model_dir,
'evaluate_ensemble.log'))
# Create data loaders for test data
logging.info('Loading test dataset...')
test_dataloader = data_loader.fetch_dataloader(
['test'], arguments.data_dir, parameters, arguments.small,
arguments.use_tencrop)['test']
logging.info('...done.')
# Configure model; return feature vectors on each input
densenet_model = net.DenseNet169(parameters, return_features=True)
if parameters.cuda: densenet_model = densenet_model.cuda()
# Load weights from trained model
utils.load_checkpoint(
os.path.join(arguments.model_dir, arguments.restore_file + '.pth.tar'),
densenet_model)
# Features file names are of the form
# features_directory/{train, val, test}_features_and_labels.txt
# with 'small_' prepended if user specifies '--small'
# 判断GPU是否可用
args.cuda = torch.cuda.is_available()
# 设置随机种子来重构实验
torch.manual_seed(230)
if args.cuda:
print('Training on GPU!')
torch.cuda.manual_seed(230)
# 创建日志文件
utils.set_logger(os.path.join(args.model_dir, 'train.log'))
logging.info("Loading the datasets...")
# 获取数据
dataloaders = data_loader.fetch_dataloader(['train', 'val'], args)
train_dl = dataloaders['train']
val_dl = dataloaders['val']
logging.info("- done.")
# 定义网络结构与优化器
model = net.Net().cuda() if args.cuda else net.Net()
optimizer = optim.Adam(model.parameters(), lr=args.learning_rate)
# 定义损失函数与指标
loss_fn = net.loss_fn
metrics = net.metrics
# 训练与评估
logging.info("Starting training for {} epoch(s)".format(args.num_epochs))
parameters = utils.Params(json_path)
# Record whether GPU is available
parameters.cuda = torch.cuda.is_available()
# Set random seed for reproducible experiments
torch.manual_seed(230)
if parameters.cuda: torch.cuda.manual_seed(230)
# Configure logger
utils.set_logger(os.path.join(arguments.model_dir, 'train_embedding.log'))
# Create data loaders for training and validation data
logging.info('Loading train datasets...')
data_loaders = data_loader.fetch_dataloader(['train'], arguments.data_dir,
parameters, arguments.small,
False, True)
train_data_loader = data_loaders['train']
logging.info('...done.')
# Configure model and optimizer
model = net.DenseNet169(
parameters, True).cuda() if parameters.cuda else net.DenseNet169(
parameters, True)
optimizer = optim.Adam(model.parameters(),
lr=parameters.learning_rate,
weight_decay=parameters.L2_penalty)
# Configure schedule for decaying learning rate
scheduler = optim.lr_scheduler.ReduceLROnPlateau(
optimizer,
# use GPU if available
params.cuda = torch.cuda.is_available() # use GPU is available
# Set the random seed for reproducible experiments
torch.manual_seed(230)
if params.cuda: torch.cuda.manual_seed(230)
# Get the logger
utils.set_logger(os.path.join(args.model_dir, 'evaluate.log'))
# Create the input data pipeline
logging.info("Loading the dataset...")
# fetch dataloaders
# train_dl = data_loader.fetch_dataloader('train', params)
dev_dl = data_loader.fetch_dataloader('dev', params)
logging.info("- done.")
# Define the model graph
model = resnet.ResNet18().cuda() if params.cuda else resnet.ResNet18()
optimizer = optim.SGD(model.parameters(),
lr=params.learning_rate,
momentum=0.9,
weight_decay=5e-4)
# fetch loss function and metrics
loss_fn_kd = net.loss_fn_kd
metrics = resnet.metrics
logging.info("Starting evaluation...")
'bin_edges': binedges_list,
'weight_pt_hist': weight_pt_hist,
'weight_eta_hist': weight_eta_hist,
'weight_puppi_hist': weight_puppi_hist,
'weight_CH_hist': weight_CH_hist,
'weight_qT_hist': weight_qT_hist,
}
utils.save(weights, 'weight.plt')
return result
if __name__ == '__main__':
args = parser.parse_args()
dataloaders = data_loader.fetch_dataloader(data_dir=osp.join(
os.environ['PWD'], args.data),
batch_size=60,
validation_split=0.5)
train_dl = dataloaders['train']
test_dl = dataloaders['test']
print(len(train_dl), len(test_dl))
#model = net.Net().to('cuda')
#model = torch.jit.script(net.Net(7, 3)).to('cuda') # [px, py, pt, eta, d0, dz, mass], [pdgid, charge, fromPV]
model = net.Net(8, 3).to('cuda')
#optimizer = torch.optim.Adam(model.parameters(), lr=0.001, weight_decay=5e-3)
optimizer = torch.optim.AdamW(model.parameters(), lr=0.001)
scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer,
factor=0.5,
patience=500,
threshold=0.05)
from util import load_model
from torchvision import transforms
def test(test_loader, model = None):
device = torch.device('cuda:2' if torch.cuda.is_available() else 'cpu')
if (model == None):
model = load_model(device)
correct, total = 0, 0
with torch.no_grad():
for images, _, labels, _ in test_loader:
flipped_img = torch.flip(images, [3]).to(device) # horizontal flip of image
images, labels = images.to(device), labels.to(device).type(torch.cuda.LongTensor)
outputs = model(images)
outputs_flipped = torch.flip(model(flipped_img), [3])
avg_output = (outputs + outputs_flipped) / 2
_, predicted = torch.max(avg_output.data, 1)
total += labels.shape[0] * labels.shape[1] * labels.shape[2]
correct += (predicted == labels).sum().item()
return correct, total
if __name__ == '__main__':
test_loader = data_loader.fetch_dataloader('data/val', batch_size=8)
correct, total = test(test_loader)
t = datetime.datetime.fromtimestamp(time.time()).strftime('%Y-%m-%d %H:%M:%S')
print('Time : {} Accuracy on test data: {:.4f} %'.format(t, 100 * correct / total))
def train_and_evaluate(model,
optimizer,
scheduler,
loss_fn,
metrics,
params,
model_dir,
restore_file=None):
"""Train the model and evaluate every epoch.
Args:
model: (torch.nn.Module) the neural network
train_dataloader: (DataLoader) a torch.utils.data.DataLoader object that fetches training data
val_dataloader: (DataLoader) a torch.utils.data.DataLoader object that fetches validation data
optimizer: (torch.optim) optimizer for parameters of model
loss_fn: a function that takes batch_output and batch_labels and computes the loss for the batch
metrics: (dict) a dictionary of functions that compute a metric using the output and labels of each batch
params: (Params) hyperparameters
model_dir: (string) directory containing config, weights and log
restore_file: (string) optional- name of file to restore from (without its extension .pth.tar)
"""
# reload weights from restore_file if specified
if restore_file is not None:
restore_path = os.path.join(args.model_dir,
args.restore_file + '.pth.tar')
logging.info("Restoring parameters from {}".format(restore_path))
utils.load_checkpoint(restore_path, model, optimizer)
best_val_loss = 1e10
best_test_loss = 1e10
for epoch in range(params.num_epochs):
logging.info("Generate the train and test datasets...")
# fetch dataloaders for every epoch
dataloaders = data_loader.fetch_dataloader(['train', 'val', 'test'],
args.data_dir, params)
logging.info("- done.")
# Run one epoch
logging.info("Epoch {}/{}".format(epoch + 1, params.num_epochs))
# compute number of batches in one epoch (one full pass over the training set)
train(model, optimizer, loss_fn, dataloaders['train'], metrics, params)
# Evaluate for one epoch on validation set
val_metrics = evaluate(model, loss_fn, dataloaders['val'], metrics,
params, 'Val')
val_loss = val_metrics['rmse']
is_best_val = val_loss <= best_val_loss
# Evaluate for one epoch on test set
test_metrics = evaluate(model, loss_fn, dataloaders['test'], metrics,
params, 'Test')
test_loss = test_metrics['rmse']
is_best_test = test_loss <= best_test_loss
# Note that step should be called after validation
# scheduler.step(val_loss)
# for param_group in optimizer.param_groups:
# print(param_group['lr'])
# Save weights
utils.save_checkpoint(
{
'epoch': epoch + 1,
'state_dict': model.state_dict(),
'optim_dict': optimizer.state_dict()
},
is_best=is_best_val,
checkpoint=model_dir)
# If best_eval, best_save_path
# if is_best and (epoch > params.num_epochs/3):
if is_best_val:
logging.info("- Found new best val result")
best_val_loss = val_loss
# Save metrics in a json file in the model directory
best_json_path = os.path.join(model_dir,
"metrics_val_best_weights.json")
utils.save_dict_to_json(val_metrics, best_json_path)
if is_best_test:
logging.info("- Found new best test result")
best_test_loss = test_loss
# Save metrics in a json file in the model directory
best_json_path = os.path.join(model_dir,
"metrics_test_best_weights.json")
utils.save_dict_to_json(test_metrics, best_json_path)
best_prediction = get_predictions(model, dataloaders['test'],
params)
with open(os.path.join(args.model_dir, "best_test.pk"), 'wb') as f:
pickle.dump(best_prediction, f)
params.cuda = torch.cuda.is_available() # use GPU is available
# Set the random seed for reproducible experiments
torch.manual_seed(230)
if params.cuda: torch.cuda.manual_seed(230)
# Get the logger
utils.set_logger(os.path.join(args.model_dir, 'analysis.log'))
# Create the input data pipeline
logging.info("Loading the dataset...")
# fetch dataloaders
# train_dl = data_loader.fetch_dataloader('train', params)
# dev_dl = data_loader.fetch_dataloader('dev', params)
dataloader = data_loader.fetch_dataloader(args.dataset, params)
logging.info("- done.")
# Define the model graph
model = resnet.ResNet18().cuda() if params.cuda else resnet.ResNet18()
# fetch loss function and metrics
metrics = resnet.metrics
logging.info("Starting analysis...")
# Reload weights from the saved file
utils.load_checkpoint(os.path.join(args.model_dir, args.restore_file + '.pth.tar'), model)
# Evaluate and analyze
# Set the random seed for reproducible experiments
random.seed(230)
torch.manual_seed(230)
if params.cuda: torch.cuda.manual_seed(230)
# Set the logger
utils.set_logger(os.path.join(args.model_dir, 'train.log')) #
# Create the input data pipeline
logging.info("Loading the datasets...")
# fetch dataloaders, considering full-set vs. sub-set scenarios
if params.subset_percent < 1.0:
train_dl = data_loader.fetch_subset_dataloader('train', params)
else:
train_dl = data_loader.fetch_dataloader('train', params, os.path.join(args.data_dir))
dev_dl = data_loader.fetch_dataloader('dev', params, os.path.join(args.data_dir))
logging.info("- done.")
"""Based on the model_version, determine model/optimizer and KD training mode
WideResNet and DenseNet were trained on multi-GPU; need to specify a dummy
nn.DataParallel module to correctly load the model parameters
"""
if args.model_student == '3CNN':
model = net.Net_3CNN(params).cuda() if params.cuda else net.Net(params)
print("Model student 3CNN is selected")
elif args.model_student == '5CNN':
model = net.Net_5CNN(params).cuda() if params.cuda else net.Net(params)
print("Model student 5CNN is selected")
import model.net as net
import model.data_loader as data_loader
import numpy as np
import torch.nn as nn
import torch
if __name__ == '__main__':
test_loader = data_loader.fetch_dataloader('/scidata/fruits-360/Test',
batch_size=128)
device = torch.device('cuda:1' if torch.cuda.is_available() else 'cpu')
model = net.Net()
model.load_state_dict(torch.load("model.pth"))
model.to(device)
model.eval()
correct, total = 0, 0
with torch.no_grad():
for images, labels in test_loader:
images, labels = images.to(device), labels.to(device)
outputs = model(images)
_, predicted = torch.max(outputs.data, 1)
total += labels.size(0)
correct += (predicted == labels).sum().item()
print('Accuracy on test data: {:.4f} %'.format(100 * correct / total))
if torch.cuda.is_available(): device = "cuda:0"
# Set the random seed for reproducible experiments
torch.manual_seed(230)
if device == "cuda:0": torch.cuda.manual_seed(230)
# Set the logger
utils.set_logger(os.path.join(model_dir, 'train.log'))
# Define the model and optimizer
crnn_model = crnn.CRNN(128).cuda() if device == "cuda:0" else crnn.CRNN(128)
optimizer = optim.Adam(crnn_model.parameters(), lr=lr, betas=(0.5, 0.999))
# fetch loss function and metrics
loss_fn = crnn.loss_fn
# Create the input data pipeline
logging.info("Loading the datasets...")
# fetch dataloaders
dataloaders = data_loader.fetch_dataloader(['train', 'val', 'test'], data_dir, batch_size)
train_dl = dataloaders['train']
val_dl = dataloaders['val']
test_dl = dataloaders['test']
logging.info("- done.")
# Train the model
logging.info("Starting training for {} epoch(s)".format(epochs))
train_and_evaluate(crnn_model, train_dl, val_dl, optimizer, loss_fn, model_dir, epochs)
json_path = os.path.join(args.model_dir, 'params.json')
assert os.path.isfile(
json_path), "No json configuration file found at {}".format(json_path)
params = utils.Params(json_path)
params.cuda = torch.cuda.is_available()
torch.manual_seed(230)
if params.cuda:
torch.cuda.manual_seed(230)
utils.set_logger(os.path.join(args.model_dir, 'train.log'))
logging.info("Loading the datasets...")
dataloader = data_loader.fetch_dataloader(['train', 'val'], args.data_dir, args.mask_dir, args.dataset_dir, params)
train_dl = dataloader['train']
val_dl = dataloader['val']
logging.info("-done")
model = net.FCN(20+1).cuda() if params.cuda else net.FCN(20+1)
optimizer = optim.Adam(model.parameters(), lr=params.learning_rate)
loss_fn = net.loss_fn
metrics = net.metrics
logging.info("Starting training for {} epoch(s)".format(params.num_epochs))
train_and_evaluate(model, train_dl, val_dl, optimizer, loss_fn, metrics, params, args.model_dir, args.restore_file)
# use GPU if available
params.cuda = torch.cuda.is_available() # use GPU is available
# Set the random seed for reproducible experiments
torch.manual_seed(230)
if params.cuda: torch.cuda.manual_seed(230)
# Get the logger
utils.set_logger(os.path.join(args.model_dir, 'evaluate.log'))
# Create the input data pipeline
logging.info("Creating the dataset...")
# fetch dataloaders
dataloaders = data_loader.fetch_dataloader(['test'], args.data_dir, params)
test_dl = dataloaders['test']
logging.info("- done.")
# Define the model
model = net.Net(params).cuda() if params.cuda else net.Net(params)
loss_fn = net.loss_fn
metrics = net.metrics
logging.info("Starting evaluation")
# Reload weights from the saved file
utils.load_checkpoint(os.path.join(args.model_dir, args.restore_file + '.pth.tar'), model)
loss = loss_fn(result, data.x, data.y, data.batch)
loss.backward()
optimizer.step()
# update the average loss
loss_avg_arr.append(loss.item())
loss_avg.update(loss.item())
t.set_postfix(loss='{:05.3f}'.format(loss_avg()))
t.update()
scheduler.step(np.mean(loss_avg_arr))
print('Training epoch: {:02d}, MSE: {:.4f}'.format(epoch, np.mean(loss_avg_arr)))
if __name__ == '__main__':
args = parser.parse_args()
dataloaders = data_loader.fetch_dataloader(data_dir=osp.join(os.environ['PWD'],'data'),
batch_size=30,
validation_split=.1)
train_dl = dataloaders['train']
test_dl = dataloaders['test']
#model = net.Net().to('cuda')
#model = torch.jit.script(net.Net(7, 3)).to('cuda') # [px, py, pt, eta, d0, dz, mass], [pdgid, charge, fromPV]
model = net.Net(8, 3).to('cuda')
#optimizer = torch.optim.Adam(model.parameters(), lr=0.001, weight_decay=5e-3)
optimizer = torch.optim.AdamW(model.parameters(),lr=0.001)
scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer, factor=0.5, patience=500, threshold=0.05)
first_epoch = 0
best_validation_loss = 10e7
deltaR = 0.4
loss_fn = net.loss_fn
import model.net as net
import model.data_loader as data_loader
from preproc import *
from util import *
from torch import FloatTensor
from tqdm import tqdm
torch.manual_seed(0)
text = open("data/train.txt", "r").read()
sent = text.split('\n')
corp = CorpusPreprocessor(text)
train_loader = data_loader.fetch_dataloader(sent, corp)
model = net.net(n_letters, 256, 3, 2, 100)
criterion = torch.nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(), lr=1e-3)
device = torch.device('cuda:1' if torch.cuda.is_available() else 'cpu')
model = model.to(device)
for epoch in range(10):
losss = 0.0
correct, total = 0, 0
for i, (x, z, y) in enumerate(tqdm(train_loader)):
x, y, z = sentToTensor(x[0]).to(device), y.to(device), lineToTensor(
z[0]).to(device)
optimizer.zero_grad()
outputs = model(x, z)
loss = criterion(outputs, y)
losss += loss
loss.backward()
def fetch_train_batch(datadir, params):
""" fetch a random batch from the trainset """
dl = data_loader.fetch_dataloader(['train'], datadir, params)
return iter(dl['train']).next()
'small_' if arguments.small else
'') + arguments.dataset_type + '_features_and_labels.txt'
features_file_path = os.path.join(arguments.features_directory,
features_file_name)
# Extract feature vectors and write out to user-specified file (if such file does not yet exist)
if os.path.isfile(features_file_path):
logging.info('Features file detected; skipping feature extraction')
else:
logging.info('Features file not detected; now extracting features...')
# Create data loader for the revelant part (train, val, or test) of the dataset
logging.info('Loading ' + ('small ' if arguments.small else '') +
arguments.dataset_type + ' dataset...')
train_data_loader = data_loader.fetch_dataloader(
[arguments.dataset_type], arguments.data_directory, parameters,
arguments.small)[arguments.dataset_type]
logging.info('...done.')
# Configure model
model = net.DenseNet169(parameters, return_features=True)
if parameters.cuda: model = model.cuda()
# Load weights from trained model
utils.load_checkpoint(
os.path.join(arguments.model_directory,
arguments.restore_file + '.pth.tar'), model)
extract_feature_vectors(model, train_data_loader, parameters,
features_file_path)
logging.info('...done.')
params.cuda = torch.cuda.is_available() # use GPU is available
# Set the random seed for reproducible experiments
torch.manual_seed(230)
if params.cuda: torch.cuda.manual_seed(230)
# Get the logger
utils.set_logger(os.path.join(args.model_dir, 'analysis.log'))
# Create the input data pipeline
logging.info("Loading the dataset...")
# fetch dataloaders
# train_dl = data_loader.fetch_dataloader('train', params)
# dev_dl = data_loader.fetch_dataloader('dev', params)
dataloader = data_loader.fetch_dataloader(args.dataset, params)
logging.info("- done.")
# Define the model graph
model = resnet.ResNet18().cuda() if params.cuda else resnet.ResNet18()
# fetch loss function and metrics
metrics = resnet.metrics
logging.info("Starting analysis...")
# Reload weights from the saved file
utils.load_checkpoint(os.path.join(args.model_dir, args.restore_file + '.pth.tar'), model)
# Evaluate and analyze
