Ciao, grazie della rapida risposta!
Di seguito posto quanto scritto fino ad ora, tutta la prima parte di codice sono dati passati dal tutor e anche la funzione su cui si allena la rete è data dal tutor, fino al fit della rete in teoria tutto bene sembra che essa si comporti bene (ho provato anche a plottare per punti funzione e rete e son molto simili, mse < 0.5 una volta sistemato set di train e test adeguatamente)
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)))
A questo punto mi trovo con una rete allenata (devo sistemare la suddivisione tra train e test ma su questo no problema), quello che dovrei fare ora è generare una popolazione iniziale di (x1, x2), valutarli con la rete neurale e attraverso un algoritmo genetico trovarne il minimo.
Il mio problema è che devo fare una cosa ricorsiva e non ho idea di come fare, in pratica mano a mano che il genetico trova dei punti migliori dovrebbe aggiungerli al set di train, riallenare la rete che poi va nuovamente nel genetico e così via fino ad un certo criterio di stop.
Ho guardato degli esempi su come settare un genetico seguendo questo esempio:
https://hackernoon.com/genetic-algorithms-explained-a-python-implementation-sd4w374i ma sto fallendo nel tentativo di implementarlo sul mio problema appunto perchè non so come fare questo processo ciclico tra rete e genetico.
