def __init__(self, *graph, device="cpu:0", seed=None, name=None, **kwargs):
"""
Parameters:
----------
graph: Graph or MultiGraph.
device: string. optional
The device where the model running on.
seed: interger scalar. optional
Used in combination with `tf.random.set_seed` & `np.random.seed`
& `random.seed` to create a reproducible sequence of tensors
across multiple calls.
name: string. optional
Specified name for the model. (default: :str: `class.__name__`)
kwargs: other custom keyword parameters.
"""
graph = parse_graph_inputs(*graph)
_backend = backend()
self.backend = _backend
self.kind = _backend.kind
raise_if_kwargs(kwargs)
if seed is not None:
np.random.seed(seed)
random.seed(seed)
if self.kind == "P":
torch.manual_seed(seed)
torch.cuda.manual_seed(seed)
# torch.cuda.manual_seed_all(seed)
else:
tf.random.set_seed(seed)
if name is None:
name = self.__class__.__name__
self.seed = seed
self.name = name
self.graph = graph.copy()
self.device = parse_device(device, self.kind)
# data types, default: `float32` and `int32`
self.floatx = floatx()
self.intx = intx()
def train(self,
idx_train,
idx_val=None,
epochs=200,
early_stopping=None,
verbose=0,
save_best=True,
weight_path=None,
as_model=False,
monitor='val_acc',
early_stop_metric='val_loss',
callbacks=None,
**kwargs):
"""Train the model for the input `idx_train` of nodes or `sequence`.
Note:
----------
You must compile your model before training/testing/predicting. Use `model.build()`.
Parameters:
----------
idx_train: Numpy array-like, `list`, Integer scalar or `graphgallery.Sequence`
The index of nodes (or sequence) that will be used during training.
idx_val: Numpy array-like, `list`, Integer scalar or
`graphgallery.Sequence`, optional
The index of nodes (or sequence) that will be used for validation.
(default :obj: `None`, i.e., do not use validation during training)
epochs: Positive integer
The number of epochs of training.(default :obj: `200`)
early_stopping: Positive integer or None
The number of early stopping patience during training. (default :obj: `None`,
i.e., do not use early stopping during training)
verbose: int in {0, 1, 2, 3, 4}
'verbose=0': not verbose;
'verbose=1': Progbar (one line, detailed);
'verbose=2': Progbar (one line, omitted);
'verbose=3': Progbar (multi line, detailed);
'verbose=4': Progbar (multi line, omitted);
(default :obj: 0)
save_best: bool
Whether to save the best weights (accuracy of loss depend on `monitor`)
of training or validation (depend on `validation` is `False` or `True`).
(default :bool: `True`)
weight_path: String or None
The path of saved weights/model. (default :obj: `None`, i.e.,
`./log/{self.name}_weights`)
as_model: bool
Whether to save the whole model or weights only, if `True`, the `self.custom_objects`
must be speficied if you are using custom `layer` or `loss` and so on.
monitor: String
One of (val_loss, val_acc, loss, acc), it determines which metric will be
used for `save_best`. (default :obj: `val_acc`)
early_stop_metric: String
One of (val_loss, val_acc, loss, acc), it determines which metric will be
used for early stopping. (default :obj: `val_loss`)
callbacks: tensorflow.keras.callbacks. (default :obj: `None`)
kwargs: other keyword Parameters.
Return:
----------
A `tf.keras.callbacks.History` object. Its `History.history` attribute is
a record of training loss values and metrics values
at successive epochs, as well as validation loss values
and validation metrics values (if applicable).
"""
raise_if_kwargs(kwargs)
if not (isinstance(verbose, int) and 0 <= verbose <= 4):
raise ValueError("'verbose=0': not verbose"
"'verbose=1': Progbar(one line, detailed), "
"'verbose=2': Progbar(one line, omitted), "
"'verbose=3': Progbar(multi line, detailed), "
"'verbose=4': Progbar(multi line, omitted), "
f"but got {verbose}")
model = self.model
# Check if model has been built
if model is None:
raise RuntimeError(
'You must compile your model before training/testing/predicting. Use `model.build()`.'
)
if isinstance(idx_train, Sequence):
train_data = idx_train
else:
idx_train = asintarr(idx_train)
train_data = self.train_sequence(idx_train)
self.idx_train = idx_train
validation = idx_val is not None
if validation:
if isinstance(idx_val, Sequence):
val_data = idx_val
else:
idx_val = asintarr(idx_val)
val_data = self.test_sequence(idx_val)
self.idx_val = idx_val
else:
monitor = 'acc' if monitor[:3] == 'val' else monitor
if not isinstance(callbacks, callbacks_module.CallbackList):
callbacks = callbacks_module.CallbackList(callbacks)
history = History()
callbacks.append(history)
if early_stopping:
es_callback = EarlyStopping(monitor=early_stop_metric,
patience=early_stopping,
mode='auto',
verbose=kwargs.pop('es_verbose', 1))
callbacks.append(es_callback)
if save_best:
if not weight_path:
weight_path = self.weight_path
else:
self.weight_path = weight_path
makedirs_from_filename(weight_path)
if not weight_path.endswith(POSTFIX):
weight_path = weight_path + POSTFIX
mc_callback = ModelCheckpoint(weight_path,
monitor=monitor,
save_best_only=True,
save_weights_only=not as_model,
verbose=0)
callbacks.append(mc_callback)
callbacks.set_model(model)
model.stop_training = False
callbacks.on_train_begin()
if verbose:
stateful_metrics = {"acc", 'loss', 'val_acc', 'val_loss', 'time'}
if verbose <= 2:
progbar = Progbar(target=epochs,
verbose=verbose,
stateful_metrics=stateful_metrics)
print("Training...")
begin_time = time.perf_counter()
try:
for epoch in range(epochs):
if verbose > 2:
progbar = Progbar(target=len(train_data),
verbose=verbose - 2,
stateful_metrics=stateful_metrics)
callbacks.on_epoch_begin(epoch)
callbacks.on_train_batch_begin(0)
loss, accuracy = self.train_step(train_data)
training_logs = {'loss': loss, 'acc': accuracy}
if validation:
val_loss, val_accuracy = self.test_step(val_data)
training_logs.update({
'val_loss': val_loss,
'val_acc': val_accuracy
})
val_data.on_epoch_end()
callbacks.on_train_batch_end(len(train_data), training_logs)
callbacks.on_epoch_end(epoch, training_logs)
train_data.on_epoch_end()
if verbose:
time_passed = time.perf_counter() - begin_time
training_logs.update({'time': time_passed})
if verbose > 2:
print(f"Epoch {epoch+1}/{epochs}")
progbar.update(len(train_data), training_logs.items())
else:
progbar.update(epoch + 1, training_logs.items())
if model.stop_training:
break
finally:
callbacks.on_train_end()
# to avoid unexpected termination of the model
if save_best:
self.load(weight_path, as_model=as_model)
self.remove_weights()
return history
def train(self,
train_data,
val_data=None,
epochs=200,
early_stopping=None,
verbose=1,
save_best=True,
ckpt_path=None,
as_model=False,
monitor='val_accuracy',
early_stop_metric='val_loss',
callbacks=None,
**kwargs):
"""Train the model for the input `train_data` of nodes or `sequence`.
Note:
----------
You must compile your model before training/testing/predicting. Use `model.build()`.
Parameters:
----------
train_data: Numpy array-like, `list`, Integer scalar or `graphgallery.Sequence`
The index of objects (or sequence) that will be used during training.
val_data: Numpy array-like, `list`, Integer scalar or
`graphgallery.Sequence`, optional
The index of objects (or sequence) that will be used for validation.
(default :obj: `None`, i.e., do not use validation during training)
epochs: Positive integer
The number of epochs of training.(default :obj: `200`)
early_stopping: Positive integer or None
The number of early stopping patience during training.
(default :obj: `None`, i.e., do not use early stopping during training)
verbose: int in {0, 1, 2, 3, 4}
'verbose=0': not verbose;
'verbose=1': Progbar (one line, detailed);
'verbose=2': Progbar (one line, omitted);
'verbose=3': Progbar (multi line, detailed);
'verbose=4': Progbar (multi line, omitted);
(default :obj: 1)
save_best: bool
Whether to save the best weights (accuracy of loss depend on `monitor`)
of training or validation (depend on `validation` is `False` or `True`).
(default :bool: `True`)
ckpt_path: String or None
The path of saved weights/model.
(default to current path.)
as_model: bool
Whether to save the whole model or weights only, if `True`, the `self.custom_objects`
must be speficied if you are using custom `layer` or `loss` and so on.
monitor: String
One of evaluation metrics, e.g., val_loss, val_accuracy, loss, accuracy,
it determines which metric will be used for `save_best`.
(default :obj: `val_accuracy`)
early_stop_metric: String
One of evaluation metrics, e.g., val_loss, val_accuracy, loss, accuracy,
it determines which metric will be used for early stopping.
(default :obj: `val_loss`)
callbacks: tensorflow.keras.callbacks. (default :obj: `None`)
kwargs: other keyword Parameters.
Return:
----------
A `tf.keras.callbacks.History` object. Its `History.history` attribute is
a record of training loss values and metrics values
at successive epochs, as well as validation loss values
and validation metrics values (if applicable).
"""
raise_if_kwargs(kwargs)
if not (isinstance(verbose, int) and 0 <= verbose <= 4):
raise ValueError("'verbose=0': not verbose"
"'verbose=1': Progbar(one line, detailed), "
"'verbose=2': Progbar(one line, omitted), "
"'verbose=3': Progbar(multi line, detailed), "
"'verbose=4': Progbar(multi line, omitted), "
f"but got {verbose}")
model = self.model
# Check if model has been built
if model is None:
raise RuntimeError(
'You must compile your model before training/testing/predicting. Use `model.build()`.'
)
metrics_names = getattr(model, "metrics_names", None)
# FIXME: This would return '[]' for tensorflow>=2.2.0
# See <https://github.com/tensorflow/tensorflow/issues/37990>
# metrics_names = ['loss', 'accuracy']
if not metrics_names:
raise RuntimeError(f"Please specify the attribute 'metrics_names' for the model.")
if not isinstance(train_data, Sequence):
train_data = self.train_sequence(train_data)
self.train_data = train_data
validation = val_data is not None
if validation:
if not isinstance(val_data, Sequence):
val_data = self.test_sequence(val_data)
self.val_data = val_data
metrics_names = metrics_names + ["val_" + metric for metric in metrics_names]
if not isinstance(callbacks, callbacks_module.CallbackList):
callbacks = callbacks_module.CallbackList(callbacks)
history = History()
callbacks.append(history)
if early_stopping:
es_callback = EarlyStopping(monitor=early_stop_metric,
patience=early_stopping,
mode='auto',
verbose=kwargs.pop('es_verbose', 1))
callbacks.append(es_callback)
if save_best:
if not ckpt_path:
ckpt_path = self.ckpt_path
else:
self.ckpt_path = ckpt_path
makedirs_from_filepath(ckpt_path)
if not ckpt_path.endswith(gg.file_ext()):
ckpt_path = ckpt_path + gg.file_ext()
if monitor not in metrics_names:
monitor = metrics_names[-1]
warnings.warn(f"'{monitor}' are not included in the metrics names. default to '{monitor}'.",
UserWarning)
mc_callback = ModelCheckpoint(ckpt_path,
monitor=monitor,
save_best_only=True,
save_weights_only=not as_model,
verbose=0)
callbacks.append(mc_callback)
callbacks.set_model(model)
model.stop_training = False
if verbose:
if verbose <= 2:
progbar = Progbar(target=epochs,
width=20,
verbose=verbose)
print("Training...")
logs = BunchDict()
callbacks.on_train_begin()
try:
for epoch in range(epochs):
if verbose > 2:
progbar = Progbar(target=len(train_data),
width=20,
verbose=verbose - 2)
callbacks.on_epoch_begin(epoch)
callbacks.on_train_batch_begin(0)
train_logs = self.train_step(train_data)
train_data.on_epoch_end()
logs.update(train_logs)
if validation:
valid_logs = self.test_step(val_data)
logs.update({("val_" + k): v for k, v in valid_logs.items()})
val_data.on_epoch_end()
callbacks.on_train_batch_end(len(train_data), logs)
callbacks.on_epoch_end(epoch, logs)
if verbose > 2:
print(f"Epoch {epoch+1}/{epochs}")
progbar.update(len(train_data), logs.items())
elif verbose:
progbar.update(epoch + 1, logs.items())
if model.stop_training:
print(f"Early Stopping at Epoch {epoch}", file=sys.stderr)
break
callbacks.on_train_end()
self.load(ckpt_path, as_model=as_model)
finally:
# to avoid unexpected termination of the model
self.remove_weights()
return history
def train(self,
idx_train,
idx_val=None,
epochs=200,
early_stopping=None,
verbose=0,
save_best=True,
weight_path=None,
as_model=False,
monitor='val_acc',
early_stop_metric='val_loss',
callbacks=None,
**kwargs):
"""Train the model for the input `idx_train` of nodes or `sequence`.
Note:
----------
You must compile your model before training/testing/predicting. Use `model.build()`.
Parameters:
----------
idx_train: Numpy array-like, `list`, Integer scalar or `graphgallery.Sequence`
The index of nodes (or sequence) that will be used during training.
idx_val: Numpy array-like, `list`, Integer scalar or
`graphgallery.Sequence`, optional
The index of nodes (or sequence) that will be used for validation.
(default :obj: `None`, i.e., do not use validation during training)
epochs: Positive integer
The number of epochs of training.(default :obj: `200`)
early_stopping: Positive integer or None
The number of early stopping patience during training. (default :obj: `None`,
i.e., do not use early stopping during training)
verbose: int in {0, 1, 2}
'verbose=0': not verbose;
'verbose=1': tqdm verbose;
'verbose=2': tensorflow probar verbose;
(default :obj: 0)
save_best: bool
Whether to save the best weights (accuracy of loss depend on `monitor`)
of training or validation (depend on `validation` is `False` or `True`).
(default :bool: `True`)
weight_path: String or None
The path of saved weights/model. (default :obj: `None`, i.e.,
`./log/{self.name}_weights`)
as_model: bool
Whether to save the whole model or weights only, if `True`, the `self.custom_objects`
must be speficied if you are using customized `layer` or `loss` and so on.
monitor: String
One of (val_loss, val_acc, loss, acc), it determines which metric will be
used for `save_best`. (default :obj: `val_acc`)
early_stop_metric: String
One of (val_loss, val_acc, loss, acc), it determines which metric will be
used for early stopping. (default :obj: `val_loss`)
callbacks: tensorflow.keras.callbacks. (default :obj: `None`)
kwargs: other keyword Parameters.
Return:
----------
A `tf.keras.callbacks.History` object. Its `History.history` attribute is
a record of training loss values and metrics values
at successive epochs, as well as validation loss values
and validation metrics values (if applicable).
"""
if not verbose in {0, 1, 2}:
raise ValueError(
"'verbose=0': not verbose; 'verbose=1': tqdm verbose; "
"'verbose=2': tensorflow probar verbose; "
f"but got {verbose}")
model = self.model
# Check if model has been built
if model is None:
raise RuntimeError(
'You must compile your model before training/testing/predicting. Use `model.build()`.'
)
# TODO: add metric names in `model`
metric_names = ['loss', 'acc']
callback_metrics = metric_names
model.stop_training = False
if isinstance(idx_train, Sequence):
train_data = idx_train
else:
idx_train = asintarr(idx_train)
train_data = self.train_sequence(idx_train)
self.idx_train = idx_train
validation = idx_val is not None
if validation:
if isinstance(idx_val, Sequence):
val_data = idx_val
else:
idx_val = asintarr(idx_val)
val_data = self.test_sequence(idx_val)
self.idx_val = idx_val
callback_metrics = copy.copy(metric_names)
callback_metrics += ['val_' + n for n in metric_names]
else:
monitor = 'acc' if monitor[:3] == 'val' else monitor
if not isinstance(callbacks, callbacks_module.CallbackList):
callbacks = callbacks_module.CallbackList(callbacks)
history = tf_History()
callbacks.append(history)
if verbose == 2:
callbacks.append(ProgbarLogger(stateful_metrics=metric_names[1:]))
if early_stopping:
es_callback = EarlyStopping(monitor=early_stop_metric,
patience=early_stopping,
mode='auto',
verbose=kwargs.pop('es_verbose', 1))
callbacks.append(es_callback)
if save_best:
if not weight_path:
weight_path = self.weight_path
makedirs_from_path(weight_path)
if not weight_path.endswith('.h5'):
weight_path = weight_path + '.h5'
mc_callback = ModelCheckpoint(weight_path,
monitor=monitor,
save_best_only=True,
save_weights_only=not as_model,
verbose=0)
callbacks.append(mc_callback)
callbacks.set_model(model)
# TODO: to be improved
callback_params = {
'batch_size': None,
'epochs': epochs,
'steps': 1,
'samples': 1,
'verbose': verbose == 2,
'do_validation': validation,
'metrics': callback_metrics,
}
callbacks.set_params(callback_params)
raise_if_kwargs(kwargs)
callbacks.on_train_begin()
if verbose == 1:
pbar = tqdm(range(1, epochs + 1))
else:
pbar = range(epochs)
for epoch in pbar:
callbacks.on_epoch_begin(epoch)
callbacks.on_train_batch_begin(0)
loss, accuracy = self.train_step(train_data)
training_logs = {'loss': loss, 'acc': accuracy}
if validation:
val_loss, val_accuracy = self.test_step(val_data)
training_logs.update({
'val_loss': val_loss,
'val_acc': val_accuracy
})
val_data.on_epoch_end()
callbacks.on_train_batch_end(0, training_logs)
callbacks.on_epoch_end(epoch, training_logs)
if verbose == 1:
msg = "<"
for key, val in training_logs.items():
msg += f"{key.title()} = {val:.4f} "
msg += ">"
pbar.set_description(msg)
train_data.on_epoch_end()
if verbose == 2:
print()
if model.stop_training:
break
callbacks.on_train_end()
if save_best:
self.load(weight_path, as_model=as_model)
remove_tf_weights(weight_path)
return history
