Common framework

Our framework BeGin contains the trainer managing the overall graph continual learning procudure, including preparing the dataloader, training, and validation. Therefore, users only have to implement novel parts of their methods.

According to the graph problems (e.g., node-, link-, and graph-level), codes of trainer users extend are different as follows:

• Node-level problems

• Link-level problems

• Graph-level problems

Then, the above three codes is inherited a base code as follows:

Note

In the framework, all task-specific trainers assumes that AdaptiveLinear is used as the classifier of the model. See here for the details of the module.

class BaseTrainer(model, scenario, optimizer_fn, loss_fn, device=None, **kwargs)

Base framework for implementing trainer module.

Parameters:

• model (torch.nn.Module) – Pytorch model for graph continual learning.

• scenario (ScenarioLoader) – The scenario module.

• x (optimizer_fn (lambda) – torch.optim.Optimizer): A generator function for optimizer.

• loss_fn – A loss function.

• device (str) – target GPU device.

• kwargs (dict, optional) – Keyword arguments to be passed to the trainer module.

Note

For instance, by kwargs, users can pass hyperparameters the implemented method needs or a scheduler function (torch.nn) for tranining. In addition, BaseTrainer supports benchmark = True and seed (int) to fix the random seed, and full_mode = True to additionally evaluate the joint (accum) model.

_evalWrapper(model, curr_batch, curr_stats)

The wrapper function for validation/test iteration. The main role of the function is to collect the returned dictionary of the processEvalItearation function to compute final stats for evalution at every epoch.

Parameters:

• model (torch.nn.Module) – the current trained model.

• curr_batch (object) – the data (or minibatch) for the current iteration.

• curr_stats (dict) – the dictionary to store the returned dictionaries.

_reduceEvalStats(curr_stats)

The helper function to reduce the returned stats during evaluation. The default behavior of the function is to compute average for each key in the returned dictionaries.

Parameters:

curr_stats (dict) – the dictionary containing the evaluation stats.

Returns:

A reduced dictionary containing the final evaluation outcomes.

_reduceTrainingStats(curr_stats)

The helper function to reduce the returned stats during training. The default behavior of the function is to compute average for each key in the returned dictionaries.

Parameters:

curr_stats (dict) – the dictionary containing the training stats.

Returns:

A reduced dictionary containing the final training outcomes.

_reset_model(target_model)

Reinitialize a model.

Parameters:

target_model (torch.nn.Module) – a model needed to re-initialize

_reset_optimizer(target_optimizer)

Reinitialize an optimizer.

Parameters:

target_model (torch.optim.Optimizer) – an optimizer needed to re-initialize

_trainWrapper(model, optimizer, curr_batch, curr_training_states, curr_stats)

The wrapper function for training iteration. The main role of the function is to collect the returned dictionary of the processTrainItearation function to compute final training stats at every epoch.

Parameters:

• model (torch.nn.Module) – the current trained model.

• optimizer (torch.optim.Optimizer) – the current optimizer function.

• curr_batch (object) – the data (or minibatch) for the current iteration.

• curr_training_states (dict) – the dictionary containing the current training states.

• curr_stats (dict) – the dictionary to store the returned dictionaries.

afterInference(results, model, optimizer, curr_batch, curr_training_states)

The event function to execute some processes right after the inference step (for training). We recommend performing backpropagation in this event function.

Parameters:

• results (dict) – the returned dictionary from the event function inference.

• model (torch.nn.Module) – the current trained model.

• optimizer (torch.optim.Optimizer) – the current optimizer function.

• curr_batch (object) – the data (or minibatch) for the current iteration.

• curr_training_states (dict) – the dictionary containing the current training states.

Returns:

A dictionary containing the information from the results.

beforeInference(model, optimizer, curr_batch, curr_training_states)

The event function to execute some processes right before inference (for training).

Parameters:

• model (torch.nn.Module) – the current trained model.

• optimizer (torch.optim.Optimizer) – the current optimizer function.

• curr_batch (object) – the data (or minibatch) for the current iteration.

• curr_training_states (dict) – the dictionary containing the current training states.

property curr_task

Returns: The index of a current task (from \(0\) to \(T-1\))

property incr_type

Returns: The incremental setting (e.g., task, class, domain, or time). The trainer retrieves the value from the given scenario loader.

inference(model, curr_batch, curr_training_states)

The event function to execute inference step.

Parameters:

• model (torch.nn.Module) – the current trained model.

• curr_batch (object) – the data (or minibatch) for the current iteration.

• curr_training_states (dict) – the dictionary containing the current training states.

