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 initialize_from_dataset(self,
input_dataset: Dataset,
ctx: mx.Context = get_mxnet_context()):
# Rescale all time series in training set.
train_target_sequence = 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 __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: AveragingStrategy = SelectNBestMean(num_models=1),
) -> 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
# Insert Lookahead optimizers...
self.__all__ = []
self._register_lookahead_opt()
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 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 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)
