def do_help(self):
""" Show this help """
keywords = [cmd[3:] for cmd in self._cmds if cmd != "do_help"]
fprint(
"%s: %s" %
(os.path.basename(self.prog_name), ", ".join("--%s" % kw
for kw in keywords)))
def help_cmd(cmd):
""" helper """
keyword = cmd[3:]
func, arg_names = self._func_args(cmd)
argc = len(arg_names)
doc = func.__doc__.strip()
if argc == 1:
fprint("--%s: %s (takes 1 argument: %s)" %
(keyword, doc, arg_names[0]))
elif argc > 1:
fprint("--%s: %s (takes %s arguments: %s)" %
(keyword, doc, argc, ", ".join(arg_names)))
else:
fprint("--%s: %s" % (keyword, doc))
for cmd in self._cmds:
if cmd != "do_help":
help_cmd(cmd)
fprint("")
help_cmd("do_help")
def test_model(model, data_loaders, args):
fprint('\nTESTING...', args)
was_training = model.training # store mode
model.eval() # run in evaluation mode
with torch.no_grad():
phase_corrects = 0
phase_preds = torch.LongTensor()
phase_category_ids = torch.LongTensor()
for inputs, category_ids in data_loaders['test']:
inputs = inputs.to(torch.device(args.device))
category_ids = category_ids.to(torch.device(args.device))
outputs = model(inputs)
_, preds = torch.max(outputs, 1)
batch_corrects = torch.sum(preds == category_ids.data)
phase_corrects += batch_corrects
phase_preds = torch.cat((phase_preds, preds), 0)
phase_category_ids = torch.cat((phase_category_ids, category_ids),
0)
dataset = data_loaders['test'].dataset
acc, f1 = calculate_metrics(phase_preds, phase_category_ids)
fprint(
'{}/{} predictions are correct -> Test acc: {:.6f} f1: {:.6f}\n'.
format(phase_corrects, len(dataset), acc, f1), args)
model.train(mode=was_training) # reinstate the previous mode
return acc
def execute(self, argv):
""" interpret the args """
args = argv or ["help"]
while args:
cmd = args.pop(0)
if cmd.startswith("--"):
cmd = cmd[2:]
fname = "do_%s" % cmd
if fname in self._cmds:
func, arg_names = self._func_args(fname)
if len(arg_names) <= len(args):
cmd_args = [args.pop(0) for _ in arg_names]
self.status = func(*cmd_args) or 0
else:
fprint(
"Not enough arguments given for command %s (got %s, need %s)"
% (cmd, len(args), len(arg_names)),
file=sys.stderr)
self.status = -1
return
else:
fprint("Command %s is not a known command!" % cmd,
file=sys.stderr)
self.do_help()
self.status = -1
return
def do_configs(self, name):
""" transform the named configuration property into gcc-like -Dkey=val list """
for _name, item in self._named_items(".//configuration/property",
name):
if item.text:
defs = [
"-D%s" % define.strip() for define in item.text.split(" ")
if define.strip()
]
fprint(" ".join(defs))
def do_pretty(self, fname):
""" pretty print the in-memry XML tree to output fname ("-" means stdout) """
lines = ET.tostringlist(self.root)
dom = xml.dom.minidom.parseString("".join(l for l in lines
if l and l.strip()))
pretty_xml = dom.toprettyxml(indent=" ",
encoding=self.xml_pi.get(
"encoding", None))
if fname == "-":
fprint(pretty_xml, end="")
else:
with open_for_writing(fname, "b") as fob:
fprint(pretty_xml, end="", file=fob)
def help_cmd(cmd):
""" helper """
keyword = cmd[3:]
func, arg_names = self._func_args(cmd)
argc = len(arg_names)
doc = func.__doc__.strip()
if argc == 1:
fprint("--%s: %s (takes 1 argument: %s)" %
(keyword, doc, arg_names[0]))
elif argc > 1:
fprint("--%s: %s (takes %s arguments: %s)" %
(keyword, doc, argc, ", ".join(arg_names)))
else:
fprint("--%s: %s" % (keyword, doc))
def main():
args = load_args()
init_random_seeds(args.seed)
# EXPORT ARGS AS JSON
json_path = export_args(args) # write to file
json_args = load_json_args(json_path) # read from file
fprint("RUNNING ARGS:\n{}\n".format(json.dumps(json_args, indent=4)), args)
fprint("Python Version: {}".format(platform.python_version()), args)
fprint("PyTorch Version: {}".format(torch.__version__), args)
fprint(
"Torchvision Version: {}".format(
torchvision.__version__.split('a')[0]), args)
# Get data loaders
data_loaders = get_data_loaders(args)
# Initialize model
model, params_to_update = initialize_model(is_pretrained=args.pretrained)
fprint("\nARCHITECTURE:\n{}\n".format(model), args)
for name, param in model.named_parameters():
fprint("{:25} requires_grad = {}".format(name, param.requires_grad),
args)
# Send the model to CPU or GPU
model = model.to(torch.device(args.device))
# Setup the optimizer
if args.optimizer == 'sgdm':
optimizer = optim.SGD(params_to_update,
lr=args.lr,
weight_decay=args.weight_decay,
momentum=0.9)
elif args.optimizer == 'adam':
optimizer = optim.AdamW(params_to_update,
lr=args.lr,
weight_decay=args.weight_decay)
# Setup the loss function
criterion = torch.nn.CrossEntropyLoss()
# Train and evaluate
model, optimizer = train_model(model, data_loaders, criterion, optimizer,
args)
# Test
test_model(model, data_loaders, args)
# Generate plots:
generate_plots(json_path)
def train_model(model, data_loaders, criterion, optimizer, args):
# create states df and csv file
stats_df = pd.DataFrame(columns=[
'epoch', 'train_loss', 'train_acc', 'train_f1', 'val_loss', 'val_acc',
'val_f1'
])
sub_dump_dir = get_sub_dump_dir(args)
stats_path = os.path.join(sub_dump_dir, 'stats.csv')
stats_df.to_csv(stats_path, sep=',',
index=False) # write loss and acc values
fprint('\nCreated stats file\t-> {}'.format(stats_path), args)
fprint('\nTRAINING {} EPOCHS...\n'.format(args.epochs), args)
since = time.time()
# initialize best values
best_model_state_dict = copy.deepcopy(model.state_dict())
best_opt_state_dict = copy.deepcopy(optimizer.state_dict())
best_loss = 999999.9
best_acc = 0.0
best_epoch = 0
for epoch in range(args.epochs):
# Each epoch has a training and validation phase
for phase in ['train', 'val']:
if phase == 'train':
model.train() # Set model to training mode
else:
model.eval() # Set model to evaluate mode
phase_loss = 0.0
phase_corrects = 0
phase_preds = torch.LongTensor()
phase_category_ids = torch.LongTensor()
# Iterate over data
for inputs, category_ids in data_loaders[phase]:
inputs = inputs.to(torch.device(args.device))
category_ids = category_ids.to(torch.device(args.device))
# zero the parameter gradients
optimizer.zero_grad()
# forward
# track history if only in train
with torch.set_grad_enabled(phase == 'train'):
# Get model outputs and calculate loss
outputs = model(inputs)
loss = criterion(outputs, category_ids)
_, preds = torch.max(outputs, 1)
# backward + optimize only if in training phase
if phase == 'train':
loss.backward()
optimizer.step()
# stats
batch_loss = loss.item() * inputs.size(0)
batch_corrects = torch.sum(preds == category_ids.data)
phase_loss += batch_loss
phase_corrects += batch_corrects
phase_preds = torch.cat((phase_preds, preds), 0)
phase_category_ids = torch.cat(
(phase_category_ids, category_ids), 0)
epoch_loss = phase_loss / len(data_loaders[phase].dataset)
epoch_acc, epoch_f1 = calculate_metrics(phase_preds,
phase_category_ids)
stats_df.at[0, 'epoch'] = epoch
stats_df.at[0, phase + '_loss'] = round(epoch_loss, 6)
stats_df.at[0, phase + '_acc'] = round(epoch_acc, 6)
stats_df.at[0, phase + '_f1'] = round(epoch_f1, 6)
# define the new bests
if phase == 'val' and epoch_acc > best_acc:
best_acc = epoch_acc
best_model_state_dict = copy.deepcopy(model.state_dict())
best_opt_state_dict = copy.deepcopy(optimizer.state_dict())
best_loss = copy.deepcopy(epoch_loss)
best_epoch = epoch
# append epoch stats to file
fprint(
stats_df.to_string(index=False,
header=(epoch == 0),
col_space=10,
justify='right'), args)
stats_df.to_csv(stats_path, mode='a', header=False, index=False)
time_elapsed = time.time() - since
fprint(
'\nTraining completed in {:.0f}m {:.0f}s\n'.format(
time_elapsed // 60, time_elapsed % 60), args)
# reload best model weights and best optimizer variables
model.load_state_dict(best_model_state_dict)
optimizer.load_state_dict(best_opt_state_dict)
# save best checkpoint
if not os.path.exists(cfg.MODEL_DIR):
os.makedirs(cfg.MODEL_DIR)
cp_path = os.path.join(
cfg.MODEL_DIR,
'{}_{}_{:.6f}.pth'.format('pt' if args.pretrained else 'fs',
args.t_start, best_acc))
if args.save:
torch.save(
{
'epoch': best_epoch,
'model_state_dict': best_model_state_dict,
'optimizer_state_dict': best_opt_state_dict,
'loss': best_loss,
'acc': best_acc
}, cp_path)
fprint('Saved best checkpoint\t-> {}'.format(cp_path), args)
return model, optimizer
def logPrint(*args, **kwargs):
return
fprint(*args, **kwargs)
def do_file_paths(self):
""" get path attributes of file elements (can be filtered further """
fprint("\n".join(XPathCommand._file_paths(self.tree, self.filters)))
def do_devkitgroup(self):
""" get devkitgroup value from a project """
item = next(self._items(".//configuration/", select="devkitGroup"))
if item is not None:
fprint(item.text)
def do_folder(self, name):
""" get the named folder paths """
for path in self._folder(name):
fprint(path)
observation_number = observation_number + 1
for observation in observations:
row = [0, 0] + [0] * number_of_set_ups
if observation.type_ == 'distance':
distance = observation.value
y = -(observation.to_point.y - observation.from_point.y) / distance
x = -(observation.to_point.x - observation.from_point.x) / distance
row[0], row[1] = y, x
A = numpy.vstack([A, row])
observed = distance
calculated = get_distance(observation.to_point, observation.from_point)
oc = observed - calculated
l = numpy.vstack([l, oc])
X = ((A.T) * P * A).I * (A.T) * P * l
V = (A * X) - l
AtPA = A.T * P * A
AtPL = A.T * P * l
variance_factor = (V.T * V) / (n - (2 + number_of_set_ups) )
sigma_X = float(variance_factor) * (AtPA).I
sigma_L = float(variance_factor) * A * (AtPA).I * A.T
fprint (str(sigma_X), 'sigma_x.txt')
fprint (str(sigma_L), 'sigma_l.txt')
fprint (str(A), 'A.txt')
fprint (str(V), 'V.txt')
fprint (str(l), 'l.txt')
fprint (str(variance_factor), 'variance_factor.txt')
fprint (str(X), 'X.txt')
