def setUpClass(cls):
super(TestAlgorithms, cls).setUpClass()
cls.model = _create_xor_model()
cls.model.to(cls.device)
min_eval_config = EvalConfig(128)
min_optim_config = OptimConfig(100, Adam, {}, None, None, min_eval_config)
cls.minima = [find_minimum(cls.model, min_optim_config) for _ in range(2)]
def test_long_run(self):
eggcarton = Eggcarton(2)
model = ModelWrapper(eggcarton)
minima = [find_minimum(model, OptimConfig(1000, SGD, {"lr": 0.1}, None, None, None)) for _ in range(2)]
neb_optim_config = OptimConfig(1000, SGD, {"lr": 0.1}, None, None, None)
neb_config = NEBConfig(float("inf"), 1e-5, equal, {"count": 20}, 1, neb_optim_config)
neb({
"path_coords": torch.cat([m["coords"].view(1, -1) for m in minima]),
"target_distances": torch.ones(1)
}, model, neb_config)
def main():
parser = ArgumentParser()
parser.add_argument("project_directory", nargs=1)
parser.add_argument("config_file", nargs=1)
parser.add_argument("--no-backup", default=False, action="store_true")
args = parser.parse_args()
project_directory = args.project_directory[0]
config_file = args.config_file[0]
graph_path, project_config_path = setup_project(config_file,
project_directory)
model, minima_count, min_config, lex_config = read_config_file(
project_config_path)
# Setup Logger
root_logger = getLogger()
root_logger.setLevel(INFO)
root_logger.addHandler(StreamHandler(sys.stdout))
root_logger.addHandler(
FileHandler(join(project_directory, "exploration.log")))
# === Create/load graph ===
if isfile(graph_path):
if not args.no_backup:
root_logger.info("Copying current 'graph.p' to backup file.")
copyfile(
graph_path,
graph_path.replace(".p", f"_bak{strftime('%Y%m%d-%H%M')}.p"))
else:
root_logger.info(
"Not creating a backup of 'graph.p' because of user request.")
graph = repair_graph(load_pickle_graph(graph_path), model)
else:
graph = MultiGraph()
# Call this after every optmisiation
def save_callback():
store_pickle_graph(graph, graph_path)
# === Ensure the specified number of minima ===
for _ in pbar(range(len(graph.nodes), minima_count), "Finding minima"):
minimum_data = find_minimum(model, min_config)
graph.add_node(
max(graph.nodes) + 1 if len(graph.nodes) > 0 else 1,
**move_to(minimum_data, "cpu"))
save_callback()
# === Connect minima ===
landscape_exploration(graph, model, lex_config, callback=save_callback)
def test_dataset_generation(self):
transform = Compose([Pad(2), ToTensor()])
train_mnist = MNIST(join(dirname(__file__), "tmp/mnist"),
True,
transform,
download=True)
input_size = train_mnist[0][0].shape
number_of_classes = 10
resnet = ResNet(20, input_size, number_of_classes)
# Find a minimiser for the network
optim_wrapper = ModelWrapper(
DataModel(CompareModel(resnet, NLLLoss()), {"train": train_mnist}))
optim_wrapper.to("cuda")
optim_config = OptimConfig(100, SGD, {"lr": 0.1}, None, None,
EvalConfig(128))
minimum = find_minimum(optim_wrapper, optim_config)
optim_wrapper.set_coords_no_grad(minimum["coords"])
nim = NetworkInputModel(resnet, input_size, 0)
nim.cuda()
resnet.cuda()
dataset = nim.generate_dataset(train_mnist, number_of_classes)
self.assertEqual(len(dataset), 100)