Create app.py

app.py

@@ -0,0 +1,264 @@
+# -*- coding: utf-8 -*-
+"""Untitled20.ipynb
+
+Automatically generated by Colaboratory.
+
+Original file is located at
+    https://colab.research.google.com/drive/1XZbCNfIzuxHNNECK_uGluXC65NH9yulc
+"""
+
+def greet(name):
+  return "Hello " + name + "!"
+
+greet("World")
+
+
+import gradio
+
+
+
+import pandas as pd
+import numpy as np
+
+
+from sklearn.decomposition import PCA
+from sklearn.preprocessing import StandardScaler
+from sklearn.pipeline import Pipeline
+
+import multiprocessing as mp
+
+
+
+#catboost
+from catboost import Pool, CatBoostRegressor
+
+modelos_cargados = []
+for i in range(3):
+    model = CatBoostRegressor()
+    model.load_model(f'./model_{i}.cbm')
+    modelos_cargados.append(model)
+
+def load_npz_file(filepath,
+                  masked = True,
+                  pad_mask = True):
+    '''load in numpy zipped files. Use masked =True to mask masked values (pad with 0's)'''
+    with np.load(filepath) as npz:
+        arr = np.ma.MaskedArray(**npz)
+
+
+    if masked == True:
+        if pad_mask : # pad masked pixels with 0's to preserve shape
+            mask = arr.mask
+            return np.where(mask==True,0,arr.data)
+
+        return arr
+
+
+    return arr.data
+
+
+def load_and_reshape(filepath):
+    '''load and reshape array'''
+
+
+    #load array
+    arr = load_npz_file(filepath,
+                        masked=False,
+                        pad_mask=False)
+
+    depth,height,width = arr.shape
+
+    # reshape to depth last format
+    arr = arr.reshape((height,width,depth))
+
+    #scale values
+#     arr = arr / scaling_values
+
+    #resize
+#     arr = cv2.resize(arr,CFG.img_size)
+
+    return arr
+
+
+def get_array_properties(arr):
+    '''get reduced properties for array with shape (h,w,channels==150)'''
+
+    #area of array
+    area_arr = arr[:,:,0].size
+
+
+    #max min range
+    arr_max = arr.max(axis=(0,1))
+    arr_range = arr_max - arr.min(axis=(0,1))
+
+
+
+    #central tendencies
+    mean_arr = arr.mean(axis=(0,1))
+    std_arr = arr.std(axis=(0,1))
+
+    median_arr = np.median(arr,axis=(0,1))
+
+    #first 25 %
+    q1 = np.percentile(a=arr,q=25,axis=(0,1))
+    #last 25 %
+    q3 = np.percentile(a=arr,q=75,axis=(0,1))
+
+
+    #iqr
+    iqr = q3 - q1
+
+
+
+    #first 10
+    d1 = np.percentile(a=arr,q=10,axis=(0,1))
+
+
+    #last 10
+    d10 = np.percentile(a=arr,q=90,axis=(0,1))
+
+
+
+
+    return np.array((area_arr,*mean_arr,*std_arr,*median_arr,*q1,*q3,*arr_max,*arr_range,*d1,*d10,*iqr))
+
+
+def get_agg_properties(filepath):
+    arr = load_and_reshape(filepath)
+
+    # properties of each band(range of each band)
+
+    properties = get_array_properties(arr)
+
+
+    return properties
+
+array_cols = ['array_area',
+              *[f'mean_{i}' for i in range(1,151)],
+              *[f'std_{i}' for i in range(1,151)],
+              *[f'med_{i}' for i in range(1,151)],
+              *[f'q1_{i}' for i in range(1,151)],
+              *[f'q3_{i}' for i in range(1,151)],
+              *[f'max_{i}' for i in range(1,151)],
+              *[f'range_{i}' for i in range(1,151)],
+             *[f'D1_{i}' for i in range(1,151)],
+             *[f'D10_{i}' for i in range(1,151)],
+             *[f'IQR_{i}' for i in range(1,151)]]
+
+print(array_cols)
+
+def pca_on_band(df, band_num, n_components=2):
+    """
+    get pca features for a particular band
+    """
+    pca_pipe = Pipeline(steps=[('standard_scaler', StandardScaler()),
+                               ('pca', PCA(n_components=min(n_components, df.shape[0])))])
+
+    band_cols = [col for col in df.columns if str(band_num) in col]
+    # Si solo hay una muestra, no realizar PCA y en su lugar devolver la muestra después del escalado
+    if df.shape[0] == 1:
+        scaler = StandardScaler()
+        scaled_features = scaler.fit_transform(df[band_cols])
+        return pd.DataFrame(scaled_features,
+                            columns=[f'B{band_num}_PC{i+1}' for i in range(scaled_features.shape[1])])
+
+
+
+    pca_pipe.fit(df[band_cols])
+    features = pca_pipe.transform(df[band_cols])
+
+    return pd.DataFrame(features,
+                        columns=[f'B{band_num}_PC{i+1}' for i in range(n_components)])
+
+
+def get_pca_dataset(df):
+
+    all_df = []
+
+    for band in range(1,151):
+        band_pca = pca_on_band(df,band)
+
+        all_df.append(band_pca)
+
+
+    return pd.concat(objs=all_df, axis=1, join='outer', ignore_index=False)
+
+
+
+
+derived_cols = ['array_area',*[f'q1_{i}' for i in range(1,151)],*[f'q3_{i}' for i in range(1,151)]]
+
+def predecir_desde_archivo_npz(ruta_archivo_npz, modelos, array_cols, derived_cols):
+    """
+    Carga un archivo .npz, procesa los datos y utiliza los modelos para predecir los valores.
+
+    :param ruta_archivo_npz: String con la ruta al archivo .npz.
+    :param modelos: Lista de modelos entrenados para hacer las predicciones.
+    :param array_cols: Columnas esperadas después de obtener las propiedades agregadas.
+    :param derived_cols: Columnas derivadas que se usan junto con PCA para la entrada del modelo.
+    :return: Predicción para el archivo dado.
+    """
+    # Cargar y procesar los datos del archivo .npz
+    propiedades_agregadas = get_agg_properties(ruta_archivo_npz)
+    datos_df = pd.DataFrame([propiedades_agregadas], columns=array_cols)
+
+    print(datos_df)
+
+    # Aplicar PCA a los datos procesados
+    pca_datos = get_pca_dataset(datos_df)
+
+    # Combinar con las columnas derivadas
+    datos_finales = pca_datos.merge(datos_df[derived_cols], left_index=True, right_index=True)
+
+    # Realizar predicciones con los modelos
+    predicciones = [modelo.predict(datos_finales) for modelo in modelos]
+    predicciones = np.array(predicciones).reshape(len(modelos), -1)
+
+    # Calcular la mediana de las predicciones
+    mediana_predicciones = np.median(predicciones, axis=0)
+    return mediana_predicciones
+
+# Aquí asumimos que `array_cols` y `derived_cols` ya están definidos en tu entorno como se ve en tu código.
+# También asumimos que los modelos ya están entrenados y contenidos en la lista `modelos`.
+
+ruta_archivo_npz = "./1.npz"  # Sustituir con la ruta real al archivo .npz
+prediccion = predecir_desde_archivo_npz(ruta_archivo_npz, modelos_cargados, array_cols, derived_cols)
+if len(prediccion) == 4:
+    fosforo_predicho, potasio_predicho, magnesio_predicho, pH_predicho = prediccion
+    print(f"Fósforo Predicho: {fosforo_predicho}")
+    print(f"Potasio Predicho: {potasio_predicho}")
+    print(f"Magnesio Predicho: {magnesio_predicho}")
+    print(f"pH Predicho: {pH_predicho}")
+else:
+    print("La predicción no contiene el número esperado de componentes.")
+
+import gradio as gr
+
+# Asegúrate de que las funciones de predicción y carga de modelos estén definidas aquí o estén siendo importadas correctamente.
+
+# Supongamos que la función 'predecir_desde_archivo_npz' está definida correctamente y funciona.
+# También asumimos que 'modelos_cargados' es una lista de modelos CatBoost ya cargados.
+
+def predecir_desde_archivo_npz_interface(archivo):
+    # Gradio pasa el archivo cargado como un objeto temporal, que puedes leer directamente
+    datos = archivo
+    # Asumimos que tus funciones de procesamiento esperan recibir un array numpy y devuelven las predicciones como un array
+    predicciones = predecir_desde_archivo_npz(datos, modelos_cargados, array_cols, derived_cols)
+    return {
+        'Fósforo (P)': float(predicciones[0]),
+        'Potasio (K)': float(predicciones[1]),
+        'Magnesio (Mg)': float(predicciones[2]),
+        'pH': float(predicciones[3])
+    }
+
+demo = gr.Interface(
+    fn=predecir_desde_archivo_npz_interface,
+    inputs=gr.File(label="Sube tu archivo NPZ",file_types = [".npz"]
+
+
+),
+    outputs=gr.JSON(label="Predicciones", )
+)
+demo.launch(
+    share=True
+)