from __future__ import absolute_import

from __future__ import print_function

import matplotlib.pyplot as plt

import autograd.numpy as np

import autograd.numpy.random as npr

from autograd import value_and_grad,grad

from scipy.optimize import minimize

import autograd.scipy.stats.multivariate_normal as mvn

from sklearn.cross_validation import train_test_split

from autograd.scipy.misc import logsumexp

from autograd.util import quick_grad_check

import time

import pandas as pd

from deep_gaussian_process_6 import rbf_covariance, pack_gp_params, pack_layer_params, pack_deep_params, build_deep_gp, initialize,build_step_function_dataset

def test_log_likelihood(all_params, X, y, n_samples):

rs = npr.RandomState(0)

samples = [sample_mean_cov_from_deep_gp(all_params, X, True, rs, FITC = True) for i in xrange(n_samples)]

return logsumexp(np.array([mvn.logpdf(y,mean,var) for mean,var in samples]))

def test_squared_error(all_params, X, y, n_samples):

rs = npr.RandomState(0)

samples = np.array([sample_mean_cov_from_deep_gp(all_params, X, True, rs, FITC = True)[0] for i in xrange(n_samples)])

return np.mean((y - np.mean(samples,axis = 0)) ** 2)

def callback(params):

print("Log likelihood {}, MSE {}".format(-objective(params),squared_error(params,X,y,n_samples)))

def plot_single_gp(ax, params, layer, unit, plot_xs, n_samples_to_plot):

ax.set_yticks([])

def plot_deep_gp(ax, params, plot_xs, n_samples_to_plot):

#ax.set_title("Full Deep GP, inputs to outputs")

if __name__ == '__main__':

random = 1

n_samples = 10

n_samples_to_test = 100

num_pseudo_params = 50

dimensions =[1,1,1]

n_layers = len(dimensions)-1

npr.seed(0) #Randomness comes from KMeans

rs = npr.RandomState(0)

motor = np.genfromtxt('motor.csv', delimiter=',',skip_header = True)

X = motor[:,1]

X = (X - np.mean(X))/(np.std(X))

X = X.reshape(len(X),1)

y = motor[:,2]

y = (y-np.mean(y))/(np.std(y))

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state = 42)

total_num_params, log_likelihood, sample_mean_cov_from_deep_gp, predict_layer_funcs, squared_error, create_deep_map = \

build_deep_gp(dimensions, rbf_covariance, num_pseudo_params, random)

init_params = .1 * npr.randn(total_num_params)

deep_map = create_deep_map(init_params)

init_params = initialize(deep_map,X,num_pseudo_params)

print("Optimizing covariance parameters...")

objective = lambda params: -log_likelihood(params,X,y,n_samples)

#print("Initial value",value_and_grad(objective)(init_params))

#print("Quick grad check", quick_grad_check(objective,init_params))

params = minimize(value_and_grad(objective), init_params, jac=True,

method='BFGS', callback=callback,options={'maxiter':500})

test_log_lik_prior = log_likelihood(params['x'],X_test,y_test,n_samples_to_test)

test_log_lik = test_log_likelihood(params['x'],X_test,y_test,n_samples_to_test)

test_error = squared_error(params['x'],X_test,y_test,n_samples_to_test)

print("Test Log Likelihood {}, Test Log Likelihood with Prior {}, Test MSE {}".format(\

test_log_lik,test_log_lik_prior,test_error))

params = params['x']

plot_xs = np.reshape(np.linspace(-5, 5, 300), (300,1))

fig = plt.figure(figsize=(16,8), facecolor='white')

ax_full = fig.add_subplot(311, frameon=False)

ax_one = fig.add_subplot(312, frameon=False)

ax_two = fig.add_subplot(313, frameon=False)

n_samples_to_plot = 5

plot_deep_gp(ax_full, params, plot_xs, n_samples_to_plot)

plot_single_gp(ax_one,params,0,0,plot_xs,n_samples_to_plot)

plot_single_gp(ax_two,params,1,0,plot_xs,n_samples_to_plot)

ax_full.set_title('Full deep GP', fontsize = 20)

ax_one.set_title("Input to Hiddens", fontsize = 20)

ax_two.set_title("Hiddens to Outputs", fontsize = 20)

plt.savefig('motorcycle.pdf', format='pdf', bbox_inches='tight',dpi=200)

plt.pause(40.0)