from sys import exit
import pathlib

import pandas as pd
import numpy as np
from scipy.optimize import minimize

import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D

from sklearn.neural_network import MLPRegressor
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
from sklearn.metrics import mean_squared_error

import MatFunc as mf

#il DoE è generato con una distribuzione latin hypercube 2d
def GenerateLHS(nd, ns, opt='smt'):

    if opt == 'smt':
        from smt.sampling_methods import LHS

        xl = np.zeros((nd,2))
        xl[:,1] = 1.0
        # option are 'center', 'maximin', 'centermaximin', 'correlation', 'ese'
        smp = LHS(criterion='ese', xlimits = xl)
        data = smp(ns)

    elif opt == 'pyDOE':
        from pyDOE2 import lhs

        data = lhs(nd, samples=ns, criterion='center', iterations = 1000)
        #data = lhs(nd, samples=ns, criterion='maximin', iterations = 1000)
        #data = lhs(nd, samples=ns, criterion='centermaximin', iterations = 1000)
        #data = lhs(nd, samples=ns, criterion='correlation', iterations = 1000)
    
    elif opt == 'pyKriging':
        from pyKriging.samplingplan import samplingplan

        sp = samplingplan(nd)  
        data = sp.optimallhc(ns, iterations=10)

    else:
        print('GenerateLHS, wrong option', opt)
        exit()

    return data
################################################################################
# INPUT VARIABLES ##############################################################
################################################################################

currentPath = pathlib.Path.cwd()

# Set Variable bound file
xBoundFile = 'Levy.csv'

# Set number of initial Database
nsol = 50

################################################################################
################################################################################
################################################################################

xBound = pd.read_csv(currentPath/xBoundFile, header = 0, sep='\t')

# Evaluate the variable ranges
xBound.loc[2] = xBound.loc[1] -xBound.loc[0]

# Print DataFrame Statistics
print(xBound.head())
print(xBound['X1'].values)
print(xBound.info(verbose=True))

# Evaluate the Number of Design variables
ndv = len(xBound.columns)

# Define Initial Database reduced matrix
xr = pd.DataFrame(data = GenerateLHS(ndv, nsol, opt='smt'), columns=xBound.columns)

# update NON-reduced matrix
x = pd.DataFrame(data = xBound.loc[0] +xr*xBound.loc[2], columns=xBound.columns)


################################################################################
################################################################################
################################################################################
# Eval all initial solutions: valuto le varie coppie x1,x2 nella funzione in esame: funzione di Ackley (2 variabili)

y = []
for i in range(nsol):
    y.append(mf.Ackley(x.loc[i]))

y = pd.DataFrame(data = y, columns=['Y'])
df = pd.concat([x, y], axis=1)
x1 = df['X1'].to_numpy()
x2= df['X2'].to_numpy()

#creo una lista di liste per accoppiare le coordinate [X1(i),X2(i)]
x = [[x1[i],x2[i]] for i in range(len(x))]

# porto tutto in ndarray
y_array = np.array(y, dtype=float)
x_array = np.array(x, dtype=float)

#Suddivido i dati in set di train e set di test
x_train, x_test, y_train, y_test = train_test_split(x_array, y_array, test_size=0.9, random_state=42)

#rete neurale 
ANN = MLPRegressor(
    hidden_layer_sizes=(1000,),  activation='relu', solver='adam', alpha=0.001, batch_size='auto',
    learning_rate='constant', learning_rate_init=0.01, power_t=0.5, max_iter=1000, shuffle=True,
    random_state=0, tol=0.0001, verbose=False, warm_start=False, momentum=0.9, nesterovs_momentum=True,
    early_stopping=False, validation_fraction=0.1, beta_1=0.9, beta_2=0.999, epsilon=1e-08)

#fit
ANN.fit(x_train, y_train)

y_pred = ANN.predict(x_test) 
print("Root mean squared error: {0:.2f}".format(mean_squared_error(y_test, y_pred)))

import sklearn.datasets
import numpy as np
import random

X = x_array
y = y_array

from sklearn.model_selection import KFold

paramgrid = {"hidden_layer_sizes":np.arange(1,100),
             "activation":["relu", "tanh"]}

random.seed(1)

from evolutionary_search import EvolutionaryAlgorithmSearchCV
cv = EvolutionaryAlgorithmSearchCV(estimator=MLPRegressor(),
                                   params=paramgrid,
                                   scoring="neg_mean_squared_error",
                                   cv=KFold(n_splits=4), #divide i dati in 4 parti, 3 train e 1 valid
                                   verbose=10,
                                   population_size=15,
                                   gene_mutation_prob=0.10,
                                   gene_crossover_prob=0.5,
                                   tournament_size=3,
                                   generations_number=5,
                                   n_jobs=1)
cv.fit(x_array, y_array)