def evaluarFitness(solucion):
valorFitness = 0
# print(solucion)
# print("alpha=" + str(hiperparametros[solucion[0]][0]) + ", lambd=" + str(hiperparametros[solucion[1]][1]) + ", iterations=" + str(hiperparametros[solucion[2]][2]) + ", keep_prob=" + str(hiperparametros[solucion[3]][3]) + "")
nn = NN_Model(train_set,
capas,
alpha=hiperparametros[solucion[0]][0],
lambd=hiperparametros[solucion[1]][1],
iterations=hiperparametros[solucion[2]][2],
keep_prob=hiperparametros[solucion[3]][3])
nn.training(False)
# Plotter.show_Model([nn])
# print('Entrenamiento Modelo 1')
# nn.predict(train_set)
# print('Validacion Modelo 1')
exactitud = nn.predict(val_set)
# print('Pruebas Modelo 1')
# nn.predict(test_set)
# global modelos
# modelos.append(nn)
valorFitness = exactitud
return valorFitness
def evaluarFitness(solucion, train_data, test_data):
# Soucion [alpha, lambda, itereaciones, kp]
val_alpha = [0.1, 0.01, 0.5, 0.09, 0.001,
0.0001, 0.009, 0.0005, 0.09, 0.007]
val_lambda = [0, 0.1, 0.01, 0.5, 0.09, 1, 50, 300, 1.5, 0.001]
val_iteraciones = [5000, 1000, 12000, 20000,
25000, 10500, 500, 40000, 50000, 35000]
val_kp = [1, 0.95, 0.85, 0.65, 0.45, 0.55, 0.75, 0.25, 0.35, 0.1]
capas = [train_data.n, 12, 10, 8, 6, 4, 2, 1]
modelo = NN_Model(train_data, capas, alpha=val_alpha[solucion[0]], iterations=val_iteraciones[
solucion[2]], lambd=val_lambda[solucion[1]], keep_prob=val_kp[solucion[3]])
modelo.training(False)
valor_Fit = modelo.predict(test_data)
return valor_Fit, modelo
def principal():
datos_entrenamiento, respuesta_entrenamiento, datos_prueba, respuesta_prueba, maxEdad, maxYear, maxDist, minEdad, minYear, minDist, dep_list= leerData()
train_set = Data(datos_entrenamiento, respuesta_entrenamiento)
test_set = Data(datos_prueba, respuesta_prueba)
capas = [train_set.n, 12, 10, 8, 6, 4, 2, 1]
modelo = NN_Model(train_set, capas, alpha=0.09, iterations=55000, lambd=1.5, keep_prob=1)
now = datetime.now()
fecha_hora = now.strftime("%d/%m/%Y %H:%M:%S")
print(fecha_hora)
modelo.training(True)
now = datetime.now()
fecha_hora = now.strftime("%d/%m/%Y %H:%M:%S")
print(fecha_hora)
print("alpa", modelo.alpha, "lam", modelo.lambd, "kp", modelo.kp, "it", modelo.max_iteration, capas)
#Plotter.show_Model([modelo])
print('Entrenamiento Modelo')
modelo.predict(train_set)
print('Validacion Modelo')
modelo.predict(test_set)
save_object(modelo, "Guardar/Modelo01.pkl")
def evaluarFitness(self, solucion):
# Recorrer contenido del archivo
fitness = 0
params_solucion = self.getDataTraining(solucion[0], solucion[1],
solucion[2], solucion[3])
# Se define el modelo
nn1 = NN_Model(self.train_set,
self.capas,
alpha=params_solucion['alpha'],
iterations=params_solucion['iterations'],
lambd=params_solucion['lambd'],
keep_prob=params_solucion['keep_prob'])
# Se entrena el modelo
nn1.training(False)
# Validacion Modelo
fitness = nn1.predict(self.val_set)
return fitness
def entrenamiento(ruta, nombre_modelo, nombre_grafica, generaciones,
numPoblacion):
# comenzar entrenamiento con Algoritmo Genetico
params = comenzarGenetico(generaciones, ruta, "principal", numPoblacion)
params_solucion = params['params']
# Imprimir Datos
print("alpha: ", params_solucion['alpha'])
print("iterations: ", params_solucion['iterations'])
print("lambd: ", params_solucion['lambd'])
print("keep_prob: ", params_solucion['keep_prob'])
# Se define el modelo
nn1 = NN_Model(params['train_set'],
params['capas'],
alpha=params_solucion['alpha'],
iterations=params_solucion['iterations'],
lambd=params_solucion['lambd'],
keep_prob=params_solucion['keep_prob'])
# Se entrena el modelo
nn1.training(False)
Plotter.show_Model([nn1], nombre_grafica)
# Guardar Modelo
guardarModelo(nn1, nombre_modelo)
[0.005, 0.0335, 1500, 0.98],
[0.03, 1.12, 800, 0.4],
[0.0358, 0, 650, 0.564],
]
train_set_x, train_set_y, val_set_x, val_set_y, test_set_x, test_set_y = cargarDatos(
)
train_set = Data(train_set_x, train_set_y)
val_set = Data(val_set_x, val_set_y)
test_set = Data(test_set_x, test_set_y)
capas = [train_set.n, 10, 5, 3, 1]
nn = NN_Model(train_set,
capas,
alpha=0.0358,
lambd=0.152,
iterations=1500,
keep_prob=1)
# nn = NN_Model(train_set, capas, alpha=0.001, lambd=0.152, iterations=1500, keep_prob=1)
nn.training(False)
Plotter.show_Model([nn])
print('Entrenamiento Modelo 1')
nn.predict(train_set, True)
print('Validacion Modelo 1')
nn.predict(val_set, True)
print('Pruebas Modelo 1')
nn.predict(test_set, True)
exit()
# Definir los conjuntos de datos
train_set = Data(train_X, train_Y)
val_set = Data(val_X, val_Y)
# Se define las dimensiones de las capas
#capas1 = [Cantidad de variables que tiene el problema, capa 1, capa 2, Capa de salida]
#se tendría una red neuronal de 3 capas, la capa de entrada NO se toma en cuenta
# capas1 = [train_set.n, 10, 5, 1]
capas1 = [train_set.n, 15, 10, 5, 1]
# Se define el modelo
nn1 = NN_Model(train_set,
capas1,
alpha=0.001,
iterations=50000,
lambd=0,
keep_prob=0.5)
nn2 = NN_Model(train_set,
capas1,
alpha=0.01,
iterations=50000,
lambd=0.7,
keep_prob=1)
# Se entrena el modelo
nn1.training(False)
nn2.training(False)
# Se analiza el entrenamiento
Plotter.show_Model([nn1, nn2])