def main():
# Set the random seed for reproducible experiments
torch.manual_seed(230)
parser = argparse.ArgumentParser()
parser.add_argument('--data_dir', help="Directory containing the dataset")
parser.add_argument('--model_dir', help="Directory containing params.json")
parser.add_argument('--params', help='Directory containing params.json')
parser.add_argument('--restore_file',
default='best',
help="name of the file in --model_dir \
containing weights to load")
params = utils.Params(args.params)
# Get the logger
utils.set_logger(os.path.join(params.model_dir, 'evaluate.log'))
# Create the input data pipeline
logging.info("Creating the dataset...")
test_dataset = dataset(file_path=params.metadata_file,
split="Test",
classes=params.classes)
test_loader = DataLoader(dataset=test_dataset,
batch_size=params.batch_size,
shuffle=True,
num_workers=8)
logging.info("- done.")
# Define the model and optimizer
if model != "Inception":
net = importlib.import_module("features.models.{}".format(
params.model))
model = net.Net()
inception = False
else:
model = models.inception_v3(pretrained=False)
model.fc = nn.Linear(2048, num_classes)
model.AuxLogits.fc = nn.Linear(768, 1)
inception = True
model.cuda()
metrics_save = metrics_code.metrics_save
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, test_loader, metrics_save, experiment,
inception)
save_path = os.path.join(model_dir,
"metrics_test_{}.json".format(restore_file))
utils.save_dict_to_json(test_metrics, save_path)
def __init__(self, config="./config/reader.json"):
params = utils.Params(config)
self._path = params.catalogpath
self.data = {
"catalog":
fits.open(self._path + params.catalogName,
mode='readonly',
memmap=True,
lazy_load_hdus=True)[1].data,
"members":
fits.open(self._path + params.memberName,
mode='readonly',
memmap=True,
lazy_load_hdus=True)[1].data,
"areaZ":
fits.open(self._path + params.areaZ,
mode='readonly',
memmap=True,
lazy_load_hdus=True)[1].data,
"random":
fits.open(self._path + params.random,
mode='readonly',
memmap=True,
lazy_load_hdus=True)[1].data
}
self.quantities = {}
for item in self.data.keys():
self.quantities[item] = self.data[item].names
def __init__(self):
params = utils.Params(_json_file)
self.model = HCN.HCN(**params.model_args)
self.optimizer = optim.Adam(filter(lambda p: p.requires_grad, self.model.parameters()), lr=params.lr, betas=(0.9, 0.999), eps=1e-8,
weight_decay=params.weight_decay)
out_channel = params.model_args['out_channel']
window_size = params.model_args['window_size']
self.model.fc7 = nn.Sequential(
nn.Linear((out_channel * 4)*(window_size//16)*(window_size//16), 256),
nn.ReLU(),
nn.Dropout2d(p=0.5))
self.model.fc8 = nn.Linear(256, 12)
checkpoint = utils.load_checkpoint(_chkp_path, self.model, self.optimizer)
self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
self.model = self.model.to(self.device)
self.model.eval()
# Load the parameters from json file
args = parser.parse_args()
experiment_path = os.path.join(args.model_dir, 'experiments',
args.dataset_name,
args.model_name + args.num)
if not os.path.isdir(experiment_path):
os.makedirs(experiment_path)
json_file = os.path.join(experiment_path, 'params.json')
if not os.path.isfile(json_file):
with open(json_file, 'w') as f:
print("No json configuration file found at {}".format(json_file))
f.close()
print('successfully made file: {}'.format(json_file))
params = utils.Params(json_file)
if args.load:
print("args.load=", args.load)
if args.load_model:
params.restore_file = args.load_model
else:
params.restore_file = experiment_path + '/checkpoint/best.pth.tar'
params.dataset_dir = args.dataset_dir
params.dataset_name = args.dataset_name
params.model_version = args.model_name
params.experiment_path = experiment_path
params.mode = args.mode
if params.gpu_id >= -1:
params.cuda = True
metrics_string = " ; ".join("{}: {:05.3f}".format(k, v)
for k, v in metrics_mean.items())
logging.info("- Eval metrics : " + metrics_string)
return metrics_mean
if __name__ == '__main__':
"""
Evaluate the model on the test set.
"""
# Load the parameters from json file
args = parser.parse_args()
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(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...")
logging.info("-"*20)
early_stopping(val_loss_source)
if early_stopping.early_stop:
logging.info("Early stopping")
break
if __name__ == '__main__':
# Load the parameters from json file
args = parser.parse_args()
json_path = os.path.join(args.model_dir_source, 'params.json')
assert os.path.isfile(
json_path), "No json configuration file found at {}".format(json_path)
params_source = utils.Params(json_path)
json_path = os.path.join(args.model_dir_target, 'params.json')
assert os.path.isfile(
json_path), "No json configuration file found at {}".format(json_path)
params_target = utils.Params(json_path)
json_path = os.path.join(args.model_dir_transfer, 'params.json')
assert os.path.isfile(
json_path), "No json configuration file found at {}".format(json_path)
params_transfer = utils.Params(json_path)
ckpt_filename = "checkpoint.tar"
best_ckpt_filename = "model_best.tar"
writer = SummaryWriter(args.tensorboard_dir)
# Clear terminal with ANSI <ESC> c "\033c"
# print("\033c", end="") # (Doesn't fully clear screen on PC)
print("\033[H\033[2J", end="")
# Initialize paths to json parameters
data_path = Path().absolute() / "data"
model_path = Path().absolute() / "experiments/train/"
pretrain_path = Path().absolute() / "experiments/pretrain/"
json_path = model_path / "params.json"
json_path_pretrain = pretrain_path / "params.json"
# Load params json
assert json_path.is_file(
), f"\n\nERROR: No params.json file found at {json_path}\n"
params = utils.Params(json_path)
pretrain_params = utils.Params(json_path_pretrain)
# If GPU, write to params file
params.cuda = torch.cuda.is_available()
# Set random seed
torch.manual_seed(42)
if params.cuda:
torch.cuda.manual_seed(42)
# Update num_workers to 2 if running on GPU
params.num_workers = 2
def train(dataloader,
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--params', help='Directory containing params.json')
args = parser.parse_args()
params = utils.Params(args.params)
# pull out lr and decay for easy access
learning_rate = params.learning_rate
decay = params.decay
#Set the random seed for reproducible experiments
torch.manual_seed(230)
experiment = Experiment(api_key=params.comet_api,
project_name=params.comet_name,
workspace="ayeaton")
# Set the logger
utils.set_logger(os.path.join(params.implementation_dir, 'train.log'))
logging.info(experiment)
log_params = {
"learning_rate": learning_rate,
"decay": decay,
"batch_size": params.batch_size,
"dropout_rate": params.dropout_rate,
"model": params.model,
"optimizer": params.optimizer,
"loss_func": params.loss_func,
"classes": params.classes,
"metadata_file": params.metadata_file,
"model_dir": params.model_dir,
"implementation_dir": params.implementation_dir
}
experiment.log_parameters(log_params)
# Create the input data pipeline
logging.info("Loading the datasets...")
# get data
train_dataset = dataset(file_path=params.metadata_file,
split="Train",
classes=params.classes)
train_loader = DataLoader(dataset=train_dataset,
batch_size=params.batch_size,
shuffle=True,
num_workers=8)
val_dataset = dataset(file_path=params.metadata_file,
split="Val",
classes=params.classes)
val_loader = DataLoader(dataset=val_dataset,
batch_size=params.batch_size,
shuffle=True,
num_workers=8)
logging.info("- done.")
# Define the model and optimizer
if params.model != "Inception":
net = importlib.import_module("models.{}".format(params.model))
model = net.Net()
inception = False
else:
model = models.inception_v3(pretrained=False)
model.fc = nn.Linear(2048, len(params.classes))
model.AuxLogits.fc = nn.Linear(768, 1)
inception = True
logging.info("Model -- {}".format(repr(model)))
model.cuda()
# fetch loss function and metrics
metrics_save = metrics_code.metrics_save
# Train the model
logging.info("Starting training for {} epoch(s)".format(params.num_epochs))
train_and_evaluate(model, train_loader, val_loader, metrics_save,
params.implementation_dir, params.num_epochs,
params.loss_func, params.optimizer, learning_rate,
decay, params.save_summary_steps, experiment, inception)
