text: 
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  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='forecast_original_scale')
  
  
  
  
  
  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')