""" The name suggests the inverse of dropout, i.e. adding more samples. See Data Augmentation section at

http://simaaron.github.io/Estimating-rainfall-from-weather-radar-readings-using-recurrent-neural-networks/

:param X: Each row is a training sequence

:param y: Tne target we train and will later predict

:return: new augmented X, y

"""

print("X shape:", X.shape)

print("y shape:",y.shape)

X_hat = []

y_hat = []

for i in range(0, len(X)):

for j in range(0, np.random.random_integers(0,20)):

X_hat.append(X[i, :])

y_hat.append(y[i])

result_mean = result.mean()

result_std = result.std()

result -= result_mean

result /= result_std

test_start, test_end):

data = np.loadtxt(path_to_dataset)

data = savitzky_golay(data[:, 1], 11, 3) # smoothed version

print("Length of Data", len(data))

# train data

print "Creating train data..."

result = []

for index in range(train_start, train_end - sequence_length):

result.append(data[index: index + sequence_length])

result = np.array(result) # shape (samples, sequence_length)

result, result_mean = z_norm(result)

print "Mean of train data : ", result_mean

print "Train data shape : ", result.shape

train = result[train_start:train_end, :]

np.random.shuffle(train) # shuffles in-place

X_train = train[:, :-1]

y_train = train[:, -1]

X_train, y_train = dropin(X_train, y_train)

# test data

print "Creating test data..."

result = []

for index in range(test_start, test_end - sequence_length):

result.append(data[index: index + sequence_length])

result = np.array(result) # shape (samples, sequence_length)

result, result_mean = z_norm(result)

print "Mean of test data : ", result_mean

print "Test data shape : ", result.shape

X_test = result[:, :-1]

y_test = result[:, -1]

print("Shape X_train", np.shape(X_train))

print("Shape X_test", np.shape(X_test))

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))

model = Sequential()

layers = {'input': 1, 'hidden1': 64, 'hidden2': 256, 'hidden3': 100, 'output': 1}

model.add(LSTM(

input_length=sequence_length - 1,

input_dim=layers['input'],

output_dim=layers['hidden1'],

return_sequences=True))

model.add(Dropout(0.2))

model.add(LSTM(

layers['hidden2'],

return_sequences=True))

model.add(Dropout(0.2))

model.add(LSTM(

layers['hidden3'],

return_sequences=False))

model.add(Dropout(0.2))

model.add(Dense(

output_dim=layers['output']))

model.add(Activation("linear"))

start = time.time()

model.compile(loss="mse", optimizer="rmsprop")

print "Compilation Time : ", time.time() - start

global_start_time = time.time()

epochs = 1

if data is None:

print 'Loading data... '

X_train, y_train, X_test, y_test = get_split_prep_data(

0, 3000, 3000, 12000)

else:

X_train, y_train, X_test, y_test = data

print '\nData Loaded. Compiling...\n'

if model is None:

model = build_model()

try:

print("Training")

model.fit(

X_train, y_train,

batch_size=512, nb_epoch=epochs, validation_split=0.05)

print("Predicting")

predicted = model.predict(X_test)

print("shape of predicted", np.shape(predicted), "size", predicted.size)

print("Reshaping predicted")

predicted = np.reshape(predicted, (predicted.size,))

except KeyboardInterrupt:

print("prediction exception")

print 'Training duration (s) : ', time.time() - global_start_time

return model, y_test, 0

try:

plt.figure(1)

plt.subplot(311)

plt.title("Actual Signal w/Anomalies")

plt.plot(y_test[:len(y_test)], 'b')

plt.subplot(312)

plt.title("Predicted Signal")

plt.plot(predicted[:len(y_test)], 'g')

plt.subplot(313)

plt.title("Squared Error")

mse = ((y_test - predicted) ** 2)

plt.plot(mse, 'r')

plt.show()

except Exception as e:

print("plotting exception")

print str(e)

print 'Training duration (s) : ', time.time() - global_start_time