def gen_mutants():
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    import tensorflow as tf
    import pandas
    import numpy as np
    
    
    
    
    
    
    DATAFILE_TRAIN = 'mock_kaggle_edit_train.csv'
    
    DATAFILE_VALIDATE = 'mock_kaggle_edit_validate.csv'
    
    
    
    
    
    TRAINED_MODEL_PATH = 'savedModel'
    
    TIME_STEPS = 10
    NUMBER_OF_DAYS_TO_FORECAST = 1
    
    BATCH_SIZE = 100
    
    NUM_EPOCHS = 100
    
    LSTM_UNITS = 250
    
    TENSORBOARD_LOGDIR = 'tensorboard_log'
    
    
    
    
    
    
    data_train = pandas.read_csv(DATAFILE_TRAIN)
    data_validate = pandas.read_csv(DATAFILE_VALIDATE)
    
    
    
    
    
    
    data_train.head()
    
    
    
    
    
    
    
    numTrainingData = len(data_train)
    numValidationData = len(data_validate)
    
    trainingData_date = data_train['date'][0:numTrainingData]
    trainingData_sales = data_train['sales'][0:numTrainingData]
    trainindData_price = data_train['price'][0:numTrainingData]
    
    validationData_date = data_validate['date'][0:numValidationData]
    validationData_sales = data_validate['sales'][0:numValidationData]
    validationData_price = data_validate['price'][0:numValidationData]
    
    
    
    
    
    trainingData_sales.head()
    
    
    
    
    
    print(len(trainingData_sales))
    print(len(validationData_sales))
    
    
    
    
    
    
    
    
    trainingData_sales_min = min(trainingData_sales)
    trainingData_sales_max = max(trainingData_sales)
    trainingData_sales_range = trainingData_sales_max - trainingData_sales_min
    trainingData_sales_normalised = [(i - trainingData_sales_min) / trainingData_sales_range for i in trainingData_sales]
    
    validationData_sales_normalised = [(i - trainingData_sales_min) / trainingData_sales_range for i in validationData_sales]
    
    
    
    
    
    
    print('Min:', trainingData_sales_min)
    print('Range:', trainingData_sales_max - trainingData_sales_min)
    
    
    
    
    
    
    trainingDataSequence_sales = np.zeros(shape=(((len(trainingData_sales) - TIME_STEPS) - NUMBER_OF_DAYS_TO_FORECAST) + 1, TIME_STEPS, 1))
    targetDataSequence_sales = np.zeros(shape=(((len(trainingData_sales) - TIME_STEPS) - NUMBER_OF_DAYS_TO_FORECAST) + 1, NUMBER_OF_DAYS_TO_FORECAST))
    start = 0
    for i in range(TIME_STEPS, (len(trainingData_sales) - NUMBER_OF_DAYS_TO_FORECAST) + 1):
        trainingDataSequence_sales[start,:,0] = trainingData_sales_normalised[start:i]
        targetDataSequence_sales[start] = trainingData_sales_normalised[i:i + NUMBER_OF_DAYS_TO_FORECAST]
        start = start + 1
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    [trainingDataSequence_sales[i,:,0] for i in range(3)]
    
    
    
    
    
    
    [targetDataSequence_sales[i] for i in range(3)]
    
    
    
    
    
    
    
    
    
    
    
    
    a = np.arange(len(targetDataSequence_sales))
    np.random.shuffle(a)
    trainingDataSequence_sales_shuffle = np.zeros(shape=(((len(trainingData_sales) - TIME_STEPS) - NUMBER_OF_DAYS_TO_FORECAST) + 1, TIME_STEPS, 1))
    targetDataSequence_sales_shuffle = np.zeros(shape=(((len(trainingData_sales) - TIME_STEPS) - NUMBER_OF_DAYS_TO_FORECAST) + 1, NUMBER_OF_DAYS_TO_FORECAST))
    
    loc = 0
    for i in a:
        trainingDataSequence_sales_shuffle[loc] = trainingDataSequence_sales[i]
        targetDataSequence_sales_shuffle[loc] = targetDataSequence_sales[i]
        loc += 1
    
    trainingDataSequence_sales = trainingDataSequence_sales_shuffle
    targetDataSequence_sales = targetDataSequence_sales_shuffle
    
    
    
    
    
    
    validationDataSequence_sales = np.zeros(shape=(((len(validationData_sales) - TIME_STEPS) - NUMBER_OF_DAYS_TO_FORECAST) + 1, TIME_STEPS, 1))
    validationDataSequence_sales_target = np.zeros(shape=(((len(validationData_sales) - TIME_STEPS) - NUMBER_OF_DAYS_TO_FORECAST) + 1, NUMBER_OF_DAYS_TO_FORECAST))
    
    start = 0
    for i in range(TIME_STEPS, (len(validationData_sales) - NUMBER_OF_DAYS_TO_FORECAST) + 1):
        validationDataSequence_sales[start,:,0] = validationData_sales_normalised[start:i]
        validationDataSequence_sales_target[start] = validationData_sales_normalised[i:i + NUMBER_OF_DAYS_TO_FORECAST]
        start += 1
    
    
    
    
    
    
    tf.reset_default_graph()
    
    inputSequencePlaceholder = tf.placeholder(dtype=tf.float32, shape=(None, TIME_STEPS, 1), name='inputSequencePlaceholder')
    targetPlaceholder = tf.placeholder(dtype=tf.float32, shape=(None, NUMBER_OF_DAYS_TO_FORECAST), name='targetPlaceholder')
    
    
    cell = tf.nn.rnn_cell.LSTMCell(num_units=LSTM_UNITS, name='LSTM_cell')
    
    
    (output, state) = tf.nn.dynamic_rnn(cell=cell, inputs=inputSequencePlaceholder, dtype=tf.float32)
    
    
    lastCellOutput = output[:,-1,:]
    
    
    
    
    
    print('output:', output)
    print('state:', state)
    print('lastCellOutput:', lastCellOutput)
    
    
    
    
    
    
    
    
    
    
    
    
    
    weights = tf.Variable(initial_value=tf.truncated_normal(shape=(LSTM_UNITS, NUMBER_OF_DAYS_TO_FORECAST)))
    bias = tf.Variable(initial_value=tf.ones(shape=NUMBER_OF_DAYS_TO_FORECAST))
    
    forecast = tf.add(x=tf.matmul(a=lastCellOutput, b=weights), y=bias, name='forecast_normalised_scale')
    
    
    
    
    forecast_originalScale = tf.add(x=forecast * trainingData_sales_range, y=trainingData_sales_min, name='mutpy')
    
    
    
    
    
    print(forecast)
    print(forecast_originalScale)
    
    
    
    
    
    
    
    loss = tf.reduce_mean(tf.squared_difference(x=forecast, y=targetPlaceholder), name='loss_comp')
    
    tf.summary.scalar(tensor=loss, name='loss')
    
    
    
    
    
    optimizer = tf.train.AdamOptimizer(learning_rate=0.1)
    minimize_step = optimizer.minimize(loss)
    
    
    
    
    
    
    
    
    
    
    
    with tf.Session() as sess:
        sess.run(tf.global_variables_initializer())
        sess.run(tf.local_variables_initializer())
        
        
        tensorboard_writer = tf.summary.FileWriter(TENSORBOARD_LOGDIR, sess.graph)
        
        
        all_summary_ops = tf.summary.merge_all()
        
        
        numSteps = 0
        for e in range(NUM_EPOCHS):
            print('starting training for epoch:', e + 1)
            
            startLocation = 0
            iteration = 0
            for iteration in range(int(len(targetDataSequence_sales) / BATCH_SIZE)):
                print('epoch:', e + 1, ' iteration:', iteration + 1)
                trainingBatchInput = trainingDataSequence_sales[startLocation:startLocation + BATCH_SIZE,:,:]
                trainingBatchTarget = targetDataSequence_sales[startLocation:startLocation + BATCH_SIZE]
                
                (_, lsBatch, forecastBatch, forecastBatch_originalScale, summary_values) = sess.run([minimize_step, loss, forecast, forecast_originalScale, all_summary_ops], feed_dict={inputSequencePlaceholder: trainingBatchInput, \
                    targetPlaceholder: trainingBatchTarget})
                
                tensorboard_writer.add_summary(summary_values, numSteps)
                numSteps += 1
                
                if (iteration + 1) % 1 == 0:
                    print('got a loss of:', lsBatch)
                    print('the forecast of first 5 normalised are:', forecastBatch[0:5])
                    print('while the actuals were normalised     :', trainingBatchTarget[0:5])
                    print('the forecast of first 5 orignal scale are:', forecastBatch_originalScale[0:5])
                    print('while the actuals were original scale     :', (trainingBatchTarget[0:5] * trainingData_sales_range) + trainingData_sales_min)
                
                startLocation += BATCH_SIZE
            
            
            if len(targetDataSequence_sales) > startLocation:
                print('epoch:', e + 1, ' iteration:', iteration + 1)
                trainingBatchInput = trainingDataSequence_sales[startLocation:len(targetDataSequence_sales),:,:]
                trainingBatchTarget = targetDataSequence_sales[startLocation:len(targetDataSequence_sales)]
                
                (_, lsBatch, forecastBatch, forecastBatch_originalScale) = sess.run([minimize_step, loss, forecast, forecast_originalScale], feed_dict={inputSequencePlaceholder: trainingBatchInput, \
                    targetPlaceholder: trainingBatchTarget})
                
                print('got a loss of:', lsBatch)
                print('the forecast of first 5 normalised are:', forecastBatch[0:5])
                print('while the actuals were normalised     :', trainingBatchTarget[0:5])
                print('the forecast of first 5 orignal scale are:', forecastBatch_originalScale[0:5])
                print('while the actuals were original scale     :', (trainingBatchTarget[0:5] * trainingData_sales_range) + trainingData_sales_min)
            
            
            
            totalValidationLoss = 0
            startLocation = 0
            print('starting validation')
            for iter in range(len(validationDataSequence_sales) // BATCH_SIZE):
                validationBatchInput = validationDataSequence_sales[startLocation:startLocation + BATCH_SIZE,:,:]
                validationBatchTarget = validationDataSequence_sales_target[startLocation:startLocation + BATCH_SIZE]
                
                (validationLsBatch, validationForecastBatch, validationForecastBatch_originalScale) = sess.run([loss, forecast, forecast_originalScale], feed_dict={inputSequencePlaceholder: validationBatchInput, \
                    targetPlaceholder: validationBatchTarget})
                
                
                startLocation += BATCH_SIZE
                totalValidationLoss += validationLsBatch
                
                print('first five predictions:', validationForecastBatch[0:5])
                print('first five actuals    :', validationBatchTarget[0:5])
                print('the forecast of first 5 orignal scale are:', validationForecastBatch_originalScale[0:5])
                print('while the actuals were original scale     :', (validationBatchTarget[0:5] * trainingData_sales_range) + trainingData_sales_min)
            
            
            if startLocation < len(validationDataSequence_sales):
                validationBatchInput = validationDataSequence_sales[startLocation:len(validationDataSequence_sales)]
                validationBatchTarget = validationDataSequence_sales_target[startLocation:len(validationDataSequence_sales)]
                
                (validationLsBatch, validationForecastBatch) = sess.run([loss, forecast], feed_dict={inputSequencePlaceholder: validationBatchInput, \
                    targetPlaceholder: validationBatchTarget})
                
                totalValidationLoss += validationLsBatch
            
            
            print('Validation completed after epoch:', e + 1, '. Total validation loss:', totalValidationLoss)
        
        
        print('----------- Saving Model')
        tf.saved_model.simple_save(sess, export_dir=TRAINED_MODEL_PATH, inputs=\
            {'inputSequencePlaceholder': inputSequencePlaceholder, 'targetPlaceholder': targetPlaceholder}, outputs=\
            {'loss': loss, 'forecast_originalScale': forecast_originalScale})
        print('saved model to:', TRAINED_MODEL_PATH)
    
    print('----------- Finis')