def __init__(self, args):
self.task = args.task
gnn_type = args.type
self.depth = args.depth
num_layers = self.depth if args.num_layers is None else args.num_layers
self.dim = args.dim
self.unroll = args.unroll
self.train_fraction = args.train_fraction
self.max_epochs = args.max_epochs
self.batch_size = args.batch_size
self.accum_grad = args.accum_grad
self.eval_every = args.eval_every
self.loader_workers = args.loader_workers
self.device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
self.stopping_criterion = args.stop
self.patience = args.patience
seed = 11
torch.manual_seed(seed)
np.random.seed(seed)
random.seed(seed)
self.X_train, self.X_test, dim0, out_dim, self.criterion = \
self.task.get_dataset(self.depth, self.train_fraction)
self.model = GraphModel(gnn_type=gnn_type, num_layers=num_layers, dim0=dim0, h_dim=self.dim, out_dim=out_dim,
last_layer_fully_adjacent=args.last_layer_fully_adjacent, unroll=args.unroll,
layer_norm=not args.no_layer_norm,
use_activation=not args.no_activation,
use_residual=not args.no_residual
).to(self.device)
print(f'Starting experiment')
self.print_args(args)
print(f'Training examples: {len(self.X_train)}, test examples: {len(self.X_test)}')
def set_graph_model(self, view_parameter: ViewNavigationParameter) -> None:
if view_parameter.graph_canvas_state == GraphCanvasState.new:
self.graph_model = GraphModel()
elif view_parameter.graph_canvas_state == GraphCanvasState.saved:
self.graph_model = self.graph_app_service.get_graph_model(
view_parameter.graph_id)
self.draw_graph(self.graph_model)
def test_update_graph(self):
# prepare
graph_repository_mock = GraphRepositoryMock()
graph_business_service = GraphBusinessService(graph_repository_mock)
graph_model = GraphModel()
graph_model.graph_id = graph_repository_mock.mock_graph_id1
graph_model.graph_name = graph_repository_mock.mock_updated_graph_name1
# act
result_graph_model = graph_business_service.update_graph(graph_model)
# assert type graph_model
self.assertEqual(type(result_graph_model), GraphModel)
# assert name of object is the same
self.assertEqual(result_graph_model.graph_name,
graph_repository_mock.mock_updated_graph_name1)
# assert id is the same
self.assertEqual(result_graph_model.graph_id,
graph_repository_mock.mock_graph_id1)
def test_insert_graph(self):
# prepare
graph_repository_mock = GraphRepositoryMock()
graph_model = GraphModel()
graph_model.graph_name = graph_repository_mock.mock_graph_name1
graph_business_service = GraphBusinessService(graph_repository_mock)
# act
result_graph_model = graph_business_service.insert_graph(graph_model)
# assert
# assert id of object is the same
self.assertEqual(result_graph_model.graph_id,
graph_repository_mock.mock_graph_id1)
# assert it is the same object/ instance of class
self.assertEqual(result_graph_model, graph_model)
# assert name of object is same
self.assertEqual(result_graph_model.graph_name,
graph_repository_mock.mock_graph_name1)
def test_save_graph_model(self):
# prepare
graph_business_service_mock = GraphBusinessServiceMock()
node_business_service_mock = NodeBusinessServiceMock()
edge_business_service_mock = EdgeBusinessServiceMock()
graph_model = GraphModel()
graph_application_service = GraphApplicationService(
graph_business_service_mock, node_business_service_mock,
edge_business_service_mock)
# act
# insert graph_model
graph_application_service.save_graph_model(graph_model)
# add nodes to graph.list_of_nodes
node1 = NodeModel()
node1.node_id = -1
node2 = NodeModel()
node2.node_id = -2
graph_model.list_of_nodes.append(node1)
graph_model.list_of_nodes.append(node2)
# add edges
edge1 = EdgeModel()
edge1.start_node_id = node1.node_id
edge1.end_node_id = node2.node_id
node1.start_edges.append(edge1)
node2.end_edges.append(edge1)
# insert node_models
graph_application_service.save_graph_model(graph_model)
# assert
self.assertEqual(graph_model.graph_id,
graph_business_service_mock.graph_model_id)
self.assertEqual(graph_model.list_of_nodes[0].node_id,
node_business_service_mock.node_id)
self.assertEqual(graph_model.list_of_nodes[0].start_edges[0].edge_id,
edge_business_service_mock.edge_id)
def insert_graph(self, graph_model: GraphModel) -> GraphModel:
graph_id = self.graph_repository.insert_graph(graph_model.graph_name)
graph_model.graph_id = graph_id
return graph_model
def insert_graph(self, graph_model: GraphModel) -> GraphModel:
graph_model.graph_id = self.graph_model_id
return graph_model
def get_graph_model(self, graph_id: int) -> GraphModel:
graph_model = GraphModel()
graph_model.graph_id = self.graph_model_id
return graph_model
def db_entity_to_graph_model(db_entity: tuple) -> GraphModel:
graph_model = GraphModel()
graph_model.graph_id = db_entity[0]
graph_model.graph_name = db_entity[1]
return graph_model
class Experiment():
def __init__(self, args):
self.task = args.task
gnn_type = args.type
self.depth = args.depth
num_layers = self.depth if args.num_layers is None else args.num_layers
self.dim = args.dim
self.unroll = args.unroll
self.train_fraction = args.train_fraction
self.max_epochs = args.max_epochs
self.batch_size = args.batch_size
self.accum_grad = args.accum_grad
self.eval_every = args.eval_every
self.loader_workers = args.loader_workers
self.device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
self.stopping_criterion = args.stop
self.patience = args.patience
seed = 11
torch.manual_seed(seed)
np.random.seed(seed)
random.seed(seed)
self.X_train, self.X_test, dim0, out_dim, self.criterion = \
self.task.get_dataset(self.depth, self.train_fraction)
self.model = GraphModel(gnn_type=gnn_type, num_layers=num_layers, dim0=dim0, h_dim=self.dim, out_dim=out_dim,
last_layer_fully_adjacent=args.last_layer_fully_adjacent, unroll=args.unroll,
layer_norm=not args.no_layer_norm,
use_activation=not args.no_activation,
use_residual=not args.no_residual
).to(self.device)
print(f'Starting experiment')
self.print_args(args)
print(f'Training examples: {len(self.X_train)}, test examples: {len(self.X_test)}')
def print_args(self, args):
if type(args) is AttrDict:
for key, value in args.items():
print(f"{key}: {value}")
else:
for arg in vars(args):
print(f"{arg}: {getattr(args, arg)}")
print()
def run(self):
optimizer = torch.optim.Adam(self.model.parameters(), lr=0.001)
scheduler = ReduceLROnPlateau(optimizer, mode='max', threshold_mode='abs', factor=0.5, patience=10)
print('Starting training')
best_test_acc = 0.0
best_train_acc = 0.0
best_epoch = 0
epochs_no_improve = 0
for epoch in range(1, (self.max_epochs // self.eval_every) + 1):
self.model.train()
loader = DataLoader(self.X_train * self.eval_every, batch_size=self.batch_size, shuffle=True,
pin_memory=True, num_workers=self.loader_workers)
total_loss = 0
total_num_examples = 0
train_correct = 0
optimizer.zero_grad()
for i, batch in enumerate(loader):
batch = batch.to(self.device)
out = self.model(batch)
loss = self.criterion(input=out, target=batch.y)
total_num_examples += batch.num_graphs
total_loss += (loss.item() * batch.num_graphs)
_, train_pred = out.max(dim=1)
train_correct += train_pred.eq(batch.y).sum().item()
loss = loss / self.accum_grad
loss.backward()
if (i + 1) % self.accum_grad == 0:
torch.nn.utils.clip_grad_norm_(self.model.parameters(), 1.0)
optimizer.step()
optimizer.zero_grad()
avg_training_loss = total_loss / total_num_examples
train_acc = train_correct / total_num_examples
scheduler.step(train_acc)
test_acc = self.eval()
cur_lr = [g["lr"] for g in optimizer.param_groups]
new_best_str = ''
stopping_threshold = 0.0001
stopping_value = 0
if self.stopping_criterion is STOP.TEST:
if test_acc > best_test_acc + stopping_threshold:
best_test_acc = test_acc
best_train_acc = train_acc
best_epoch = epoch
epochs_no_improve = 0
stopping_value = test_acc
new_best_str = ' (new best test)'
else:
epochs_no_improve += 1
elif self.stopping_criterion is STOP.TRAIN:
if train_acc > best_train_acc + stopping_threshold:
best_train_acc = train_acc
best_test_acc = test_acc
best_epoch = epoch
epochs_no_improve = 0
stopping_value = train_acc
new_best_str = ' (new best train)'
else:
epochs_no_improve += 1
print(
f'Epoch {epoch * self.eval_every}, LR: {cur_lr}: Train loss: {avg_training_loss:.7f}, Train acc: {train_acc:.4f}, Test accuracy: {test_acc:.4f}{new_best_str}')
if stopping_value == 1.0:
break
if epochs_no_improve >= self.patience:
print(
f'{self.patience} * {self.eval_every} epochs without {self.stopping_criterion} improvement, stopping. ')
break
print(f'Best train acc: {best_train_acc}, epoch: {best_epoch * self.eval_every}')
return best_train_acc, best_test_acc, best_epoch
def eval(self):
self.model.eval()
with torch.no_grad():
loader = DataLoader(self.X_test, batch_size=self.batch_size, shuffle=False,
pin_memory=True, num_workers=self.loader_workers)
total_correct = 0
total_examples = 0
for batch in loader:
batch = batch.to(self.device)
_, pred = self.model(batch).max(dim=1)
total_correct += pred.eq(batch.y).sum().item()
total_examples += batch.y.size(0)
acc = total_correct / total_examples
return acc