data-maker/data/gan.py

"""
usage :
    optional :
    --num_gpu   number of gpus to use will default to 1
    --epoch     steps per epoch default to 256
"""
import tensorflow as tf
from tensorflow.contrib.layers import l2_regularizer
import numpy as np
import pandas as pd
import time
import os
import sys
        self.NUM_GPUS = 1 if 'num_gpu' not in args else args['num_gpu']
        self.train_dir  = os.sep.join([self.log_dir,'train',self.CONTEXT])        
        self.out_dir = os.sep.join([self.log_dir,'output',self.CONTEXT])
        
    def load_meta(self,column):
        """
        This function is designed to accomodate the uses of the sub-classes outside of a strict dependency model.
        Because prediction and training can happen independently
        """
        return _object
        average_grads = []
        for grad_and_vars in zip(*tower_grads):
            grads = []
            for g, _ in grad_and_vars:
                expanded_g = tf.expand_dims(g, 0)
                grads.append(expanded_g)

            grad = tf.concat(axis=0, values=grads)
            grad = tf.reduce_mean(grad, 0)

            v = grad_and_vars[0][1]
            grad_and_var = (grad, v)
            average_grads.append(grad_and_var)
        return average_grads        


class Generator (GNet):
    """
    This class is designed to handle generation of candidate datasets for this it will aggregate a discriminator, this allows the generator not to be random
    
    """
    def __init__(self,**args):
        GNet.__init__(self,**args)
        self.discriminator = Discriminator(**args)
    def loss(self,**args):
        fake    = args['fake']
        label   = args['label']
        y_hat_fake = self.discriminator.network(inputs=fake, label=label)
                kernel = self.get.variables(name='W_' + str(i), shape=[self.D_STRUCTURE[i], dim])
                bias = self.get.variables(name='b_' + str(i), shape=[dim])

                        #vars_ = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, scope=stage)
                        vars_ = tf.compat.v1.get_collection(tf.compat.v1.GraphKeys.TRAINABLE_VARIABLES, scope=stage)
                    w_sum = 0
                    for i in range(self.STEPS_PER_EPOCH):
                        for _ in range(2):
                            _, w = sess.run([train_d, w_distance])
                            w_sum += w
                        sess.run(train_g)
                    duration = time.time() - start_time

                    assert not np.isnan(w_sum), 'Model diverged with loss = NaN'

                    format_str = 'epoch: %d, w_distance = %f (%.1f)'
                    print(format_str % (epoch, -w_sum/(self.STEPS_PER_EPOCH*2), duration))
            return df.to_dict(orient='lists')
            # return df.to_dict(orient='list')
    
    context     = SYS_ARGS['raw-data'].split(os.sep)[-1:][0][:-4]
    if set(['train','learn']) & set(SYS_ARGS.keys()):
        
        df = pd.read_csv(SYS_ARGS['raw-data'])   
        
        # cols = SYS_ARGS['column']
        # _map,_df = (Binary()).Export(df)
        # i = np.arange(_map[column]['start'],_map[column]['end'])
        max_epochs = np.int32(SYS_ARGS['max_epochs']) if 'max_epochs' in SYS_ARGS else 10
        # REAL    = _df[:,i]
        REAL    = pd.get_dummies(df[column]).astype(np.float32).values
        LABEL = pd.get_dummies(df[column_id]).astype(np.float32).values
        trainer = Train(context=context,max_epochs=max_epochs,real=REAL,label=LABEL,column=column,column_id=column_id)
        trainer.apply()
        
        
       
        
        #
        # We should train upon this data
        #
        # -- we need to convert the data-frame to binary matrix, given a column
        #
        pass
    elif 'generate' in SYS_ARGS:
        values = df[column].unique().tolist()
        values.sort()