def programa():
#obtengo los valores
train_X, train_Y, val_X, val_Y, distancias, min_max = Ar.lectura_dataset()
#creo los datasets
train_set = Data(train_X, train_Y)
val_set = Data(val_X, val_Y)
#definimos capas
capas1 = [train_set.n, 15, 10, 5, 1]
poblacion = crear_poblacion(train_set, val_set, capas1)
loop = True
iteraciones = 1
while loop:
mejoresPadres = seleccionTorneo(poblacion)
poblacion = cruzarPadres(mejoresPadres, train_set, val_set, capas1)
if iteraciones == 3:
loop = False
iteraciones = iteraciones + 1
mejor = sorted(poblacion, key=lambda x: x.fitness, reverse=True)
print("iteraciones: ", iteraciones)
return mejor[0], train_set, val_set, capas1, distancias, min_max
def comenzarGenetico(iteraciones, ruta, resArchivo, numPoblacion):
# Lectura archivo de Entrenamiento y Validacion
train_X, train_Y, val_X, val_Y = File.cargarDatos(ruta)
# ====== DEFINICION DE RED NEURONAL ======
# 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
#capas = [train_set.n, 5, 5, 4, 4, 3, 1]
capas = [train_set.n, 7, 7, 5, 5, 3, 1]
# ==== Lectura archivo CSV Hiperparametros ====
entradas_params = {}
df = pd.read_csv(ruta + "/" + "hiperparams.csv")
entradas_params["alpha"] = df['alpha'].tolist()
entradas_params["lambda"] = df["lambda"].tolist()
entradas_params["max_iteration"] = df["max_iteration"].tolist()
entradas_params["keep_prob"] = df["keep_prob"].tolist()
# Inicializacion de Algoritmo Genetico
print("Ejecutando Algoritmo Genetico ...")
genetico = Genetico(iteraciones, entradas_params, numPoblacion,
len(entradas_params["alpha"]), train_set, val_set,
capas, 6)
hiper_params = genetico.ejecutar()
return {
"params": hiper_params,
"train_set": train_set,
"val_set": val_set,
"capas": capas
}
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 predecir():
data = request.get_json()
genero = int(data["genero"])
edad = float(data["edad"])
year = float(data["year"])
distancia = float(data["distancia"])
print(genero, edad, year, distancia)
mejor = cargar("Guardar/Modelo01.pkl")
departamentos = cargar("Guardar/Datos.pkl")
esc_edad = (edad - departamentos.minEdad) / (departamentos.maxEdad -
departamentos.minEdad)
esc_year = (year - departamentos.minYear) / (departamentos.maxYear -
departamentos.minYear)
esc_dist = (distancia - departamentos.minDist) / (departamentos.maxDist -
departamentos.minDist)
print(genero, esc_edad, esc_year, esc_dist)
# [Genereo, Edad, Año, Distancia]
valor = [genero, esc_edad, esc_year, esc_dist]
datos_arr = np.asarray([valor])
resp_arr = np.asarray([[0]])
datos_entrenamiento = datos_arr.T
respuesta_entrenamiento = resp_arr.T
print(datos_arr.shape)
print(datos_entrenamiento.shape)
print(resp_arr.shape)
print(respuesta_entrenamiento.shape)
test_set = Data(datos_entrenamiento, respuesta_entrenamiento)
val = predecirModelo(mejor, test_set)
resp = "Activo" if val == 1 else "Traslado"
return jsonify(depa=resp)
def predecir(self, genero, edad, inscripcion, departamento, municipio):
if self.modelo != None:
genero_res = genero
edad_res = self.escalarVariable(edad, self.min_edad, self.max_edad)
inscripcion_res = self.escalarVariable(inscripcion, self.min_anio,
self.max_anio)
distancia_res = self.escalarVariable(
self.getDistancia(departamento, municipio), self.min_dist,
self.max_dist)
arreglo_x = np.array([
np.array(
[genero_res, edad_res, inscripcion_res, distancia_res])
])
arreglo_x = arreglo_x.T
arreglo_y = np.array([[1]])
arreglo_y = arreglo_y.T
val_set = Data(arreglo_x, arreglo_y)
#nNuevo = NN_Model(self.modelo.data, [self.modelo.data.n, 7, 7, 5, 5, 3, 1], alpha=self.modelo.alpha, iterations=self.modelo.max_iteration, lambd=self.modelo.lambd, keep_prob=self.modelo.kp)
#nNuevo.parametros = self.modelo.parametros
p = self.modelo.predictNormal(val_set)
return p
else:
print("NO HAY MODELO CARGADO EN LA APLICACION")
pass
def principal():
ganador, train_set, val_set, capas1, distancias, min_max = programa()
alfa, lamb, ite, keep = get_hyperParams(ganador.constantes[0],
ganador.constantes[1],
ganador.constantes[2],
ganador.constantes[3])
print("--------------------- SOLUCION ENCONTRADA ---------------------")
print("Alpha: ", alfa)
print("Lambda: ", lamb)
print("Iteraciones: ", ite)
print("Keep: ", keep)
print("Fintess: ", ganador.fitness)
# Se define el modelo
nn1 = NN_Model(train_set,
capas1,
alpha=alfa,
iterations=ite,
lambd=lamb,
keep_prob=keep)
#nn2 = NN_Model(train_set, capas1, alpha=0.01, iterations=50000, lambd=0.7, keep_prob=1)
# Se entrena el modelo
nn1.training(False)
loop = True
while loop:
print("1. Predecir ")
print("2. Salir ")
seleccion = input("Opcion :")
if seleccion == "1":
genero = input("Elija su genero: 1. Masculino, 0.Femenino: ")
edad = input("Seleccione su edad: ")
año = input("Su año de inscripcion: ")
municipio = input("Municipio de residencia: ")
pre = [
float(genero),
escalar_var(edad, min_max[0], min_max[1]),
escalar_var(año, min_max[2], min_max[3]),
escalar_var(distancias[municipio], min_max[4], min_max[5])
]
pre = np.array(pre)
arr_pre = [pre]
arr_pre = (np.array(arr_pre)).T
arr_res = np.zeros(1)
arr_res2 = [arr_res]
arr_res2 = (np.array(arr_res2)).T
predict = Data(arr_pre, arr_res2)
valor = nn1.predic2(predict)
if int(valor) == 1:
print("Usted no se trasladara")
else:
print("Usted se trasladara")
else:
loop = False
def ejecutar():
datos_entrenamiento, respuesta_entrenamiento, datos_prueba, respuesta_prueba, maxEdad, maxYear, maxDist, minEdad, minYear, minDist, dep_list = leerData()
datos = Datos( maxEdad, maxYear, maxDist, minEdad, minYear, minDist, dep_list)
save_object(datos, "Guardar/Datos.pkl")
train_set = Data(datos_entrenamiento, respuesta_entrenamiento)
test_set = Data(datos_prueba, respuesta_prueba)
w = open("bitacora.txt", "a")
now = datetime.now()
fecha_hora = now.strftime("%d/%m/%Y %H:%M:%S")
w.write(" Inicio: "+fecha_hora + "\n")
w.close()
generacion = 0
p = inicializarPoblacion(train_set, test_set)
print("------------------------- Poblacion Inicial -----------------------")
imprimirPoblacion(p)
fin = verificarCriterio(generacion)
while (not fin):
padres = seleccionarPadres(p)
p = emparejar(padres, train_set, test_set)
generacion += 1
fin = verificarCriterio(generacion)
print("---------- Generacion ", generacion, " ------------------ ")
p = sorted(p, key=lambda item: item.fitness, reverse=True)[:len(p)]
save_object(p[0], "Guardar/Mejor.pkl")
save_object(p, "Guardar/PoblacionFinal.pkl")
imprimirPoblacion(p)
w = open("bitacora.txt", "a")
now = datetime.now()
fecha_hora = now.strftime("%d/%m/%Y %H:%M:%S")
w.write(" Finalizo: "+fecha_hora + "\n")
w.close()
def consultar():
"""
Predecir con la red neuronal
"""
if modelo_nn == None:
inicializarModelo()
data = [
0,
float(request.json['genero']),
float(request.json['edad']),
calcularDistancia(str(request.json['departamento']),
str(request.json['municipio']), ''),
float(request.json['anio'])
]
# print('antes')
# print(data)
edad = [57.0, 17.0]
dist = [269.7739244046257, 6.135217051724262]
anio = [2019.0, 2010.0]
data = escalarVariables([data], edad, dist, anio)
# print('desp')
# print(data)
# print([[data[0][1]], [data[0][2]], [data[0][3]], [data[0][4]]])
pred = Data(
np.asarray([[data[0][1]], [data[0][2]], [data[0][3]], [data[0][4]]]),
[[1.0]])
prediccion = modelo_nn.predecir(pred)
return jsonify(prediccion=prediccion[0][0],
mensaje='imagen Analizada!',
status=200)
[0.1, 0.001, 1000, 1],
[0.2, 0.3, 1250, 0.95],
[0.3, 0.5, 2000, 0.90],
[0.5, 0.005, 1100, 0.85],
[0.03, 0.015, 1050, 0.83],
[0.25, 0.152, 2250, 0.70],
[0.14, 0.001, 2500, 0.75],
[0.28, 0.0335, 1800, 0.99],
[0.44, 0.12, 1300, 0.93],
[0.04, 0, 3000, 0.88],
]
#train_set_x, train_set_y, val_set_x, val_set_y, test_set_x, test_set_y = cargarDatos()
train_set_x, train_set_y, val_set_x, val_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, 15, 10, 7, 1]
@app.route("/consultar", methods=['POST'])
@cross_origin()
def consultar():
"""
Predecir con la red neuronal
"""
if modelo_nn == None:
inicializarModelo()
[0.1, 0.001, 1000, 1],
[0.001, 0.7, 1250, 0.5],
[0.0001, 0.8, 2000, 0.67],
[0.0015, 0.005, 500, 0.9],
[0.002, 0.015, 400, 0.1],
[0.02, 0.152, 100, 0.55],
[0.000001, 1, 2500, 0.03],
[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])
ONLY_SHOW = False
# Cargando conjunto de datos
train_X, train_Y, val_X, val_Y = get_dataFile()
if ONLY_SHOW:
Plotter.plot_field_data(train_X, train_Y)
# Plotter.plot_field_data(val_X, val_Y)
print("Entradas de entrenamiento:", train_X.shape, sep=' ')
print("Salidas de entrenamiento:", train_Y.shape, sep=' ')
print("Entradas de validacion:", val_X.shape, sep=' ')
print("Salidas de validacion:", val_Y.shape, sep=' ')
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)