def recuperar_informacion_dataset(self, columna_decision,
nombre_columna_binarizada):
# guarda los datasets recuperados y filtrados
listado_datasets = []
# recupera la informacion del dataset y elimina la columna propia
data_set_completo_original = AccesoDB().consultar_informacion()
data_set_completo_clon = AccesoDB().consultar_informacion().drop(
columns=[
'_id', "Identificador", 'Procesamiento', columna_decision
])
# obtiene el listado de los componentes principales
lista_componentes_principales = ModelosML().analisis_pca(
data_set_completo_clon, nombre_columna_binarizada)
lista_componentes_principales.append(nombre_columna_binarizada)
dataset_eliminacion = data_set_completo_original[
data_set_completo_original['Procesamiento'] == 'ELIMINACION']
dataset_eliminacion = dataset_eliminacion.filter(
lista_componentes_principales, axis=1)
dataset_promedio = data_set_completo_original[
data_set_completo_original['Procesamiento'] == 'PROMEDIO']
dataset_promedio = dataset_promedio.filter(
lista_componentes_principales, axis=1)
data_set_completo = data_set_completo_original.filter(
lista_componentes_principales, axis=1)
# adiciona los dataset recuperados a la lista
listado_datasets.append(data_set_completo)
listado_datasets.append(dataset_eliminacion)
listado_datasets.append(dataset_promedio)
return listado_datasets, list(data_set_completo.columns)
def predecir(self, directorio_archivo, nombre_columna_binarizada,
columna_decision, limite_binarizacion):
# carga toda la informacionde la base de datos, tambien el mejor clasidicador y la lista de componentes principales
data_set_completo = AccesoDB().consultar_informacion()
datos_en_db = AccesoDB().consultar_informacion('mejorclasificador')
tamano_lista_clasificadores = list(datos_en_db.shape)[0]
ultimo_mejor_clasificador = datos_en_db['mejor_clasificador'][
tamano_lista_clasificadores - 1]
listado_componentes_principales = datos_en_db[
'lista_nombre_componentes_principales'][tamano_lista_clasificadores
- 1]
# obtengo solo las columnas que no son objetivo
listado_nombres_columnas = [
i for i in listado_componentes_principales
if i != nombre_columna_binarizada
]
# solo las columnas que fueron elegidas por los componentes proncipales
data_set_completo_entrenamiento = data_set_completo.filter(
listado_componentes_principales, axis=1)
# fue el dataset que se quiere validar para prediccion
data_subida_para_prediccion = self.crear_dataframe_original(
directorio_archivo, nombre_columna_binarizada, columna_decision,
limite_binarizacion)
data_subida_para_prediccion = data_subida_para_prediccion.filter(
listado_nombres_columnas, axis=1)
# adiciona el dataset que se va a entrenar para la prediccion de la data
listado_datasets = [data_set_completo_entrenamiento]
# split bajito por que ya se conoce que es mejor modelo de todos, entonces se entrena con mas datos
split = 0.25
datos_para_entrenamiento = self.fraccionar_datos_de_entrenamiento(
listado_datasets, listado_componentes_principales,
nombre_columna_binarizada, split)[0]
cantidad_validaciones = 10
# obteine los datos de la prediccion
datos = ModelosML().obtener_mejor_clasificador(
ultimo_mejor_clasificador, datos_para_entrenamiento,
cantidad_validaciones, data_subida_para_prediccion).tolist()
#print('wwww ', ModelosML().obtener_mejor_clasificador(ultimo_mejor_clasificador, datos_para_entrenamiento, cantidad_validaciones, data_subida_para_prediccion))
# reemplazo los valores para la predccion
datos = list(
map(lambda x: 'BAJA HUMEDAD' if x == 0 else 'ALTA HUMEDAD', datos))
# retorna la prediccion del dataset
return datos
def entrenar_modelo(self, columna_decision, nombre_columna_binarizada,
split):
# guarda los datasets recuperados y filtrados
listado_datasets, listado_nombres_columnas = self.recuperar_informacion_dataset(
columna_decision, nombre_columna_binarizada)
datos_para_entrenamiento = self.fraccionar_datos_de_entrenamiento(
listado_datasets, listado_nombres_columnas,
nombre_columna_binarizada, split)
lista_resultados = []
for i in range(len(listado_datasets)):
for j in range(len(CLASIFICADORES)):
mc = ModelosML().obtener_mejor_clasificador(
CLASIFICADORES[j], datos_para_entrenamiento[i], '')
lista_resultados.append(mc)
conexion, _, coleccion_clasificador, _ = MongoDB().conexion_mongoDB()
nombre_clasificador_entrenado = ''
mejor_clasificador = ''
valor = 0
for i in range(len(lista_resultados)):
if (lista_resultados[i]['evaluacion_clasificador'] > valor):
mejor_clasificador = lista_resultados[i]['clasificador']
nombre_clasificador_entrenado = lista_resultados[i][
'nombre_clasificador_entrenado']
lista_dataframes = [
pd.DataFrame({
'Clasificadores Evaluados': [CLASIFICADORES],
'mejor_clasificador': [mejor_clasificador],
'nombre_clasificador_entrenado':
nombre_clasificador_entrenado,
'lista_nombre_componentes_principales':
[listado_nombres_columnas],
'fecha': [str(datetime.now())]
})
]
# guarda la informacion en base de datos del mejor clasificador en este entrenamiento
datos_en_BD = AccesoDB().guardar_datos(lista_dataframes, conexion,
coleccion_clasificador)
return lista_resultados
def procesar_informacion(self, directorio_archivo,
nombre_columna_binarizada, columna_decision,
limite_binarizacion):
df_original = self.crear_dataframe_original(directorio_archivo,
nombre_columna_binarizada,
columna_decision,
limite_binarizacion)
lista_dataframes = self.crear_dataframes_procesados(df_original)
conexion, coleccion, _, _ = MongoDB().conexion_mongoDB()
# guarda la informacion en base de datos
datos_en_BD = AccesoDB().guardar_datos(lista_dataframes, conexion,
coleccion)
return datos_en_BD
def predecir(self, directorio_archivo, nombre_columna_binarizada,
columna_decision, limite_binarizacion,
coleccion_clasificador):
# carga la informacion de la base de datos del mejor clasificador, los componentes principales, mejor modelo entrenado
datos_en_db = AccesoDB().consultar_informacion('mejorclasificador')
tamano_lista_clasificadores = list(datos_en_db.shape)[0]
ultimo_mejor_clasificador = datos_en_db['mejor_clasificador'][
tamano_lista_clasificadores - 1]
# lee el nombre del clasificador con que se realizara la prediccion
nombre_clasificador_entrenado = datos_en_db[
'nombre_clasificador_entrenado'][tamano_lista_clasificadores - 1]
# obtirnr los componentes principales del ultimo mejor clasificador
listado_componentes_principales = datos_en_db[
'lista_nombre_componentes_principales'][tamano_lista_clasificadores
- 1]
# obtengo solo las columnas que no son objetivo
listado_nombres_columnas = [
i for i in listado_componentes_principales
if i != nombre_columna_binarizada
]
# fue el dataset que se quiere validar para prediccion
data_original = self.crear_dataframe_original(
directorio_archivo, nombre_columna_binarizada, columna_decision,
limite_binarizacion)
data_subida_para_prediccion = data_original.filter(
listado_nombres_columnas, axis=1)
# realiza pretratamiento de data, no acepta columnas con datos vacios
data_subida_para_prediccion = data_subida_para_prediccion.dropna()
# se ubica en el directorio donde estan los clasificadores entrenados
os.chdir(DIRECTORIO_MODELOS)
# carga el mejor clasificador para predecir la data
clasificador_entrenado = joblib.load(nombre_clasificador_entrenado)
# retorna al directorio principal del proyecto
os.chdir(DIRECTORIO_ARCHIVOS)
# obtiene los datos predecidos
datos = clasificador_entrenado.predict(data_subida_para_prediccion)
# reemplazo los valores numericos por etiquetas para la predccion
datos = list(
map(lambda x: 'BAJA HUMEDAD' if x == 0 else 'ALTA HUMEDAD', datos))
# crea el dataframe que se va a guardar con todo lo que se uso para la prediccion
lista_dataframes = [
pd.DataFrame({
'Clasificador':
ultimo_mejor_clasificador,
'listado_componentes_principales':
[listado_componentes_principales],
'nombre_clasificador_entrenado_usado':
nombre_clasificador_entrenado,
'Prediccion': [datos],
'Cantidad de Datos Cargados': [{
'Filas':
data_original.shape[0],
'Columnas':
data_original.shape[1]
}],
'data_procesada_para_prediccion':
[data_subida_para_prediccion],
'fecha': [str(datetime.now())]
})
]
# guarda la informacion en base de datos del mejor clasificador en este entrenamiento
conexion, _, _, coleccion_prediccion = MongoDB().conexion_mongoDB()
datos_en_BD = AccesoDB().guardar_datos(lista_dataframes, conexion,
coleccion_prediccion)
print('Prediccion API ', datos)
# retorna la prediccion del dataset
return datos