import os
import warnings
import time
import copy

import numpy as np
import pandas as pd

from sklearn.metrics import mean_squared_error, explained_variance_score, r2_score
from sklearn.model_selection import train_test_split, KFold
from sklearn.linear_model import LinearRegression, Lasso, lasso_path, lars_path, LassoLarsIC
from sklearn.neural_network import MLPRegressor

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

import keras
from keras.layers.core import Dense, Activation, Dropout
from keras.layers import Input
from keras.models import Model

from keras.layers.recurrent import LSTM, GRU
from keras.regularizers import l1
from keras.models import Sequential
from keras.models import load_model

#plotly charts
from plotly.offline import download_plotlyjs, init_notebook_mode, plot, iplot
from plotly.graph_objs import *
import plotly.figure_factory as ff
init_notebook_mode(connected=True)

data = splines.values

x = data[:,2]
y = data[:,3]  
fit2 = data[:,4]
fit3 = data[:,5]
fit4 = data[:,6]
fit5 = data[:,7]
fit6 = data[:,8]
fit20 = data[:,9]
fit40 = data[:,10]
fit80 = data[:,11]
fit160 = data[:,12]
fit240 = data[:,13]
fitcv = data[:,14]

plotdata = []
plotdata.append(Scatter(x=x,
                        y=y,
                        name='Raw data',
                        mode = 'markers',
                        marker = dict(
                            size = 3,
                            line = dict(
                                width = 2,
                                color = 'rgba(128, 128, 192, .75)',
                            )
                        )
                       )
               )
plotdata.append(Scatter(x=x,
                    y=fit2,
                    name='Linear (high bias / low variance)',
                    mode = 'line',
                        line = dict(
                            color = ('orange'),
                            width = 2)                        
                       ))
plotdata.append(Scatter(x=x,
                    y=fit4,
                    name='Underfit (high bias / low variance)',
                    mode = 'line',
                        line = dict(
                            width = 2,
                        color= ('blue'),                                                
                        )                                                
                       ))
plotdata.append(Scatter(x=x,
                        y=fitcv,
                        name='Lowest CV error',
                        mode = 'line',
                        line = dict(
                            color = ('green'),
                            width = 5)
)               )
plotdata.append(Scatter(x=x,
                    y=fit240,
                    name='Overfit (high variance / low bias)',
                    mode = 'line',
                        line = dict(
                            width = 2,
                        color= ('rgb(192,0,0)'))                                                
                        
                       ))

layout = Layout(
    yaxis=dict(
        autorange=True))


fig = Figure(data=plotdata, layout=layout)

iplot(fig) # png to save notebook w/static image   

# chart it

def mychart(*args):

    # pass some 2d n x 1 arrays, x, y, z
    
    # 1st array is independent vars
    # reshape to 1 dimensional array
    x = args[0].reshape(-1)
    
    # following are dependent vars plotted on y axis
    data = []
    for i in range(1, len(args)):
        data.append(Scatter(x=x,
                            y=args[i].reshape(-1),
                            mode = 'markers'))

    layout = Layout(
        yaxis=dict(
            autorange=True))
    
    fig = Figure(data=data, layout=layout)
    
    return iplot(fig) # png to save notebook w/static image   
    
mychart(x,y)

mychart(x2,y1, y2)

import pandas as pd
pd.read_csv('splines.csv')

# fit with sklearn MLPRegressor

layer1_sizes=[1,2,4,8]
layer2_sizes=[1,2,4,8]
import itertools
from plotly import tools
                         
def run_grid(build_model_fn, layer1_sizes, layer2_sizes, x, y, epochs=None):
    nrows = len(layer1_sizes)
    ncols = len(layer2_sizes)
    
    hyperparameter_list = list(itertools.product(layer1_sizes, layer2_sizes))
    subplot_titles = ["%d units, %d units" % 
                      (layer1_size, layer2_size) for (layer1_size, layer2_size) in hyperparameter_list]
    
    fig = tools.make_subplots(rows=nrows, 
                              cols=ncols, 
                              subplot_titles=subplot_titles)
    
    for count, (layer1_size, layer2_size) in enumerate(hyperparameter_list):
        print("Layer 1 units: %d, Layer 2 units %d:" % (layer1_size, layer2_size))
        
        print("Running experiment %d of %d : %d %d" % (count+1, len(hyperparameter_list), layer1_size, layer2_size))
        model = build_model_fn(hidden_layer_sizes=(layer1_size, layer2_size),
                               activation='tanh',
                               max_iter=10000, tol=1e-10,
                               solver='lbfgs'
                              )
        x = x.reshape(-1,1)
        
        if epochs:
            model.fit(x,y, epochs=EPOCHS)
        else:
            model.fit(x,y)
            
        y_pred = model.predict(x)
        train_score = mean_squared_error(y, y_pred)
        print(train_score)
        print("%s Train MSE: %s" % (time.strftime("%H:%M:%S"), str(train_score)))
        print("%s Train R-squared: %.6f" % (time.strftime("%H:%M:%S"), 1-train_score/y.var()))

        z = model.predict(x)
        
        trace = Scatter(
            x = x.reshape(-1),
            y = z.reshape(-1),
            name = 'fit',    
            mode = 'markers',
            marker = dict(size = 2)
        )
        fig.append_trace(trace, count // nrows + 1, count % ncols +1)
    return(iplot(fig))
    
run_grid(MLPRegressor, layer1_sizes, layer2_sizes, x, y)