deep.py

import os
import time
import warnings
import numpy as np
from numpy import newaxis
from keras.layers.core import Dense, Activation, Dropout
from keras.layers.recurrent import LSTM
from keras.models import Sequential

os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3' #Hide messy TensorFlow warnings
warnings.filterwarnings("ignore") #Hide messy Numpy warnings


def load_data(filename, seq_len, normalise_window):
    f = open(filename, 'rb').read()
    data = f.decode().split('\n')

    sequence_length = seq_len + 1
    result = []
    for index in range(len(data) - sequence_length):
        result.append(data[index: index + sequence_length])


    if normalise_window:
        result = normalise_windows(result)
        print "CONDUCTED"
        #print result

    result = np.array(result)
    #print "$$$$$$$$$$$$$$$$"
#    print result.shape

    row = round(0.9 * result.shape[0])
    train = result[:int(row), :]


    np.random.shuffle(train)
    x_train = train[:, :-1]
    y_train = train[:, -1]
    x_test = result[int(row):, :-1]
    y_test = result[int(row):, -1]


    x_train = np.reshape(x_train, (x_train.shape[0], x_train.shape[1], 1))
    x_test = np.reshape(x_test, (x_test.shape[0], x_test.shape[1], 1))

    print "*************"
    print x_train
    print x_train.shape
    return [x_train, y_train, x_test, y_test]

def normalise_windows(window_data):
    normalised_data = []
    for window in window_data:
        normalised_window = [((float(p) / float(window[0])) - 1) for p in window]
        normalised_data.append(normalised_window)
    return normalised_data

def build_model(layers):
    model = Sequential()

    model.add(LSTM(
        input_dim=layers[0], # should be just one dimensional if we only have prices as our data input
        output_dim=layers[1],
        return_sequences=True))
    model.add(Dropout(0.2))

    model.add(LSTM(
        layers[2],
        return_sequences=False))
    model.add(Dropout(0.2))

    model.add(Dense(
        output_dim=layers[3]))
    model.add(Activation("linear"))

    start = time.time()
    model.compile(loss="mse", optimizer="rmsprop")
    print("> Compilation Time : ", time.time() - start)
    return model

def predict_sequences_multiple(model, data, window_size, prediction_len):
    #Predict sequence of 50 steps before shifting prediction run forward by 50 steps
    prediction_seqs = []

    for i in range(int(len(data)/prediction_len)):
        curr_frame = data[i*prediction_len]
        #print data
        #print "**********"
        print len(data)
        #print curr_frame
        predicted = []
        for j in range(prediction_len):
            predicted.append(model.predict(curr_frame[newaxis,:,:])[0,0])
            curr_frame = curr_frame[1:]
            curr_frame = np.insert(curr_frame, [window_size-1], predicted[-1], axis=0)
        prediction_seqs.append(predicted)
    return prediction_seqs


global_start_time = time.time()
epochs  = 1
seq_len = 50

print('> Loading data... ')


X_train, y_train, X_test, y_test = load_data('closingSP.csv', seq_len, True)

print "//////////////////////"
print X_train.shape


print('> Data Loaded. Compiling...')
#print X_train

model = build_model([1, 50, 100, 1])
print model.summary()

model.fit(
    X_train,
	y_train,
	batch_size=512,
	nb_epoch=epochs,
	validation_split=0.05)

predictions = predict_sequences_multiple(model, X_test, seq_len, 50)

print"&"
#print predictions
#predicted = lstm.predict_sequence_full(model, X_test, seq_