I am struggling to understand the actual function of supervisor. G_loss_S = tf.losses.mean_squared_error(H[:,1:,:], H_hat_supervise[:,1:,:]) What this line acutally does? Doesn't it force supervisor to learn identity between H and H_hat_supervise?

What sequence should the supervisor generate? Is it generating from [0, T] to [1, T+1] or is it trying to reflect the original sequence [0, T]?

Hi !

First, thanks for the amazing work. I would like to use this code but unfortunately, all the warning from your Jupiter Notebook are now errors since TensorFlow dropped the next version.

Is there any way to have the code updated?

Thanks and keep the good job !

Hi, Thanks for the wonderful Time Gans approach. I was trying to execute the Juypter notebook from Colab and while executing the line " generated_data = timegan(ori_data, parameters) " I am getting Attribute Error. Have attached the error detail below. Kindly let me how to overcome this error. Thanks

Mritula

AttributeError Traceback (most recent call last) in () 1 # Run TimeGAN ----> 2 generated_data = timegan(ori_data, parameters) 3 print('Finish Synthetic Data Generation')

/content/cloned-repo/cloned-repo/timegan.py in timegan(ori_data, parameters) 36 """ 37 # Initialization on the Graph ---> 38 tf.reset_default_graph() 39 40 # Basic Parameters

AttributeError: module 'tensorflow' has no attribute 'reset_default_graph'

Hello @jsyoon0823 , As the ouput is synthetic time series, as for example I am using time series data from start date to end date. So, how to determine what would be start date and end date of synthetic time series generated?

Hi!

When I generate data, let's say with da dataset with 1000 samples and sequence length 10 and 20 features, the output of the generated data should have the shape (1000, 10, 20), am I right? How can I convert the data back in the shape of the original data, so (1000, 20)?

Hi, Yoon! It is a great work for sequence generation! And I am a new at this field, May I ask a question that if I could use my own dataset with different length(timestamp) of each multidimensional sample(in another word,the sample has the shape as [timestamp, features], whose 'timestamp' is unfixed while 'features' is fixed), what should I do to process the data as well as the training model? Yours, Hu!

Hi!

Why does the data get flipped for the purpose of chronology. As far as I can see, the original dataset of energy data for example is already in chronological order.

Kind regards!

Hi @jsyoon0823, Thank you for your great work and for sharing your code.

I have a few questions related to the implementation of supervised loss introduced in the paper. First, in Eq. 9: the generator takes in z_t as the input, while in the code, I see no z in the arguments here https://github.com/jsyoon0823/TimeGAN/blob/master/timegan.py#L132.

Second, I see you create another supervisor network for that purpose instead of using the generator, and the loss here https://github.com/jsyoon0823/TimeGAN/blob/master/timegan.py#L200 (between H=embedder(X, T) and H_hat_supervise=supervisor(H, T)) has no connection with the generator, so I wonder how the supervision loss helps training generator (same question with issue #35).

Third, what is the motivation for using num_layers-1 layers in the supervisor network? (https://github.com/jsyoon0823/TimeGAN/blob/master/timegan.py#L143)

Please correct me if I misunderstand something.

Best, Hieu

Firstly, many thanks for your countless efforts on the work of TimeGAN and the distribution of the package to the community. I'm really enjoying implementing it!

One question to ask regarding the random vector, from the theory within the paper and the code implementation.

In the paper, z_t is thought to be the Wiener process which I think is reasonable since the time correlation is present throughout the series. In the code implementation, however, I've noticed that the way you generate the random vector is via the random_generator function from the utils.py, which samples its element from the NumPy uniform function.

As far as I know, the NumPy uniform function is independent of the previously sampled value and does not form a Wiener process.

Am I missing something here?

Thanks.

First of all, great work with TimeGAN! Really an interesting paper.

I have a question regarding the supervised loss, computed as follows: G_loss_S = tf.losses.mean_squared_error(H[:,1:,:], H_hat_supervise[:,:-1,:]) .

I understand the purpose of the supervisor. However, I am confused by the fact that the generator is supposed to be trained on G_loss_S in the second step of training TimeGAN (you call it 'Training only with supervised loss'), although it does not contribute to the computation and consequently no gradients are available. Why is that?

Hi, I have a trouble about how to reproduce the results on autoregressive multivariate Gaussian data on section 5.1. I write multivariate gaussian data generation code according to your description, but I failed finally. So, What should I do to reproduce it? Here is my code, can you help me to solve this difficult? Thanks in advance!

def normalize(data):
    def min_max_norm(data):
        """ Normalize data to range [0, 1]. """
        min_val = np.min(data, axis=0)
        max_val = np.max(data, axis=0)
        data = (data - min_val)/(max_val - min_val + 1e-7)

        return data
    
    ori_data = np.array(data)

    return min_max_norm(ori_data)

def get_multi_gaussian_data(num_samples, seq_len, num_features, phi, sigma, burn_in=0):
    """ Multivariate Gaussian Data Generation

    Args:
        - num_samples: the number of samples
        - seq_len: sequence length of each time-series sample
        - num_features: the number of features of multivariate gaussian data
        - phi: control the correlation across time steps
        - sigma: control the correlation across features

    Returns:
        - data: generated multi-gaussian data, [num_samples, seq_len, num_features]    
    """
    # First: generate time-series data
    total_len = num_samples + seq_len + burn_in
    x = np.zeros((total_len, num_features))
    ## Set mean and covariace matrix for multivariate normal distribution
    one = np.ones(num_features)
    ide_mat = np.identity(num_features)     # identity matrix
    mu = np.zeros(num_features)
    cov_mat = sigma*one + (1-sigma)*ide_mat
    ## epsilon matrix
    eps_mat = np.random.multivariate_normal(mu, cov_mat, total_len)
    ## generate t+1 step from t step
    x[0, :] = 0     # x_0 = 0
    for t in range(1, total_len):   # x_1, x_2, ..., x_{total_len-1}
        x[t, :] = phi*x[t-1, :] + eps_mat[t-1, :]
    ## delete first burn_in samples
    x = x[burn_in:, :]

    # Second: data normalization
    x = normalize(x)

    # Third: samples generation
    ## Initialize the output
    data = []
    ## each sample has shape seq_len*num_features
    for i in range(x.shape[0] - seq_len):
        data_ = x[i:(i+seq_len), :]
        data.append(data_)
    
    return np.array(data)       # [num_samples, seq_len, num_features]

Bumps tensorflow from 1.15.0 to 2.9.3.

Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting @dependabot rebase.