def make_generator_model():
model = tf.keras.Sequential()
model.add(layers.Input(shape=(47, 1))) # Noise shape
model.add(layers.Bidirectional(layers.LSTM(64, return_sequences=True)))
model.add(layers.Conv1D(filters=128, kernel_size=16, strides=1, padding='same'))
model.add(layers.LeakyReLU())
model.add(layers.Conv1D(filters=64, kernel_size=16, strides=1, padding='same'))
model.add(layers.LeakyReLU())
model.add(layers.UpSampling1D(2))
model.add(layers.Conv1D(filters=32, kernel_size=16, strides=1, padding='same'))
model.add(layers.LeakyReLU())
model.add(layers.Conv1D(filters=16, kernel_size=16, strides=1, padding='same'))
model.add(layers.LeakyReLU())
model.add(layers.UpSampling1D(2))
model.add(layers.Conv1D(filters=1, kernel_size=16, strides=1, padding='same', activation='tanh'))
model.add(layers.Permute((2, 1)))
return model
def define_generator(input_shape, n_class=4):
in_latent = tf.keras.Input(shape=input_shape)
n_nodes = 15*128
in_label = layers.Input(shape=(1,))
lb = layers.Embedding(n_class, 50)(in_label)
lb = layers.Dense(15)(lb)
lb = layers.Reshape((15, 1))(lb)
gen = layers.Dense(n_nodes)(in_latent)
gen = layers.LeakyReLU(alpha=0.2)(gen)
gen = layers.Reshape((15, 128))(gen)
gen = layers.Concatenate()([gen, lb])
gen = layers.Conv1D(128, 16, padding='same')(gen)
gen = layers.LeakyReLU(alpha=0.2)(gen)
gen = layers.UpSampling1D(2)(gen)
gen = layers.BatchNormalization()(gen)
gen = layers.Conv1D(64, 16, padding='same')(gen)
gen = layers.LeakyReLU(alpha=0.2)(gen)
gen = layers.UpSampling1D(3)(gen)
gen = layers.BatchNormalization()(gen)
gen = layers.Conv1D(32, 16, padding='same')(gen)
gen = layers.LeakyReLU(alpha=0.2)(gen)
gen = layers.UpSampling1D(2)(gen)
gen = layers.BatchNormalization()(gen)
g_out = layers.Conv1D(1, 16, activation='tanh',padding='same')(gen)
# g_out = layers.Permute((2,1))(gen)
g_model = tf.keras.Model([in_latent, in_label], g_out)
# model.summary()
return g_model
def cnn_1(N):
layer_in = tfkl.Input(shape=[N, 1])
enc = tfkl.Conv1D(8,
8,
strides=1,
padding='SAME',
activation='relu',
use_bias=False)(layer_in)
enc = tfkl.MaxPooling1D(2)(enc)
enc = tfkl.Conv1D(16,
8,
strides=1,
padding='SAME',
activation='relu',
use_bias=False)(enc)
enc = tfkl.MaxPooling1D(2)(enc)
enc = tfkl.Conv1D(32,
8,
strides=1,
padding='SAME',
activation='relu',
use_bias=False)(enc)
enc = tfkl.MaxPooling1D(2)(enc)
enc = tfkl.Conv1D(64,
8,
strides=1,
padding='SAME',
activation='relu',
use_bias=False)(enc)
dec = tfkl.UpSampling1D(2)(enc)
dec = tfkl.Conv1D(32,
8,
strides=1,
padding='SAME',
activation='relu',
use_bias=False)(dec)
dec = tfkl.UpSampling1D(2)(dec)
dec = tfkl.Conv1D(16,
8,
strides=1,
padding='SAME',
activation='relu',
use_bias=False)(dec)
dec = tfkl.UpSampling1D(2)(dec)
dec = tfkl.Conv1D(8,
8,
strides=1,
padding='SAME',
activation='relu',
use_bias=False)(dec)
out = tfkl.Conv1D(1, 8, strides=1, padding='SAME', use_bias=False)(dec)
model = tf.keras.Model(inputs=[layer_in], outputs=[out])
return model
def build_model(wav_size=16384, chunk_size=256, chunk_hop=128, emb_size=32):
N_WIN = (wav_size - chunk_size) // chunk_hop + 1
hann_win = tf.signal.hann_window(chunk_size)
wav_input = tf.keras.Input(shape=(wav_size, ))
encoder = tf.signal.frame(wav_input, chunk_size, chunk_hop, axis=1)
encoder = tf.multiply(encoder, hann_win)
encoder = tf.expand_dims(encoder, axis=-1)
encoder = tfkl.TimeDistributed(tfkl.Conv1D(64, 8, padding='SAME'))(encoder)
encoder = tfkl.TimeDistributed(
tfkl.Conv1D(64, 8, padding='SAME', strides=8))(encoder)
encoder = tfkl.TimeDistributed(
tfkl.Conv1D(64, 8, padding='SAME', strides=4))(encoder)
encoder = tfkl.TimeDistributed(
tfkl.Conv1D(64, 8, padding='SAME', strides=2))(encoder)
encoder = tfkl.TimeDistributed(tfkl.Flatten())(encoder)
encoder = tfkl.GRU(emb_size, return_sequences=True)(encoder) #Global LSTM
encoder_model = tf.keras.Model(wav_input, encoder)
decoder_input = tf.keras.Input(shape=(N_WIN, emb_size), name='encoded_img')
decoder = tfkl.GRU(256, return_sequences=True)(decoder_input)
decoder = tfkl.TimeDistributed(tfkl.Reshape(target_shape=(4, 64)))(decoder)
decoder = tfkl.TimeDistributed(tfkl.Conv1D(64, 8, padding='SAME'))(decoder)
decoder = tfkl.TimeDistributed(tfkl.UpSampling1D(2))(decoder)
decoder = tfkl.TimeDistributed(tfkl.Conv1D(64, 8, padding='SAME'))(decoder)
decoder = tfkl.TimeDistributed(tfkl.UpSampling1D(4))(decoder)
decoder = tfkl.TimeDistributed(tfkl.Conv1D(64, 8, padding='SAME'))(decoder)
decoder = tfkl.TimeDistributed(tfkl.UpSampling1D(8))(decoder)
decoder = tfkl.TimeDistributed(
tfkl.Conv1D(1, 8, padding='SAME', activation='tanh',
dtype=tf.float32))(decoder)
decoder = tfkl.Reshape(target_shape=(N_WIN, chunk_size))(decoder)
decoder = tf.multiply(decoder, hann_win)
decoder = tf.signal.overlap_and_add(decoder, chunk_hop)
decoder_model = tf.keras.Model(decoder_input, decoder)
ae_input = tf.keras.Input(shape=(wav_size, ))
encoder_out = encoder_model(ae_input)
decoder_out = decoder_model(encoder_out)
ae_model = tf.keras.Model(inputs=ae_input, outputs=decoder_out)
return ae_model, encoder_model, decoder_model
def build(self, input_shape):
assert len(input_shape) == 2
assert len(input_shape[0]) == 3 and len(input_shape[1]) == 3
# Assertion for high inputs
assert input_shape[0][1] >= self.mor_kernel_size
# Assertion for low inputs
assert input_shape[0][1] // input_shape[1][1] == self.beta
# channel last for Tensorflow
assert K.image_data_format() == 'channels_last'
self.conv_high_high = NCausalConv1D(
filters=self.high_channels,
kernel_size=self.mor_kernel_size,
dilation_rate=self.mor_dilation,
activation=tf.nn.leaky_relu,
)
self.conv_low_high = NCausalConv1D(
filters=self.high_channels,
kernel_size=self.rhy_kernel_size,
dilation_rate=self.rhy_dilation,
activation=tf.nn.leaky_relu,
)
self.conv_high_low = NCausalConv1D(
filters=self.low_channels,
kernel_size=self.mor_kernel_size,
dilation_rate=self.mor_dilation,
activation=tf.nn.leaky_relu,
)
self.conv_low_low = NCausalConv1D(
filters=self.low_channels,
kernel_size=self.rhy_kernel_size,
dilation_rate=self.rhy_dilation,
activation=tf.nn.leaky_relu,
)
# self.bi_gru = BiGRUCell(rnn_size=self.filters,
# dropout=self.dropout)
self.high_cross = layers.Conv1D(self.filters, 1, padding='same')
self.low_cross = layers.Conv1D(self.filters, 1, padding='same')
self.upsampling1d = layers.UpSampling1D(size=self.beta)
self.averagepooling1d = layers.AveragePooling1D(pool_size=self.beta)
self.batch_norm1 = layers.BatchNormalization()
self.batch_norm2 = layers.BatchNormalization()
self.batch_norm3 = layers.BatchNormalization()
self.batch_norm4 = layers.BatchNormalization()
self.dropout_high = layers.Dropout(
self.dropout,
[tf.constant(1),
tf.constant(1),
tf.constant(self.high_channels)])
self.dropout_low = layers.Dropout(
self.dropout,
[tf.constant(1),
tf.constant(1),
tf.constant(self.low_channels)])
super().build(input_shape)
def make_aa_model():
model = tf.keras.Sequential()
model.add(layers.Conv1D(100, 10, activation='relu', padding="same", input_shape=(22143, 1)))
model.add(layers.MaxPooling1D(5, padding="same")) # output = 100 x 4429
model.add(layers.Conv1D(50, 10, activation='relu', padding="same")) # output = 50 x 8857
model.add(layers.MaxPooling1D(5, padding="same")) # output = 50 x 886 (8857/ 5)
assert model.output_shape == (None, 886, 50)
model.add(layers.Conv1D(50, 10, activation='relu', padding="same")) # output = 50 x 886
model.add(layers.UpSampling1D(5)) # output = 50 x 4430
model.add(layers.Conv1D(50, 10, activation='relu', padding="same")) # output = 50 x 4430
model.add(layers.UpSampling1D(5)) # output = 50 x 44300
model.add(layers.Conv1D(1, 8, activation='relu', padding="valid")) # output = 1 x 22150 (using VALID)
assert model.output_shape == (None, 22143, 1)
print("C")
return model
def create_vae(self):
input_size = self.hparams['window_samples']
scale = self.hparams['model_scale']
n_layers = 4
i = tfkl.Input(shape=(input_size, 1))
o = i
for n in range(1, n_layers + 1):
o = tfkl.Conv1D(scale * (n + 1),
kernel_size=2,
strides=2,
padding='same')(o)
o = tfkl.BatchNormalization(axis=1)(o)
o = tfkl.ReLU()(o)
o = tfkl.Flatten()(o)
o = tfkl.Dense(tfpl.IndependentNormal.params_size(
self.hparams['latent_size']),
activation=None)(o)
o = tfpl.IndependentNormal(
self.hparams['latent_size'],
activity_regularizer=tfpl.KLDivergenceRegularizer(self.prior,
weight=2.0))(o)
encoder = tfk.Model(inputs=i, outputs=o)
i = tfkl.Input(shape=(self.hparams['latent_size'], ))
s = scale * (n_layers + 1)
o = tfkl.Dense(s, activation='relu')(i)
o = tfkl.Reshape(target_shape=(1, s))(o)
for n in range(1, n_layers + 1):
o = tfkl.UpSampling1D(size=2)(o)
o = tfkl.Conv1D(scale * (n_layers + 1 - n),
kernel_size=2,
strides=1,
padding='same')(o)
o = tfkl.BatchNormalization(axis=1)(o)
o = tfkl.ReLU()(o)
o = tfkl.Cropping1D((0, o.shape[1] - input_size))(o)
o = tfkl.Conv1D(1, kernel_size=1, strides=1, padding='same')(o)
o = tfkl.Flatten()(o)
o = tfkl.Dense(tfpl.IndependentNormal.params_size(
(self.hparams['window_samples'], 1)),
activation='tanh')(o)
o = tfpl.IndependentNormal((self.hparams['window_samples'], 1))(o)
decoder = tfk.Model(inputs=i, outputs=o)
vae = tfk.Model(inputs=encoder.inputs,
outputs=decoder(encoder.outputs[0]))
return vae, encoder, decoder
def make_generator_model():
# input
noise = layers.Input(shape=(noise_dim, ))
label = layers.Input(shape=(1, ))
label_embedding = layers.Flatten()(layers.Embedding(num_classes, noise_dim)(label))
model_input = layers.multiply([noise, label_embedding])
# network
x = layers.Dense(1790 * 256, use_bias=False, input_shape=(noise_dim, ))(model_input)
x = layers.Reshape((1790, 256))(x)
x = layers.BatchNormalization(epsilon=2e-5, momentum=9e-1)(x)
x = layers.LeakyReLU()(x)
x = layers.Conv1D(256,
7,
strides=1,
padding='same',
use_bias=False,
kernel_initializer='glorot_uniform')(x)
x = layers.UpSampling1D(2)(x)
x = layers.BatchNormalization(epsilon=2e-5, momentum=9e-1)(x)
x = layers.LeakyReLU()(x)
x = layers.Conv1D(128,
5,
strides=1,
padding='same',
use_bias=False,
kernel_initializer='glorot_uniform')(x)
x = layers.UpSampling1D(2)(x)
x = layers.BatchNormalization(epsilon=2e-5, momentum=9e-1)(x)
x = layers.LeakyReLU()(x)
x = layers.Conv1D(channels,
5,
strides=1,
padding='same',
activation='softmax')(x)
return Model([noise, label], x)
def __init__(self, scale: tuple, interp=NEAREST, scope='UPS'):
super(Upscale, self).__init__(scope)
dim = len(scale)
if dim == 1:
self.fn = layers.UpSampling1D(scale_factor=scale, mode=TF_INTERP[interp])
elif dim == 2:
self.fn = layers.UpSampling2D(scale_factor=scale, mode=TF_INTERP[interp])
elif dim == 3:
self.fn = layers.UpSampling3D(scale_factor=scale, mode=TF_INTERP[interp])
else:
raise Exception('NEBULAE ERROR ⨷ %d-d upscaling is not supported.' % dim)
def __init__(self, channels, kernel_size=4, w_norm_clip=2,
use_initial_activation=True, normalization=None, **kwargs):
super(UpResBlock, self).__init__(**kwargs)
self.out_channels = channels
self.use_initial_activation = use_initial_activation
self.norm0 = None
self.norm1 = None
if normalization is "layer":
self.norm0 = layers.LayerNormalization(axis=[2])
self.norm1 = layers.LayerNormalization(axis=[2])
elif normalization is "batch":
self.norm0 = layers.BatchNormalization()
self.norm1 = layers.BatchNormalization()
self.initial_activation = layers.LeakyReLU(alpha=0.2)
self.up = layers.UpSampling1D(size=2)
self.conv0 = layers.Conv1D(filters=channels, kernel_size=kernel_size, padding="same", activation=layers.LeakyReLU(),
)#kernel_constraint=tf.keras.constraints.MaxNorm(max_value=w_norm_clip, axis=[0,1]))
self.conv1 = layers.Conv1D(filters=channels, kernel_size=kernel_size, padding="same",
)#kernel_constraint=tf.keras.constraints.MaxNorm(max_value=w_norm_clip, axis=[0,1]))
self.up_s = layers.UpSampling1D(size=2)
self.upconv_s = layers.Conv1D(filters=channels, kernel_size=1, padding="same",
)#kernel_constraint=tf.keras.constraints.MaxNorm(max_value=w_norm_clip, axis=[0,1]))
def upsample(x, c):
"""Upsamples tensor c to have the same second dimension as x
Args:
x (tf.Tensor): Input tensor of desired size
c (tf.Tensor): Conditional tensor to upsample
Returns:
tf.Tensor of c upsamples s.t. the 2nd dimension matches
that of x
"""
length = x.shape[1]
encoding_length = c.shape[1]
upsampling = layers.UpSampling1D(length / encoding_length)
return upsampling(c)
def cnn_2(N):
layer_in = tfkl.Input(shape=[N, 1])
enc = tfkl.Conv1D(256, 512, strides=128)(layer_in)
enc = tfkl.Conv1D(64, 3, activation='relu', padding='SAME')(enc)
enc = tfkl.Conv1D(64, 3, activation='relu', padding='SAME')(enc)
enc = tfkl.MaxPooling1D(2)
enc = tfkl.Conv1D(64, 3, activation='relu', padding='SAME')(enc)
enc = tfkl.Conv1D(64, 3, activation='relu', padding='SAME')(enc)
dec = tfkl.UpSampling1D(2)
dec = tfkl.Conv1D(64, 3, activation='relu', padding='SAME')(dec)
dec = tfkl.Conv1D(64, 3, activation='relu', padding='SAME')(dec)
dec = tfkl.Conv1D(256, 3, activation='relu', padding='SAME')(dec)
dec = tfkl.Conv1D(512, 1, activation='relu', padding='SAME')(dec)
out = overlap_and_add(dec, 128)
model = tf.keras.Model(inputs=[layer_in], outputs=[out])
return model
def __init__(self, hparams, **kwargs):
super(WaveGlow, self).__init__(dtype=hparams['ftype'], **kwargs)
assert (hparams['n_group'] % 2 == 0)
self.n_flows = hparams['n_flows']
self.n_group = hparams['n_group']
self.n_early_every = hparams['n_early_every']
self.n_early_size = hparams['n_early_size']
self.upsampling_size = hparams['upsampling_size']
self.hidden_channels = hparams['hidden_channels']
self.mel_channels = hparams['mel_channels']
self.hparams = hparams
self.normalisation = self.hparams['train_batch_size'] * self.hparams[
'segment_length']
self.waveNetAffineBlocks = []
self.weightNormInv1x1ConvLayers = []
self.upsampling = layers.UpSampling1D(size=self.upsampling_size,
dtype=self.dtype)
n_half = self.n_group // 2
n_remaining_channels = self.n_group
for index in range(self.n_flows):
if ((index % self.n_early_every == 0) and (index > 0)):
n_half -= self.n_early_size // 2
n_remaining_channels -= self.n_early_size
self.weightNormInv1x1ConvLayers.append(
tfa.layers.wrappers.WeightNormalization(
Inv1x1Conv(filters=n_remaining_channels,
dtype=hparams['ftype'],
name="newInv1x1conv_{}".format(index)),
data_init=False,
dtype=hparams['ftype']))
self.waveNetAffineBlocks.append(
WaveNetAffineBlock(n_in_channels=n_half,
n_channels=hparams['n_channels'],
n_layers=hparams['n_layers'],
kernel_size=hparams['kernel_size'],
dtype=hparams['ftype'],
name="waveNetAffineBlock_{}".format(index)))
self.n_remaining_channels = n_remaining_channels
def decoder_smate(encoder, timesteps, data_dim, pool_step):
input_ = encoder.output # input: (batch_size, timesteps, latent_dim)
out = ll.UpSampling1D(size=pool_step)(input_)
# 1D-CNN for reconstructing the spatial information
#cells = [rnn_cell(module_name) for _ in range(num_layers)]
#out = ll.RNN(cells, return_sequences=True)(out)
# temporal axis
if (module_name == 'gru'):
if (tf.test.is_gpu_available()):
out_t = ll.CuDNNGRU(hidden_dim, return_sequences=True)(out)
for i in range(num_layers - 1):
out_t = ll.CuDNNGRU(hidden_dim, return_sequences=True)(
out_t) # output: (batch_size, timesteps, hidden_dim)
else:
out_t = ll.GRU(hidden_dim, return_sequences=True)(out)
for i in range(num_layers - 1):
out_t = ll.GRU(hidden_dim, return_sequences=True)(
out_t) # output: (batch_size, timesteps, hidden_dim)
elif (module_name == 'lstm'):
if (tf.test.is_gpu_available()):
out_t = ll.CuDNNLSTM(hidden_dim, return_sequences=True)(out)
for i in range(num_layers - 1):
out_t = ll.CuDNNLSTM(hidden_dim, return_sequences=True)(
out_t) # output: (batch_size, timesteps, hidden_dim)
else:
out_t = ll.LSTM(hidden_dim, return_sequences=True)(out)
for i in range(num_layers - 1):
out_t = ll.LSTM(hidden_dim, return_sequences=True)(
out_t) # output: (batch_size, timesteps, hidden_dim)
out = ll.Dense(data_dim, activation='sigmoid')(out_t)
model = Model(encoder.input, out)
return model
def __init__(self, **kwargs):
super(_Subdecoder, self).__init__(**kwargs)
self.conv = create_conv1d()
self.cat = layers.Concatenate()
self.up_sample = layers.UpSampling1D(size=SAMPLING_RATE)
def build_model(nhr, nreg, conv_layers, l1, l2, lgdp1, lgdp2, gdp_out_name,
dec_out_name):
"""
Build the convolutional neural network.
Our model is constructed using the Keras functional API
(https://keras.io/getting-started/functional-api-guide/) which allows us to
have multiple inputs. Note that all inputs must be specified with an Input
layer.
The main input to this model is a 4-dimensional array:
[cases, weeks, hours, regions]
where
cases = number of quarters (open)
weeks = number of weeks in a quarter (open)
hours = 168, the number of hours in a week (fixed)
regions = number of spatial regions (fixed)
We need an additional inputs:
timestep = value representing time since the start of the data
"""
# Weekly timeseries input
input_numeric = layers.Input(shape=(nhr, nreg), name='HourlyElectricity')
# Time since start input (for dealing with energy efficiency changes)
input_time = layers.Input(shape=(1, ), name='TimeSinceStart')
# Previous quarter's GDP
input_gdp_prev = layers.Input(shape=(1, ), name='GDPPrev')
# Natural gas data at a weekly level
input_gas = layers.Input(shape=(1, ), name='NaturalGas')
# Petroleum data at a weekly level
input_petrol = layers.Input(shape=(1, ), name='Petroleum')
## Add a way to specify specific encodings to investigate what the
## encoder is responding to. The following scalar is either 1 or
## zero. 0 means normal operation; 1 means we use a specified
## input for the encoding.
input_switch = layers.Input(shape=(1, ), name='EncoderSwitch')
input_switch_complement = layers.Input(shape=(1, ),
name='EncoderSwitchComplement')
encoder_input = layers.Input(
shape=(l2, ), name='EncoderInput') # ignored if input_switch == 0.
# The convolutional layers need input tensors with the shape (batch, steps, channels).
# A convolutional layer is 1D in that it slides through the data length-wise,
# moving along just one dimension.
# Parameters for the convolutional layers are given as a comma-separated argument:
#
# [kernel_size]-[filters]-[pool_size (optional)],[filters]-...
#
# These are fed directly into the Conv1D layer, which has parameters:
# Conv1D(filters, kernel_size, ...)
conv_params = parse_conv_layers(conv_layers)
i = 0
for param_set in conv_params:
if i == 0:
convolutions = layers.Conv1D(
param_set[1],
param_set[0],
padding='same',
activation='relu',
bias_initializer='glorot_uniform')(input_numeric)
else:
convolutions = layers.Conv1D(
param_set[1],
param_set[0],
padding='same',
activation='relu',
bias_initializer='glorot_uniform')(convolutions)
convolutions = layers.MaxPool1D(param_set[2])(convolutions)
i += 1
feature_layer = layers.Flatten()(convolutions)
# Merge the inputs together and end our encoding with fully connected layers
encoded = layers.Dense(l1,
bias_initializer='glorot_uniform')(feature_layer)
encoded = layers.LeakyReLU()(encoded)
encoded = layers.Dense(l2,
bias_initializer='glorot_uniform',
name='FinalEncoding')(encoded)
encoded = layers.LeakyReLU()(encoded)
## Implement the input switch (see above).
# def oneminus(tensor):
# one = keras.backend.ones(shape=(1,))
# return layers.subtract([one, tensor])
# input_switch_complement = layers.Lambda(oneminus)(input_switch)
##input_switch_complement = layers.Subtract()([one, input_switch])
encoded = layers.Multiply()([encoded, input_switch_complement])
enc_in = layers.Multiply()([encoder_input, input_switch])
encoded = layers.Add(name='SwitchedEncoding')([encoded, enc_in])
# At this point, the representation is the most encoded and small; now let's build the decoder
decoded = layers.Dense(l1, bias_initializer='glorot_uniform')(encoded)
decoded = layers.LeakyReLU()(decoded)
decoded = layers.Dense(convolutions.shape[1] * convolutions.shape[2],
bias_initializer='glorot_uniform')(decoded)
decoded = layers.LeakyReLU()(decoded)
decoded = layers.Reshape((convolutions.shape[1], convolutions.shape[2]),
name='UnFlatten')(decoded)
for param_set in reversed(conv_params):
i -= 1
decoded = layers.UpSampling1D(param_set[2])(decoded)
if i == 0:
decoded = layers.Conv1D(nreg,
param_set[0],
padding='same',
activation='linear',
bias_initializer='glorot_uniform',
name=dec_out_name)(decoded)
else:
decoded = layers.Conv1D(conv_params[i - 1][1],
param_set[0],
padding='same',
activation='relu',
bias_initializer='glorot_uniform')(decoded)
# This is our actual output, the GDP prediction
merged_layer = layers.Concatenate()(
[encoded, input_time, input_gdp_prev, input_gas, input_petrol])
gdp_hidden_layer = layers.Dense(lgdp1, name='GDP_Hidden')(merged_layer)
gdp_hidden_layer = layers.LeakyReLU()(gdp_hidden_layer)
if lgdp2 > 0:
gdp_hidden_layer = layers.Dense(
lgdp2,
name='GDP_Hidden2',
kernel_regularizer=keras.regularizers.l1(0))(gdp_hidden_layer)
gdp_hidden_layer = layers.LeakyReLU()(gdp_hidden_layer)
output = layers.Dense(1, activation='linear',
name=gdp_out_name)(gdp_hidden_layer)
autoencoder = keras.models.Model(inputs=[
input_numeric, input_time, input_gdp_prev, input_gas, input_petrol,
input_switch, input_switch_complement, encoder_input
],
outputs=[output, decoded])
return autoencoder
cnn = Conv1D(72, 2, padding="same")(inputs)
cnn = layers.PReLU()(cnn)
concat = layers.Concatenate()([inputs, cnn])
return cnn
inputs = layers.Input((num_nits, 1))
inputs_2 = layers.MaxPool1D()(inputs)
inputs_3 = layers.MaxPool1D(4)(inputs)
net1 = fine(inputs=inputs)
net2 = midium(inputs_2)
net3 = coarse(inputs_3)
net2 = layers.UpSampling1D()(net2)
net3 = layers.UpSampling1D(4)(net3)
concat = layers.Add()([net1, net2, net3])
concat = layers.Flatten()(concat)
dense = layers.Dense(128, activation="relu")(concat)
outputs = layers.Dense(s)(concat)
model = tf.keras.Model(inputs, outputs)
####################################################################################################################################
####################################################################################################################################
from tensorflow.keras import layers
from tensorflow.keras.layers import Conv1D
def build_model(self):
inputs = layers.Input(shape=(self.window_size, 1))
conv_1 = layers.Conv1D(64, 3, activation='relu',
padding='same')(inputs)
conv_1 = layers.Conv1D(64, 3, activation='relu',
padding='same')(conv_1)
pool_1 = layers.MaxPooling1D(pool_size=2)(conv_1)
conv_2 = layers.Conv1D(128, 3, activation='relu',
padding='same')(pool_1)
conv_2 = layers.Conv1D(128, 3, activation='relu',
padding='same')(conv_2)
pool_2 = layers.MaxPooling1D(pool_size=2)(conv_2)
conv_3 = layers.Conv1D(256, 3, activation='relu',
padding='same')(pool_2)
conv_3 = layers.Conv1D(256, 3, activation='relu',
padding='same')(conv_3)
pool_3 = layers.MaxPooling1D(pool_size=2)(conv_3)
conv_4 = layers.Conv1D(512, 3, activation='relu',
padding='same')(pool_3)
conv_4 = layers.Conv1D(512, 3, activation='relu',
padding='same')(conv_4)
pool_4 = layers.MaxPooling1D(pool_size=2)(conv_4)
conv_5 = layers.Conv1D(1024, 3, activation='relu',
padding='same')(pool_4)
conv_5 = layers.Conv1D(1024, 3, activation='relu',
padding='same')(conv_5)
up_1 = layers.UpSampling1D(size=2)(conv_5)
merge_1 = layers.concatenate([conv_4, up_1], axis=2)
conv_6 = layers.Conv1D(512, 3, activation='relu',
padding='same')(merge_1)
conv_6 = layers.Conv1D(512, 3, activation='relu',
padding='same')(conv_6)
up_2 = layers.UpSampling1D(size=2)(conv_6)
merge_2 = layers.concatenate([conv_3, up_2], axis=2)
conv_7 = layers.Conv1D(256, 3, activation='relu',
padding='same')(merge_2)
conv_7 = layers.Conv1D(256, 3, activation='relu',
padding='same')(conv_7)
up_3 = layers.UpSampling1D(size=2)(conv_7)
merge_3 = layers.concatenate([conv_2, up_3], axis=2)
conv_8 = layers.Conv1D(128, 3, activation='relu',
padding='same')(merge_3)
conv_8 = layers.Conv1D(128, 3, activation='relu',
padding='same')(conv_8)
up_4 = layers.UpSampling1D(size=2)(conv_8)
merge_4 = layers.concatenate([conv_1, up_4], axis=2)
conv_9 = layers.Conv1D(64, 3, activation='relu',
padding='same')(merge_4)
conv_9 = layers.Conv1D(64, 3, activation='relu',
padding='same')(conv_9)
outputs = layers.Conv1D(self.num_states,
3,
activation="softmax",
padding="same")(conv_9)
final_reshape = layers.Reshape(
(self.window_size, self.num_states))(outputs)
model = Model(inputs, final_reshape, name='UNet')
return model
def coarse_fine(inputs):
def Net1(inputs):
cnn = Conv1D(18,6,padding="causal",activation="relu")(inputs)
cnn = Conv1D(18,6,padding="causal",activation="relu")(cnn)
cnn = Conv1D(36,6,padding="causal",activation="relu")(cnn)
cnn = Conv1D(36,6,padding="causal",activation="relu")(cnn)
cnn = Conv1D(74,6,padding="causal",activation="relu")(cnn)
cnn = Conv1D(74, 6, padding="causal", activation="relu")(cnn)
cnn = Conv1D(148, 6, padding="causal", activation="relu")(cnn)
cnn = Conv1D(148, 6, padding="causal", activation="relu")(cnn)
cnn = Conv1D(296, 6, padding="causal", activation="relu")(cnn)
return cnn
def Net2(inputs):
pool = layers.MaxPool1D(2)(inputs)
cnn = Conv1D(18,8,padding="causal",activation="relu")(pool)
cnn = Conv1D(36,8,padding="causal",activation="relu")(cnn)
cnn = Conv1D(74, 8, padding="causal", activation="relu")(cnn)
cnn = Conv1D(148, 8, padding="causal", activation="relu")(cnn)
cnn = Conv1D(296, 6, padding="causal", activation="relu")(cnn)
return cnn
def Net3(inputs):
pool = layers.MaxPool1D(4)(inputs)
cnn = Conv1D(36,8,padding="causal",activation="relu")(pool)
cnn = Conv1D(74, 8, padding="causal", activation="relu")(cnn)
cnn = Conv1D(148, 8, padding="causal", activation="relu")(cnn)
cnn = Conv1D(296, 8, padding="causal", activation="relu")(cnn)
return cnn
def Net4(inputs):
pool = layers.MaxPool1D(8)(inputs)
cnn = Conv1D(74, 6, padding="causal", activation="relu")(pool)
cnn = Conv1D(148, 6, padding="causal", activation="relu")(cnn)
cnn = Conv1D(296, 6, padding="causal", activation="relu")(cnn)
return cnn
def Net5(inputs):
pool = layers.MaxPool1D(16)(inputs)
cnn = Conv1D(148, 4, padding="causal", activation="relu")(pool)
cnn = Conv1D(296, 4, padding="causal", activation="relu")(cnn)
return cnn
def Net6(inputs):
pool = layers.MaxPool1D(32)(inputs)
cnn = Conv1D(296, 2, padding="causal", activation="relu")(pool)
return cnn
net1 = Net1(inputs=inputs)
net2 = Net2(inputs=inputs)
net3 = Net3(inputs=inputs)
net4 = Net4(inputs=inputs)
net5 = Net5(inputs=inputs)
net6 = Net6(inputs=inputs)
# fine_net = layers.UpSampling1D()(fine_net)
net2 = layers.UpSampling1D(2)(net2)
net3 = layers.UpSampling1D(4)(net3)
net4 = layers.UpSampling1D(8)(net4)
net5 = layers.UpSampling1D(16)(net5)
net6 = layers.UpSampling1D(32)(net6)
concat = layers.Add()([net1,net2,net3,net5,net6])
concat = layers.Flatten()(concat)
outputs = layers.Dense(1)(concat)
model = tf.keras.Model(inputs, outputs)
print(model.summary())
return model
layers.Dense(1, name='{}_pred'.format(param))(pre_pred))
encoder = keras.Model([encoder_inputs] + param_inputs,
[z_mean, z_log_var, z] + y_predictions,
name='encoder')
latent_inputs = keras.Input(shape=(latent_dim, ), name='z_sampling')
x = layers.Dense(np.prod(intermediate_shape),
activation="relu")(latent_inputs)
x = layers.Reshape(intermediate_shape)(x)
x = layers.Conv1DTranspose(fil2,
10,
activation="relu",
strides=1,
padding="same")(x)
x = layers.UpSampling1D(size=2)(x)
x = layers.Conv1DTranspose(fil1,
3,
activation="relu",
strides=1,
padding="same")(x)
x = layers.UpSampling1D(size=2)(x)
decoder_outputs = layers.Conv1DTranspose(2,
3,
activation="sigmoid",
padding="same")(x)
decoder = keras.Model(latent_inputs, decoder_outputs, name="decoder")
else:
## CONV 2D Model
def __init__(self,
filters,
kernel_size,
octave=2,
ratio_out=0.5,
strides=1,
dilation_rate=1,
activation=None,
use_bias=True,
kernel_initializer='glorot_uniform',
bias_initializer='zeros',
kernel_regularizer=None,
bias_regularizer=None,
activity_regularizer=None,
kernel_constraint=None,
bias_constraint=None,
**kwargs):
super(OctaveConv1D, self).__init__(**kwargs)
self.filters = filters
self.kernel_size = kernel_size
self.octave = octave
self.ratio_out = ratio_out
self.strides = strides
self.dilation_rate = dilation_rate
self.activation = activations.get(activation)
self.use_bias = use_bias
self.kernel_initializer = initializers.get(kernel_initializer)
self.bias_initializer = initializers.get(bias_initializer)
self.kernel_regularizer = regularizers.get(kernel_regularizer)
self.bias_regularizer = regularizers.get(bias_regularizer)
self.activity_regularizer = regularizers.get(activity_regularizer)
self.kernel_constraint = constraints.get(kernel_constraint)
self.bias_constraint = constraints.get(bias_constraint)
self.filters_low = int(filters * self.ratio_out)
self.filters_high = filters - self.filters_low
self.conv_high_to_high, self.conv_low_to_high = None, None
if self.filters_high > 0:
self.conv_high_to_high = self._init_conv(
self.filters_high, name='{}-Conv1D-HH'.format(self.name))
self.conv_low_to_high = self._init_conv(self.filters_high,
name='{}-Conv1D-LH'.format(
self.name))
self.conv_low_to_low, self.conv_high_to_low = None, None
if self.filters_low > 0:
self.conv_low_to_low = self._init_conv(self.filters_low,
name='{}-Conv1D-HL'.format(
self.name))
self.conv_high_to_low = self._init_conv(self.filters_low,
name='{}-Conv1D-LL'.format(
self.name))
self.pooling = layers.AveragePooling1D(
pool_size=self.octave,
padding='valid',
name='{}-AveragePooling1D'.format(self.name),
)
self.up_sampling = layers.UpSampling1D(
size=self.octave,
name='{}-UpSampling1D'.format(self.name),
)
def octave_conv_1d(inputs,
filters,
kernel_size,
octave=2,
ratio_out=0.5,
strides=1,
dilation_rate=1,
activation=None,
use_bias=True,
kernel_initializer='glorot_uniform',
bias_initializer='zeros',
kernel_regularizer=None,
bias_regularizer=None,
activity_regularizer=None,
kernel_constraint=None,
bias_constraint=None,
name=None,
**kwargs):
if isinstance(inputs, (list, tuple)):
inputs_high, inputs_low = inputs
else:
inputs_high, inputs_low = inputs, None
filters_low = int(filters * ratio_out)
filters_high = filters - filters_low
def _init_conv(conv_filters, conv_name_suffix):
if name is None:
conv_name = None
else:
conv_name = name + '-' + conv_name_suffix
return layers.Conv1D(filters=conv_filters,
kernel_size=kernel_size,
strides=strides,
padding='same',
dilation_rate=dilation_rate,
activation=activation,
use_bias=use_bias,
kernel_initializer=kernel_initializer,
bias_initializer=bias_initializer,
kernel_regularizer=kernel_regularizer,
bias_regularizer=bias_regularizer,
activity_regularizer=activity_regularizer,
kernel_constraint=kernel_constraint,
bias_constraint=bias_constraint,
name=conv_name,
**kwargs)
outputs_high = None
if filters_high > 0:
outputs_high = _init_conv(filters_high, 'HH')(inputs_high)
if inputs_low is not None:
if name is None:
up_sampling_name, add_name = None, None
else:
up_sampling_name, add_name = name + '-UpSample', name + '-Add-H'
outputs_high = layers.Add(name=add_name)([
outputs_high,
layers.UpSampling1D(
size=octave,
name=up_sampling_name,
)(_init_conv(filters_high, 'LH')(inputs_low))
])
outputs_low = None
if filters_low > 0:
if name is None:
pooling_name, add_name = None, None
else:
pooling_name, add_name = name + '-Pool', name + '-Add-L'
outputs_low = _init_conv(filters_low, 'HL')(layers.AveragePooling1D(
pool_size=octave,
padding='valid',
name=pooling_name,
)(inputs_high))
if inputs_low is not None:
outputs_low = layers.Add(name=add_name)(
[_init_conv(filters_low, 'LL')(inputs_low), outputs_low])
if outputs_high is None:
return outputs_low
if outputs_low is None:
return outputs_high
return [outputs_high, outputs_low]