Returns:

A dictionary containing the inference results, such as prediction result and loss.

initTrainingStates(scenario, model, optimizer)

The event function to initialize the dictionary for storing training states (i.e., intermedeiate results).

Parameters:

• scenario (begin.scenarios.common.BaseScenarioLoader) – the given ScenarioLoader to the trainer

• model (torch.nn.Module) – the given model to the trainer

• optmizer (torch.optim.Optimizer) – the optimizer generated from the given optimizer_fn

Returns:

Initialized training state (dict).

predictionFormat(results)

The helper function for formatting the prediction results before feeding the results to evaluator.

Parameters:

results (dict) – the dictionary containing the prediction results.

prepareLoader(curr_dataset, curr_training_states)

The event function to generate dataloaders from the given dataset for the current task.

Parameters:

• curr_dataset (object) – The dataset for the current task. Its type is dgl.graph for node-level and link-level problem, and dgl.data.DGLDataset for graph-level problem.

• curr_training_states (dict) – the dictionary containing the current training states.

Returns:

A tuple containing three dataloaders. The trainer considers the first dataloader, second dataloader, and third dataloader as dataloaders for training, validation, and test, respectively.

processAfterEachIteration(curr_model, curr_optimizer, curr_training_states, curr_iter_results)

The event function to execute some processes for every end of each epoch. Whether to continue training or not is determined by the return value of this function. If the returned value is False, the trainer stops training the current model in the current task.

Note

This function is called for every end of each epoch, and the event function processAfterTraining is called only when the learning on the current task has ended.

Parameters:

• curr_model (torch.nn.Module) – the current trained model.

• curr_optimizer (torch.optim.Optimizer) – the current optimizer function.

• curr_training_states (dict) – the dictionary containing the current training states.

• curr_iter_results (dict) – the dictionary containing the training/validation results of the current epoch.

Returns:

A boolean value. If the returned value is False, the trainer stops training the current model in the current task.

processAfterTraining(task_id, curr_dataset, curr_model, curr_optimizer, curr_training_states)

The event function to execute some processes after training the current task.

Note

The event function processAfterEachIteration is called for every end of each epoch, and this function is called only when the learning on the current task has ended.

Parameters:

• task_id (int) – the index of the current task.

• curr_dataset (object) – The dataset for the current task.

• curr_model (torch.nn.Module) – the current trained model.

• curr_optimizer (torch.optim.Optimizer) – the current optimizer function.

• curr_training_states (dict) – the dictionary containing the current training states.

processBeforeTraining(task_id, curr_dataset, curr_model, curr_optimizer, curr_training_states)

The event function to execute some processes before training.

Parameters:

• task_id (int) – the index of the current task

• curr_dataset (object) – The dataset for the current task.

• curr_model (torch.nn.Module) – the current trained model.

• curr_optimizer (torch.optim.Optimizer) – the current optimizer function.

• curr_training_states (dict) – the dictionary containing the current training states.

processEvalIteration(model, curr_batch)

The event function to handle every evaluation iteration.

Parameters:

• model (torch.nn.Module) – the current trained model.

• curr_batch (object) – the data (or minibatch) for the current iteration.

Returns:

A dictionary containing the outcomes (stats) during the evaluation iteration.

processTrainIteration(model, optimizer, curr_batch, curr_training_states)

The event function to handle every training iteration.

Parameters:

• model (torch.nn.Module) – the current trained model.

• optimizer (torch.optim.Optimizer) – the current optimizer function.

• curr_batch (object) – the data (or minibatch) for the current iteration.

• curr_training_states (dict) – the dictionary containing the current training states.

Returns:

A dictionary containing the outcomes (stats) during the training iteration.

processTrainingLogs(task_id, epoch_cnt, val_metric_result, train_stats, val_stats)

(Optional) The event function to output the training logs.

Parameters:

• task_id (int) – the index of the current task

• epoch_cnt (int) – the index of the current epoch

• val_metric_result (object) – the validation performance computed by the evaluator

• train_stats (dict) – the reduced dictionary containg the final training outcomes.

• val_stats (dict) – the reduced dictionary containg the final validation outcomes.

run(epoch_per_task=1)

Run the overall process of graph continual learning optimization.

Parameters:

epoch_per_task (int) – maximum number of training epochs for each task

Returns:

The base trainer returns the dictionary containing the evaluation results on validation and test dataset. And each trainer for specific problem processes the results and outputs the matrix-shaped results for performances and the final evaluation metrics, such as AP, AF, INT, and FWT.