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