def __init__(self,
layers_encoder: list,
layers_decoder: list,
optimizer: str,
learning_rate: float = 0.001,
epochs: int = 35,
batch_size: int = 64,
shuffle: bool = True,
verbose: bool = True,
callbacks: tuple = tuple(),
reg_ratio: float = 0.5,
lstm_units: int = 30,
validation_split: float = 0.0,
**hyperparameters):
self.layers_encoder = layers_encoder
self.layers_decoder = layers_decoder
self.epochs = epochs
self.batch_size = batch_size
self.reg_ratio = reg_ratio
self.optimizer = import_object(optimizer)(learning_rate)
self.lstm_units = lstm_units
self.shuffle = shuffle
self.verbose = verbose
self.hyperparameters = hyperparameters
self.validation_split = validation_split
for callback in callbacks:
callback['class'] = import_object(callback['class'])
self.callbacks = callbacks
self._fitted = False
self.fit_history = None
def __init__(self,
layers,
loss,
optimizer,
metrics=None,
epochs=10,
**hyperparameters):
self.epochs = epochs
self.is_classification = hyperparameters['dense_units'] > 1
self.model = keras.models.Sequential()
for layer in layers:
layer_class = import_object(layer['class'])
layer_kwargs = layer['parameters']
for key, value in layer_kwargs.items():
if isinstance(value, str):
layer_kwargs[key] = hyperparameters.get(value, value)
self.model.add(layer_class(**layer_kwargs))
optimizer = import_object(optimizer)()
loss = import_object(loss)
self.model.compile(loss=loss, optimizer=optimizer, metrics=metrics)
def __init__(self,
layers,
loss,
optimizer,
classification,
callbacks=tuple(),
metrics=None,
epochs=10,
verbose=False,
validation_split=0,
batch_size=32,
shuffle=True,
**hyperparameters):
self.layers = layers
self.optimizer = import_object(optimizer)
self.loss = import_object(loss)
self.metrics = metrics
self.epochs = epochs
self.verbose = verbose
self.classification = classification
self.hyperparameters = hyperparameters
self.validation_split = validation_split
self.batch_size = batch_size
self.shuffle = shuffle
for callback in callbacks:
callback['class'] = import_object(callback['class'])
self.callbacks = callbacks
def graph_feature_extraction(X, functions, graphs):
functions = [import_object(function) for function in functions]
for node_column, graph in graphs.items():
index_type = type(X[node_column].values[0])
features = pd.DataFrame(index=graph.nodes)
features.index = features.index.astype(index_type)
def apply(function):
values = function(graph)
return np.array(list(values.values()))
for function in functions:
name = '{}_{}'.format(function.__name__, node_column)
features[name] = apply(function)
X = X.merge(features,
left_on=node_column,
right_index=True,
how='left')
graph_data = pd.DataFrame(dict(graph.nodes.items())).T
graph_data.index = graph_data.index.astype(index_type)
X = X.merge(graph_data,
left_on=node_column,
right_index=True,
how='left')
return X
def __init__(self,
shape,
encoder_input_shape,
generator_input_shape,
critic_x_input_shape,
critic_z_input_shape,
layers_encoder,
layers_generator,
layers_critic_x,
layers_critic_z,
optimizer,
learning_rate=0.0005,
epochs=2000,
latent_dim=20,
batch_size=64,
iterations_critic=5,
**hyperparameters):
self.shape = shape
self.latent_dim = latent_dim
self.batch_size = batch_size
self.iterations_critic = iterations_critic
self.epochs = epochs
self.hyperparameters = hyperparameters
self.encoder_input_shape = encoder_input_shape
self.generator_input_shape = generator_input_shape
self.critic_x_input_shape = critic_x_input_shape
self.critic_z_input_shape = critic_z_input_shape
self.layers_encoder, self.layers_generator = layers_encoder, layers_generator
self.layers_critic_x, self.layers_critic_z = layers_critic_x, layers_critic_z
self.optimizer = import_object(optimizer)(learning_rate)
def __init__(self,
layers_encoder,
layers_generator,
layers_critic_x,
layers_critic_z,
optimizer,
input_shape=(100, 1),
target_shape=(100, 1),
latent_dim=20,
learning_rate=0.0005,
epochs=2000,
batch_size=64,
iterations_critic=5,
**hyperparameters):
self.shape = input_shape
self.epochs = epochs
self.batch_size = batch_size
self.latent_dim = latent_dim
self.latent_shape = (latent_dim, 1)
self.target_shape = target_shape
self.iterations_critic = iterations_critic
self.layers_encoder, self.layers_generator = layers_encoder, layers_generator
self.layers_critic_x, self.layers_critic_z = layers_critic_x, layers_critic_z
self.optimizer = import_object(optimizer)(learning_rate)
self.hyperparameters = hyperparameters
def build_layer(layer, hyperparameters):
layer_class = import_object(layer['class'])
layer_kwargs = layer['parameters'].copy()
if issubclass(layer_class, keras.layers.wrappers.Wrapper):
layer_kwargs['layer'] = build_layer(layer_kwargs['layer'], hyperparameters)
for key, value in layer_kwargs.items():
if isinstance(value, str):
layer_kwargs[key] = hyperparameters.get(value, value)
return layer_class(**layer_kwargs)
def __init__(self, shape, encoder_input_shape, generator_input_shape, critic_x_input_shape,
critic_z_input_shape, layers_encoder, layers_generator, layers_critic_x,
layers_critic_z, optimizer, learning_rate=0.0005, epochs=2000, latent_dim=20,
batch_size=64, iterations_critic=5, **hyperparameters):
"""Initialize the TadGAN object.
Args:
shape (tuple):
Tuple denoting the shape of an input sample.
encoder_input_shape (tuple):
Shape of encoder input.
generator_input_shape (tuple):
Shape of generator input.
critic_x_input_shape (tuple):
Shape of critic_x input.
critic_z_input_shape (tuple):
Shape of critic_z input.
layers_encoder (list):
List containing layers of encoder.
layers_generator (list):
List containing layers of generator.
layers_critic_x (list):
List containing layers of critic_x.
layers_critic_z (list):
List containing layers of critic_z.
optimizer (str):
String denoting the keras optimizer.
learning_rate (float):
Optional. Float denoting the learning rate of the optimizer. Default 0.005.
epochs (int):
Optional. Integer denoting the number of epochs. Default 2000.
latent_dim (int):
Optional. Integer denoting dimension of latent space. Default 20.
batch_size (int):
Integer denoting the batch size. Default 64.
iterations_critic (int):
Optional. Integer denoting the number of critic training steps per one
Generator/Encoder training step. Default 5.
hyperparameters (dictionary):
Optional. Dictionary containing any additional inputs.
"""
self.shape = shape
self.latent_dim = latent_dim
self.batch_size = batch_size
self.iterations_critic = iterations_critic
self.epochs = epochs
self.hyperparameters = hyperparameters
self.encoder_input_shape = encoder_input_shape
self.generator_input_shape = generator_input_shape
self.critic_x_input_shape = critic_x_input_shape
self.critic_z_input_shape = critic_z_input_shape
self.layers_encoder, self.layers_generator = layers_encoder, layers_generator
self.layers_critic_x, self.layers_critic_z = layers_critic_x, layers_critic_z
self.optimizer = import_object(optimizer)(learning_rate)
def build_layer(layer: dict, hyperparameters: dict):
layer_class = import_object(layer['class'])
layer_kwargs = layer['parameters'].copy()
# TODO: Upgrade to using tf.keras.layers.Wrapper in mlprimitives.
if issubclass(layer_class, tf.keras.layers.Wrapper):
layer_kwargs['layer'] = build_layer(layer_kwargs['layer'],
hyperparameters)
for key, value in layer_kwargs.items():
if isinstance(value, str):
layer_kwargs[key] = hyperparameters.get(value, value)
return layer_class(**layer_kwargs)
def __init__(self,
layers,
loss,
optimizer,
classification,
metrics=None,
epochs=10,
**hyperparameters):
self.layers = list()
for layer in layers:
layer = layer.copy()
layer['class'] = import_object(layer['class'])
self.layers.append(layer)
self.optimizer = import_object(optimizer)
self.loss = import_object(loss)
self.metrics = metrics
self.epochs = epochs
self.classification = classification
self.hyperparameters = hyperparameters
def graph_pairs_feature_extraction(X, functions, node_columns, graph=None):
functions = [import_object(function) for function in functions]
pairs = X[node_columns].values
# for i, graph in enumerate(graphs):
def apply(function):
try:
values = function(graph, pairs)
return np.array(list(values))[:, 2]
except ZeroDivisionError:
LOGGER.warn("ZeroDivisionError captured running %s", function)
return np.zeros(len(pairs))
for function in functions:
name = '{}_{}_{}'.format(function.__name__, *node_columns)
X[name] = apply(function)
return X
def test_import_object():
imported_dummy = import_object(__name__ + '.Dummy')
assert Dummy is imported_dummy
def resample(df,
rule,
on=None,
groupby=(),
aggregation='mean',
reset_index=True,
time_index=None):
"""pd.DataFrame.resample adapter.
Call the `df.resample` method on the given time_index
and afterwards call the indicated aggregation.
Optionally group the dataframe by the indicated columns before
performing the resampling.
If groupby option is used, the result is a multi-index datagrame.
Args:
df (pandas.DataFrame):
DataFrame to resample.
rule (str or int):
The offset string or object representing target conversion or an
integer value that will be interpreted as the number of seconds.
on (str or None):
Name of the column to use as the time index. If ``None`` is given, the
DataFrame index is used.
groupby (list):
Optional list of columns to group by.
aggregation (callable or str):
Function or name of the function to use for the aggregation. If a name is given, it
can either be one of the standard pandas aggregation functions or the fully qualified
name of a python function that will be imported and used.
reset_index (boolt):
Whether to reset the index after aggregating
time_index (str or None):
Deprecated: This has been renamed to `on`.
Name of the column to use as the time index. If ``None`` is given, the
DataFrame is index is used.
Returns:
pandas.Dataframe:
resampled dataframe
"""
if on is None and time_index is not None:
message = (
'resample `time_series` argument deprecated and will be removed'
' in future versions of MLPrimitives. Please use `on` instead.')
warnings.warn(message, DeprecationWarning, stacklevel=2)
on = time_index
if groupby:
df = df.groupby(groupby)
if isinstance(rule, int):
rule = '{}s'.format(rule)
dtir = df.resample(rule, on=on)
if not callable(aggregation) and aggregation not in _RESAMPLE_AGGS:
try:
aggregation = import_object(aggregation)
except (AttributeError, ImportError, ValueError):
pass
df = dtir.aggregate(aggregation)
if reset_index:
df.reset_index(inplace=True)
return df
