def deserialize(
cls,
path: Path,
ctx: Optional[mx.Context] = None) -> "SymbolBlockPredictor":
ctx = ctx if ctx is not None else get_mxnet_context()
with mx.Context(ctx):
# deserialize constructor parameters
with (path / "parameters.json").open("r") as fp:
parameters = load_json(fp.read())
parameters["ctx"] = ctx
# deserialize transformation chain
with (path / "input_transform.json").open("r") as fp:
transform = load_json(fp.read())
# deserialize prediction network
num_inputs = len(parameters["input_names"])
prediction_net = import_symb_block(num_inputs, path,
"prediction_net")
return SymbolBlockPredictor(
input_transform=transform,
prediction_net=prediction_net,
**parameters,
)
def deserialize(
cls,
path: Path,
ctx: Optional[mx.Context] = None) -> "RepresentableBlockPredictor":
ctx = ctx if ctx is not None else get_mxnet_context()
with mx.Context(ctx):
# deserialize constructor parameters
with (path / "parameters.json").open("r") as fp:
parameters = load_json(fp.read())
# deserialize transformation chain
with (path / "input_transform.json").open("r") as fp:
transform = load_json(fp.read())
# deserialize prediction network
prediction_net = import_repr_block(path, "prediction_net")
# input_names is derived from the prediction_net
if "input_names" in parameters:
del parameters["input_names"]
parameters["ctx"] = ctx
return RepresentableBlockPredictor(
input_transform=transform,
prediction_net=prediction_net,
**parameters,
)
def _get_estimator(self):
if get_mxnet_context() != mx.context.cpu():
self.params["hybridize"] = False
with warning_filter():
return self.gluonts_estimator_class.from_hyperparameters(
**self._get_estimator_init_args())
def _get_estimator(self):
# TODO: temporarily disabling hybridization on GPU due to mxnet issue
# TODO: fixed in mxnet v2.0
if get_mxnet_context() != mx.context.cpu():
self.params["hybridize"] = False
with warning_filter():
return self.gluonts_estimator_class.from_hyperparameters(
**self._get_estimator_init_args())
def __init__(
self,
ctx: Optional[mx.Context] = None,
epochs: int = 100,
batch_size: int = 32,
num_batches_per_epoch: int = 50,
learning_rate: float = 1e-3,
learning_rate_decay_factor: float = 0.5,
patience: int = 10,
minimum_learning_rate: float = 5e-5,
clip_gradient: float = 10.0,
weight_decay: float = 1e-8,
init: Union[str, mx.initializer.Initializer] = "xavier",
hybridize: bool = True,
avg_strategy: Union[
AveragingStrategy, IterationAveragingStrategy
] = SelectNBestMean(num_models=1),
post_initialize_cb: Optional[Callable[[mx.gluon.Block], None]] = None,
) -> None:
assert (
0 <= epochs < float("inf")
), "The value of `epochs` should be >= 0"
assert 0 < batch_size, "The value of `batch_size` should be > 0"
assert (
0 < num_batches_per_epoch
), "The value of `num_batches_per_epoch` should be > 0"
assert (
0 < learning_rate < float("inf")
), "The value of `learning_rate` should be > 0"
assert (
0 <= learning_rate_decay_factor < 1
), "The value of `learning_rate_decay_factor` should be in the [0, 1) range"
assert 0 <= patience, "The value of `patience` should be >= 0"
assert (
0 <= minimum_learning_rate
), "The value of `minimum_learning_rate` should be >= 0"
assert 0 < clip_gradient, "The value of `clip_gradient` should be > 0"
assert 0 <= weight_decay, "The value of `weight_decay` should be => 0"
self.epochs = epochs
self.batch_size = batch_size
self.num_batches_per_epoch = num_batches_per_epoch
self.learning_rate = learning_rate
self.learning_rate_decay_factor = learning_rate_decay_factor
self.patience = patience
self.minimum_learning_rate = minimum_learning_rate
self.clip_gradient = clip_gradient
self.weight_decay = weight_decay
self.init = init
self.hybridize = hybridize
self.avg_strategy = avg_strategy
self.ctx = ctx if ctx is not None else get_mxnet_context()
self.halt = False
self.post_initialize_cb = post_initialize_cb
def initialize_from_dataset(self,
input_dataset: Dataset,
ctx: mx.Context = get_mxnet_context()):
# Rescale all time series in training set.
train_target_sequence: np.ndarray = np.array([])
for train_entry in input_dataset:
train_entry_target = train_entry["target"]
train_tar_mean = np.mean(train_entry_target)
train_entry_target /= train_tar_mean
train_target_sequence = np.concatenate(
[train_target_sequence, train_entry_target])
self.initialize_from_array(train_target_sequence, ctx)
def initialize_from_array(self,
input_array: np.ndarray,
ctx: mx.Context = get_mxnet_context()):
r"""
Initialize the representation based on a numpy array.
Parameters
----------
input_array
Numpy array.
ctx
MXNet context.
"""
pass
def initialize_from_dataset(self,
input_dataset: Dataset,
ctx: mx.Context = get_mxnet_context()):
r"""
Initialize the representation based on an entire dataset.
Parameters
----------
input_dataset
GluonTS dataset.
ctx
MXNet context.
"""
pass
def __init__(
self,
units: int,
in_units: int,
coeff: float = 0.9,
activation: Optional[str] = None,
use_bias: bool = True,
flatten: bool = True,
weight_initializer: init.Initializer = init.Orthogonal(scale=0.9),
bias_initializer="zeros",
dtype="float32",
num_power_iter: int = 1,
ctx: Optional[mx.Context] = None,
**kwargs):
super().__init__(**kwargs)
self._coeff = coeff
self._flatten = flatten
self._ctx = ctx if ctx is not None else get_mxnet_context()
self._num_power_iter = num_power_iter
with self.name_scope():
self._units = units
self._in_units = in_units
self._weight = self.params.get(
"weight",
shape=(units, in_units),
init=weight_initializer,
dtype=dtype,
)
self._u = self.params.get("u",
init=mx.init.Normal(),
shape=(1, units))
if use_bias:
self._bias = self.params.get("bias",
shape=(units, ),
init=bias_initializer,
dtype=dtype)
else:
self._bias = None
if activation is not None:
self._act = get_activation(activation, prefix=activation + "_")
else:
self._act = None
def initialize_from_array(self,
input_array: np.ndarray,
ctx: mx.Context = get_mxnet_context()):
# Calculate bin centers and bin edges using linear or quantile binning..
if self.is_quantile:
bin_centers = np.quantile(
input_array,
np.linspace(0, self.quantile_scaling_limit, self.num_bins),
)
bin_centers = ensure_binning_monotonicity(bin_centers)
else:
has_negative_data = np.any(input_array < 0)
low = -self.linear_scaling_limit if has_negative_data else 0
high = self.linear_scaling_limit
bin_centers = np.linspace(low, high, self.num_bins)
bin_edges = bin_edges_from_bin_centers(bin_centers)
# Store bin centers and edges since their are globally applicable to all time series.
with ctx:
self.bin_edges.initialize()
self.bin_centers.initialize()
self.bin_edges.set_data(mx.nd.array(bin_edges))
self.bin_centers.set_data(mx.nd.array(bin_centers))
def initialize_from_array(self,
input_array: np.ndarray,
ctx: mx.Context = get_mxnet_context()):
for representation in self.representations:
representation.initialize_from_array(input_array, ctx)
def initialize_from_dataset(self,
input_dataset: Dataset,
ctx: mx.Context = get_mxnet_context()):
for representation in self.representations:
representation.initialize_from_dataset(input_dataset, ctx)
def __init__(
self,
ctx: Optional[mx.Context] = None,
epochs: int = 100,
batch_size: Optional[int] = None,
num_batches_per_epoch: int = 50,
learning_rate: float = 1e-3,
learning_rate_decay_factor: float = 0.5,
patience: int = 10,
minimum_learning_rate: float = 5e-5,
clip_gradient: float = 10.0,
weight_decay: float = 1e-8,
init: Union[str, mx.initializer.Initializer] = "xavier",
hybridize: bool = True,
callbacks: Optional[List[Callback]] = None,
add_default_callbacks: bool = True,
) -> None:
if batch_size is not None:
warnings.warn(
"batch_size argument is deprecated",
DeprecationWarning,
stacklevel=2,
)
else:
batch_size = 32
assert isinstance(batch_size, int)
# TODO param disable_default_callbacks to get backwards compatibility
# deprecation warnings, in the future, the following callbacks should be
# controlled by altering callbacks:
if learning_rate_decay_factor is not None:
warnings.warn(
'Trainer argument "learning_rate_decay_factor" is deprecated. Use callbacks instead.',
DeprecationWarning,
)
assert (
0 <= learning_rate_decay_factor < 1
), "The value of `learning_rate_decay_factor` should be in the [0, 1) range"
if patience is not None:
warnings.warn(
'Trainer argument "patience" is deprecated. Use callbacks instead.',
DeprecationWarning,
)
assert 0 <= patience, "The value of `patience` should be >= 0"
if minimum_learning_rate:
warnings.warn(
'Trainer argument "minimum_learning_rate" is deprecated. Use callbacks instead.',
DeprecationWarning,
)
assert (0 <= minimum_learning_rate
), "The value of `minimum_learning_rate` should be >= 0"
assert (0 <= epochs <
float("inf")), "The value of `epochs` should be >= 0"
assert 0 < batch_size, "The value of `batch_size` should be > 0"
assert (0 < num_batches_per_epoch
), "The value of `num_batches_per_epoch` should be > 0"
assert (0 < learning_rate <
float("inf")), "The value of `learning_rate` should be > 0"
assert 0 < clip_gradient, "The value of `clip_gradient` should be > 0"
assert 0 <= weight_decay, "The value of `weight_decay` should be => 0"
self.epochs = epochs
self.batch_size = batch_size
self.num_batches_per_epoch = num_batches_per_epoch
self.learning_rate = learning_rate
self.learning_rate_decay_factor = learning_rate_decay_factor
self.patience = patience
self.minimum_learning_rate = minimum_learning_rate
self.clip_gradient = clip_gradient
self.weight_decay = weight_decay
self.init = init
self.hybridize = hybridize
self.ctx = ctx if ctx is not None else get_mxnet_context()
self.halt = False
# Make sure callbacks is list -- they are assigned to `self.callbacks`
# below
callbacks = callbacks or []
# TODO the following is done for backwards compatibility. For future
# versions, add the default callbacks as default arg
if add_default_callbacks:
default_callbacks = [
ModelAveraging(avg_strategy=SelectNBestMean(num_models=1)),
LearningRateReduction(
base_lr=learning_rate,
decay_factor=learning_rate_decay_factor,
patience=patience,
min_lr=minimum_learning_rate,
objective="min",
),
]
self.callbacks = CallbackList(callbacks + default_callbacks)
else:
self.callbacks = CallbackList(callbacks)
def initialize_from_array(
self, input_array: np.ndarray, ctx: mx.Context = get_mxnet_context()
):
with ctx:
self.bin_edges.initialize()
self.bin_centers.initialize()
def initialize_from_dataset(
self, input_dataset: Dataset, ctx: mx.Context = get_mxnet_context()
):
self.initialize_from_array(np.array([]), ctx)
